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

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

@@ -0,0 +1,332 @@
+/**
+ * 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

@@ -0,0 +1,141 @@
+/**
+ * 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);
+        });
+    }
+}