@etothepii/satisfactory-file-parser 0.4.13 → 0.4.14

package/build/parser/satisfactory/objects/ue/FMD5Hash.d.ts

@@ -1,7 +0,0 @@
-import { ByteReader, ByteWriter } from '../../../..';
-export type MD5Hash = {
-    isValid: boolean;
-    hash?: number[];
-};
-export declare const readMD5Hash: (reader: ByteReader) => MD5Hash;
-export declare const writeMD5Hash: (writer: ByteWriter, md5Hash: MD5Hash) => void;

package/build/parser/satisfactory/objects/ue/FMD5Hash.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeMD5Hash = exports.readMD5Hash = void 0;
-const readMD5Hash = (reader) => {
-    const md5Hash = { isValid: false };
-    md5Hash.isValid = reader.readInt32() === 1;
-    if (md5Hash.isValid) {
-        md5Hash.hash = Array.from(reader.readBytes(16));
-    }
-    return md5Hash;
-};
-exports.readMD5Hash = readMD5Hash;
-const writeMD5Hash = (writer, md5Hash) => {
-    writer.writeInt32(md5Hash.isValid ? 1 : 0);
-    if (md5Hash.isValid) {
-        writer.writeBytesArray(md5Hash.hash);
-    }
-};
-exports.writeMD5Hash = writeMD5Hash;

package/build/parser/satisfactory/objects/ue/GUID.d.ts

@@ -1,6 +0,0 @@
-import { BinaryReadable, ByteWriter } from '../../../..';
-export type GUID = [number, number, number, number];
-export declare namespace GUID {
-    const read: (reader: BinaryReadable) => GUID;
-    const write: (writer: ByteWriter, guid: GUID) => void;
-}

package/build/parser/satisfactory/objects/ue/GUID.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GUID = void 0;
-var GUID;
-(function (GUID) {
-    GUID.read = (reader) => {
-        return [
-            reader.readUint32(),
-            reader.readUint32(),
-            reader.readUint32(),
-            reader.readUint32(),
-        ];
-    };
-    GUID.write = (writer, guid) => {
-        writer.writeUint32(guid[0]);
-        writer.writeUint32(guid[1]);
-        writer.writeUint32(guid[2]);
-        writer.writeUint32(guid[3]);
-    };
-})(GUID = exports.GUID || (exports.GUID = {}));
-;

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

@@ -1,9 +0,0 @@
-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

@@ -1,66 +0,0 @@
-"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, undefined);
-        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, undefined);
-        await writer.endLevel();
-        return level;
-    }
-}
-exports.AsynchronousLevel = AsynchronousLevel;

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

@@ -1,57 +0,0 @@
-/// <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;
-}

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

@@ -1,241 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,83 +0,0 @@
-"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

@@ -1,22 +0,0 @@
-/// <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 {};