xhs-mp-pack 1.1.0-beta.0

package/dist/serialization/middlewares/BinaryMiddleware.js

@@ -0,0 +1,955 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const memoize_1 = __importDefault(require("@/base/memoize"));
+const SerializerMiddleware_1 = __importDefault(require("../SerializerMiddleware"));
+/*
+Format:
+
+File -> Section*
+
+Section -> NullsSection |
+                     BooleansSection |
+                     F64NumbersSection |
+                     I32NumbersSection |
+                     I8NumbersSection |
+                     ShortStringSection |
+                     BigIntSection |
+                     I32BigIntSection |
+                     I8BigIntSection
+                     StringSection |
+                     BufferSection |
+                     NopSection
+
+NullsSection ->
+    NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
+    Nulls8HeaderByte 0xnn (n:count - 4) |
+    Nulls32HeaderByte n:ui32 (n:count - 260) |
+BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
+F64NumbersSection -> F64NumbersSectionHeaderByte f64*
+I32NumbersSection -> I32NumbersSectionHeaderByte i32*
+I8NumbersSection -> I8NumbersSectionHeaderByte i8*
+ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
+StringSection -> StringSectionHeaderByte i32:length utf8-byte*
+BufferSection -> BufferSectionHeaderByte i32:length byte*
+NopSection --> NopSectionHeaderByte
+BigIntSection -> BigIntSectionHeaderByte i32:length ascii-byte*
+I32BigIntSection -> I32BigIntSectionHeaderByte i32
+I8BigIntSection -> I8BigIntSectionHeaderByte i8
+
+ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
+
+F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
+I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
+I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
+
+NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
+BooleansCountAndBitsByte ->
+    0b0000_1xxx (count = 3) |
+    0b0001_xxxx (count = 4) |
+    0b001x_xxxx (count = 5) |
+    0b01xx_xxxx (count = 6) |
+    0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
+    0xff n:ui32 (n:count, 134 <= count < 2^32)
+
+StringSectionHeaderByte -> 0b0000_1110
+BufferSectionHeaderByte -> 0b0000_1111
+NopSectionHeaderByte -> 0b0000_1011
+BigIntSectionHeaderByte -> 0b0001_1010
+I32BigIntSectionHeaderByte -> 0b0001_1100
+I8BigIntSectionHeaderByte -> 0b0001_1011
+FalseHeaderByte -> 0b0000_1100
+TrueHeaderByte -> 0b0000_1101
+
+RawNumber -> n (n <= 10)
+
+*/
+const LAZY_HEADER = 0x0b;
+const TRUE_HEADER = 0x0c;
+const FALSE_HEADER = 0x0d;
+const BOOLEANS_HEADER = 0x0e;
+const NULL_HEADER = 0x10;
+const NULL2_HEADER = 0x11;
+const NULL3_HEADER = 0x12;
+const NULLS8_HEADER = 0x13;
+const NULLS32_HEADER = 0x14;
+const NULL_AND_I8_HEADER = 0x15;
+const NULL_AND_I32_HEADER = 0x16;
+const NULL_AND_TRUE_HEADER = 0x17;
+const NULL_AND_FALSE_HEADER = 0x18;
+const BIGINT_HEADER = 0x1a;
+const BIGINT_I8_HEADER = 0x1b;
+const BIGINT_I32_HEADER = 0x1c;
+const STRING_HEADER = 0x1e;
+const BUFFER_HEADER = 0x1f;
+const I8_HEADER = 0x60;
+const I32_HEADER = 0x40;
+const F64_HEADER = 0x20;
+const SHORT_STRING_HEADER = 0x80;
+/** Uplift high-order bits */
+const NUMBERS_HEADER_MASK = 0xe0; // 0b1010_0000
+const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
+const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
+const HEADER_SIZE = 1;
+const I8_SIZE = 1;
+const I32_SIZE = 4;
+const F64_SIZE = 8;
+const MEASURE_START_OPERATION = Symbol('MEASURE_START_OPERATION');
+const MEASURE_END_OPERATION = Symbol('MEASURE_END_OPERATION');
+const identifyNumber = (n) => {
+    if (n === (n | 0)) {
+        if (n <= 127 && n >= -128)
+            return 0;
+        if (n <= 2147483647 && n >= -2147483648)
+            return 1;
+    }
+    return 2;
+};
+const identifyBigInt = (n) => {
+    if (n <= BigInt(127) && n >= BigInt(-128))
+        return 0;
+    if (n <= BigInt(2147483647) && n >= BigInt(-2147483648))
+        return 1;
+    return 2;
+};
+class BinaryMiddleware extends SerializerMiddleware_1.default {
+    serialize(data, context) {
+        return this._serialize(data, context);
+    }
+    _serializeLazy(fn, context) {
+        return SerializerMiddleware_1.default.serializeLazy(fn, data => this._serialize(data, context));
+    }
+    _serialize(data, context, allocationScope = {
+        allocationSize: 1024,
+        increaseCounter: 0,
+        leftOverBuffer: null,
+    }) {
+        let leftOverBuffer = null;
+        let buffers = [];
+        let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
+        allocationScope.leftOverBuffer = null;
+        let currentPosition = 0;
+        if (currentBuffer === null) {
+            currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
+        }
+        const allocate = bytesNeeded => {
+            if (currentBuffer !== null) {
+                if (currentBuffer.length - currentPosition >= bytesNeeded)
+                    return;
+                flush();
+            }
+            if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
+                currentBuffer = leftOverBuffer;
+                leftOverBuffer = null;
+            }
+            else {
+                currentBuffer = Buffer.allocUnsafe(Math.max(bytesNeeded, allocationScope.allocationSize));
+                if (!(allocationScope.increaseCounter = (allocationScope.increaseCounter + 1) % 4) &&
+                    allocationScope.allocationSize < 16777216) {
+                    allocationScope.allocationSize <<= 1;
+                }
+            }
+        };
+        const flush = () => {
+            if (currentBuffer !== null) {
+                if (currentPosition > 0) {
+                    buffers.push(Buffer.from(currentBuffer.buffer, currentBuffer.byteOffset, currentPosition));
+                }
+                if (!leftOverBuffer || leftOverBuffer.length < currentBuffer.length - currentPosition) {
+                    leftOverBuffer = Buffer.from(currentBuffer.buffer, currentBuffer.byteOffset + currentPosition, currentBuffer.byteLength - currentPosition);
+                }
+                // @ts-ignore
+                currentBuffer = null;
+                currentPosition = 0;
+            }
+        };
+        const writeU8 = byte => {
+            currentBuffer.writeUInt8(byte, currentPosition++);
+        };
+        const writeU32 = ui32 => {
+            currentBuffer.writeUInt32LE(ui32, currentPosition);
+            currentPosition += 4;
+        };
+        const measureStack = [];
+        const measureStart = () => {
+            measureStack.push(buffers.length, currentPosition);
+        };
+        const measureEnd = () => {
+            const oldPos = measureStack.pop();
+            const buffersIndex = measureStack.pop();
+            let size = currentPosition - oldPos;
+            for (let i = buffersIndex; i < buffers.length; i++) {
+                size += buffers[i].length;
+            }
+            return size;
+        };
+        for (let i = 0; i < data.length; i++) {
+            const thing = data[i];
+            switch (typeof thing) {
+                case 'function': {
+                    if (!SerializerMiddleware_1.default.isLazy(thing))
+                        throw new Error(`Unexpected function ${thing}`);
+                    let serializedData = SerializerMiddleware_1.default.getLazySerializedValue(thing);
+                    if (serializedData === undefined) {
+                        if (SerializerMiddleware_1.default.isLazy(thing, this)) {
+                            flush();
+                            allocationScope.leftOverBuffer = leftOverBuffer;
+                            const result = thing();
+                            const data = this._serialize(result, context, allocationScope);
+                            leftOverBuffer = allocationScope.leftOverBuffer;
+                            allocationScope.leftOverBuffer = null;
+                            SerializerMiddleware_1.default.setLazySerializedValue(thing, data);
+                            serializedData = data;
+                        }
+                        else {
+                            serializedData = this._serializeLazy(thing, context);
+                            flush();
+                            buffers.push(serializedData);
+                            break;
+                        }
+                    }
+                    else if (typeof serializedData === 'function') {
+                        flush();
+                        buffers.push(serializedData);
+                        break;
+                    }
+                    const lengths = [];
+                    for (const item of serializedData) {
+                        let last;
+                        if (typeof item === 'function') {
+                            lengths.push(0);
+                        }
+                        else if (item.length === 0) {
+                            // ignore
+                            // eslint-disable-next-line no-cond-assign
+                        }
+                        else if (lengths.length > 0 && (last = lengths[lengths.length - 1]) !== 0) {
+                            const remaining = 0xffffffff - last;
+                            if (remaining >= item.length) {
+                                lengths[lengths.length - 1] += item.length;
+                            }
+                            else {
+                                lengths.push(item.length - remaining);
+                                lengths[lengths.length - 2] = 0xffffffff;
+                            }
+                        }
+                        else {
+                            lengths.push(item.length);
+                        }
+                    }
+                    allocate(5 + lengths.length * 4);
+                    writeU8(LAZY_HEADER);
+                    writeU32(lengths.length);
+                    for (const l of lengths) {
+                        writeU32(l);
+                    }
+                    flush();
+                    for (const item of serializedData) {
+                        buffers.push(item);
+                    }
+                    break;
+                }
+                case 'string': {
+                    const len = Buffer.byteLength(thing);
+                    if (len >= 128 || len !== thing.length) {
+                        allocate(len + HEADER_SIZE + I32_SIZE);
+                        writeU8(STRING_HEADER);
+                        writeU32(len);
+                        currentBuffer.write(thing, currentPosition);
+                        currentPosition += len;
+                    }
+                    else if (len >= 70) {
+                        allocate(len + HEADER_SIZE);
+                        writeU8(SHORT_STRING_HEADER | len);
+                        currentBuffer.write(thing, currentPosition, 'latin1');
+                        currentPosition += len;
+                    }
+                    else {
+                        allocate(len + HEADER_SIZE);
+                        writeU8(SHORT_STRING_HEADER | len);
+                        for (let i = 0; i < len; i++) {
+                            currentBuffer[currentPosition++] = thing.charCodeAt(i);
+                        }
+                    }
+                    break;
+                }
+                case 'bigint': {
+                    const type = identifyBigInt(thing);
+                    if (type === 0 && thing >= 0 && thing <= BigInt(10)) {
+                        // shortcut for very small bigints
+                        allocate(HEADER_SIZE + I8_SIZE);
+                        writeU8(BIGINT_I8_HEADER);
+                        writeU8(Number(thing));
+                        break;
+                    }
+                    switch (type) {
+                        case 0: {
+                            let n = 1;
+                            allocate(HEADER_SIZE + I8_SIZE * n);
+                            writeU8(BIGINT_I8_HEADER | (n - 1));
+                            while (n > 0) {
+                                currentBuffer.writeInt8(Number(data[i]), currentPosition);
+                                currentPosition += I8_SIZE;
+                                n--;
+                                i++;
+                            }
+                            i--;
+                            break;
+                        }
+                        case 1: {
+                            let n = 1;
+                            allocate(HEADER_SIZE + I32_SIZE * n);
+                            writeU8(BIGINT_I32_HEADER | (n - 1));
+                            while (n > 0) {
+                                currentBuffer.writeInt32LE(Number(data[i]), currentPosition);
+                                currentPosition += I32_SIZE;
+                                n--;
+                                i++;
+                            }
+                            i--;
+                            break;
+                        }
+                        default: {
+                            const value = thing.toString();
+                            const len = Buffer.byteLength(value);
+                            allocate(len + HEADER_SIZE + I32_SIZE);
+                            writeU8(BIGINT_HEADER);
+                            writeU32(len);
+                            currentBuffer.write(value, currentPosition);
+                            currentPosition += len;
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case 'number': {
+                    const type = identifyNumber(thing);
+                    if (type === 0 && thing >= 0 && thing <= 10) {
+                        // shortcut for very small numbers
+                        allocate(I8_SIZE);
+                        writeU8(thing);
+                        break;
+                    }
+                    /**
+                     * amount of numbers to write
+                     * @type {number}
+                     */
+                    let n = 1;
+                    for (; n < 32 && i + n < data.length; n++) {
+                        const item = data[i + n];
+                        if (typeof item !== 'number')
+                            break;
+                        if (identifyNumber(item) !== type)
+                            break;
+                    }
+                    switch (type) {
+                        case 0:
+                            allocate(HEADER_SIZE + I8_SIZE * n);
+                            writeU8(I8_HEADER | (n - 1));
+                            while (n > 0) {
+                                currentBuffer.writeInt8(data[i], currentPosition);
+                                currentPosition += I8_SIZE;
+                                n--;
+                                i++;
+                            }
+                            break;
+                        case 1:
+                            allocate(HEADER_SIZE + I32_SIZE * n);
+                            writeU8(I32_HEADER | (n - 1));
+                            while (n > 0) {
+                                currentBuffer.writeInt32LE(data[i], currentPosition);
+                                currentPosition += I32_SIZE;
+                                n--;
+                                i++;
+                            }
+                            break;
+                        case 2:
+                            allocate(HEADER_SIZE + F64_SIZE * n);
+                            writeU8(F64_HEADER | (n - 1));
+                            while (n > 0) {
+                                currentBuffer.writeDoubleLE(data[i], currentPosition);
+                                currentPosition += F64_SIZE;
+                                n--;
+                                i++;
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                    i--;
+                    break;
+                }
+                case 'boolean': {
+                    let lastByte = thing === true ? 1 : 0;
+                    const bytes = [];
+                    let count = 1;
+                    let n;
+                    for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
+                        const item = data[i + n];
+                        if (typeof item !== 'boolean')
+                            break;
+                        const pos = count & 0x7;
+                        if (pos === 0) {
+                            bytes.push(lastByte);
+                            lastByte = item === true ? 1 : 0;
+                        }
+                        else if (item === true) {
+                            lastByte |= 1 << pos;
+                        }
+                        count++;
+                    }
+                    i += count - 1;
+                    if (count === 1) {
+                        allocate(HEADER_SIZE);
+                        writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
+                    }
+                    else if (count === 2) {
+                        allocate(HEADER_SIZE * 2);
+                        writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
+                        writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
+                    }
+                    else if (count <= 6) {
+                        allocate(HEADER_SIZE + I8_SIZE);
+                        writeU8(BOOLEANS_HEADER);
+                        writeU8((1 << count) | lastByte);
+                    }
+                    else if (count <= 133) {
+                        allocate(HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+                        writeU8(BOOLEANS_HEADER);
+                        writeU8(0x80 | (count - 7));
+                        for (const byte of bytes)
+                            writeU8(byte);
+                        writeU8(lastByte);
+                    }
+                    else {
+                        allocate(HEADER_SIZE + I8_SIZE + I32_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+                        writeU8(BOOLEANS_HEADER);
+                        writeU8(0xff);
+                        writeU32(count);
+                        for (const byte of bytes)
+                            writeU8(byte);
+                        writeU8(lastByte);
+                    }
+                    break;
+                }
+                case 'object': {
+                    if (thing === null) {
+                        let n;
+                        for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
+                            const item = data[i + n];
+                            if (item !== null)
+                                break;
+                        }
+                        i += n - 1;
+                        if (n === 1) {
+                            if (i + 1 < data.length) {
+                                const next = data[i + 1];
+                                if (next === true) {
+                                    allocate(HEADER_SIZE);
+                                    writeU8(NULL_AND_TRUE_HEADER);
+                                    i++;
+                                }
+                                else if (next === false) {
+                                    allocate(HEADER_SIZE);
+                                    writeU8(NULL_AND_FALSE_HEADER);
+                                    i++;
+                                }
+                                else if (typeof next === 'number') {
+                                    const type = identifyNumber(next);
+                                    if (type === 0) {
+                                        allocate(HEADER_SIZE + I8_SIZE);
+                                        writeU8(NULL_AND_I8_HEADER);
+                                        currentBuffer.writeInt8(next, currentPosition);
+                                        currentPosition += I8_SIZE;
+                                        i++;
+                                    }
+                                    else if (type === 1) {
+                                        allocate(HEADER_SIZE + I32_SIZE);
+                                        writeU8(NULL_AND_I32_HEADER);
+                                        currentBuffer.writeInt32LE(next, currentPosition);
+                                        currentPosition += I32_SIZE;
+                                        i++;
+                                    }
+                                    else {
+                                        allocate(HEADER_SIZE);
+                                        writeU8(NULL_HEADER);
+                                    }
+                                }
+                                else {
+                                    allocate(HEADER_SIZE);
+                                    writeU8(NULL_HEADER);
+                                }
+                            }
+                            else {
+                                allocate(HEADER_SIZE);
+                                writeU8(NULL_HEADER);
+                            }
+                        }
+                        else if (n === 2) {
+                            allocate(HEADER_SIZE);
+                            writeU8(NULL2_HEADER);
+                        }
+                        else if (n === 3) {
+                            allocate(HEADER_SIZE);
+                            writeU8(NULL3_HEADER);
+                        }
+                        else if (n < 260) {
+                            allocate(HEADER_SIZE + I8_SIZE);
+                            writeU8(NULLS8_HEADER);
+                            writeU8(n - 4);
+                        }
+                        else {
+                            allocate(HEADER_SIZE + I32_SIZE);
+                            writeU8(NULLS32_HEADER);
+                            writeU32(n - 260);
+                        }
+                    }
+                    else if (Buffer.isBuffer(thing)) {
+                        if (thing.length < 8192) {
+                            allocate(HEADER_SIZE + I32_SIZE + thing.length);
+                            writeU8(BUFFER_HEADER);
+                            writeU32(thing.length);
+                            thing.copy(currentBuffer, currentPosition);
+                            currentPosition += thing.length;
+                        }
+                        else {
+                            allocate(HEADER_SIZE + I32_SIZE);
+                            writeU8(BUFFER_HEADER);
+                            writeU32(thing.length);
+                            flush();
+                            buffers.push(thing);
+                        }
+                    }
+                    break;
+                }
+                case 'symbol': {
+                    if (thing === MEASURE_START_OPERATION) {
+                        measureStart();
+                    }
+                    else if (thing === MEASURE_END_OPERATION) {
+                        const size = measureEnd();
+                        allocate(HEADER_SIZE + I32_SIZE);
+                        writeU8(I32_HEADER);
+                        currentBuffer.writeInt32LE(size, currentPosition);
+                        currentPosition += I32_SIZE;
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        flush();
+        allocationScope.leftOverBuffer = leftOverBuffer;
+        // avoid leaking memory
+        // @ts-ignore
+        currentBuffer = null;
+        leftOverBuffer = null;
+        allocationScope = undefined;
+        const _buffers = buffers;
+        // @ts-ignore
+        buffers = undefined;
+        return _buffers;
+    }
+    deserialize(data, context) {
+        return this._deserialize(data, context);
+    }
+    _createLazyDeserialized(content, context) {
+        return SerializerMiddleware_1.default.createLazy((0, memoize_1.default)(() => this._deserialize(content, context)), this, {}, content);
+    }
+    _deserializeLazy(fn, context) {
+        return SerializerMiddleware_1.default.deserializeLazy(fn, data => this._deserialize(data, context));
+    }
+    _deserialize(data, context) {
+        let currentDataItem = 0;
+        let currentBuffer = data[0];
+        let currentIsBuffer = Buffer.isBuffer(currentBuffer);
+        let currentPosition = 0;
+        let result = [];
+        const retainedBuffer = context.retainedBuffer || (x => x);
+        const checkOverflow = () => {
+            if (currentPosition >= currentBuffer.length) {
+                currentPosition = 0;
+                currentDataItem++;
+                currentBuffer = currentDataItem < data.length ? data[currentDataItem] : null;
+                currentIsBuffer = Buffer.isBuffer(currentBuffer);
+            }
+        };
+        const isInCurrentBuffer = n => currentIsBuffer && n + currentPosition <= currentBuffer.length;
+        const ensureBuffer = () => {
+            if (!currentIsBuffer) {
+                throw new Error(currentBuffer === null ? 'Unexpected end of stream' : 'Unexpected lazy element in stream');
+            }
+        };
+        const read = n => {
+            ensureBuffer();
+            const rem = currentBuffer.length - currentPosition;
+            if (rem < n) {
+                const buffers = [read(rem)];
+                n -= rem;
+                ensureBuffer();
+                while (currentBuffer.length < n) {
+                    const b = currentBuffer;
+                    buffers.push(b);
+                    n -= b.length;
+                    currentDataItem++;
+                    currentBuffer = currentDataItem < data.length ? data[currentDataItem] : null;
+                    currentIsBuffer = Buffer.isBuffer(currentBuffer);
+                    ensureBuffer();
+                }
+                buffers.push(read(n));
+                return Buffer.concat(buffers);
+            }
+            const b = currentBuffer;
+            const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+            currentPosition += n;
+            checkOverflow();
+            return res;
+        };
+        const readUpTo = n => {
+            ensureBuffer();
+            const rem = currentBuffer.length - currentPosition;
+            if (rem < n) {
+                n = rem;
+            }
+            const b = currentBuffer;
+            const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+            currentPosition += n;
+            checkOverflow();
+            return res;
+        };
+        const readU8 = () => {
+            ensureBuffer();
+            /**
+             * There is no need to check remaining buffer size here
+             * since {@link checkOverflow} guarantees at least one byte remaining
+             */
+            const byte = currentBuffer.readUInt8(currentPosition);
+            currentPosition += I8_SIZE;
+            checkOverflow();
+            return byte;
+        };
+        /**
+         * @returns {number} U32
+         */
+        const readU32 = () => read(I32_SIZE).readUInt32LE(0);
+        const readBits = (data, n) => {
+            let mask = 1;
+            while (n !== 0) {
+                result.push((data & mask) !== 0);
+                mask <<= 1;
+                n--;
+            }
+        };
+        const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
+            switch (header) {
+                case LAZY_HEADER:
+                    return () => {
+                        const count = readU32();
+                        const lengths = Array.from({ length: count }).map(() => readU32());
+                        const content = [];
+                        for (let l of lengths) {
+                            if (l === 0) {
+                                if (typeof currentBuffer !== 'function') {
+                                    throw new Error('Unexpected non-lazy element in stream');
+                                }
+                                content.push(currentBuffer);
+                                currentDataItem++;
+                                currentBuffer = currentDataItem < data.length ? data[currentDataItem] : null;
+                                currentIsBuffer = Buffer.isBuffer(currentBuffer);
+                            }
+                            else {
+                                do {
+                                    const buf = readUpTo(l);
+                                    l -= buf.length;
+                                    content.push(retainedBuffer(buf));
+                                } while (l > 0);
+                            }
+                        }
+                        result.push(this._createLazyDeserialized(content, context));
+                    };
+                case BUFFER_HEADER:
+                    return () => {
+                        const len = readU32();
+                        result.push(retainedBuffer(read(len)));
+                    };
+                case TRUE_HEADER:
+                    return () => result.push(true);
+                case FALSE_HEADER:
+                    return () => result.push(false);
+                case NULL3_HEADER:
+                    return () => result.push(null, null, null);
+                case NULL2_HEADER:
+                    return () => result.push(null, null);
+                case NULL_HEADER:
+                    return () => result.push(null);
+                case NULL_AND_TRUE_HEADER:
+                    return () => result.push(null, true);
+                case NULL_AND_FALSE_HEADER:
+                    return () => result.push(null, false);
+                case NULL_AND_I8_HEADER:
+                    return () => {
+                        if (currentIsBuffer) {
+                            result.push(null, currentBuffer.readInt8(currentPosition));
+                            currentPosition += I8_SIZE;
+                            checkOverflow();
+                        }
+                        else {
+                            result.push(null, read(I8_SIZE).readInt8(0));
+                        }
+                    };
+                case NULL_AND_I32_HEADER:
+                    return () => {
+                        result.push(null);
+                        if (isInCurrentBuffer(I32_SIZE)) {
+                            result.push(currentBuffer.readInt32LE(currentPosition));
+                            currentPosition += I32_SIZE;
+                            checkOverflow();
+                        }
+                        else {
+                            result.push(read(I32_SIZE).readInt32LE(0));
+                        }
+                    };
+                case NULLS8_HEADER:
+                    return () => {
+                        const len = readU8() + 4;
+                        for (let i = 0; i < len; i++) {
+                            result.push(null);
+                        }
+                    };
+                case NULLS32_HEADER:
+                    return () => {
+                        const len = readU32() + 260;
+                        for (let i = 0; i < len; i++) {
+                            result.push(null);
+                        }
+                    };
+                case BOOLEANS_HEADER:
+                    return () => {
+                        const innerHeader = readU8();
+                        if ((innerHeader & 0xf0) === 0) {
+                            readBits(innerHeader, 3);
+                        }
+                        else if ((innerHeader & 0xe0) === 0) {
+                            readBits(innerHeader, 4);
+                        }
+                        else if ((innerHeader & 0xc0) === 0) {
+                            readBits(innerHeader, 5);
+                        }
+                        else if ((innerHeader & 0x80) === 0) {
+                            readBits(innerHeader, 6);
+                        }
+                        else if (innerHeader !== 0xff) {
+                            let count = (innerHeader & 0x7f) + 7;
+                            while (count > 8) {
+                                readBits(readU8(), 8);
+                                count -= 8;
+                            }
+                            readBits(readU8(), count);
+                        }
+                        else {
+                            let count = readU32();
+                            while (count > 8) {
+                                readBits(readU8(), 8);
+                                count -= 8;
+                            }
+                            readBits(readU8(), count);
+                        }
+                    };
+                case STRING_HEADER:
+                    return () => {
+                        const len = readU32();
+                        if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+                            result.push(currentBuffer.toString(undefined, currentPosition, currentPosition + len));
+                            currentPosition += len;
+                            checkOverflow();
+                        }
+                        else {
+                            result.push(read(len).toString());
+                        }
+                    };
+                case SHORT_STRING_HEADER:
+                    return () => result.push('');
+                case SHORT_STRING_HEADER | 1:
+                    return () => {
+                        if (currentIsBuffer && currentPosition < 0x7ffffffe) {
+                            result.push(currentBuffer.toString('latin1', currentPosition, currentPosition + 1));
+                            currentPosition++;
+                            checkOverflow();
+                        }
+                        else {
+                            result.push(read(1).toString('latin1'));
+                        }
+                    };
+                case I8_HEADER:
+                    return () => {
+                        if (currentIsBuffer) {
+                            result.push(currentBuffer.readInt8(currentPosition));
+                            currentPosition++;
+                            checkOverflow();
+                        }
+                        else {
+                            result.push(read(1).readInt8(0));
+                        }
+                    };
+                case BIGINT_I8_HEADER: {
+                    const len = 1;
+                    return () => {
+                        const need = I8_SIZE * len;
+                        if (isInCurrentBuffer(need)) {
+                            for (let i = 0; i < len; i++) {
+                                const value = currentBuffer.readInt8(currentPosition);
+                                result.push(BigInt(value));
+                                currentPosition += I8_SIZE;
+                            }
+                            checkOverflow();
+                        }
+                        else {
+                            const buf = read(need);
+                            for (let i = 0; i < len; i++) {
+                                const value = buf.readInt8(i * I8_SIZE);
+                                result.push(BigInt(value));
+                            }
+                        }
+                    };
+                }
+                case BIGINT_I32_HEADER: {
+                    const len = 1;
+                    return () => {
+                        const need = I32_SIZE * len;
+                        if (isInCurrentBuffer(need)) {
+                            for (let i = 0; i < len; i++) {
+                                const value = currentBuffer.readInt32LE(currentPosition);
+                                result.push(BigInt(value));
+                                currentPosition += I32_SIZE;
+                            }
+                            checkOverflow();
+                        }
+                        else {
+                            const buf = read(need);
+                            for (let i = 0; i < len; i++) {
+                                const value = buf.readInt32LE(i * I32_SIZE);
+                                result.push(BigInt(value));
+                            }
+                        }
+                    };
+                }
+                case BIGINT_HEADER: {
+                    return () => {
+                        const len = readU32();
+                        if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+                            const value = currentBuffer.toString(undefined, currentPosition, currentPosition + len);
+                            result.push(BigInt(value));
+                            currentPosition += len;
+                            checkOverflow();
+                        }
+                        else {
+                            const value = read(len).toString();
+                            result.push(BigInt(value));
+                        }
+                    };
+                }
+                default:
+                    if (header <= 10) {
+                        return () => result.push(header);
+                    }
+                    if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
+                        const len = header & SHORT_STRING_LENGTH_MASK;
+                        return () => {
+                            if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+                                result.push(currentBuffer.toString('latin1', currentPosition, currentPosition + len));
+                                currentPosition += len;
+                                checkOverflow();
+                            }
+                            else {
+                                result.push(read(len).toString('latin1'));
+                            }
+                        };
+                    }
+                    if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
+                        const len = (header & NUMBERS_COUNT_MASK) + 1;
+                        return () => {
+                            const need = F64_SIZE * len;
+                            if (isInCurrentBuffer(need)) {
+                                for (let i = 0; i < len; i++) {
+                                    result.push(currentBuffer.readDoubleLE(currentPosition));
+                                    currentPosition += F64_SIZE;
+                                }
+                                checkOverflow();
+                            }
+                            else {
+                                const buf = read(need);
+                                for (let i = 0; i < len; i++) {
+                                    result.push(buf.readDoubleLE(i * F64_SIZE));
+                                }
+                            }
+                        };
+                    }
+                    if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
+                        const len = (header & NUMBERS_COUNT_MASK) + 1;
+                        return () => {
+                            const need = I32_SIZE * len;
+                            if (isInCurrentBuffer(need)) {
+                                for (let i = 0; i < len; i++) {
+                                    result.push(currentBuffer.readInt32LE(currentPosition));
+                                    currentPosition += I32_SIZE;
+                                }
+                                checkOverflow();
+                            }
+                            else {
+                                const buf = read(need);
+                                for (let i = 0; i < len; i++) {
+                                    result.push(buf.readInt32LE(i * I32_SIZE));
+                                }
+                            }
+                        };
+                    }
+                    if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
+                        const len = (header & NUMBERS_COUNT_MASK) + 1;
+                        return () => {
+                            const need = I8_SIZE * len;
+                            if (isInCurrentBuffer(need)) {
+                                for (let i = 0; i < len; i++) {
+                                    result.push(currentBuffer.readInt8(currentPosition));
+                                    currentPosition += I8_SIZE;
+                                }
+                                checkOverflow();
+                            }
+                            else {
+                                const buf = read(need);
+                                for (let i = 0; i < len; i++) {
+                                    result.push(buf.readInt8(i * I8_SIZE));
+                                }
+                            }
+                        };
+                    }
+                    return () => {
+                        throw new Error(`Unexpected header byte 0x${header.toString(16)}`);
+                    };
+            }
+        });
+        while (currentBuffer !== null) {
+            if (typeof currentBuffer === 'function') {
+                result.push(this._deserializeLazy(currentBuffer, context));
+                currentDataItem++;
+                currentBuffer = currentDataItem < data.length ? data[currentDataItem] : null;
+                currentIsBuffer = Buffer.isBuffer(currentBuffer);
+            }
+            else {
+                const header = readU8();
+                dispatchTable[header]();
+            }
+        }
+        // avoid leaking memory in context
+        const _result = result;
+        result = undefined;
+        return _result;
+    }
+}
+// @ts-ignore
+BinaryMiddleware.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+// @ts-ignore
+BinaryMiddleware.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+exports.default = BinaryMiddleware;