object-input-stream 0.1.0

package/dist/object-input-stream.js

@@ -0,0 +1,1022 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __propKey = (this && this.__propKey) || function (x) {
+    return typeof x === "symbol" ? x : "".concat(x);
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFallbackEnum = exports.BaseFallbackExternalizable = exports.BaseFallbackSerializable = exports.BaseFallbackClass = exports.BaseProxy = exports.ObjectStreamClass = exports.HandleTable = exports.ByteArray = exports.ObjectInputStream = void 0;
+const exc = __importStar(require("./exceptions"));
+const classes_1 = require("./classes");
+class ObjectInputStream {
+    constructor(data, options) {
+        // ========== CONSTANTS ==========
+        this.baseWireHandle = 0x7E0000;
+        this.PROTOCOL_VERSION_1 = 1;
+        this.PROTOCOL_VERSION_2 = 2;
+        this.STREAM_MAGIC = 0xACED;
+        this.STREAM_VERSION = 0x0005;
+        this.SC_WRITE_METHOD = 0x01;
+        this.SC_BLOCK_DATA = 0x08;
+        this.SC_SERIALIZABLE = 0x02;
+        this.SC_EXTERNALIZABLE = 0x04;
+        this.SC_ENUM = 0x10;
+        this.TC_BASE = 0x70;
+        this.TC_MAX = 0x7E;
+        this.TC_NULL = 0x70;
+        this.TC_REFERENCE = 0x71;
+        this.TC_CLASSDESC = 0x72;
+        this.TC_OBJECT = 0x73;
+        this.TC_STRING = 0x74;
+        this.TC_ARRAY = 0x75;
+        this.TC_CLASS = 0x76;
+        this.TC_BLOCKDATA = 0x77;
+        this.TC_ENDBLOCKDATA = 0x78;
+        this.TC_RESET = 0x79;
+        this.TC_BLOCKDATALONG = 0x7A;
+        this.TC_EXCEPTION = 0x7B;
+        this.TC_LONGSTRING = 0x7C;
+        this.TC_PROXYCLASSDESC = 0x7D;
+        this.TC_ENUM = 0x7E;
+        this.data = data;
+        this.offset = 0;
+        this.blockDataMode = false;
+        this.remainingInBlock = -1;
+        this.handleTable = new HandleTable();
+        this.registeredClasses = new Map();
+        this.proxyClasses = new Map();
+        this.curContext = null;
+        if (this.readUnsignedShort() !== this.STREAM_MAGIC)
+            throw new exc.StreamCorruptedException("Missing STREAM_MAGIC");
+        if (this.readUnsignedShort() !== this.STREAM_VERSION)
+            throw new exc.StreamCorruptedException("Missing STREAM_VERSION");
+        this.setBlockDataMode(true);
+        const initialSerializables = options?.initialClasses?.serializable ?? classes_1.builtinSerializables;
+        const initialExternalizables = options?.initialClasses?.externalizable ?? classes_1.builtinExternalizables;
+        const initialEnums = options?.initialClasses?.enum ?? classes_1.builtinEnums;
+        const initialClasses = options?.initialClasses?.general ?? classes_1.builtinClasses;
+        for (const [name, ctor] of initialSerializables)
+            this.registerSerializable(name, ctor);
+        for (const [name, ctor] of initialExternalizables)
+            this.registerExternalizable(name, ctor);
+        for (const [name, enum_] of initialEnums)
+            this.registerEnum(name, enum_);
+        for (const [name, ctor] of initialClasses)
+            this.registerClass(name, ctor);
+    }
+    // ========== PROTECTED BYTE READ METHODS ==========
+    setBlockDataMode(newMode) {
+        if (this.blockDataMode === newMode) {
+            return this.blockDataMode;
+        }
+        this.remainingInBlock = newMode ? 0 : -1;
+        if (!newMode && this.remainingInBlock > 0) {
+            throw new exc.IllegalStateException("unread block data");
+        }
+        this.blockDataMode = newMode;
+        return !this.blockDataMode;
+    }
+    peek1() {
+        if (!this.blockDataMode)
+            return (this.offset < this.data.length) ? this.data[this.offset] : -1;
+        if (this.remainingInBlock === 0)
+            this.refillBlockData();
+        if (this.remainingInBlock > 0) {
+            this.remainingInBlock;
+            return this.data[this.offset];
+        }
+        else {
+            return -1;
+        }
+    }
+    peekByte() {
+        const result = this.peek1();
+        if (result < 0)
+            throw new exc.EOFException();
+        return result >= 128 ? 256 - result : result;
+    }
+    readBlockHeader() {
+        if (!this.blockDataMode)
+            throw new exc.IllegalStateException("readBlockHeader in normal mode");
+        if (this.curContext?.defaultEndData)
+            // Fix for 4360508
+            return -1;
+        const oldMode = this.setBlockDataMode(false);
+        let len = null;
+        try {
+            while (len === null) {
+                const tc = this.peek1();
+                switch (tc) {
+                    case this.TC_BLOCKDATA:
+                        this.readByte();
+                        len = this.readUnsignedByte();
+                        break;
+                    case this.TC_BLOCKDATALONG:
+                        this.readByte();
+                        len = this.readInt();
+                        if (len < 0)
+                            throw new exc.StreamCorruptedException("illegal block data header length: " + len);
+                        break;
+                    case this.TC_RESET:
+                        this.readReset();
+                        break;
+                    default:
+                        if (tc >= 0 && (tc < this.TC_BASE || tc > this.TC_MAX))
+                            throw new exc.StreamCorruptedException("invalid block type code: " + tcHex(tc));
+                        len = -1;
+                        break;
+                }
+            }
+        }
+        finally {
+            this.setBlockDataMode(oldMode);
+        }
+        return len;
+    }
+    refillBlockData() {
+        if (!this.blockDataMode)
+            throw new exc.IllegalStateException("refill in normal mode");
+        if (this.remainingInBlock > 0)
+            return;
+        while (true) {
+            const len = this.readBlockHeader();
+            if (len < 0)
+                return;
+            if (len > 0) {
+                this.remainingInBlock = len;
+                return;
+            }
+        }
+    }
+    // ========== BYTE READ METHODS ==========
+    read1() {
+        if (!this.blockDataMode)
+            return (this.offset < this.data.length) ? this.data[this.offset++] : -1;
+        if (this.remainingInBlock === 0)
+            this.refillBlockData();
+        if (this.remainingInBlock > 0) {
+            this.remainingInBlock--;
+            return this.data[this.offset++];
+        }
+        else {
+            return -1;
+        }
+    }
+    read(len) {
+        len = Math.max(len, 0);
+        len = Math.min(len, this.data.length - this.offset);
+        if (!this.blockDataMode) {
+            const result = new Uint8Array(this.data.slice(this.offset, this.offset + len));
+            this.offset += len;
+            return result;
+        }
+        const blocks = [];
+        let left = len;
+        while (left > 0 && this.peek1() >= 0) {
+            const toRead = Math.min(left, this.remainingInBlock);
+            const block = this.data.subarray(this.offset, this.offset + toRead);
+            this.offset += toRead;
+            this.remainingInBlock -= toRead;
+            left -= toRead;
+            blocks.push(block);
+        }
+        const result = new Uint8Array(blocks.reduce((sum, cur) => sum + cur.length, 0));
+        let offset = 0;
+        for (const block of blocks) {
+            result.set(block, offset);
+            offset += block.length;
+        }
+        if (offset !== result.length)
+            throw new exc.InternalError();
+        return result;
+    }
+    readFully(len) {
+        const result = this.read(len);
+        if (result.length < len)
+            throw new exc.EOFException();
+        return result;
+    }
+    // ========== PROTECTED PRIMITIVE READ METHODS ==========
+    readLongUTF() {
+        const length = this.readLong();
+        if (length > Number.MAX_SAFE_INTEGER) {
+            throw new exc.NotImplementedError("string longer than Number.MAX_SAFE_INTEGER bytes");
+        }
+        return this.readUTFBody(Number(length));
+    }
+    // https://docs.oracle.com/javase/8/docs/api/java/io/DataInput.html#readUTF--
+    readUTFBody(byteLength) {
+        const bytes = this.readFully(byteLength);
+        const resultChars = new Uint16Array(bytes.length);
+        let resultCharsOffset = 0;
+        for (let i = 0; i < bytes.length; resultCharsOffset++) {
+            const a = bytes[i++];
+            // Single-byte group
+            if ((a & 128) === 0) {
+                resultChars[resultCharsOffset] = a;
+            }
+            // Two-byte group
+            else if ((a & 224) === 192) {
+                if (i + 1 > bytes.length)
+                    throw new exc.UTFDataFormatException();
+                const b = bytes[i++];
+                if ((b & 192) !== 128)
+                    throw new exc.UTFDataFormatException();
+                resultChars[resultCharsOffset] = (((a & 0x1F) << 6) | (b & 0x3F));
+            }
+            // Three-byte group
+            else if ((a & 240) === 224) {
+                if (i + 2 > bytes.length)
+                    throw new exc.UTFDataFormatException();
+                const b = bytes[i++];
+                const c = bytes[i++];
+                if ((b & 192) !== 128)
+                    throw new exc.UTFDataFormatException();
+                if ((c & 192) !== 128)
+                    throw new exc.UTFDataFormatException();
+                resultChars[resultCharsOffset] = (((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F));
+            }
+            // Encoding error
+            else {
+                throw new exc.UTFDataFormatException();
+            }
+        }
+        return Array.from(resultChars.subarray(0, resultCharsOffset), c => String.fromCharCode(c)).join("");
+    }
+    readTC() { return this.readByte(); }
+    // ========== PRIMITIVE READ METHODS ==========
+    readBoolean() {
+        return ByteArray.getBoolean(this.readFully(1));
+    }
+    readByte() {
+        return ByteArray.getByte(this.readFully(1));
+    }
+    readUnsignedByte() {
+        return ByteArray.getUnsignedByte(this.readFully(1));
+    }
+    readChar() {
+        return ByteArray.getChar(this.readFully(2));
+    }
+    readShort() {
+        return ByteArray.getShort(this.readFully(2));
+    }
+    readUnsignedShort() {
+        return ByteArray.getUnsignedShort(this.readFully(2));
+    }
+    readInt() {
+        return ByteArray.getInt(this.readFully(4));
+    }
+    readLong() {
+        return ByteArray.getLong(this.readFully(8));
+    }
+    readFloat() {
+        return ByteArray.getFloat(this.readFully(4));
+    }
+    readDouble() {
+        return ByteArray.getDouble(this.readFully(8));
+    }
+    readUTF() {
+        return this.readUTFBody(this.readUnsignedShort());
+    }
+    // ========== PROTECTED OBJECT READ METHODS ==========
+    readReset() {
+        if (this.readTC() !== this.TC_RESET)
+            throw new exc.InternalError();
+        // TODO when depth > 0
+        this.handleTable.reset();
+    }
+    readNull() {
+        if (this.readTC() !== this.TC_NULL)
+            throw new exc.InternalError();
+        return null;
+    }
+    readHandle() {
+        if (this.readTC() !== this.TC_REFERENCE)
+            throw new exc.InternalError();
+        const handle = this.readInt();
+        return this.handleTable.getObject(handle);
+    }
+    readClass() {
+        if (this.readTC() !== this.TC_CLASS)
+            throw new exc.InternalError();
+        const classDesc = this.readClassDesc();
+        if (classDesc === null)
+            throw new exc.NullPointerException();
+        const result = classDesc.cl;
+        const handle = this.handleTable.newHandle(result);
+        return result;
+    }
+    readClassDesc() {
+        const tc = this.peekByte();
+        switch (tc) {
+            case this.TC_NULL:
+                return this.readNull();
+            case this.TC_PROXYCLASSDESC:
+                return this.readProxyDesc();
+            case this.TC_CLASSDESC:
+                return this.readNonProxyDesc();
+            case this.TC_REFERENCE:
+                const d = this.readHandle();
+                if (!(d instanceof ObjectStreamClass))
+                    throw new exc.ClassCastException(d);
+                d.checkInitialized();
+                return d;
+            default:
+                throw new exc.StreamCorruptedException("invalid classDesc type code: " + tcHex(tc));
+        }
+    }
+    readProxyDesc() {
+        if (this.readTC() !== this.TC_PROXYCLASSDESC)
+            throw new exc.InternalError();
+        const desc = new ObjectStreamClass(null, null, true);
+        const handle = this.handleTable.newHandle(desc);
+        const proxyInterfaces = [];
+        const numIfaces = this.readInt();
+        for (let i = 0; i < numIfaces; i++) {
+            proxyInterfaces.push(this.readUTF());
+        }
+        const cl = this.resolveProxyClass(proxyInterfaces);
+        const annotation = this.readAnnotation();
+        const superDesc = this.readClassDesc();
+        desc.initProxy(cl, proxyInterfaces, annotation, superDesc);
+        return desc;
+    }
+    resolveProxyClass(proxyInterfaces) {
+        var _a, _b;
+        const ifacesStr = proxyInterfaces.join(",");
+        if (!this.proxyClasses.has(ifacesStr)) {
+            const classId = this.proxyClasses.size.toString();
+            const className = "JavaProxy" + classId;
+            const newClass = { [_a = __propKey(className)]: (_b = class extends BaseProxy {
+                    },
+                    __setFunctionName(_b, _a),
+                    _b.proxyInterfaces = proxyInterfaces,
+                    _b) }[className];
+            this.proxyClasses.set(ifacesStr, newClass);
+        }
+        return this.proxyClasses.get(ifacesStr);
+    }
+    readNonProxyDesc() {
+        if (this.readTC() !== this.TC_CLASSDESC)
+            throw new exc.InternalError();
+        const name = this.readUTF();
+        const suid = this.readLong();
+        const desc = new ObjectStreamClass(name, suid, false);
+        const handle = this.handleTable.newHandle(desc);
+        const flags = this.readUnsignedByte();
+        const numFields = this.readShort();
+        const fields = [];
+        for (let i = 0; i < numFields; i++) {
+            const typecode = String.fromCodePoint(this.readUnsignedByte());
+            const fieldName = this.readUTF();
+            switch (typecode) {
+                case 'L':
+                case '[':
+                    const className = this.readString();
+                    fields.push({ typecode, name: fieldName, className });
+                    break;
+                case 'B':
+                case 'C':
+                case 'D':
+                case 'F':
+                case 'I':
+                case 'J':
+                case 'S':
+                case 'Z':
+                    fields.push({ typecode, name: fieldName });
+                    break;
+                default:
+                    throw new exc.InvalidClassException(name, "invalid typecode for field " + fieldName + ": " + typecode);
+            }
+        }
+        const annotation = this.readAnnotation();
+        const superDesc = this.readClassDesc();
+        const cl = this.resolveClass(name, this.getClassType(flags), desc, superDesc);
+        desc.initNonProxy(cl, flags, fields, annotation, superDesc);
+        return desc;
+    }
+    getClassType(flags) {
+        if (flags & this.SC_ENUM)
+            return "enum";
+        else if (flags & this.SC_SERIALIZABLE)
+            return "serializable";
+        else if (flags & this.SC_EXTERNALIZABLE)
+            return "externalizable";
+        else
+            return "general";
+    }
+    resolveClass(name, type, desc, superDesc) {
+        var _a, _b;
+        if (this.registeredClasses.has(name))
+            return this.registeredClasses.get(name)[1];
+        const fallbackSuperClass = {
+            "general": BaseFallbackClass,
+            "serializable": BaseFallbackSerializable,
+            "externalizable": BaseFallbackExternalizable,
+            "enum": BaseFallbackEnum,
+        }[type];
+        const superClass = superDesc !== null ? superDesc.cl : fallbackSuperClass;
+        const cl = { [_a = __propKey(name)]: (_b = class extends superClass {
+                },
+                __setFunctionName(_b, _a),
+                _b.$desc = desc,
+                _b) }[name];
+        // @ts-expect-error
+        cl.displayName = name;
+        return cl;
+    }
+    readString() {
+        const tc = this.readTC();
+        let str;
+        switch (tc) {
+            case this.TC_STRING:
+                str = this.readUTF();
+                break;
+            case this.TC_LONGSTRING:
+                str = this.readLongUTF();
+                break;
+            case this.TC_REFERENCE:
+                str = this.readHandle();
+                if (typeof str !== "string")
+                    throw new exc.ClassCastException("string reference is not a string: " + str);
+                return str;
+            default:
+                throw new exc.StreamCorruptedException("invalid string type code: " + tcHex(tc));
+        }
+        this.handleTable.newHandle(str);
+        return str;
+    }
+    readArray() {
+        if (this.readTC() !== this.TC_ARRAY)
+            throw new exc.InternalError();
+        const desc = this.readClassDesc();
+        const len = this.readInt();
+        if (len < 0)
+            throw new exc.StreamCorruptedException("Array length is negative");
+        const result = [];
+        const handle = this.handleTable.newHandle(result);
+        if (!desc?.name?.startsWith("[") || desc.name.length < 2)
+            throw new exc.StreamCorruptedException("Invalid array desc name: " + desc?.name);
+        const typecode = desc.name.charAt(1);
+        for (let i = 0; i < len; i++) {
+            result.push(this.readValue(typecode));
+        }
+        return result;
+    }
+    readValue(typecode) {
+        switch (typecode) {
+            case '[':
+            case 'L':
+                // TODO: type checking
+                return this.readObject();
+            case 'B': return this.readByte();
+            case 'C': return this.readChar();
+            case 'D': return this.readDouble();
+            case 'F': return this.readFloat();
+            case 'I': return this.readInt();
+            case 'J': return this.readLong();
+            case 'S': return this.readShort();
+            case 'Z': return this.readBoolean();
+            default:
+                throw new exc.StreamCorruptedException("Unkown field value typecode: " + typecode);
+        }
+    }
+    readEnum() {
+        if (this.readTC() !== this.TC_ENUM)
+            throw new exc.InternalError();
+        const desc = this.readClassDesc();
+        if (!desc?.isEnum)
+            throw new exc.InvalidClassException(desc?.name ?? null, "non-enum class");
+        const handle = this.handleTable.newHandle(null);
+        const constantName = this.readString();
+        if (!(constantName in desc.cl))
+            throw new exc.InvalidClassException(desc.name, "enum constant name doesn't exist: " + constantName);
+        // @ts-expect-error
+        const result = desc.cl[constantName];
+        this.handleTable.replaceObject(handle, null, result);
+        return result;
+    }
+    readOrdinaryObject() {
+        if (this.readTC() !== this.TC_OBJECT)
+            throw new exc.InternalError();
+        const desc = this.readClassDesc();
+        if (desc === null)
+            throw new exc.NullPointerException();
+        const result = new desc.cl();
+        const handle = this.handleTable.newHandle(result);
+        if (desc.externalizable) {
+            this.readExternalData(result, desc);
+        }
+        else if (desc.serializable) {
+            this.readSerialData(result, desc);
+        }
+        else {
+            throw new exc.InvalidClassException(desc.name, "not serializable and not externalizable");
+        }
+        if (typeof result.readResolve === "function") {
+            const replaced = result.readResolve();
+            this.handleTable.replaceObject(handle, result, replaced);
+            return replaced;
+        }
+        else {
+            return result;
+        }
+    }
+    readExternalData(obj, desc) {
+        const registered = this.registeredClasses.get(desc.name)?.[1];
+        if (!desc.hasBlockExternalData && desc.cl !== registered)
+            throw new exc.ClassNotFoundException("Cannot deserialize instance of Externalizable class " + desc.name + " written using PROTOCOL_VERSION_1, without a matching JS-side class");
+        const oldContext = this.curContext;
+        this.curContext = null;
+        try {
+            if (desc.hasBlockExternalData)
+                this.setBlockDataMode(true);
+            try {
+                obj.readExternal(this);
+            }
+            finally {
+                if (desc.hasBlockExternalData)
+                    this.readAnnotation();
+            }
+        }
+        finally {
+            this.curContext = oldContext;
+        }
+    }
+    readSerialData(obj, objDesc) {
+        const descs = this.getClassDescHierarchy(objDesc);
+        for (const curDesc of descs) {
+            const curClass = curDesc.cl;
+            let readMethod = null;
+            if (obj instanceof curClass) {
+                if (curClass.serialVersionUID !== undefined && curClass.serialVersionUID !== curDesc.suid)
+                    throw new exc.InvalidClassException(curDesc.name, "stream suid " + curDesc.suid + " doesn't match available suid " + curClass.serialVersionUID);
+                if (typeof curClass.prototype.readObject === "function") {
+                    readMethod = curClass.prototype.readObject;
+                }
+                else {
+                    readMethod = defaultReadMethod;
+                }
+            }
+            else {
+                if (curClass.prototype instanceof BaseFallbackClass) {
+                    readMethod = defaultReadMethod;
+                }
+                else {
+                    throw new exc.ClassNotFoundException(curDesc.name + " parent of " + objDesc.name + " in java but not in javascript");
+                }
+            }
+            const oldContext = this.curContext;
+            this.curContext = {
+                desc: curDesc,
+                obj,
+                alreadyReadFields: false,
+                defaultEndData: false,
+            };
+            this.setBlockDataMode(true);
+            readMethod.apply(obj, [this]);
+            if (curDesc.hasWriteObjectData)
+                this.readAnnotation();
+            this.curContext = oldContext;
+        }
+    }
+    getClassDescHierarchy(classDesc) {
+        const hierarchy = [];
+        let currClass = classDesc;
+        while (currClass !== null) {
+            hierarchy.push(currClass);
+            currClass = currClass.superDesc;
+        }
+        return hierarchy.reverse();
+    }
+    readFatalException() {
+        if (this.readTC() !== this.TC_EXCEPTION)
+            throw new exc.InternalError();
+        this.handleTable.reset();
+        const oldMode = this.setBlockDataMode(false);
+        const tc = this.peekByte();
+        this.setBlockDataMode(oldMode);
+        if (tc !== this.TC_OBJECT && tc !== this.TC_REFERENCE)
+            throw new exc.StreamCorruptedException("invalid exception type code: " + tcHex(tc));
+        const result = this.readObject();
+        // This line is required by the spec and implemented in OpenJDK's ObjectOutputStream,
+        // but not in OpenJDK's ObjectInputStream. This is a bug in OpenJDK.
+        this.handleTable.reset();
+        return result;
+    }
+    readAnnotation() {
+        const result = [];
+        while (true) {
+            if (this.blockDataMode) {
+                const block = this.read(Infinity);
+                if (block.length > 0)
+                    result.push(block);
+                this.setBlockDataMode(false);
+            }
+            switch (this.peekByte()) {
+                case this.TC_BLOCKDATA:
+                case this.TC_BLOCKDATALONG:
+                    this.setBlockDataMode(true);
+                    break;
+                case this.TC_ENDBLOCKDATA:
+                    this.readByte();
+                    return result;
+                default:
+                    result.push(this.readObject());
+                    break;
+            }
+        }
+    }
+    // ========== OBJECT READ METHODS ==========
+    readObject() {
+        const oldMode = this.blockDataMode;
+        if (this.blockDataMode) {
+            this.peek1();
+            if (this.remainingInBlock > 0) {
+                throw new exc.OptionalDataException(this.remainingInBlock);
+            }
+            else if (this.curContext?.defaultEndData) {
+                // Fix for 4360508
+                throw new exc.OptionalDataException(true);
+            }
+            this.setBlockDataMode(false);
+        }
+        let tc;
+        // Skip resets
+        while ((tc = this.peekByte()) === this.TC_RESET)
+            this.readReset();
+        try {
+            switch (tc) {
+                case this.TC_NULL:
+                    return this.readNull();
+                case this.TC_REFERENCE:
+                    return this.readHandle();
+                case this.TC_CLASS:
+                    return this.readClass();
+                case this.TC_CLASSDESC:
+                case this.TC_PROXYCLASSDESC:
+                    return this.readClassDesc();
+                case this.TC_STRING:
+                case this.TC_LONGSTRING:
+                    return this.readString();
+                case this.TC_ARRAY:
+                    return this.readArray();
+                case this.TC_ENUM:
+                    return this.readEnum();
+                case this.TC_OBJECT:
+                    return this.readOrdinaryObject();
+                case this.TC_EXCEPTION:
+                    const ex = this.readFatalException();
+                    throw new exc.WriteAbortedException("writing aborted", ex);
+                case this.TC_ENDBLOCKDATA:
+                    if (oldMode) {
+                        throw new exc.OptionalDataException(true);
+                    }
+                    else {
+                        throw new exc.StreamCorruptedException("unexpected end of block data");
+                    }
+                default:
+                    throw new exc.StreamCorruptedException("invalid object type code: " + tcHex(tc));
+            }
+        }
+        finally {
+            this.setBlockDataMode(oldMode);
+        }
+    }
+    readFields() {
+        if (this.curContext === null)
+            throw new exc.NotActiveException("Not inside a readObject method");
+        if (this.curContext.alreadyReadFields)
+            throw new exc.NotActiveException("Fields already read");
+        const fields = this.curContext.desc.fields;
+        if (fields === null)
+            throw new exc.InternalError();
+        this.setBlockDataMode(false);
+        const result = new Map();
+        for (const field of fields) {
+            result.set(field.name, this.readValue(field.typecode));
+        }
+        this.setBlockDataMode(true);
+        this.curContext.alreadyReadFields = true;
+        if (!this.curContext.desc.hasWriteObjectData)
+            this.curContext.defaultEndData = true;
+        return result;
+    }
+    defaultReadObject() {
+        const fields = this.readFields();
+        const obj = this.curContext?.obj;
+        for (const [k, v] of fields.entries()) {
+            // @ts-expect-error
+            obj[k] = v;
+        }
+    }
+    readEverything() {
+        const result = [];
+        try {
+            while (true) {
+                const block = this.read(Infinity);
+                if (block.length > 0)
+                    result.push(block);
+                result.push(this.readObject());
+            }
+        }
+        catch (e) {
+            if (!(e instanceof exc.OptionalDataException || e instanceof exc.EOFException))
+                throw e;
+        }
+        return result;
+    }
+    // ========== PROTECTED CLASS REGISTRATION METHODS ==========
+    registerClass0(name, clazz, type) {
+        this.registeredClasses.set(name, [type, clazz]);
+    }
+    // ========== CLASS REGISTRATION METHODS ==========
+    registerSerializable(name, ctor) {
+        return this.registerClass0(name, ctor, "serializable");
+    }
+    registerExternalizable(name, ctor) {
+        return this.registerClass0(name, ctor, "externalizable");
+    }
+    registerEnum(name, enum_) {
+        return this.registerClass0(name, enum_, "enum");
+    }
+    registerClass(name, clazz) {
+        return this.registerClass0(name, clazz, "general");
+    }
+}
+exports.ObjectInputStream = ObjectInputStream;
+ObjectInputStream.baseWireHandle = 0x7E0000;
+ObjectInputStream.PROTOCOL_VERSION_1 = 1;
+ObjectInputStream.PROTOCOL_VERSION_2 = 2;
+ObjectInputStream.STREAM_MAGIC = 0xACED;
+ObjectInputStream.STREAM_VERSION = 0x0005;
+ObjectInputStream.SC_WRITE_METHOD = 0x01;
+ObjectInputStream.SC_BLOCK_DATA = 0x08;
+ObjectInputStream.SC_SERIALIZABLE = 0x02;
+ObjectInputStream.SC_EXTERNALIZABLE = 0x04;
+ObjectInputStream.SC_ENUM = 0x10;
+ObjectInputStream.TC_BASE = 0x70;
+ObjectInputStream.TC_MAX = 0x7E;
+ObjectInputStream.TC_NULL = 0x70;
+ObjectInputStream.TC_REFERENCE = 0x71;
+ObjectInputStream.TC_CLASSDESC = 0x72;
+ObjectInputStream.TC_OBJECT = 0x73;
+ObjectInputStream.TC_STRING = 0x74;
+ObjectInputStream.TC_ARRAY = 0x75;
+ObjectInputStream.TC_CLASS = 0x76;
+ObjectInputStream.TC_BLOCKDATA = 0x77;
+ObjectInputStream.TC_ENDBLOCKDATA = 0x78;
+ObjectInputStream.TC_RESET = 0x79;
+ObjectInputStream.TC_BLOCKDATALONG = 0x7A;
+ObjectInputStream.TC_EXCEPTION = 0x7B;
+ObjectInputStream.TC_LONGSTRING = 0x7C;
+ObjectInputStream.TC_PROXYCLASSDESC = 0x7D;
+ObjectInputStream.TC_ENUM = 0x7E;
+exports.default = ObjectInputStream;
+class ByteArray {
+    static getIntegral(arr, numBytes, signed) {
+        if (arr.length < numBytes) {
+            throw new exc.IndexOutOfBoundsException();
+        }
+        if (numBytes <= 0) {
+            return 0n;
+        }
+        const bytes = arr.subarray(0, numBytes);
+        let result = 0n;
+        for (const byte of bytes) {
+            result <<= 8n;
+            result += BigInt(byte);
+        }
+        if (signed) {
+            const topBit = 1n << BigInt(numBytes * 8 - 1);
+            if ((result & topBit) !== 0n) {
+                result -= 1n << BigInt(numBytes * 8);
+            }
+        }
+        return result;
+    }
+    static getBoolean(arr) {
+        if (arr.length < 1)
+            throw new exc.IndexOutOfBoundsException();
+        return arr[0] !== 0;
+    }
+    static getByte(arr) {
+        return Number(this.getIntegral(arr, 1, true));
+    }
+    static getUnsignedByte(arr) {
+        return Number(this.getIntegral(arr, 1, false));
+    }
+    static getChar(arr) {
+        return String.fromCharCode(Number(this.getIntegral(arr, 2, false)));
+    }
+    static getShort(arr) {
+        return Number(this.getIntegral(arr, 2, true));
+    }
+    static getUnsignedShort(arr) {
+        return Number(this.getIntegral(arr, 2, false));
+    }
+    static getInt(arr) {
+        return Number(this.getIntegral(arr, 4, true));
+    }
+    static getLong(arr) {
+        return this.getIntegral(arr, 8, true);
+    }
+    static getFloat(arr) {
+        if (arr.length < 4)
+            throw new exc.IndexOutOfBoundsException();
+        return new DataView(arr.subarray(0, 4).buffer).getFloat32(0, false);
+    }
+    static getDouble(arr) {
+        if (arr.length < 8)
+            throw new exc.IndexOutOfBoundsException();
+        return new DataView(arr.subarray(0, 8).buffer).getFloat64(0, false);
+    }
+}
+exports.ByteArray = ByteArray;
+class HandleTable {
+    constructor() {
+        this.table = new Map();
+        this.currHandle = ObjectInputStream.baseWireHandle;
+    }
+    reset() {
+        this.table.clear();
+        this.currHandle = ObjectInputStream.baseWireHandle;
+    }
+    newHandle(obj) {
+        const handle = this.currHandle++;
+        this.table.set(handle, obj);
+        return handle;
+    }
+    getObject(handle) {
+        if (!this.table.has(handle))
+            throw new exc.StreamCorruptedException("Object handle doesn't exist: " + handle);
+        return this.table.get(handle);
+    }
+    replaceObject(handle, oldObj, newObj) {
+        if (this.table.get(handle) !== oldObj)
+            throw new exc.IllegalStateException(`Replaced handle ${handle} doesn't refer to object ${oldObj}`);
+        this.table.set(handle, newObj);
+    }
+}
+exports.HandleTable = HandleTable;
+function tcHex(tc) {
+    return tc.toString(16).padStart(2, '0');
+}
+class ObjectStreamClass {
+    constructor(name, suid, isProxy) {
+        this.initialized = false;
+        this.name = name;
+        this.suid = suid;
+        this.isProxy = isProxy;
+        // Set default values
+        this.cl = Object;
+        this.fields = (isProxy ? null : []);
+        this.proxyInterfaces = (isProxy ? [] : null);
+        this.isEnum = false;
+        this.serializable = false;
+        this.externalizable = false;
+        this.hasWriteObjectData = false;
+        this.hasBlockExternalData = false;
+        this.annotation = [];
+        this.superDesc = null;
+    }
+    initNonProxy(cl, flags, fields, annotation, superDesc) {
+        if (this.isProxy)
+            throw new exc.IllegalStateException("initialize non-proxy on a proxy class");
+        if (this.initialized)
+            throw new exc.IllegalStateException("already initialized non-proxy");
+        this.cl = cl;
+        this.isEnum = (flags & ObjectInputStream.SC_ENUM) !== 0;
+        this.serializable = (flags & ObjectInputStream.SC_SERIALIZABLE) !== 0;
+        this.externalizable = (flags & ObjectInputStream.SC_EXTERNALIZABLE) !== 0;
+        this.hasWriteObjectData = (flags & ObjectInputStream.SC_WRITE_METHOD) !== 0;
+        this.hasBlockExternalData = (flags & ObjectInputStream.SC_BLOCK_DATA) !== 0;
+        this.fields = fields;
+        this.annotation = annotation;
+        this.superDesc = superDesc;
+        if (this.serializable && this.externalizable)
+            throw new exc.InvalidClassException(this.name, "serializable and externalizable flags conflict");
+        if (this.isEnum && this.suid !== 0n)
+            throw new exc.InvalidClassException(this.name, "enum descriptor has non-zero serialVersionUID: " + this.suid);
+        if (this.isEnum && this.fields.length > 0)
+            throw new exc.InvalidClassException(this.name, "enum descriptor has non-zero field count: " + this.fields.length);
+        this.initialized = true;
+    }
+    initProxy(cl, proxyInterfaces, annotation, superDesc) {
+        if (!this.isProxy)
+            throw new exc.IllegalStateException("initialize proxy on a non-proxy class");
+        if (this.initialized)
+            throw new exc.IllegalStateException("already initialized proxy");
+        this.cl = cl;
+        this.proxyInterfaces = proxyInterfaces;
+        this.annotation = annotation;
+        this.superDesc = superDesc;
+        this.initialized = true;
+    }
+    checkInitialized() {
+        if (!this.initialized)
+            throw new exc.InvalidClassException(this.name, "Class descriptor should be initialized");
+    }
+}
+exports.ObjectStreamClass = ObjectStreamClass;
+class BaseProxy {
+    constructor(h) {
+        this.h = h;
+        return new Proxy(this, { get: (target, prop, receiver) => {
+                if (typeof prop !== "string")
+                    return Reflect.get(target, prop, receiver);
+                if (this.h === undefined || typeof this.h.invoke !== "function")
+                    throw new TypeError("invocation handler doesn't have invoke method");
+                const h = this.h;
+                return (...args) => {
+                    return h.invoke(target, prop, args);
+                };
+            } });
+    }
+    static getInterfaces() {
+        return this.proxyInterfaces;
+    }
+}
+exports.BaseProxy = BaseProxy;
+BaseProxy.proxyInterfaces = [];
+class BaseFallbackClass {
+}
+exports.BaseFallbackClass = BaseFallbackClass;
+class BaseFallbackSerializable extends BaseFallbackClass {
+    constructor() {
+        super(...arguments);
+        this.$annotation = [];
+    }
+    readObject(ois) {
+        ois.defaultReadObject();
+        this.$annotation.push(ois.readEverything());
+    }
+}
+exports.BaseFallbackSerializable = BaseFallbackSerializable;
+class BaseFallbackExternalizable extends BaseFallbackClass {
+    constructor() {
+        super(...arguments);
+        this.$annotation = [];
+    }
+    readExternal(ois) {
+        this.$annotation = ois.readEverything();
+    }
+}
+exports.BaseFallbackExternalizable = BaseFallbackExternalizable;
+class BaseFallbackEnum extends BaseFallbackClass {
+    constructor() {
+        super();
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (typeof prop !== "string")
+                    return Reflect.get(target, prop, receiver);
+                return prop;
+            },
+            has(target, prop) {
+                if (typeof prop === "string")
+                    return true;
+                return prop in target;
+            },
+        });
+    }
+}
+exports.BaseFallbackEnum = BaseFallbackEnum;
+function defaultReadMethod(ois) {
+    ois.defaultReadObject();
+}
+//# sourceMappingURL=object-input-stream.js.map