@etothepii/satisfactory-file-parser 0.0.30 → 0.0.32

package/build/parser/satisfactory/blueprint/blueprint-writer.d.ts

@@ -0,0 +1,15 @@
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { ChunkCompressionInfo, ChunkSummary } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
+export declare class BlueprintWriter extends ByteWriter {
+    constructor();
+    static SerializeHeader(writer: ByteWriter, header: BlueprintHeader): void;
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
+    static SerializeObjects(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+}
+export declare class BlueprintConfigWriter extends ByteWriter {
+    constructor();
+    static SerializeConfig(writer: ByteWriter, config: BlueprintConfig): void;
+}

package/build/parser/satisfactory/blueprint/blueprint-writer.js

@@ -0,0 +1,73 @@
+(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", "../../byte/alignment.enum", "../../byte/byte-writer.class", "../../error/parser.error", "../save/level.class", "../save/save-writer", "../structs/util.types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BlueprintConfigWriter = exports.BlueprintWriter = void 0;
+    const alignment_enum_1 = require("../../byte/alignment.enum");
+    const byte_writer_class_1 = require("../../byte/byte-writer.class");
+    const parser_error_1 = require("../../error/parser.error");
+    const level_class_1 = require("../save/level.class");
+    const save_writer_1 = require("../save/save-writer");
+    const util_types_1 = require("../structs/util.types");
+    class BlueprintWriter extends byte_writer_class_1.ByteWriter {
+        constructor() {
+            super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        }
+        static SerializeHeader(writer, header) {
+            writer.writeInt32(2);
+            writer.writeInt32(36);
+            writer.writeInt32(211839);
+            writer.writeInt32(4);
+            writer.writeInt32(4);
+            writer.writeInt32(4);
+            writer.writeInt32(header.itemCosts.length);
+            for (const itemCost of header.itemCosts) {
+                writer.writeInt32(0);
+                writer.writeString(itemCost[0]);
+                writer.writeInt32(itemCost[1]);
+            }
+            writer.writeInt32(header.recipeReferences.length);
+            for (const recipeReference of header.recipeReferences) {
+                writer.writeInt32(0);
+                writer.writeString(recipeReference);
+            }
+        }
+        generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk) {
+            if (posAfterHeader <= 0) {
+                throw new parser_error_1.ParserError('ParserError', 'seems like this buffer has no header. Please write the header first before you can generate chunks.');
+            }
+            const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
+            onHeader(header);
+            this.bufferArray = this.bufferArray.slice(posAfterHeader);
+            const chunkSummary = save_writer_1.SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, this.alignment);
+            return chunkSummary;
+        }
+        static SerializeObjects(writer, objects) {
+            const headersLenIndicator = writer.getBufferPosition();
+            writer.writeInt32(0);
+            level_class_1.Level.SerializeObjectHeaders(writer, objects);
+            writer.writeBinarySizeFromPosition(headersLenIndicator, headersLenIndicator + 4);
+            level_class_1.Level.SerializeObjectContents(writer, objects, 0, '');
+        }
+    }
+    exports.BlueprintWriter = BlueprintWriter;
+    class BlueprintConfigWriter extends byte_writer_class_1.ByteWriter {
+        constructor() {
+            super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        }
+        static SerializeConfig(writer, config) {
+            writer.writeInt32(2);
+            writer.writeString(config.description);
+            writer.writeInt32(config.iconID);
+            (0, util_types_1.SerializeCol4RGBA)(writer, config.color);
+        }
+    }
+    exports.BlueprintConfigWriter = BlueprintConfigWriter;
+});

package/build/parser/satisfactory/blueprint/blueprint.types.d.ts

@@ -0,0 +1,20 @@
+import { ChunkCompressionInfo } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { col4 } from "../structs/util.types";
+export interface BlueprintConfig {
+    description: string;
+    color: col4;
+    iconID: number;
+}
+export type BlueprintHeader = {
+    itemCosts: [string, number][];
+    recipeReferences: string[];
+};
+export interface Blueprint {
+    name: string;
+    compressionInfo: ChunkCompressionInfo;
+    header: BlueprintHeader;
+    config: BlueprintConfig;
+    objects: (SaveEntity | SaveComponent)[];
+}

package/build/parser/satisfactory/blueprint/blueprint.types.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

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

@@ -0,0 +1,41 @@
+import { ByteWriter } from "../../..";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { SaveWriter } from "../save/save-writer";
+import { vec3 } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
+import { AbstractBaseProperty } from "./Property";
+export type SpecialAnyProperty = {} | PowerLineSpecialProperty;
+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 declare class DataFields {
+    properties: AbstractBaseProperty[];
+    specialProperties: SpecialAnyProperty;
+    trailingData: number[];
+    shouldBeNulled: boolean;
+    constructor();
+    static Parse(length: number, reader: BinaryReadable, buildVersion: number, typePath: string): DataFields;
+    static ParseAdditionalSpecialProperties(reader: BinaryReadable, typePath: string, remainingLen: number): SpecialAnyProperty;
+    static ParseProperty(reader: BinaryReadable, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
+    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number, typePath: string): void;
+    static SerializeAdditionalSpecialProperties(writer: ByteWriter, typePath: string, property: SpecialAnyProperty): void;
+    static SerializeProperty(writer: ByteWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
+}

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

@@ -0,0 +1,317 @@
+(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", "./Property"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataFields = void 0;
+    const util_types_1 = require("../structs/util.types");
+    const Property_1 = require("./Property");
+    class DataFields {
+        constructor() {
+            this.properties = [];
+            this.specialProperties = {};
+            this.trailingData = [];
+            this.shouldBeNulled = false;
+        }
+        static Parse(length, reader, buildVersion, typePath) {
+            const start = reader.getBufferPosition();
+            const fields = new DataFields();
+            if (length === 0) {
+                fields.shouldBeNulled = true;
+                return fields;
+            }
+            let propertyName = reader.readString();
+            while (propertyName !== 'None') {
+                const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
+                fields.properties.push(property);
+                propertyName = reader.readString();
+            }
+            let int1 = reader.readInt32();
+            if (int1 !== 0) {
+            }
+            fields.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, start + length - reader.getBufferPosition() - 4);
+            const end = reader.getBufferPosition();
+            let remainingBytes = start + length - end;
+            fields.trailingData = Array.from(reader.readBytes(remainingBytes));
+            return fields;
+        }
+        static ParseAdditionalSpecialProperties(reader, typePath, remainingLen) {
+            let property;
+            switch (typePath) {
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+                    property = {};
+                    break;
+                case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+                case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                    property = {
+                        source: Property_1.ObjectProperty.ReadValue(reader),
+                        target: Property_1.ObjectProperty.ReadValue(reader)
+                    };
+                    if (remainingLen >= 24) {
+                        property.sourceTranslation = (0, util_types_1.ParseVec3)(reader);
+                        property.targetTranslation = (0, util_types_1.ParseVec3)(reader);
+                    }
+                    break;
+                case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                    property = {};
+                    property.flag = reader.readByte();
+                    switch (property.flag) {
+                        case 248:
+                            const eos = reader.readString();
+                            property.eosData = reader.readString();
+                            break;
+                        case 25:
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                default:
+                    property = {};
+                    break;
+            }
+            return property;
+        }
+        static ParseProperty(reader, buildVersion, propertyName) {
+            let currentProperty = {};
+            if (currentProperty.name === 'None') {
+                return null;
+            }
+            const propertyType = reader.readString();
+            const binarySize = reader.readInt32();
+            const index = reader.readInt32();
+            const before = reader.getBufferPosition();
+            let overhead = 0;
+            switch (propertyType) {
+                case 'BoolProperty':
+                    currentProperty = Property_1.BoolProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.BoolProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'ByteProperty':
+                    currentProperty = Property_1.ByteProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.ByteProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'Int8Property':
+                    currentProperty = Property_1.Int8Property.Parse(reader, propertyType, index);
+                    overhead = Property_1.Int8Property.CalcOverhead(currentProperty);
+                    break;
+                case 'UInt8Property':
+                    currentProperty = Property_1.Uint8Property.Parse(reader, propertyType, index);
+                    overhead = Property_1.Uint8Property.CalcOverhead(currentProperty);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    currentProperty = Property_1.Int32Property.Parse(reader, propertyType, index);
+                    overhead = Property_1.Int32Property.CalcOverhead(currentProperty);
+                    break;
+                case 'UInt32Property':
+                    currentProperty = Property_1.Uint32Property.Parse(reader, propertyType, index);
+                    overhead = Property_1.Uint32Property.CalcOverhead(currentProperty);
+                    break;
+                case 'Int64Property':
+                    currentProperty = Property_1.Int64Property.Parse(reader, propertyType, index);
+                    overhead = Property_1.Int64Property.CalcOverhead(currentProperty);
+                    break;
+                case 'SingleProperty':
+                case 'FloatProperty':
+                    currentProperty = Property_1.FloatProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.FloatProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'DoubleProperty':
+                    currentProperty = Property_1.DoubleProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.DoubleProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    currentProperty = Property_1.StrProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.StrProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'ObjectProperty':
+                case 'InterfaceProperty':
+                    currentProperty = Property_1.ObjectProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.ObjectProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'EnumProperty':
+                    currentProperty = Property_1.EnumProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.EnumProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'StructProperty':
+                    currentProperty = Property_1.StructProperty.Parse(reader, propertyType, index, binarySize);
+                    overhead = Property_1.StructProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'ArrayProperty':
+                    currentProperty = Property_1.ArrayProperty.Parse(reader, propertyType, index, propertyName);
+                    overhead = Property_1.ArrayProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'MapProperty':
+                    currentProperty = Property_1.MapProperty.Parse(reader, propertyName, buildVersion, binarySize);
+                    overhead = Property_1.MapProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'TextProperty':
+                    currentProperty = Property_1.TextProperty.Parse(reader, propertyType, index);
+                    overhead = Property_1.TextProperty.CalcOverhead(currentProperty);
+                    break;
+                case 'SetProperty':
+                    currentProperty = Property_1.SetProperty.Parse(reader, propertyType, index, propertyName);
+                    overhead = Property_1.SetProperty.CalcOverhead(currentProperty);
+                    break;
+                default:
+                    throw new Error(`Unimplemented type ${propertyType}`);
+            }
+            currentProperty.name = propertyName;
+            const readBytes = reader.getBufferPosition() - before - overhead;
+            if (readBytes !== binarySize) {
+                throw new Error(`possibly corrupt. Read ${readBytes} for ${propertyType} ${propertyName}, but ${binarySize} were indicated.`);
+            }
+            return currentProperty;
+        }
+        static Serialize(writer, fields, buildVersion, typePath) {
+            for (const property of fields.properties) {
+                writer.writeString(property.name);
+                DataFields.SerializeProperty(writer, property, property.name, buildVersion);
+            }
+            writer.writeString('None');
+            writer.writeInt32(0);
+            DataFields.SerializeAdditionalSpecialProperties(writer, typePath, fields.specialProperties);
+            writer.writeBytesArray(fields.trailingData);
+        }
+        static SerializeAdditionalSpecialProperties(writer, typePath, property) {
+            switch (typePath) {
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+                    break;
+                case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+                case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                    Property_1.ObjectProperty.SerializeValue(writer, property.source);
+                    Property_1.ObjectProperty.SerializeValue(writer, property.target);
+                    break;
+                case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                    writer.writeByte(property.flag);
+                    switch (property.flag) {
+                        case 248:
+                            writer.writeString('EOS');
+                            writer.writeString(property.eosData);
+                            break;
+                        case 25:
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        }
+        static SerializeProperty(writer, property, propertyName, buildVersion) {
+            writer.writeString(property.ueType);
+            const lenIndicator = writer.getBufferPosition();
+            writer.writeInt32(0);
+            writer.writeInt32(property.index ?? 0);
+            const start = writer.getBufferPosition();
+            let overhead = 0;
+            switch (property.ueType) {
+                case 'BoolProperty':
+                    overhead = Property_1.BoolProperty.CalcOverhead(property);
+                    Property_1.BoolProperty.Serialize(writer, property);
+                    break;
+                case 'ByteProperty':
+                    overhead = Property_1.ByteProperty.CalcOverhead(property);
+                    Property_1.ByteProperty.Serialize(writer, property);
+                    break;
+                case 'Int8Property':
+                    overhead = Property_1.Int8Property.CalcOverhead(property);
+                    Property_1.Int8Property.Serialize(writer, property);
+                    break;
+                case 'UInt8Property':
+                    overhead = Property_1.Uint8Property.CalcOverhead(property);
+                    Property_1.Uint8Property.Serialize(writer, property);
+                    break;
+                case 'IntProperty':
+                case 'Int32Property':
+                    overhead = Property_1.Int32Property.CalcOverhead(property);
+                    Property_1.Int32Property.Serialize(writer, property);
+                    break;
+                case 'UInt32Property':
+                    overhead = Property_1.Uint32Property.CalcOverhead(property);
+                    Property_1.Uint32Property.Serialize(writer, property);
+                    break;
+                case 'Int64Property':
+                    overhead = Property_1.Int64Property.CalcOverhead(property);
+                    Property_1.Int64Property.Serialize(writer, property);
+                    break;
+                case 'SingleProperty':
+                case 'FloatProperty':
+                    overhead = Property_1.FloatProperty.CalcOverhead(property);
+                    Property_1.FloatProperty.Serialize(writer, property);
+                    break;
+                case 'DoubleProperty':
+                    overhead = Property_1.DoubleProperty.CalcOverhead(property);
+                    Property_1.DoubleProperty.Serialize(writer, property);
+                    break;
+                case 'StrProperty':
+                case 'NameProperty':
+                    overhead = Property_1.StrProperty.CalcOverhead(property);
+                    Property_1.StrProperty.Serialize(writer, property);
+                    break;
+                case 'ObjectProperty':
+                case 'InterfaceProperty':
+                    overhead = Property_1.ObjectProperty.CalcOverhead(property);
+                    Property_1.ObjectProperty.Serialize(writer, property);
+                    break;
+                case 'EnumProperty':
+                    overhead = Property_1.EnumProperty.CalcOverhead(property);
+                    Property_1.EnumProperty.Serialize(writer, property);
+                    break;
+                case 'ByteProperty':
+                    overhead = Property_1.ByteProperty.CalcOverhead(property);
+                    Property_1.ByteProperty.Serialize(writer, property);
+                    break;
+                case 'StructProperty':
+                    overhead = Property_1.StructProperty.CalcOverhead(property);
+                    Property_1.StructProperty.Serialize(writer, property);
+                    break;
+                case 'ArrayProperty':
+                    overhead = Property_1.ArrayProperty.CalcOverhead(property);
+                    Property_1.ArrayProperty.Serialize(writer, property, propertyName);
+                    break;
+                case 'MapProperty':
+                    overhead = Property_1.MapProperty.CalcOverhead(property);
+                    Property_1.MapProperty.Serialize(writer, property);
+                    break;
+                case 'TextProperty':
+                    overhead = Property_1.TextProperty.CalcOverhead(property);
+                    Property_1.TextProperty.Serialize(writer, property);
+                    break;
+                case 'SetProperty':
+                    overhead = Property_1.SetProperty.CalcOverhead(property);
+                    Property_1.SetProperty.Serialize(writer, property);
+                    break;
+                default:
+                    throw new Error(`Unimplemented type ${property.type}`);
+            }
+            writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
+        }
+    }
+    exports.DataFields = DataFields;
+});

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

@@ -0,0 +1,9 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+export declare class ObjectReference {
+    levelName: string;
+    pathName: string;
+    constructor(levelName: string, pathName: string);
+    static Parse(reader: BinaryReadable): ObjectReference;
+    static Serialize(writer: ByteWriter, ref: ObjectReference): void;
+}

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

@@ -0,0 +1,27 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ObjectReference = void 0;
+    class ObjectReference {
+        constructor(levelName, pathName) {
+            this.levelName = levelName;
+            this.pathName = pathName;
+        }
+        static Parse(reader) {
+            return new ObjectReference(reader.readString(), reader.readString());
+        }
+        static Serialize(writer, ref) {
+            writer.writeString(ref.levelName);
+            writer.writeString(ref.pathName);
+        }
+    }
+    exports.ObjectReference = ObjectReference;
+});