@etothepii/satisfactory-file-parser 0.5.1 → 1.0.2

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

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

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

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

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

@@ -1,24 +0,0 @@
-import { BinaryReadable } from "../../byte/binary-readable.interface";
-import { ByteWriter } from "../../byte/byte-writer.class";
-import { PropertiesMap } from "./property/generic/BasicProperty";
-import { SpecialAnyProperty } from './property/special/SpecialAnyProperty';
-export interface SaveObjectHeader {
-    typePath: string;
-    rootObject: string;
-    instanceName: string;
-}
-export declare abstract class SaveObject implements SaveObjectHeader {
-    typePath: string;
-    rootObject: string;
-    instanceName: string;
-    properties: PropertiesMap;
-    specialProperties: SpecialAnyProperty;
-    trailingData: number[];
-    objectVersion: number;
-    unknownType2: number;
-    constructor(typePath: string, rootObject: string, instanceName: string);
-    protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
-    protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
-    static ParseData(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
-    static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
-}

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveObject = void 0;
-const DataFields_1 = require("./DataFields");
-class SaveObject {
-    constructor(typePath, rootObject, instanceName) {
-        this.typePath = typePath;
-        this.rootObject = rootObject;
-        this.instanceName = instanceName;
-        this.properties = {};
-        this.specialProperties = {};
-        this.trailingData = [];
-        this.objectVersion = 0;
-        this.unknownType2 = 0;
-    }
-    static ParseHeader(reader, obj) {
-        obj.typePath = reader.readString();
-        obj.rootObject = reader.readString();
-        obj.instanceName = reader.readString();
-    }
-    static SerializeHeader(writer, obj) {
-        writer.writeString(obj.typePath);
-        writer.writeString(obj.rootObject);
-        writer.writeString(obj.instanceName);
-    }
-    static ParseData(obj, length, reader, buildVersion, typePath) {
-        DataFields_1.DataFields.ParseProperties(obj, length, reader, buildVersion, typePath);
-    }
-    static SerializeData(writer, obj, buildVersion) {
-        DataFields_1.DataFields.Serialize(obj, writer, buildVersion, obj.typePath);
-    }
-}
-exports.SaveObject = SaveObject;

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

@@ -1,21 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { BasicProperty } from './BasicProperty';
-export type ArrayPropertyStructValueFields = {
-    allStructType: string;
-    allIndex: number;
-    allGuid: number;
-    allUnk1?: number;
-    allUnk2?: number;
-    allUnk3?: number;
-    allUnk4?: number;
-};
-export declare class ArrayProperty<T> extends BasicProperty {
-    subtype: string;
-    values: T[];
-    structValueFields?: ArrayPropertyStructValueFields | undefined;
-    constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
-    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
-    static CalcOverhead(property: ArrayProperty<any>): number;
-    static Serialize(writer: ByteWriter, property: ArrayProperty<any>, propertyName: string): void;
-}

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

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayProperty = void 0;
-const SoftObjectReference_1 = require("../../values/SoftObjectReference");
-const BasicProperty_1 = require("./BasicProperty");
-const BoolProperty_1 = require("./BoolProperty");
-const ByteProperty_1 = require("./ByteProperty");
-const DoubleProperty_1 = require("./DoubleProperty");
-const EnumProperty_1 = require("./EnumProperty");
-const FloatProperty_1 = require("./FloatProperty");
-const Int32Property_1 = require("./Int32Property");
-const Int64Property_1 = require("./Int64Property");
-const ObjectProperty_1 = require("./ObjectProperty");
-const StrProperty_1 = require("./StrProperty");
-const StructProperty_1 = require("./StructProperty");
-const TextProperty_1 = require("./TextProperty");
-class ArrayProperty extends BasicProperty_1.BasicProperty {
-    constructor(subtype, values, ueType = 'ArrayProperty', index = 0, structValueFields) {
-        super({ type: 'ArrayProperty', ueType, index });
-        this.subtype = subtype;
-        this.values = values;
-        this.structValueFields = structValueFields;
-    }
-    static Parse(reader, ueType, index, propertyName) {
-        const subtype = reader.readString();
-        reader.skipBytes(1);
-        let property;
-        const elementCount = reader.readInt32();
-        switch (subtype) {
-            case "FloatProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty_1.FloatProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "BoolProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty_1.BoolProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "IntProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property_1.Int32Property.ReadValue(reader)), ueType, index);
-                break;
-            case "Int64Property":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property_1.Int64Property.ReadValue(reader)), ueType, index);
-                break;
-            case "DoubleProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty_1.DoubleProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "ByteProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty_1.ByteProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "StrProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty_1.StrProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "EnumProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty_1.EnumProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "TextProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty_1.TextProperty.ParseValue(reader)), ueType, index);
-                break;
-            case "InterfaceProperty":
-            case "ObjectProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "SoftObjectProperty":
-                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => SoftObjectReference_1.SoftObjectReference.read(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_1.StructProperty(allStructType, type, allIndex, allGuid);
-                    struct.value = StructProperty_1.StructProperty.ParseValue(reader, allStructType, binarySize);
-                    return struct;
-                });
-                const readBytes = reader.getBufferPosition() - before;
-                if (readBytes !== 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_1.FloatProperty.SerializeValue(writer, v));
-                break;
-            case "BoolProperty":
-                property.values.forEach(v => BoolProperty_1.BoolProperty.SerializeValue(writer, v));
-                break;
-            case "IntProperty":
-                property.values.forEach(v => Int32Property_1.Int32Property.SerializeValue(writer, v));
-                break;
-            case "Int64Property":
-                property.values.forEach(v => Int64Property_1.Int64Property.SerializeValue(writer, v));
-                break;
-            case "DoubleProperty":
-                property.values.forEach(v => DoubleProperty_1.DoubleProperty.SerializeValue(writer, v));
-                break;
-            case "ByteProperty":
-                property.values.forEach(v => ByteProperty_1.ByteProperty.SerializeValue(writer, v));
-                break;
-            case "StrProperty":
-                property.values.forEach(v => StrProperty_1.StrProperty.SerializeValue(writer, v));
-                break;
-            case "EnumProperty":
-                property.values.forEach(v => EnumProperty_1.EnumProperty.SerializeValue(writer, v));
-                break;
-            case "TextProperty":
-                property.values.forEach(v => TextProperty_1.TextProperty.SerializeValue(writer, v));
-                break;
-            case "InterfaceProperty":
-            case "ObjectProperty":
-                property.values.forEach(v => ObjectProperty_1.ObjectProperty.SerializeValue(writer, v));
-                break;
-            case "SoftObjectProperty":
-                property.values.forEach(v => SoftObjectReference_1.SoftObjectReference.write(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_1.StructProperty.SerializeValue(writer, property.structValueFields.allStructType, v.value));
-                writer.writeBinarySizeFromPosition(lenIndicator, before);
-                break;
-            default:
-                throw new Error(`Unknown array property ${property.ueType}, ${property.type}`);
-        }
-    }
-}
-exports.ArrayProperty = ArrayProperty;

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

@@ -1,25 +0,0 @@
-import { GUIDInfo } from '../../GUIDInfo';
-export type PropertiesMap = {
-    [name: string]: AbstractBaseProperty | AbstractBaseProperty[];
-};
-export declare abstract class AbstractProperty {
-    type: string;
-    index?: number | undefined;
-    constructor(type: string, index?: number | undefined);
-}
-export declare abstract class AbstractBaseProperty extends AbstractProperty {
-    ueType: string;
-    name: string;
-    constructor(type: string, ueType: string, index: number);
-}
-type AbstractBasePropertyOptions = {
-    type: string;
-    ueType: string;
-    guidInfo?: GUIDInfo;
-    index: number;
-};
-export declare abstract class BasicProperty extends AbstractBaseProperty {
-    guidInfo: GUIDInfo;
-    constructor(options: AbstractBasePropertyOptions);
-}
-export {};

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

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicProperty = exports.AbstractBaseProperty = exports.AbstractProperty = void 0;
-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.AbstractBaseProperty = AbstractBaseProperty;
-class BasicProperty extends AbstractBaseProperty {
-    constructor(options) {
-        super(options.type, options.ueType, options.index ?? 0);
-        if (options.guidInfo !== undefined) {
-            this.guidInfo = options.guidInfo;
-        }
-    }
-}
-exports.BasicProperty = BasicProperty;

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

@@ -1,13 +0,0 @@
-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 BoolProperty extends BasicProperty {
-    value: boolean;
-    constructor(value: boolean, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): BoolProperty;
-    static ReadValue(reader: BinaryReadable): boolean;
-    static CalcOverhead(property: BoolProperty): number;
-    static Serialize(writer: ByteWriter, property: BoolProperty): void;
-    static SerializeValue(writer: ByteWriter, value: boolean): void;
-}

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BoolProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-class BoolProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'BoolProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'BoolProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const value = BoolProperty.ReadValue(reader);
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(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);
-        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeByte(value ? 1 : 0);
-    }
-}
-exports.BoolProperty = BoolProperty;

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

@@ -1,17 +0,0 @@
-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 ByteProperty extends BasicProperty {
-    value: BytePropertyValue;
-    constructor(value: BytePropertyValue, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): ByteProperty;
-    static ReadValue(reader: BinaryReadable): number;
-    static CalcOverhead(property: ByteProperty): number;
-    static Serialize(writer: ByteWriter, property: ByteProperty): void;
-    static SerializeValue(writer: ByteWriter, value: number): void;
-}
-export type BytePropertyValue = {
-    type: string;
-    value: string | number;
-};

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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ByteProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-class ByteProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'ByteProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'ByteProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const type = reader.readString();
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
-        let value;
-        if (type === 'None') {
-            value = {
-                type,
-                value: ByteProperty.ReadValue(reader)
-            };
-        }
-        else {
-            value = {
-                type,
-                value: reader.readString()
-            };
-        }
-        const property = new ByteProperty(value, ueType, guidInfo, index);
-        return property;
-    }
-    static ReadValue(reader) {
-        return reader.readByte();
-    }
-    static CalcOverhead(property) {
-        return property.value.type.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.value.type);
-        GUIDInfo_1.GUIDInfo.write(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);
-    }
-}
-exports.ByteProperty = ByteProperty;

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

@@ -1,13 +0,0 @@
-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 DoubleProperty extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): DoubleProperty;
-    static ReadValue(reader: BinaryReadable): number;
-    static CalcOverhead(property: DoubleProperty): number;
-    static Serialize(writer: ByteWriter, property: DoubleProperty): void;
-    static SerializeValue(writer: ByteWriter, value: number): void;
-}

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoubleProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-class DoubleProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'DoubleProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'DoubleProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(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) {
-        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
-        DoubleProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeDouble(value);
-    }
-}
-exports.DoubleProperty = DoubleProperty;

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

@@ -1,19 +0,0 @@
-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 EnumProperty extends BasicProperty {
-    value: {
-        name: string;
-        value: string;
-    };
-    constructor(value: {
-        name: string;
-        value: string;
-    }, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): EnumProperty;
-    static ReadValue(reader: BinaryReadable): string;
-    static CalcOverhead(property: EnumProperty): number;
-    static Serialize(writer: ByteWriter, property: EnumProperty): void;
-    static SerializeValue(writer: ByteWriter, value: string): void;
-}

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

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-class EnumProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'EnumProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'EnumProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        let name = reader.readString();
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(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);
-        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
-        EnumProperty.SerializeValue(writer, property.value.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeString(value);
-    }
-}
-exports.EnumProperty = EnumProperty;

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

@@ -1,13 +0,0 @@
-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 FloatProperty extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): FloatProperty;
-    static CalcOverhead(property: FloatProperty): number;
-    static ReadValue(reader: BinaryReadable): number;
-    static Serialize(writer: ByteWriter, property: FloatProperty): void;
-    static SerializeValue(writer: ByteWriter, value: number): void;
-}

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

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FloatProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-class FloatProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'FloatProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'FloatProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(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) {
-        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
-        FloatProperty.SerializeValue(writer, property.value);
-    }
-    static SerializeValue(writer, value) {
-        writer.writeFloat32(value);
-    }
-}
-exports.FloatProperty = FloatProperty;