@etothepii/satisfactory-file-parser 1.1.1 → 2.0.1

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isByteArrayProperty: (property: any) => property is ByteArrayProperty;
+export type ByteArrayProperty = AbstractBaseProperty & {
+    type: 'ByteArrayProperty';
+    subtype: string;
+    values: number[];
+};
+export declare namespace ByteArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => ByteArrayProperty;
+    const Serialize: (writer: ByteWriter, property: ByteArrayProperty) => void;
+}
+//# sourceMappingURL=ByteArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,mBAAmB,aAAc,GAAG,KAAG,QAAQ,IAAI,iBAAsF,CAAC;AAEvJ,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG;IACnD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,iBAAiB,CAAC;IAExB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,iBAYxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,iBAAiB,KAAG,IAE3E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteArrayProperty = exports.isByteArrayProperty = void 0;
+const ByteProperty_1 = require("../ByteProperty");
+const isByteArrayProperty = (property) => !Array.isArray(property) && property.type === 'ByteArrayProperty';
+exports.isByteArrayProperty = isByteArrayProperty;
+var ByteArrayProperty;
+(function (ByteArrayProperty) {
+    ByteArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => ByteProperty_1.ByteProperty.ReadValue(reader));
+        return {
+            type: 'ByteArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    ByteArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => ByteProperty_1.ByteProperty.SerializeValue(writer, value));
+    };
+})(ByteArrayProperty || (exports.ByteArrayProperty = ByteArrayProperty = {}));
+//# sourceMappingURL=ByteArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ByteArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/ByteArrayProperty.ts"],"names":[],"mappings":";;;AAGA,kDAA+C;AAExC,MAAM,mBAAmB,GAAG,CAAC,QAAa,EAAiC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,mBAAmB,CAAC;AAA1I,QAAA,mBAAmB,uBAAuH;AAQvJ,IAAiB,iBAAiB,CAmBjC;AAnBD,WAAiB,iBAAiB;IAEjB,uBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAqB,EAAE;QACzI,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,2BAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAEzF,OAAO;YACH,IAAI,EAAE,mBAAmB;YACzB,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACiB,CAAC;IAClC,CAAC,CAAA;IAEY,2BAAS,GAAG,CAAC,MAAkB,EAAE,QAA2B,EAAQ,EAAE;QAC/E,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,2BAAY,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACjF,CAAC,CAAA;AACL,CAAC,EAnBgB,iBAAiB,iCAAjB,iBAAiB,QAmBjC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { ByteProperty } from '../ByteProperty';\n\nexport const isByteArrayProperty = (property: any): property is ByteArrayProperty => !Array.isArray(property) && property.type === 'ByteArrayProperty';\n\nexport type ByteArrayProperty = AbstractBaseProperty & {\n    type: 'ByteArrayProperty';\n    subtype: string;\n    values: number[];\n};\n\nexport namespace ByteArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): ByteArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => ByteProperty.ReadValue(reader));\n\n        return {\n            type: 'ByteArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies ByteArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: ByteArrayProperty): void => {\n        property.values.forEach(value => ByteProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isDoubleArrayProperty: (property: any) => property is DoubleArrayProperty;
+export type DoubleArrayProperty = AbstractBaseProperty & {
+    type: 'DoubleArrayProperty';
+    subtype: string;
+    values: number[];
+};
+export declare namespace DoubleArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => DoubleArrayProperty;
+    const Serialize: (writer: ByteWriter, property: DoubleArrayProperty) => void;
+}
+//# sourceMappingURL=DoubleArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoubleArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,qBAAqB,aAAc,GAAG,KAAG,QAAQ,IAAI,mBAA0F,CAAC;AAE7J,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG;IACrD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,mBAAmB,CAAC;IAE1B,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,mBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,mBAAmB,KAAG,IAE7E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleArrayProperty = exports.isDoubleArrayProperty = void 0;
+const DoubleProperty_1 = require("../DoubleProperty");
+const isDoubleArrayProperty = (property) => !Array.isArray(property) && property.type === 'DoubleArrayProperty';
+exports.isDoubleArrayProperty = isDoubleArrayProperty;
+var DoubleArrayProperty;
+(function (DoubleArrayProperty) {
+    DoubleArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => DoubleProperty_1.DoubleProperty.ReadValue(reader));
+        return {
+            type: 'DoubleArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    DoubleArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => DoubleProperty_1.DoubleProperty.SerializeValue(writer, value));
+    };
+})(DoubleArrayProperty || (exports.DoubleArrayProperty = DoubleArrayProperty = {}));
+//# sourceMappingURL=DoubleArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoubleArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/DoubleArrayProperty.ts"],"names":[],"mappings":";;;AAGA,sDAAmD;AAE5C,MAAM,qBAAqB,GAAG,CAAC,QAAa,EAAmC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,qBAAqB,CAAC;AAAhJ,QAAA,qBAAqB,yBAA2H;AAQ7J,IAAiB,mBAAmB,CAkBnC;AAlBD,WAAiB,mBAAmB;IAEnB,yBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAuB,EAAE;QAC3I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,+BAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3F,OAAO;YACH,IAAI,EAAE,qBAAqB;YAC3B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACmB,CAAC;IACpC,CAAC,CAAA;IAEY,6BAAS,GAAG,CAAC,MAAkB,EAAE,QAA6B,EAAQ,EAAE;QACjF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,+BAAc,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACnF,CAAC,CAAA;AACL,CAAC,EAlBgB,mBAAmB,mCAAnB,mBAAmB,QAkBnC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { DoubleProperty } from '../DoubleProperty';\n\nexport const isDoubleArrayProperty = (property: any): property is DoubleArrayProperty => !Array.isArray(property) && property.type === 'DoubleArrayProperty';\n\nexport type DoubleArrayProperty = AbstractBaseProperty & {\n    type: 'DoubleArrayProperty';\n    subtype: string;\n    values: number[];\n};\n\nexport namespace DoubleArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): DoubleArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => DoubleProperty.ReadValue(reader));\n        return {\n            type: 'DoubleArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies DoubleArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: DoubleArrayProperty): void => {\n        property.values.forEach(value => DoubleProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isEnumArrayProperty: (property: any) => property is EnumArrayProperty;
+export type EnumArrayProperty = AbstractBaseProperty & {
+    type: 'EnumArrayProperty';
+    subtype: string;
+    values: string[];
+};
+export declare namespace EnumArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => EnumArrayProperty;
+    const Serialize: (writer: ByteWriter, property: EnumArrayProperty) => void;
+}
+//# sourceMappingURL=EnumArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,mBAAmB,aAAc,GAAG,KAAG,QAAQ,IAAI,iBAAsF,CAAC;AAEvJ,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,GAAG;IACnD,IAAI,EAAE,mBAAmB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,iBAAiB,CAAC;IAExB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,iBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,iBAAiB,KAAG,IAE3E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumArrayProperty = exports.isEnumArrayProperty = void 0;
+const EnumProperty_1 = require("../EnumProperty");
+const isEnumArrayProperty = (property) => !Array.isArray(property) && property.type === 'EnumArrayProperty';
+exports.isEnumArrayProperty = isEnumArrayProperty;
+var EnumArrayProperty;
+(function (EnumArrayProperty) {
+    EnumArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => EnumProperty_1.EnumProperty.ReadValue(reader));
+        return {
+            type: 'EnumArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    EnumArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => EnumProperty_1.EnumProperty.SerializeValue(writer, value));
+    };
+})(EnumArrayProperty || (exports.EnumArrayProperty = EnumArrayProperty = {}));
+//# sourceMappingURL=EnumArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/EnumArrayProperty.ts"],"names":[],"mappings":";;;AAGA,kDAA+C;AAExC,MAAM,mBAAmB,GAAG,CAAC,QAAa,EAAiC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,mBAAmB,CAAC;AAA1I,QAAA,mBAAmB,uBAAuH;AAQvJ,IAAiB,iBAAiB,CAkBjC;AAlBD,WAAiB,iBAAiB;IAEjB,uBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAqB,EAAE;QACzI,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,2BAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QACzF,OAAO;YACH,IAAI,EAAE,mBAAmB;YACzB,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACiB,CAAC;IAClC,CAAC,CAAA;IAEY,2BAAS,GAAG,CAAC,MAAkB,EAAE,QAA2B,EAAQ,EAAE;QAC/E,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,2BAAY,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACjF,CAAC,CAAA;AACL,CAAC,EAlBgB,iBAAiB,iCAAjB,iBAAiB,QAkBjC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { EnumProperty } from '../EnumProperty';\n\nexport const isEnumArrayProperty = (property: any): property is EnumArrayProperty => !Array.isArray(property) && property.type === 'EnumArrayProperty';\n\nexport type EnumArrayProperty = AbstractBaseProperty & {\n    type: 'EnumArrayProperty';\n    subtype: string;\n    values: string[];\n};\n\nexport namespace EnumArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): EnumArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => EnumProperty.ReadValue(reader));\n        return {\n            type: 'EnumArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies EnumArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: EnumArrayProperty): void => {\n        property.values.forEach(value => EnumProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isFloatArrayProperty: (property: any) => property is FloatArrayProperty;
+export type FloatArrayProperty = AbstractBaseProperty & {
+    type: 'FloatArrayProperty';
+    subtype: string;
+    values: number[];
+};
+export declare namespace FloatArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => FloatArrayProperty;
+    const Serialize: (writer: ByteWriter, property: FloatArrayProperty) => void;
+}
+//# sourceMappingURL=FloatArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,oBAAoB,aAAc,GAAG,KAAG,QAAQ,IAAI,kBAAwF,CAAC;AAE1J,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACpD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,kBAAkB,CAAC;IAEzB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,kBAYxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,kBAAkB,KAAG,IAE5E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatArrayProperty = exports.isFloatArrayProperty = void 0;
+const FloatProperty_1 = require("../FloatProperty");
+const isFloatArrayProperty = (property) => !Array.isArray(property) && property.type === 'FloatArrayProperty';
+exports.isFloatArrayProperty = isFloatArrayProperty;
+var FloatArrayProperty;
+(function (FloatArrayProperty) {
+    FloatArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => FloatProperty_1.FloatProperty.ReadValue(reader));
+        return {
+            type: 'FloatArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    FloatArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => FloatProperty_1.FloatProperty.SerializeValue(writer, value));
+    };
+})(FloatArrayProperty || (exports.FloatArrayProperty = FloatArrayProperty = {}));
+//# sourceMappingURL=FloatArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/FloatArrayProperty.ts"],"names":[],"mappings":";;;AAGA,oDAAiD;AAE1C,MAAM,oBAAoB,GAAG,CAAC,QAAa,EAAkC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,oBAAoB,CAAC;AAA7I,QAAA,oBAAoB,wBAAyH;AAQ1J,IAAiB,kBAAkB,CAmBlC;AAnBD,WAAiB,kBAAkB;IAElB,wBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAsB,EAAE;QAC1I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,6BAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAE1F,OAAO;YACH,IAAI,EAAE,oBAAoB;YAC1B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACkB,CAAC;IACnC,CAAC,CAAA;IAEY,4BAAS,GAAG,CAAC,MAAkB,EAAE,QAA4B,EAAQ,EAAE;QAChF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,6BAAa,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAClF,CAAC,CAAA;AACL,CAAC,EAnBgB,kBAAkB,kCAAlB,kBAAkB,QAmBlC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { FloatProperty } from '../FloatProperty';\n\nexport const isFloatArrayProperty = (property: any): property is FloatArrayProperty => !Array.isArray(property) && property.type === 'FloatArrayProperty';\n\nexport type FloatArrayProperty = AbstractBaseProperty & {\n    type: 'FloatArrayProperty';\n    subtype: string;\n    values: number[];\n};\n\nexport namespace FloatArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): FloatArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => FloatProperty.ReadValue(reader));\n\n        return {\n            type: 'FloatArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies FloatArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: FloatArrayProperty): void => {\n        property.values.forEach(value => FloatProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isInt32ArrayProperty: (property: any) => property is Int32ArrayProperty;
+export type Int32ArrayProperty = AbstractBaseProperty & {
+    type: 'Int32ArrayProperty';
+    subtype: string;
+    values: number[];
+};
+export declare namespace Int32ArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => Int32ArrayProperty;
+    const Serialize: (writer: ByteWriter, property: Int32ArrayProperty) => void;
+}
+//# sourceMappingURL=Int32ArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int32ArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,oBAAoB,aAAc,GAAG,KAAG,QAAQ,IAAI,kBAAwF,CAAC;AAE1J,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACpD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,kBAAkB,CAAC;IAEzB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,kBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,kBAAkB,KAAG,IAE5E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int32ArrayProperty = exports.isInt32ArrayProperty = void 0;
+const Int32Property_1 = require("../Int32Property");
+const isInt32ArrayProperty = (property) => !Array.isArray(property) && property.type === 'Int32ArrayProperty';
+exports.isInt32ArrayProperty = isInt32ArrayProperty;
+var Int32ArrayProperty;
+(function (Int32ArrayProperty) {
+    Int32ArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => Int32Property_1.Int32Property.ReadValue(reader));
+        return {
+            type: 'Int32ArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    Int32ArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => Int32Property_1.Int32Property.SerializeValue(writer, value));
+    };
+})(Int32ArrayProperty || (exports.Int32ArrayProperty = Int32ArrayProperty = {}));
+//# sourceMappingURL=Int32ArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int32ArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/Int32ArrayProperty.ts"],"names":[],"mappings":";;;AAGA,oDAAiD;AAE1C,MAAM,oBAAoB,GAAG,CAAC,QAAa,EAAkC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,oBAAoB,CAAC;AAA7I,QAAA,oBAAoB,wBAAyH;AAQ1J,IAAiB,kBAAkB,CAkBlC;AAlBD,WAAiB,kBAAkB;IAElB,wBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAsB,EAAE;QAC1I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,6BAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1F,OAAO;YACH,IAAI,EAAE,oBAAoB;YAC1B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACkB,CAAC;IACnC,CAAC,CAAA;IAEY,4BAAS,GAAG,CAAC,MAAkB,EAAE,QAA4B,EAAQ,EAAE;QAChF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,6BAAa,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAClF,CAAC,CAAA;AACL,CAAC,EAlBgB,kBAAkB,kCAAlB,kBAAkB,QAkBlC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { Int32Property } from '../Int32Property';\n\nexport const isInt32ArrayProperty = (property: any): property is Int32ArrayProperty => !Array.isArray(property) && property.type === 'Int32ArrayProperty';\n\nexport type Int32ArrayProperty = AbstractBaseProperty & {\n    type: 'Int32ArrayProperty';\n    subtype: string;\n    values: number[];\n};\n\nexport namespace Int32ArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): Int32ArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader));\n        return {\n            type: 'Int32ArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies Int32ArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: Int32ArrayProperty): void => {\n        property.values.forEach(value => Int32Property.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isInt64ArrayProperty: (property: any) => property is Int64ArrayProperty;
+export type Int64ArrayProperty = AbstractBaseProperty & {
+    type: 'Int64ArrayProperty';
+    subtype: string;
+    values: string[];
+};
+export declare namespace Int64ArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => Int64ArrayProperty;
+    const Serialize: (writer: ByteWriter, property: Int64ArrayProperty) => void;
+}
+//# sourceMappingURL=Int64ArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int64ArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,oBAAoB,aAAc,GAAG,KAAG,QAAQ,IAAI,kBAAwF,CAAC;AAE1J,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GAAG;IACpD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,kBAAkB,CAAC;IAEzB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,kBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,kBAAkB,KAAG,IAE5E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int64ArrayProperty = exports.isInt64ArrayProperty = void 0;
+const Int64Property_1 = require("../Int64Property");
+const isInt64ArrayProperty = (property) => !Array.isArray(property) && property.type === 'Int64ArrayProperty';
+exports.isInt64ArrayProperty = isInt64ArrayProperty;
+var Int64ArrayProperty;
+(function (Int64ArrayProperty) {
+    Int64ArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => Int64Property_1.Int64Property.ReadValue(reader));
+        return {
+            type: 'Int64ArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    Int64ArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => Int64Property_1.Int64Property.SerializeValue(writer, value));
+    };
+})(Int64ArrayProperty || (exports.Int64ArrayProperty = Int64ArrayProperty = {}));
+//# sourceMappingURL=Int64ArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int64ArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/Int64ArrayProperty.ts"],"names":[],"mappings":";;;AAGA,oDAAiD;AAE1C,MAAM,oBAAoB,GAAG,CAAC,QAAa,EAAkC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,oBAAoB,CAAC;AAA7I,QAAA,oBAAoB,wBAAyH;AAQ1J,IAAiB,kBAAkB,CAkBlC;AAlBD,WAAiB,kBAAkB;IAElB,wBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAsB,EAAE;QAC1I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,6BAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1F,OAAO;YACH,IAAI,EAAE,oBAAoB;YAC1B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACkB,CAAC;IACnC,CAAC,CAAA;IAEY,4BAAS,GAAG,CAAC,MAAkB,EAAE,QAA4B,EAAQ,EAAE;QAChF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,6BAAa,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAClF,CAAC,CAAA;AACL,CAAC,EAlBgB,kBAAkB,kCAAlB,kBAAkB,QAkBlC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { Int64Property } from '../Int64Property';\n\nexport const isInt64ArrayProperty = (property: any): property is Int64ArrayProperty => !Array.isArray(property) && property.type === 'Int64ArrayProperty';\n\nexport type Int64ArrayProperty = AbstractBaseProperty & {\n    type: 'Int64ArrayProperty';\n    subtype: string;\n    values: string[];\n};\n\nexport namespace Int64ArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): Int64ArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => Int64Property.ReadValue(reader));\n        return {\n            type: 'Int64ArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies Int64ArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: Int64ArrayProperty): void => {\n        property.values.forEach(value => Int64Property.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.d.ts

@@ -0,0 +1,15 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { ObjectReference } from '../../../structs/ObjectReference';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isObjectArrayProperty: (property: any) => property is ObjectArrayProperty;
+export type ObjectArrayProperty = AbstractBaseProperty & {
+    type: 'ObjectArrayProperty';
+    subtype: string;
+    values: ObjectReference[];
+};
+export declare namespace ObjectArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => ObjectArrayProperty;
+    const Serialize: (writer: ByteWriter, property: ObjectArrayProperty) => void;
+}
+//# sourceMappingURL=ObjectArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,qBAAqB,aAAc,GAAG,KAAG,QAAQ,IAAI,mBAA0F,CAAC;AAE7J,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG;IACrD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,yBAAiB,mBAAmB,CAAC;IAE1B,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,mBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,mBAAmB,KAAG,IAE7E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectArrayProperty = exports.isObjectArrayProperty = void 0;
+const ObjectProperty_1 = require("../ObjectProperty");
+const isObjectArrayProperty = (property) => !Array.isArray(property) && property.type === 'ObjectArrayProperty';
+exports.isObjectArrayProperty = isObjectArrayProperty;
+var ObjectArrayProperty;
+(function (ObjectArrayProperty) {
+    ObjectArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader));
+        return {
+            type: 'ObjectArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    ObjectArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => ObjectProperty_1.ObjectProperty.SerializeValue(writer, value));
+    };
+})(ObjectArrayProperty || (exports.ObjectArrayProperty = ObjectArrayProperty = {}));
+//# sourceMappingURL=ObjectArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/ObjectArrayProperty.ts"],"names":[],"mappings":";;;AAIA,sDAAmD;AAE5C,MAAM,qBAAqB,GAAG,CAAC,QAAa,EAAmC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,qBAAqB,CAAC;AAAhJ,QAAA,qBAAqB,yBAA2H;AAQ7J,IAAiB,mBAAmB,CAkBnC;AAlBD,WAAiB,mBAAmB;IAEnB,yBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAuB,EAAE;QAC3I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,+BAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3F,OAAO;YACH,IAAI,EAAE,qBAAqB;YAC3B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACmB,CAAC;IACpC,CAAC,CAAA;IAEY,6BAAS,GAAG,CAAC,MAAkB,EAAE,QAA6B,EAAQ,EAAE;QACjF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,+BAAc,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACnF,CAAC,CAAA;AACL,CAAC,EAlBgB,mBAAmB,mCAAnB,mBAAmB,QAkBnC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { ObjectReference } from '../../../structs/ObjectReference';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { ObjectProperty } from '../ObjectProperty';\n\nexport const isObjectArrayProperty = (property: any): property is ObjectArrayProperty => !Array.isArray(property) && property.type === 'ObjectArrayProperty';\n\nexport type ObjectArrayProperty = AbstractBaseProperty & {\n    type: 'ObjectArrayProperty';\n    subtype: string;\n    values: ObjectReference[];\n};\n\nexport namespace ObjectArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): ObjectArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader));\n        return {\n            type: 'ObjectArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies ObjectArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: ObjectArrayProperty): void => {\n        property.values.forEach(value => ObjectProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.d.ts

@@ -0,0 +1,15 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { SoftObjectReference } from '../../../structs/SoftObjectReference';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isSoftObjectArrayProperty: (property: any) => property is SoftObjectArrayProperty;
+export type SoftObjectArrayProperty = AbstractBaseProperty & {
+    type: 'SoftObjectArrayProperty';
+    subtype: string;
+    values: SoftObjectReference[];
+};
+export declare namespace SoftObjectArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => SoftObjectArrayProperty;
+    const Serialize: (writer: ByteWriter, property: SoftObjectArrayProperty) => void;
+}
+//# sourceMappingURL=SoftObjectArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoftObjectArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,yBAAyB,aAAc,GAAG,KAAG,QAAQ,IAAI,uBAAkG,CAAC;AAEzK,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,GAAG;IACzD,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,mBAAmB,EAAE,CAAC;CACjC,CAAC;AAEF,yBAAiB,uBAAuB,CAAC;IAE9B,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,uBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,uBAAuB,KAAG,IAEjF,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftObjectArrayProperty = exports.isSoftObjectArrayProperty = void 0;
+const SoftObjectProperty_1 = require("../SoftObjectProperty");
+const isSoftObjectArrayProperty = (property) => !Array.isArray(property) && property.type === 'SoftObjectArrayProperty';
+exports.isSoftObjectArrayProperty = isSoftObjectArrayProperty;
+var SoftObjectArrayProperty;
+(function (SoftObjectArrayProperty) {
+    SoftObjectArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => SoftObjectProperty_1.SoftObjectProperty.ReadValue(reader));
+        return {
+            type: 'SoftObjectArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    SoftObjectArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => SoftObjectProperty_1.SoftObjectProperty.SerializeValue(writer, value));
+    };
+})(SoftObjectArrayProperty || (exports.SoftObjectArrayProperty = SoftObjectArrayProperty = {}));
+//# sourceMappingURL=SoftObjectArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoftObjectArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/SoftObjectArrayProperty.ts"],"names":[],"mappings":";;;AAIA,8DAA2D;AAEpD,MAAM,yBAAyB,GAAG,CAAC,QAAa,EAAuC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,yBAAyB,CAAC;AAA5J,QAAA,yBAAyB,6BAAmI;AAQzK,IAAiB,uBAAuB,CAkBvC;AAlBD,WAAiB,uBAAuB;IAEvB,6BAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAA2B,EAAE;QAC/I,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,uCAAkB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/F,OAAO;YACH,IAAI,EAAE,yBAAyB;YAC/B,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACuB,CAAC;IACxC,CAAC,CAAA;IAEY,iCAAS,GAAG,CAAC,MAAkB,EAAE,QAAiC,EAAQ,EAAE;QACrF,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,uCAAkB,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACvF,CAAC,CAAA;AACL,CAAC,EAlBgB,uBAAuB,uCAAvB,uBAAuB,QAkBvC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { SoftObjectReference } from '../../../structs/SoftObjectReference';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { SoftObjectProperty } from '../SoftObjectProperty';\n\nexport const isSoftObjectArrayProperty = (property: any): property is SoftObjectArrayProperty => !Array.isArray(property) && property.type === 'SoftObjectArrayProperty';\n\nexport type SoftObjectArrayProperty = AbstractBaseProperty & {\n    type: 'SoftObjectArrayProperty';\n    subtype: string;\n    values: SoftObjectReference[];\n};\n\nexport namespace SoftObjectArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): SoftObjectArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => SoftObjectProperty.ReadValue(reader));\n        return {\n            type: 'SoftObjectArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies SoftObjectArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: SoftObjectArrayProperty): void => {\n        property.values.forEach(value => SoftObjectProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+export declare const isStrArrayProperty: (property: any) => property is StrArrayProperty;
+export type StrArrayProperty = AbstractBaseProperty & {
+    type: 'StrArrayProperty';
+    subtype: string;
+    values: string[];
+};
+export declare namespace StrArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => StrArrayProperty;
+    const Serialize: (writer: ByteWriter, property: StrArrayProperty) => void;
+}
+//# sourceMappingURL=StrArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAG/D,eAAO,MAAM,kBAAkB,aAAc,GAAG,KAAG,QAAQ,IAAI,gBAAoF,CAAC;AAEpJ,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG;IAClD,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,yBAAiB,gBAAgB,CAAC;IAEvB,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,gBAWxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,gBAAgB,KAAG,IAE1E,CAAA;CACJ"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrArrayProperty = exports.isStrArrayProperty = void 0;
+const StrProperty_1 = require("../StrProperty");
+const isStrArrayProperty = (property) => !Array.isArray(property) && property.type === 'StrArrayProperty';
+exports.isStrArrayProperty = isStrArrayProperty;
+var StrArrayProperty;
+(function (StrArrayProperty) {
+    StrArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const values = new Array(elementCount).fill(0).map(() => StrProperty_1.StrProperty.ReadValue(reader));
+        return {
+            type: 'StrArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    StrArrayProperty.Serialize = (writer, property) => {
+        property.values.forEach(value => StrProperty_1.StrProperty.SerializeValue(writer, value));
+    };
+})(StrArrayProperty || (exports.StrArrayProperty = StrArrayProperty = {}));
+//# sourceMappingURL=StrArrayProperty.js.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrArrayProperty.js","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/StrArrayProperty.ts"],"names":[],"mappings":";;;AAGA,gDAA6C;AAEtC,MAAM,kBAAkB,GAAG,CAAC,QAAa,EAAgC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,KAAK,kBAAkB,CAAC;AAAvI,QAAA,kBAAkB,sBAAqH;AAQpJ,IAAiB,gBAAgB,CAkBhC;AAlBD,WAAiB,gBAAgB;IAEhB,sBAAK,GAAG,CAAC,MAAsB,EAAE,YAAoB,EAAE,OAAe,EAAE,MAAc,EAAE,QAAgB,CAAC,EAAoB,EAAE;QACxI,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,yBAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QACxF,OAAO;YACH,IAAI,EAAE,kBAAkB;YACxB,KAAK;YACL,MAAM;YACN,OAAO;YACP,MAAM;YACN,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,EAAE;SACgB,CAAC;IACjC,CAAC,CAAA;IAEY,0BAAS,GAAG,CAAC,MAAkB,EAAE,QAA0B,EAAQ,EAAE;QAC9E,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,yBAAW,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAChF,CAAC,CAAA;AACL,CAAC,EAlBgB,gBAAgB,gCAAhB,gBAAgB,QAkBhC","sourcesContent":["import { BinaryReadable } from '../../../../../byte/binary-readable.interface';\nimport { ByteWriter } from '../../../../../byte/byte-writer.class';\nimport { AbstractBaseProperty } from '../AbstractBaseProperty';\nimport { StrProperty } from '../StrProperty';\n\nexport const isStrArrayProperty = (property: any): property is StrArrayProperty => !Array.isArray(property) && property.type === 'StrArrayProperty';\n\nexport type StrArrayProperty = AbstractBaseProperty & {\n    type: 'StrArrayProperty';\n    subtype: string;\n    values: string[];\n};\n\nexport namespace StrArrayProperty {\n\n    export const Parse = (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index: number = 0): StrArrayProperty => {\n        const values = new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader));\n        return {\n            type: 'StrArrayProperty',\n            index,\n            ueType,\n            subtype,\n            values,\n            guidInfo: undefined,\n            name: ''\n        } satisfies StrArrayProperty;\n    }\n\n    export const Serialize = (writer: ByteWriter, property: StrArrayProperty): void => {\n        property.values.forEach(value => StrProperty.SerializeValue(writer, value));\n    }\n}\n"]}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StructArrayProperty.d.ts

@@ -0,0 +1,26 @@
+import { BinaryReadable } from '../../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../../structs/GUIDInfo';
+import { AbstractBaseProperty } from '../AbstractBaseProperty';
+import { StructProperty } from '../StructProperty';
+export declare const isStructArrayProperty: (property: any) => property is StructArrayProperty;
+export type StructArrayProperty = AbstractBaseProperty & {
+    type: 'StructArrayProperty';
+    subtype: string;
+    values: StructProperty[];
+    structValueFields: ArrayPropertyStructValueFields;
+};
+export declare namespace StructArrayProperty {
+    const Parse: (reader: BinaryReadable, elementCount: number, subtype: string, ueType: string, index?: number) => StructArrayProperty;
+    const Serialize: (writer: ByteWriter, property: StructArrayProperty) => void;
+}
+export type ArrayPropertyStructValueFields = {
+    allStructType: string;
+    allIndex?: number;
+    allGuid: GUIDInfo;
+    allUnk1?: number;
+    allUnk2?: number;
+    allUnk3?: number;
+    allUnk4?: number;
+};
+//# sourceMappingURL=StructArrayProperty.d.ts.map

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StructArrayProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructArrayProperty.d.ts","sourceRoot":"","sources":["../../../../../../../src/parser/satisfactory/types/property/generic/ArrayProperty/StructArrayProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,eAAO,MAAM,qBAAqB,aAAc,GAAG,KAAG,QAAQ,IAAI,mBAA0F,CAAC;AAE7J,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG;IACrD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,iBAAiB,EAAE,8BAA8B,CAAC;CACrD,CAAC;AAEF,yBAAiB,mBAAmB,CAAC;IAE1B,MAAM,KAAK,WAAY,cAAc,gBAAgB,MAAM,WAAW,MAAM,UAAU,MAAM,UAAS,MAAM,KAAO,mBAuDxH,CAAA;IAEM,MAAM,SAAS,WAAY,UAAU,YAAY,mBAAmB,KAAG,IAmB7E,CAAA;CACJ;AAED,MAAM,MAAM,8BAA8B,GAAG;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,QAAQ,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/build/parser/satisfactory/types/property/generic/ArrayProperty/StructArrayProperty.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructArrayProperty = exports.isStructArrayProperty = void 0;
+const GUIDInfo_1 = require("../../../structs/GUIDInfo");
+const StructProperty_1 = require("../StructProperty");
+const isStructArrayProperty = (property) => !Array.isArray(property) && property.type === 'StructArrayProperty';
+exports.isStructArrayProperty = isStructArrayProperty;
+var StructArrayProperty;
+(function (StructArrayProperty) {
+    StructArrayProperty.Parse = (reader, elementCount, subtype, ueType, index = 0) => {
+        const name = reader.readString();
+        const allUEType = reader.readString();
+        const binarySize = reader.readInt32();
+        const allIndex = reader.readInt32();
+        const allStructType = reader.readString();
+        const allGuid = GUIDInfo_1.GUIDInfo.read(reader);
+        const allUnk1 = reader.readInt32();
+        const allUnk2 = reader.readInt32();
+        const allUnk3 = reader.readInt32();
+        const allUnk4 = reader.readInt32();
+        const structValueFields = { allStructType, allIndex: allIndex > 0 ? allIndex : undefined, allGuid };
+        if (allUnk1 !== 0) {
+            structValueFields.allUnk1 = allUnk1;
+        }
+        if (allUnk2 !== 0) {
+            structValueFields.allUnk2 = allUnk2;
+        }
+        if (allUnk3 !== 0) {
+            structValueFields.allUnk3 = allUnk3;
+        }
+        if (allUnk4 !== 0) {
+            structValueFields.allUnk4 = allUnk4;
+        }
+        const before = reader.getBufferPosition();
+        const values = new Array(elementCount).fill(0).map(() => {
+            const struct = new StructProperty_1.StructProperty(allStructType, allUEType, 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.');
+        }
+        return {
+            type: 'StructArrayProperty',
+            index,
+            ueType,
+            subtype,
+            values,
+            structValueFields,
+            guidInfo: undefined,
+            name: ''
+        };
+    };
+    StructArrayProperty.Serialize = (writer, property) => {
+        writer.writeString(property.name);
+        writer.writeString(property.subtype);
+        const lenIndicator = writer.getBufferPosition();
+        writer.writeInt32(0);
+        writer.writeInt32(property.structValueFields.allIndex ?? 0);
+        writer.writeString(property.structValueFields.allStructType);
+        GUIDInfo_1.GUIDInfo.write(writer, property.structValueFields.allGuid);
+        writer.writeInt32(property.structValueFields.allUnk1 ?? 0);
+        writer.writeInt32(property.structValueFields.allUnk2 ?? 0);
+        writer.writeInt32(property.structValueFields.allUnk3 ?? 0);
+        writer.writeInt32(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);
+    };
+})(StructArrayProperty || (exports.StructArrayProperty = StructArrayProperty = {}));
+//# sourceMappingURL=StructArrayProperty.js.map