@cj-tech-master/excelts 4.2.1 → 4.2.2-canary.20260115044841.88820eb

package/dist/types/modules/excel/utils/parse-sax.d.ts

@@ -54,6 +54,7 @@ export declare class SaxesParser {
     private positionAtNewLine;
     private chunkPosition;
     ENTITIES: Record<string, string>;
+    private nsPrefix;
     private textHandler?;
     private openTagHandler?;
     private closeTagHandler?;
@@ -62,6 +63,7 @@ export declare class SaxesParser {
     get closed(): boolean;
     get position(): number;
     private _init;
+    private stripNsPrefix;
     on(name: "text", handler: TextHandler): void;
     on(name: "opentag", handler: OpenTagHandler): void;
     on(name: "closetag", handler: CloseTagHandler): void;
@@ -106,6 +108,7 @@ export declare class SaxesParser {
     private skipSpaces;
     private openTag;
     private openSelfClosingTag;
+    private processAttributes;
     private closeTag;
     private end;
 }

package/dist/types/modules/excel/xlsx/xform/drawing/ctrl-prop-xform.d.ts

@@ -8,6 +8,7 @@ import type { FormCheckboxModel } from "../../../form-control.js";
  */
 declare class CtrlPropXform extends BaseXform {
     model: FormCheckboxModel;
+    private _checkedToXmlValue;
     get tag(): string;
     render(xmlStream: any, model?: FormCheckboxModel): void;
     /**

package/dist/types/modules/excel/xlsx/xform/drawing/sp-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "../base-xform.js";
+export interface ShapeModel {
+    /** Drawing object id (must be unique within drawing part) */
+    cNvPrId: number;
+    /** Display name (e.g. "Check Box 1") */
+    name: string;
+    /** VML spid compat value (e.g. "_x0000_s1025") */
+    spid: string;
+    /** Text shown in the shape text box */
+    text: string;
+    /** Whether the shape should be hidden */
+    hidden?: boolean;
+}
+declare class SpXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: ShapeModel): void;
+}
+export { SpXform };

package/dist/types/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.d.ts

@@ -5,7 +5,12 @@ interface TwoCellModel {
         tl: any;
         br: any;
     };
-    picture: any;
+    picture?: any;
+    shape?: any;
+    /** Wrap the anchor in mc:AlternateContent for modern drawing clients */
+    alternateContent?: {
+        requires: string;
+    };
 }
 declare class TwoCellAnchorXform extends BaseCellAnchorXform {
     constructor();

package/dist/types/modules/excel/xlsx/xform/sheet/page-setup-xform.d.ts

@@ -19,6 +19,7 @@ interface PageSetupModel {
 }
 declare class PageSetupXform extends BaseXform {
     get tag(): string;
+    private _dpiToXml;
     render(xmlStream: any, model: PageSetupModel): void;
     parseOpen(node: any): boolean;
     parseText(): void;

package/dist/types/modules/stream/base-transform.d.ts

@@ -24,6 +24,8 @@ export declare abstract class BaseTransform<TInput = Uint8Array, TOutput = Uint8
     protected _errorEmitted: boolean;
     protected _objectMode: boolean;
     protected _highWaterMark: number;
+    private _ending;
+    private _flushInProgress;
     constructor(options?: BaseTransformOptions);
     /**
      * Main transform implementation - must be overridden by subclasses
@@ -49,6 +51,7 @@ export declare abstract class BaseTransform<TInput = Uint8Array, TOutput = Uint8
      * Process next chunk in buffer
      */
     private _processNext;
+    private _maybeFlush;
     /**
      * Emit error only once
      */

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

@@ -5,14 +5,8 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "./event-emitter.js";
-/**
- * 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;
-}
+import type { BufferedStreamOptions, DataChunk } from "./types.js";
+export type { BufferedStreamOptions, DataChunk } from "./types.js";
 /**
  * String chunk implementation
  */
@@ -34,10 +28,6 @@ export declare class BufferChunk implements DataChunk {
     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
  */

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

@@ -1,22 +1,16 @@
 /**
- * Stream Module (browser type surface)
+ * Stream Module (browser entry)
  *
- * Mirrors [src/modules/stream/index.ts] but explicitly re-exports from
- * ./streams.browser so we can enforce index export-surface parity.
+ * Mirrors the public surface of `./index.ts`, but exports the browser
+ * implementation from `./streams.browser`.
+ *
+ * This file is intentionally export-only (tree-shaking friendly).
  */
-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 "./types.js";
-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 "./streams.browser.js";
-import type { PipelineOptions, FinishedOptions } from "./streams.browser.js";
-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 "./event-emitter.js";
-export { EventEmitter };
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
-import type { ChunkedBuilderOptions, BuilderSnapshot } from "./chunked-builder.js";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-export type { ChunkedBuilderOptions, BuilderSnapshot };
-import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
-export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
-import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
-export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };
+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 } from "./types.js";
+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, normalizeWritable as Writeable, consumers, promises } from "./streams.browser.js";
+export type { PipelineOptions, FinishedOptions } from "./streams.browser.js";
+export { EventEmitter } from "./event-emitter.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export type { ChunkedBuilderOptions, BuilderSnapshot } from "./chunked-builder.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";

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

@@ -1,49 +1,26 @@
 /**
- * Stream Module
+ * Stream Module (Node.js entry)
  *
- * Native stream implementations for Node.js and Browser.
+ * Public entrypoint for stream utilities and classes.
  *
- * - 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.
+ * Notes:
+ * - This file is intentionally export-only (tree-shaking friendly).
+ * - Browser builds should import from `@stream/index.browser`.
  *
  * @example
- * ```typescript
- * import {
- *   Readable,
- *   Writable,
- *   Transform,
- *   Duplex,
- *   PassThrough,
- *   pipeline,
- *   createTransform,
- *   streamToUint8Array
- * } from './modules/stream.js';
- *
- * // Create a transform stream
- * const uppercase = createTransform<Uint8Array, Uint8Array>(chunk => {
- *   const text = new TextDecoder().decode(chunk);
- *   return new TextEncoder().encode(text.toUpperCase());
- * });
+ * ```ts
+ * import { pipeline, createTransform, createCollector } from "./index.js";
  *
- * // Use pipeline for clean stream composition
- * await pipeline(readable, uppercase, writable);
+ * const upper = createTransform<Uint8Array, Uint8Array>(chunk => chunk);
+ * const out = createCollector<Uint8Array>();
+ * await pipeline(source, upper, out);
  * ```
  */
-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 "./types.js";
-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 "./streams.js";
-import type { PipelineOptions, FinishedOptions } from "./streams.js";
-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 "./event-emitter.js";
-export { EventEmitter };
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
-import type { ChunkedBuilderOptions, BuilderSnapshot } from "./chunked-builder.js";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-export type { ChunkedBuilderOptions, BuilderSnapshot };
-import { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
-export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays };
-import { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";
-export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter };
+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 } from "./types.js";
+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, normalizeWritable as Writeable, consumers, promises } from "./streams.js";
+export type { PipelineOptions, FinishedOptions } from "./streams.js";
+export { EventEmitter } from "./event-emitter.js";
+export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
+export type { ChunkedBuilderOptions, BuilderSnapshot } from "./chunked-builder.js";
+export { textEncoder, textDecoder, stringToUint8Array, uint8ArrayToString, uint8ArrayEquals, uint8ArrayIndexOf, uint8ArraySlice, toUint8Array, bufferToString, concatUint8Arrays } from "./shared.js";
+export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter } from "./utils.js";

package/dist/types/modules/stream/internal/event-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Small event utilities for Node-style emitters.
+ *
+ * Prefer keeping this separate from the main stream implementation so other
+ * modules (e.g. archive) can reuse it without pulling in the whole stream API.
+ */
+type NodeStyleEmitter = {
+    on?: (event: string, listener: (...args: any[]) => void) => any;
+    once?: (event: string, listener: (...args: any[]) => void) => any;
+    off?: (event: string, listener: (...args: any[]) => void) => any;
+    removeListener?: (event: string, listener: (...args: any[]) => void) => any;
+};
+/**
+ * Resolve when an emitter fires `event`, reject on `error`.
+ */
+export declare function onceEvent(emitter: NodeStyleEmitter, event: string): Promise<void>;
+export {};

package/dist/types/modules/stream/internal/type-guards.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lightweight runtime type guards shared across modules.
+ *
+ * Keep this file dependency-free to maximize deduping in bundled builds.
+ */
+export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
+export declare function isWritableStream(value: unknown): value is WritableStream<unknown>;
+export declare function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
+export declare function isTransformStream(value: unknown): value is TransformStream<unknown, unknown>;

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

@@ -5,16 +5,15 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "./event-emitter.js";
-export interface PullStreamOptions {
-    /** Enable object mode */
-    objectMode?: boolean;
-}
+import type { PullStreamOptions } from "./types.js";
+export type { PullStreamOptions } from "./types.js";
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 export declare class PullStream extends EventEmitter {
-    private _bufferChunks;
-    private _totalLength;
+    private _buffer;
+    private _bufferReadIndex;
+    private _bufferWriteIndex;
     protected finished: boolean;
     protected _match?: number;
     private _destroyed;

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

@@ -31,7 +31,7 @@ export declare function uint8ArrayToString(arr: Uint8Array, encoding?: string):
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-export declare function concatUint8Arrays(arrays: readonly Uint8Array[]): Uint8Array;
+export declare function concatUint8Arrays(arrays: readonly Uint8Array[], totalLength?: number): Uint8Array;
 /**
  * Compare two Uint8Arrays for equality
  */

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

@@ -10,11 +10,11 @@
  * - Safari >= 14.1
  * - Edge >= 89
  */
-import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "./types.js";
+import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "./types.js";
 import type { Writable as NodeWritable } from "stream";
 import { EventEmitter } from "./event-emitter.js";
-import { PullStream as StandalonePullStream, type PullStreamOptions as StandalonePullStreamOptions } from "./pull-stream.js";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.js";
+import { PullStream } from "./pull-stream.js";
+import { BufferedStream, BufferChunk, StringChunk } from "./buffered-stream.js";
 /**
  * A wrapper around Web ReadableStream that provides Node.js-like API
  */
@@ -27,6 +27,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _bufferSize;
     private _reading;
     private _ended;
+    private _endEmitted;
     private _destroyed;
     private _errored;
     private _closed;
@@ -71,6 +72,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
      * Push data to the stream (when using controllable stream)
      */
     push(chunk: T | null): boolean;
+    private _emitEndOnce;
     /**
      * Put a chunk back at the front of the buffer
      * Note: unshift is allowed even after end, as it's used to put back already read data
@@ -158,7 +160,8 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _startReading;
     /**
      * Async iterator support
-     * Uses Web Stream reader for non-push mode, event-based for push mode
+     * Uses a unified event-queue iterator with simple backpressure.
+     * This matches Node's behavior more closely (iterator drives flowing mode).
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
     /**
@@ -285,10 +288,12 @@ export declare class Writable<T = Uint8Array> extends EventEmitter {
     private _closed;
     private _pendingWrites;
     private _writableLength;
+    private _needDrain;
     private _corked;
     private _corkedChunks;
     private _defaultEncoding;
     private _aborted;
+    private _ownsStream;
     private _writeFunc?;
     private _finalFunc?;
     readonly objectMode: boolean;
@@ -398,53 +403,46 @@ export declare function normalizeWritable<T = Uint8Array>(stream: WritableLike |
  * A wrapper around Web TransformStream that provides Node.js-like API
  */
 export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extends EventEmitter {
-    private _stream;
     /** @internal - for pipe() support */
     readonly _readable: Readable<TOutput>;
     /** @internal - for pipe() support */
     readonly _writable: Writable<TInput>;
     readonly objectMode: boolean;
-    private _ended;
     private _destroyed;
+    private _ended;
     private _errored;
-    private _pushBuffer;
-    private _transformController;
-    private _pendingEndWrites;
-    private _endPending;
+    private _dataForwardingSetup;
+    private _endTimer;
+    private _webStream;
+    private _sideForwardingCleanup;
+    private _transformImpl;
+    private _flushImpl;
     /**
-     * Push data to the readable side (Node.js compatibility)
-     * Can be called from within transform callback
+     * Push data to the readable side (Node.js compatibility).
+     * Intended to be called from within transform/flush.
      */
     push(chunk: TOutput | null): boolean;
     constructor(options?: TransformStreamOptions & {
         transform?: ((chunk: TInput) => TOutput | Promise<TOutput>) | ((this: Transform<TInput, TOutput>, chunk: TInput, encoding: string, callback: (error?: Error | null, data?: TOutput) => void) => void);
         flush?: (() => TOutput | void | Promise<TOutput | void>) | ((this: Transform<TInput, TOutput>, callback: (error?: Error | null, data?: TOutput) => void) => void);
     });
-    private _dataForwardingSetup;
+    private _setupSideForwarding;
+    private _scheduleEnd;
+    private _emitErrorOnce;
+    private _hasSubclassTransform;
+    private _hasSubclassFlush;
+    private _runTransform;
+    private _runFlush;
     /**
-     * Override on to start flowing when data listener is added
+     * Override on() to lazily forward readable 'data' events.
+     * Avoids starting flowing mode unless requested.
      */
     on(event: string | symbol, listener: (...args: any[]) => void): this;
-    /** @internal - whether we have a data event consumer */
-    private _hasDataConsumer;
     /**
-     * Write data to the transform stream
-     * Note: Automatically starts consuming readable if no consumer to allow
-     * transform function to execute (Web Streams backpressure compatibility)
+     * Write to the writable side
      */
     write(chunk: TInput, callback?: (error?: Error | null) => void): boolean;
     write(chunk: TInput, encoding?: string, callback?: (error?: Error | null) => void): boolean;
-    /** @internal - whether we're auto-consuming the readable */
-    private _readableConsuming;
-    /** @internal - buffer for auto-consumed data */
-    private _autoConsumedBuffer;
-    private _autoConsumedBufferIndex;
-    /** @internal - whether auto-consume has ended */
-    private _autoConsumeEnded;
-    /** @internal - promise that resolves when auto-consume finishes */
-    private _autoConsumePromise;
-    /** @internal - auto-consume readable to allow transform to execute */
-    private _startAutoConsume;
     /**
      * End the transform stream
      * Delays closing to allow writes during data events to complete
@@ -456,10 +454,8 @@ export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extend
      * Read from the transform stream
      */
     read(size?: number): TOutput | null;
-    /** @internal - list of piped destinations for forwarding auto-consumed data */
-    private _pipeDestinations;
     /**
-     * Pipe to another stream (writable, transform, or duplex)
+     * Pipe readable side to destination
      */
     pipe<W extends Writable<TOutput> | Transform<TOutput, any> | Duplex<any, TOutput>>(destination: W): W;
     /**
@@ -554,6 +550,7 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         writable: WritableStream<W>;
     };
     private _dataForwardingSetup;
+    private _sideForwardingCleanup;
     constructor(options?: DuplexStreamOptions & {
         allowHalfOpen?: boolean;
         objectMode?: boolean;
@@ -561,6 +558,7 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         write?: (this: Duplex<TRead, TWrite>, chunk: TWrite, encoding: string, callback: (error?: Error | null) => void) => void;
         final?: (this: Duplex<TRead, TWrite>, callback: (error?: Error | null) => void) => void;
     });
+    private _setupSideForwarding;
     /**
      * Override on() to set up data forwarding lazily
      */
@@ -669,16 +667,7 @@ export declare class Collector<T = Uint8Array> extends Writable<T> {
     toString(): string;
     get isFinished(): boolean;
 }
-export declare class PullStream extends StandalonePullStream {
-    constructor(options?: PullStreamOptions | StandalonePullStreamOptions);
-}
-export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
-}
-export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
-}
-export declare class BufferedStream extends StandaloneBufferedStream {
-    constructor(options?: BufferedStreamOptions);
-}
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 /**
  * Create a readable stream with custom read implementation
  */
@@ -935,4 +924,3 @@ export declare const promises: {
     pipeline: typeof pipeline;
     finished: typeof finished;
 };
-export {};

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

@@ -5,9 +5,9 @@
  * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
  */
 import { Readable, Writable as NodeWritable, Transform, Duplex, PassThrough } from "stream";
-import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "./types.js";
-import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.js";
-import { PullStream as StandalonePullStream } from "./pull-stream.js";
+import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "./types.js";
+import { BufferedStream, BufferChunk, StringChunk } from "./buffered-stream.js";
+import { PullStream } from "./pull-stream.js";
 /**
  * Extended Writable options that match browser API
  * Supports wrapping an existing Node.js stream
@@ -30,6 +30,7 @@ export declare class Writable<T = Uint8Array> extends NodeWritable {
     constructor(options?: WritableOptions<T>);
 }
 export { Readable, Transform, Duplex, PassThrough };
+export { PullStream, BufferedStream, StringChunk, BufferChunk };
 /**
  * Normalize a user-provided writable into a Node.js-compatible Writable.
  *
@@ -130,27 +131,10 @@ export declare class Collector<T = Uint8Array> extends Writable {
  * Create a collector stream
  */
 export declare function createCollector<T = Uint8Array>(options?: WritableStreamOptions): ICollector<T>;
-export declare class PullStream extends StandalonePullStream {
-}
 /**
  * Create a pull stream
  */
 export declare function createPullStream(options?: PullStreamOptions): PullStream;
-/**
- * String chunk implementation
- */
-export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
-}
-/**
- * Buffer chunk implementation
- */
-export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
-}
-/**
- * Buffered stream with efficient chunk management
- */
-export declare class BufferedStream extends StandaloneBufferedStream {
-}
 /**
  * Create a buffered stream
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "4.2.1",
+  "version": "4.2.2-canary.20260115044841.88820eb",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "publishConfig": {
@@ -44,6 +44,10 @@
         "default": "./dist/cjs/index.js"
       }
     },
+    "./browser": {
+      "types": "./dist/browser/index.browser.d.ts",
+      "default": "./dist/browser/index.browser.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -86,23 +90,23 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.6",
     "@typescript-eslint/eslint-plugin": "^8.52.0",
     "@typescript-eslint/parser": "^8.52.0",
-    "@typescript/native-preview": "^7.0.0-dev.20260108.1",
-    "@vitest/browser": "^4.0.16",
-    "@vitest/browser-playwright": "^4.0.16",
-    "@vitest/ui": "^4.0.16",
+    "@typescript/native-preview": "^7.0.0-dev.20260112.1",
+    "@vitest/browser": "^4.0.17",
+    "@vitest/browser-playwright": "^4.0.17",
+    "@vitest/ui": "^4.0.17",
     "concurrently": "^9.2.1",
     "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.1",
-    "eslint-plugin-oxlint": "^1.38.0",
+    "eslint-plugin-oxlint": "^1.39.0",
     "eslint-plugin-unused-imports": "^4.3.0",
     "husky": "^9.1.7",
-    "oxlint": "^1.38.0",
+    "oxlint": "^1.39.0",
     "playwright": "^1.57.0",
     "prettier": "^3.7.4",
     "rimraf": "^6.1.2",
@@ -110,8 +114,8 @@
     "rollup-plugin-visualizer": "^6.0.5",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.52.0",
-    "vite-tsconfig-paths": "^6.0.3",
-    "vitest": "^4.0.16"
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17"
   },
   "scripts": {
     "example": "node scripts/run-examples.ts",

package/dist/browser/modules/archive/byte-queue.d.ts

@@ -1,18 +0,0 @@
-export declare class ByteQueue {
-    private static readonly EMPTY;
-    private _buf;
-    private _start;
-    private _end;
-    private _cachedView;
-    private _cachedBuf;
-    private _cachedStart;
-    private _cachedEnd;
-    constructor(initial?: Uint8Array);
-    get length(): number;
-    isEmpty(): boolean;
-    view(): Uint8Array;
-    reset(data?: Uint8Array): void;
-    append(chunk: Uint8Array): void;
-    read(length: number): Uint8Array;
-    discard(length: number): void;
-}