@sachitv/avro-typescript 0.4.0

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/esm/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/avro_reader.d.ts

@@ -0,0 +1,156 @@
+import type { IReadableBuffer } from "./serialization/buffers/buffer.js";
+import { type DecoderRegistry, type ParsedAvroHeader } from "./serialization/avro_file_parser.js";
+export type { DecoderRegistry, ParsedAvroHeader };
+/**
+ * Options for reading Avro data, including schema resolution, custom decoders, and close hooks.
+ */
+export interface ReaderSchemaOptions {
+    /** Optional reader schema used to resolve records written with a different schema. */
+    readerSchema?: unknown;
+    /** Custom codec decoders. Cannot include "null" or "deflate" as they are built-in. */
+    decoders?: DecoderRegistry;
+    /** Optional hook to call when closing the reader. */
+    closeHook?: () => Promise<void> | void;
+}
+/**
+ * Options for URL-based reading.
+ */
+export interface FromUrlOptions extends ReaderSchemaOptions {
+    /** Cache size for stream buffering in bytes (default: 0 = unlimited) */
+    cacheSize?: number;
+    /** Custom fetch init options (optional) */
+    fetchInit?: RequestInit;
+}
+/**
+ * Options for stream-based reading.
+ */
+export interface FromStreamOptions extends ReaderSchemaOptions {
+    /** Cache size for stream buffering in bytes (default: 0 = unlimited) */
+    cacheSize?: number;
+    /** Optional hook to call when closing the reader. */
+    closeHook?: () => Promise<void> | void;
+}
+/**
+ * Options for buffer- or blob-based reading.
+ */
+export type FromBufferOptions = ReaderSchemaOptions;
+/**
+ * Interface for Avro reader instances that provide access to header and records.
+ */
+export interface AvroReaderInstance {
+    /**
+     * Gets the parsed Avro file header with proper typing.
+     *
+     * @returns Promise that resolves to the parsed header information.
+     */
+    getHeader(): Promise<ParsedAvroHeader>;
+    /**
+     * Closes the reader and releases any resources.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns an async iterator over the records in the Avro file.
+     */
+    iterRecords(): AsyncIterableIterator<unknown>;
+}
+/**
+ * Public API for reading Avro object container files from various sources.
+ *
+ * This class provides static factory methods for creating Avro readers from
+ * different data sources while maintaining a consistent interface.
+ *
+ * @example
+ * ```typescript
+ * const readerSchema = {
+ *   type: "record",
+ *   name: "test.Weather",
+ *   fields: [
+ *     { name: "station", type: "string" },
+ *     { name: "temp", type: "int" },
+ *   ],
+ * };
+ *
+ * // Read from a buffer (for example when the Avro file is already in memory)
+ * const bufferReader = AvroReader.fromBuffer(buffer, { readerSchema });
+ * for await (const record of bufferReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a blob (e.g., file input)
+ * const blobReader = AvroReader.fromBlob(blob, { readerSchema });
+ * for await (const record of blobReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a URL with unlimited buffering
+ * const urlReader = await AvroReader.fromUrl("data.avro", { readerSchema });
+ * for await (const record of urlReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a URL with limited memory usage
+ * const cachedUrlReader = await AvroReader.fromUrl("data.avro", {
+ *   cacheSize: 1024 * 1024,
+ *   readerSchema,
+ * });
+ * for await (const record of cachedUrlReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a stream with optional caching
+ * const streamReader = AvroReader.fromStream(stream, {
+ *   cacheSize: 1024,
+ *   readerSchema,
+ * });
+ * for await (const record of streamReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ * ```
+ */
+export declare class AvroReader {
+    /**
+     * Creates an Avro reader from any readable buffer.
+     *
+     * This is the core method that all other factory methods delegate to.
+     *
+     * @param buffer The readable buffer containing Avro data.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromBuffer(buffer: IReadableBuffer, options?: FromBufferOptions): AvroReaderInstance;
+    /**
+     * Creates an Avro reader from a Blob.
+     *
+     * Uses BlobReadableBuffer for efficient random access without loading
+     * the entire blob into memory.
+     *
+     * @param blob The blob containing Avro data.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromBlob(blob: Blob, options?: FromBufferOptions): AvroReaderInstance;
+    /**
+     * Creates an Avro reader from a URL.
+     *
+     * Fetches the URL and creates a stream-based reader. The caching strategy
+     * depends on the cacheSize option:
+     * - cacheSize = 0 (default): Uses ForwardOnlyStreamReadableBufferAdapter for unlimited buffering
+     * - cacheSize > 0: Uses FixedSizeStreamReadableBufferAdapter with the specified window size
+     *
+     * @param url The URL to fetch Avro data from.
+     * @param options Configuration options for URL reading.
+     * @returns Promise that resolves to AvroReaderInstance providing access to header and records.
+     */
+    static fromUrl(url: string, options?: FromUrlOptions): Promise<AvroReaderInstance>;
+    /**
+     * Creates an Avro reader from a ReadableStream.
+     *
+     * Creates a stream-based reader with configurable caching. The caching strategy
+     * depends on the cacheSize option:
+     * - cacheSize = 0 (default): Uses ForwardOnlyStreamReadableBufferAdapter for unlimited buffering
+     * - cacheSize > 0: Uses FixedSizeStreamReadableBufferAdapter with the specified window size
+     *
+     * @param stream The readable stream containing Avro data.
+     * @param options Configuration options for stream reading.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromStream(stream: ReadableStream, options?: FromStreamOptions): AvroReaderInstance;
+}

package/esm/avro_reader.js

@@ -0,0 +1,201 @@
+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 _AvroReaderInstanceImpl_parser, _AvroReaderInstanceImpl_recordIterator, _AvroReaderInstanceImpl_closeHook, _AvroReaderInstanceImpl_closed;
+import { BlobReadableBuffer } from "./serialization/buffers/blob_readable_buffer.js";
+import { StreamReadableBuffer } from "./serialization/streams/stream_readable_buffer.js";
+import { FixedSizeStreamReadableBufferAdapter } from "./serialization/streams/fixed_size_stream_readable_buffer_adapter.js";
+import { ForwardOnlyStreamReadableBufferAdapter } from "./serialization/streams/forward_only_stream_readable_buffer_adapter.js";
+import { AvroFileParser, } from "./serialization/avro_file_parser.js";
+/**
+ * Default cache size: 0 (unlimited, uses forward-only adapter)
+ */
+const DEFAULT_CACHE_SIZE = 0;
+/**
+ * Internal implementation of AvroReaderInstance that wraps AvroFileParser.
+ */
+class AvroReaderInstanceImpl {
+    constructor(parser, closeHook) {
+        _AvroReaderInstanceImpl_parser.set(this, void 0);
+        _AvroReaderInstanceImpl_recordIterator.set(this, void 0);
+        _AvroReaderInstanceImpl_closeHook.set(this, void 0);
+        _AvroReaderInstanceImpl_closed.set(this, false);
+        __classPrivateFieldSet(this, _AvroReaderInstanceImpl_parser, parser, "f");
+        __classPrivateFieldSet(this, _AvroReaderInstanceImpl_recordIterator, parser.iterRecords(), "f");
+        __classPrivateFieldSet(this, _AvroReaderInstanceImpl_closeHook, closeHook, "f");
+    }
+    async getHeader() {
+        return await __classPrivateFieldGet(this, _AvroReaderInstanceImpl_parser, "f").getHeader();
+    }
+    iterRecords() {
+        return __classPrivateFieldGet(this, _AvroReaderInstanceImpl_recordIterator, "f");
+    }
+    async close() {
+        if (__classPrivateFieldGet(this, _AvroReaderInstanceImpl_closed, "f")) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _AvroReaderInstanceImpl_closeHook, "f")) {
+            try {
+                await __classPrivateFieldGet(this, _AvroReaderInstanceImpl_closeHook, "f").call(this);
+            }
+            catch {
+                // Ignore close hook errors
+            }
+            __classPrivateFieldSet(this, _AvroReaderInstanceImpl_closeHook, undefined, "f");
+        }
+        __classPrivateFieldSet(this, _AvroReaderInstanceImpl_closed, true, "f");
+    }
+}
+_AvroReaderInstanceImpl_parser = new WeakMap(), _AvroReaderInstanceImpl_recordIterator = new WeakMap(), _AvroReaderInstanceImpl_closeHook = new WeakMap(), _AvroReaderInstanceImpl_closed = new WeakMap();
+/**
+ * Public API for reading Avro object container files from various sources.
+ *
+ * This class provides static factory methods for creating Avro readers from
+ * different data sources while maintaining a consistent interface.
+ *
+ * @example
+ * ```typescript
+ * const readerSchema = {
+ *   type: "record",
+ *   name: "test.Weather",
+ *   fields: [
+ *     { name: "station", type: "string" },
+ *     { name: "temp", type: "int" },
+ *   ],
+ * };
+ *
+ * // Read from a buffer (for example when the Avro file is already in memory)
+ * const bufferReader = AvroReader.fromBuffer(buffer, { readerSchema });
+ * for await (const record of bufferReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a blob (e.g., file input)
+ * const blobReader = AvroReader.fromBlob(blob, { readerSchema });
+ * for await (const record of blobReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a URL with unlimited buffering
+ * const urlReader = await AvroReader.fromUrl("data.avro", { readerSchema });
+ * for await (const record of urlReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a URL with limited memory usage
+ * const cachedUrlReader = await AvroReader.fromUrl("data.avro", {
+ *   cacheSize: 1024 * 1024,
+ *   readerSchema,
+ * });
+ * for await (const record of cachedUrlReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ *
+ * // Read from a stream with optional caching
+ * const streamReader = AvroReader.fromStream(stream, {
+ *   cacheSize: 1024,
+ *   readerSchema,
+ * });
+ * for await (const record of streamReader.iterRecords()) {
+ *   console.log(record);
+ * }
+ * ```
+ */
+export class AvroReader {
+    /**
+     * Creates an Avro reader from any readable buffer.
+     *
+     * This is the core method that all other factory methods delegate to.
+     *
+     * @param buffer The readable buffer containing Avro data.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromBuffer(buffer, options) {
+        const parser = new AvroFileParser(buffer, {
+            readerSchema: options?.readerSchema,
+            decoders: options?.decoders,
+        });
+        return new AvroReaderInstanceImpl(parser, options?.closeHook);
+    }
+    /**
+     * Creates an Avro reader from a Blob.
+     *
+     * Uses BlobReadableBuffer for efficient random access without loading
+     * the entire blob into memory.
+     *
+     * @param blob The blob containing Avro data.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromBlob(blob, options) {
+        const buffer = new BlobReadableBuffer(blob);
+        return AvroReader.fromBuffer(buffer, options);
+    }
+    /**
+     * Creates an Avro reader from a URL.
+     *
+     * Fetches the URL and creates a stream-based reader. The caching strategy
+     * depends on the cacheSize option:
+     * - cacheSize = 0 (default): Uses ForwardOnlyStreamReadableBufferAdapter for unlimited buffering
+     * - cacheSize > 0: Uses FixedSizeStreamReadableBufferAdapter with the specified window size
+     *
+     * @param url The URL to fetch Avro data from.
+     * @param options Configuration options for URL reading.
+     * @returns Promise that resolves to AvroReaderInstance providing access to header and records.
+     */
+    static async fromUrl(url, options) {
+        const response = await fetch(url, options?.fetchInit);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error(`Response body is null for ${url}`);
+        }
+        const stream = response.body;
+        return AvroReader.fromStream(stream, {
+            cacheSize: options?.cacheSize,
+            readerSchema: options?.readerSchema,
+            decoders: options?.decoders,
+            closeHook: async () => {
+                await stream.cancel();
+            },
+        });
+    }
+    /**
+     * Creates an Avro reader from a ReadableStream.
+     *
+     * Creates a stream-based reader with configurable caching. The caching strategy
+     * depends on the cacheSize option:
+     * - cacheSize = 0 (default): Uses ForwardOnlyStreamReadableBufferAdapter for unlimited buffering
+     * - cacheSize > 0: Uses FixedSizeStreamReadableBufferAdapter with the specified window size
+     *
+     * @param stream The readable stream containing Avro data.
+     * @param options Configuration options for stream reading.
+     * @returns AvroReaderInstance that provides access to header and records.
+     */
+    static fromStream(stream, options) {
+        const cacheSize = options?.cacheSize ?? DEFAULT_CACHE_SIZE;
+        const streamBuffer = new StreamReadableBuffer(stream);
+        let buffer;
+        if (cacheSize > 0) {
+            // Use fixed-size adapter for limited memory usage
+            buffer = new FixedSizeStreamReadableBufferAdapter(streamBuffer, cacheSize);
+        }
+        else {
+            // Use forward-only adapter for unlimited buffering
+            buffer = new ForwardOnlyStreamReadableBufferAdapter(streamBuffer);
+        }
+        return AvroReader.fromBuffer(buffer, {
+            readerSchema: options?.readerSchema,
+            decoders: options?.decoders,
+            closeHook: options?.closeHook,
+        });
+    }
+}

package/esm/avro_writer.d.ts

@@ -0,0 +1,75 @@
+import type { IWritableBuffer } from "./serialization/buffers/buffer.js";
+import { type AvroWriterOptions } from "./serialization/avro_file_writer.js";
+export type { AvroWriterOptions } from "./serialization/avro_file_writer.js";
+export type { EncoderRegistry } from "./serialization/encoders/encoder.js";
+/**
+ * Interface exposed by Avro writer instances.
+ */
+export interface AvroWriterInstance {
+    /**
+     * Appends a single record to the output.
+     */
+    append(record: unknown): Promise<void>;
+    /**
+     * Manually flush pending records to a block.
+     * This can be called to force writing of accumulated records before the block size threshold is reached.
+     */
+    flushBlock(): Promise<void>;
+    /**
+     * Flushes pending data and closes the writer.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Public API for writing Avro object container files to various destinations.
+ *
+ * The writer mirrors the structure of {@link AvroReader}, providing factory
+ * helpers that adapt different buffer and stream implementations to the
+ * internal {@link AvroFileWriter}.
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: "record",
+ *   name: "example.Event",
+ *   fields: [
+ *     { name: "id", type: "int" },
+ *     { name: "message", type: "string" },
+ *   ],
+ * };
+ *
+ * // Write to an in-memory buffer
+ * const memoryBuffer = new InMemoryWritableBuffer(new ArrayBuffer(1024));
+ * const bufferWriter = AvroWriter.toBuffer(memoryBuffer, { schema });
+ * await bufferWriter.append({ id: 1, message: "hello" });
+ * await bufferWriter.close();
+ *
+ * // Write to a WritableStream (e.g., network, file)
+ * const stream = new WritableStream<Uint8Array>({
+ *   async write(chunk) {
+ *     await someSink.write(chunk);
+ *   },
+ * });
+ * const streamWriter = AvroWriter.toStream(stream, { schema, codec: "deflate" });
+ * for (const record of records) {
+ *   await streamWriter.append(record);
+ * }
+ * await streamWriter.close();
+ * ```
+ */
+export declare class AvroWriter {
+    /**
+     * Creates an Avro writer from any {@link IWritableBuffer}.
+     *
+     * @param buffer Writable buffer that will receive the Avro container output.
+     * @param options Writer configuration including schema, codec, metadata, etc.
+     */
+    static toBuffer(buffer: IWritableBuffer, options: AvroWriterOptions): AvroWriterInstance;
+    /**
+     * Creates an Avro writer that emits data to a {@link WritableStream}.
+     *
+     * @param stream Writable stream that will receive chunked Avro data.
+     * @param options Writer configuration including schema, codec, metadata, etc.
+     */
+    static toStream(stream: WritableStream<Uint8Array>, options: AvroWriterOptions): AvroWriterInstance;
+}

package/esm/avro_writer.js

@@ -0,0 +1,105 @@
+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 _AvroWriterInstanceImpl_writer, _AvroWriterInstanceImpl_closeHook, _AvroWriterInstanceImpl_closed;
+import { AvroFileWriter, } from "./serialization/avro_file_writer.js";
+import { StreamWritableBuffer } from "./serialization/streams/stream_writable_buffer.js";
+import { StreamWritableBufferAdapter } from "./serialization/streams/stream_writable_buffer_adapter.js";
+class AvroWriterInstanceImpl {
+    constructor(writer, closeHook) {
+        _AvroWriterInstanceImpl_writer.set(this, void 0);
+        _AvroWriterInstanceImpl_closeHook.set(this, void 0);
+        _AvroWriterInstanceImpl_closed.set(this, false);
+        __classPrivateFieldSet(this, _AvroWriterInstanceImpl_writer, writer, "f");
+        __classPrivateFieldSet(this, _AvroWriterInstanceImpl_closeHook, closeHook, "f");
+    }
+    async append(record) {
+        await __classPrivateFieldGet(this, _AvroWriterInstanceImpl_writer, "f").append(record);
+    }
+    async flushBlock() {
+        await __classPrivateFieldGet(this, _AvroWriterInstanceImpl_writer, "f").flushBlock();
+    }
+    async close() {
+        if (__classPrivateFieldGet(this, _AvroWriterInstanceImpl_closed, "f")) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _AvroWriterInstanceImpl_writer, "f").close();
+        if (__classPrivateFieldGet(this, _AvroWriterInstanceImpl_closeHook, "f")) {
+            await __classPrivateFieldGet(this, _AvroWriterInstanceImpl_closeHook, "f").call(this);
+            __classPrivateFieldSet(this, _AvroWriterInstanceImpl_closeHook, undefined, "f");
+        }
+        __classPrivateFieldSet(this, _AvroWriterInstanceImpl_closed, true, "f");
+    }
+}
+_AvroWriterInstanceImpl_writer = new WeakMap(), _AvroWriterInstanceImpl_closeHook = new WeakMap(), _AvroWriterInstanceImpl_closed = new WeakMap();
+/**
+ * Public API for writing Avro object container files to various destinations.
+ *
+ * The writer mirrors the structure of {@link AvroReader}, providing factory
+ * helpers that adapt different buffer and stream implementations to the
+ * internal {@link AvroFileWriter}.
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: "record",
+ *   name: "example.Event",
+ *   fields: [
+ *     { name: "id", type: "int" },
+ *     { name: "message", type: "string" },
+ *   ],
+ * };
+ *
+ * // Write to an in-memory buffer
+ * const memoryBuffer = new InMemoryWritableBuffer(new ArrayBuffer(1024));
+ * const bufferWriter = AvroWriter.toBuffer(memoryBuffer, { schema });
+ * await bufferWriter.append({ id: 1, message: "hello" });
+ * await bufferWriter.close();
+ *
+ * // Write to a WritableStream (e.g., network, file)
+ * const stream = new WritableStream<Uint8Array>({
+ *   async write(chunk) {
+ *     await someSink.write(chunk);
+ *   },
+ * });
+ * const streamWriter = AvroWriter.toStream(stream, { schema, codec: "deflate" });
+ * for (const record of records) {
+ *   await streamWriter.append(record);
+ * }
+ * await streamWriter.close();
+ * ```
+ */
+export class AvroWriter {
+    /**
+     * Creates an Avro writer from any {@link IWritableBuffer}.
+     *
+     * @param buffer Writable buffer that will receive the Avro container output.
+     * @param options Writer configuration including schema, codec, metadata, etc.
+     */
+    static toBuffer(buffer, options) {
+        const writer = new AvroFileWriter(buffer, options);
+        return new AvroWriterInstanceImpl(writer);
+    }
+    /**
+     * Creates an Avro writer that emits data to a {@link WritableStream}.
+     *
+     * @param stream Writable stream that will receive chunked Avro data.
+     * @param options Writer configuration including schema, codec, metadata, etc.
+     */
+    static toStream(stream, options) {
+        const streamBuffer = new StreamWritableBuffer(stream);
+        const adapter = new StreamWritableBufferAdapter(streamBuffer);
+        const writer = new AvroFileWriter(adapter, options);
+        return new AvroWriterInstanceImpl(writer, async () => {
+            await adapter.close();
+        });
+    }
+}

package/esm/internal/collections/array_utils.d.ts

@@ -0,0 +1,4 @@
+/** Concatenates an array of Uint8Arrays into a single Uint8Array. */
+export declare function concatUint8Arrays(parts: Uint8Array[]): Uint8Array;
+/** Converts an ArrayBuffer or Uint8Array to a Uint8Array. */
+export declare function toUint8Array(data: ArrayBuffer | Uint8Array): Uint8Array;

package/esm/internal/collections/array_utils.js

@@ -0,0 +1,18 @@
+/** Concatenates an array of Uint8Arrays into a single Uint8Array. */
+export function concatUint8Arrays(parts) {
+    if (parts.length === 0) {
+        return new Uint8Array(0);
+    }
+    const length = parts.reduce((sum, part) => sum + part.length, 0);
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+        result.set(part, offset);
+        offset += part.length;
+    }
+    return result;
+}
+/** Converts an ArrayBuffer or Uint8Array to a Uint8Array. */
+export function toUint8Array(data) {
+    return data instanceof Uint8Array ? data : new Uint8Array(data);
+}

package/esm/internal/collections/circular_buffer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A circular buffer implementation that maintains a rolling window of Uint8Array data.
+ * Uses copyWithin for efficient window sliding and provides memory-efficient random access.
+ */
+export declare class CircularBuffer {
+    #private;
+    /**
+     * Creates a new circular buffer with the specified capacity.
+     * @param capacity Maximum number of bytes the buffer can hold
+     * @throws RangeError if capacity is not positive
+     */
+    constructor(capacity: number);
+    /**
+     * Maximum capacity of the buffer in bytes.
+     */
+    capacity(): number;
+    /**
+     * Current number of bytes in the buffer.
+     */
+    length(): number;
+    /**
+     * Position in the overall data stream where the current window starts.
+     */
+    windowStart(): number;
+    /**
+     * Position in the overall data stream where the current window ends (exclusive).
+     */
+    windowEnd(): number;
+    /**
+     * Clears the buffer, resetting the window to empty.
+     */
+    clear(): void;
+    /**
+     * Adds data to the buffer, sliding the window if necessary.
+     * @param data Uint8Array to add
+     * @throws RangeError if data size exceeds buffer capacity
+     */
+    push(data: Uint8Array): void;
+    /**
+     * Retrieves a contiguous sequence of bytes from the buffer.
+     * @param start Start position relative to the overall data stream
+     * @param size Number of bytes to retrieve
+     * @returns Readonly view of the requested bytes (shallow copy, no allocation)
+     * @throws RangeError if start is before window start or size is negative
+     * @throws RangeError if requested range extends beyond window end
+     */
+    get(start: number, size: number): Readonly<Uint8Array>;
+}