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

package/dist/esm/modules/stream/chunked-builder.js

@@ -1,165 +0,0 @@
-/**
- * Chunked Builder (Browser Compatible)
- *
- * Browser-compatible version that uses Uint8Array instead of Buffer.
- * This file provides the same API but works in browser environments.
- */
-import { textEncoder } from "@stream/shared";
-/**
- * Efficient builder for accumulating and consolidating string chunks
- * Browser-compatible version
- */
-export class ChunkedBuilder {
-    constructor(options = {}) {
-        this._pieces = [];
-        this._chunks = [];
-        this._totalLength = 0;
-        this._chunkSize = options.chunkSize ?? 10000;
-    }
-    /**
-     * Add a piece to the builder
-     */
-    push(piece) {
-        this._pieces.push(piece);
-        this._totalLength += piece.length;
-        if (this._pieces.length >= this._chunkSize) {
-            this._consolidate();
-        }
-    }
-    /**
-     * Add multiple pieces
-     */
-    pushAll(pieces) {
-        const len = pieces.length;
-        for (let i = 0; i < len; i++) {
-            this._pieces.push(pieces[i]);
-            this._totalLength += pieces[i].length;
-        }
-        if (this._pieces.length >= this._chunkSize) {
-            this._consolidate();
-        }
-    }
-    /**
-     * Consolidate pieces into chunks
-     */
-    _consolidate() {
-        if (this._pieces.length > 0) {
-            this._chunks.push(this._pieces.join(""));
-            this._pieces = [];
-        }
-    }
-    /**
-     * Get current cursor position (useful for tracking changes)
-     */
-    get cursor() {
-        return this._chunks.length * this._chunkSize + this._pieces.length;
-    }
-    /**
-     * Get total piece/chunk count
-     */
-    get length() {
-        return this._pieces.length + this._chunks.length;
-    }
-    /**
-     * Get total string length (character count)
-     */
-    get stringLength() {
-        return this._totalLength;
-    }
-    /**
-     * Check if empty
-     */
-    get isEmpty() {
-        return this._pieces.length === 0 && this._chunks.length === 0;
-    }
-    /**
-     * Clear all content
-     */
-    clear() {
-        this._pieces = [];
-        this._chunks = [];
-        this._totalLength = 0;
-    }
-    /**
-     * Build final string
-     */
-    toString() {
-        const chunksLen = this._chunks.length;
-        const piecesLen = this._pieces.length;
-        // Fast path: only pieces, no chunks
-        if (chunksLen === 0) {
-            if (piecesLen === 0) {
-                return "";
-            }
-            if (piecesLen === 1) {
-                return this._pieces[0];
-            }
-            return this._pieces.join("");
-        }
-        // Has chunks - consolidate and join
-        if (piecesLen > 0) {
-            this._chunks.push(this._pieces.join(""));
-            this._pieces = [];
-        }
-        if (this._chunks.length === 1) {
-            return this._chunks[0];
-        }
-        return this._chunks.join("");
-    }
-    /**
-     * Convert to Uint8Array (browser-compatible)
-     */
-    toUint8Array() {
-        return textEncoder.encode(this.toString());
-    }
-}
-/**
- * Chunked builder with rollback/commit support
- * Browser-compatible version
- */
-export class TransactionalChunkedBuilder extends ChunkedBuilder {
-    constructor() {
-        super(...arguments);
-        this._snapshots = [];
-    }
-    /**
-     * Create a rollback point
-     */
-    snapshot() {
-        const snap = {
-            piecesLength: this._pieces.length,
-            chunksLength: this._chunks.length,
-            totalLength: this._totalLength
-        };
-        this._snapshots.push(snap);
-        return snap;
-    }
-    /**
-     * Commit the current snapshot (remove rollback point)
-     */
-    commit() {
-        this._snapshots.pop();
-    }
-    /**
-     * Rollback to the last snapshot
-     */
-    rollback() {
-        const snap = this._snapshots.pop();
-        if (!snap) {
-            throw new Error("No snapshot to rollback to");
-        }
-        if (this._pieces.length > snap.piecesLength) {
-            this._pieces.length = snap.piecesLength;
-        }
-        if (this._chunks.length > snap.chunksLength) {
-            this._chunks.length = snap.chunksLength;
-        }
-        this._totalLength = snap.totalLength;
-    }
-    /**
-     * Check if there are active snapshots
-     */
-    get hasSnapshots() {
-        return this._snapshots.length > 0;
-    }
-}

package/dist/esm/modules/stream/event-emitter.js

@@ -1,239 +0,0 @@
-/**
- * Event Emitter
- *
- * Browser-compatible EventEmitter with a Node.js-like API surface.
- * Kept lightweight and allocation-lean for hot paths.
- */
-const isListenerList = (value) => Array.isArray(value);
-export class EventEmitter {
-    constructor() {
-        // Brand for ExcelTS browser stream objects.
-        // Use a string key (not a Symbol) so it still works if the bundle ends up
-        // containing multiple copies of this module.
-        this.__excelts_stream = true;
-        this._listeners = new Map();
-        this._maxListeners = EventEmitter.defaultMaxListeners;
-    }
-    addListener(event, listener) {
-        return this.on(event, listener);
-    }
-    _listenerCount(value) {
-        if (!value) {
-            return 0;
-        }
-        return isListenerList(value) ? value.length : 1;
-    }
-    _hasListeners(event) {
-        return this._listenerCount(this._listeners.get(event)) > 0;
-    }
-    on(event, listener) {
-        const existing = this._listeners.get(event);
-        // Warn if exceeding max listeners (skip check if maxListeners is 0 = unlimited)
-        if (this._maxListeners > 0) {
-            const count = this._listenerCount(existing);
-            if (count >= this._maxListeners) {
-                // Avoid hard dependency on console for bundle/minified builds
-                console?.warn?.(`MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ` +
-                    `${count + 1} ${String(event)} listeners added. ` +
-                    `Use emitter.setMaxListeners() to increase limit`);
-            }
-        }
-        if (!existing) {
-            this._listeners.set(event, listener);
-        }
-        else if (isListenerList(existing)) {
-            existing.push(listener);
-        }
-        else {
-            this._listeners.set(event, [existing, listener]);
-        }
-        // Node emits 'newListener' only if someone is listening to it.
-        if (event !== "newListener" && this._hasListeners("newListener")) {
-            this.emit("newListener", event, listener);
-        }
-        return this;
-    }
-    prependListener(event, listener) {
-        const existing = this._listeners.get(event);
-        if (!existing) {
-            this._listeners.set(event, listener);
-        }
-        else if (isListenerList(existing)) {
-            existing.unshift(listener);
-        }
-        else {
-            this._listeners.set(event, [listener, existing]);
-        }
-        if (event !== "newListener" && this._hasListeners("newListener")) {
-            this.emit("newListener", event, listener);
-        }
-        return this;
-    }
-    once(event, listener) {
-        const onceWrapper = (...args) => {
-            this.off(event, onceWrapper);
-            listener.apply(this, args);
-        };
-        onceWrapper.listener = listener;
-        return this.on(event, onceWrapper);
-    }
-    prependOnceListener(event, listener) {
-        const onceWrapper = (...args) => {
-            this.off(event, onceWrapper);
-            listener.apply(this, args);
-        };
-        onceWrapper.listener = listener;
-        return this.prependListener(event, onceWrapper);
-    }
-    removeListener(event, listener) {
-        return this.off(event, listener);
-    }
-    off(event, listener) {
-        const existing = this._listeners.get(event);
-        if (!existing) {
-            return this;
-        }
-        if (!isListenerList(existing)) {
-            if (existing === listener || existing.listener === listener) {
-                this._listeners.delete(event);
-                if (event !== "removeListener" && this._hasListeners("removeListener")) {
-                    this.emit("removeListener", event, listener);
-                }
-            }
-            return this;
-        }
-        const listeners = existing;
-        if (listeners.length === 0) {
-            this._listeners.delete(event);
-            return this;
-        }
-        // Fast path: direct match
-        const directIdx = listeners.indexOf(listener);
-        if (directIdx !== -1) {
-            listeners.splice(directIdx, 1);
-        }
-        else {
-            // Slow path: check for once wrapper
-            for (let i = 0, len = listeners.length; i < len; i++) {
-                if (listeners[i].listener === listener) {
-                    listeners.splice(i, 1);
-                    break;
-                }
-            }
-        }
-        if (listeners.length === 0) {
-            this._listeners.delete(event);
-        }
-        else if (listeners.length === 1) {
-            this._listeners.set(event, listeners[0]);
-        }
-        if (event !== "removeListener" && this._hasListeners("removeListener")) {
-            this.emit("removeListener", event, listener);
-        }
-        return this;
-    }
-    emit(event, ...args) {
-        const existing = this._listeners.get(event);
-        if (!existing) {
-            return false;
-        }
-        if (!isListenerList(existing)) {
-            try {
-                existing.apply(this, args);
-            }
-            catch (err) {
-                if (event !== "error") {
-                    this.emit("error", err);
-                }
-            }
-            return true;
-        }
-        const listeners = existing;
-        const len = listeners.length;
-        if (len === 0) {
-            return false;
-        }
-        if (len === 1) {
-            try {
-                listeners[0].apply(this, args);
-            }
-            catch (err) {
-                if (event !== "error") {
-                    this.emit("error", err);
-                }
-            }
-            return true;
-        }
-        if (len === 2) {
-            const l0 = listeners[0];
-            const l1 = listeners[1];
-            try {
-                l0.apply(this, args);
-            }
-            catch (err) {
-                if (event !== "error") {
-                    this.emit("error", err);
-                }
-            }
-            try {
-                l1.apply(this, args);
-            }
-            catch (err) {
-                if (event !== "error") {
-                    this.emit("error", err);
-                }
-            }
-            return true;
-        }
-        // Snapshot to allow removal during emit
-        const snapshot = listeners.slice();
-        for (let i = 0; i < snapshot.length; i++) {
-            try {
-                snapshot[i].apply(this, args);
-            }
-            catch (err) {
-                if (event !== "error") {
-                    this.emit("error", err);
-                }
-            }
-        }
-        return true;
-    }
-    removeAllListeners(event) {
-        if (event !== undefined) {
-            this._listeners.delete(event);
-        }
-        else {
-            this._listeners.clear();
-        }
-        return this;
-    }
-    listenerCount(event) {
-        return this._listenerCount(this._listeners.get(event));
-    }
-    listeners(event) {
-        const value = this._listeners.get(event);
-        if (!value) {
-            return [];
-        }
-        return isListenerList(value) ? value.slice() : [value];
-    }
-    rawListeners(event) {
-        const value = this._listeners.get(event);
-        if (!value) {
-            return [];
-        }
-        return isListenerList(value) ? value.slice() : [value];
-    }
-    eventNames() {
-        return [...this._listeners.keys()];
-    }
-    setMaxListeners(n) {
-        this._maxListeners = n;
-        return this;
-    }
-    getMaxListeners() {
-        return this._maxListeners;
-    }
-}
-EventEmitter.defaultMaxListeners = 10;

package/dist/esm/modules/stream/index.browser.js

@@ -1,25 +0,0 @@
-/**
- * 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.
- */
-// =============================================================================
-// Native Stream Classes and Functions (browser)
-// =============================================================================
-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";
-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 };
-import { EventEmitter } from "@stream/event-emitter";
-export { EventEmitter };
-// =============================================================================
-// ChunkedBuilder (platform-independent)
-// =============================================================================
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "@stream/chunked-builder";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-// =============================================================================
-// Utility Functions (platform-independent)
-// =============================================================================
-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/esm/modules/stream/index.js

@@ -1,52 +0,0 @@
-/**
- * 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.js';
- *
- * // 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);
- * ```
- */
-// =============================================================================
-// Native Stream Classes and Functions (platform-specific)
-// =============================================================================
-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";
-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 };
-import { EventEmitter } from "@stream/event-emitter";
-export { EventEmitter };
-// =============================================================================
-// ChunkedBuilder (platform-independent)
-// =============================================================================
-import { ChunkedBuilder, TransactionalChunkedBuilder } from "@stream/chunked-builder";
-export { ChunkedBuilder, TransactionalChunkedBuilder };
-// =============================================================================
-// Utility Functions (platform-independent)
-// =============================================================================
-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/esm/modules/stream/pull-stream.js

@@ -1,204 +0,0 @@
-/**
- * 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";
-import { concatUint8Arrays } from "@stream/shared";
-/**
- * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
- */
-export class PullStream extends EventEmitter {
-    constructor(_options = {}) {
-        super();
-        // Use chunked buffer storage to avoid repeated concat
-        this._bufferChunks = [];
-        this._totalLength = 0;
-        this.finished = false;
-        this._destroyed = false;
-    }
-    // Consolidate chunks into single buffer when needed
-    get buffer() {
-        const len = this._bufferChunks.length;
-        if (len === 0) {
-            return new Uint8Array(0);
-        }
-        if (len === 1) {
-            return this._bufferChunks[0];
-        }
-        // Consolidate multiple chunks
-        const buf = concatUint8Arrays(this._bufferChunks);
-        this._bufferChunks = [buf];
-        return buf;
-    }
-    set buffer(buf) {
-        this._bufferChunks = buf.length > 0 ? [buf] : [];
-        this._totalLength = buf.length;
-    }
-    /**
-     * Write data to the stream
-     */
-    write(chunk) {
-        if (this._destroyed) {
-            this.emit("error", new Error("Cannot write to destroyed stream"));
-            return false;
-        }
-        this._bufferChunks.push(chunk);
-        this._totalLength += chunk.length;
-        this.emit("chunk");
-        return true;
-    }
-    /**
-     * Signal end of input
-     */
-    end(chunk) {
-        if (chunk !== undefined) {
-            this.write(chunk);
-        }
-        this.finished = true;
-        this.emit("chunk", false);
-        this.emit("finish");
-        this.emit("end");
-    }
-    /**
-     * Destroy the stream
-     */
-    destroy(error) {
-        if (this._destroyed) {
-            return;
-        }
-        this._destroyed = true;
-        this._bufferChunks = [];
-        this._totalLength = 0;
-        if (error) {
-            this.emit("error", error);
-        }
-        this.emit("close");
-    }
-    pull(sizeOrPattern, includePattern) {
-        if (typeof sizeOrPattern === "number") {
-            return this._pullSize(sizeOrPattern);
-        }
-        return this._pullPattern(sizeOrPattern, includePattern ?? false);
-    }
-    /**
-     * Pull until pattern is found (alias for pull(pattern, includePattern))
-     */
-    pullUntil(pattern, includePattern) {
-        return this._pullPattern(pattern, includePattern ?? false);
-    }
-    _pullSize(size) {
-        return new Promise((resolve, reject) => {
-            const tryPull = () => {
-                if (this._destroyed) {
-                    reject(new Error("Stream destroyed"));
-                    return;
-                }
-                // Use _totalLength for fast check before consolidating
-                if (this._totalLength >= size) {
-                    const buf = this.buffer;
-                    const result = buf.subarray(0, size);
-                    this.buffer = buf.subarray(size);
-                    resolve(result);
-                    return;
-                }
-                if (this.finished) {
-                    // Return whatever we have
-                    const result = this.buffer;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
-                    resolve(result);
-                    return;
-                }
-                // Wait for more data
-                this.once("chunk", tryPull);
-            };
-            tryPull();
-        });
-    }
-    _pullPattern(pattern, includePattern) {
-        return new Promise((resolve, reject) => {
-            const tryPull = () => {
-                if (this._destroyed) {
-                    reject(new Error("Stream destroyed"));
-                    return;
-                }
-                const buf = this.buffer;
-                const matchIndex = this._indexOf(buf, pattern);
-                if (matchIndex !== -1) {
-                    this._match = matchIndex;
-                    const endIndex = includePattern ? matchIndex + pattern.length : matchIndex;
-                    const result = buf.subarray(0, endIndex);
-                    this.buffer = buf.subarray(includePattern ? endIndex : matchIndex + pattern.length);
-                    resolve(result);
-                    return;
-                }
-                if (this.finished) {
-                    // Pattern not found, return everything
-                    const result = buf;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
-                    resolve(result);
-                    return;
-                }
-                // Wait for more data
-                this.once("chunk", tryPull);
-            };
-            tryPull();
-        });
-    }
-    /**
-     * Get the match position from last pattern match
-     */
-    get matchPosition() {
-        return this._match;
-    }
-    /**
-     * Get remaining buffer length
-     */
-    get length() {
-        return this._totalLength;
-    }
-    /**
-     * Check if stream is finished
-     */
-    get isFinished() {
-        return this.finished;
-    }
-    /**
-     * Check if stream is destroyed
-     */
-    get destroyed() {
-        return this._destroyed;
-    }
-    /**
-     * Find pattern in Uint8Array (like Buffer.indexOf)
-     */
-    _indexOf(haystack, needle, start = 0) {
-        const needleLen = needle.length;
-        if (needleLen === 0) {
-            return start;
-        }
-        const haystackLen = haystack.length;
-        if (needleLen > haystackLen) {
-            return -1;
-        }
-        const first = needle[0];
-        const last = haystackLen - needleLen;
-        outer: for (let i = start; i <= last; i++) {
-            // Quick check first byte
-            if (haystack[i] !== first) {
-                continue;
-            }
-            // Check rest of pattern
-            for (let j = 1; j < needleLen; j++) {
-                if (haystack[i + j] !== needle[j]) {
-                    continue outer;
-                }
-            }
-            return i;
-        }
-        return -1;
-    }
-}