@etothepii/satisfactory-file-parser 0.0.31 → 0.0.33

package/build/parser/stream/byte-stream-reader.class.js

@@ -0,0 +1,251 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../byte/alignment.enum", "../byte/byte-writer.class", "../error/parser.error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ByteStreamReader = void 0;
+    const alignment_enum_1 = require("../byte/alignment.enum");
+    const byte_writer_class_1 = require("../byte/byte-writer.class");
+    const parser_error_1 = require("../error/parser.error");
+    class ByteStreamReader {
+        constructor(reader, onCloseCallback, timeout = 30000, maxBufferThreshold = 100 * 1000 * 1000, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
+            this.reader = reader;
+            this.onCloseCallback = onCloseCallback;
+            this.timeout = timeout;
+            this.maxBufferThreshold = maxBufferThreshold;
+            this.alignment = alignment;
+            this.debug = false;
+            this.closedAlready = false;
+            this.totalNumberOfBytesRead = 0;
+            this.trailingBufferSize = 0;
+            this.continuousRead = async () => {
+                while (!this.inputStreamIsDone && !this.paused) {
+                    const { done, value } = await this.reader.read();
+                    if (!this.inputStreamIsDone) {
+                        if (value) {
+                            const trailingPos = Math.max(0, this.currentByte - this.trailingBufferSize);
+                            this.operatingStreamBuffer = new Uint8Array(byte_writer_class_1.ByteWriter.AppendBuffer(this.operatingStreamBuffer.slice(trailingPos), value));
+                            this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
+                            this.currentByte = Math.min(this.currentByte, this.trailingBufferSize);
+                            if (this.operatingStreamBuffer.byteLength > this.maxBufferThreshold) {
+                                console.warn('pausing due to size.');
+                                this.pause();
+                            }
+                            if (this.callbackAfterRead) {
+                                this.callbackAfterRead();
+                            }
+                        }
+                    }
+                    else {
+                        this.close();
+                    }
+                    this.inputStreamIsDone = done;
+                }
+            };
+            this.operatingStreamBuffer = new Uint8Array();
+            this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
+            this.inputStreamIsDone = false;
+            this.currentByte = 0;
+            this.neededNextAmountOfBytes = 0;
+            this.paused = false;
+            this.trailingBufferSize = 2000;
+            this.readLoopHandle = setTimeout(this.continuousRead);
+            this.waitingTimeoutHandle = undefined;
+        }
+        pause() {
+            this.paused = true;
+            clearTimeout(this.readLoopHandle);
+            this.readLoopHandle = undefined;
+            if (this.waitingTimeoutHandle) {
+                clearTimeout(this.waitingTimeoutHandle);
+                this.waitingTimeoutHandle = undefined;
+            }
+        }
+        resume() {
+            if (this.paused) {
+                this.paused = false;
+                this.readLoopHandle = setTimeout(this.continuousRead);
+            }
+        }
+        hasInput() {
+            return !this.inputStreamIsDone;
+        }
+        async close() {
+            this.inputStreamIsDone = true;
+            this.pause();
+            await this.onCloseCallback();
+            this.closedAlready = true;
+        }
+        async allocate(count) {
+            if (count > this.maxBufferThreshold * 0.5) {
+                console.warn(`you are waiting for a very big chunk here mate. ${count} bytes. U sure you have your numbers right?`);
+            }
+            if (this.getAmountAllocatedLeft() < count) {
+                if (this.inputStreamIsDone) {
+                    throw new parser_error_1.CorruptSaveError('Input Stream has finished before needed data was received.');
+                }
+                if (this.paused) {
+                    this.resume();
+                }
+                await this.waitUntilNumBytesAvailable(count);
+            }
+        }
+        waitUntilNumBytesAvailable(count) {
+            this.neededNextAmountOfBytes = count;
+            return new Promise((resolve, reject) => {
+                if (this.getAmountAllocatedLeft() >= this.neededNextAmountOfBytes) {
+                    this.neededNextAmountOfBytes = 0;
+                    return resolve();
+                }
+                this.callbackAfterRead = () => {
+                    if (this.getAmountAllocatedLeft() >= this.neededNextAmountOfBytes) {
+                        if (this.waitingTimeoutHandle) {
+                            clearTimeout(this.waitingTimeoutHandle);
+                        }
+                        this.neededNextAmountOfBytes = 0;
+                        this.callbackAfterRead = undefined;
+                        return resolve();
+                    }
+                };
+                if (this.waitingTimeoutHandle) {
+                    clearTimeout(this.waitingTimeoutHandle);
+                }
+                this.waitingTimeoutHandle = setTimeout(() => {
+                    if (!this.inputStreamIsDone) {
+                        reject(new parser_error_1.TimeoutError(`Timed out before ${this.neededNextAmountOfBytes} bytes were available to read next.`));
+                    }
+                    return resolve();
+                }, this.timeout);
+            });
+        }
+        skipBytes(byteLength = 1) {
+            this.currentByte += byteLength;
+            this.totalNumberOfBytesRead += byteLength;
+            return;
+        }
+        readByte() {
+            this.totalNumberOfBytesRead += 1;
+            return this.operatingDataView.getUint8(this.currentByte++);
+        }
+        readBytes(count) {
+            this.totalNumberOfBytesRead += count;
+            return new Uint8Array(new Array(count).fill(0).map(pl => this.operatingDataView.getUint8(this.currentByte++)));
+        }
+        readHex(hexLength) {
+            let hexPart = [];
+            for (let i = 0; i < hexLength; i++) {
+                let currentHex = String.fromCharCode(this.operatingDataView.getUint8(this.currentByte++));
+                hexPart.push(currentHex);
+            }
+            this.totalNumberOfBytesRead += hexLength;
+            return hexPart.join('');
+        }
+        readInt8() {
+            this.totalNumberOfBytesRead += 1;
+            let data = this.operatingDataView.getInt8(this.currentByte++);
+            return data;
+        }
+        readUint8() {
+            this.totalNumberOfBytesRead += 1;
+            let data = this.operatingDataView.getUint8(this.currentByte++);
+            return data;
+        }
+        readInt16() {
+            this.totalNumberOfBytesRead += 2;
+            let data = this.operatingDataView.getInt16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 2;
+            return data;
+        }
+        readUint16() {
+            this.totalNumberOfBytesRead += 2;
+            let data = this.operatingDataView.getUint16(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 2;
+            return data;
+        }
+        readInt32() {
+            this.totalNumberOfBytesRead += 4;
+            let data = this.operatingDataView.getInt32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+            return data;
+        }
+        readUint32() {
+            this.totalNumberOfBytesRead += 4;
+            let data = this.operatingDataView.getUint32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+            return data;
+        }
+        readLong() {
+            this.totalNumberOfBytesRead += 8;
+            let data = this.operatingDataView.getBigInt64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+            return data;
+        }
+        readInt64() {
+            return this.readLong();
+        }
+        readUint64() {
+            this.totalNumberOfBytesRead += 8;
+            let data = this.operatingDataView.getBigUint64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+            return data;
+        }
+        readFloat32() {
+            this.totalNumberOfBytesRead += 4;
+            let data = this.operatingDataView.getFloat32(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 4;
+            return data;
+        }
+        readDouble() {
+            this.totalNumberOfBytesRead += 8;
+            let data = this.operatingDataView.getFloat64(this.currentByte, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte += 8;
+            return data;
+        }
+        readString() {
+            let strLength = this.readInt32();
+            if (strLength === 0) {
+                return '';
+            }
+            if (strLength > (this.operatingDataView.buffer.byteLength - this.currentByte)) {
+                let errorMessage = `Cannot read string of length ${strLength} at position ${this.currentByte} as it exceeds the end at ${this.operatingDataView.buffer.byteLength}`;
+                throw new Error(errorMessage);
+            }
+            if (strLength < 0) {
+                const string = new Array(-strLength - 1).fill('').map(c => String.fromCharCode(this.readUint16()));
+                this.currentByte += 2;
+                this.totalNumberOfBytesRead += 2;
+                return string.join('');
+            }
+            try {
+                const string = new Array(strLength - 1).fill('').map(c => String.fromCharCode(this.readUint8()));
+                this.currentByte += 1;
+                this.totalNumberOfBytesRead += 1;
+                return string.join('');
+            }
+            catch (error) {
+                let errorMessage = `Cannot read UTF8 string of length ${strLength} at position ${this.currentByte}.`;
+                console.log(errorMessage, error);
+                throw error;
+            }
+        }
+        getBufferPosition() {
+            return this.totalNumberOfBytesRead;
+        }
+        getBufferProgress() {
+            throw new parser_error_1.UnimplementedError();
+        }
+        getBufferLength() {
+            return this.operatingStreamBuffer.byteLength;
+        }
+        getAmountAllocatedLeft() {
+            return this.operatingStreamBuffer.byteLength - this.currentByte;
+        }
+    }
+    exports.ByteStreamReader = ByteStreamReader;
+});

package/build/parser/stream/json-stream-state-writer.d.ts

@@ -0,0 +1,12 @@
+import { JsonStreamWritable } from "./json-stream-writable";
+export type Transition<S extends string> = {
+    name: string;
+    requiresOneOfThemToBeBefore: S[];
+    do: (...params: any[]) => Promise<void>;
+    assignOnFinish: S;
+};
+export declare abstract class JsonStreamStateWriter<S extends string> extends JsonStreamWritable {
+    private currentState;
+    constructor(pushWritable: (value: string) => Promise<void>, startState: S);
+    protected useTransition(transition: Transition<S>, ...params: any[]): Promise<void>;
+}

package/build/parser/stream/json-stream-state-writer.js

@@ -0,0 +1,28 @@
+(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", "./json-stream-writable"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JsonStreamStateWriter = void 0;
+    const json_stream_writable_1 = require("./json-stream-writable");
+    class JsonStreamStateWriter extends json_stream_writable_1.JsonStreamWritable {
+        constructor(pushWritable, startState) {
+            super(pushWritable);
+            this.currentState = startState;
+        }
+        async useTransition(transition, ...params) {
+            if (!transition.requiresOneOfThemToBeBefore.includes(this.currentState)) {
+                throw new Error(`Invalid command. Method ${transition.name} is not allowed to be called at this state.`);
+            }
+            await transition.do(...params);
+            this.currentState = transition.assignOnFinish;
+        }
+    }
+    exports.JsonStreamStateWriter = JsonStreamStateWriter;
+});

package/build/parser/stream/json-stream-writable.d.ts

@@ -0,0 +1,20 @@
+export declare abstract class JsonStreamWritable {
+    protected pushWritable: (value: string) => Promise<void>;
+    private openedSymbols;
+    private numberPropertiesInOpenedSymbol;
+    private currentPropertyOpen;
+    constructor(pushWritable: (value: string) => Promise<void>);
+    protected isValid: () => boolean;
+    private numPropertiesInCurrentOpenedSymbol;
+    protected startObject(): Promise<void>;
+    protected endObject(): Promise<void>;
+    protected startArray(): Promise<void>;
+    protected endArray(): Promise<void>;
+    protected writeProperty<T>(name: string, value: Promise<string>): Promise<void>;
+    protected writeProperties<T>(properties: {
+        name: string;
+        value: Promise<string>;
+    }[]): Promise<void>;
+    protected writePropertyName(name: string): Promise<void>;
+    protected writeValue<T>(value: Promise<string>): Promise<void>;
+}

package/build/parser/stream/json-stream-writable.js

@@ -0,0 +1,93 @@
+(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.JsonStreamWritable = void 0;
+    class JsonStreamWritable {
+        constructor(pushWritable) {
+            this.pushWritable = pushWritable;
+            this.isValid = () => this.openedSymbols.length === 0;
+            this.numPropertiesInCurrentOpenedSymbol = () => this.numberPropertiesInOpenedSymbol.length > 0 ? this.numberPropertiesInOpenedSymbol.at(-1) : 0;
+            this.openedSymbols = [];
+            this.numberPropertiesInOpenedSymbol = [];
+            this.currentPropertyOpen = false;
+        }
+        async startObject() {
+            await this.pushWritable('{');
+            this.openedSymbols.push('object');
+            this.numberPropertiesInOpenedSymbol.push(0);
+            this.currentPropertyOpen = false;
+            return;
+        }
+        async endObject() {
+            await this.pushWritable('}');
+            this.openedSymbols.splice(this.openedSymbols.lastIndexOf('object'), 1);
+            if (this.numberPropertiesInOpenedSymbol.length > 0) {
+                this.numberPropertiesInOpenedSymbol.splice(this.numberPropertiesInOpenedSymbol.length - 1, 1);
+            }
+            return;
+        }
+        async startArray() {
+            await this.pushWritable('[');
+            this.openedSymbols.push('array');
+            this.numberPropertiesInOpenedSymbol.push(0);
+            this.currentPropertyOpen = false;
+            return;
+        }
+        async endArray() {
+            this.pushWritable(']');
+            this.openedSymbols.splice(this.openedSymbols.lastIndexOf('array'), 1);
+            if (this.numberPropertiesInOpenedSymbol.length > 0) {
+                this.numberPropertiesInOpenedSymbol.splice(this.numberPropertiesInOpenedSymbol.length - 1, 1);
+            }
+            return;
+        }
+        async writeProperty(name, value) {
+            if (this.openedSymbols.length <= 0 || this.openedSymbols.at(-1) !== 'object' || this.currentPropertyOpen) {
+                throw new Error(`Json Write Method is not allowed for property ${name} here.`);
+            }
+            const prefix = this.numPropertiesInCurrentOpenedSymbol() > 0 ? ', ' : '';
+            await this.pushWritable(`${prefix}${name}: ${await value}`);
+            this.numberPropertiesInOpenedSymbol[this.numberPropertiesInOpenedSymbol.length - 1] += 1;
+            return;
+        }
+        async writeProperties(properties) {
+            if (this.currentPropertyOpen) {
+                throw new Error(`Json Write Method is not allowed, since currently a property value needs to be written.`);
+            }
+            for (const property of properties) {
+                await this.writeProperty(property.name, property.value);
+            }
+            return;
+        }
+        async writePropertyName(name) {
+            if (this.currentPropertyOpen) {
+                throw new Error(`Json Write Method is not allowed, since currently a property value needs to be written.`);
+            }
+            const prefix = this.numPropertiesInCurrentOpenedSymbol() > 0 ? ', ' : '';
+            this.currentPropertyOpen = true;
+            await this.pushWritable(`${prefix}${name}:`);
+            return;
+        }
+        async writeValue(value) {
+            if (this.openedSymbols.length <= 0 || (!this.currentPropertyOpen && this.openedSymbols.at(-1) !== 'array')) {
+                throw new Error(`Json Write Method is not allowed for any value here.`);
+            }
+            const prefix = this.numPropertiesInCurrentOpenedSymbol() > 0 ? ', ' : '';
+            if (this.currentPropertyOpen) {
+                this.currentPropertyOpen = false;
+            }
+            await this.pushWritable(`${prefix}${await value}`);
+            this.numberPropertiesInOpenedSymbol[this.numberPropertiesInOpenedSymbol.length - 1] += 1;
+            return;
+        }
+    }
+    exports.JsonStreamWritable = JsonStreamWritable;
+});

package/build/parser/stream/json-stream-writer.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { WritableStreamDefaultWriter } from "stream/web";
+import { ChunkCompressionInfo, ObjectReference, SatisfactorySaveHeader, SaveComponent, SaveEntity } from "../..";
+import { JsonStreamStateWriter } from "./json-stream-state-writer";
+type State = 'BEFORE_START' | 'OPENED_SAVE' | 'FINISHED_HEADER' | 'OPENED_LEVELS' | 'FINISHED_LEVELS' | 'OPENED_LEVEL' | 'FINISHED_LEVEL' | 'FINISHED_SAVE' | 'WROTE_COMPRESSION_INFO' | 'WROTE_OBJECT' | 'SWITCH_TO_COLLECTABLES' | 'WROTE_COLLECTABLE';
+export declare class JsonStreamWriter extends JsonStreamStateWriter<State> {
+    private writer;
+    private readonly stateMachine;
+    constructor(writer: WritableStreamDefaultWriter<string>);
+    beginSave(): Promise<void>;
+    writeHeader(header: SatisfactorySaveHeader): Promise<void>;
+    writeCompressionInfo(compressionInfo: ChunkCompressionInfo): Promise<void>;
+    openLevels(): Promise<void>;
+    openLevel(): Promise<void>;
+    writeObject(object: SaveEntity | SaveComponent): Promise<void>;
+    switchToCollectables(): Promise<void>;
+    writeCollectable(object: ObjectReference): Promise<void>;
+    closeLevel(): Promise<void>;
+    closeLevels(): Promise<void>;
+    endSave(): Promise<void>;
+}
+export {};

package/build/parser/stream/json-stream-writer.js

@@ -0,0 +1,137 @@
+(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", "./json-stream-state-writer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JsonStreamWriter = void 0;
+    const json_stream_state_writer_1 = require("./json-stream-state-writer");
+    class JsonStreamWriter extends json_stream_state_writer_1.JsonStreamStateWriter {
+        constructor(writer) {
+            super(async (value) => await writer.write(value), 'BEFORE_START');
+            this.writer = writer;
+            this.stateMachine = {
+                openSave: {
+                    name: 'Open Save',
+                    requiresOneOfThemToBeBefore: ['BEFORE_START'],
+                    do: async () => await this.startObject(),
+                    assignOnFinish: 'OPENED_SAVE',
+                },
+                writeHeader: {
+                    name: 'Write Header',
+                    requiresOneOfThemToBeBefore: ['OPENED_SAVE'],
+                    do: async (param) => await this.writeProperty('header', Promise.resolve(JSON.stringify(param))),
+                    assignOnFinish: 'FINISHED_HEADER',
+                },
+                writeCompressionInfo: {
+                    name: 'Write Compression Info',
+                    requiresOneOfThemToBeBefore: ['FINISHED_HEADER'],
+                    do: async (param) => await this.writeProperty('compressionInfo', Promise.resolve(JSON.stringify(param))),
+                    assignOnFinish: 'WROTE_COMPRESSION_INFO',
+                },
+                openLevels: {
+                    name: 'Open Levels',
+                    requiresOneOfThemToBeBefore: ['WROTE_COMPRESSION_INFO'],
+                    do: async () => await this.startArray(),
+                    assignOnFinish: 'OPENED_LEVELS',
+                },
+                openLevel: {
+                    name: 'Open Level',
+                    requiresOneOfThemToBeBefore: ['OPENED_LEVELS', 'FINISHED_LEVEL'],
+                    do: async (param) => {
+                        await this.writePropertyName(param);
+                        await this.startObject();
+                        await this.writeProperty('name', Promise.resolve(param));
+                        await this.writePropertyName('objects');
+                        await this.startArray();
+                    },
+                    assignOnFinish: 'OPENED_LEVEL',
+                },
+                writeObject: {
+                    name: 'Write Object',
+                    requiresOneOfThemToBeBefore: ['OPENED_LEVEL', 'WROTE_OBJECT'],
+                    do: async (param) => await this.writeValue(Promise.resolve(JSON.stringify(param))),
+                    assignOnFinish: 'WROTE_OBJECT',
+                },
+                switchToCollectables: {
+                    name: 'Switch To collectables',
+                    requiresOneOfThemToBeBefore: ['OPENED_LEVEL', 'WROTE_OBJECT'],
+                    do: async () => {
+                        await this.endArray();
+                        await this.writePropertyName('collectables');
+                        await this.startArray();
+                    },
+                    assignOnFinish: 'SWITCH_TO_COLLECTABLES',
+                },
+                writeCollectable: {
+                    name: 'Write Collectables',
+                    requiresOneOfThemToBeBefore: ['SWITCH_TO_COLLECTABLES'],
+                    do: async (param) => {
+                        await this.writeValue(Promise.resolve(JSON.stringify(param)));
+                    },
+                    assignOnFinish: 'WROTE_COLLECTABLE',
+                },
+                closeLevel: {
+                    name: 'Close Level',
+                    requiresOneOfThemToBeBefore: ['SWITCH_TO_COLLECTABLES', 'WROTE_COLLECTABLE'],
+                    do: async () => {
+                        await this.endArray();
+                        await this.endObject();
+                    },
+                    assignOnFinish: 'FINISHED_LEVEL',
+                },
+                closeLevels: {
+                    name: 'Close Levels',
+                    requiresOneOfThemToBeBefore: [],
+                    do: async () => await this.endArray(),
+                    assignOnFinish: "FINISHED_LEVELS",
+                },
+                closeSave: {
+                    name: 'Close Save',
+                    requiresOneOfThemToBeBefore: ['FINISHED_LEVELS'],
+                    do: async () => await this.startObject(),
+                    assignOnFinish: 'FINISHED_SAVE',
+                }
+            };
+        }
+        async beginSave() {
+            await this.useTransition(this.stateMachine.openSave);
+        }
+        async writeHeader(header) {
+            await this.useTransition(this.stateMachine.writeHeader, header);
+        }
+        async writeCompressionInfo(compressionInfo) {
+            await this.useTransition(this.stateMachine.writeCompressionInfo, compressionInfo);
+        }
+        async openLevels() {
+            await this.useTransition(this.stateMachine.openLevels);
+        }
+        async openLevel() {
+            await this.useTransition(this.stateMachine.openLevel);
+        }
+        async writeObject(object) {
+            await this.useTransition(this.stateMachine.writeObject, object);
+        }
+        async switchToCollectables() {
+            await this.useTransition(this.stateMachine.switchToCollectables);
+        }
+        async writeCollectable(object) {
+            await this.useTransition(this.stateMachine.writeCollectable, object);
+        }
+        async closeLevel() {
+            await this.useTransition(this.stateMachine.closeLevel);
+        }
+        async closeLevels() {
+            await this.useTransition(this.stateMachine.closeLevels);
+        }
+        async endSave() {
+            await this.useTransition(this.stateMachine.closeSave);
+        }
+    }
+    exports.JsonStreamWriter = JsonStreamWriter;
+});

package/build/parser/stream/save-stream-json-stringifier.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { WritableStream } from "stream/web";
+import { SatisfactorySave } from "../..";
+export declare class SaveStreamJsonStringifier {
+    static StreamStringifySave(save: SatisfactorySave, output: WritableStream<string>): Promise<void>;
+}

package/build/parser/stream/save-stream-json-stringifier.js

@@ -0,0 +1,43 @@
+(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", "./save-stream-writer.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveStreamJsonStringifier = void 0;
+    const save_stream_writer_class_1 = require("./save-stream-writer.class");
+    class SaveStreamJsonStringifier {
+        static async StreamStringifySave(save, output) {
+            const writer = new save_stream_writer_class_1.SaveStreamWriter(output.getWriter());
+            await writer.beginSave();
+            await writer.writeHeader(save.header);
+            if (save.compressionInfo) {
+                await writer.writeCompressionInfo(save.compressionInfo);
+            }
+            await writer.openLevels();
+            const objectBatchSize = 10000;
+            for (const level of save.levels) {
+                await writer.openLevel(level.name);
+                let i = 0;
+                for (i; i < level.objects.length; i += objectBatchSize) {
+                    await writer.writeObjects(...level.objects.slice(i, Math.min(i + objectBatchSize, level.objects.length)));
+                }
+                await writer.switchInLevelToCollectables();
+                i = 0;
+                for (i; i < level.collectables.length; i += objectBatchSize) {
+                    await writer.writeCollectables(...level.collectables.slice(i, Math.min(i + objectBatchSize, level.collectables.length)));
+                }
+                await writer.endLevel();
+            }
+            await writer.endLevels();
+            await writer.endSave();
+            await writer.close();
+        }
+    }
+    exports.SaveStreamJsonStringifier = SaveStreamJsonStringifier;
+});

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

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { ReadableStreamDefaultReader } from "stream/web";
+import { ChunkCompressionInfo, SatisfactorySaveHeader } from "../..";
+import { ByteStreamReader } from "./byte-stream-reader.class";
+import { SaveStreamWriter } from "./save-stream-writer.class";
+export declare class SaveStreamReader extends ByteStreamReader {
+    static readonly EPOCH_TICKS = 621355968000000000n;
+    static readonly DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
+    compressionInfo: ChunkCompressionInfo;
+    constructor(reader: ReadableStreamDefaultReader<Uint8Array>, maxBufferThreshold: number, onCloseCallback?: () => Promise<void>);
+    readHeader(): Promise<SatisfactorySaveHeader>;
+    readBodyChunk(): Promise<Uint8Array>;
+    debugInfo(): string;
+    streamLevelsToOutput(writer: SaveStreamWriter, header: SatisfactorySaveHeader): Promise<void>;
+}