gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/esm/structure/io/binary/GraphBinary.d.ts

@@ -1,3 +1,4 @@
+export function createPreciseReader(): GraphBinaryReader;
 export { default as DataType } from "./internals/DataType.js";
 export const serializers: {};
 export const intSerializer: IntSerializer;
@@ -15,6 +16,7 @@ export const pathSerializer: PathSerializer;
 export const propertySerializer: PropertySerializer;
 export const vertexSerializer: VertexSerializer;
 export const vertexPropertySerializer: VertexPropertySerializer;
+export const graphSerializer: GraphSerializer;
 export const bigIntegerSerializer: BigIntegerSerializer;
 export const byteSerializer: ByteSerializer;
 export const binarySerializer: BinarySerializer;
@@ -23,11 +25,15 @@ export const booleanSerializer: BooleanSerializer;
 export const markerSerializer: MarkerSerializer;
 export const unspecifiedNullSerializer: UnspecifiedNullSerializer;
 export const enumSerializer: EnumSerializer;
+export const compositePDTSerializer: CompositePDTSerializer;
+export const primitivePDTSerializer: PrimitivePDTSerializer;
+export const treeSerializer: TreeSerializer;
 export const numberSerializationStrategy: NumberSerializationStrategy;
 export const anySerializer: AnySerializer;
 export const graphBinaryReader: GraphBinaryReader;
 export const graphBinaryWriter: GraphBinaryWriter;
 export default ioc;
+import GraphBinaryReader from './internals/GraphBinaryReader.js';
 import IntSerializer from './internals/IntSerializer.js';
 import LongSerializer from './internals/LongSerializer.js';
 import StringSerializer from './internals/StringSerializer.js';
@@ -43,6 +49,7 @@ import PathSerializer from './internals/PathSerializer.js';
 import PropertySerializer from './internals/PropertySerializer.js';
 import VertexSerializer from './internals/VertexSerializer.js';
 import VertexPropertySerializer from './internals/VertexPropertySerializer.js';
+import GraphSerializer from './internals/GraphSerializer.js';
 import BigIntegerSerializer from './internals/BigIntegerSerializer.js';
 import ByteSerializer from './internals/ByteSerializer.js';
 import BinarySerializer from './internals/BinarySerializer.js';
@@ -51,9 +58,11 @@ import BooleanSerializer from './internals/BooleanSerializer.js';
 import MarkerSerializer from './internals/MarkerSerializer.js';
 import UnspecifiedNullSerializer from './internals/UnspecifiedNullSerializer.js';
 import EnumSerializer from './internals/EnumSerializer.js';
+import CompositePDTSerializer from './internals/CompositePDTSerializer.js';
+import PrimitivePDTSerializer from './internals/PrimitivePDTSerializer.js';
+import TreeSerializer from './internals/TreeSerializer.js';
 import NumberSerializationStrategy from './internals/NumberSerializationStrategy.js';
 import AnySerializer from './internals/AnySerializer.js';
-import GraphBinaryReader from './internals/GraphBinaryReader.js';
 import GraphBinaryWriter from './internals/GraphBinaryWriter.js';
 declare namespace ioc {
     export { DataType };
@@ -74,6 +83,7 @@ declare namespace ioc {
     export let propertySerializer: PropertySerializer;
     export let vertexSerializer: VertexSerializer;
     export let vertexPropertySerializer: VertexPropertySerializer;
+    export let graphSerializer: GraphSerializer;
     export let bigIntegerSerializer: BigIntegerSerializer;
     export let byteSerializer: ByteSerializer;
     export let binarySerializer: BinarySerializer;
@@ -82,6 +92,10 @@ declare namespace ioc {
     export let markerSerializer: MarkerSerializer;
     export let unspecifiedNullSerializer: UnspecifiedNullSerializer;
     export let enumSerializer: EnumSerializer;
+    export let compositePDTSerializer: CompositePDTSerializer;
+    export let primitivePDTSerializer: PrimitivePDTSerializer;
+    export let treeSerializer: TreeSerializer;
+    export let pdtRegistry: any;
     export let numberSerializationStrategy: NumberSerializationStrategy;
     export let anySerializer: AnySerializer;
     export let graphBinaryReader: GraphBinaryReader;

package/build/esm/structure/io/binary/GraphBinary.js

@@ -29,7 +29,6 @@
  * TODO: it has the following open topics:
  * Core Data Types support:
  * - [] 0x22: BigDecimal
- * - [] 0x2b: Tree
  * Extended Types support:
  * - [] 0x80: Char
  * - [] 0x81: Duration
@@ -51,9 +50,11 @@ import SetSerializer from './internals/SetSerializer.js';
 import UuidSerializer from './internals/UuidSerializer.js';
 import EdgeSerializer from './internals/EdgeSerializer.js';
 import PathSerializer from './internals/PathSerializer.js';
+import TreeSerializer from './internals/TreeSerializer.js';
 import PropertySerializer from './internals/PropertySerializer.js';
 import VertexSerializer from './internals/VertexSerializer.js';
 import VertexPropertySerializer from './internals/VertexPropertySerializer.js';
+import GraphSerializer from './internals/GraphSerializer.js';
 import BigIntegerSerializer from './internals/BigIntegerSerializer.js';
 import ByteSerializer from './internals/ByteSerializer.js';
 import BinarySerializer from './internals/BinarySerializer.js';
@@ -63,46 +64,73 @@ import MarkerSerializer from './internals/MarkerSerializer.js';
 import UnspecifiedNullSerializer from './internals/UnspecifiedNullSerializer.js';
 import EnumSerializer from './internals/EnumSerializer.js';
 import StubSerializer from './internals/StubSerializer.js';
+import CompositePDTSerializer from './internals/CompositePDTSerializer.js';
+import PrimitivePDTSerializer from './internals/PrimitivePDTSerializer.js';
 import NumberSerializationStrategy from './internals/NumberSerializationStrategy.js';
 import AnySerializer from './internals/AnySerializer.js';
 import GraphBinaryReader from './internals/GraphBinaryReader.js';
 import GraphBinaryWriter from './internals/GraphBinaryWriter.js';
-const ioc = {};
-ioc.DataType = DataType;
-ioc.utils = utils;
-ioc.serializers = {};
-ioc.intSerializer = new IntSerializer(ioc);
-ioc.longSerializer = new LongSerializer(ioc);
-ioc.stringSerializer = new StringSerializer(ioc, ioc.DataType.STRING);
-ioc.dateTimeSerializer = new DateTimeSerializer(ioc);
-ioc.doubleSerializer = new DoubleSerializer(ioc);
-ioc.floatSerializer = new FloatSerializer(ioc);
-ioc.listSerializer = new ArraySerializer(ioc, ioc.DataType.LIST);
-ioc.mapSerializer = new MapSerializer(ioc);
-ioc.setSerializer = new SetSerializer(ioc, ioc.DataType.SET);
-ioc.uuidSerializer = new UuidSerializer(ioc);
-ioc.edgeSerializer = new EdgeSerializer(ioc);
-ioc.pathSerializer = new PathSerializer(ioc);
-ioc.propertySerializer = new PropertySerializer(ioc);
-ioc.vertexSerializer = new VertexSerializer(ioc);
-ioc.vertexPropertySerializer = new VertexPropertySerializer(ioc);
-ioc.bigIntegerSerializer = new BigIntegerSerializer(ioc);
-ioc.byteSerializer = new ByteSerializer(ioc);
-ioc.binarySerializer = new BinarySerializer(ioc);
-ioc.shortSerializer = new ShortSerializer(ioc);
-ioc.booleanSerializer = new BooleanSerializer(ioc);
-ioc.markerSerializer = new MarkerSerializer(ioc);
-ioc.unspecifiedNullSerializer = new UnspecifiedNullSerializer(ioc);
-ioc.enumSerializer = new EnumSerializer(ioc);
-// Register stub serializers for unimplemented v4 types
-new StubSerializer(ioc, ioc.DataType.TREE, 'Tree');
-new StubSerializer(ioc, ioc.DataType.GRAPH, 'Graph');
-new StubSerializer(ioc, ioc.DataType.COMPOSITEPDT, 'CompositePDT');
-new StubSerializer(ioc, ioc.DataType.PRIMITIVEPDT, 'PrimitivePDT');
-ioc.numberSerializationStrategy = new NumberSerializationStrategy(ioc);
-ioc.anySerializer = new AnySerializer(ioc);
-ioc.graphBinaryReader = new GraphBinaryReader(ioc);
-ioc.graphBinaryWriter = new GraphBinaryWriter(ioc);
+import { Float, Double, Int, Long, Short, Byte } from '../../../utils.js';
+function createIoc(anySerializerOptions) {
+    const ioc = {};
+    ioc.DataType = DataType;
+    ioc.utils = utils;
+    ioc.serializers = {};
+    ioc.intSerializer = new IntSerializer(ioc);
+    ioc.longSerializer = new LongSerializer(ioc);
+    ioc.stringSerializer = new StringSerializer(ioc, ioc.DataType.STRING);
+    ioc.dateTimeSerializer = new DateTimeSerializer(ioc);
+    ioc.doubleSerializer = new DoubleSerializer(ioc);
+    ioc.floatSerializer = new FloatSerializer(ioc);
+    ioc.listSerializer = new ArraySerializer(ioc, ioc.DataType.LIST);
+    ioc.mapSerializer = new MapSerializer(ioc);
+    ioc.setSerializer = new SetSerializer(ioc, ioc.DataType.SET);
+    ioc.uuidSerializer = new UuidSerializer(ioc);
+    ioc.edgeSerializer = new EdgeSerializer(ioc);
+    ioc.pathSerializer = new PathSerializer(ioc);
+    ioc.propertySerializer = new PropertySerializer(ioc);
+    ioc.vertexSerializer = new VertexSerializer(ioc);
+    ioc.vertexPropertySerializer = new VertexPropertySerializer(ioc);
+    ioc.graphSerializer = new GraphSerializer(ioc);
+    ioc.bigIntegerSerializer = new BigIntegerSerializer(ioc);
+    ioc.byteSerializer = new ByteSerializer(ioc);
+    ioc.binarySerializer = new BinarySerializer(ioc);
+    ioc.shortSerializer = new ShortSerializer(ioc);
+    ioc.booleanSerializer = new BooleanSerializer(ioc);
+    ioc.markerSerializer = new MarkerSerializer(ioc);
+    ioc.unspecifiedNullSerializer = new UnspecifiedNullSerializer(ioc);
+    ioc.enumSerializer = new EnumSerializer(ioc);
+    ioc.compositePDTSerializer = new CompositePDTSerializer(ioc);
+    ioc.primitivePDTSerializer = new PrimitivePDTSerializer(ioc);
+    ioc.treeSerializer = new TreeSerializer(ioc);
+    ioc.pdtRegistry = null;
+    ioc.numberSerializationStrategy = new NumberSerializationStrategy(ioc);
+    ioc.anySerializer = new AnySerializer(ioc, anySerializerOptions);
+    ioc.graphBinaryReader = new GraphBinaryReader(ioc);
+    ioc.graphBinaryWriter = new GraphBinaryWriter(ioc);
+    return ioc;
+}
+export function createPreciseReader() {
+    const wrapperMap = new Map([
+        [DataType.INT, Int],
+        [DataType.LONG, Long],
+        [DataType.FLOAT, Float],
+        [DataType.DOUBLE, Double],
+        [DataType.SHORT, Short],
+        [DataType.BYTE, Byte],
+    ]);
+    const preciseIoc = createIoc({
+        postDeserialize(result, typeCode) {
+            const Wrapper = wrapperMap.get(typeCode);
+            if (Wrapper && result !== null && result !== undefined) {
+                return new Wrapper(result);
+            }
+            return result;
+        },
+    });
+    return preciseIoc.graphBinaryReader;
+}
+const ioc = createIoc();
 export { default as DataType } from './internals/DataType.js';
-export const { serializers, intSerializer, longSerializer, stringSerializer, dateTimeSerializer, doubleSerializer, floatSerializer, listSerializer, mapSerializer, setSerializer, uuidSerializer, edgeSerializer, pathSerializer, propertySerializer, vertexSerializer, vertexPropertySerializer, bigIntegerSerializer, byteSerializer, binarySerializer, shortSerializer, booleanSerializer, markerSerializer, unspecifiedNullSerializer, enumSerializer, numberSerializationStrategy, anySerializer, graphBinaryReader, graphBinaryWriter, } = ioc;
+export const { serializers, intSerializer, longSerializer, stringSerializer, dateTimeSerializer, doubleSerializer, floatSerializer, listSerializer, mapSerializer, setSerializer, uuidSerializer, edgeSerializer, pathSerializer, propertySerializer, vertexSerializer, vertexPropertySerializer, graphSerializer, bigIntegerSerializer, byteSerializer, binarySerializer, shortSerializer, booleanSerializer, markerSerializer, unspecifiedNullSerializer, enumSerializer, compositePDTSerializer, primitivePDTSerializer, treeSerializer, numberSerializationStrategy, anySerializer, graphBinaryReader, graphBinaryWriter, } = ioc;
 export default ioc;

package/build/esm/structure/io/binary/internals/AnySerializer.d.ts

@@ -1,8 +1,18 @@
+/**
+ * @author Igor Ostapenko
+ */
 export default class AnySerializer {
-    constructor(ioc: any);
+    constructor(ioc: any, { postDeserialize }?: {});
     ioc: any;
+    _postDeserialize: any;
     serializers: any[];
     getSerializerCanBeUsedFor(item: any): any;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, ...args: any[]): any;
+    /**
+     * Async deserialization from a StreamReader.
+     * Reads type_code + value_flag, then dispatches to the appropriate serializer's deserializeValue().
+     * @param {StreamReader} reader
+     * @returns {Promise<any>}
+     */
+    deserialize(reader: StreamReader): Promise<any>;
 }

package/build/esm/structure/io/binary/internals/AnySerializer.js

@@ -19,10 +19,10 @@
 /**
  * @author Igor Ostapenko
  */
-import { Buffer } from 'buffer';
 export default class AnySerializer {
-    constructor(ioc) {
+    constructor(ioc, { postDeserialize } = {}) {
         this.ioc = ioc;
+        this._postDeserialize = postDeserialize || null;
         // specifically ordered, the first canBeUsedFor=true wins
         this.serializers = [
             ioc.unspecifiedNullSerializer,
@@ -37,9 +37,13 @@ export default class AnySerializer {
             ioc.propertySerializer,
             ioc.vertexSerializer,
             ioc.vertexPropertySerializer,
+            ioc.graphSerializer,
             ioc.enumSerializer,
             ioc.stringSerializer,
             ioc.binarySerializer,
+            ioc.primitivePDTSerializer,
+            ioc.compositePDTSerializer,
+            ioc.treeSerializer,
             ioc.mapSerializer,
         ];
     }
@@ -54,24 +58,37 @@ export default class AnySerializer {
     serialize(item, fullyQualifiedFormat = true) {
         return this.getSerializerCanBeUsedFor(item).serialize(item, fullyQualifiedFormat);
     }
-    deserialize(buffer) {
-        // obviously, fullyQualifiedFormat always is true
+    /**
+     * Async deserialization from a StreamReader.
+     * Reads type_code + value_flag, then dispatches to the appropriate serializer's deserializeValue().
+     * @param {StreamReader} reader
+     * @returns {Promise<any>}
+     */
+    async deserialize(reader) {
+        const pos = reader.position;
+        const type_code = await reader.readUInt8();
+        const serializer = this.ioc.serializers[type_code];
+        if (!serializer) {
+            throw new Error(`AnySerializer: unknown {type_code}=0x${type_code.toString(16)} at position ${pos}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00 && value_flag !== 0x02) {
+            throw new Error(`AnySerializer: unexpected {value_flag}=0x${value_flag.toString(16)} at position ${pos}`);
+        }
+        let result;
         try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            const type_code = buffer.readUInt8();
-            const serializer = this.ioc.serializers[type_code];
-            if (!serializer) {
-                throw new Error('unknown {type_code}');
-            }
-            return serializer.deserialize(buffer);
+            result = await serializer.deserializeValue(reader, value_flag, type_code);
         }
         catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, err });
+            err.message = `${serializer.constructor.name}.deserializeValue() at position ${pos}: ${err.message}`;
+            throw err;
+        }
+        if (this._postDeserialize) {
+            return this._postDeserialize(result, type_code);
         }
+        return result;
     }
 }

package/build/esm/structure/io/binary/internals/ArraySerializer.d.ts

@@ -4,12 +4,19 @@ export default class ArraySerializer {
     ID: any;
     canBeUsedFor(value: any): value is any[];
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: any[];
-        len: number;
-    };
+    /**
+     * Async deserialization of array value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - 0x00 for normal, 0x02 for bulked
+     * @param {number} typeCode
+     * @returns {Promise<Array>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<any[]>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Array|null>}
+     */
+    deserialize(reader: StreamReader): Promise<any[] | null>;
 }
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/ArraySerializer.js

@@ -55,82 +55,51 @@ export default class ArraySerializer {
         }
         return Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        let isBulked = false;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ID) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0 && value_flag !== 2) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                isBulked = value_flag === 2;
-                cursor = cursor.slice(1);
-            }
-            let length, length_len;
-            try {
-                ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
-                len += length_len;
-            }
-            catch (err) {
-                err.message = '{length}: ' + err.message;
-                throw err;
-            }
-            if (length < 0) {
-                throw new Error('{length} is less than zero');
-            }
-            cursor = cursor.slice(length_len);
-            const v = [];
-            for (let i = 0; i < length; i++) {
-                let value, value_len;
-                try {
-                    ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
-                    len += value_len;
-                }
-                catch (err) {
-                    err.message = `{item_${i}}: ` + err.message;
-                    throw err;
-                }
-                cursor = cursor.slice(value_len);
-                if (isBulked) {
-                    if (cursor.length < 8) {
-                        throw new Error(`{item_${i}}: bulk count is missing`);
-                    }
-                    const bulkCount = cursor.readBigInt64BE();
-                    len += 8;
-                    cursor = cursor.slice(8);
-                    for (let j = 0n; j < bulkCount; j++) {
-                        v.push(value);
-                    }
-                }
-                else {
+    /**
+     * Async deserialization of array value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - 0x00 for normal, 0x02 for bulked
+     * @param {number} typeCode
+     * @returns {Promise<Array>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const isBulked = valueFlag === 0x02;
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`ArraySerializer: {length}=${length} is less than zero`);
+        }
+        const v = [];
+        for (let i = 0; i < length; i++) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (isBulked) {
+                const bulkCount = await reader.readBigInt64BE();
+                for (let j = 0n; j < bulkCount; j++) {
                     v.push(value);
                 }
             }
-            return { v, len };
+            else {
+                v.push(value);
+            }
+        }
+        return v;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Array|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ID) {
+            throw new Error(`ArraySerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00 && value_flag !== 0x02) {
+            throw new Error(`ArraySerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/BigIntegerSerializer.d.ts

@@ -3,12 +3,17 @@ export default class BigIntegerSerializer {
     ioc: any;
     canBeUsedFor(value: any): value is bigint;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: bigint;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<bigint>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<bigint>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<bigint|null>}
+     */
+    deserialize(reader: StreamReader): Promise<bigint | null>;
 }
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/BigIntegerSerializer.js

@@ -73,61 +73,41 @@ export default class BigIntegerSerializer {
         bufs.push(v);
         return Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ioc.DataType.BIGINTEGER) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            // {length}
-            let length, length_len;
-            try {
-                ({ v: length, len: length_len } = this.ioc.intSerializer.deserialize(cursor, false));
-                len += length_len;
-            }
-            catch (err) {
-                err.message = '{length}: ' + err.message;
-                throw err;
-            }
-            if (length < 1) {
-                throw new Error(`{length}=${length} is less than one`);
-            }
-            cursor = cursor.slice(length_len);
-            len += length;
-            cursor = cursor.slice(0, length);
-            let v = BigInt(`0x${cursor.toString('hex')}`);
-            const is_sign_bit_set = (cursor[0] & 0x80) === 0x80;
-            if (is_sign_bit_set) {
-                v = BigInt.asIntN(length * 8, v); // now we get expected negative number
-            }
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<bigint>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 1) {
+            throw new Error(`BigIntegerSerializer: {length}=${length} is less than one`);
+        }
+        const bytes = await reader.readBytes(length);
+        let v = BigInt(`0x${bytes.toString('hex')}`);
+        const is_sign_bit_set = (bytes[0] & 0x80) === 0x80;
+        if (is_sign_bit_set) {
+            v = BigInt.asIntN(length * 8, v);
+        }
+        return v;
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<bigint|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.BIGINTEGER) {
+            throw new Error(`BigIntegerSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`BigIntegerSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/BinarySerializer.d.ts

@@ -3,9 +3,17 @@ export default class BinarySerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Buffer>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Buffer>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<Buffer|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Buffer | null>;
 }
 import { Buffer } from 'buffer';