@sachitv/avro-typescript 0.4.0

package/esm/serialization/buffers/in_memory_buffer.d.ts

@@ -0,0 +1,121 @@
+import type { IReadableBuffer, IWritableBuffer } from "./buffer.js";
+/**
+ * Shared strict in-memory buffer base with common functionality.
+ */
+export declare abstract class InMemoryBufferBase {
+    /** The underlying Uint8Array view of the buffer. */
+    protected readonly view: Uint8Array;
+    /**
+     * Constructs an InMemoryBufferBase with the given ArrayBuffer.
+     * @param buf The ArrayBuffer to create the view from.
+     */
+    constructor(buf: ArrayBuffer);
+    /**
+     * Returns the length of the buffer in bytes.
+     * @returns The length of the buffer.
+     */
+    length(): Promise<number>;
+}
+/**
+ * Strict read-only in-memory buffer for serialization reads.
+ * Throws errors on all out-of-bounds operations.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Random access: Supports reading at arbitrary byte offsets.
+ * - Strict bounds checking: Operations that exceed buffer bounds throw RangeError.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new StrictInMemoryReadableBuffer(arrayBuffer);
+ *
+ * // Read some data
+ * const data = await buffer.read(0, 4); // Returns Uint8Array of 4 bytes
+ *
+ * // This will throw:
+ * await buffer.read(1020, 10); // RangeError: Operation exceeds buffer bounds
+ * ```
+ */
+export declare class InMemoryReadableBuffer extends InMemoryBufferBase implements IReadableBuffer {
+    /**
+     * Checks if the offset and size are within buffer bounds.
+     * @param offset The starting offset.
+     * @param size The number of bytes to check.
+     */
+    private checkBounds;
+    /**
+     * Reads a portion of the buffer.
+     * @param offset The starting offset.
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the read bytes.
+     */
+    read(offset: number, size: number): Promise<Uint8Array>;
+    /**
+     * Checks if more data can be read starting at the given offset.
+     * @param offset The byte offset to check.
+     * @returns True if at least one byte can be read from the offset.
+     */
+    canReadMore(offset: number): Promise<boolean>;
+}
+/**
+ * Strict write-only in-memory buffer for serialization writes.
+ * Throws errors when attempting to write beyond buffer bounds.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Sequential writes: Maintains an internal offset that advances with each write.
+ * - Strict bounds checking: Throws RangeError when write would exceed buffer capacity.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new StrictInMemoryWritableBuffer(arrayBuffer);
+ *
+ * // Write some data
+ * await buffer.appendBytes(new Uint8Array([1, 2, 3, 4]));
+ *
+ * // This will throw if buffer is full:
+ * await buffer.appendBytes(new Uint8Array(2000)); // RangeError: Write operation exceeds buffer bounds
+ * ```
+ */
+export declare class InMemoryWritableBuffer extends InMemoryBufferBase implements IWritableBuffer {
+    #private;
+    /**
+     * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
+     * @param buf The underlying ArrayBuffer to write to.
+     * @param offset The starting offset within the buffer (default: 0).
+     */
+    constructor(buf: ArrayBuffer, offset?: number);
+    /**
+     * Checks if writing the given data at the specified offset would exceed buffer bounds.
+     * Throws a RangeError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param data The data to write.
+     */
+    protected checkWriteBounds(offset: number, data: Uint8Array): void;
+    /**
+     * Appends the given bytes to the buffer at the current offset and advances the offset.
+     * @param data The bytes to append.
+     */
+    appendBytes(data: Uint8Array): Promise<void>;
+    /**
+     * Checks if the buffer is in a valid state.
+     * Always returns true as this buffer throws on overflow instead of becoming invalid.
+     * @returns Always true.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    canAppendMore(_size: number): Promise<boolean>;
+    /**
+     * Gets a copy of the buffer containing only the bytes written to the buffer.
+     * @returns An ArrayBuffer containing only the written data.
+     */
+    getBufferCopy(): ArrayBuffer;
+}

package/esm/serialization/buffers/in_memory_buffer.js

@@ -0,0 +1,206 @@
+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 _InMemoryWritableBuffer_offset, _InMemoryWritableBuffer_initialOffset;
+/**
+ * Shared strict in-memory buffer base with common functionality.
+ */
+export class InMemoryBufferBase {
+    /**
+     * Constructs an InMemoryBufferBase with the given ArrayBuffer.
+     * @param buf The ArrayBuffer to create the view from.
+     */
+    constructor(buf) {
+        /** The underlying Uint8Array view of the buffer. */
+        Object.defineProperty(this, "view", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.view = new Uint8Array(buf);
+    }
+    /**
+     * Returns the length of the buffer in bytes.
+     * @returns The length of the buffer.
+     */
+    // deno-lint-ignore require-await
+    async length() {
+        return this.view.length;
+    }
+}
+/**
+ * Strict read-only in-memory buffer for serialization reads.
+ * Throws errors on all out-of-bounds operations.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Random access: Supports reading at arbitrary byte offsets.
+ * - Strict bounds checking: Operations that exceed buffer bounds throw RangeError.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new StrictInMemoryReadableBuffer(arrayBuffer);
+ *
+ * // Read some data
+ * const data = await buffer.read(0, 4); // Returns Uint8Array of 4 bytes
+ *
+ * // This will throw:
+ * await buffer.read(1020, 10); // RangeError: Operation exceeds buffer bounds
+ * ```
+ */
+export class InMemoryReadableBuffer extends InMemoryBufferBase {
+    /**
+     * Checks if the offset and size are within buffer bounds.
+     * @param offset The starting offset.
+     * @param size The number of bytes to check.
+     */
+    checkBounds(offset, size) {
+        if (offset < 0 || size < 0) {
+            throw new RangeError(`Offset and size must be non-negative. Got offset=${offset}, size=${size}`);
+        }
+        if (offset + size > this.view.length) {
+            throw new RangeError(`Operation exceeds buffer bounds. offset=${offset}, size=${size}, bufferLength=${this.view.length}`);
+        }
+    }
+    /**
+     * Reads a portion of the buffer.
+     * @param offset The starting offset.
+     * @param size The number of bytes to read.
+     * @returns A Uint8Array containing the read bytes.
+     */
+    // deno-lint-ignore require-await
+    async read(offset, size) {
+        this.checkBounds(offset, size);
+        return this.view.slice(offset, offset + size);
+    }
+    /**
+     * Checks if more data can be read starting at the given offset.
+     * @param offset The byte offset to check.
+     * @returns True if at least one byte can be read from the offset.
+     */
+    // deno-lint-ignore require-await
+    async canReadMore(offset) {
+        try {
+            this.checkBounds(offset, 1);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Strict write-only in-memory buffer for serialization writes.
+ * Throws errors when attempting to write beyond buffer bounds.
+ *
+ * Key features:
+ * - Fixed size: The buffer size is determined at construction and cannot be resized.
+ * - Sequential writes: Maintains an internal offset that advances with each write.
+ * - Strict bounds checking: Throws RangeError when write would exceed buffer capacity.
+ * - Efficient: Uses Uint8Array for fast byte-level operations.
+ *
+ * @example
+ * ```typescript
+ * const arrayBuffer = new ArrayBuffer(1024);
+ * const buffer = new StrictInMemoryWritableBuffer(arrayBuffer);
+ *
+ * // Write some data
+ * await buffer.appendBytes(new Uint8Array([1, 2, 3, 4]));
+ *
+ * // This will throw if buffer is full:
+ * await buffer.appendBytes(new Uint8Array(2000)); // RangeError: Write operation exceeds buffer bounds
+ * ```
+ */
+export class InMemoryWritableBuffer extends InMemoryBufferBase {
+    /**
+     * Creates a new writable buffer with the specified ArrayBuffer and initial offset.
+     * @param buf The underlying ArrayBuffer to write to.
+     * @param offset The starting offset within the buffer (default: 0).
+     */
+    constructor(buf, offset = 0) {
+        super(buf);
+        _InMemoryWritableBuffer_offset.set(this, void 0);
+        _InMemoryWritableBuffer_initialOffset.set(this, void 0);
+        if (offset < 0 || offset > this.view.length) {
+            throw new RangeError(`Initial offset must be within buffer bounds. Got offset=${offset}, bufferLength=${this.view.length}`);
+        }
+        __classPrivateFieldSet(this, _InMemoryWritableBuffer_initialOffset, offset, "f");
+        __classPrivateFieldSet(this, _InMemoryWritableBuffer_offset, offset, "f");
+    }
+    /**
+     * Checks if writing the given data at the specified offset would exceed buffer bounds.
+     * Throws a RangeError if the operation would exceed bounds.
+     * @param offset The offset to write at.
+     * @param data The data to write.
+     */
+    checkWriteBounds(offset, data) {
+        if (offset < 0) {
+            throw new RangeError(`Offset must be non-negative. Got offset=${offset}`);
+        }
+        if (offset + data.length > this.view.length) {
+            throw new RangeError(`Write operation exceeds buffer bounds. offset=${offset}, dataSize=${data.length}, bufferLength=${this.view.length}`);
+        }
+    }
+    /**
+     * Appends the given bytes to the buffer at the current offset and advances the offset.
+     * @param data The bytes to append.
+     */
+    // deno-lint-ignore require-await
+    async appendBytes(data) {
+        this.checkWriteBounds(__classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f"), data);
+        if (data.length === 0) {
+            return;
+        }
+        this.view.set(data, __classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f"));
+        __classPrivateFieldSet(this, _InMemoryWritableBuffer_offset, __classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f") + data.length, "f");
+    }
+    /**
+     * Checks if the buffer is in a valid state.
+     * Always returns true as this buffer throws on overflow instead of becoming invalid.
+     * @returns Always true.
+     */
+    // deno-lint-ignore require-await
+    async isValid() {
+        return true; // Always valid since we throw on overflow instead of marking as invalid
+    }
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    async canAppendMore(_size) {
+        return await this.isValid();
+    }
+    /**
+     * @internal Test-only function to get the current write offset position.
+     */
+    _testOnlyOffset() {
+        return __classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f");
+    }
+    /**
+     * @internal Test-only function to get the remaining space in the buffer.
+     */
+    _testOnlyRemaining() {
+        return this.view.length - __classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f");
+    }
+    /**
+     * Gets a copy of the buffer containing only the bytes written to the buffer.
+     * @returns An ArrayBuffer containing only the written data.
+     */
+    getBufferCopy() {
+        const sliced = this.view.slice(__classPrivateFieldGet(this, _InMemoryWritableBuffer_initialOffset, "f"), __classPrivateFieldGet(this, _InMemoryWritableBuffer_offset, "f"));
+        return sliced.buffer.slice(sliced.byteOffset, sliced.byteOffset + sliced.length);
+    }
+}
+_InMemoryWritableBuffer_offset = new WeakMap(), _InMemoryWritableBuffer_initialOffset = new WeakMap();

package/esm/serialization/clamp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clamps a requested length for a DataView based on its byte length and an offset.
+ * Ensures the returned length does not exceed the available bytes in the view from the offset.
+ *
+ * @param view The DataView to clamp the length for.
+ * @param offset The starting offset within the DataView.
+ * @param length The requested length.
+ * @returns The clamped length.
+ */
+export declare function clampLengthForView(view: DataView, offset: number, length: number): number;

package/esm/serialization/clamp.js

@@ -0,0 +1,19 @@
+/**
+ * Clamps a requested length for a DataView based on its byte length and an offset.
+ * Ensures the returned length does not exceed the available bytes in the view from the offset.
+ *
+ * @param view The DataView to clamp the length for.
+ * @param offset The starting offset within the DataView.
+ * @param length The requested length.
+ * @returns The clamped length.
+ */
+export function clampLengthForView(view, offset, length) {
+    if (offset >= view.byteLength) {
+        return 0;
+    }
+    const available = view.byteLength - offset;
+    if (length <= 0) {
+        return 0;
+    }
+    return length > available ? available : length;
+}

package/esm/serialization/compare_bytes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compares two Uint8Array objects.
+ * Returns a negative value if a is less than b, a positive value if a is greater than b,
+ * and 0 if they are equal.
+ * @param a The first Uint8Array to compare.
+ * @param b The second Uint8Array to compare.
+ * @returns A negative, positive, or zero number indicating the comparison result.
+ */
+export declare function compareUint8Arrays(a: Uint8Array, b: Uint8Array): number;

package/esm/serialization/compare_bytes.js

@@ -0,0 +1,45 @@
+import { clampLengthForView } from "./clamp.js";
+/**
+ * Compares two byte ranges from DataView objects.
+ * Returns a negative value if viewA is less than viewB, a positive value if viewA is greater than viewB,
+ * and 0 if they are equal.
+ * @param viewA The first DataView to compare.
+ * @param offsetA The starting offset in viewA.
+ * @param lengthA The length of the byte range in viewA.
+ * @param viewB The second DataView to compare.
+ * @param offsetB The starting offset in viewB.
+ * @param lengthB The length of the byte range in viewB.
+ * @returns A negative, positive, or zero number indicating the comparison result.
+ * @internal
+ */
+export function _compareByteRanges(viewA, offsetA, lengthA, viewB, offsetB, lengthB) {
+    const safeOffsetA = offsetA >= 0 ? offsetA : 0;
+    const safeOffsetB = offsetB >= 0 ? offsetB : 0;
+    const clampedLengthA = clampLengthForView(viewA, safeOffsetA, lengthA);
+    const clampedLengthB = clampLengthForView(viewB, safeOffsetB, lengthB);
+    const len = Math.min(clampedLengthA, clampedLengthB);
+    for (let i = 0; i < len; i++) {
+        const diff = viewA.getUint8(safeOffsetA + i) -
+            viewB.getUint8(safeOffsetB + i);
+        if (diff !== 0) {
+            return diff < 0 ? -1 : 1;
+        }
+    }
+    if (clampedLengthA === clampedLengthB) {
+        return 0;
+    }
+    return clampedLengthA < clampedLengthB ? -1 : 1;
+}
+/**
+ * Compares two Uint8Array objects.
+ * Returns a negative value if a is less than b, a positive value if a is greater than b,
+ * and 0 if they are equal.
+ * @param a The first Uint8Array to compare.
+ * @param b The second Uint8Array to compare.
+ * @returns A negative, positive, or zero number indicating the comparison result.
+ */
+export function compareUint8Arrays(a, b) {
+    const viewA = new DataView(a.buffer, a.byteOffset, a.byteLength);
+    const viewB = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    return _compareByteRanges(viewA, 0, a.length, viewB, 0, b.length);
+}

package/esm/serialization/conversion.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a bigint to a number, throwing a RangeError if the bigint is outside the safe integer range.
+ * @param value The bigint to convert.
+ * @param context A string describing the context of the conversion, used in the error message if an error occurs.
+ * @returns The converted number.
+ * @throws {RangeError} if the bigint is outside the safe integer range.
+ */
+export declare function bigIntToSafeNumber(value: bigint, context: string): number;

package/esm/serialization/conversion.js

@@ -0,0 +1,15 @@
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+ * Converts a bigint to a number, throwing a RangeError if the bigint is outside the safe integer range.
+ * @param value The bigint to convert.
+ * @param context A string describing the context of the conversion, used in the error message if an error occurs.
+ * @returns The converted number.
+ * @throws {RangeError} if the bigint is outside the safe integer range.
+ */
+export function bigIntToSafeNumber(value, context) {
+    if (value > MAX_SAFE_INTEGER_BIGINT || value < MIN_SAFE_INTEGER_BIGINT) {
+        throw new RangeError(`${context} is outside the safe integer range.`);
+    }
+    return Number(value);
+}

package/esm/serialization/decoders/decoder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Interface for custom Avro codec decoders.
+ */
+export interface Decoder {
+    /**
+     * Decompresses the given data using the codec's algorithm.
+     *
+     * @param compressedData The compressed data from the Avro file block
+     * @returns Promise that resolves to the decompressed data
+     */
+    decode(compressedData: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Registry of codec name to decoder implementation.
+ */
+export type DecoderRegistry = Record<string, Decoder>;

package/esm/serialization/decoders/decoder.js

@@ -0,0 +1 @@
+export {};

package/esm/serialization/decoders/deflate_decoder.d.ts

@@ -0,0 +1,15 @@
+import type { Decoder } from "./decoder.js";
+/**
+ * Built-in deflate decoder using modern web standards.
+ *
+ * Uses the 'deflate-raw' format which corresponds to RFC 1951 as specified
+ * in the Avro specification (no zlib header or checksum).
+ */
+export declare class DeflateDecoder implements Decoder {
+    /**
+     * Decodes data that was compressed with the deflate algorithm.
+     * @param compressedData The compressed data.
+     * @returns The decompressed data.
+     */
+    decode(compressedData: Uint8Array): Promise<Uint8Array>;
+}

package/esm/serialization/decoders/deflate_decoder.js

@@ -0,0 +1,26 @@
+/**
+ * Built-in deflate decoder using modern web standards.
+ *
+ * Uses the 'deflate-raw' format which corresponds to RFC 1951 as specified
+ * in the Avro specification (no zlib header or checksum).
+ */
+export class DeflateDecoder {
+    /**
+     * Decodes data that was compressed with the deflate algorithm.
+     * @param compressedData The compressed data.
+     * @returns The decompressed data.
+     */
+    async decode(compressedData) {
+        if (typeof DecompressionStream === "undefined") {
+            throw new Error("Deflate codec not supported in this environment. DecompressionStream API required.");
+        }
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(compressedData);
+                controller.close();
+            },
+        });
+        const decompressed = await new Response(stream.pipeThrough(new DecompressionStream("deflate-raw"))).arrayBuffer();
+        return new Uint8Array(decompressed);
+    }
+}

package/esm/serialization/decoders/null_decoder.d.ts

@@ -0,0 +1,12 @@
+import type { Decoder } from "./decoder.js";
+/**
+ * Built-in null decoder (no compression).
+ */
+export declare class NullDecoder implements Decoder {
+    /**
+     * Decodes data by passing it through unchanged.
+     * @param compressedData The data to decode.
+     * @returns The decoded (uncompressed) data.
+     */
+    decode(compressedData: Uint8Array): Promise<Uint8Array>;
+}

package/esm/serialization/decoders/null_decoder.js

@@ -0,0 +1,13 @@
+/**
+ * Built-in null decoder (no compression).
+ */
+export class NullDecoder {
+    /**
+     * Decodes data by passing it through unchanged.
+     * @param compressedData The data to decode.
+     * @returns The decoded (uncompressed) data.
+     */
+    decode(compressedData) {
+        return Promise.resolve(compressedData);
+    }
+}

package/esm/serialization/encoders/deflate_encoder.d.ts

@@ -0,0 +1,15 @@
+import type { Encoder } from "./encoder.js";
+/**
+ * Built-in deflate encoder using modern web standards.
+ *
+ * Uses the 'deflate-raw' format which corresponds to RFC 1951 as specified
+ * in the Avro specification (no zlib header or checksum).
+ */
+export declare class DeflateEncoder implements Encoder {
+    /**
+     * Encodes data using the deflate algorithm.
+     * @param uncompressedData The data to compress.
+     * @returns The compressed data.
+     */
+    encode(uncompressedData: Uint8Array): Promise<Uint8Array>;
+}

package/esm/serialization/encoders/deflate_encoder.js

@@ -0,0 +1,26 @@
+/**
+ * Built-in deflate encoder using modern web standards.
+ *
+ * Uses the 'deflate-raw' format which corresponds to RFC 1951 as specified
+ * in the Avro specification (no zlib header or checksum).
+ */
+export class DeflateEncoder {
+    /**
+     * Encodes data using the deflate algorithm.
+     * @param uncompressedData The data to compress.
+     * @returns The compressed data.
+     */
+    async encode(uncompressedData) {
+        if (typeof CompressionStream === "undefined") {
+            throw new Error("Deflate codec not supported in this environment. CompressionStream API required.");
+        }
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(uncompressedData);
+                controller.close();
+            },
+        });
+        const compressed = await new Response(stream.pipeThrough(new CompressionStream("deflate-raw"))).arrayBuffer();
+        return new Uint8Array(compressed);
+    }
+}

package/esm/serialization/encoders/encoder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Interface for custom Avro codec encoders.
+ */
+export interface Encoder {
+    /**
+     * Compresses the given data using the codec's algorithm.
+     *
+     * @param uncompressedData The raw block data that should be compressed
+     * @returns Promise that resolves to the compressed data
+     */
+    encode(uncompressedData: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Registry of codec name to encoder implementation.
+ */
+export type EncoderRegistry = Record<string, Encoder>;

package/esm/serialization/encoders/encoder.js

@@ -0,0 +1 @@
+export {};

package/esm/serialization/encoders/null_encoder.d.ts

@@ -0,0 +1,12 @@
+import type { Encoder } from "./encoder.js";
+/**
+ * Built-in null encoder (no compression).
+ */
+export declare class NullEncoder implements Encoder {
+    /**
+     * Encodes data by passing it through unchanged.
+     * @param uncompressedData The data to encode.
+     * @returns The encoded (uncompressed) data.
+     */
+    encode(uncompressedData: Uint8Array): Promise<Uint8Array>;
+}

package/esm/serialization/encoders/null_encoder.js

@@ -0,0 +1,13 @@
+/**
+ * Built-in null encoder (no compression).
+ */
+export class NullEncoder {
+    /**
+     * Encodes data by passing it through unchanged.
+     * @param uncompressedData The data to encode.
+     * @returns The encoded (uncompressed) data.
+     */
+    encode(uncompressedData) {
+        return Promise.resolve(uncompressedData);
+    }
+}

package/esm/serialization/manipulate_bytes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Inverts the bits of the bytes in a Uint8Array up to a specified length.
+ * @param arr The Uint8Array to invert.
+ * @param len The number of bytes to invert from the beginning of the array.
+ */
+export declare function invert(arr: Uint8Array, len: number): void;

package/esm/serialization/manipulate_bytes.js

@@ -0,0 +1,13 @@
+/**
+ * Inverts the bits of the bytes in a Uint8Array up to a specified length.
+ * @param arr The Uint8Array to invert.
+ * @param len The number of bytes to invert from the beginning of the array.
+ */
+export function invert(arr, len) {
+    const view = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    let remaining = Math.min(Math.max(len, 0), arr.length);
+    while (remaining--) {
+        const current = view.getUint8(remaining);
+        view.setUint8(remaining, (~current) & 0xff);
+    }
+}

package/esm/serialization/read_uint_le.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Reads an unsigned little-endian integer from a buffer at a specified offset and byte length.
+ */
+export declare function readUIntLE(view: DataView, offset: number, byteLength: number): number;

package/esm/serialization/read_uint_le.js

@@ -0,0 +1,14 @@
+/**
+ * Reads an unsigned little-endian integer from a buffer at a specified offset and byte length.
+ */
+export function readUIntLE(view, offset, byteLength) {
+    let value = 0;
+    for (let i = 0; i < byteLength; i++) {
+        const index = offset + i;
+        if (index >= view.byteLength) {
+            break;
+        }
+        value |= view.getUint8(index) << (8 * i);
+    }
+    return value >>> 0;
+}