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

package/dist/cjs/modules/excel/utils/stream-buf.js

@@ -1,456 +0,0 @@
-"use strict";
-/**
- * StreamBuf - Cross-Platform Multi-purpose Read-Write Stream
- *
- * A unified implementation that works in both Node.js and Browser environments
- * using the cross-platform EventEmitter from modules/stream.
- *
- * Features:
- * - As MemBuf: write data, then call toBuffer() to consolidate
- * - As StreamHub: pipe to multiple writable streams
- * - As readable stream: feed data into writable part and read from it
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamBuf = void 0;
-const _stream_1 = require("@stream");
-const string_buf_1 = require("@excel/utils/string-buf");
-class StringChunk {
-    constructor(data) {
-        this._data = data;
-    }
-    get length() {
-        return this.toBuffer().length;
-    }
-    copy(target, targetOffset, offset, length) {
-        const buf = this.toBuffer();
-        const bytesToCopy = Math.min(length, buf.length - offset);
-        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
-        return bytesToCopy;
-    }
-    toBuffer() {
-        if (!this._buffer) {
-            this._buffer = new TextEncoder().encode(this._data);
-        }
-        return this._buffer;
-    }
-}
-class StringBufChunk {
-    constructor(data) {
-        this._data = data;
-    }
-    get length() {
-        return this._data.length;
-    }
-    copy(target, targetOffset, offset, length) {
-        const buf = this.toBuffer();
-        const bytesToCopy = Math.min(length, buf.length - offset);
-        target.set(buf.subarray(offset, offset + bytesToCopy), targetOffset);
-        return bytesToCopy;
-    }
-    toBuffer() {
-        return this._data.toBuffer();
-    }
-}
-class BufferChunk {
-    constructor(data) {
-        this._data = data;
-    }
-    get length() {
-        return this._data.length;
-    }
-    copy(target, targetOffset, offset, length) {
-        const bytesToCopy = Math.min(length, this._data.length - offset);
-        target.set(this._data.subarray(offset, offset + bytesToCopy), targetOffset);
-        return bytesToCopy;
-    }
-    toBuffer() {
-        return this._data;
-    }
-}
-// =============================================================================
-// ReadWriteBuf - a single buffer supporting simple read-write
-// =============================================================================
-class ReadWriteBuf {
-    constructor(size) {
-        this.size = size;
-        this.buffer = new Uint8Array(size);
-        this.iRead = 0;
-        this.iWrite = 0;
-    }
-    toBuffer() {
-        if (this.iRead === 0 && this.iWrite === this.size) {
-            return this.buffer;
-        }
-        return this.buffer.slice(this.iRead, this.iWrite);
-    }
-    get length() {
-        return this.iWrite - this.iRead;
-    }
-    get eod() {
-        return this.iRead === this.iWrite;
-    }
-    get full() {
-        return this.iWrite === this.size;
-    }
-    read(size) {
-        if (size === 0) {
-            return null;
-        }
-        if (size === undefined || size >= this.length) {
-            const buf = this.toBuffer();
-            this.iRead = this.iWrite;
-            return buf;
-        }
-        const buf = this.buffer.slice(this.iRead, this.iRead + size);
-        this.iRead += size;
-        return buf;
-    }
-    write(chunk, offset, length) {
-        const size = Math.min(length, this.size - this.iWrite);
-        chunk.copy(this.buffer, this.iWrite, offset, offset + size);
-        this.iWrite += size;
-        return size;
-    }
-}
-// =============================================================================
-// StreamBuf - Cross-Platform Implementation
-// =============================================================================
-/**
- * StreamBuf is a multi-purpose read-write stream that works in both
- * Node.js and Browser environments.
- *
- * It extends EventEmitter to provide stream-like events:
- * - 'data': emitted when data is written (flowing mode)
- * - 'readable': emitted when data is available to read
- * - 'finish': emitted when end() is called
- * - 'error': emitted on errors
- * - 'drain': emitted when buffer drains (after pipe)
- */
-class StreamBuf extends _stream_1.EventEmitter {
-    constructor(options) {
-        super();
-        // Native WritableStream support
-        this._writableStream = null;
-        this._writableStreamWriter = null;
-        this._asyncWriteQueue = Promise.resolve();
-        this.bufSize = options?.bufSize || 1024 * 1024;
-        this.buffers = [];
-        this.batch = options?.batch || false;
-        this.corked = false;
-        this.paused = false;
-        this.encoding = null;
-        this.pipes = [];
-        this._ended = false;
-    }
-    /**
-     * Returns true if the stream is writable (not ended)
-     * Required for compatibility with Node.js pipe()
-     */
-    get writable() {
-        return !this._ended;
-    }
-    /**
-     * Consolidate all buffers into a single Uint8Array
-     */
-    toBuffer() {
-        switch (this.buffers.length) {
-            case 0:
-                return null;
-            case 1:
-                return this.buffers[0].toBuffer();
-            default: {
-                const totalLength = this.buffers.reduce((acc, buf) => acc + buf.length, 0);
-                const result = new Uint8Array(totalLength);
-                let offset = 0;
-                for (const rwBuf of this.buffers) {
-                    const buf = rwBuf.toBuffer();
-                    result.set(buf, offset);
-                    offset += buf.length;
-                }
-                return result;
-            }
-        }
-    }
-    _getWritableBuffer() {
-        if (this.buffers.length) {
-            const last = this.buffers[this.buffers.length - 1];
-            if (!last.full) {
-                return last;
-            }
-        }
-        const buf = new ReadWriteBuf(this.bufSize);
-        this.buffers.push(buf);
-        return buf;
-    }
-    async _pipeChunk(chunk) {
-        const writePromises = this.pipes.map((pipe) => new Promise(resolve => {
-            pipe.write(chunk.toBuffer(), () => resolve());
-        }));
-        await Promise.all(writePromises);
-    }
-    _writeToBuffers(chunk) {
-        let inPos = 0;
-        const inLen = chunk.length;
-        while (inPos < inLen) {
-            const buffer = this._getWritableBuffer();
-            inPos += buffer.write(chunk, inPos, inLen - inPos);
-        }
-    }
-    /**
-     * Write data to the stream
-     */
-    async write(data, encoding, callback) {
-        const nop = () => { };
-        if (typeof encoding === "function") {
-            callback = encoding;
-            encoding = "utf8";
-        }
-        callback = callback || nop;
-        // Create chunk from data
-        let chunk;
-        if (data instanceof string_buf_1.StringBuf || (data && data.constructor?.name === "StringBuf")) {
-            chunk = new StringBufChunk(data);
-        }
-        else if (data instanceof Uint8Array) {
-            chunk = new BufferChunk(data);
-        }
-        else if (ArrayBuffer.isView(data)) {
-            chunk = new BufferChunk(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-        }
-        else if (data instanceof ArrayBuffer) {
-            chunk = new BufferChunk(new Uint8Array(data));
-        }
-        else if (typeof data === "string") {
-            chunk = new StringChunk(data);
-        }
-        else {
-            throw new Error("Chunk must be one of type String, Uint8Array, ArrayBuffer or StringBuf.");
-        }
-        // Handle piping and buffering
-        if (this.pipes.length) {
-            if (this.batch) {
-                this._writeToBuffers(chunk);
-                while (!this.corked && this.buffers.length > 1) {
-                    const buf = this.buffers.shift();
-                    await this._pipeChunk(new BufferChunk(buf.toBuffer()));
-                }
-            }
-            else if (!this.corked) {
-                await this._pipeChunk(chunk);
-                callback();
-            }
-            else {
-                this._writeToBuffers(chunk);
-                queueMicrotask(() => callback());
-            }
-        }
-        else {
-            const chunkBuffer = chunk.toBuffer();
-            if (!this.paused) {
-                this.emit("data", chunkBuffer);
-            }
-            // Also write to native WritableStream if connected
-            if (this._writableStreamWriter) {
-                this._asyncWriteQueue = this._asyncWriteQueue.then(() => this._writableStreamWriter.write(chunkBuffer));
-            }
-            this._writeToBuffers(chunk);
-            this.emit("readable");
-        }
-        return true;
-    }
-    /**
-     * Cork the stream - buffer writes until uncork
-     */
-    cork() {
-        this.corked = true;
-    }
-    _flush() {
-        if (this.pipes.length) {
-            const flushAll = async () => {
-                while (this.buffers.length) {
-                    const buf = this.buffers.shift();
-                    await this._pipeChunk(new BufferChunk(buf.toBuffer()));
-                }
-            };
-            flushAll().catch(err => this.emit("error", err));
-        }
-    }
-    /**
-     * Uncork the stream - flush buffered writes
-     */
-    uncork() {
-        this.corked = false;
-        this._flush();
-    }
-    /**
-     * End the stream
-     */
-    end(chunk, encoding, callback) {
-        const writeComplete = (error) => {
-            if (error) {
-                callback?.(error);
-                return;
-            }
-            this._ended = true;
-            this._flush();
-            this.pipes.forEach((pipe) => {
-                if (typeof pipe.end === "function") {
-                    pipe.end();
-                }
-            });
-            // If we have a native WritableStream, wait for all async writes to complete
-            if (this._writableStreamWriter) {
-                this._asyncWriteQueue
-                    .then(() => this._writableStreamWriter.close())
-                    .then(() => {
-                    this.emit("finish");
-                })
-                    .catch(err => {
-                    this.emit("error", err);
-                });
-            }
-            else {
-                this.emit("finish");
-            }
-        };
-        if (chunk) {
-            this.write(chunk, encoding, writeComplete);
-        }
-        else {
-            writeComplete();
-        }
-    }
-    /**
-     * Read from the stream
-     */
-    read(size) {
-        if (size) {
-            const buffers = [];
-            let remaining = size;
-            while (remaining && this.buffers.length && !this.buffers[0].eod) {
-                const first = this.buffers[0];
-                const buffer = first.read(remaining);
-                if (buffer) {
-                    remaining -= buffer.length;
-                    buffers.push(buffer);
-                }
-                if (first.eod && first.full) {
-                    this.buffers.shift();
-                }
-            }
-            return concatUint8Arrays(buffers);
-        }
-        const buffers = this.buffers.map(buf => buf.toBuffer()).filter(Boolean);
-        this.buffers = [];
-        return concatUint8Arrays(buffers);
-    }
-    /**
-     * Read from the stream and return as string.
-     * Cross-platform compatible - works identically in Node.js and Browser.
-     */
-    readString(encoding) {
-        const enc = encoding || this.encoding || "utf-8";
-        const buf = this.read();
-        if (typeof Buffer !== "undefined" && buf instanceof Buffer) {
-            return buf.toString(enc);
-        }
-        return new TextDecoder(enc).decode(buf);
-    }
-    /**
-     * Set encoding for string reads
-     */
-    setEncoding(encoding) {
-        this.encoding = encoding;
-    }
-    /**
-     * Pause the stream
-     */
-    pause() {
-        this.paused = true;
-    }
-    /**
-     * Resume the stream
-     */
-    resume() {
-        this.paused = false;
-    }
-    /**
-     * Check if stream is paused
-     */
-    isPaused() {
-        return this.paused;
-    }
-    /**
-     * Pipe to a writable stream
-     */
-    pipe(destination) {
-        this.pipes.push(destination);
-        if (!this.paused && this.buffers.length) {
-            this.end();
-        }
-        return destination;
-    }
-    /**
-     * Pipe to a native WritableStream (browser Streams API).
-     * This properly handles async writes and waits for completion before finish.
-     */
-    pipeTo(writableStream) {
-        this._writableStream = writableStream;
-        this._writableStreamWriter = writableStream.getWriter();
-    }
-    /**
-     * Remove a piped destination
-     */
-    unpipe(destination) {
-        this.pipes = this.pipes.filter((pipe) => pipe !== destination);
-    }
-    /**
-     * Put data back at the front (not implemented)
-     */
-    unshift() {
-        throw new Error("Not Implemented");
-    }
-    /**
-     * Wrap a stream (not implemented)
-     */
-    wrap() {
-        throw new Error("Not Implemented");
-    }
-    /**
-     * Push data to the stream (alias for write)
-     */
-    push(chunk) {
-        if (chunk !== null) {
-            this.write(chunk);
-        }
-        return true;
-    }
-}
-exports.StreamBuf = StreamBuf;
-// =============================================================================
-// Utility Functions
-// =============================================================================
-/**
- * Concatenate multiple Uint8Arrays into one
- * Returns Buffer in Node.js for better toString() compatibility
- */
-function concatUint8Arrays(arrays) {
-    // In Node.js, use Buffer.concat for better compatibility (Buffer.toString() works)
-    if (typeof Buffer !== "undefined" && typeof Buffer.concat === "function") {
-        return Buffer.concat(arrays);
-    }
-    if (arrays.length === 0) {
-        return new Uint8Array(0);
-    }
-    if (arrays.length === 1) {
-        return arrays[0];
-    }
-    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const arr of arrays) {
-        result.set(arr, offset);
-        offset += arr.length;
-    }
-    return result;
-}

package/dist/cjs/modules/excel/utils/string-buf.js

@@ -1,78 +0,0 @@
-"use strict";
-/**
- * StringBuf - Cross-Platform String Buffer
- *
- * A way to keep string memory operations to a minimum while building XML strings.
- * Uses TextEncoder and Uint8Array for cross-platform compatibility (Node.js + Browser).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringBuf = void 0;
-const encoder = new TextEncoder();
-/**
- * StringBuf - efficient string builder using Uint8Array
- * Works identically in Node.js and Browser environments.
- */
-class StringBuf {
-    constructor(options) {
-        this._buf = new Uint8Array((options && options.size) || 16384);
-        // TextEncoder only supports UTF-8, so encoding option is ignored
-        this._inPos = 0;
-        this._buffer = undefined;
-    }
-    get length() {
-        return this._inPos;
-    }
-    get capacity() {
-        return this._buf.length;
-    }
-    get buffer() {
-        return this._buf;
-    }
-    toBuffer() {
-        // Return the current data as a single enclosing buffer
-        if (!this._buffer) {
-            this._buffer = this._buf.slice(0, this._inPos);
-        }
-        return this._buffer;
-    }
-    reset(position) {
-        position = position || 0;
-        this._buffer = undefined;
-        this._inPos = position;
-    }
-    _grow(min) {
-        let size = this._buf.length * 2;
-        while (size < min) {
-            size *= 2;
-        }
-        const buf = new Uint8Array(size);
-        buf.set(this._buf);
-        this._buf = buf;
-    }
-    addText(text) {
-        this._buffer = undefined;
-        // Encode string to UTF-8 bytes
-        const encoded = encoder.encode(text);
-        const minSpace = this._inPos + encoded.length;
-        // Grow preemptively: if remaining space < 4 bytes margin, double
-        // This matches original Buffer behavior where growth is triggered proactively
-        if (minSpace > this._buf.length - 4) {
-            this._grow(minSpace);
-        }
-        // Copy encoded bytes to buffer
-        this._buf.set(encoded, this._inPos);
-        this._inPos += encoded.length;
-    }
-    addStringBuf(inBuf) {
-        if (inBuf.length) {
-            this._buffer = undefined;
-            if (this.length + inBuf.length > this.capacity) {
-                this._grow(this.length + inBuf.length);
-            }
-            // Copy bytes from input buffer
-            this._buf.set(inBuf._buf.subarray(0, inBuf.length), this._inPos);
-            this._inPos += inBuf.length;
-        }
-    }
-}
-exports.StringBuf = StringBuf;

package/dist/cjs/modules/excel/utils/under-dash.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEqual = isEqual;
-exports.escapeHtml = escapeHtml;
-exports.isUndefined = isUndefined;
-exports.isObject = isObject;
-exports.deepMerge = deepMerge;
-exports.cloneDeep = cloneDeep;
-exports.get = get;
-const escapeHtmlMap = {
-    '"': """,
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;"
-};
-const escapeHtmlRegex = /["&<>]/g;
-function isEqual(a, b) {
-    // Fast path: identical references or primitives
-    if (a === b) {
-        return true;
-    }
-    if (a == null || b == null) {
-        return a === b;
-    }
-    const aType = typeof a;
-    if (aType !== typeof b) {
-        return false;
-    }
-    // Primitives already handled by ===
-    if (aType !== "object") {
-        return false;
-    }
-    // Arrays
-    const aIsArray = Array.isArray(a);
-    const bIsArray = Array.isArray(b);
-    if (aIsArray !== bIsArray) {
-        return false;
-    }
-    if (aIsArray) {
-        const len = a.length;
-        if (len !== b.length) {
-            return false;
-        }
-        for (let i = 0; i < len; i++) {
-            if (!isEqual(a[i], b[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // Objects
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-        return false;
-    }
-    for (let i = 0, len = aKeys.length; i < len; i++) {
-        const key = aKeys[i];
-        if (!Object.prototype.hasOwnProperty.call(b, key)) {
-            return false;
-        }
-        if (!isEqual(a[key], b[key])) {
-            return false;
-        }
-    }
-    return true;
-}
-function escapeHtml(html) {
-    return html.replace(escapeHtmlRegex, char => escapeHtmlMap[char]);
-}
-function isUndefined(val) {
-    return val === undefined;
-}
-function isObject(val) {
-    return val !== null && typeof val === "object" && !Array.isArray(val);
-}
-function deepMerge(...args) {
-    const target = args[0] || {};
-    const len = args.length;
-    for (let i = 1; i < len; i++) {
-        const arg = args[i];
-        if (!arg) {
-            continue;
-        }
-        if (Array.isArray(arg)) {
-            for (let j = 0, jLen = arg.length; j < jLen; j++) {
-                const val = arg[j];
-                if (val === undefined) {
-                    continue;
-                }
-                const src = target[j];
-                if (Array.isArray(val)) {
-                    target[j] = deepMerge(Array.isArray(src) ? src : [], val);
-                }
-                else if (isObject(val)) {
-                    target[j] = deepMerge(isObject(src) ? src : {}, val);
-                }
-                else {
-                    target[j] = val;
-                }
-            }
-        }
-        else {
-            const keys = Object.keys(arg);
-            for (let j = 0, jLen = keys.length; j < jLen; j++) {
-                const key = keys[j];
-                // Prevent prototype pollution
-                if (key === "__proto__" || key === "constructor" || key === "prototype") {
-                    continue;
-                }
-                const val = arg[key];
-                if (val === undefined) {
-                    continue;
-                }
-                const src = target[key];
-                if (Array.isArray(val)) {
-                    target[key] = deepMerge(Array.isArray(src) ? src : [], val);
-                }
-                else if (isObject(val)) {
-                    target[key] = deepMerge(isObject(src) ? src : {}, val);
-                }
-                else {
-                    target[key] = val;
-                }
-            }
-        }
-    }
-    return target;
-}
-function cloneDeep(obj, preserveUndefined = true) {
-    if (obj === null || typeof obj !== "object") {
-        return obj;
-    }
-    if (obj instanceof Date) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        const len = obj.length;
-        const clone = new Array(len);
-        for (let i = 0; i < len; i++) {
-            const value = obj[i];
-            if (value !== undefined) {
-                clone[i] = cloneDeep(value, preserveUndefined);
-            }
-            else if (preserveUndefined) {
-                clone[i] = undefined;
-            }
-        }
-        return clone;
-    }
-    const clone = {};
-    const keys = Object.keys(obj);
-    for (let i = 0, len = keys.length; i < len; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (value !== undefined) {
-            clone[key] = cloneDeep(value, preserveUndefined);
-        }
-        else if (preserveUndefined) {
-            clone[key] = undefined;
-        }
-    }
-    return clone;
-}
-function get(obj, path, defaultValue) {
-    const keys = path.split(".");
-    let result = obj;
-    for (let i = 0, len = keys.length; i < len; i++) {
-        if (result == null) {
-            return defaultValue;
-        }
-        result = result[keys[i]];
-    }
-    return result ?? defaultValue;
-}