gremlin 3.8.1 → 4.0.0-beta.3

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

@@ -0,0 +1,90 @@
+/*
+ *  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';
+import { Property } from '../../../graph.js';
+export default class PropertySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.PROPERTY] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Property;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.PROPERTY, 0x01]);
+            }
+            return Buffer.concat([
+                this.ioc.stringSerializer.serialize('', false), // {key}=''
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {value}=null
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {parent}=null
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.PROPERTY, 0x00]));
+        }
+        // {key}
+        bufs.push(this.ioc.stringSerializer.serialize(item.key, false));
+        // {value}
+        bufs.push(this.ioc.anySerializer.serialize(item.value));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of property value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Property>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {key} bare string (length + text_value)
+        const key = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, typeCode);
+        // {value} fully qualified
+        const value = await this.ioc.anySerializer.deserialize(reader);
+        // {parent} fully qualified (always null in current TinkerPop)
+        await this.ioc.anySerializer.deserialize(reader);
+        return new Property(key, value);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Property|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.PROPERTY) {
+            throw new Error(`PropertySerializer: 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(`PropertySerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,22 @@
+export default class SetSerializer {
+    constructor(ioc: any, ID: any);
+    ioc: any;
+    ID: any;
+    canBeUsedFor(value: any): value is Set<any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Async deserialization of set value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - 0x00 for normal, 0x02 for bulked
+     * @param {number} typeCode
+     * @returns {Promise<Set>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Set<any>>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Set|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Set<any> | null>;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,101 @@
+/*
+ *  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 SetSerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Set;
+    }
+    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.size;
+        if (length < 0) {
+            length = 0;
+        }
+        if (length > this.ioc.intSerializer.INT32_MAX) {
+            throw new Error(`Set 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 (const i of item) {
+            bufs.push(this.ioc.anySerializer.serialize(i));
+        }
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of set value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - 0x00 for normal, 0x02 for bulked
+     * @param {number} typeCode
+     * @returns {Promise<Set>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const isBulked = valueFlag === 0x02;
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`SetSerializer: {length}=${length} is less than zero`);
+        }
+        const v = new Set();
+        for (let i = 0; i < length; i++) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (isBulked) {
+                // consume the bulk count; Set.add is idempotent so count doesn't matter
+                await reader.readBigInt64BE();
+            }
+            v.add(value);
+        }
+        return v;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Set|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ID) {
+            throw new Error(`SetSerializer: 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(`SetSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,19 @@
+export default class ShortSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,74 @@
+/*
+ *  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 ShortSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.SHORT] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used during serialization
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.SHORT, 0x01]);
+            }
+            return Buffer.from([0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.SHORT, 0x00]));
+        }
+        const v = Buffer.alloc(2);
+        v.writeInt16BE(item); // TODO: what if item is not within int16 limits, for now writeInt16BE would error
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readInt16BE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.SHORT) {
+            throw new Error(`ShortSerializer: 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(`ShortSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Async byte reader that provides a uniform interface over both a complete Buffer
+ * (for non-streaming submit()) and a ReadableStream (for streaming HTTP responses).
+ *
+ * Handles chunk boundaries transparently and blocks (awaits) until the requested bytes are available.
+ */
+export default class StreamReader {
+    /**
+     * Create a StreamReader backed by a complete Buffer.
+     * All reads are satisfied from the buffer; no async I/O occurs.
+     * @param {Buffer} buffer
+     * @returns {StreamReader}
+     */
+    static fromBuffer(buffer: Buffer): StreamReader;
+    /**
+     * Create a StreamReader backed by a ReadableStream (e.g. fetch response.body).
+     * Reads pull chunks from the stream as needed.
+     * @param {ReadableStream} readableStream
+     * @returns {StreamReader}
+     */
+    static fromReadableStream(readableStream: ReadableStream): StreamReader;
+    /**
+     * @param {Buffer} initialBuffer
+     * @param {ReadableStreamDefaultReader|null} reader
+     */
+    constructor(initialBuffer: Buffer, reader: ReadableStreamDefaultReader | null);
+    /**
+     * Total number of bytes consumed so far (monotonically increasing).
+     * Useful for error diagnostics.
+     * @returns {number}
+     */
+    get position(): number;
+    /**
+     * Read exactly `n` bytes and return them as a Buffer.
+     * @param {number} n
+     * @returns {Promise<Buffer>}
+     */
+    readBytes(n: number): Promise<Buffer>;
+    /**
+     * @returns {Promise<number>} unsigned 8-bit integer
+     */
+    readUInt8(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 8-bit integer
+     */
+    readByte(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 16-bit big-endian integer
+     */
+    readInt16BE(): Promise<number>;
+    /**
+     * @returns {Promise<number>} signed 32-bit big-endian integer
+     */
+    readInt32BE(): Promise<number>;
+    /**
+     * @returns {Promise<bigint>} signed 64-bit big-endian integer
+     */
+    readBigInt64BE(): Promise<bigint>;
+    /**
+     * @returns {Promise<number>} 32-bit big-endian float
+     */
+    readFloatBE(): Promise<number>;
+    /**
+     * @returns {Promise<number>} 64-bit big-endian double
+     */
+    readDoubleBE(): Promise<number>;
+    #private;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,181 @@
+/*
+ *  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.
+ */
+import { Buffer } from 'buffer';
+/**
+ * Async byte reader that provides a uniform interface over both a complete Buffer
+ * (for non-streaming submit()) and a ReadableStream (for streaming HTTP responses).
+ *
+ * Handles chunk boundaries transparently and blocks (awaits) until the requested bytes are available.
+ */
+export default class StreamReader {
+    /** @type {Buffer} */
+    #buffer;
+    /** @type {number} */
+    #offset;
+    /** @type {ReadableStreamDefaultReader|null} */
+    #reader;
+    /** @type {number} Total bytes consumed (monotonically increasing, survives chunk reassembly) */
+    #position;
+    /**
+     * @param {Buffer} initialBuffer
+     * @param {ReadableStreamDefaultReader|null} reader
+     */
+    constructor(initialBuffer, reader) {
+        this.#buffer = initialBuffer;
+        this.#offset = 0;
+        this.#reader = reader;
+        this.#position = 0;
+    }
+    /**
+     * Create a StreamReader backed by a complete Buffer.
+     * All reads are satisfied from the buffer; no async I/O occurs.
+     * @param {Buffer} buffer
+     * @returns {StreamReader}
+     */
+    static fromBuffer(buffer) {
+        return new StreamReader(buffer, null);
+    }
+    /**
+     * Create a StreamReader backed by a ReadableStream (e.g. fetch response.body).
+     * Reads pull chunks from the stream as needed.
+     * @param {ReadableStream} readableStream
+     * @returns {StreamReader}
+     */
+    static fromReadableStream(readableStream) {
+        return new StreamReader(Buffer.alloc(0), readableStream.getReader());
+    }
+    /**
+     * Ensure at least `n` bytes are available in the buffer from the current offset.
+     * For buffer-backed readers this is a bounds check. For stream-backed readers
+     * this pulls chunks until enough data is buffered.
+     * @param {number} n
+     */
+    async #ensure(n) {
+        const available = this.#buffer.length - this.#offset;
+        if (available >= n) {
+            return;
+        }
+        if (this.#reader === null) {
+            throw new Error(`Unexpected end of buffer at position ${this.#position}: needed ${n} bytes, ${available} available`);
+        }
+        // Collect chunks until we have enough
+        const chunks = [this.#buffer.subarray(this.#offset)];
+        let total = available;
+        while (total < n) {
+            const { value, done } = await this.#reader.read();
+            if (done) {
+                break;
+            }
+            const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+            chunks.push(chunk);
+            total += chunk.length;
+        }
+        if (total < n) {
+            throw new Error(`Unexpected end of stream at position ${this.#position}: needed ${n} bytes, ${total} available`);
+        }
+        this.#buffer = Buffer.concat(chunks);
+        this.#offset = 0;
+    }
+    /**
+     * Total number of bytes consumed so far (monotonically increasing).
+     * Useful for error diagnostics.
+     * @returns {number}
+     */
+    get position() {
+        return this.#position;
+    }
+    /**
+     * Read exactly `n` bytes and return them as a Buffer.
+     * @param {number} n
+     * @returns {Promise<Buffer>}
+     */
+    async readBytes(n) {
+        await this.#ensure(n);
+        const result = this.#buffer.subarray(this.#offset, this.#offset + n);
+        this.#offset += n;
+        this.#position += n;
+        return result;
+    }
+    /**
+     * @returns {Promise<number>} unsigned 8-bit integer
+     */
+    async readUInt8() {
+        await this.#ensure(1);
+        this.#position++;
+        return this.#buffer[this.#offset++];
+    }
+    /**
+     * @returns {Promise<number>} signed 8-bit integer
+     */
+    async readByte() {
+        await this.#ensure(1);
+        this.#position++;
+        return this.#buffer.readInt8(this.#offset++);
+    }
+    /**
+     * @returns {Promise<number>} signed 16-bit big-endian integer
+     */
+    async readInt16BE() {
+        await this.#ensure(2);
+        const v = this.#buffer.readInt16BE(this.#offset);
+        this.#offset += 2;
+        this.#position += 2;
+        return v;
+    }
+    /**
+     * @returns {Promise<number>} signed 32-bit big-endian integer
+     */
+    async readInt32BE() {
+        await this.#ensure(4);
+        const v = this.#buffer.readInt32BE(this.#offset);
+        this.#offset += 4;
+        this.#position += 4;
+        return v;
+    }
+    /**
+     * @returns {Promise<bigint>} signed 64-bit big-endian integer
+     */
+    async readBigInt64BE() {
+        await this.#ensure(8);
+        const v = this.#buffer.readBigInt64BE(this.#offset);
+        this.#offset += 8;
+        this.#position += 8;
+        return v;
+    }
+    /**
+     * @returns {Promise<number>} 32-bit big-endian float
+     */
+    async readFloatBE() {
+        await this.#ensure(4);
+        const v = this.#buffer.readFloatBE(this.#offset);
+        this.#offset += 4;
+        this.#position += 4;
+        return v;
+    }
+    /**
+     * @returns {Promise<number>} 64-bit big-endian double
+     */
+    async readDoubleBE() {
+        await this.#ensure(8);
+        const v = this.#buffer.readDoubleBE(this.#offset);
+        this.#offset += 8;
+        this.#position += 8;
+        return v;
+    }
+}

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

@@ -0,0 +1,21 @@
+export default class StringSerializer {
+    constructor(ioc: any, ID: any);
+    ioc: any;
+    ID: any;
+    canBeUsedFor(value: any): value is string;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    /**
+     * Read the string value bytes from the StreamReader (length + text_value).
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<string>;
+    /**
+     * Read a fully-qualified string from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    deserialize(reader: StreamReader): Promise<string | null>;
+}

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

@@ -0,0 +1,85 @@
+/*
+ *  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 StringSerializer {
+    constructor(ioc, ID) {
+        this.ioc = ioc;
+        this.ID = ID;
+        this.ioc.serializers[ID] = this;
+    }
+    canBeUsedFor(value) {
+        return typeof value === 'string';
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ID, 0x01]);
+            }
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ID, 0x00]));
+        }
+        const v = Buffer.from(String(item), 'utf8');
+        bufs.push(this.ioc.intSerializer.serialize(v.length, false)); // TODO: what if len > INT32_MAX, for now it's backed by logic of IntSerializer.serialize itself
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Read the string value bytes from the StreamReader (length + text_value).
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        if (length < 0) {
+            throw new Error(`StringSerializer: {length}=${length} is less than zero`);
+        }
+        if (length === 0) {
+            return '';
+        }
+        const bytes = await reader.readBytes(length);
+        return bytes.toString('utf8');
+    }
+    /**
+     * Read a fully-qualified string from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ID) {
+            throw new Error(`StringSerializer: 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(`StringSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,7 @@
+export default class StubSerializer {
+    constructor(ioc: any, typeCode: any, typeName: any);
+    ioc: any;
+    typeCode: any;
+    typeName: any;
+    deserializeValue(reader: any, valueFlag: any, typeCode: any): Promise<void>;
+}