@sachitv/avro-typescript 0.4.2 → 0.5.0

package/esm/schemas/complex/array_type.js

@@ -9,13 +9,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ArrayType_instances, _ArrayType_itemsType, _ArrayType_readArraySize, _ArrayResolver_itemResolver;
-import { WritableTap, } from "../../serialization/tap.js";
+var _ArrayType_instances, _ArrayType_itemsType, _ArrayType_readArraySize, _ArrayType_readArraySizeSync, _ArrayResolver_itemResolver;
 import { bigIntToSafeNumber } from "../../serialization/conversion.js";
 import { BaseType } from "../base_type.js";
 import { Resolver } from "../resolver.js";
-import { throwInvalidError } from "../error.js";
-import { calculateVarintSize } from "../../internal/varint.js";
 /**
  * Helper function to read an array from a tap.
  * @param tap The tap to read from.
@@ -40,6 +37,31 @@ export async function readArrayInto(tap, readElement, collect) {
         }
     }
 }
+/**
+ * Synchronous helper function to read an array from a tap.
+ * @param tap The tap to read from.
+ * @param readElement Function to read a single element.
+ * @param collect Function to collect each read element.
+ */
+export function readArrayIntoSync(tap, readElement, collect) {
+    /**
+     * Reads repeated blocks from the tap synchronously and collects decoded elements.
+     */
+    while (true) {
+        const rawCount = tap.readLong();
+        if (rawCount === 0n) {
+            break;
+        }
+        let count = bigIntToSafeNumber(rawCount, "Array block length");
+        if (count < 0) {
+            count = -count;
+            tap.skipLong();
+        }
+        for (let i = 0; i < count; i++) {
+            collect(readElement(tap));
+        }
+    }
+}
 /**
  * Avro `array` type for homogeneous collections of items described by a schema.
  */
@@ -49,7 +71,7 @@ export class ArrayType extends BaseType {
      * @param params The array type parameters.
      */
     constructor(params) {
-        super();
+        super(params.validate ?? true);
         _ArrayType_instances.add(this);
         _ArrayType_itemsType.set(this, void 0);
         if (!params.items) {
@@ -92,22 +114,29 @@ export class ArrayType extends BaseType {
         return isValid;
     }
     /**
-     * Overrides the base write method to serialize an array.
-     * @param tap The tap to write to.
-     * @param value The array to write.
+     * Writes array without validation.
      */
-    async write(tap, value) {
-        if (!Array.isArray(value)) {
-            throwInvalidError([], value, this);
-        }
+    async writeUnchecked(tap, value) {
         if (value.length > 0) {
             await tap.writeLong(BigInt(value.length));
             for (const element of value) {
-                await __classPrivateFieldGet(this, _ArrayType_itemsType, "f").write(tap, element);
+                await __classPrivateFieldGet(this, _ArrayType_itemsType, "f").writeUnchecked(tap, element);
             }
         }
         await tap.writeLong(0n);
     }
+    /**
+     * Writes array without validation synchronously.
+     */
+    writeSyncUnchecked(tap, value) {
+        if (value.length > 0) {
+            tap.writeLong(BigInt(value.length));
+            for (const element of value) {
+                __classPrivateFieldGet(this, _ArrayType_itemsType, "f").writeSyncUnchecked(tap, element);
+            }
+        }
+        tap.writeLong(0n);
+    }
     /**
      * Overrides the base skip method to skip over an array in the tap.
      * @param tap The tap to skip from.
@@ -137,6 +166,30 @@ export class ArrayType extends BaseType {
             }
         }
     }
+    /**
+     * Advances the sync tap past the encoded array without decoding elements.
+     */
+    skipSync(tap) {
+        while (true) {
+            const rawCount = tap.readLong();
+            if (rawCount === 0n) {
+                break;
+            }
+            let count = bigIntToSafeNumber(rawCount, "Array block length");
+            if (count < 0) {
+                count = -count;
+                const blockSize = Number(tap.readLong());
+                if (blockSize > 0) {
+                    tap.skipFixed(blockSize);
+                }
+            }
+            else {
+                for (let i = 0; i < count; i++) {
+                    __classPrivateFieldGet(this, _ArrayType_itemsType, "f").skipSync(tap);
+                }
+            }
+        }
+    }
     /**
      * Overrides the base read method to deserialize an array.
      * @param tap The tap to read from.
@@ -150,32 +203,17 @@ export class ArrayType extends BaseType {
         return result;
     }
     /**
-     * Overrides the base toBuffer method to serialize an array to a buffer.
-     * @param value The array to serialize.
-     * @returns The serialized buffer.
+     * Reads the entire array synchronously from the tap.
      */
-    async toBuffer(value) {
-        if (!Array.isArray(value)) {
-            throwInvalidError([], value, this);
-        }
-        const elementBuffers = value.length === 0 ? [] : await Promise.all(value.map(async (element) => new Uint8Array(await __classPrivateFieldGet(this, _ArrayType_itemsType, "f").toBuffer(element))));
-        let totalSize = 1; // final zero block terminator
-        if (value.length > 0) {
-            totalSize += calculateVarintSize(value.length);
-            for (const buf of elementBuffers) {
-                totalSize += buf.byteLength;
-            }
-        }
-        const buffer = new ArrayBuffer(totalSize);
-        const tap = new WritableTap(buffer);
-        if (value.length > 0) {
-            await tap.writeLong(BigInt(value.length));
-            for (const buf of elementBuffers) {
-                await tap.writeFixed(buf);
-            }
-        }
-        await tap.writeLong(0n);
-        return buffer;
+    /**
+     * Reads resolved elements synchronously through the item resolver.
+     */
+    readSync(tap) {
+        const result = [];
+        readArrayIntoSync(tap, (innerTap) => __classPrivateFieldGet(this, _ArrayType_itemsType, "f").readSync(innerTap), (value) => {
+            result.push(value);
+        });
+        return result;
     }
     /**
      * Overrides the base cloneFromValue method to clone an array.
@@ -257,7 +295,45 @@ export class ArrayType extends BaseType {
                 n2 = await __classPrivateFieldGet(this, _ArrayType_instances, "m", _ArrayType_readArraySize).call(this, tap2);
             }
         }
-        return n1 === n2 ? 0 : n1 < n2 ? -1 : 1;
+        if (n1 === n2) {
+            return 0;
+        }
+        if (n1 < n2) {
+            return -1;
+        }
+        return 1;
+    }
+    /**
+     * Compares two sync taps that encode arrays for ordering.
+     */
+    matchSync(tap1, tap2) {
+        let n1 = __classPrivateFieldGet(this, _ArrayType_instances, "m", _ArrayType_readArraySizeSync).call(this, tap1);
+        let n2 = __classPrivateFieldGet(this, _ArrayType_instances, "m", _ArrayType_readArraySizeSync).call(this, tap2);
+        while (n1 !== 0n && n2 !== 0n) {
+            const f = __classPrivateFieldGet(this, _ArrayType_itemsType, "f").matchSync(tap1, tap2);
+            if (f !== 0) {
+                return f;
+            }
+            if (n1 > 0n) {
+                n1--;
+            }
+            if (n1 === 0n) {
+                n1 = __classPrivateFieldGet(this, _ArrayType_instances, "m", _ArrayType_readArraySizeSync).call(this, tap1);
+            }
+            if (n2 > 0n) {
+                n2--;
+            }
+            if (n2 === 0n) {
+                n2 = __classPrivateFieldGet(this, _ArrayType_instances, "m", _ArrayType_readArraySizeSync).call(this, tap2);
+            }
+        }
+        if (n1 === n2) {
+            return 0;
+        }
+        if (n1 < n2) {
+            return -1;
+        }
+        return 1;
     }
     /**
      * Creates a resolver for schema evolution between array types.
@@ -279,6 +355,13 @@ _ArrayType_itemsType = new WeakMap(), _ArrayType_instances = new WeakSet(), _Arr
         await tap.skipLong(); // skip size
     }
     return n;
+}, _ArrayType_readArraySizeSync = function _ArrayType_readArraySizeSync(tap) {
+    let n = tap.readLong();
+    if (n < 0n) {
+        n = -n;
+        tap.skipLong();
+    }
+    return n;
 };
 class ArrayResolver extends Resolver {
     constructor(reader, itemResolver) {
@@ -295,5 +378,12 @@ class ArrayResolver extends Resolver {
         });
         return result;
     }
+    readSync(tap) {
+        const result = [];
+        readArrayIntoSync(tap, (innerTap) => __classPrivateFieldGet(this, _ArrayResolver_itemResolver, "f").readSync(innerTap), (value) => {
+            result.push(value);
+        });
+        return result;
+    }
 }
 _ArrayResolver_itemResolver = new WeakMap();

package/esm/schemas/complex/enum_type.d.ts

@@ -1,4 +1,5 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { Resolver } from "../resolver.js";
 import type { JSONType, Type } from "../type.js";
 import { NamedType } from "./named_type.js";
@@ -12,6 +13,8 @@ export interface EnumTypeParams extends ResolvedNames {
     symbols: string[];
     /** Optional default value. */
     default?: string;
+    /** Whether to validate during writes. Defaults to true. */
+    validate?: boolean;
 }
 /**
  * Avro enum type implemented in TypeScript.
@@ -41,23 +44,33 @@ export declare class EnumType extends NamedType<string> {
      */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /**
-     * Serializes the enum value by writing its index.
-     * @param tap The tap to write to.
-     * @param value The enum value to write.
+     * Writes enum value without type validation.
+     * Still validates that the symbol exists to avoid undefined behavior.
      */
-    write(tap: WritableTapLike, value: string): Promise<void>;
+    writeUnchecked(tap: WritableTapLike, value: string): Promise<void>;
+    /**
+     * Writes enum value without type validation synchronously.
+     * Still validates that the symbol exists to avoid undefined behavior.
+     */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: string): void;
+    /** Returns the encoded byte length for the given enum value. */
+    protected byteLength(value: string): number;
     /**
      * Skips the enum value in the tap.
      */
     skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Advances the sync tap past a stored enum index.
+     */
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Reads the enum value from the tap.
      */
     read(tap: ReadableTapLike): Promise<string>;
     /**
-     * Converts the enum value to its binary buffer representation.
+     * Reads an enum index synchronously and returns the matching symbol.
      */
-    toBuffer(value: string): Promise<ArrayBuffer>;
+    readSync(tap: SyncReadableTapLike): string;
     /** Clones a value into a string. */
     cloneFromValue(value: unknown): string;
     /** Compares two strings. */
@@ -74,6 +87,10 @@ export declare class EnumType extends NamedType<string> {
      * Compares two encoded enum values for equality.
      */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the enum indices stored in two sync taps.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Creates a resolver for schema evolution between enum types.
      */

package/esm/schemas/complex/enum_type.js

@@ -10,7 +10,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _EnumType_symbols, _EnumType_indices, _EnumType_default;
-import { WritableTap, } from "../../serialization/tap.js";
 import { Resolver } from "../resolver.js";
 import { NamedType } from "./named_type.js";
 import { isValidName } from "./resolve_names.js";
@@ -30,7 +29,7 @@ export class EnumType extends NamedType {
             throw new Error("EnumType requires a non-empty symbols array.");
         }
         const { symbols, default: defaultValue, ...nameInfo } = params;
-        super(nameInfo);
+        super(nameInfo, params.validate ?? true);
         _EnumType_symbols.set(this, void 0);
         _EnumType_indices.set(this, void 0);
         _EnumType_default.set(this, void 0);
@@ -79,23 +78,47 @@ export class EnumType extends NamedType {
         return isValid;
     }
     /**
-     * Serializes the enum value by writing its index.
-     * @param tap The tap to write to.
-     * @param value The enum value to write.
+     * Writes enum value without type validation.
+     * Still validates that the symbol exists to avoid undefined behavior.
      */
-    async write(tap, value) {
+    async writeUnchecked(tap, value) {
         const index = __classPrivateFieldGet(this, _EnumType_indices, "f").get(value);
         if (index === undefined) {
             throwInvalidError([], value, this);
         }
         await tap.writeLong(BigInt(index));
     }
+    /**
+     * Writes enum value without type validation synchronously.
+     * Still validates that the symbol exists to avoid undefined behavior.
+     */
+    writeSyncUnchecked(tap, value) {
+        const index = __classPrivateFieldGet(this, _EnumType_indices, "f").get(value);
+        if (index === undefined) {
+            throwInvalidError([], value, this);
+        }
+        tap.writeLong(BigInt(index));
+    }
+    /** Returns the encoded byte length for the given enum value. */
+    byteLength(value) {
+        const index = __classPrivateFieldGet(this, _EnumType_indices, "f").get(value);
+        if (index === undefined) {
+            throwInvalidError([], value, this);
+        }
+        return calculateVarintSize(index);
+    }
     /**
      * Skips the enum value in the tap.
      */
     async skip(tap) {
         await tap.skipLong();
     }
+    /**
+     * Advances the sync tap past a stored enum index.
+     */
+    skipSync(tap) {
+        tap.skipLong();
+    }
     /**
      * Reads the enum value from the tap.
      */
@@ -108,16 +131,15 @@ export class EnumType extends NamedType {
         return __classPrivateFieldGet(this, _EnumType_symbols, "f")[index];
     }
     /**
-     * Converts the enum value to its binary buffer representation.
+     * Reads an enum index synchronously and returns the matching symbol.
      */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        const index = __classPrivateFieldGet(this, _EnumType_indices, "f").get(value);
-        const size = calculateVarintSize(index);
-        const buffer = new ArrayBuffer(size);
-        const tap = new WritableTap(buffer);
-        await this.write(tap, value);
-        return buffer;
+    readSync(tap) {
+        const rawIndex = tap.readLong();
+        const index = Number(rawIndex);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= __classPrivateFieldGet(this, _EnumType_symbols, "f").length) {
+            throw new Error(`Invalid enum index ${rawIndex.toString()} for ${this.getFullName()}`);
+        }
+        return __classPrivateFieldGet(this, _EnumType_symbols, "f")[index];
     }
     /** Clones a value into a string. */
     cloneFromValue(value) {
@@ -154,6 +176,12 @@ export class EnumType extends NamedType {
     async match(tap1, tap2) {
         return await tap1.matchLong(tap2);
     }
+    /**
+     * Compares the enum indices stored in two sync taps.
+     */
+    matchSync(tap1, tap2) {
+        return tap1.matchLong(tap2);
+    }
     /**
      * Creates a resolver for schema evolution between enum types.
      */
@@ -182,6 +210,12 @@ export class EnumType extends NamedType {
                     async read(tap) {
                         return await __classPrivateFieldGet(this, _writer, "f").read(tap);
                     }
+                    /**
+                     * Reads a symbol via the underlying writer enum synchronously.
+                     */
+                    readSync(tap) {
+                        return __classPrivateFieldGet(this, _writer, "f").readSync(tap);
+                    }
                 },
                 _writer = new WeakMap(),
                 _a)(this, writerType);
@@ -204,6 +238,18 @@ export class EnumType extends NamedType {
                             return __classPrivateFieldGet(__classPrivateFieldGet(this, _reader, "f"), _EnumType_default, "f");
                         }
                     }
+                    /**
+                     * Reads a writer symbol and falls back to the reader default synchronously.
+                     */
+                    readSync(tap) {
+                        const writerSymbol = __classPrivateFieldGet(this, _writer_1, "f").readSync(tap);
+                        if (__classPrivateFieldGet(__classPrivateFieldGet(this, _reader, "f"), _EnumType_indices, "f").has(writerSymbol)) {
+                            return writerSymbol;
+                        }
+                        else {
+                            return __classPrivateFieldGet(__classPrivateFieldGet(this, _reader, "f"), _EnumType_default, "f");
+                        }
+                    }
                 },
                 _writer_1 = new WeakMap(),
                 _reader = new WeakMap(),

package/esm/schemas/complex/fixed_type.d.ts

@@ -1,4 +1,5 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { NamedType } from "./named_type.js";
 import { Resolver } from "../resolver.js";
 import type { JSONType, Type } from "../type.js";
@@ -10,6 +11,8 @@ import type { ResolvedNames } from "./resolve_names.js";
 export interface FixedTypeParams extends ResolvedNames {
     /** The size in bytes. */
     size: number;
+    /** Whether to validate during writes. Defaults to true. */
+    validate?: boolean;
 }
 /**
  * Avro `fixed` type representing a fixed-length byte sequence.
@@ -21,23 +24,18 @@ export declare class FixedType extends NamedType<Uint8Array> {
      * @param params The fixed type parameters.
      */
     constructor(params: FixedTypeParams);
-    /**
-     * Gets the size in bytes.
-     */
-    sizeBytes(): number;
-    /**
-     * Serializes a value into an ArrayBuffer using the exact fixed size.
-     * @param value The value to serialize.
-     * @returns The serialized ArrayBuffer.
-     */
-    toBuffer(value: Uint8Array): Promise<ArrayBuffer>;
     /**
      * Skips a fixed-size value by advancing the tap by the fixed size.
      * @param tap The tap to skip from.
      */
     skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Advances a sync tap past the fixed payload without reading.
+     */
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Gets the size in bytes.
+     * This is a public method so that it can be called in the resolver.
      */
     getSize(): number;
     /**
@@ -54,12 +52,25 @@ export declare class FixedType extends NamedType<Uint8Array> {
      * @returns The read byte array.
      */
     read(tap: ReadableTapLike): Promise<Uint8Array>;
+    /**
+     * Reads the fixed bytes synchronously from a tap.
+     */
+    readSync(tap: SyncReadableTapLike): Uint8Array;
     /**
      * Writes a fixed-size byte array to the tap.
      * @param tap The tap to write to.
      * @param value The byte array to write.
      */
-    write(tap: WritableTapLike, value: Uint8Array): Promise<void>;
+    /**
+     * Writes fixed bytes without validation.
+     */
+    writeUnchecked(tap: WritableTapLike, value: Uint8Array): Promise<void>;
+    /**
+     * Writes fixed bytes without validation synchronously.
+     */
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: Uint8Array): void;
+    /** Returns the fixed byte length. */
+    protected byteLength(_value: Uint8Array): number;
     /**
      * Matches two fixed-size byte arrays from the taps.
      * @param tap1 The first tap.
@@ -67,6 +78,10 @@ export declare class FixedType extends NamedType<Uint8Array> {
      * @returns The comparison result.
      */
     match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Compares two sync taps that decode fixed values.
+     */
+    matchSync(tap1: SyncReadableTapLike, tap2: SyncReadableTapLike): number;
     /**
      * Compares two fixed values for ordering.
      * @param val1 The first value to compare.

package/esm/schemas/complex/fixed_type.js

@@ -10,7 +10,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _a, _FixedType_size, _FixedType_fromJsonString;
-import { WritableTap, } from "../../serialization/tap.js";
 import { NamedType } from "./named_type.js";
 import { Resolver } from "../resolver.js";
 import { throwInvalidError } from "../error.js";
@@ -28,38 +27,26 @@ export class FixedType extends NamedType {
         if (!Number.isInteger(size) || size < 1) {
             throw new Error(`Invalid fixed size: ${size}. Size must be a positive integer.`);
         }
-        super(names);
+        super(names, params.validate ?? true);
         _FixedType_size.set(this, void 0);
         __classPrivateFieldSet(this, _FixedType_size, size, "f");
     }
-    /**
-     * Gets the size in bytes.
-     */
-    sizeBytes() {
-        return __classPrivateFieldGet(this, _FixedType_size, "f");
-    }
-    /**
-     * Serializes a value into an ArrayBuffer using the exact fixed size.
-     * @param value The value to serialize.
-     * @returns The serialized ArrayBuffer.
-     */
-    async toBuffer(value) {
-        this.check(value, throwInvalidError, []);
-        const size = this.sizeBytes();
-        const buf = new ArrayBuffer(size);
-        const tap = new WritableTap(buf);
-        await this.write(tap, value);
-        return buf;
-    }
     /**
      * Skips a fixed-size value by advancing the tap by the fixed size.
      * @param tap The tap to skip from.
      */
     async skip(tap) {
-        await tap.skipFixed(this.sizeBytes());
+        await tap.skipFixed(__classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
+    /**
+     * Advances a sync tap past the fixed payload without reading.
+     */
+    skipSync(tap) {
+        tap.skipFixed(__classPrivateFieldGet(this, _FixedType_size, "f"));
     }
     /**
      * Gets the size in bytes.
+     * This is a public method so that it can be called in the resolver.
      */
     getSize() {
         return __classPrivateFieldGet(this, _FixedType_size, "f");
@@ -86,16 +73,32 @@ export class FixedType extends NamedType {
     async read(tap) {
         return await tap.readFixed(__classPrivateFieldGet(this, _FixedType_size, "f"));
     }
+    /**
+     * Reads the fixed bytes synchronously from a tap.
+     */
+    readSync(tap) {
+        return tap.readFixed(__classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
     /**
      * Writes a fixed-size byte array to the tap.
      * @param tap The tap to write to.
      * @param value The byte array to write.
      */
-    async write(tap, value) {
-        if (!(value instanceof Uint8Array) || value.length !== __classPrivateFieldGet(this, _FixedType_size, "f")) {
-            throwInvalidError([], value, this);
-        }
-        await tap.writeFixed(value, __classPrivateFieldGet(this, _FixedType_size, "f"));
+    /**
+     * Writes fixed bytes without validation.
+     */
+    async writeUnchecked(tap, value) {
+        await tap.writeFixed(value);
+    }
+    /**
+     * Writes fixed bytes without validation synchronously.
+     */
+    writeSyncUnchecked(tap, value) {
+        tap.writeFixed(value);
+    }
+    /** Returns the fixed byte length. */
+    byteLength(_value) {
+        return __classPrivateFieldGet(this, _FixedType_size, "f");
     }
     /**
      * Matches two fixed-size byte arrays from the taps.
@@ -106,6 +109,12 @@ export class FixedType extends NamedType {
     async match(tap1, tap2) {
         return await tap1.matchFixed(tap2, __classPrivateFieldGet(this, _FixedType_size, "f"));
     }
+    /**
+     * Compares two sync taps that decode fixed values.
+     */
+    matchSync(tap1, tap2) {
+        return tap1.matchFixed(tap2, __classPrivateFieldGet(this, _FixedType_size, "f"));
+    }
     /**
      * Compares two fixed values for ordering.
      * @param val1 The first value to compare.
@@ -205,4 +214,8 @@ class FixedResolver extends Resolver {
         const reader = this.readerType;
         return await reader.read(tap);
     }
+    readSync(tap) {
+        const reader = this.readerType;
+        return reader.readSync(tap);
+    }
 }