gremlin 3.8.1 → 4.0.0-beta.2

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

@@ -0,0 +1,88 @@
+"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 ByteSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.BYTE] = this;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.BYTE, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.BYTE, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(1);
+        v.writeInt8(item); // if item is not within int8 limits writeInt8 will error
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.BYTE) {
+                    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);
+            }
+            if (cursor.length < 1) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 1;
+            const v = cursor.readInt8();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = ByteSerializer;

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

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

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

@@ -0,0 +1,63 @@
+"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
+ */
+/**
+ * Represents a GraphBinary data type.
+ *
+ * See org.apache.tinkerpop.gremlin.structure.io.binary.DataType Java class.
+ */
+const DataType = {
+    INT: 0x01,
+    LONG: 0x02,
+    STRING: 0x03,
+    DATETIME: 0x04,
+    DOUBLE: 0x07,
+    FLOAT: 0x08,
+    LIST: 0x09,
+    MAP: 0x0a,
+    SET: 0x0b,
+    UUID: 0x0c,
+    EDGE: 0x0d,
+    PATH: 0x0e,
+    PROPERTY: 0x0f,
+    GRAPH: 0x10,
+    VERTEX: 0x11,
+    VERTEXPROPERTY: 0x12,
+    DIRECTION: 0x18,
+    T: 0x20,
+    BIGDECIMAL: 0x22,
+    BIGINTEGER: 0x23,
+    BYTE: 0x24,
+    BINARY: 0x25,
+    SHORT: 0x26,
+    BOOLEAN: 0x27,
+    TREE: 0x2b,
+    MERGE: 0x2e,
+    CHAR: 0x80,
+    DURATION: 0x81,
+    COMPOSITEPDT: 0xf0,
+    PRIMITIVEPDT: 0xf1,
+    MARKER: 0xfd,
+    UNSPECIFIED_NULL: 0xfe,
+};
+exports.default = DataType;

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

@@ -0,0 +1,35 @@
+export default DataType;
+declare namespace DataType {
+    let INT: number;
+    let LONG: number;
+    let STRING: number;
+    let DATETIME: number;
+    let DOUBLE: number;
+    let FLOAT: number;
+    let LIST: number;
+    let MAP: number;
+    let SET: number;
+    let UUID: number;
+    let EDGE: number;
+    let PATH: number;
+    let PROPERTY: number;
+    let GRAPH: number;
+    let VERTEX: number;
+    let VERTEXPROPERTY: number;
+    let DIRECTION: number;
+    let T: number;
+    let BIGDECIMAL: number;
+    let BIGINTEGER: number;
+    let BYTE: number;
+    let BINARY: number;
+    let SHORT: number;
+    let BOOLEAN: number;
+    let TREE: number;
+    let MERGE: number;
+    let CHAR: number;
+    let DURATION: number;
+    let COMPOSITEPDT: number;
+    let PRIMITIVEPDT: number;
+    let MARKER: number;
+    let UNSPECIFIED_NULL: number;
+}

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

@@ -0,0 +1,139 @@
+"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 });
+const buffer_1 = require("node:buffer");
+class DateTimeSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ID = ioc.DataType.DATETIME;
+        this.ioc.serializers[this.ID] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Date;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ID, 0x01]);
+            }
+            return buffer_1.Buffer.alloc(18);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ID, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(18);
+        let offset = 0;
+        // Year (Int32BE)
+        v.writeInt32BE(item.getUTCFullYear(), offset);
+        offset += 4;
+        // Month (UInt8, 1-based)
+        v.writeUInt8(item.getUTCMonth() + 1, offset);
+        offset += 1;
+        // Day (UInt8, 1-based)
+        v.writeUInt8(item.getUTCDate(), offset);
+        offset += 1;
+        // Nanoseconds since midnight (BigInt64BE)
+        const hours = item.getUTCHours();
+        const minutes = item.getUTCMinutes();
+        const seconds = item.getUTCSeconds();
+        const millis = item.getUTCMilliseconds();
+        const nanos = BigInt(hours * 3600 + minutes * 60 + seconds) * 1000000000n + BigInt(millis) * 1000000n;
+        v.writeBigInt64BE(nanos, offset);
+        offset += 8;
+        // UTC offset in seconds (Int32BE) - always 0 for JS Date
+        v.writeInt32BE(0, offset);
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            if (cursor.length < 18) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 18;
+            let offset = 0;
+            // Read year (Int32BE)
+            const year = cursor.readInt32BE(offset);
+            offset += 4;
+            // Read month (UInt8, 1-based)
+            const month = cursor.readUInt8(offset);
+            offset += 1;
+            // Read day (UInt8, 1-based)
+            const day = cursor.readUInt8(offset);
+            offset += 1;
+            // Read nanoseconds since midnight (BigInt64BE)
+            const nanos = cursor.readBigInt64BE(offset);
+            offset += 8;
+            // Read UTC offset in seconds (Int32BE) - JS Date cannot represent non-zero offsets
+            const utcOffset = cursor.readInt32BE(offset);
+            offset += 4;
+            // Convert nanos to time components
+            const hours = Number(nanos / 3600000000000n);
+            const remainingNanos = nanos % 3600000000000n;
+            const minutes = Number(remainingNanos / 60000000000n);
+            const remainingNanos2 = remainingNanos % 60000000000n;
+            const seconds = Number(remainingNanos2 / 1000000000n);
+            const millis = Number((remainingNanos2 % 1000000000n) / 1000000n);
+            const v = new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds, millis));
+            // Date.UTC treats years 0-99 as 1900-1999, correct it
+            if (year >= 0 && year <= 99) {
+                v.setUTCFullYear(year);
+            }
+            // Adjust for non-zero UTC offset (JS Date is always UTC internally)
+            if (utcOffset !== 0) {
+                v.setTime(v.getTime() - utcOffset * 1000);
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = DateTimeSerializer;

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

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

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

@@ -0,0 +1,91 @@
+"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 DoubleSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.DOUBLE] = this;
+    }
+    canBeUsedFor(value) {
+        return typeof value === 'number' && !Number.isInteger(value);
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.DOUBLE, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.DOUBLE, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(8);
+        v.writeDoubleBE(item);
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.DOUBLE) {
+                    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);
+            }
+            if (cursor.length < 8) {
+                throw new Error('unexpected {value} length');
+            }
+            len += 8;
+            const v = cursor.readDoubleBE();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = DoubleSerializer;

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

@@ -0,0 +1,11 @@
+export default class DoubleSerializer {
+    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';

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

@@ -0,0 +1,201 @@
+"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");
+const graph_js_1 = require("../../../graph.cjs");
+class EdgeSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.EDGE] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.Edge;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.EDGE, 0x01]);
+            }
+            const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const label = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const inVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const inVLabel = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const outVId = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const outVLabel = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const parent = [0xfe, 0x01]; // null
+            const properties = [0x09, 0x00, 0x00, 0x00, 0x00, 0x00]; // empty list
+            return buffer_1.Buffer.from([...id, ...label, ...inVId, ...inVLabel, ...outVId, ...outVLabel, ...parent, ...properties]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.EDGE, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {inVId}
+        const inVId = item.inV && item.inV.id;
+        bufs.push(this.ioc.anySerializer.serialize(inVId));
+        // {inVLabel}
+        const inVLabel = item.inV && item.inV.label;
+        const inVLabels = Array.isArray(inVLabel) ? inVLabel : inVLabel ? [inVLabel] : [];
+        bufs.push(this.ioc.listSerializer.serialize(inVLabels, false));
+        // {outVId}
+        const outVId = item.outV && item.outV.id;
+        bufs.push(this.ioc.anySerializer.serialize(outVId));
+        // {outVLabel}
+        const outVLabel = item.outV && item.outV.label;
+        const outVLabels = Array.isArray(outVLabel) ? outVLabel : outVLabel ? [outVLabel] : [];
+        bufs.push(this.ioc.listSerializer.serialize(outVLabels, false));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.EDGE) {
+                    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);
+            }
+            let id, id_len;
+            try {
+                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += id_len;
+            }
+            catch (err) {
+                err.message = '{id}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(id_len);
+            let label, label_len;
+            try {
+                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
+                len += label_len;
+            }
+            catch (err) {
+                err.message = '{label}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(label_len);
+            let inVId, inVId_len;
+            try {
+                ({ v: inVId, len: inVId_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += inVId_len;
+            }
+            catch (err) {
+                err.message = '{inVId}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(inVId_len);
+            let inVLabel, inVLabel_len;
+            try {
+                ({ v: inVLabel, len: inVLabel_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                inVLabel = Array.isArray(inVLabel) && inVLabel.length > 0 ? inVLabel[0] : inVLabel;
+                len += inVLabel_len;
+            }
+            catch (err) {
+                err.message = '{inVLabel}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(inVLabel_len);
+            let outVId, outVId_len;
+            try {
+                ({ v: outVId, len: outVId_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += outVId_len;
+            }
+            catch (err) {
+                err.message = '{outVId}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(outVId_len);
+            let outVLabel, outVLabel_len;
+            try {
+                ({ v: outVLabel, len: outVLabel_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                outVLabel = Array.isArray(outVLabel) && outVLabel.length > 0 ? outVLabel[0] : outVLabel;
+                len += outVLabel_len;
+            }
+            catch (err) {
+                err.message = '{outVLabel}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(outVLabel_len);
+            let parent_len;
+            try {
+                ({ len: parent_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += parent_len;
+            }
+            catch (err) {
+                err.message = '{parent}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(parent_len);
+            let properties, properties_len;
+            try {
+                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += properties_len;
+            }
+            catch (err) {
+                err.message = '{properties}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(properties_len);
+            // null properties are deserialized into empty lists
+            const edge_props = properties ? properties : [];
+            const v = new graph_js_1.Edge(id, new graph_js_1.Vertex(outVId, outVLabel, null), label, new graph_js_1.Vertex(inVId, inVLabel, null), edge_props);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = EdgeSerializer;

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

@@ -0,0 +1,20 @@
+export default class EdgeSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Edge<any, any, any, any, any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: Edge<Vertex<any, Record<string, any>, any, {
+            [x: string]: [import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>, ...import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>[]];
+        }>, any, Vertex<any, Record<string, any>, any, {
+            [x: string]: [import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>, ...import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>[]];
+        }>, Record<string, any>, any>;
+        len: number;
+    };
+}
+import { Edge } from '../../../graph.cjs';
+import { Buffer } from 'buffer';
+import { Vertex } from '../../../graph.cjs';