@etothepii/satisfactory-file-parser 0.0.31 → 0.0.33

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

@@ -1,14 +1,19 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { DataFields } from "./DataFields";
-export declare abstract class SaveObject {
+export interface SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+}
+export declare abstract class SaveObject implements SaveObjectHeader {
     typePath: string;
     rootObject: string;
     instanceName: string;
     dataFields: DataFields;
     constructor(typePath: string, rootObject: string, instanceName: string);
-    protected static ParseHeader(reader: ByteReader, obj: SaveObject): void;
+    protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
     protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
-    static ParseData(obj: SaveObject, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseData(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
     static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
 }

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

@@ -28,11 +28,11 @@
             writer.writeString(obj.rootObject);
             writer.writeString(obj.instanceName);
         }
-        static ParseData(obj, length, reader, buildVersion) {
-            obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion);
+        static ParseData(obj, length, reader, buildVersion, typePath) {
+            obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion, typePath);
         }
         static SerializeData(writer, obj, buildVersion) {
-            DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion);
+            DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion, obj.typePath);
         }
     }
     exports.SaveObject = SaveObject;

package/build/parser/satisfactory/save/asynchronous-level.class.d.ts

@@ -0,0 +1,9 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
+import { SaveObject } from "../objects/SaveObject";
+import { Level } from "./level.class";
+import { SaveReader } from "./save-reader";
+export declare class AsynchronousLevel {
+    static StreamReadObjectContents(reader: ByteReader, objectsList: SaveObject[], buildVersion: number, writer: SaveStreamWriter, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
+    static StreamReadLevel(reader: SaveReader, levelName: string, buildVersion: number, writer: SaveStreamWriter): Promise<Level>;
+}

package/build/parser/satisfactory/save/asynchronous-level.class.js

@@ -0,0 +1,76 @@
+(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", "../objects/SaveComponent", "../objects/SaveEntity", "./level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsynchronousLevel = void 0;
+    const SaveComponent_1 = require("../objects/SaveComponent");
+    const SaveEntity_1 = require("../objects/SaveEntity");
+    const level_class_1 = require("./level.class");
+    class AsynchronousLevel {
+        static async StreamReadObjectContents(reader, objectsList, buildVersion, writer, onProgressCallback) {
+            const binarySize = reader.readInt32();
+            const posBefore = reader.getBufferPosition();
+            await reader.allocate(binarySize);
+            const countEntities = reader.readInt32();
+            if (countEntities !== objectsList.length) {
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
+            }
+            let dynamicObjectBatch = [];
+            for (let i = 0; i < countEntities; i++) {
+                if (i % 1000 === 0) {
+                    console.log(`having some objects, writing ${i + 1}/${countEntities}.`);
+                    onProgressCallback(reader.getBufferProgress());
+                    await writer.writeObjects(...dynamicObjectBatch);
+                    dynamicObjectBatch = [];
+                }
+                const len = reader.readInt32();
+                const before = reader.getBufferPosition();
+                if (len < reader.getAmountAllocatedLeft()) {
+                    await reader.allocate(Math.max(before - binarySize, 300 * 1000 * 1000));
+                }
+                const obj = objectsList[i];
+                if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                dynamicObjectBatch.push(obj);
+                const after = reader.getBufferPosition();
+                if (after - before !== len) {
+                    console.warn('entity may be corrupt', this.name, i);
+                }
+            }
+            await writer.writeObjects(...dynamicObjectBatch);
+            const posAfter = reader.getBufferPosition();
+            if (posAfter - posBefore !== binarySize) {
+                console.warn('save seems corrupt.', this.name);
+            }
+        }
+        static async StreamReadLevel(reader, levelName, buildVersion, writer) {
+            const level = new level_class_1.Level(levelName);
+            const binaryLength = reader.readInt32();
+            await reader.allocate(binaryLength);
+            await writer.openLevel(levelName);
+            level_class_1.Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level.collectables = level_class_1.Level.ReadCollectablesList(reader);
+            console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
+            await AsynchronousLevel.StreamReadObjectContents(reader, level.objects, buildVersion, writer, reader.onProgressCallback);
+            await writer.switchInLevelToCollectables();
+            await writer.writeCollectables(...level.collectables);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level_class_1.Level.ReadCollectablesList(reader);
+            await writer.endLevel();
+            return level;
+        }
+    }
+    exports.AsynchronousLevel = AsynchronousLevel;
+});

package/build/parser/satisfactory/save/level.class.d.ts

@@ -1,4 +1,4 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { ObjectReference } from "../objects/ObjectReference";
 import { SaveComponent } from "../objects/SaveComponent";
@@ -12,10 +12,10 @@ export declare class Level {
     constructor(name: string);
     static SerializeObjectHeaders(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
     static WriteLevel(writer: ByteWriter, level: Level, buildVersion: number): void;
-    static SerializeObjectContents(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[], buildVersion: number): void;
-    static ReadObjectHeaders(reader: ByteReader, objectsList: SaveObject[], onProgressCallback: (progress: number, msg?: string) => void): void;
-    static ReadObjectContents(reader: ByteReader, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): void;
+    static SerializeObjectContents(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[], buildVersion: number, levelName: string): void;
+    static ReadObjectHeaders(reader: BinaryReadable, objectsList: SaveObject[], onProgressCallback: (progress: number, msg?: string) => void): void;
+    static ReadObjectContents(reader: BinaryReadable, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
     static ReadLevel(reader: SaveReader, levelName: string, buildVersion: number): Level;
     static SerializeCollectablesList(writer: ByteWriter, collectables: ObjectReference[]): void;
-    static ReadCollectablesList(reader: SaveReader): ObjectReference[];
+    static ReadCollectablesList(reader: BinaryReadable): ObjectReference[];
 }

package/build/parser/satisfactory/save/level.class.js

@@ -43,10 +43,10 @@
             Level.SerializeObjectHeaders(writer, level.objects);
             Level.SerializeCollectablesList(writer, level.collectables);
             writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
-            Level.SerializeObjectContents(writer, level.objects, buildVersion);
+            Level.SerializeObjectContents(writer, level.objects, buildVersion, level.name);
             Level.SerializeCollectablesList(writer, level.collectables);
         }
-        static SerializeObjectContents(writer, objects, buildVersion) {
+        static SerializeObjectContents(writer, objects, buildVersion, levelName) {
             const lenIndicatorEntities = writer.getBufferPosition();
             writer.writeInt32(0);
             writer.writeInt32(objects.length);
@@ -87,12 +87,12 @@
                 }
             }
         }
-        static ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
+        static async ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
             const binarySize = reader.readInt32();
             const posBefore = reader.getBufferPosition();
             const countEntities = reader.readInt32();
             if (countEntities !== objectsList.length) {
-                throw new Error(`possibly corrupt. entity content count ${countEntities} does not object count of ${objectsList.length}`);
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
             }
             for (let i = 0; i < countEntities; i++) {
                 if (i % 1000 === 0) {
@@ -102,10 +102,10 @@
                 const before = reader.getBufferPosition();
                 const obj = objectsList[i];
                 if ((0, SaveEntity_1.isSaveEntity)(obj)) {
-                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion);
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
                 }
                 else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
-                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion);
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
                 }
                 const after = reader.getBufferPosition();
                 if (after - before !== len) {

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

@@ -1,9 +1,9 @@
 import { ByteReader } from "../../byte/byte-reader.class";
 import { ChunkCompressionInfo } from "../../file.types";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
 import { ObjectReference } from "../objects/ObjectReference";
 import { SaveComponent } from "../objects/SaveComponent";
 import { SaveEntity } from "../objects/SaveEntity";
-import { SaveObject } from "../objects/SaveObject";
 import { Level } from "./level.class";
 import { SatisfactorySaveHeader } from "./save.types";
 export type EntityPathFilter = {
@@ -15,6 +15,8 @@ export type SaveProjectionConfig = {
     includeComponents: boolean;
 };
 export declare const projectionFilterApplies: (config: SaveProjectionConfig, object: SaveComponent | SaveEntity) => boolean;
+export type ReadMode = 'stream' | 'whole';
+export declare const DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
 export declare class SaveReader extends ByteReader {
     onProgressCallback: (progress: number, msg?: string) => void;
     header: SatisfactorySaveHeader | undefined;
@@ -29,16 +31,5 @@ export declare class SaveReader extends ByteReader {
         numChunks: number;
     };
     readLevels(): Level[];
-}
-export declare class Conveyor {
-    static getConveyorBeltRegex(): RegExp;
-    static getConveyorLiftRegex(): RegExp;
-    static isAConveyorBelt(obj: SaveObject): boolean;
-    static isAConveyorLift(obj: SaveObject): boolean;
-    static get availableConnections(): string[];
-    static get availableConveyorBelts(): string[];
-    static get availableConveyorLifts(): string[];
-    static isConveyor(currentObject: any): boolean;
-    static isConveyorBelt(currentObject: any): boolean;
-    static isConveyorLift(currentObject: any): boolean;
+    readLevelsAsynchronously(writer: SaveStreamWriter): Promise<Level[]>;
 }

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

@@ -7,18 +7,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         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", "../objects/SaveComponent", "../objects/SaveEntity", "./level.class"], factory);
+        define(["require", "exports", "pako", "../../byte/alignment.enum", "../../byte/byte-reader.class", "../../error/parser.error", "../objects/SaveComponent", "../objects/SaveEntity", "./asynchronous-level.class", "./level.class"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Conveyor = exports.SaveReader = exports.projectionFilterApplies = void 0;
+    exports.SaveReader = exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = exports.projectionFilterApplies = 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 SaveComponent_1 = require("../objects/SaveComponent");
     const SaveEntity_1 = require("../objects/SaveEntity");
+    const asynchronous_level_class_1 = require("./asynchronous-level.class");
     const level_class_1 = require("./level.class");
     const projectionFilterApplies = (config, object) => {
         let cond1 = false;
@@ -38,6 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         return cond1 && cond2;
     };
     exports.projectionFilterApplies = projectionFilterApplies;
+    exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
     class SaveReader extends byte_reader_class_1.ByteReader {
         constructor(fileBuffer, onProgressCallback = () => { }) {
             super(fileBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
@@ -47,7 +49,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
             this.compressionInfo = {
                 packageFileTag: 0,
                 maxChunkContentSize: 0,
-                chunkHeaderSize: 48
+                chunkHeaderSize: exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
             };
         }
         readHeader() {
@@ -168,76 +170,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
             }
             return this.levels;
         }
-    }
-    SaveReader.EPOCH_TICKS = 621355968000000000n;
-    exports.SaveReader = SaveReader;
-    class Conveyor {
-        static getConveyorBeltRegex() {
-            return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorBeltMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
-        }
-        ;
-        static getConveyorLiftRegex() {
-            return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorLiftMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
-        }
-        ;
-        static isAConveyorBelt(obj) {
-            return obj.typePath.match(this.getConveyorBeltRegex()) !== null;
-        }
-        static isAConveyorLift(obj) {
-            return obj.typePath.match(this.getConveyorLiftRegex()) !== null;
-        }
-        static get availableConnections() { return ['.ConveyorAny0', '.ConveyorAny1', '.Input0', '.Input1', '.Input2', '.Input3', '.InPut3', '.Input4', '.Input5', '.Input6', '.Output0', '.Output1', '.Output2', '.Output3']; }
-        static get availableConveyorBelts() {
-            return [
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C'
-            ];
-        }
-        static get availableConveyorLifts() {
-            return [
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C'
-            ];
-        }
-        static isConveyor(currentObject) {
-            return Conveyor.isConveyorBelt(currentObject) || Conveyor.isConveyorLift(currentObject);
-        }
-        static isConveyorBelt(currentObject) {
-            if (Conveyor.availableConveyorBelts.includes(currentObject.className)) {
-                return true;
-            }
-            if (currentObject.className.startsWith('/Conveyors_Mod/Build_BeltMk')
-                || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_BeltMk')
-                || currentObject.className.startsWith('/UltraFastLogistics/Buildable/build_conveyorbeltMK')
-                || currentObject.className.startsWith('/FlexSplines/Conveyor/Build_Belt')
-                || currentObject.className.startsWith('/conveyorbeltmod/Belt/mk')
-                || currentObject.className.startsWith('/minerplus/content/buildable/Factory/belt_')
-                || currentObject.className.startsWith('/bamfp/content/buildable/Factory/belt_')) {
-                return true;
-            }
-            return false;
-        }
-        static isConveyorLift(currentObject) {
-            if (Conveyor.availableConveyorLifts.includes(currentObject.className)) {
-                return true;
-            }
-            if (currentObject.className.startsWith('/minerplus/content/buildable/Factory/lift')
-                || currentObject.className.startsWith('/bamfp/content/buildable/Factory/lift')
-                || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_LiftMk')
-                || currentObject.className.startsWith('/Conveyors_Mod/Build_LiftMk')
-                || currentObject.className.startsWith('/Game/CoveredConveyor')
-                || currentObject.className.startsWith('/CoveredConveyor')
-                || currentObject.className.startsWith('/conveyorbeltmod/lift/')) {
-                return true;
+        async readLevelsAsynchronously(writer) {
+            const numSubLevels = this.readInt32();
+            this.levels = new Array(numSubLevels + 1);
+            await writer.openLevels();
+            for (let j = 0; j <= numSubLevels; j++) {
+                let levelName = (j === numSubLevels) ? '' + this.header.mapName : this.readString();
+                this.onProgressCallback(this.getBufferProgress(), `reading level [${(j + 1)}/${(numSubLevels + 1)}] ${levelName}`);
+                this.levels[j] = await asynchronous_level_class_1.AsynchronousLevel.StreamReadLevel(this, levelName, this.header.buildVersion, writer);
             }
-            return false;
+            await writer.endLevels();
+            return this.levels;
         }
     }
-    exports.Conveyor = Conveyor;
+    SaveReader.EPOCH_TICKS = 621355968000000000n;
+    exports.SaveReader = SaveReader;
 });

package/build/parser/satisfactory/structs/util.types.d.ts

@@ -1,4 +1,4 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 export type col4 = {
     r: number;
@@ -7,13 +7,13 @@ export type col4 = {
     a: number;
 };
 export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4RGBA: (reader: ByteReader) => col4;
+export declare const ParseCol4RGBA: (reader: BinaryReadable) => col4;
 export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4BGRA: (reader: ByteReader) => col4;
+export declare const ParseCol4BGRA: (reader: BinaryReadable) => col4;
 export type vec4 = vec3 & {
     w: number;
 };
-export declare const ParseVec4: (reader: ByteReader) => vec4;
+export declare const ParseVec4: (reader: BinaryReadable) => vec4;
 export declare const SerializeVec4: (writer: ByteWriter, vec: vec4) => void;
 export declare const sub: (other: vec3, vec: vec3) => vec3;
 export declare const add: (vec: vec3, other: vec3) => vec3;
@@ -23,18 +23,18 @@ export declare const norm: (vec: vec3) => vec3;
 export type vec3 = vec2 & {
     z: number;
 };
-export declare const ParseVec3: (reader: ByteReader) => vec3;
+export declare const ParseVec3: (reader: BinaryReadable) => vec3;
 export declare const SerializeVec3: (writer: ByteWriter, vec: vec3) => void;
 export type vec2 = {
     x: number;
     y: number;
 };
-export declare const ParseVec2: (reader: ByteReader) => vec2;
+export declare const ParseVec2: (reader: BinaryReadable) => vec2;
 export declare const SerializeVec2: (writer: ByteWriter, vec: vec2) => void;
 export type Transform = {
     rotation: vec4;
     translation: vec3;
     scale3d: vec3;
 };
-export declare const ParseTransform: (reader: ByteReader) => Transform;
+export declare const ParseTransform: (reader: BinaryReadable) => Transform;
 export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;

package/build/parser/satisfactory/structs/util.types.js

@@ -19,10 +19,10 @@
     exports.SerializeCol4RGBA = SerializeCol4RGBA;
     const ParseCol4RGBA = (reader) => {
         return {
-            r: reader.readFloat(),
-            g: reader.readFloat(),
-            b: reader.readFloat(),
-            a: reader.readFloat(),
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32(),
+            a: reader.readFloat32(),
         };
     };
     exports.ParseCol4RGBA = ParseCol4RGBA;
@@ -44,8 +44,8 @@
     exports.ParseCol4BGRA = ParseCol4BGRA;
     const ParseVec4 = (reader) => {
         return {
-            ...(0, exports.ParseVec3)(reader),
-            w: reader.readFloat()
+            ...((0, exports.ParseVec3)(reader)),
+            w: reader.readFloat32()
         };
     };
     exports.ParseVec4 = ParseVec4;
@@ -66,8 +66,8 @@
     exports.norm = norm;
     const ParseVec3 = (reader) => {
         return {
-            ...(0, exports.ParseVec2)(reader),
-            z: reader.readFloat()
+            ...((0, exports.ParseVec2)(reader)),
+            z: reader.readFloat32()
         };
     };
     exports.ParseVec3 = ParseVec3;
@@ -78,8 +78,8 @@
     exports.SerializeVec3 = SerializeVec3;
     const ParseVec2 = (reader) => {
         return {
-            x: reader.readFloat(),
-            y: reader.readFloat(),
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
         };
     };
     exports.ParseVec2 = ParseVec2;

package/build/parser/stream/byte-stream-reader.class.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { ReadableStreamDefaultReader } from "stream/web";
+import { Alignment } from "../byte/alignment.enum";
+import { BinaryReadable } from "../byte/binary-readable.interface";
+export interface StreamBinaryReadable extends BinaryReadable {
+    pause: () => void;
+    resume: () => void;
+    hasInput: () => boolean;
+}
+export declare abstract class ByteStreamReader implements StreamBinaryReadable {
+    private reader;
+    onCloseCallback: () => Promise<void>;
+    private timeout;
+    maxBufferThreshold: number;
+    alignment: Alignment;
+    protected operatingStreamBuffer: Uint8Array;
+    protected operatingDataView: DataView;
+    protected callbackAfterRead: undefined | (() => void);
+    protected currentByte: number;
+    protected inputStreamIsDone: boolean;
+    protected paused: boolean;
+    debug: boolean;
+    protected closedAlready: boolean;
+    protected neededNextAmountOfBytes: number;
+    private readLoopHandle;
+    private waitingTimeoutHandle;
+    protected totalNumberOfBytesRead: number;
+    protected trailingBufferSize: number;
+    constructor(reader: ReadableStreamDefaultReader<Uint8Array>, onCloseCallback: () => Promise<void>, timeout?: number, maxBufferThreshold?: number, alignment?: Alignment);
+    pause(): void;
+    resume(): void;
+    hasInput(): boolean;
+    close(): Promise<void>;
+    protected continuousRead: () => Promise<void>;
+    allocate(count: number): Promise<void>;
+    private waitUntilNumBytesAvailable;
+    skipBytes(byteLength?: number): void;
+    readByte(): number;
+    readBytes(count: number): Uint8Array;
+    readHex(hexLength: number): string;
+    readInt8(): number;
+    readUint8(): number;
+    readInt16(): number;
+    readUint16(): number;
+    readInt32(): number;
+    readUint32(): number;
+    readLong(): bigint;
+    readInt64(): bigint;
+    readUint64(): bigint;
+    readFloat32(): number;
+    readDouble(): number;
+    readString(): string;
+    getBufferPosition(): number;
+    getBufferProgress(): number;
+    getBufferLength(): number;
+    getAmountAllocatedLeft(): number;
+}