@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1-canary.20260112134913.a3cecdd

package/dist/cjs/modules/stream/streams.browser.js

@@ -12,7 +12,7 @@
  * - Edge >= 89
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promises = exports.consumers = exports.streamToBuffer = exports.BufferedStream = exports.BufferChunk = exports.StringChunk = exports.PullStream = exports.Collector = exports.PassThrough = exports.Duplex = exports.Transform = exports.Writable = exports.Readable = void 0;
+exports.promises = exports.consumers = exports.streamToBuffer = exports.BufferChunk = exports.StringChunk = exports.BufferedStream = exports.PullStream = exports.Collector = exports.PassThrough = exports.Duplex = exports.Transform = exports.Writable = exports.Readable = void 0;
 exports.normalizeWritable = normalizeWritable;
 exports.createReadable = createReadable;
 exports.createReadableFromAsyncIterable = createReadableFromAsyncIterable;
@@ -53,8 +53,13 @@ exports.isWritable = isWritable;
 exports.duplexPair = duplexPair;
 const event_emitter_1 = require("./event-emitter.js");
 const pull_stream_1 = require("./pull-stream.js");
+Object.defineProperty(exports, "PullStream", { enumerable: true, get: function () { return pull_stream_1.PullStream; } });
 const buffered_stream_1 = require("./buffered-stream.js");
+Object.defineProperty(exports, "BufferedStream", { enumerable: true, get: function () { return buffered_stream_1.BufferedStream; } });
+Object.defineProperty(exports, "BufferChunk", { enumerable: true, get: function () { return buffered_stream_1.BufferChunk; } });
+Object.defineProperty(exports, "StringChunk", { enumerable: true, get: function () { return buffered_stream_1.StringChunk; } });
 const shared_1 = require("./shared.js");
+const type_guards_1 = require("./internal/type-guards.js");
 const removeEmitterListener = (emitter, event, listener) => {
     if (typeof emitter.off === "function") {
         emitter.off(event, listener);
@@ -2450,28 +2455,6 @@ class Collector extends Writable {
 }
 exports.Collector = Collector;
 // =============================================================================
-// PullStream / BufferedStream / DataChunk helpers
-// =============================================================================
-class PullStream extends pull_stream_1.PullStream {
-    // Keep constructor signature aligned with streams.browser.ts public API
-    constructor(options) {
-        super(options);
-    }
-}
-exports.PullStream = PullStream;
-class StringChunk extends buffered_stream_1.StringChunk {
-}
-exports.StringChunk = StringChunk;
-class BufferChunk extends buffered_stream_1.BufferChunk {
-}
-exports.BufferChunk = BufferChunk;
-class BufferedStream extends buffered_stream_1.BufferedStream {
-    constructor(options) {
-        super(options);
-    }
-}
-exports.BufferedStream = BufferedStream;
-// =============================================================================
 // Stream Creation Functions
 // =============================================================================
 /**
@@ -2545,28 +2528,14 @@ function createPassThrough(options) {
  * Create a pull stream
  */
 function createPullStream(options) {
-    return new PullStream(options);
+    return new pull_stream_1.PullStream(options);
 }
 /**
  * Create a buffered stream
  */
 function createBufferedStream(options) {
-    return new BufferedStream(options);
+    return new buffered_stream_1.BufferedStream(options);
 }
-const isReadableStream = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
-const isAsyncIterable = (value) => {
-    if (!value || (typeof value !== "object" && typeof value !== "function")) {
-        return false;
-    }
-    return typeof value[Symbol.asyncIterator] === "function";
-};
-const isWritableStream = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
-const isTransformStream = (value) => !!value &&
-    typeof value === "object" &&
-    !!value.readable &&
-    !!value.writable &&
-    isReadableStream(value.readable) &&
-    isWritableStream(value.writable);
 const isPipelineOptions = (value) => {
     if (!value || typeof value !== "object") {
         return false;
@@ -2591,13 +2560,13 @@ const toBrowserPipelineStream = (stream) => {
         stream instanceof Duplex) {
         return stream;
     }
-    if (isTransformStream(stream)) {
+    if ((0, type_guards_1.isTransformStream)(stream)) {
         return Transform.fromWeb(stream);
     }
-    if (isReadableStream(stream)) {
+    if ((0, type_guards_1.isReadableStream)(stream)) {
         return Readable.fromWeb(stream);
     }
-    if (isWritableStream(stream)) {
+    if ((0, type_guards_1.isWritableStream)(stream)) {
         return Writable.fromWeb(stream);
     }
     return stream;
@@ -2836,8 +2805,8 @@ async function streamToPromise(stream) {
  * (Browser equivalent of Node.js streamToBuffer)
  */
 async function streamToUint8Array(stream) {
-    const { chunks, totalLength } = await collectStreamChunks(stream);
-    return concatWithLength(chunks, totalLength);
+    const [chunks, totalLength] = await collectStreamChunks(stream);
+    return (0, shared_1.concatUint8Arrays)(chunks, totalLength);
 }
 /**
  * Alias for streamToUint8Array (Node.js compatibility)
@@ -2847,8 +2816,8 @@ exports.streamToBuffer = streamToUint8Array;
  * Collect all data from a readable stream into a string
  */
 async function streamToString(stream, encoding) {
-    const { chunks, totalLength } = await collectStreamChunks(stream);
-    const combined = concatWithLength(chunks, totalLength);
+    const [chunks, totalLength] = await collectStreamChunks(stream);
+    const combined = (0, shared_1.concatUint8Arrays)(chunks, totalLength);
     const decoder = encoding ? (0, shared_1.getTextDecoder)(encoding) : shared_1.textDecoder;
     return decoder.decode(combined);
 }
@@ -2856,16 +2825,7 @@ async function streamToString(stream, encoding) {
  * Drain a stream (consume all data without processing)
  */
 async function drainStream(stream) {
-    let iterable;
-    if (isReadableStream(stream)) {
-        iterable = Readable.fromWeb(stream);
-    }
-    else if (isAsyncIterable(stream)) {
-        iterable = stream;
-    }
-    else {
-        throw new Error("drainStream: unsupported stream type");
-    }
+    const iterable = toReadableAsyncIterable(stream, "drainStream");
     for await (const _chunk of iterable) {
         // Consume data
     }
@@ -3085,94 +3045,117 @@ function compose(...transforms) {
     for (let i = 0; i < len - 1; i++) {
         transforms[i].pipe(transforms[i + 1]);
     }
-    class ComposedTransform extends Transform {
-        constructor(options) {
-            super(options);
-            this._dataForwarding = false;
-            this._endForwarding = false;
-            this._dataForwardCleanup = null;
-            this._endForwardCleanup = null;
-            this._errorForwardCleanup = [];
-            for (const t of transforms) {
-                const onError = (err) => {
-                    this.emit("error", err);
-                };
-                this._errorForwardCleanup.push(addEmitterListener(t, "error", onError));
-            }
-        }
-        on(event, listener) {
-            if (event === "data" && !this._dataForwarding) {
-                this._dataForwarding = true;
-                const onData = (chunk) => {
-                    this.emit("data", chunk);
-                };
-                this._dataForwardCleanup = addEmitterListener(last, "data", onData);
-            }
-            if (event === "end" && !this._endForwarding) {
-                this._endForwarding = true;
-                const onEnd = () => {
-                    this.emit("end");
-                };
-                this._endForwardCleanup = addEmitterListener(last, "end", onEnd, { once: true });
-            }
-            return super.on(event, listener);
-        }
-        write(chunk, encodingOrCallback, callback) {
-            if (typeof encodingOrCallback === "function") {
-                return first.write(chunk, encodingOrCallback);
-            }
-            return first.write(chunk, encodingOrCallback, callback);
-        }
-        end(chunkOrCallback, encodingOrCallback, callback) {
-            if (typeof chunkOrCallback === "function") {
-                first.end(chunkOrCallback);
-                return this;
-            }
-            if (typeof encodingOrCallback === "function") {
-                first.end(chunkOrCallback, encodingOrCallback);
-                return this;
-            }
-            first.end(chunkOrCallback, encodingOrCallback, callback);
-            return this;
+    // A lightweight Transform wrapper that delegates:
+    // - writable side to `first`
+    // - readable side to `last`
+    // It forwards relevant events lazily to avoid per-chunk overhead when unused.
+    const composed = new Transform({
+        objectMode: first?.objectMode ?? true,
+        transform: chunk => chunk
+    });
+    const registry = createListenerRegistry();
+    // Always forward errors; they are critical for pipeline semantics.
+    for (const t of transforms) {
+        registry.add(t, "error", (err) => composed.emit("error", err));
+    }
+    // Forward writable-side backpressure/completion events from `first`.
+    registry.add(first, "drain", () => composed.emit("drain"));
+    registry.once(first, "finish", () => composed.emit("finish"));
+    // Forward readable-side events from `last` lazily.
+    let forwardData = false;
+    let forwardEnd = false;
+    let forwardReadable = false;
+    const ensureDataForwarding = () => {
+        if (forwardData) {
+            return;
         }
-        pipe(destination) {
-            return last.pipe(destination);
+        forwardData = true;
+        registry.add(last, "data", (chunk) => composed.emit("data", chunk));
+    };
+    const ensureEndForwarding = () => {
+        if (forwardEnd) {
+            return;
         }
-        destroy(error) {
-            if (this._dataForwardCleanup) {
-                this._dataForwardCleanup();
-                this._dataForwardCleanup = null;
-            }
-            if (this._endForwardCleanup) {
-                this._endForwardCleanup();
-                this._endForwardCleanup = null;
-            }
-            for (let i = this._errorForwardCleanup.length - 1; i >= 0; i--) {
-                this._errorForwardCleanup[i]();
-            }
-            this._errorForwardCleanup.length = 0;
-            for (const t of transforms) {
-                t.destroy(error);
-            }
-            super.destroy(error);
+        forwardEnd = true;
+        registry.once(last, "end", () => composed.emit("end"));
+    };
+    const ensureReadableForwarding = () => {
+        if (forwardReadable) {
+            return;
+        }
+        forwardReadable = true;
+        registry.add(last, "readable", () => composed.emit("readable"));
+    };
+    const originalOn = composed.on.bind(composed);
+    const originalOnce = composed.once.bind(composed);
+    composed.on = (event, listener) => {
+        if (event === "data") {
+            ensureDataForwarding();
         }
-        read(size) {
-            return typeof last.read === "function" ? last.read(size) : null;
+        else if (event === "end") {
+            ensureEndForwarding();
         }
-        async *[Symbol.asyncIterator]() {
-            const it = last?.[Symbol.asyncIterator]?.();
-            if (it) {
-                for await (const chunk of it) {
-                    yield chunk;
-                }
-                return;
+        else if (event === "readable") {
+            ensureReadableForwarding();
+        }
+        return originalOn(event, listener);
+    };
+    composed.once = (event, listener) => {
+        if (event === "data") {
+            ensureDataForwarding();
+        }
+        else if (event === "end") {
+            ensureEndForwarding();
+        }
+        else if (event === "readable") {
+            ensureReadableForwarding();
+        }
+        return originalOnce(event, listener);
+    };
+    // Delegate core stream methods
+    const firstAny = first;
+    const lastAny = last;
+    composed.write = (chunk, encodingOrCallback, callback) => {
+        if (typeof encodingOrCallback === "function") {
+            return firstAny.write(chunk, encodingOrCallback);
+        }
+        return firstAny.write(chunk, encodingOrCallback, callback);
+    };
+    composed.end = (chunkOrCallback, encodingOrCallback, callback) => {
+        if (typeof chunkOrCallback === "function") {
+            firstAny.end(chunkOrCallback);
+            return composed;
+        }
+        if (typeof encodingOrCallback === "function") {
+            firstAny.end(chunkOrCallback, encodingOrCallback);
+            return composed;
+        }
+        firstAny.end(chunkOrCallback, encodingOrCallback, callback);
+        return composed;
+    };
+    composed.pipe = (destination) => {
+        return lastAny.pipe(destination);
+    };
+    composed.read = (size) => {
+        return typeof lastAny.read === "function" ? lastAny.read(size) : null;
+    };
+    composed[Symbol.asyncIterator] = async function* () {
+        const it = lastAny?.[Symbol.asyncIterator]?.();
+        if (it) {
+            for await (const chunk of it) {
+                yield chunk;
             }
-            yield* super[Symbol.asyncIterator]();
+            return;
         }
-    }
-    const composed = new ComposedTransform({
-        objectMode: first?.objectMode ?? true,
-        transform: chunk => chunk
+        yield* Transform.prototype[Symbol.asyncIterator].call(composed);
+    };
+    const originalDestroy = composed.destroy.bind(composed);
+    composed.destroy = ((error) => {
+        registry.cleanup();
+        for (const t of transforms) {
+            t.destroy(error);
+        }
+        originalDestroy(error);
     });
     // Reflect underlying readability/writability like the previous duck-typed wrapper
     Object.defineProperty(composed, "readable", {
@@ -3419,77 +3402,54 @@ function duplexPair(options) {
 async function collectStreamChunks(stream) {
     const chunks = [];
     let totalLength = 0;
-    let iterable;
-    if (isReadableStream(stream)) {
-        iterable = Readable.fromWeb(stream);
-    }
-    else if (isAsyncIterable(stream)) {
-        iterable = stream;
-    }
-    else {
-        throw new Error("collectStreamChunks: unsupported stream type");
-    }
+    const iterable = toReadableAsyncIterable(stream, "collectStreamChunks");
     for await (const chunk of iterable) {
         chunks.push(chunk);
         totalLength += chunk.length;
     }
-    return { chunks, totalLength };
+    return [chunks, totalLength];
 }
-// Helper to concatenate with known length (faster)
-function concatWithLength(chunks, totalLength) {
-    const len = chunks.length;
-    if (len === 0) {
-        return new Uint8Array(0);
-    }
-    if (len === 1) {
-        return chunks[0];
+function toReadableAsyncIterable(stream, name) {
+    if ((0, type_guards_1.isReadableStream)(stream)) {
+        return Readable.fromWeb(stream);
     }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0; i < len; i++) {
-        result.set(chunks[i], offset);
-        offset += chunks[i].length;
+    if ((0, type_guards_1.isAsyncIterable)(stream)) {
+        return stream;
     }
-    return result;
+    throw new Error(`${name}: unsupported stream type`);
 }
 exports.consumers = {
     /**
      * Consume entire stream as ArrayBuffer
      */
     async arrayBuffer(stream) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        const combined = concatWithLength(chunks, totalLength);
-        return combined.buffer.slice(combined.byteOffset, combined.byteOffset + combined.byteLength);
+        const bytes = await streamToUint8Array(stream);
+        return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
     },
     /**
      * Consume entire stream as Blob
      */
     async blob(stream, options) {
-        const { chunks } = await collectStreamChunks(stream);
+        const [chunks] = await collectStreamChunks(stream);
         return new Blob(chunks, options);
     },
     /**
      * Consume entire stream as Buffer (Uint8Array in browser)
      */
     async buffer(stream) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        return concatWithLength(chunks, totalLength);
+        return streamToUint8Array(stream);
     },
     /**
      * Consume entire stream as JSON
      */
     async json(stream) {
-        const text = await exports.consumers.text(stream);
-        return JSON.parse(text);
+        return JSON.parse(await streamToString(stream));
     },
     /**
      * Consume entire stream as text
      */
     async text(stream, encoding) {
-        const { chunks, totalLength } = await collectStreamChunks(stream);
-        const combined = concatWithLength(chunks, totalLength);
-        const decoder = encoding ? (0, shared_1.getTextDecoder)(encoding) : shared_1.textDecoder;
-        return decoder.decode(combined);
+        return streamToString(stream, encoding);
     }
 };
 // =============================================================================

package/dist/cjs/modules/stream/streams.js

@@ -6,7 +6,7 @@
  * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promises = exports.consumers = exports.BufferedStream = exports.BufferChunk = exports.StringChunk = exports.PullStream = exports.Collector = exports.PassThrough = exports.Duplex = exports.Transform = exports.Readable = exports.Writable = void 0;
+exports.promises = exports.consumers = exports.Collector = exports.BufferChunk = exports.StringChunk = exports.BufferedStream = exports.PullStream = exports.PassThrough = exports.Duplex = exports.Transform = exports.Readable = exports.Writable = void 0;
 exports.normalizeWritable = normalizeWritable;
 exports.pipeline = pipeline;
 exports.finished = finished;
@@ -52,7 +52,12 @@ Object.defineProperty(exports, "Transform", { enumerable: true, get: function ()
 Object.defineProperty(exports, "Duplex", { enumerable: true, get: function () { return stream_1.Duplex; } });
 Object.defineProperty(exports, "PassThrough", { enumerable: true, get: function () { return stream_1.PassThrough; } });
 const buffered_stream_1 = require("./buffered-stream.js");
+Object.defineProperty(exports, "BufferedStream", { enumerable: true, get: function () { return buffered_stream_1.BufferedStream; } });
+Object.defineProperty(exports, "BufferChunk", { enumerable: true, get: function () { return buffered_stream_1.BufferChunk; } });
+Object.defineProperty(exports, "StringChunk", { enumerable: true, get: function () { return buffered_stream_1.StringChunk; } });
 const pull_stream_1 = require("./pull-stream.js");
+Object.defineProperty(exports, "PullStream", { enumerable: true, get: function () { return pull_stream_1.PullStream; } });
+const type_guards_1 = require("./internal/type-guards.js");
 /**
  * Unified Writable class - wraps Node.js Writable with browser-compatible API
  *
@@ -127,29 +132,12 @@ function normalizeWritable(stream) {
 }
 // Import for internal use
 const shared_1 = require("./shared.js");
-const isReadableStream = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
-const isAsyncIterable = (value) => {
-    if (!value || (typeof value !== "object" && typeof value !== "function")) {
-        return false;
-    }
-    return typeof value[Symbol.asyncIterator] === "function";
-};
-const isWritableStream = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
-const isTransformStream = (value) => !!value &&
-    typeof value === "object" &&
-    !!value.readable &&
-    !!value.writable &&
-    isReadableStream(value.readable) &&
-    isWritableStream(value.writable);
 const isPipelineOptions = (value) => {
     if (!value || typeof value !== "object") {
         return false;
     }
-    // IMPORTANT:
-    // Do NOT use `"end" in obj` here because streams have `.end()` and would be
-    // misclassified as options, breaking argument parsing and potentially hanging.
+    // Avoid treating streams as options objects.
     if (typeof value.pipe === "function" ||
-        typeof value.write === "function" ||
         typeof value.end === "function" ||
         typeof value.getReader === "function" ||
         typeof value.getWriter === "function") {
@@ -166,13 +154,13 @@ const toNodePipelineStream = (stream) => {
         stream instanceof stream_1.Writable) {
         return stream;
     }
-    if (isTransformStream(stream)) {
+    if ((0, type_guards_1.isTransformStream)(stream)) {
         return stream_1.Transform.fromWeb(stream);
     }
-    if (isReadableStream(stream)) {
+    if ((0, type_guards_1.isReadableStream)(stream)) {
         return stream_1.Readable.fromWeb(stream);
     }
-    if (isWritableStream(stream)) {
+    if ((0, type_guards_1.isWritableStream)(stream)) {
         return stream_1.Writable.fromWeb(stream);
     }
     return stream;
@@ -469,41 +457,20 @@ function createCollector(options) {
 // =============================================================================
 // Pull Stream - Read data on demand with pattern matching
 // =============================================================================
-class PullStream extends pull_stream_1.PullStream {
-}
-exports.PullStream = PullStream;
 /**
  * Create a pull stream
  */
 function createPullStream(options) {
-    return new PullStream(options);
+    return new pull_stream_1.PullStream(options);
 }
 // =============================================================================
 // Buffered Stream - Efficient chunk management
 // =============================================================================
-/**
- * String chunk implementation
- */
-class StringChunk extends buffered_stream_1.StringChunk {
-}
-exports.StringChunk = StringChunk;
-/**
- * Buffer chunk implementation
- */
-class BufferChunk extends buffered_stream_1.BufferChunk {
-}
-exports.BufferChunk = BufferChunk;
-/**
- * Buffered stream with efficient chunk management
- */
-class BufferedStream extends buffered_stream_1.BufferedStream {
-}
-exports.BufferedStream = BufferedStream;
 /**
  * Create a buffered stream
  */
 function createBufferedStream(options) {
-    return new BufferedStream(options);
+    return new buffered_stream_1.BufferedStream(options);
 }
 // =============================================================================
 // Utility Functions
@@ -520,10 +487,10 @@ async function streamToPromise(stream) {
  */
 async function streamToBuffer(stream) {
     let iterable;
-    if (isReadableStream(stream)) {
+    if ((0, type_guards_1.isReadableStream)(stream)) {
         iterable = stream_1.Readable.fromWeb(stream);
     }
-    else if (isAsyncIterable(stream)) {
+    else if ((0, type_guards_1.isAsyncIterable)(stream)) {
         iterable = stream;
     }
     else {
@@ -565,10 +532,10 @@ async function streamToString(stream, encoding) {
  */
 async function drainStream(stream) {
     let iterable;
-    if (isReadableStream(stream)) {
+    if ((0, type_guards_1.isReadableStream)(stream)) {
         iterable = stream_1.Readable.fromWeb(stream);
     }
-    else if (isAsyncIterable(stream)) {
+    else if ((0, type_guards_1.isAsyncIterable)(stream)) {
         iterable = stream;
     }
     else {

package/dist/cjs/modules/stream/utils.js

@@ -28,46 +28,13 @@ async function collect(stream) {
     return result;
 }
 async function text(stream) {
-    const chunks = [];
-    let totalLength = 0;
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    if (chunks.length === 1) {
-        return (0, shared_1.uint8ArrayToString)(chunks[0]);
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0, len = chunks.length; i < len; i++) {
-        const c = chunks[i];
-        result.set(c, offset);
-        offset += c.length;
-    }
-    return (0, shared_1.uint8ArrayToString)(result);
+    return streams_1.consumers.text(stream);
 }
 async function json(stream) {
-    const str = await text(stream);
-    return JSON.parse(str);
+    return streams_1.consumers.json(stream);
 }
 async function bytes(stream) {
-    const chunks = [];
-    let totalLength = 0;
-    for await (const chunk of stream) {
-        chunks.push(chunk);
-        totalLength += chunk.length;
-    }
-    if (chunks.length === 1) {
-        return chunks[0];
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (let i = 0, len = chunks.length; i < len; i++) {
-        const c = chunks[i];
-        result.set(c, offset);
-        offset += c.length;
-    }
-    return result;
+    return streams_1.consumers.buffer(stream);
 }
 // =============================================================================
 // Stream Factory Helpers