gremlin 3.8.1 → 4.0.0-beta.3

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

@@ -0,0 +1,105 @@
+export function createPreciseReader(): GraphBinaryReader;
+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 graphSerializer: GraphSerializer;
+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 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';
+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 GraphSerializer from './internals/GraphSerializer.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 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 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 graphSerializer: GraphSerializer;
+    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 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;
+    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,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.
+ */
+/**
+ * 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
+ * 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 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';
+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 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';
+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, 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

@@ -0,0 +1,18 @@
+/**
+ * @author Igor Ostapenko
+ */
+export default class AnySerializer {
+    constructor(ioc: any, { postDeserialize }?: {});
+    ioc: any;
+    _postDeserialize: any;
+    serializers: any[];
+    getSerializerCanBeUsedFor(item: any): any;
+    serialize(item: any, fullyQualifiedFormat?: boolean): 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

@@ -0,0 +1,94 @@
+/*
+ *  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
+ */
+export default class AnySerializer {
+    constructor(ioc, { postDeserialize } = {}) {
+        this.ioc = ioc;
+        this._postDeserialize = postDeserialize || null;
+        // 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.graphSerializer,
+            ioc.enumSerializer,
+            ioc.stringSerializer,
+            ioc.binarySerializer,
+            ioc.primitivePDTSerializer,
+            ioc.compositePDTSerializer,
+            ioc.treeSerializer,
+            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);
+    }
+    /**
+     * 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 {
+            result = await serializer.deserializeValue(reader, value_flag, type_code);
+        }
+        catch (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

@@ -0,0 +1,22 @@
+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>;
+    /**
+     * 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

@@ -0,0 +1,105 @@
+/*
+ *  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);
+    }
+    /**
+     * 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);
+                }
+            }
+            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;
+        }
+        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

@@ -0,0 +1,19 @@
+export default class BigIntegerSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is bigint;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @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

@@ -0,0 +1,113 @@
+/*
+ *  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);
+    }
+    /**
+     * @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;
+        }
+        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

@@ -0,0 +1,19 @@
+export default class BinarySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @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';