@sachitv/avro-typescript 0.4.0

package/esm/schemas/logical/temporal_logical_types.js

@@ -0,0 +1,364 @@
+import { LogicalType, withLogicalTypeJSON } from "./logical_type.js";
+import { bigIntToSafeNumber } from "../../serialization/conversion.js";
+const MILLIS_PER_DAY = 86400000;
+const MICROS_PER_DAY = 86400000000n;
+/**
+ * Logical type for `date`.
+ * Represents the number of days since the epoch.
+ */
+export class DateLogicalType extends LogicalType {
+    /**
+     * Creates a new DateLogicalType.
+     * @param underlying The underlying int type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof DateLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "number" && Number.isInteger(value);
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const today = Math.floor(Date.now() / MILLIS_PER_DAY);
+        return today + Math.floor(Math.random() * 2000) - 1000;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "date");
+    }
+}
+/**
+ * Logical type for `time-millis`.
+ * Represents the time of day in milliseconds since midnight.
+ */
+export class TimeMillisLogicalType extends LogicalType {
+    /**
+     * Creates a new TimeMillisLogicalType.
+     * @param underlying The underlying int type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof TimeMillisLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "number" && Number.isInteger(value) &&
+            value >= 0 && value < MILLIS_PER_DAY;
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        return Math.floor(Math.random() * MILLIS_PER_DAY);
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "time-millis");
+    }
+}
+/**
+ * Logical type for `time-micros`.
+ * Represents the time of day in microseconds since midnight.
+ */
+export class TimeMicrosLogicalType extends LogicalType {
+    /**
+     * Creates a new TimeMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof TimeMicrosLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "bigint" && value >= 0n && value < MICROS_PER_DAY;
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        return BigInt(Math.floor(Math.random() * Number(MICROS_PER_DAY)));
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "time-micros");
+    }
+}
+/**
+ * Logical type for `timestamp-millis`.
+ * Represents an instant in time as the number of milliseconds since the epoch.
+ */
+export class TimestampMillisLogicalType extends LogicalType {
+    /**
+     * Creates a new TimestampMillisLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof TimestampMillisLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return value instanceof Date && !Number.isNaN(value.getTime());
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        const millis = value.getTime();
+        if (!Number.isFinite(millis)) {
+            throw new Error("Invalid Date value for timestamp-millis logical type.");
+        }
+        return BigInt(Math.trunc(millis));
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        const millis = bigIntToSafeNumber(value, "timestamp-millis");
+        return new Date(millis);
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const now = Date.now();
+        const offset = Math.floor(Math.random() * 1000000000) - 500000000;
+        return new Date(now + offset);
+    }
+    /** Compares two Date values. */
+    compare(val1, val2) {
+        const diff = val1.getTime() - val2.getTime();
+        return diff < 0 ? -1 : diff > 0 ? 1 : 0;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "timestamp-millis");
+    }
+}
+/**
+ * Logical type for `timestamp-micros`.
+ * Represents an instant in time as the number of microseconds since the epoch.
+ */
+export class TimestampMicrosLogicalType extends LogicalType {
+    /**
+     * Creates a new TimestampMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof TimestampMicrosLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "bigint";
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const nowMicros = BigInt(Math.trunc(Date.now())) * 1000n;
+        const offset = BigInt(Math.floor(Math.random() * 1000000)) - 500000n;
+        return nowMicros + offset;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "timestamp-micros");
+    }
+}
+/**
+ * Logical type for `timestamp-nanos`.
+ * Represents an instant in time as the number of nanoseconds since the epoch.
+ */
+export class TimestampNanosLogicalType extends LogicalType {
+    /**
+     * Creates a new TimestampNanosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof TimestampNanosLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "bigint";
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const nowNanos = BigInt(Math.trunc(Date.now())) * 1000000n;
+        const offset = BigInt(Math.floor(Math.random() * 1000000)) - 500000n;
+        return nowNanos + offset;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "timestamp-nanos");
+    }
+}
+/**
+ * Logical type for `local-timestamp-millis`.
+ * Represents a timestamp in a local time zone, in milliseconds.
+ */
+export class LocalTimestampMillisLogicalType extends LogicalType {
+    /**
+     * Creates a new LocalTimestampMillisLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof LocalTimestampMillisLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "number" && Number.isFinite(value) &&
+            Number.isInteger(value);
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return BigInt(value);
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return bigIntToSafeNumber(value, "local-timestamp-millis");
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const now = Date.now();
+        const offset = Math.floor(Math.random() * 1000000000) - 500000000;
+        return Math.trunc(now + offset);
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "local-timestamp-millis");
+    }
+}
+/**
+ * Logical type for `local-timestamp-micros`.
+ * Represents a timestamp in a local time zone, in microseconds.
+ */
+export class LocalTimestampMicrosLogicalType extends LogicalType {
+    /**
+     * Creates a new LocalTimestampMicrosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof LocalTimestampMicrosLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "bigint";
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const nowMicros = BigInt(Math.trunc(Date.now())) * 1000n;
+        const offset = BigInt(Math.floor(Math.random() * 1000000)) - 500000n;
+        return nowMicros + offset;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "local-timestamp-micros");
+    }
+}
+/**
+ * Logical type for `local-timestamp-nanos`.
+ * Represents a timestamp in a local time zone, in nanoseconds.
+ */
+export class LocalTimestampNanosLogicalType extends LogicalType {
+    /**
+     * Creates a new LocalTimestampNanosLogicalType.
+     * @param underlying The underlying long type.
+     */
+    constructor(underlying) {
+        super(underlying);
+    }
+    /** Checks if the logical type can read from the underlying type. */
+    canReadFromLogical(writer) {
+        return writer instanceof LocalTimestampNanosLogicalType;
+    }
+    /** Checks if the value is a valid instance of this logical type. */
+    isInstance(value) {
+        return typeof value === "bigint";
+    }
+    /** Converts the logical value to the underlying representation. */
+    toUnderlying(value) {
+        return value;
+    }
+    /** Converts the underlying value to the logical representation. */
+    fromUnderlying(value) {
+        return value;
+    }
+    /** Generates a random value for testing. */
+    random() {
+        const nowNanos = BigInt(Math.trunc(Date.now())) * 1000000n;
+        const offset = BigInt(Math.floor(Math.random() * 1000000)) - 500000n;
+        return nowNanos + offset;
+    }
+    /** Returns the JSON representation of this type. */
+    toJSON() {
+        return withLogicalTypeJSON(this.getUnderlyingType().toJSON(), "local-timestamp-nanos");
+    }
+}

package/esm/schemas/logical/uuid_logical_type.d.ts

@@ -0,0 +1,63 @@
+import { FixedType } from "../complex/fixed_type.js";
+import { StringType } from "../primitive/string_type.js";
+import { LogicalType } from "./logical_type.js";
+import type { JSONType } from "../type.js";
+/**
+ * Logical type for UUID.
+ * Represents a universally unique identifier.
+ */
+export declare class UuidLogicalType extends LogicalType<string, string | Uint8Array> {
+    #private;
+    /**
+     * Creates a UUID logical type backed by the given underlying type.
+     * @param underlying The underlying StringType or FixedType.
+     */
+    constructor(underlying: StringType | FixedType);
+    /**
+     * Checks if this UUID logical type can read from the given writer logical type.
+     * @param writer The writer logical type.
+     * @returns True if compatible, false otherwise.
+     */
+    protected canReadFromLogical(writer: LogicalType<unknown, unknown>): boolean;
+    /**
+     * Determines if the given value is a valid UUID string.
+     * @param value The value to check.
+     * @returns True if the value is a valid UUID string.
+     */
+    protected isInstance(value: unknown): value is string;
+    /**
+     * Converts a UUID string to the underlying type's representation.
+     * @param value The UUID string.
+     * @returns The underlying representation.
+     */
+    protected toUnderlying(value: string): string | Uint8Array;
+    /**
+     * Converts from the underlying type's representation to a UUID string.
+     * @param value The underlying value.
+     * @returns The UUID string.
+     */
+    protected fromUnderlying(value: string | Uint8Array): string;
+    /**
+     * Generates a random UUID string.
+     */
+    random(): string;
+    /**
+     * Returns the JSON schema representation of this logical type.
+     */
+    toJSON(): JSONType;
+    /**
+     * Returns the full name of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getFullName(): string;
+    /**
+     * Returns the namespace of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getNamespace(): string;
+    /**
+     * Returns the aliases of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getAliases(): string[];
+}

package/esm/schemas/logical/uuid_logical_type.js

@@ -0,0 +1,146 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _UuidLogicalType_underlying, _UuidLogicalType_named;
+import { FixedType } from "../complex/fixed_type.js";
+import { StringType } from "../primitive/string_type.js";
+import { withLogicalTypeJSON } from "./logical_type.js";
+import { LogicalType } from "./logical_type.js";
+const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+/**
+ * Logical type for UUID.
+ * Represents a universally unique identifier.
+ */
+export class UuidLogicalType extends LogicalType {
+    /**
+     * Creates a UUID logical type backed by the given underlying type.
+     * @param underlying The underlying StringType or FixedType.
+     */
+    constructor(underlying) {
+        super(underlying);
+        _UuidLogicalType_underlying.set(this, void 0);
+        _UuidLogicalType_named.set(this, void 0);
+        __classPrivateFieldSet(this, _UuidLogicalType_underlying, underlying, "f");
+        if (underlying instanceof FixedType) {
+            if (underlying.getSize() !== 16) {
+                throw new Error("UUID logical type requires fixed size of 16 bytes.");
+            }
+            __classPrivateFieldSet(this, _UuidLogicalType_named, underlying, "f");
+        }
+    }
+    /**
+     * Checks if this UUID logical type can read from the given writer logical type.
+     * @param writer The writer logical type.
+     * @returns True if compatible, false otherwise.
+     */
+    canReadFromLogical(writer) {
+        return writer instanceof UuidLogicalType;
+    }
+    /**
+     * Determines if the given value is a valid UUID string.
+     * @param value The value to check.
+     * @returns True if the value is a valid UUID string.
+     */
+    isInstance(value) {
+        return typeof value === "string" && UUID_REGEX.test(value);
+    }
+    /**
+     * Converts a UUID string to the underlying type's representation.
+     * @param value The UUID string.
+     * @returns The underlying representation.
+     */
+    toUnderlying(value) {
+        if (__classPrivateFieldGet(this, _UuidLogicalType_underlying, "f") instanceof StringType) {
+            return value;
+        }
+        return uuidToBytes(value);
+    }
+    /**
+     * Converts from the underlying type's representation to a UUID string.
+     * @param value The underlying value.
+     * @returns The UUID string.
+     */
+    fromUnderlying(value) {
+        if (typeof value === "string") {
+            return value;
+        }
+        return bytesToUuid(value);
+    }
+    /**
+     * Generates a random UUID string.
+     */
+    random() {
+        if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+            return crypto.randomUUID();
+        }
+        const bytes = new Uint8Array(16);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
+        // Set version (4) and variant bits for RFC-4122 compliance.
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        return bytesToUuid(bytes);
+    }
+    /**
+     * Returns the JSON schema representation of this logical type.
+     */
+    toJSON() {
+        return withLogicalTypeJSON(__classPrivateFieldGet(this, _UuidLogicalType_underlying, "f").toJSON(), "uuid");
+    }
+    /**
+     * Returns the full name of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getFullName() {
+        if (!__classPrivateFieldGet(this, _UuidLogicalType_named, "f")) {
+            throw new Error("UUID logical type backed by string has no name.");
+        }
+        return __classPrivateFieldGet(this, _UuidLogicalType_named, "f").getFullName();
+    }
+    /**
+     * Returns the namespace of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getNamespace() {
+        if (!__classPrivateFieldGet(this, _UuidLogicalType_named, "f")) {
+            throw new Error("UUID logical type backed by string has no namespace.");
+        }
+        return __classPrivateFieldGet(this, _UuidLogicalType_named, "f").getNamespace();
+    }
+    /**
+     * Returns the aliases of the named type backing this UUID.
+     * Throws if backed by a primitive string type.
+     */
+    getAliases() {
+        if (!__classPrivateFieldGet(this, _UuidLogicalType_named, "f")) {
+            throw new Error("UUID logical type backed by string has no aliases.");
+        }
+        return __classPrivateFieldGet(this, _UuidLogicalType_named, "f").getAliases();
+    }
+}
+_UuidLogicalType_underlying = new WeakMap(), _UuidLogicalType_named = new WeakMap();
+function uuidToBytes(value) {
+    const hex = value.replace(/-/g, "");
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+        bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function bytesToUuid(bytes) {
+    if (bytes.length !== 16) {
+        throw new Error("UUID bytes must be 16 bytes long.");
+    }
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/esm/schemas/primitive/boolean_type.d.ts

@@ -0,0 +1,49 @@
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import type { JSONType } from "../type.js";
+import { type ErrorHook } from "../error.js";
+/**
+ * Boolean type.
+ */
+export declare class BooleanType extends FixedSizeBaseType<boolean> {
+    /**
+     * Validates if the value is a boolean.
+     */
+    check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
+    /**
+     * Reads a boolean value from the tap.
+     */
+    read(tap: ReadableTapLike): Promise<boolean>;
+    /**
+     * Writes a boolean value to the tap.
+     */
+    write(tap: WritableTapLike, value: boolean): Promise<void>;
+    /**
+     * Skips a boolean value in the tap.
+     */
+    skip(tap: ReadableTapLike): Promise<void>;
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes(): number;
+    /**
+     * Clones a boolean value from the given value.
+     */
+    cloneFromValue(value: unknown): boolean;
+    /**
+     * Compares two boolean values.
+     */
+    compare(val1: boolean, val2: boolean): number;
+    /**
+     * Generates a random boolean value.
+     */
+    random(): boolean;
+    /**
+     * Returns the JSON representation of the boolean type.
+     */
+    toJSON(): JSONType;
+    /**
+     * Matches two boolean values from the taps.
+     */
+    match(tap1: ReadableTapLike, tap2: ReadableTapLike): Promise<number>;
+}

package/esm/schemas/primitive/boolean_type.js

@@ -0,0 +1,75 @@
+import { FixedSizeBaseType } from "./fixed_size_base_type.js";
+import { throwInvalidError } from "../error.js";
+/**
+ * Boolean type.
+ */
+export class BooleanType extends FixedSizeBaseType {
+    /**
+     * Validates if the value is a boolean.
+     */
+    check(value, errorHook, path = []) {
+        const isValid = typeof value === "boolean";
+        if (!isValid && errorHook) {
+            errorHook(path, value, this);
+        }
+        return isValid;
+    }
+    /**
+     * Reads a boolean value from the tap.
+     */
+    async read(tap) {
+        return await tap.readBoolean();
+    }
+    /**
+     * Writes a boolean value to the tap.
+     */
+    async write(tap, value) {
+        if (typeof value !== "boolean") {
+            throwInvalidError([], value, this);
+        }
+        await tap.writeBoolean(value);
+    }
+    /**
+     * Skips a boolean value in the tap.
+     */
+    async skip(tap) {
+        await tap.skipBoolean();
+    }
+    /**
+     * Gets the size in bytes.
+     */
+    sizeBytes() {
+        return 1; // 1 byte
+    }
+    /**
+     * Clones a boolean value from the given value.
+     */
+    cloneFromValue(value) {
+        this.check(value, throwInvalidError, []);
+        return value;
+    }
+    /**
+     * Compares two boolean values.
+     */
+    compare(val1, val2) {
+        return val1 === val2 ? 0 : val1 ? 1 : -1;
+    }
+    /**
+     * Generates a random boolean value.
+     */
+    random() {
+        return Math.random() < 0.5;
+    }
+    /**
+     * Returns the JSON representation of the boolean type.
+     */
+    toJSON() {
+        return "boolean";
+    }
+    /**
+     * Matches two boolean values from the taps.
+     */
+    async match(tap1, tap2) {
+        return await tap1.matchBoolean(tap2);
+    }
+}