@etothepii/satisfactory-file-parser 0.0.30 → 0.0.32

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

@@ -0,0 +1,188 @@
+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", "../objects/SaveComponent", "../objects/SaveEntity", "./asynchronous-level.class", "./level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    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;
+        if ((0, SaveEntity_1.isSaveEntity)(object) || (config.includeComponents && (0, SaveComponent_1.isSaveComponent)(object))) {
+            cond1 = true;
+        }
+        let cond2 = true;
+        if ((0, SaveEntity_1.isSaveEntity)(object)) {
+            cond2 = false;
+            if (config.entityPathFilter.behavior === 'whitelist') {
+                cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) !== undefined;
+            }
+            else if (config.entityPathFilter.behavior === 'blacklist') {
+                cond2 = config.entityPathFilter.list.find(en => object.typePath.startsWith(en)) === undefined;
+            }
+        }
+        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);
+            this.onProgressCallback = onProgressCallback;
+            this.levels = [];
+            this.trailingCollectedObjects = [];
+            this.compressionInfo = {
+                packageFileTag: 0,
+                maxChunkContentSize: 0,
+                chunkHeaderSize: exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
+            };
+        }
+        readHeader() {
+            this.header = {
+                saveHeaderType: 0,
+                saveVersion: 0,
+                buildVersion: 0,
+                mapName: "DEFAULT",
+                mapOptions: "",
+                sessionName: "",
+                playDurationSeconds: 0,
+                saveDateTime: "0",
+                sessionVisibility: 0
+            };
+            this.header.saveHeaderType = this.readInt32();
+            this.header.saveVersion = this.readInt32();
+            this.header.buildVersion = this.readInt32();
+            this.header.mapName = this.readString();
+            this.header.mapOptions = this.readString();
+            this.header.sessionName = this.readString();
+            this.header.playDurationSeconds = this.readInt32();
+            const rawSaveDateTimeInTicks = this.readLong();
+            const unixMilliseconds = (rawSaveDateTimeInTicks - SaveReader.EPOCH_TICKS) / 10000n;
+            this.header.saveDateTime = unixMilliseconds.toString();
+            this.header.sessionVisibility = this.readByte();
+            if (this.header.saveHeaderType >= 7) {
+                this.header.fEditorObjectVersion = this.readInt32();
+            }
+            if (this.header.saveHeaderType >= 8) {
+                this.header.rawModMetadataString = this.readString();
+                try {
+                    this.header.modMetadata = JSON.parse(this.header.rawModMetadataString);
+                }
+                catch (error) {
+                }
+                this.header.isModdedSave = this.readInt32();
+            }
+            if (this.header.saveHeaderType >= 10) {
+                this.header.saveIdentifier = this.readString();
+            }
+            if (this.header.saveVersion >= 21) {
+            }
+            else {
+                throw new parser_error_1.UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
+            }
+            return this.header;
+        }
+        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.getInt32(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.CompressionLibraryError("Failed to inflate compressed save data. " + 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);
+            const dataLength = this.readInt32();
+            if (totalUncompressedBodySize !== dataLength + 4) {
+                throw new parser_error_1.CorruptSaveError(`Possibly corrupt. Indicated size of total save body (${dataLength}) does not match the uncompressed real size of ${totalUncompressedBodySize}.`);
+            }
+            return {
+                concatenatedChunkLength: newChunkLength,
+                numChunks: currentChunks.length
+            };
+        }
+        readLevels() {
+            if (!this.header) {
+                throw new parser_error_1.ParserError('ParserError', 'Header must be set before objects can be read.');
+            }
+            if (this.header.saveVersion < 29) {
+                throw new parser_error_1.UnsupportedVersionError('Support for < U6 is not yet implemented.');
+            }
+            const numSubLevels = this.readInt32();
+            this.levels = new Array(numSubLevels + 1);
+            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] = level_class_1.Level.ReadLevel(this, levelName, this.header.buildVersion);
+            }
+            if (this.getBufferPosition() < this.bufferView.byteLength) {
+                this.trailingCollectedObjects = level_class_1.Level.ReadCollectablesList(this);
+            }
+            return this.levels;
+        }
+        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);
+            }
+            await writer.endLevels();
+            return this.levels;
+        }
+    }
+    SaveReader.EPOCH_TICKS = 621355968000000000n;
+    exports.SaveReader = SaveReader;
+});

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

@@ -0,0 +1,12 @@
+import { Alignment } from "../../byte/alignment.enum";
+import { ByteWriter } from "../../byte/byte-writer.class";
+import { ChunkCompressionInfo, ChunkSummary } from "../../file.types";
+import { SatisfactorySave } from "./satisfactory-save";
+import { SatisfactorySaveHeader } from "./save.types";
+export declare class SaveWriter extends ByteWriter {
+    constructor();
+    static WriteHeader(writer: ByteWriter, header: SatisfactorySaveHeader): void;
+    static WriteLevels(writer: ByteWriter, save: SatisfactorySave, buildVersion: number): void;
+    static GenerateCompressedChunksFromData(bufferArray: ArrayBuffer, compressionInfo: ChunkCompressionInfo, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onChunk: (chunk: Uint8Array) => void, alignment?: Alignment): ChunkSummary[];
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
+}

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

@@ -0,0 +1,122 @@
+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-writer.class", "../../error/parser.error", "./level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveWriter = void 0;
+    const pako_1 = __importDefault(require("pako"));
+    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("./level.class");
+    class SaveWriter extends byte_writer_class_1.ByteWriter {
+        constructor() {
+            super(alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        }
+        static WriteHeader(writer, header) {
+            writer.writeInt32(header.saveHeaderType);
+            writer.writeInt32(header.saveVersion);
+            writer.writeInt32(header.buildVersion);
+            writer.writeString(header.mapName);
+            writer.writeString(header.mapOptions);
+            writer.writeString(header.sessionName);
+            writer.writeInt32(header.playDurationSeconds);
+            writer.writeInt64(BigInt(header.saveDateTime));
+            writer.writeByte(header.sessionVisibility);
+            if (header.saveHeaderType >= 7) {
+                writer.writeInt32(header.fEditorObjectVersion);
+            }
+            if (header.saveHeaderType >= 8) {
+                if (header.modMetadata) {
+                    writer.writeString(JSON.stringify(header.modMetadata));
+                }
+                else {
+                    writer.writeString(header.rawModMetadataString);
+                }
+                writer.writeInt32(header.isModdedSave);
+            }
+            if (header.saveHeaderType >= 10) {
+                writer.writeString(header.saveIdentifier);
+            }
+            if (header.saveVersion >= 21) {
+            }
+            else {
+                throw new parser_error_1.UnsupportedVersionError("The save version is too old to be supported currently.");
+            }
+        }
+        static WriteLevels(writer, save, buildVersion) {
+            writer.writeInt32(save.levels.length - 1);
+            for (const level of save.levels) {
+                if (level.name !== save.header.mapName) {
+                    writer.writeString(level.name);
+                }
+                level_class_1.Level.WriteLevel(writer, level, buildVersion);
+            }
+            level_class_1.Level.SerializeCollectablesList(writer, save.trailingCollectedObjects);
+        }
+        static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
+            const errors = [];
+            const totalUncompressedSize = bufferArray.byteLength;
+            const saveBody = new Uint8Array(bufferArray.byteLength + 4);
+            saveBody.set(new Uint8Array(bufferArray), 4);
+            const miniView = new DataView(saveBody.buffer);
+            miniView.setInt32(0, totalUncompressedSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            onBinaryBeforeCompressing(saveBody.buffer);
+            let handledByte = 0;
+            const chunkSummary = [];
+            while (handledByte < saveBody.byteLength) {
+                const uncompressedContentSize = Math.min(compressionInfo.maxChunkContentSize, saveBody.byteLength - handledByte);
+                const uncompressedChunk = saveBody.buffer.slice(handledByte, handledByte + uncompressedContentSize);
+                let compressedChunk = new Uint8Array(0);
+                try {
+                    compressedChunk = pako_1.default.deflate(uncompressedChunk);
+                }
+                catch (err) {
+                    throw new parser_error_1.CompressionLibraryError("Could not compress save data. " + err);
+                }
+                const chunk = new Uint8Array(compressionInfo.chunkHeaderSize + compressedChunk.byteLength);
+                chunk.set(compressedChunk, compressionInfo.chunkHeaderSize);
+                const view = new DataView(chunk.buffer);
+                view.setInt32(0, compressionInfo.packageFileTag, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(4, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(8, compressionInfo.maxChunkContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(12, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(16, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(20, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(24, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(28, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(32, compressedChunk.byteLength, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(36, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(40, uncompressedContentSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                view.setInt32(44, 0, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+                onChunk(chunk);
+                chunkSummary.push({
+                    uncompressedSize: uncompressedContentSize + compressionInfo.chunkHeaderSize,
+                    compressedSize: compressedChunk.byteLength + compressionInfo.chunkHeaderSize
+                });
+                handledByte += uncompressedContentSize;
+            }
+            return chunkSummary;
+        }
+        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 = SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, this.alignment);
+            return chunkSummary;
+        }
+    }
+    exports.SaveWriter = SaveWriter;
+});

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

@@ -0,0 +1,49 @@
+export interface ModData {
+    Reference: string;
+    Name: string;
+    Version: string;
+}
+export interface SatisfactoryModMetadata {
+    Mods: ModData[];
+}
+export interface SatisfactorySaveHeader {
+    saveHeaderType: number;
+    saveVersion: number;
+    buildVersion: number;
+    mapName: string;
+    mapOptions: string;
+    sessionName: string;
+    playDurationSeconds: number;
+    saveDateTime: string;
+    sessionVisibility: number;
+    rawModMetadataString?: string;
+    modMetadata?: SatisfactoryModMetadata;
+    isModdedSave?: number;
+    saveIdentifier?: string;
+    fEditorObjectVersion?: number;
+}
+export type ResourceNodeEntry = {
+    purity: string;
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type CollectibleEntry = {
+    pathName: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: string;
+};
+export type StaticData = {
+    collectibles: CollectibleEntry[];
+    artifacts: CollectibleEntry[];
+    slugs: CollectibleEntry[];
+    resourceNodes: ResourceNodeEntry[];
+};

package/build/parser/satisfactory/save/save.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/structs/util.types.d.ts

@@ -0,0 +1,40 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
+import { ByteWriter } from "../../byte/byte-writer.class";
+export type col4 = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4RGBA: (reader: BinaryReadable) => col4;
+export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
+export declare const ParseCol4BGRA: (reader: BinaryReadable) => col4;
+export type vec4 = vec3 & {
+    w: number;
+};
+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;
+export declare const length: (vec: vec3) => number;
+export declare const mult: (vec: vec3, scale: number) => vec3;
+export declare const norm: (vec: vec3) => vec3;
+export type vec3 = vec2 & {
+    z: number;
+};
+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: 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: BinaryReadable) => Transform;
+export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;

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

@@ -0,0 +1,105 @@
+(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.SerializeTransform = exports.ParseTransform = exports.SerializeVec2 = exports.ParseVec2 = exports.SerializeVec3 = exports.ParseVec3 = exports.norm = exports.mult = exports.length = exports.add = exports.sub = exports.SerializeVec4 = exports.ParseVec4 = exports.ParseCol4BGRA = exports.SerializeCol4BGRA = exports.ParseCol4RGBA = exports.SerializeCol4RGBA = void 0;
+    const SerializeCol4RGBA = (writer, value) => {
+        writer.writeFloat(value.r);
+        writer.writeFloat(value.g);
+        writer.writeFloat(value.b);
+        writer.writeFloat(value.a);
+    };
+    exports.SerializeCol4RGBA = SerializeCol4RGBA;
+    const ParseCol4RGBA = (reader) => {
+        return {
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32(),
+            a: reader.readFloat32(),
+        };
+    };
+    exports.ParseCol4RGBA = ParseCol4RGBA;
+    const SerializeCol4BGRA = (writer, value) => {
+        writer.writeByte(value.b);
+        writer.writeByte(value.g);
+        writer.writeByte(value.r);
+        writer.writeByte(value.a);
+    };
+    exports.SerializeCol4BGRA = SerializeCol4BGRA;
+    const ParseCol4BGRA = (reader) => {
+        return {
+            b: reader.readByte(),
+            g: reader.readByte(),
+            r: reader.readByte(),
+            a: reader.readByte(),
+        };
+    };
+    exports.ParseCol4BGRA = ParseCol4BGRA;
+    const ParseVec4 = (reader) => {
+        return {
+            ...((0, exports.ParseVec3)(reader)),
+            w: reader.readFloat32()
+        };
+    };
+    exports.ParseVec4 = ParseVec4;
+    const SerializeVec4 = (writer, vec) => {
+        (0, exports.SerializeVec3)(writer, vec);
+        writer.writeFloat(vec.w);
+    };
+    exports.SerializeVec4 = SerializeVec4;
+    const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+    exports.sub = sub;
+    const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+    exports.add = add;
+    const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+    exports.length = length;
+    const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+    exports.mult = mult;
+    const norm = (vec) => (0, exports.mult)(vec, 1. / (0, exports.length)(vec));
+    exports.norm = norm;
+    const ParseVec3 = (reader) => {
+        return {
+            ...((0, exports.ParseVec2)(reader)),
+            z: reader.readFloat32()
+        };
+    };
+    exports.ParseVec3 = ParseVec3;
+    const SerializeVec3 = (writer, vec) => {
+        (0, exports.SerializeVec2)(writer, vec);
+        writer.writeFloat(vec.z);
+    };
+    exports.SerializeVec3 = SerializeVec3;
+    const ParseVec2 = (reader) => {
+        return {
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
+        };
+    };
+    exports.ParseVec2 = ParseVec2;
+    const SerializeVec2 = (writer, vec) => {
+        writer.writeFloat(vec.x);
+        writer.writeFloat(vec.y);
+    };
+    exports.SerializeVec2 = SerializeVec2;
+    const ParseTransform = (reader) => {
+        return {
+            rotation: (0, exports.ParseVec4)(reader),
+            translation: (0, exports.ParseVec3)(reader),
+            scale3d: (0, exports.ParseVec3)(reader),
+        };
+    };
+    exports.ParseTransform = ParseTransform;
+    const SerializeTransform = (writer, transform) => {
+        (0, exports.SerializeVec4)(writer, transform.rotation);
+        (0, exports.SerializeVec3)(writer, transform.translation);
+        (0, exports.SerializeVec3)(writer, transform.scale3d);
+    };
+    exports.SerializeTransform = SerializeTransform;
+});

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;
+}