gremlin 3.8.0 → 4.0.0-beta.2

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

@@ -0,0 +1,91 @@
+export { default as DataType } from "./internals/DataType.js";
+export const serializers: {};
+export const intSerializer: IntSerializer;
+export const longSerializer: LongSerializer;
+export const stringSerializer: StringSerializer;
+export const dateTimeSerializer: DateTimeSerializer;
+export const doubleSerializer: DoubleSerializer;
+export const floatSerializer: FloatSerializer;
+export const listSerializer: ArraySerializer;
+export const mapSerializer: MapSerializer;
+export const setSerializer: SetSerializer;
+export const uuidSerializer: UuidSerializer;
+export const edgeSerializer: EdgeSerializer;
+export const pathSerializer: PathSerializer;
+export const propertySerializer: PropertySerializer;
+export const vertexSerializer: VertexSerializer;
+export const vertexPropertySerializer: VertexPropertySerializer;
+export const bigIntegerSerializer: BigIntegerSerializer;
+export const byteSerializer: ByteSerializer;
+export const binarySerializer: BinarySerializer;
+export const shortSerializer: ShortSerializer;
+export const booleanSerializer: BooleanSerializer;
+export const markerSerializer: MarkerSerializer;
+export const unspecifiedNullSerializer: UnspecifiedNullSerializer;
+export const enumSerializer: EnumSerializer;
+export const numberSerializationStrategy: NumberSerializationStrategy;
+export const anySerializer: AnySerializer;
+export const graphBinaryReader: GraphBinaryReader;
+export const graphBinaryWriter: GraphBinaryWriter;
+export default ioc;
+import IntSerializer from './internals/IntSerializer.js';
+import LongSerializer from './internals/LongSerializer.js';
+import StringSerializer from './internals/StringSerializer.js';
+import DateTimeSerializer from './internals/DateTimeSerializer.js';
+import DoubleSerializer from './internals/DoubleSerializer.js';
+import FloatSerializer from './internals/FloatSerializer.js';
+import ArraySerializer from './internals/ArraySerializer.js';
+import MapSerializer from './internals/MapSerializer.js';
+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 PropertySerializer from './internals/PropertySerializer.js';
+import VertexSerializer from './internals/VertexSerializer.js';
+import VertexPropertySerializer from './internals/VertexPropertySerializer.js';
+import BigIntegerSerializer from './internals/BigIntegerSerializer.js';
+import ByteSerializer from './internals/ByteSerializer.js';
+import BinarySerializer from './internals/BinarySerializer.js';
+import ShortSerializer from './internals/ShortSerializer.js';
+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 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 };
+    export { utils };
+    export let serializers: {};
+    export let intSerializer: IntSerializer;
+    export let longSerializer: LongSerializer;
+    export let stringSerializer: StringSerializer;
+    export let dateTimeSerializer: DateTimeSerializer;
+    export let doubleSerializer: DoubleSerializer;
+    export let floatSerializer: FloatSerializer;
+    export let listSerializer: ArraySerializer;
+    export let mapSerializer: MapSerializer;
+    export let setSerializer: SetSerializer;
+    export let uuidSerializer: UuidSerializer;
+    export let edgeSerializer: EdgeSerializer;
+    export let pathSerializer: PathSerializer;
+    export let propertySerializer: PropertySerializer;
+    export let vertexSerializer: VertexSerializer;
+    export let vertexPropertySerializer: VertexPropertySerializer;
+    export let bigIntegerSerializer: BigIntegerSerializer;
+    export let byteSerializer: ByteSerializer;
+    export let binarySerializer: BinarySerializer;
+    export let shortSerializer: ShortSerializer;
+    export let booleanSerializer: BooleanSerializer;
+    export let markerSerializer: MarkerSerializer;
+    export let unspecifiedNullSerializer: UnspecifiedNullSerializer;
+    export let enumSerializer: EnumSerializer;
+    export let numberSerializationStrategy: NumberSerializationStrategy;
+    export let anySerializer: AnySerializer;
+    export let graphBinaryReader: GraphBinaryReader;
+    export let graphBinaryWriter: GraphBinaryWriter;
+}
+import DataType from './internals/DataType.js';
+import * as utils from './internals/utils.js';

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

@@ -0,0 +1,108 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * GraphBinary 4.0 support implementation.
+ *
+ * The officially expected entrypoint is GraphBinaryReader/GraphBinaryWriter pair of classes,
+ * examine lib/driver/** for use cases.
+ *
+ * See AnySerializer.serialize() for the mechanism of serializer selection for a given JavaScript value,
+ * also consider AnySerializer.serialize() unit tests for real examples.
+ * See NumberSerializationStrategy to understand how it deals with JavaScript numbers' serialization.
+ *
+ * TODO: it has the following open topics:
+ * Core Data Types support:
+ * - [] 0x22: BigDecimal
+ * - [] 0x2b: Tree
+ * Extended Types support:
+ * - [] 0x80: Char
+ * - [] 0x81: Duration
+ *
+ * @author Igor Ostapenko
+ */
+/*eslint-disable*/
+import DataType from './internals/DataType.js';
+import * as utils from './internals/utils.js';
+import IntSerializer from './internals/IntSerializer.js';
+import LongSerializer from './internals/LongSerializer.js';
+import StringSerializer from './internals/StringSerializer.js';
+import DateTimeSerializer from './internals/DateTimeSerializer.js';
+import DoubleSerializer from './internals/DoubleSerializer.js';
+import FloatSerializer from './internals/FloatSerializer.js';
+import ArraySerializer from './internals/ArraySerializer.js';
+import MapSerializer from './internals/MapSerializer.js';
+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 PropertySerializer from './internals/PropertySerializer.js';
+import VertexSerializer from './internals/VertexSerializer.js';
+import VertexPropertySerializer from './internals/VertexPropertySerializer.js';
+import BigIntegerSerializer from './internals/BigIntegerSerializer.js';
+import ByteSerializer from './internals/ByteSerializer.js';
+import BinarySerializer from './internals/BinarySerializer.js';
+import ShortSerializer from './internals/ShortSerializer.js';
+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 StubSerializer from './internals/StubSerializer.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);
+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 default ioc;

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

@@ -0,0 +1,8 @@
+export default class AnySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    serializers: any[];
+    getSerializerCanBeUsedFor(item: any): any;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, ...args: any[]): any;
+}

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

@@ -0,0 +1,77 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class AnySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        // specifically ordered, the first canBeUsedFor=true wins
+        this.serializers = [
+            ioc.unspecifiedNullSerializer,
+            ioc.numberSerializationStrategy,
+            ioc.booleanSerializer,
+            ioc.dateTimeSerializer,
+            ioc.setSerializer,
+            ioc.listSerializer,
+            ioc.uuidSerializer,
+            ioc.edgeSerializer,
+            ioc.pathSerializer,
+            ioc.propertySerializer,
+            ioc.vertexSerializer,
+            ioc.vertexPropertySerializer,
+            ioc.enumSerializer,
+            ioc.stringSerializer,
+            ioc.binarySerializer,
+            ioc.mapSerializer,
+        ];
+    }
+    getSerializerCanBeUsedFor(item) {
+        for (let i = 0; i < this.serializers.length; i++) {
+            if (this.serializers[i].canBeUsedFor(item)) {
+                return this.serializers[i];
+            }
+        }
+        throw new Error(`No serializer found to support item where typeof(item)='${typeof item}' and String(item)='${String(item)}'.`);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        return this.getSerializerCanBeUsedFor(item).serialize(item, fullyQualifiedFormat);
+    }
+    deserialize(buffer) {
+        // obviously, fullyQualifiedFormat always is true
+        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);
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, err });
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+export default class ArraySerializer {
+    constructor(ioc: any, ID: any);
+    ioc: any;
+    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;
+    };
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,136 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class ArraySerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return Array.isArray(value);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ID, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ID, 0x00]));
+        }
+        // {length}
+        let length = item.length;
+        if (length < 0) {
+            length = 0; // TODO: test it
+        }
+        if (length > this.ioc.intSerializer.INT32_MAX) {
+            throw new Error(`Array length=${length} is greater than supported max_length=${this.ioc.intSerializer.INT32_MAX}.`);
+        }
+        bufs.push(this.ioc.intSerializer.serialize(length, false));
+        // {item_0}...{item_n}
+        for (let i = 0; i < length; i++) {
+            bufs.push(this.ioc.anySerializer.serialize(item[i]));
+        }
+        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 {
+                    v.push(value);
+                }
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+export default class BigIntegerSerializer {
+    constructor(ioc: any);
+    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;
+    };
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,133 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+// TODO: it has room for performance improvements
+export default class BigIntegerSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.BIGINTEGER] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used directly, see NumberSerializationStrategy
+        return typeof value === 'bigint';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.BIGINTEGER, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00, 0x00, 0x01, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.BIGINTEGER, 0x00]));
+        }
+        let v;
+        // positive number
+        if (item >= 0) {
+            let hex_str = item.toString(16);
+            if (hex_str.length % 2 !== 0) {
+                hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+            }
+            if (Number.parseInt(hex_str[0], 16) > 7) {
+                hex_str = '00' + hex_str; // to keep sign bit unset for positive number
+            }
+            v = Buffer.from(hex_str, 'hex');
+        }
+        // negative number
+        else {
+            let hex_str = (-item).toString(16);
+            const bytes = (hex_str.length + (hex_str.length % 2)) / 2; // number's size in bytes
+            let N = BigInt(bytes) * BigInt(8); // number's size in bits
+            const INTN_MIN = -(BigInt(2) ** (N - BigInt(1))); // minimum negative number we can keep within N bits
+            if (item < INTN_MIN) {
+                N += BigInt(8); // to provide room for smaller negative number
+            }
+            const twos_complement = BigInt(2) ** N + item;
+            hex_str = twos_complement.toString(16);
+            if (hex_str.length % 2 !== 0) {
+                hex_str = '0' + hex_str; // Buffer.from() expects exactly two hex digits per byte
+            }
+            v = Buffer.from(hex_str, 'hex');
+        }
+        bufs.push(this.ioc.intSerializer.serialize(v.length, false));
+        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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+export default class BinarySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}
+import { Buffer } from 'buffer';