object-input-stream 0.2.0 → 0.2.2

package/dist/ois-ast.js

@@ -0,0 +1,1019 @@
+"use strict";
+/**
+ * Forgive me father, for I have sinned.
+ */
+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 __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectInputStreamAST = void 0;
+const _1 = __importDefault(require("."));
+const exc = __importStar(require("./exceptions"));
+let ObjectInputStreamAST = (() => {
+    var _a;
+    let _classSuper = _1.default;
+    let _instanceExtraInitializers = [];
+    let _readBoolean_decorators;
+    let _readByte_decorators;
+    let _readUnsignedByte_decorators;
+    let _readChar_decorators;
+    let _readShort_decorators;
+    let _readUnsignedShort_decorators;
+    let _readInt_decorators;
+    let _readLong_decorators;
+    let _readFloat_decorators;
+    let _readDouble_decorators;
+    let _readTC_decorators;
+    let _read1_decorators;
+    let _read_decorators;
+    let _readBlockHeader_decorators;
+    let _readUTF_decorators;
+    let _readLongUTF_decorators;
+    let _readUTFBody_decorators;
+    let _readReset_decorators;
+    let _readNull_decorators;
+    let _readHandle_decorators;
+    let _readClass_decorators;
+    let _readClassDesc_decorators;
+    let _readProxyDesc_decorators;
+    let _readNonProxyDesc_decorators;
+    let _readString_decorators;
+    let _readArray_decorators;
+    let _readEnum_decorators;
+    let _readOrdinaryObject_decorators;
+    let _readExternalData_decorators;
+    let _readSerialData_decorators;
+    let _readClassDataWr_decorators;
+    let _readClassDataNoWr_decorators;
+    let _readFatalException_decorators;
+    let _readAnnotation_decorators;
+    let _readFields_decorators;
+    let _readFieldDescs_decorators;
+    let _readFieldDesc_decorators;
+    return _a = class ObjectInputStreamAST extends _classSuper {
+            constructor(data, options) {
+                super(data, options);
+                this.cst = __runInitializers(this, _instanceExtraInitializers);
+                this.finalized = false;
+                this.ast = null;
+                // How many resets happened so far
+                this.epoch = 0;
+                const rootNode = {
+                    type: "root",
+                    span: { start: 0, end: data.length },
+                    value: null,
+                    parent: null,
+                    children: [],
+                };
+                rootNode.children = [{
+                        type: "magic",
+                        span: { start: 0, end: 2 },
+                        value: this.STREAM_MAGIC,
+                        parent: rootNode,
+                        children: [],
+                    }, {
+                        type: "version",
+                        span: { start: 2, end: 4 },
+                        value: this.STREAM_VERSION,
+                        parent: rootNode,
+                        children: [],
+                    }, {
+                        type: "contents",
+                        span: { start: 4, end: data.length },
+                        value: null,
+                        parent: rootNode,
+                        children: [],
+                    }];
+                this.cst = rootNode;
+                this.cstStack = [this.cst, this.cst.children[2]];
+            }
+            getAST() {
+                if (this.offset < this.data.length) {
+                    throw new Error("Not done reading");
+                }
+                if (this.finalized) {
+                    assert(this.ast !== null);
+                    return this.ast;
+                }
+                this.finalized = true;
+                return cstToAst(this.cst, this.data);
+            }
+            readBoolean() { return super.readBoolean(); }
+            readByte() { return super.readByte(); }
+            readUnsignedByte() { return super.readUnsignedByte(); }
+            readChar() { return super.readChar(); }
+            readShort() { return super.readShort(); }
+            readUnsignedShort() { return super.readUnsignedShort(); }
+            readInt() { return super.readInt(); }
+            readLong() { return super.readLong(); }
+            readFloat() { return super.readFloat(); }
+            readDouble() { return super.readDouble(); }
+            readTC() { return super.readTC(); }
+            read1() { return super.read1(); }
+            read(len) { return super.read(len); }
+            readBlockHeader() { return super.readBlockHeader(); }
+            readUTF() { return super.readUTF(); }
+            readLongUTF() { return super.readLongUTF(); }
+            readUTFBody(byteLength) { return super.readUTFBody(byteLength); }
+            reset() {
+                assert(this.cstStack.length > 0);
+                const currNode = this.cstStack[this.cstStack.length - 1];
+                assert(currNode.type === "object/reset" || currNode.type === "object/exception");
+                currNode.value = ++this.epoch;
+                return super.reset();
+            }
+            newHandle(obj) {
+                assert(this.cstStack.length > 0);
+                const currNode = this.cstStack[this.cstStack.length - 1];
+                assert(currNode.type === "object/class"
+                    || currNode.type === "proxy-desc"
+                    || currNode.type === "non-proxy-desc"
+                    || currNode.type === "object/string"
+                    || currNode.type === "object/array"
+                    || currNode.type === "object/enum"
+                    || currNode.type === "object/instance");
+                const handle = super.newHandle(obj);
+                currNode.handle = { epoch: this.epoch, handle: handle };
+                return handle;
+            }
+            readReset() { return super.readReset(); }
+            readNull() { return super.readNull(); }
+            readHandle() {
+                assert(this.cstStack.length > 0);
+                const currNode = this.cstStack[this.cstStack.length - 1];
+                assert(currNode.type === "object/handle");
+                currNode.value = this.epoch;
+                return super.readHandle();
+            }
+            readClass() { return super.readClass(); }
+            readClassDesc() { return super.readClassDesc(); }
+            readProxyDesc() { return super.readProxyDesc(); }
+            readNonProxyDesc() { return super.readNonProxyDesc(); }
+            readString() { return super.readString(); }
+            readArray() { return super.readArray(); }
+            readEnum() { return super.readEnum(); }
+            readOrdinaryObject() { return super.readOrdinaryObject(); }
+            readExternalData(obj, desc) { return super.readExternalData(obj, desc); }
+            readSerialData(obj, desc) { return super.readSerialData(obj, desc); }
+            readClassDataWr(obj, desc, readMethod) {
+                return super.readClassDataWr(obj, desc, readMethod);
+            }
+            readClassDataNoWr(obj, desc, readMethod) { return super.readClassDataNoWr(obj, desc, readMethod); }
+            readFatalException() { return super.readFatalException(); }
+            readAnnotation() { return super.readAnnotation(); }
+            readFields() { return super.readFields(); }
+            readFieldDescs(className) { return super.readFieldDescs(className); }
+            readFieldDesc(className) { return super.readFieldDesc(className); }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _readBoolean_decorators = [traceMethod("primitive/boolean", { keep: true })];
+            _readByte_decorators = [traceMethod("primitive/byte", { keep: true })];
+            _readUnsignedByte_decorators = [traceMethod("primitive/unsigned-byte", { keep: true })];
+            _readChar_decorators = [traceMethod("primitive/char", { keep: true })];
+            _readShort_decorators = [traceMethod("primitive/short", { keep: true })];
+            _readUnsignedShort_decorators = [traceMethod("primitive/unsigned-short", { keep: true })];
+            _readInt_decorators = [traceMethod("primitive/int", { keep: true })];
+            _readLong_decorators = [traceMethod("primitive/long", { keep: true })];
+            _readFloat_decorators = [traceMethod("primitive/float", { keep: true })];
+            _readDouble_decorators = [traceMethod("primitive/double", { keep: true })];
+            _readTC_decorators = [traceMethod("tc", { keep: true })];
+            _read1_decorators = [traceMethod("read1", { keep: true })];
+            _read_decorators = [traceMethod("read")];
+            _readBlockHeader_decorators = [traceMethod("block-header", { keep: true })];
+            _readUTF_decorators = [traceMethod("utf", { keep: true })];
+            _readLongUTF_decorators = [traceMethod("long-utf", { keep: true })];
+            _readUTFBody_decorators = [traceMethod("utf-body", { keep: true })];
+            _readReset_decorators = [traceMethod("object/reset")];
+            _readNull_decorators = [traceMethod("object/null")];
+            _readHandle_decorators = [traceMethod("object/handle")];
+            _readClass_decorators = [traceMethod("object/class")];
+            _readClassDesc_decorators = [traceMethod("object/class-desc")];
+            _readProxyDesc_decorators = [traceMethod("proxy-desc")];
+            _readNonProxyDesc_decorators = [traceMethod("non-proxy-desc")];
+            _readString_decorators = [traceMethod("object/string", { keep: true })];
+            _readArray_decorators = [traceMethod("object/array")];
+            _readEnum_decorators = [traceMethod("object/enum")];
+            _readOrdinaryObject_decorators = [traceMethod("object/instance")];
+            _readExternalData_decorators = [traceMethod("external-data")];
+            _readSerialData_decorators = [traceMethod("serial-data")];
+            _readClassDataWr_decorators = [traceMethod("class-data-wr")];
+            _readClassDataNoWr_decorators = [traceMethod("class-data-no-wr")];
+            _readFatalException_decorators = [traceMethod("object/exception")];
+            _readAnnotation_decorators = [traceMethod("annotation")];
+            _readFields_decorators = [traceMethod("values")];
+            _readFieldDescs_decorators = [traceMethod("fields")];
+            _readFieldDesc_decorators = [traceMethod("field")];
+            __esDecorate(_a, null, _readBoolean_decorators, { kind: "method", name: "readBoolean", static: false, private: false, access: { has: obj => "readBoolean" in obj, get: obj => obj.readBoolean }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readByte_decorators, { kind: "method", name: "readByte", static: false, private: false, access: { has: obj => "readByte" in obj, get: obj => obj.readByte }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readUnsignedByte_decorators, { kind: "method", name: "readUnsignedByte", static: false, private: false, access: { has: obj => "readUnsignedByte" in obj, get: obj => obj.readUnsignedByte }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readChar_decorators, { kind: "method", name: "readChar", static: false, private: false, access: { has: obj => "readChar" in obj, get: obj => obj.readChar }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readShort_decorators, { kind: "method", name: "readShort", static: false, private: false, access: { has: obj => "readShort" in obj, get: obj => obj.readShort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readUnsignedShort_decorators, { kind: "method", name: "readUnsignedShort", static: false, private: false, access: { has: obj => "readUnsignedShort" in obj, get: obj => obj.readUnsignedShort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readInt_decorators, { kind: "method", name: "readInt", static: false, private: false, access: { has: obj => "readInt" in obj, get: obj => obj.readInt }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readLong_decorators, { kind: "method", name: "readLong", static: false, private: false, access: { has: obj => "readLong" in obj, get: obj => obj.readLong }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readFloat_decorators, { kind: "method", name: "readFloat", static: false, private: false, access: { has: obj => "readFloat" in obj, get: obj => obj.readFloat }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readDouble_decorators, { kind: "method", name: "readDouble", static: false, private: false, access: { has: obj => "readDouble" in obj, get: obj => obj.readDouble }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readTC_decorators, { kind: "method", name: "readTC", static: false, private: false, access: { has: obj => "readTC" in obj, get: obj => obj.readTC }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _read1_decorators, { kind: "method", name: "read1", static: false, private: false, access: { has: obj => "read1" in obj, get: obj => obj.read1 }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _read_decorators, { kind: "method", name: "read", static: false, private: false, access: { has: obj => "read" in obj, get: obj => obj.read }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readBlockHeader_decorators, { kind: "method", name: "readBlockHeader", static: false, private: false, access: { has: obj => "readBlockHeader" in obj, get: obj => obj.readBlockHeader }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readUTF_decorators, { kind: "method", name: "readUTF", static: false, private: false, access: { has: obj => "readUTF" in obj, get: obj => obj.readUTF }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readLongUTF_decorators, { kind: "method", name: "readLongUTF", static: false, private: false, access: { has: obj => "readLongUTF" in obj, get: obj => obj.readLongUTF }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readUTFBody_decorators, { kind: "method", name: "readUTFBody", static: false, private: false, access: { has: obj => "readUTFBody" in obj, get: obj => obj.readUTFBody }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readReset_decorators, { kind: "method", name: "readReset", static: false, private: false, access: { has: obj => "readReset" in obj, get: obj => obj.readReset }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readNull_decorators, { kind: "method", name: "readNull", static: false, private: false, access: { has: obj => "readNull" in obj, get: obj => obj.readNull }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readHandle_decorators, { kind: "method", name: "readHandle", static: false, private: false, access: { has: obj => "readHandle" in obj, get: obj => obj.readHandle }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readClass_decorators, { kind: "method", name: "readClass", static: false, private: false, access: { has: obj => "readClass" in obj, get: obj => obj.readClass }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readClassDesc_decorators, { kind: "method", name: "readClassDesc", static: false, private: false, access: { has: obj => "readClassDesc" in obj, get: obj => obj.readClassDesc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readProxyDesc_decorators, { kind: "method", name: "readProxyDesc", static: false, private: false, access: { has: obj => "readProxyDesc" in obj, get: obj => obj.readProxyDesc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readNonProxyDesc_decorators, { kind: "method", name: "readNonProxyDesc", static: false, private: false, access: { has: obj => "readNonProxyDesc" in obj, get: obj => obj.readNonProxyDesc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readString_decorators, { kind: "method", name: "readString", static: false, private: false, access: { has: obj => "readString" in obj, get: obj => obj.readString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readArray_decorators, { kind: "method", name: "readArray", static: false, private: false, access: { has: obj => "readArray" in obj, get: obj => obj.readArray }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readEnum_decorators, { kind: "method", name: "readEnum", static: false, private: false, access: { has: obj => "readEnum" in obj, get: obj => obj.readEnum }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readOrdinaryObject_decorators, { kind: "method", name: "readOrdinaryObject", static: false, private: false, access: { has: obj => "readOrdinaryObject" in obj, get: obj => obj.readOrdinaryObject }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readExternalData_decorators, { kind: "method", name: "readExternalData", static: false, private: false, access: { has: obj => "readExternalData" in obj, get: obj => obj.readExternalData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readSerialData_decorators, { kind: "method", name: "readSerialData", static: false, private: false, access: { has: obj => "readSerialData" in obj, get: obj => obj.readSerialData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readClassDataWr_decorators, { kind: "method", name: "readClassDataWr", static: false, private: false, access: { has: obj => "readClassDataWr" in obj, get: obj => obj.readClassDataWr }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readClassDataNoWr_decorators, { kind: "method", name: "readClassDataNoWr", static: false, private: false, access: { has: obj => "readClassDataNoWr" in obj, get: obj => obj.readClassDataNoWr }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readFatalException_decorators, { kind: "method", name: "readFatalException", static: false, private: false, access: { has: obj => "readFatalException" in obj, get: obj => obj.readFatalException }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readAnnotation_decorators, { kind: "method", name: "readAnnotation", static: false, private: false, access: { has: obj => "readAnnotation" in obj, get: obj => obj.readAnnotation }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readFields_decorators, { kind: "method", name: "readFields", static: false, private: false, access: { has: obj => "readFields" in obj, get: obj => obj.readFields }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readFieldDescs_decorators, { kind: "method", name: "readFieldDescs", static: false, private: false, access: { has: obj => "readFieldDescs" in obj, get: obj => obj.readFieldDescs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _readFieldDesc_decorators, { kind: "method", name: "readFieldDesc", static: false, private: false, access: { has: obj => "readFieldDesc" in obj, get: obj => obj.readFieldDesc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+exports.ObjectInputStreamAST = ObjectInputStreamAST;
+function traceMethod(type, options) {
+    return (method) => {
+        return function decorated(...args) {
+            if (!(this instanceof ObjectInputStreamAST))
+                throw new exc.InternalError();
+            if (this.finalized)
+                throw new exc.NotActiveException();
+            const parent = (this.cstStack?.length > 0) ? this.cstStack[this.cstStack.length - 1] : null;
+            const node = {
+                type: type,
+                span: { start: this.offset, end: this.offset },
+                value: null,
+                parent: parent,
+                children: [],
+            };
+            if (parent !== null) {
+                parent.children.push(node);
+                this.cstStack.push(node);
+            }
+            let result;
+            try {
+                result = method.apply(this, args);
+                if (options?.keep)
+                    node.value = result;
+                return result;
+            }
+            catch (e) {
+                node.error = e;
+                throw e;
+            }
+            finally {
+                node.span.end = this.offset;
+                if (parent !== null) {
+                    const popped = this.cstStack.pop();
+                    assert(popped === node);
+                }
+            }
+        };
+    };
+}
+function assert(predicate, message = "assertion error") {
+    if (!predicate)
+        throw new exc.InternalError(message);
+}
+/**
+ * Convert a concrete-syntax-tree to an abstract-syntax-tree.
+ * This function is destructive to the CST.
+ */
+function cstToAst(cst, data) {
+    hoistBlockHeaders(cst);
+    hoistResets(cst);
+    // Remove calls to "read" from primitives and strings
+    removeNodesWhere(cst, node => node.type === "read" && node.parent !== null && (node.parent.type.startsWith("primitive/") || node.parent.type === "utf-body"));
+    // Remove calls to "readByte" from tc
+    removeNodesWhere(cst, node => node.type === "primitive/byte" && node.parent?.type === "tc");
+    // Remove empty nodes that shouldn't be empty
+    removeNodesWhere(cst, node => {
+        if (node.span.start < node.span.end)
+            return false;
+        return (node.type !== "contents"
+            && node.type !== "serial-data"
+            && node.type !== "external-data"
+            && node.type !== "class-data-no-wr");
+    }, { recursive: true });
+    handleBlocks(cst);
+    const root = trasformCSTBottomUp(cst, cstToAstNode);
+    assert(root.type === "root");
+    return { root, data };
+}
+/**
+ * Instead of headers being children of primitives, make them their siblings.
+ * They will later become their parents.
+ */
+function hoistBlockHeaders(cst) {
+    const headers = [...traverseCST(cst)].filter(node => node.type === "block-header");
+    for (const header of headers) {
+        while (header.parent !== null && !canContainContent(header.parent)) {
+            assert(header.parent.children[0] === header);
+            hoistFirstChild(header);
+        }
+        assert(header.parent !== null);
+    }
+}
+function pp(node, indent = 0) {
+    let res = " ".repeat(indent) + node.type;
+    if (node.type === "object")
+        res += "/" + node.objectType;
+    if (node.type === "primitive")
+        res += "/" + node.dataType;
+    if (node.value !== null)
+        res += ": " + node.value;
+    if (node.children !== null && node.children.length > 0)
+        res += "\n" + node.children.map(c => pp(c, indent + 1)).join("\n");
+    return res;
+}
+/**
+ * Instead of resets being children of objects / block headers, make them their siblings/
+ */
+function hoistResets(cst) {
+    const resets = [...traverseCST(cst)].filter(node => node.type === "object/reset");
+    for (const reset of resets) {
+        while (reset.parent !== null && !canContainContent(reset.parent)) {
+            assert(reset.parent.children[0] === reset);
+            hoistFirstChild(reset);
+        }
+        assert(reset.parent !== null);
+    }
+}
+function canContainContent(node) {
+    if (node === null)
+        return false;
+    const type = node.type;
+    return type === "class-data-no-wr" || type === "class-data-wr" || type === "contents" || type === "external-data";
+}
+/**
+ * Manipulate the CST s.t `child` becomes its parent's sibling.
+ * `child` must be its parent's first child.
+ */
+function hoistFirstChild(child) {
+    const parent = child.parent;
+    assert(parent !== null);
+    assert(parent.children.indexOf(child) === 0);
+    const grandParent = parent.parent;
+    assert(grandParent !== null);
+    const parentIndex = grandParent.children.indexOf(parent);
+    assert(parentIndex !== -1);
+    parent.children.shift();
+    parent.span.start = child.span.end;
+    grandParent.children.splice(parentIndex, 0, child);
+    child.parent = grandParent;
+}
+function handleBlocks(cst) {
+    // resets that are in between block headers
+    const blockResets = removeNodesWhere(cst, node => {
+        if (node.type !== "object/reset")
+            return false;
+        assert(node.parent !== null);
+        const siblings = node.parent.children;
+        const index = siblings.indexOf(node);
+        assert(0 <= index);
+        const nextRight = siblings.slice(index + 1).find(node => node.type !== "object/reset");
+        const nextLeft = siblings.slice(0, index).reverse().find(node => node.type !== "object/reset");
+        return (nextRight !== undefined && nextRight.type === "block-header"
+            && nextLeft !== undefined && nextLeft.type === "block-header");
+    }, { recursive: true });
+    const blocks = removeNodesWhere(cst, node => node.type === "block-header", { recursive: true })
+        .filter(header => header.span.start < header.span.end)
+        .map(header => {
+        assert(header.value !== -1);
+        let parent = header.parent;
+        assert(parent !== null);
+        assert(typeof header.value === "number");
+        const span = { start: header.span.start, end: header.span.end + header.value };
+        return { header, parent, span };
+    });
+    if (blocks.length === 0)
+        return;
+    // Group blocks into contiguous sequences
+    let currSequence = [blocks[0]];
+    const blockSequences = [currSequence];
+    for (let i = 1; i < blocks.length; i++) {
+        let prev = currSequence[currSequence.length - 1];
+        while (blockResets.length > 0 && blockResets[0].span.start === prev.span.end) {
+            const reset = blockResets.shift();
+            assert(reset !== undefined);
+            currSequence.push(reset);
+            prev = reset;
+        }
+        const curr = blocks[i];
+        if (prev.span.end === curr.span.start) {
+            currSequence.push(curr);
+        }
+        else {
+            currSequence = [curr];
+            blockSequences.push(currSequence);
+        }
+    }
+    assert(blockResets.length === 0);
+    for (const sequence of blockSequences) {
+        assert(sequence.length > 0);
+        assert(sequence.every(block => block.parent === sequence[0].parent));
+        const parent = sequence[0].parent;
+        assert(parent !== null);
+        const start = sequence[0].span.start;
+        const end = sequence[sequence.length - 1].span.end;
+        // Get the values stored in each sequence
+        const values = removeNodesWhere(cst, node => (node.parent === parent && start <= node.span.start && node.span.end <= end), { recursive: true });
+        assert(values.every(v => v.type.startsWith("primitive/") || v.type === "utf" || v.type === "read"));
+        values.forEach(v => removeNodesWhere(v, node => node.type === "block-header", { recursive: true }));
+        const sequenceNode = {
+            type: "blockdata-sequence",
+            span: { start, end },
+            parent: null,
+            value: values,
+            children: [],
+        };
+        sequenceNode.children = sequence.map((seqItem) => {
+            if ("type" in seqItem && seqItem.type === "object/reset") {
+                return seqItem;
+            }
+            const { parent, header, span } = seqItem;
+            const result = {
+                type: "blockdata",
+                span: span,
+                parent: sequenceNode,
+                value: null,
+                children: [...header.children],
+            };
+            result.children.push({
+                type: "read",
+                span: { start: header.span.end, end: span.end },
+                value: null,
+                parent: result,
+                children: [],
+            });
+            return result;
+        });
+        insertNode(parent, sequenceNode);
+    }
+}
+function removeNodesWhere(cst, condition, options) {
+    const toRemove = [];
+    for (const node of traverseCST(cst)) {
+        if (condition(node)) {
+            toRemove.push(node);
+        }
+    }
+    for (const node of toRemove)
+        removeNode(node, options);
+    return toRemove;
+}
+function removeNode(node, options) {
+    assert(node.parent !== null);
+    const nodeIndex = node.parent.children.indexOf(node);
+    assert(nodeIndex !== -1);
+    if (options?.recursive) {
+        node.parent.children.splice(nodeIndex, 1);
+    }
+    else {
+        for (const child of node.children) {
+            child.parent = node.parent;
+        }
+        node.parent.children.splice(nodeIndex, 1, ...node.children);
+    }
+}
+function insertNode(parent, child) {
+    assert(parent.span.start <= child.span.start && child.span.end <= parent.span.end);
+    child.parent = parent;
+    if (parent.children.length === 0) {
+        parent.children.push(child);
+        return;
+    }
+    let inserted = false;
+    for (let i = 0; i <= parent.children.length; i++) {
+        const left = parent.children[i - 1];
+        const right = parent.children[i];
+        // Not overlapping
+        if (left !== undefined)
+            assert(child.span.end <= left.span.start || left.span.end <= child.span.start);
+        if (right !== undefined)
+            assert(child.span.end <= right.span.start || right.span.end <= child.span.start);
+        const leftGood = (left === undefined) || (left.span.end <= child.span.start);
+        const rightGood = (right === undefined) || (child.span.end <= right.span.start);
+        if (leftGood && rightGood) {
+            parent.children.splice(i, 0, child);
+            inserted = true;
+            break;
+        }
+    }
+    assert(inserted);
+}
+function* traverseCST(cst) {
+    yield cst;
+    for (const child of cst.children)
+        yield* traverseCST(child);
+}
+function trasformCSTBottomUp(cst, transform) {
+    const children = cst.children.map(c => trasformCSTBottomUp(c, transform));
+    return transform(cst, children);
+}
+function cstToAstNode(node, children) {
+    if (node.type.startsWith("primitive/")) {
+        assert(children.length === 0);
+        const dataType = node.type.split("/", 2)[1];
+        const value = node.value;
+        const span = node.span;
+        switch (dataType) {
+            case "boolean":
+                assert(typeof value === "boolean");
+                return { type: "primitive", dataType, value, span, children: null };
+            case "char":
+                assert(typeof value === "string");
+                return { type: "primitive", dataType, value, span, children: null };
+            case "long":
+                assert(typeof value === "bigint");
+                return { type: "primitive", dataType, value, span, children: null };
+            case "byte":
+            case "unsigned-byte":
+            case "short":
+            case "unsigned-short":
+            case "int":
+            case "float":
+            case "double":
+                assert(typeof value === "number");
+                return { type: "primitive", dataType, value, span, children: null };
+            default:
+                throw new exc.InternalError(dataType);
+        }
+    }
+    switch (node.type) {
+        case "root": {
+            assert(children.length === 3);
+            const magic = children[0];
+            const version = children[1];
+            const contents = children[2];
+            assert(magic.type === "magic");
+            assert(version.type === "version");
+            assert(contents.type === "contents");
+            return { type: "root", span: node.span, children: [magic, version, contents] };
+        }
+        case "magic": {
+            assert(children.length === 0);
+            return { type: "magic", span: node.span, value: _1.default.STREAM_MAGIC, children: null };
+        }
+        case "version": {
+            assert(children.length === 0);
+            return { type: "version", span: node.span, value: _1.default.STREAM_VERSION, children: null };
+        }
+        case "contents": {
+            assert(children.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+            return { type: "contents", span: node.span, children: children };
+        }
+        case "blockdata-sequence": {
+            assert(children.every(c => c.type === "blockdata" || (c.type === "object" && c.objectType === "reset")));
+            const rawValues = node.value;
+            const values = rawValues.map(v => trasformCSTBottomUp(v, cstToAstNode));
+            assert(values.every(v => v.type === "primitive" || v.type === "utf"));
+            return { type: "blockdata-sequence", span: node.span, values, children };
+        }
+        case "blockdata": {
+            assert(children.length === 3);
+            const tc = children[0];
+            const length = children[1];
+            const bytes = children[2];
+            assert(tc.type === "tc");
+            assert(length.type === "primitive");
+            assert(bytes.type === "primitive" && bytes.dataType === "bytes");
+            if (tc.value === _1.default.TC_BLOCKDATA && length.dataType === "unsigned-byte") {
+                return { type: "blockdata", span: node.span, children: [tc, length, bytes] };
+            }
+            else if (tc.value === _1.default.TC_BLOCKDATALONG && length.dataType === "long") {
+                return { type: "blockdata", span: node.span, children: [tc, length, bytes] };
+            }
+            else {
+                throw new exc.InternalError();
+            }
+        }
+        case "tc": {
+            assert(children.length === 0);
+            assert(typeof node.value === "number" && _1.default.TC_BASE <= node.value && node.value <= _1.default.TC_MAX);
+            return { type: "tc", span: node.span, value: node.value, children: null };
+        }
+        case "read1": {
+            assert(children.length === 0);
+            assert(typeof node.value === "number");
+            return { type: "primitive", span: node.span, dataType: "unsigned-byte", value: node.value, children: null };
+        }
+        case "read": {
+            assert(children.length === 0);
+            return { type: "primitive", dataType: "bytes", span: node.span, value: null, children: null };
+        }
+        case "utf": {
+            assert(children.length === 2);
+            const length = children[0];
+            const body = children[1];
+            assert(length.type === "primitive" && length.dataType === "unsigned-short");
+            assert(body.type === "utf-body");
+            return { type: "utf", value: body.value, span: node.span, children: [length, body] };
+        }
+        case "long-utf": {
+            assert(children.length === 2);
+            const length = children[0];
+            const body = children[1];
+            assert(length.type === "primitive" && length.dataType === "long");
+            assert(body.type === "utf-body");
+            return { type: "long-utf", value: body.value, span: node.span, children: [length, body] };
+        }
+        case "utf-body": {
+            assert(children.length === 0);
+            assert(typeof node.value === "string");
+            return { type: "utf-body", value: node.value, span: node.span, children: null };
+        }
+        case "object/reset": {
+            assert(children.length === 1);
+            const tc = children[0];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_RESET);
+            assert(typeof node.value === "number");
+            return { type: "object", objectType: "reset", newEpoch: node.value, span: node.span, children: [tc] };
+        }
+        case "object/null": {
+            assert(children.length === 1);
+            const tc = children[0];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_NULL);
+            return { type: "object", objectType: "null", span: node.span, children: [tc] };
+        }
+        case "object/handle": {
+            assert(children.length === 2);
+            const tc = children[0];
+            const ref = children[1];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_REFERENCE);
+            assert(ref.type === "primitive" && ref.dataType === "int");
+            assert(typeof node.value === "number");
+            return { type: "object", objectType: "prev-object", span: node.span, value: { epoch: node.value, handle: ref.value }, children: [tc, ref] };
+        }
+        case "object/class": {
+            assert(children.length === 1);
+            const tc = children[0];
+            const desc = children[0];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_CLASS);
+            assertDescNode(desc);
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-class", span: node.span, handle: node.handle, children: [tc, desc] };
+        }
+        case "object/class-desc": {
+            assert(children.length === 1);
+            const first = children[0];
+            assertDescNode(first);
+            return first;
+        }
+        case "proxy-desc": {
+            assert(children.length >= 2);
+            const tc = children[0];
+            const numIfaces = children[1];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_PROXYCLASSDESC);
+            assert(numIfaces.type === "primitive" && numIfaces.dataType === "int");
+            assert(children.length >= 2 + numIfaces.value);
+            const ifaces = children.slice(2, 2 + numIfaces.value);
+            assert(ifaces.every(x => x.type === "utf"));
+            assert(children.length === 2 + numIfaces.value + 2);
+            const annotation = children[2 + numIfaces.value];
+            const superDesc = children[2 + numIfaces.value + 1];
+            assert(annotation.type === "annotation");
+            assertDescNode(superDesc);
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-class-desc", handle: node.handle, span: node.span, children: [tc, {
+                        type: "proxy-class-desc-info",
+                        span: { start: node.span.start + 1, end: node.span.end },
+                        children: [numIfaces, ...ifaces, annotation, superDesc],
+                    }] };
+        }
+        case "non-proxy-desc": {
+            assert(children.length === 7);
+            const tc = children[0];
+            const name = children[1];
+            const suid = children[2];
+            const flags = children[3];
+            const fields = children[4];
+            const annotation = children[5];
+            const superDesc = children[6];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_CLASSDESC);
+            assert(name.type === "utf");
+            assert(suid.type === "primitive" && suid.dataType === "long");
+            assert(flags.type === "primitive" && flags.dataType === "unsigned-byte");
+            assert(fields.type === "fields");
+            assert(annotation.type === "annotation");
+            assertDescNode(superDesc);
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-class-desc", handle: node.handle, span: node.span, children: [
+                    tc, name, suid, {
+                        type: "class-desc-info",
+                        span: { start: suid.span.end, end: node.span.end },
+                        children: [flags, fields, annotation, superDesc],
+                    }
+                ] };
+        }
+        case "object/string": {
+            assert(children.length > 0);
+            const first = children[0];
+            if (first.type === "object" && first.objectType === "prev-object")
+                return first;
+            assert(children.length === 2);
+            const tc = children[0];
+            const utf = children[1];
+            assert(tc.type === "tc");
+            if (tc.value === _1.default.TC_STRING) {
+                assert(utf.type === "utf");
+                assert(node.handle !== undefined);
+                return { type: "object", objectType: "new-string", value: utf.value, handle: node.handle, span: node.span, children: [tc, utf] };
+            }
+            else if (tc.value === _1.default.TC_LONGSTRING) {
+                assert(utf.type === "long-utf");
+                assert(node.handle !== undefined);
+                return { type: "object", objectType: "new-string", value: utf.value, handle: node.handle, span: node.span, children: [tc, utf] };
+            }
+            else {
+                throw new exc.InternalError();
+            }
+        }
+        case "object/array": {
+            assert(children.length >= 3);
+            const tc = children[0];
+            const desc = children[1];
+            const len = children[2];
+            const values = children.slice(3);
+            assert(tc.type === "tc" && tc.value === _1.default.TC_ARRAY);
+            assertDescNode(desc);
+            assert(len.type === "primitive" && len.dataType === "int");
+            assert(len.value === values.length);
+            assert(values.every(v => v.type === "primitive" || v.type === "object"));
+            const firstItem = values.length > 0 ? values[0] : null;
+            if (firstItem?.type === "primitive") {
+                assert(values.every(v => v.type === "primitive" && v.dataType === firstItem.dataType));
+            }
+            else {
+                assert(values.every(v => v.type === "object"));
+            }
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-array", handle: node.handle, span: node.span, children: [tc, desc, len, {
+                        type: "values", span: { start: len.span.end, end: node.span.end }, children: values
+                    }] };
+        }
+        case "object/enum": {
+            assert(children.length === 2);
+            const tc = children[0];
+            const desc = children[1];
+            const name = children[2];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_ENUM);
+            assertDescNode(desc);
+            assertStringNode(name);
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-enum", span: node.span, handle: node.handle, children: [tc, desc, name] };
+        }
+        case "object/instance": {
+            assert(children.length === 3);
+            const tc = children[0];
+            const desc = children[1];
+            const data = children[2];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_OBJECT);
+            assertDescNode(desc);
+            assert(data.type === "external-data" || data.type === "serial-data");
+            assert(node.handle !== undefined);
+            return { type: "object", objectType: "new-object", handle: node.handle, span: node.span, children: [tc, desc, data] };
+        }
+        case "external-data": {
+            // PROTOCOL_VERSION_1
+            if (children.every(c => c.type === "primitive" || c.type === "object" || c.type === "utf")) {
+                return { type: "external-data", protocolVersion: 1, span: node.span, children: children };
+            }
+            // PROTOCOL_VERSION_2
+            else {
+                assert(children.length > 0);
+                const annotation = children[children.length - 1];
+                assert(annotation.type === "annotation");
+                const before = children.slice(0, children.length - 1);
+                assert(before.every(c => c.type === "object" || c.type === "blockdata-sequence"));
+                const contents = annotation.children[0];
+                const endBlock = annotation.children[1];
+                const newContents = {
+                    type: "contents",
+                    span: { start: node.span.start, end: contents.span.end },
+                    children: [...before, ...contents.children],
+                };
+                return { type: "external-data", protocolVersion: 2, span: node.span, children: [{
+                            type: "annotation",
+                            span: node.span,
+                            children: [newContents, endBlock],
+                        }] };
+            }
+        }
+        case "serial-data": {
+            assert(children.every(c => c.type === "class-data"));
+            return { type: "serial-data", span: node.span, children: children };
+        }
+        case "class-data-wr": {
+            assert(children.length > 0);
+            const annotation = children[children.length - 1];
+            assert(annotation.type === "annotation");
+            let beforeValues;
+            let values;
+            let afterValues;
+            const valuesIdx = children.findIndex(c => c.type === "values");
+            if (valuesIdx === -1) {
+                beforeValues = [];
+                values = null;
+                const tempAfter = children.slice(0, -1);
+                assert(tempAfter.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+                afterValues = tempAfter;
+            }
+            else {
+                const tempBefore = children.slice(0, valuesIdx);
+                const tempValues = children[valuesIdx];
+                const tempAfter = children.slice(valuesIdx + 1, -1);
+                assert(tempBefore.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+                assert(tempValues.type === "values");
+                assert(tempAfter.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+                beforeValues = tempBefore;
+                values = tempValues;
+                afterValues = tempAfter;
+            }
+            const annotationSpan = {
+                start: afterValues.length > 0 ? afterValues[0].span.start : annotation.span.start,
+                end: annotation.span.end,
+            };
+            const annotationContentsSpan = { start: annotationSpan.start, end: annotationSpan.end - 1 };
+            const newAnnotation = {
+                type: "annotation",
+                span: annotationSpan,
+                children: [{
+                        type: "contents",
+                        span: annotationContentsSpan,
+                        children: [...afterValues, ...annotation.children[0].children],
+                    }, annotation.children[1]],
+            };
+            const constentsSpan = { start: node.span.start, end: values !== null ? values.span.start : -1 };
+            const contents = {
+                type: "contents",
+                span: constentsSpan,
+                children: [...beforeValues],
+            };
+            const beforeAnnotation = values !== null ? [contents, values] : [];
+            return { type: "class-data", writeMethod: true, span: node.span, children: [...beforeAnnotation, newAnnotation] };
+        }
+        case "class-data-no-wr": {
+            const hasValues = children.length > 0 && children[children.length - 1].type === "values";
+            const values = hasValues ? children[children.length - 1] : null;
+            assert(values === null || values.type === "values");
+            const before = children.slice(0, hasValues ? -1 : undefined);
+            assert(before.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+            const contentsStart = node.span.start;
+            const contentsEnd = before.length > 0 ? before[before.length - 1].span.end : values !== null ? values.span.start : node.span.end;
+            const contents = {
+                type: "contents",
+                span: { start: contentsStart, end: contentsEnd },
+                children: before,
+            };
+            const valuesNodes = values !== null ? [values] : [];
+            return { type: "class-data", writeMethod: false, span: node.span, children: [
+                    contents, ...valuesNodes,
+                ] };
+        }
+        case "object/exception": {
+            assert(node.error !== undefined);
+            assert(children.length === 2);
+            const tc = children[0];
+            const throwable = children[1];
+            assert(tc.type === "tc" && tc.value === _1.default.TC_EXCEPTION);
+            assert(throwable.type === "object" && (throwable.objectType === "new-object" || throwable.objectType === "prev-object"));
+            assert(typeof node.value === "number");
+            const newEpoch = node.value;
+            return { type: "object", objectType: "exception", exceptionEpoch: newEpoch - 1, newEpoch: newEpoch, span: node.span, children: [tc, throwable] };
+        }
+        case "annotation": {
+            assert(children.length > 0);
+            const contents = children.slice(0, -1);
+            const tc = children[children.length - 1];
+            assert(contents.every(c => c.type === "blockdata-sequence" || c.type === "object"));
+            assert(tc.type === "tc" && tc.value === _1.default.TC_ENDBLOCKDATA);
+            return { type: "annotation", span: node.span, children: [{
+                        type: "contents", span: { start: node.span.start, end: tc.span.start }, children: contents,
+                    }, tc] };
+        }
+        case "fields": {
+            assert(children.length > 0);
+            const length = children[0];
+            const fields = children.slice(1);
+            assert(length.type === "primitive" && length.dataType === "short");
+            assert(fields.every(f => f.type === "field-desc"));
+            return { type: "fields", span: node.span, children: [length, ...fields] };
+        }
+        case "field": {
+            assert(children.length >= 2);
+            const typecode = children[0];
+            const name = children[1];
+            assert(typecode.type === "primitive" && typecode.dataType === "unsigned-byte");
+            assert(name.type === "utf");
+            const tcStr = String.fromCharCode(typecode.value);
+            if (tcStr === "[" || tcStr === "L") {
+                assert(children.length === 3);
+                const className = children[2];
+                assertStringNode(className);
+                return { type: "field-desc", fieldType: "object", span: node.span, children: [typecode, name, className] };
+            }
+            else {
+                assert(children.length === 2);
+                return { type: "field-desc", fieldType: "primitive", span: node.span, children: [typecode, name] };
+            }
+        }
+        case "values": {
+            assert(children.every(c => c.type === "primitive" || c.type === "object"));
+            return { type: "values", span: node.span, children: children };
+        }
+        default:
+            throw new exc.InternalError();
+    }
+}
+function assertDescNode(node) {
+    assert(node.type === "object" &&
+        (node.objectType === "new-class-desc" || node.objectType === "null" || node.objectType === "prev-object"));
+}
+function assertStringNode(node) {
+    assert(node.type === "object" &&
+        (node.objectType === "new-string" || node.objectType === "prev-object"));
+}
+//# sourceMappingURL=ois-ast.js.map