@etothepii/satisfactory-file-parser 0.0.30 → 0.0.31

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

@@ -0,0 +1,18 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { ChunkCompressionInfo } from "../../file.types";
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
+export declare class BlueprintReader extends ByteReader {
+    compressionInfo: ChunkCompressionInfo;
+    constructor(bluePrintBuffer: ArrayBuffer);
+    static ReadHeader(reader: ByteReader): BlueprintHeader;
+    inflateChunks(): any;
+    static ParseObjects(reader: ByteReader): (SaveEntity | SaveComponent)[];
+}
+export declare class BlueprintConfigReader extends ByteReader {
+    bluePrintConfigBuffer: ArrayBuffer;
+    constructor(bluePrintConfigBuffer: ArrayBuffer);
+    parse: () => BlueprintConfig;
+    static ParseConfig(reader: ByteReader): BlueprintConfig;
+}

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

@@ -0,0 +1,134 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "pako", "../../byte/alignment.enum", "../../byte/byte-reader.class", "../../error/parser.error", "../save/level.class", "../structs/util.types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BlueprintConfigReader = exports.BlueprintReader = void 0;
+    const pako_1 = __importDefault(require("pako"));
+    const alignment_enum_1 = require("../../byte/alignment.enum");
+    const byte_reader_class_1 = require("../../byte/byte-reader.class");
+    const parser_error_1 = require("../../error/parser.error");
+    const level_class_1 = require("../save/level.class");
+    const util_types_1 = require("../structs/util.types");
+    class BlueprintReader extends byte_reader_class_1.ByteReader {
+        constructor(bluePrintBuffer) {
+            super(bluePrintBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.compressionInfo = {
+                packageFileTag: 0,
+                maxChunkContentSize: 0,
+                chunkHeaderSize: 48
+            };
+        }
+        static ReadHeader(reader) {
+            const unk = reader.readBytes(3 * 4);
+            const positionThingOrWhat = (0, util_types_1.ParseVec3)(reader);
+            let itemTypeCount = reader.readInt32();
+            const itemCosts = new Array(itemTypeCount).fill(['', 0]);
+            for (let i = 0; i < itemTypeCount; i++) {
+                let indexOrWhat = reader.readInt32();
+                let itemPathName = reader.readString();
+                let itemCount = reader.readInt32();
+                itemCosts[i] = [itemPathName, itemCount];
+            }
+            let recipeCount = reader.readInt32();
+            const recipeRefs = new Array(recipeCount).fill('');
+            for (let i = 0; i < recipeCount; i++) {
+                let indexOrWhat = reader.readInt32();
+                const recipeName = reader.readString();
+                recipeRefs[i] = recipeName;
+            }
+            return {
+                recipeReferences: recipeRefs,
+                itemCosts
+            };
+        }
+        inflateChunks() {
+            this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+            this.handledByte = 0;
+            this.currentByte = 0;
+            this.maxByte = this.fileBuffer.byteLength;
+            let currentChunks = [];
+            let totalUncompressedBodySize = 0;
+            while (this.handledByte < this.maxByte) {
+                let chunkHeader = new DataView(this.fileBuffer.slice(0, this.compressionInfo.chunkHeaderSize));
+                this.currentByte = this.compressionInfo.chunkHeaderSize;
+                this.handledByte += this.compressionInfo.chunkHeaderSize;
+                if (this.compressionInfo.packageFileTag <= 0) {
+                    this.compressionInfo.packageFileTag = chunkHeader.getUint32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                }
+                if (this.compressionInfo.maxChunkContentSize <= 0) {
+                    this.compressionInfo.maxChunkContentSize = chunkHeader.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                }
+                const chunkCompressedLength = chunkHeader.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                const chunkUncompressedLength = chunkHeader.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                totalUncompressedBodySize += chunkUncompressedLength;
+                const currentChunkSize = chunkCompressedLength;
+                let currentChunk = this.fileBuffer.slice(this.currentByte, this.currentByte + currentChunkSize);
+                this.handledByte += currentChunkSize;
+                this.currentByte += currentChunkSize;
+                this.fileBuffer = this.fileBuffer.slice(this.currentByte);
+                this.currentByte = 0;
+                try {
+                    let currentInflatedChunk = null;
+                    currentInflatedChunk = pako_1.default.inflate(currentChunk);
+                    currentChunks.push(currentInflatedChunk);
+                }
+                catch (err) {
+                    throw new parser_error_1.ParserError('ParserError', 'An error occurred while calling pako inflate.' + err);
+                }
+            }
+            let newChunkLength = currentChunks.map(cc => cc.length).reduce((prev, cur) => prev + cur);
+            const bigWholeChunk = new Uint8Array(newChunkLength);
+            let currentLength = 0;
+            for (let i = 0; i < currentChunks.length; i++) {
+                bigWholeChunk.set(currentChunks[i], currentLength);
+                currentLength += currentChunks[i].length;
+            }
+            this.currentByte = 0;
+            this.maxByte = bigWholeChunk.buffer.byteLength;
+            this.bufferView = new DataView(bigWholeChunk.buffer);
+            return {
+                newChunkLength,
+                numChunks: currentChunks.length,
+                inflatedData: bigWholeChunk
+            };
+        }
+        static ParseObjects(reader) {
+            const totalBodyRestSize = reader.readInt32();
+            const objectHeadersBinarySize = reader.readInt32();
+            let objects = [];
+            level_class_1.Level.ReadObjectHeaders(reader, objects, () => { });
+            level_class_1.Level.ReadObjectContents(reader, objects, 0, () => { });
+            return objects;
+        }
+    }
+    exports.BlueprintReader = BlueprintReader;
+    class BlueprintConfigReader extends byte_reader_class_1.ByteReader {
+        constructor(bluePrintConfigBuffer) {
+            super(bluePrintConfigBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.bluePrintConfigBuffer = bluePrintConfigBuffer;
+            this.parse = () => BlueprintConfigReader.ParseConfig(this);
+        }
+        static ParseConfig(reader) {
+            const unk = reader.readInt32();
+            const description = reader.readString();
+            const unk3 = reader.readInt32();
+            const colorMaybe = (0, util_types_1.ParseCol4RGBA)(reader);
+            return {
+                description,
+                color: colorMaybe,
+                iconID: unk3
+            };
+        }
+    }
+    exports.BlueprintConfigReader = BlueprintConfigReader;
+});

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,13 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveWriter } from "../save/save-writer";
+import { AbstractBaseProperty } from "./Property";
+export declare class DataFields {
+    properties: any[];
+    trailingData: number[];
+    shouldBeNulled: boolean;
+    constructor();
+    static Parse(length: number, reader: ByteReader, buildVersion: number): DataFields;
+    static ParseProperty(reader: ByteReader, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
+    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number): void;
+    static SerializeProperty(writer: SaveWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
+}

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

@@ -0,0 +1,234 @@
+(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", "./Property"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataFields = void 0;
+    const Property_1 = require("./Property");
+    class DataFields {
+        constructor() {
+            this.properties = [];
+            this.trailingData = [];
+            this.shouldBeNulled = false;
+        }
+        static Parse(length, reader, buildVersion) {
+            const start = reader.getBufferPosition();
+            const fields = new DataFields();
+            if (length === 0) {
+                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) {
+            }
+            const end = reader.getBufferPosition();
+            let remainingBytes = start + length - end;
+            fields.trailingData = Array.from(reader.readBytes(remainingBytes));
+            return fields;
+        }
+        static ParseProperty(reader, buildVersion, propertyName) {
+            let currentProperty = {};
+            if (currentProperty.name === 'None') {
+                return null;
+            }
+            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) {
+            for (const property of fields.properties) {
+                writer.writeString(property.name);
+                DataFields.SerializeProperty(writer, property, property.name, buildVersion);
+            }
+            writer.writeString('None');
+            writer.writeInt32(0);
+            writer.writeBytesArray(fields.trailingData);
+        }
+        static SerializeProperty(writer, property, propertyName, buildVersion) {
+            writer.writeString(property.ueType);
+            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 { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../byte/byte-writer.class";
+export declare class ObjectReference {
+    levelName: string;
+    pathName: string;
+    constructor(levelName: string, pathName: string);
+    static Parse(reader: ByteReader): 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;
+});