@cj-tech-master/excelts 3.0.1-canary.20251230173853.c3c79fa → 3.1.0-canary.20260102041828.82ed571

package/dist/types/modules/stream/buffered-stream.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Buffered Stream
+ *
+ * A Duplex-like stream that manages internal buffering with chunk-based read/write operations.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "@stream/event-emitter";
+/**
+ * Represents a chunk of data with copy capabilities
+ */
+export interface DataChunk {
+    readonly length: number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * String chunk implementation
+ */
+export declare class StringChunk implements DataChunk {
+    private readonly _data;
+    private _buffer?;
+    constructor(data: string);
+    get length(): number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Uint8Array chunk implementation
+ */
+export declare class BufferChunk implements DataChunk {
+    private readonly _data;
+    constructor(data: Uint8Array);
+    get length(): number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+export interface BufferedStreamOptions {
+    /** Batch size for internal read-write buffers */
+    batchSize?: number;
+}
+/**
+ * Browser-compatible Buffered Stream with efficient chunk management
+ */
+export declare class BufferedStream extends EventEmitter {
+    private _chunks;
+    private _chunkReadIndex;
+    private _buffers;
+    private _bufferReadIndex;
+    private readonly _batchSize;
+    private _finished;
+    private _destroyed;
+    private _totalLength;
+    constructor(options?: BufferedStreamOptions);
+    /**
+     * Write data to the stream
+     */
+    write(chunk: Uint8Array | string): boolean;
+    /**
+     * Read data from the stream
+     */
+    read(size?: number): Uint8Array | null;
+    /**
+     * Signal end of writes
+     */
+    end(chunk?: Uint8Array | string): void;
+    /**
+     * Destroy the stream
+     */
+    destroy(error?: Error): void;
+    /**
+     * Get total buffered length
+     */
+    get bufferedLength(): number;
+    /**
+     * Get buffer of specified size from internal buffers
+     */
+    private _getBuffer;
+    /**
+     * Add chunk to internal buffers
+     */
+    private _addChunkToBuffers;
+    /**
+     * Get all buffered data as a single Uint8Array
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Check if stream is finished
+     */
+    get isFinished(): boolean;
+    /**
+     * Check if stream is destroyed
+     */
+    get destroyed(): boolean;
+}

package/dist/types/modules/stream/chunked-builder.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Chunked Builder (Browser Compatible)
+ *
+ * Browser-compatible version that uses Uint8Array instead of Buffer.
+ * This file provides the same API but works in browser environments.
+ */
+/**
+ * Options for ChunkedBuilder
+ */
+export interface ChunkedBuilderOptions {
+    /** Number of pieces to accumulate before consolidation */
+    chunkSize?: number;
+    /** Initial capacity hint */
+    initialCapacity?: number;
+}
+/**
+ * Efficient builder for accumulating and consolidating string chunks
+ * Browser-compatible version
+ */
+export declare class ChunkedBuilder {
+    protected _pieces: string[];
+    protected _chunks: string[];
+    protected readonly _chunkSize: number;
+    protected _totalLength: number;
+    constructor(options?: ChunkedBuilderOptions);
+    /**
+     * Add a piece to the builder
+     */
+    push(piece: string): void;
+    /**
+     * Add multiple pieces
+     */
+    pushAll(pieces: string[]): void;
+    /**
+     * Consolidate pieces into chunks
+     */
+    private _consolidate;
+    /**
+     * Get current cursor position (useful for tracking changes)
+     */
+    get cursor(): number;
+    /**
+     * Get total piece/chunk count
+     */
+    get length(): number;
+    /**
+     * Get total string length (character count)
+     */
+    get stringLength(): number;
+    /**
+     * Check if empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Clear all content
+     */
+    clear(): void;
+    /**
+     * Build final string
+     */
+    toString(): string;
+    /**
+     * Convert to Uint8Array (browser-compatible)
+     */
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Snapshot for rollback support
+ */
+export interface BuilderSnapshot {
+    piecesLength: number;
+    chunksLength: number;
+    totalLength: number;
+}
+/**
+ * Chunked builder with rollback/commit support
+ * Browser-compatible version
+ */
+export declare class TransactionalChunkedBuilder extends ChunkedBuilder {
+    private _snapshots;
+    /**
+     * Create a rollback point
+     */
+    snapshot(): BuilderSnapshot;
+    /**
+     * Commit the current snapshot (remove rollback point)
+     */
+    commit(): void;
+    /**
+     * Rollback to the last snapshot
+     */
+    rollback(): void;
+    /**
+     * Check if there are active snapshots
+     */
+    get hasSnapshots(): boolean;
+}

package/dist/types/modules/stream/event-emitter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Event Emitter
+ *
+ * Browser-compatible EventEmitter with a Node.js-like API surface.
+ * Kept lightweight and allocation-lean for hot paths.
+ */
+export type EventListener = (...args: any[]) => void;
+export declare class EventEmitter {
+    readonly __excelts_stream: true;
+    private _listeners;
+    private _maxListeners;
+    static defaultMaxListeners: number;
+    addListener(event: string | symbol, listener: EventListener): this;
+    private _listenerCount;
+    private _hasListeners;
+    on(event: string | symbol, listener: EventListener): this;
+    prependListener(event: string | symbol, listener: EventListener): this;
+    once(event: string | symbol, listener: EventListener): this;
+    prependOnceListener(event: string | symbol, listener: EventListener): this;
+    removeListener(event: string | symbol, listener: EventListener): this;
+    off(event: string | symbol, listener: EventListener): this;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    removeAllListeners(event?: string | symbol): this;
+    listenerCount(event: string | symbol): number;
+    listeners(event: string | symbol): EventListener[];
+    rawListeners(event: string | symbol): EventListener[];
+    eventNames(): (string | symbol)[];
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+}

package/dist/types/modules/stream/index.browser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stream Module (browser type surface)
+ *
+ * Mirrors [src/modules/stream/index.ts] but explicitly re-exports from
+ * ./streams.browser so we can enforce index export-surface parity.
+ */
+import type { ReadableStreamOptions, WritableStreamOptions, TransformStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, TransformCallback, FlushCallback, WriteCallback, DestroyCallback, IEventEmitter, IReadable, IWritable, ITransform, IDuplex, IPullStream, IBufferedStream, IPassThrough, ICollector, DataChunk, EventListener, PipelineSource, PipelineTransform, PipelineDestination, ReadWriteBufferOptions } from "@stream/types";
+export type { ReadableStreamOptions, WritableStreamOptions, TransformStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, TransformCallback, FlushCallback, WriteCallback, DestroyCallback, IEventEmitter, IReadable, IWritable, ITransform, IDuplex, IPullStream, IBufferedStream, IPassThrough, ICollector, DataChunk, EventListener, PipelineSource, PipelineTransform, PipelineDestination, ReadWriteBufferOptions };
+import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "@stream/streams.browser";
+import type { PipelineOptions, FinishedOptions } from "@stream/streams.browser";
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
+export type { PipelineOptions, FinishedOptions };
+import { EventEmitter } from "@stream/event-emitter";
+export { EventEmitter };
+import { ChunkedBuilder, TransactionalChunkedBuilder } from "@stream/chunked-builder";
+import type { ChunkedBuilderOptions, BuilderSnapshot } from "@stream/chunked-builder";
+export { ChunkedBuilder, TransactionalChunkedBuilder };
+export type { ChunkedBuilderOptions, BuilderSnapshot };
+import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "@stream/shared";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
+import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "@stream/utils";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };

package/dist/types/modules/stream/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Stream Module
+ *
+ * Native stream implementations for Node.js and Browser.
+ *
+ * - Node.js: Uses native `stream` module (Readable, Writable, Transform, Duplex, PassThrough)
+ * - Browser: Uses Web Streams API (ReadableStream, WritableStream, TransformStream)
+ *
+ * Both implementations provide the same API for cross-platform compatibility.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   Readable,
+ *   Writable,
+ *   Transform,
+ *   Duplex,
+ *   PassThrough,
+ *   pipeline,
+ *   createTransform,
+ *   streamToUint8Array
+ * } from './modules/stream';
+ *
+ * // Create a transform stream
+ * const uppercase = createTransform<Uint8Array, Uint8Array>(chunk => {
+ *   const text = new TextDecoder().decode(chunk);
+ *   return new TextEncoder().encode(text.toUpperCase());
+ * });
+ *
+ * // Use pipeline for clean stream composition
+ * await pipeline(readable, uppercase, writable);
+ * ```
+ */
+import type { ReadableStreamOptions, WritableStreamOptions, TransformStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, TransformCallback, FlushCallback, WriteCallback, DestroyCallback, IEventEmitter, IReadable, IWritable, ITransform, IDuplex, IPullStream, IBufferedStream, IPassThrough, ICollector, DataChunk, EventListener, PipelineSource, PipelineTransform, PipelineDestination, ReadWriteBufferOptions } from "@stream/types";
+export type { ReadableStreamOptions, WritableStreamOptions, TransformStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, TransformCallback, FlushCallback, WriteCallback, DestroyCallback, IEventEmitter, IReadable, IWritable, ITransform, IDuplex, IPullStream, IBufferedStream, IPassThrough, ICollector, DataChunk, EventListener, PipelineSource, PipelineTransform, PipelineDestination, ReadWriteBufferOptions };
+import { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, normalizeWritable as Writeable, consumers, promises } from "@stream/streams";
+import type { PipelineOptions, FinishedOptions } from "@stream/streams";
+export { Readable, Writable, Transform, Duplex, PassThrough, Collector, PullStream, BufferedStream, StringChunk, BufferChunk, createReadable, createWritable, createTransform, createCollector, createPassThrough, createPullStream, createBufferedStream, createReadableFromArray, createReadableFromAsyncIterable, createReadableFromGenerator, createReadableFromPromise, createDuplex, createEmptyReadable, createNullWritable, pipeline, finished, streamToPromise, streamToUint8Array, streamToBuffer, streamToString, drainStream, copyStream, addAbortSignal, compose, finishedAll, once, promisify, isReadable, isWritable, isTransform, isDuplex, isStream, isDestroyed, isDisturbed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMark, duplexPair, Writeable, consumers, promises };
+export type { PipelineOptions, FinishedOptions };
+import { EventEmitter } from "@stream/event-emitter";
+export { EventEmitter };
+import { ChunkedBuilder, TransactionalChunkedBuilder } from "@stream/chunked-builder";
+import type { ChunkedBuilderOptions, BuilderSnapshot } from "@stream/chunked-builder";
+export { ChunkedBuilder, TransactionalChunkedBuilder };
+export type { ChunkedBuilderOptions, BuilderSnapshot };
+import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "@stream/shared";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
+import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "@stream/utils";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };

package/dist/types/modules/stream/pull-stream.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Pull Stream
+ *
+ * A stream that allows pulling data from internal buffer with pattern matching.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "@stream/event-emitter";
+export interface PullStreamOptions {
+    /** Enable object mode */
+    objectMode?: boolean;
+}
+/**
+ * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
+ */
+export declare class PullStream extends EventEmitter {
+    private _bufferChunks;
+    private _totalLength;
+    protected finished: boolean;
+    protected _match?: number;
+    private _destroyed;
+    constructor(_options?: PullStreamOptions);
+    protected get buffer(): Uint8Array;
+    protected set buffer(buf: Uint8Array);
+    /**
+     * Write data to the stream
+     */
+    write(chunk: Uint8Array): boolean;
+    /**
+     * Signal end of input
+     */
+    end(chunk?: Uint8Array): void;
+    /**
+     * Destroy the stream
+     */
+    destroy(error?: Error): void;
+    /**
+     * Pull exactly N bytes from buffer, or pull until pattern is found
+     */
+    pull(size: number): Promise<Uint8Array>;
+    pull(pattern: Uint8Array, includePattern?: boolean): Promise<Uint8Array>;
+    /**
+     * Pull until pattern is found (alias for pull(pattern, includePattern))
+     */
+    pullUntil(pattern: Uint8Array, includePattern?: boolean): Promise<Uint8Array>;
+    private _pullSize;
+    private _pullPattern;
+    /**
+     * Get the match position from last pattern match
+     */
+    get matchPosition(): number | undefined;
+    /**
+     * Get remaining buffer length
+     */
+    get length(): number;
+    /**
+     * Check if stream is finished
+     */
+    get isFinished(): boolean;
+    /**
+     * Check if stream is destroyed
+     */
+    get destroyed(): boolean;
+    /**
+     * Find pattern in Uint8Array (like Buffer.indexOf)
+     */
+    private _indexOf;
+}

package/dist/types/modules/stream/shared.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared Utilities
+ *
+ * Common utilities shared across all stream implementations.
+ * This module provides cached TextEncoder/TextDecoder instances
+ * and core binary operations.
+ */
+/**
+ * Cached TextEncoder instance for UTF-8 encoding
+ */
+export declare const textEncoder: TextEncoder;
+/**
+ * Cached TextDecoder instance for UTF-8 decoding
+ * ignoreBOM: true - preserves BOM in output to match Node.js behavior
+ */
+export declare const textDecoder: TextDecoder;
+/**
+ * Get a cached TextDecoder instance.
+ *
+ * Note: For the default UTF-8 path we reuse the module-level `textDecoder`.
+ */
+export declare function getTextDecoder(encoding?: string): TextDecoder;
+/**
+ * Convert string to Uint8Array using cached encoder
+ */
+export declare function stringToUint8Array(str: string): Uint8Array;
+/**
+ * Convert Uint8Array to string using cached decoder
+ */
+export declare function uint8ArrayToString(arr: Uint8Array, encoding?: string): string;
+/**
+ * Concatenate multiple Uint8Arrays efficiently
+ */
+export declare function concatUint8Arrays(arrays: readonly Uint8Array[]): Uint8Array;
+/**
+ * Compare two Uint8Arrays for equality
+ */
+export declare function uint8ArrayEquals(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Find pattern in Uint8Array
+ */
+export declare function uint8ArrayIndexOf(haystack: Uint8Array, needle: Uint8Array, start?: number): number;
+/**
+ * Slice Uint8Array (returns a copy)
+ */
+export declare function uint8ArraySlice(arr: Uint8Array, start?: number, end?: number): Uint8Array;
+/**
+ * Convert any buffer-like input to Uint8Array
+ */
+export declare function toUint8Array(input: string | Uint8Array | ArrayBuffer | number[]): Uint8Array;
+/**
+ * Convert any input to string
+ */
+export declare function bufferToString(input: string | Uint8Array | ArrayBuffer | number[], encoding?: string): string;