gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/structure/io/binary/GraphBinary.cjs

@@ -0,0 +1,177 @@
+"use strict";
+/*
+ *  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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphBinaryWriter = exports.graphBinaryReader = exports.anySerializer = exports.numberSerializationStrategy = exports.treeSerializer = exports.primitivePDTSerializer = exports.compositePDTSerializer = exports.enumSerializer = exports.unspecifiedNullSerializer = exports.markerSerializer = exports.booleanSerializer = exports.shortSerializer = exports.binarySerializer = exports.byteSerializer = exports.bigIntegerSerializer = exports.graphSerializer = exports.vertexPropertySerializer = exports.vertexSerializer = exports.propertySerializer = exports.pathSerializer = exports.edgeSerializer = exports.uuidSerializer = exports.setSerializer = exports.mapSerializer = exports.listSerializer = exports.floatSerializer = exports.doubleSerializer = exports.dateTimeSerializer = exports.stringSerializer = exports.longSerializer = exports.intSerializer = exports.serializers = exports.DataType = void 0;
+exports.createPreciseReader = createPreciseReader;
+/**
+ * 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*/
+const DataType_js_1 = __importDefault(require("./internals/DataType.cjs"));
+const utils = __importStar(require("./internals/utils.cjs"));
+const IntSerializer_js_1 = __importDefault(require("./internals/IntSerializer.cjs"));
+const LongSerializer_js_1 = __importDefault(require("./internals/LongSerializer.cjs"));
+const StringSerializer_js_1 = __importDefault(require("./internals/StringSerializer.cjs"));
+const DateTimeSerializer_js_1 = __importDefault(require("./internals/DateTimeSerializer.cjs"));
+const DoubleSerializer_js_1 = __importDefault(require("./internals/DoubleSerializer.cjs"));
+const FloatSerializer_js_1 = __importDefault(require("./internals/FloatSerializer.cjs"));
+const ArraySerializer_js_1 = __importDefault(require("./internals/ArraySerializer.cjs"));
+const MapSerializer_js_1 = __importDefault(require("./internals/MapSerializer.cjs"));
+const SetSerializer_js_1 = __importDefault(require("./internals/SetSerializer.cjs"));
+const UuidSerializer_js_1 = __importDefault(require("./internals/UuidSerializer.cjs"));
+const EdgeSerializer_js_1 = __importDefault(require("./internals/EdgeSerializer.cjs"));
+const PathSerializer_js_1 = __importDefault(require("./internals/PathSerializer.cjs"));
+const TreeSerializer_js_1 = __importDefault(require("./internals/TreeSerializer.cjs"));
+const PropertySerializer_js_1 = __importDefault(require("./internals/PropertySerializer.cjs"));
+const VertexSerializer_js_1 = __importDefault(require("./internals/VertexSerializer.cjs"));
+const VertexPropertySerializer_js_1 = __importDefault(require("./internals/VertexPropertySerializer.cjs"));
+const GraphSerializer_js_1 = __importDefault(require("./internals/GraphSerializer.cjs"));
+const BigIntegerSerializer_js_1 = __importDefault(require("./internals/BigIntegerSerializer.cjs"));
+const ByteSerializer_js_1 = __importDefault(require("./internals/ByteSerializer.cjs"));
+const BinarySerializer_js_1 = __importDefault(require("./internals/BinarySerializer.cjs"));
+const ShortSerializer_js_1 = __importDefault(require("./internals/ShortSerializer.cjs"));
+const BooleanSerializer_js_1 = __importDefault(require("./internals/BooleanSerializer.cjs"));
+const MarkerSerializer_js_1 = __importDefault(require("./internals/MarkerSerializer.cjs"));
+const UnspecifiedNullSerializer_js_1 = __importDefault(require("./internals/UnspecifiedNullSerializer.cjs"));
+const EnumSerializer_js_1 = __importDefault(require("./internals/EnumSerializer.cjs"));
+const StubSerializer_js_1 = __importDefault(require("./internals/StubSerializer.cjs"));
+const CompositePDTSerializer_js_1 = __importDefault(require("./internals/CompositePDTSerializer.cjs"));
+const PrimitivePDTSerializer_js_1 = __importDefault(require("./internals/PrimitivePDTSerializer.cjs"));
+const NumberSerializationStrategy_js_1 = __importDefault(require("./internals/NumberSerializationStrategy.cjs"));
+const AnySerializer_js_1 = __importDefault(require("./internals/AnySerializer.cjs"));
+const GraphBinaryReader_js_1 = __importDefault(require("./internals/GraphBinaryReader.cjs"));
+const GraphBinaryWriter_js_1 = __importDefault(require("./internals/GraphBinaryWriter.cjs"));
+const utils_js_1 = require("../../../utils.cjs");
+function createIoc(anySerializerOptions) {
+    const ioc = {};
+    ioc.DataType = DataType_js_1.default;
+    ioc.utils = utils;
+    ioc.serializers = {};
+    ioc.intSerializer = new IntSerializer_js_1.default(ioc);
+    ioc.longSerializer = new LongSerializer_js_1.default(ioc);
+    ioc.stringSerializer = new StringSerializer_js_1.default(ioc, ioc.DataType.STRING);
+    ioc.dateTimeSerializer = new DateTimeSerializer_js_1.default(ioc);
+    ioc.doubleSerializer = new DoubleSerializer_js_1.default(ioc);
+    ioc.floatSerializer = new FloatSerializer_js_1.default(ioc);
+    ioc.listSerializer = new ArraySerializer_js_1.default(ioc, ioc.DataType.LIST);
+    ioc.mapSerializer = new MapSerializer_js_1.default(ioc);
+    ioc.setSerializer = new SetSerializer_js_1.default(ioc, ioc.DataType.SET);
+    ioc.uuidSerializer = new UuidSerializer_js_1.default(ioc);
+    ioc.edgeSerializer = new EdgeSerializer_js_1.default(ioc);
+    ioc.pathSerializer = new PathSerializer_js_1.default(ioc);
+    ioc.propertySerializer = new PropertySerializer_js_1.default(ioc);
+    ioc.vertexSerializer = new VertexSerializer_js_1.default(ioc);
+    ioc.vertexPropertySerializer = new VertexPropertySerializer_js_1.default(ioc);
+    ioc.graphSerializer = new GraphSerializer_js_1.default(ioc);
+    ioc.bigIntegerSerializer = new BigIntegerSerializer_js_1.default(ioc);
+    ioc.byteSerializer = new ByteSerializer_js_1.default(ioc);
+    ioc.binarySerializer = new BinarySerializer_js_1.default(ioc);
+    ioc.shortSerializer = new ShortSerializer_js_1.default(ioc);
+    ioc.booleanSerializer = new BooleanSerializer_js_1.default(ioc);
+    ioc.markerSerializer = new MarkerSerializer_js_1.default(ioc);
+    ioc.unspecifiedNullSerializer = new UnspecifiedNullSerializer_js_1.default(ioc);
+    ioc.enumSerializer = new EnumSerializer_js_1.default(ioc);
+    ioc.compositePDTSerializer = new CompositePDTSerializer_js_1.default(ioc);
+    ioc.primitivePDTSerializer = new PrimitivePDTSerializer_js_1.default(ioc);
+    ioc.treeSerializer = new TreeSerializer_js_1.default(ioc);
+    ioc.pdtRegistry = null;
+    ioc.numberSerializationStrategy = new NumberSerializationStrategy_js_1.default(ioc);
+    ioc.anySerializer = new AnySerializer_js_1.default(ioc, anySerializerOptions);
+    ioc.graphBinaryReader = new GraphBinaryReader_js_1.default(ioc);
+    ioc.graphBinaryWriter = new GraphBinaryWriter_js_1.default(ioc);
+    return ioc;
+}
+function createPreciseReader() {
+    const wrapperMap = new Map([
+        [DataType_js_1.default.INT, utils_js_1.Int],
+        [DataType_js_1.default.LONG, utils_js_1.Long],
+        [DataType_js_1.default.FLOAT, utils_js_1.Float],
+        [DataType_js_1.default.DOUBLE, utils_js_1.Double],
+        [DataType_js_1.default.SHORT, utils_js_1.Short],
+        [DataType_js_1.default.BYTE, utils_js_1.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();
+var DataType_js_2 = require("./internals/DataType.cjs");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return __importDefault(DataType_js_2).default; } });
+exports.serializers = ioc.serializers, exports.intSerializer = ioc.intSerializer, exports.longSerializer = ioc.longSerializer, exports.stringSerializer = ioc.stringSerializer, exports.dateTimeSerializer = ioc.dateTimeSerializer, exports.doubleSerializer = ioc.doubleSerializer, exports.floatSerializer = ioc.floatSerializer, exports.listSerializer = ioc.listSerializer, exports.mapSerializer = ioc.mapSerializer, exports.setSerializer = ioc.setSerializer, exports.uuidSerializer = ioc.uuidSerializer, exports.edgeSerializer = ioc.edgeSerializer, exports.pathSerializer = ioc.pathSerializer, exports.propertySerializer = ioc.propertySerializer, exports.vertexSerializer = ioc.vertexSerializer, exports.vertexPropertySerializer = ioc.vertexPropertySerializer, exports.graphSerializer = ioc.graphSerializer, exports.bigIntegerSerializer = ioc.bigIntegerSerializer, exports.byteSerializer = ioc.byteSerializer, exports.binarySerializer = ioc.binarySerializer, exports.shortSerializer = ioc.shortSerializer, exports.booleanSerializer = ioc.booleanSerializer, exports.markerSerializer = ioc.markerSerializer, exports.unspecifiedNullSerializer = ioc.unspecifiedNullSerializer, exports.enumSerializer = ioc.enumSerializer, exports.compositePDTSerializer = ioc.compositePDTSerializer, exports.primitivePDTSerializer = ioc.primitivePDTSerializer, exports.treeSerializer = ioc.treeSerializer, exports.numberSerializationStrategy = ioc.numberSerializationStrategy, exports.anySerializer = ioc.anySerializer, exports.graphBinaryReader = ioc.graphBinaryReader, exports.graphBinaryWriter = ioc.graphBinaryWriter;
+exports.default = ioc;

package/build/cjs/structure/io/binary/GraphBinary.d.cts

@@ -0,0 +1,105 @@
+export function createPreciseReader(): GraphBinaryReader;
+export { default as DataType } from "./internals/DataType.cjs";
+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.cjs';
+import IntSerializer from './internals/IntSerializer.cjs';
+import LongSerializer from './internals/LongSerializer.cjs';
+import StringSerializer from './internals/StringSerializer.cjs';
+import DateTimeSerializer from './internals/DateTimeSerializer.cjs';
+import DoubleSerializer from './internals/DoubleSerializer.cjs';
+import FloatSerializer from './internals/FloatSerializer.cjs';
+import ArraySerializer from './internals/ArraySerializer.cjs';
+import MapSerializer from './internals/MapSerializer.cjs';
+import SetSerializer from './internals/SetSerializer.cjs';
+import UuidSerializer from './internals/UuidSerializer.cjs';
+import EdgeSerializer from './internals/EdgeSerializer.cjs';
+import PathSerializer from './internals/PathSerializer.cjs';
+import PropertySerializer from './internals/PropertySerializer.cjs';
+import VertexSerializer from './internals/VertexSerializer.cjs';
+import VertexPropertySerializer from './internals/VertexPropertySerializer.cjs';
+import GraphSerializer from './internals/GraphSerializer.cjs';
+import BigIntegerSerializer from './internals/BigIntegerSerializer.cjs';
+import ByteSerializer from './internals/ByteSerializer.cjs';
+import BinarySerializer from './internals/BinarySerializer.cjs';
+import ShortSerializer from './internals/ShortSerializer.cjs';
+import BooleanSerializer from './internals/BooleanSerializer.cjs';
+import MarkerSerializer from './internals/MarkerSerializer.cjs';
+import UnspecifiedNullSerializer from './internals/UnspecifiedNullSerializer.cjs';
+import EnumSerializer from './internals/EnumSerializer.cjs';
+import CompositePDTSerializer from './internals/CompositePDTSerializer.cjs';
+import PrimitivePDTSerializer from './internals/PrimitivePDTSerializer.cjs';
+import TreeSerializer from './internals/TreeSerializer.cjs';
+import NumberSerializationStrategy from './internals/NumberSerializationStrategy.cjs';
+import AnySerializer from './internals/AnySerializer.cjs';
+import GraphBinaryWriter from './internals/GraphBinaryWriter.cjs';
+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.cjs';
+import * as utils from './internals/utils.cjs';

package/build/cjs/structure/io/binary/internals/AnySerializer.cjs

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+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;
+    }
+}
+exports.default = AnySerializer;

package/build/cjs/structure/io/binary/internals/AnySerializer.d.cts

@@ -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/cjs/structure/io/binary/internals/ArraySerializer.cjs

@@ -0,0 +1,108 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+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_1.Buffer.from([this.ID, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00]); // {length} = 0
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.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_1.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);
+    }
+}
+exports.default = ArraySerializer;

package/build/cjs/structure/io/binary/internals/ArraySerializer.d.cts

@@ -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/cjs/structure/io/binary/internals/BigIntegerSerializer.cjs

@@ -0,0 +1,116 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+// TODO: it has room for performance improvements
+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_1.Buffer.from([this.ioc.DataType.BIGINTEGER, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x01, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.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_1.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_1.Buffer.from(hex_str, 'hex');
+        }
+        bufs.push(this.ioc.intSerializer.serialize(v.length, false));
+        bufs.push(v);
+        return buffer_1.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);
+    }
+}
+exports.default = BigIntegerSerializer;

package/build/cjs/structure/io/binary/internals/BigIntegerSerializer.d.cts

@@ -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';