@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102043356.6791d4e

package/dist/esm/utils/unzip/parse.js

@@ -1,332 +0,0 @@
-/**
- * Unzipper parse module
- * Original source: https://github.com/ZJONSSON/node-unzipper
- * License: MIT
- * Copyright (c) 2012 - 2013 Near Infinity Corporation
- * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
- */
-import zlib from "zlib";
-import { PassThrough, Transform, pipeline } from "stream";
-import { PullStream } from "./pull-stream.js";
-import { NoopStream } from "./noop-stream.js";
-import { bufferStream } from "./buffer-stream.js";
-import { parseExtraField } from "./parse-extra-field.js";
-import { parseDateTime } from "./parse-datetime.js";
-import { parse as parseBuffer } from "./parse-buffer.js";
-// Check if native zlib is available (Node.js environment)
-// In browser with polyfill, createInflateRaw may not exist or may not work properly
-const hasNativeZlib = typeof zlib?.createInflateRaw === "function" &&
-    typeof process !== "undefined" &&
-    process.versions?.node;
-/**
- * A Transform stream that wraps browser's native DecompressionStream.
- * Used when native zlib is not available (browser environment).
- */
-class BrowserInflateRawStream extends Transform {
-    constructor() {
-        super();
-        this.chunks = [];
-        this.totalLength = 0;
-    }
-    _transform(chunk, _encoding, callback) {
-        // Avoid unnecessary copy - Buffer extends Uint8Array
-        this.chunks.push(chunk);
-        this.totalLength += chunk.length;
-        callback();
-    }
-    _flush(callback) {
-        try {
-            // Use pre-calculated totalLength for better performance
-            const combined = new Uint8Array(this.totalLength);
-            let offset = 0;
-            for (const chunk of this.chunks) {
-                combined.set(chunk, offset);
-                offset += chunk.length;
-            }
-            // Clear chunks to free memory
-            this.chunks = [];
-            // Use native DecompressionStream
-            const ds = new DecompressionStream("deflate-raw");
-            const writer = ds.writable.getWriter();
-            const reader = ds.readable.getReader();
-            // Optimized read loop - collect chunks and concatenate at the end
-            const readAll = async () => {
-                const results = [];
-                let total = 0;
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
-                    }
-                    results.push(value);
-                    total += value.length;
-                }
-                // Single allocation for final result
-                const result = Buffer.allocUnsafe(total);
-                let off = 0;
-                for (const r of results) {
-                    result.set(r, off);
-                    off += r.length;
-                }
-                return result;
-            };
-            writer.write(combined);
-            writer.close();
-            readAll()
-                .then(decompressed => {
-                this.push(decompressed);
-                callback();
-            })
-                .catch(callback);
-        }
-        catch (err) {
-            callback(err);
-        }
-    }
-}
-/**
- * Creates an InflateRaw stream.
- * Uses native zlib in Node.js for best performance, falls back to DecompressionStream in browser.
- */
-function createInflateRaw() {
-    if (hasNativeZlib) {
-        return zlib.createInflateRaw();
-    }
-    return new BrowserInflateRawStream();
-}
-const endDirectorySignature = Buffer.alloc(4);
-endDirectorySignature.writeUInt32LE(0x06054b50, 0);
-export class Parse extends PullStream {
-    constructor(opts = {}) {
-        super();
-        this._opts = opts;
-        this.on("finish", () => {
-            this.emit("end");
-            this.emit("close");
-        });
-        this._readRecord().catch((e) => {
-            if (!this.__emittedError || this.__emittedError !== e) {
-                this.emit("error", e);
-            }
-        });
-    }
-    async _readRecord() {
-        const data = await this.pull(4);
-        if (data.length === 0) {
-            return;
-        }
-        const signature = data.readUInt32LE(0);
-        if (signature === 0x34327243) {
-            const shouldLoop = await this._readCrxHeader();
-            if (shouldLoop) {
-                return this._readRecord();
-            }
-            return;
-        }
-        if (signature === 0x04034b50) {
-            const shouldLoop = await this._readFile();
-            if (shouldLoop) {
-                return this._readRecord();
-            }
-            return;
-        }
-        else if (signature === 0x02014b50) {
-            this.reachedCD = true;
-            const shouldLoop = await this._readCentralDirectoryFileHeader();
-            if (shouldLoop) {
-                return this._readRecord();
-            }
-            return;
-        }
-        else if (signature === 0x06054b50) {
-            await this._readEndOfCentralDirectoryRecord();
-            return;
-        }
-        else if (this.reachedCD) {
-            // _readEndOfCentralDirectoryRecord expects the EOCD
-            // signature to be consumed so set includeEof=true
-            const includeEof = true;
-            await this.pull(endDirectorySignature, includeEof);
-            await this._readEndOfCentralDirectoryRecord();
-            return;
-        }
-        else {
-            this.emit("error", new Error("invalid signature: 0x" + signature.toString(16)));
-        }
-    }
-    async _readCrxHeader() {
-        const data = await this.pull(12);
-        this.crxHeader = parseBuffer(data, [
-            ["version", 4],
-            ["pubKeyLength", 4],
-            ["signatureLength", 4]
-        ]);
-        const keyAndSig = await this.pull((this.crxHeader.pubKeyLength || 0) + (this.crxHeader.signatureLength || 0));
-        this.crxHeader.publicKey = keyAndSig.slice(0, this.crxHeader.pubKeyLength || 0);
-        this.crxHeader.signature = keyAndSig.slice(this.crxHeader.pubKeyLength || 0);
-        this.emit("crx-header", this.crxHeader);
-        return true;
-    }
-    async _readFile() {
-        const data = await this.pull(26);
-        const vars = parseBuffer(data, [
-            ["versionsNeededToExtract", 2],
-            ["flags", 2],
-            ["compressionMethod", 2],
-            ["lastModifiedTime", 2],
-            ["lastModifiedDate", 2],
-            ["crc32", 4],
-            ["compressedSize", 4],
-            ["uncompressedSize", 4],
-            ["fileNameLength", 2],
-            ["extraFieldLength", 2]
-        ]);
-        vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate || 0, vars.lastModifiedTime || 0);
-        if (this.crxHeader) {
-            vars.crxHeader = this.crxHeader;
-        }
-        const fileNameBuffer = await this.pull(vars.fileNameLength || 0);
-        const fileName = fileNameBuffer.toString("utf8");
-        const entry = new PassThrough();
-        let __autodraining = false;
-        entry.autodrain = function () {
-            __autodraining = true;
-            const draining = entry.pipe(new NoopStream());
-            draining.promise = function () {
-                return new Promise((resolve, reject) => {
-                    draining.on("finish", resolve);
-                    draining.on("error", reject);
-                });
-            };
-            return draining;
-        };
-        entry.buffer = function () {
-            return bufferStream(entry);
-        };
-        entry.path = fileName;
-        entry.props = {
-            path: fileName,
-            pathBuffer: fileNameBuffer,
-            flags: {
-                isUnicode: ((vars.flags || 0) & 0x800) !== 0
-            }
-        };
-        entry.type = vars.uncompressedSize === 0 && /[/\\]$/.test(fileName) ? "Directory" : "File";
-        if (this._opts.verbose) {
-            if (entry.type === "Directory") {
-                console.log("   creating:", fileName);
-            }
-            else if (entry.type === "File") {
-                if (vars.compressionMethod === 0) {
-                    console.log(" extracting:", fileName);
-                }
-                else {
-                    console.log("  inflating:", fileName);
-                }
-            }
-        }
-        const extraFieldData = await this.pull(vars.extraFieldLength || 0);
-        const extra = parseExtraField(extraFieldData, vars);
-        entry.vars = vars;
-        entry.extra = extra;
-        if (this._opts.forceStream) {
-            this.push(entry);
-        }
-        else {
-            this.emit("entry", entry);
-            const state = this._readableState;
-            if (state.pipesCount || (state.pipes && state.pipes.length)) {
-                this.push(entry);
-            }
-        }
-        if (this._opts.verbose) {
-            console.log({
-                filename: fileName,
-                vars: vars,
-                extra: extra
-            });
-        }
-        const fileSizeKnown = !((vars.flags || 0) & 0x08) || vars.compressedSize > 0;
-        let eof;
-        entry.__autodraining = __autodraining; // expose __autodraining for test purposes
-        const inflater = vars.compressionMethod && !__autodraining ? createInflateRaw() : new PassThrough();
-        if (fileSizeKnown) {
-            entry.size = vars.uncompressedSize;
-            eof = vars.compressedSize;
-        }
-        else {
-            eof = Buffer.alloc(4);
-            eof.writeUInt32LE(0x08074b50, 0);
-        }
-        return new Promise((resolve, reject) => {
-            pipeline(this.stream(eof), inflater, entry, err => {
-                if (err) {
-                    return reject(err);
-                }
-                return fileSizeKnown
-                    ? resolve(fileSizeKnown)
-                    : this._processDataDescriptor(entry).then(resolve).catch(reject);
-            });
-        });
-    }
-    async _processDataDescriptor(entry) {
-        const data = await this.pull(16);
-        const vars = parseBuffer(data, [
-            ["dataDescriptorSignature", 4],
-            ["crc32", 4],
-            ["compressedSize", 4],
-            ["uncompressedSize", 4]
-        ]);
-        entry.size = vars.uncompressedSize || 0;
-        return true;
-    }
-    async _readCentralDirectoryFileHeader() {
-        const data = await this.pull(42);
-        const vars = parseBuffer(data, [
-            ["versionMadeBy", 2],
-            ["versionsNeededToExtract", 2],
-            ["flags", 2],
-            ["compressionMethod", 2],
-            ["lastModifiedTime", 2],
-            ["lastModifiedDate", 2],
-            ["crc32", 4],
-            ["compressedSize", 4],
-            ["uncompressedSize", 4],
-            ["fileNameLength", 2],
-            ["extraFieldLength", 2],
-            ["fileCommentLength", 2],
-            ["diskNumber", 2],
-            ["internalFileAttributes", 2],
-            ["externalFileAttributes", 4],
-            ["offsetToLocalFileHeader", 4]
-        ]);
-        await this.pull(vars.fileNameLength || 0);
-        await this.pull(vars.extraFieldLength || 0);
-        await this.pull(vars.fileCommentLength || 0);
-        return true;
-    }
-    async _readEndOfCentralDirectoryRecord() {
-        const data = await this.pull(18);
-        const vars = parseBuffer(data, [
-            ["diskNumber", 2],
-            ["diskStart", 2],
-            ["numberOfRecordsOnDisk", 2],
-            ["numberOfRecords", 2],
-            ["sizeOfCentralDirectory", 4],
-            ["offsetToStartOfCentralDirectory", 4],
-            ["commentLength", 2]
-        ]);
-        await this.pull(vars.commentLength || 0);
-        this.end();
-        this.push(null);
-    }
-    promise() {
-        return new Promise((resolve, reject) => {
-            this.on("finish", resolve);
-            this.on("error", reject);
-        });
-    }
-}
-export function createParse(opts) {
-    return new Parse(opts);
-}

package/dist/esm/utils/unzip/pull-stream.js

@@ -1,141 +0,0 @@
-/**
- * Unzipper pull-stream module
- * Original source: https://github.com/ZJONSSON/node-unzipper
- * License: MIT
- * Copyright (c) 2012 - 2013 Near Infinity Corporation
- * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
- */
-import { Duplex, PassThrough, Transform } from "stream";
-const STR_FUNCTION = "function";
-export class PullStream extends Duplex {
-    constructor() {
-        super({ decodeStrings: false, objectMode: true });
-        this.buffer = Buffer.from("");
-        this.finished = false;
-        this.on("finish", () => {
-            this.finished = true;
-            this.emit("chunk", false);
-        });
-    }
-    _write(chunk, _encoding, cb) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        this.cb = cb;
-        this.emit("chunk");
-    }
-    _read() { }
-    /**
-     * The `eof` parameter is interpreted as `file_length` if the type is number
-     * otherwise (i.e. buffer) it is interpreted as a pattern signaling end of stream
-     */
-    stream(eof, includeEof) {
-        const p = new PassThrough();
-        let done = false;
-        const cb = () => {
-            if (typeof this.cb === STR_FUNCTION) {
-                const callback = this.cb;
-                this.cb = undefined;
-                callback();
-            }
-        };
-        const pull = () => {
-            let packet;
-            if (this.buffer && this.buffer.length) {
-                if (typeof eof === "number") {
-                    packet = this.buffer.slice(0, eof);
-                    this.buffer = this.buffer.slice(eof);
-                    eof -= packet.length;
-                    done = done || !eof;
-                }
-                else {
-                    let match = this.buffer.indexOf(eof);
-                    if (match !== -1) {
-                        // store signature match byte offset to allow us to reference
-                        // this for zip64 offset
-                        this.match = match;
-                        if (includeEof) {
-                            match = match + eof.length;
-                        }
-                        packet = this.buffer.slice(0, match);
-                        this.buffer = this.buffer.slice(match);
-                        done = true;
-                    }
-                    else {
-                        const len = this.buffer.length - eof.length;
-                        if (len <= 0) {
-                            cb();
-                        }
-                        else {
-                            packet = this.buffer.slice(0, len);
-                            this.buffer = this.buffer.slice(len);
-                        }
-                    }
-                }
-                if (packet) {
-                    p.write(packet, () => {
-                        if (this.buffer.length === 0 ||
-                            (typeof eof !== "number" && eof.length && this.buffer.length <= eof.length)) {
-                            cb();
-                        }
-                    });
-                }
-            }
-            if (!done) {
-                if (this.finished) {
-                    this.removeListener("chunk", pull);
-                    this.emit("error", new Error("FILE_ENDED"));
-                    return;
-                }
-            }
-            else {
-                this.removeListener("chunk", pull);
-                p.end();
-            }
-        };
-        this.on("chunk", pull);
-        pull();
-        return p;
-    }
-    pull(eof, includeEof) {
-        if (eof === 0) {
-            return Promise.resolve(Buffer.from(""));
-        }
-        // If we already have the required data in buffer
-        // we can resolve the request immediately
-        if (typeof eof === "number" && this.buffer.length > eof) {
-            const data = this.buffer.slice(0, eof);
-            this.buffer = this.buffer.slice(eof);
-            return Promise.resolve(data);
-        }
-        // Otherwise we stream until we have it
-        let buffer = Buffer.from("");
-        const concatStream = new Transform({
-            transform(d, _e, cb) {
-                buffer = Buffer.concat([buffer, d]);
-                cb();
-            }
-        });
-        let rejectHandler;
-        let pullStreamRejectHandler;
-        return new Promise((resolve, reject) => {
-            rejectHandler = reject;
-            pullStreamRejectHandler = (e) => {
-                this.__emittedError = e;
-                reject(e);
-            };
-            if (this.finished) {
-                return reject(new Error("FILE_ENDED"));
-            }
-            this.once("error", pullStreamRejectHandler); // reject any errors from pullstream itself
-            this.stream(eof, includeEof)
-                .on("error", reject)
-                .pipe(concatStream)
-                .on("finish", () => {
-                resolve(buffer);
-            })
-                .on("error", reject);
-        }).finally(() => {
-            this.removeListener("error", rejectHandler);
-            this.removeListener("error", pullStreamRejectHandler);
-        });
-    }
-}