@cj-tech-master/excelts 1.0.0 → 1.4.0

package/dist/esm/utils/stream-buf.js

@@ -198,14 +198,24 @@ inherits(StreamBuf, Duplex, {
         if (data instanceof StringBuf || (data && data.constructor?.name === "StringBuf")) {
             chunk = new StringBufChunk(data);
         }
-        else if (data instanceof Buffer) {
+        else if (Buffer.isBuffer(data)) {
+            // Use Buffer.isBuffer() instead of instanceof for cross-realm compatibility
+            // (e.g., Web Workers where Buffer polyfill instances may differ)
             chunk = new BufferChunk(data);
         }
-        else if (typeof data === "string" || data instanceof String || data instanceof ArrayBuffer) {
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays (Uint8Array, Int8Array, etc.) - cross-realm safe
+            chunk = new BufferChunk(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer - convert to Buffer
+            chunk = new BufferChunk(Buffer.from(data));
+        }
+        else if (typeof data === "string" || data instanceof String) {
             chunk = new StringChunk(String(data), encoding);
         }
         else {
-            throw new Error("Chunk must be one of type String, Buffer or StringBuf.");
+            throw new Error("Chunk must be one of type String, Buffer, Uint8Array, ArrayBuffer or StringBuf.");
         }
         // now, do something with the chunk
         if (this.pipes.length) {
@@ -221,7 +231,8 @@ inherits(StreamBuf, Duplex, {
             }
             else {
                 this._writeToBuffers(chunk);
-                process.nextTick(callback);
+                // Use queueMicrotask for cross-platform compatibility (ES2020+)
+                queueMicrotask(() => callback());
             }
         }
         else {

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

@@ -0,0 +1,24 @@
+/**
+ * Unzipper buffer-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 { Transform } from "stream";
+export function bufferStream(entry) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const stream = new Transform({
+            transform(d, _encoding, cb) {
+                chunks.push(d);
+                cb();
+            }
+        });
+        stream.on("finish", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        stream.on("error", reject);
+        entry.on("error", reject).pipe(stream);
+    });
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Unzip utilities for parsing ZIP archives
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ */
+export { Parse, createParse } from "./parse.js";
+export { PullStream } from "./pull-stream.js";
+export { NoopStream } from "./noop-stream.js";
+export { bufferStream } from "./buffer-stream.js";
+export { parse as parseBuffer } from "./parse-buffer.js";
+export { parseDateTime } from "./parse-datetime.js";
+export { parseExtraField } from "./parse-extra-field.js";

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

@@ -0,0 +1,16 @@
+/**
+ * Unzipper noop-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 { Transform } from "stream";
+export class NoopStream extends Transform {
+    constructor() {
+        super();
+    }
+    _transform(_chunk, _encoding, cb) {
+        cb();
+    }
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Unzipper parse-buffer 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)
+ */
+function parseUIntLE(buffer, offset, size) {
+    let result;
+    switch (size) {
+        case 1:
+            result = buffer.readUInt8(offset);
+            break;
+        case 2:
+            result = buffer.readUInt16LE(offset);
+            break;
+        case 4:
+            result = buffer.readUInt32LE(offset);
+            break;
+        case 8:
+            result = Number(buffer.readBigUInt64LE(offset));
+            break;
+        default:
+            throw new Error("Unsupported UInt LE size!");
+    }
+    return result;
+}
+/**
+ * Parses sequential unsigned little endian numbers from the head of the passed buffer according to
+ * the specified format passed. If the buffer is not large enough to satisfy the full format,
+ * null values will be assigned to the remaining keys.
+ * @param buffer The buffer to sequentially extract numbers from.
+ * @param format Expected format to follow when extracting values from the buffer. A list of list entries
+ * with the following structure:
+ * [
+ *   [
+ *     <key>,  // Name of the key to assign the extracted number to.
+ *     <size>  // The size in bytes of the number to extract. possible values are 1, 2, 4, 8.
+ *   ],
+ *   ...
+ * ]
+ * @returns An object with keys set to their associated extracted values.
+ */
+export function parse(buffer, format) {
+    const result = {};
+    let offset = 0;
+    for (const [key, size] of format) {
+        if (buffer.length >= offset + size) {
+            result[key] = parseUIntLE(buffer, offset, size);
+        }
+        else {
+            result[key] = null;
+        }
+        offset += size;
+    }
+    return result;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Unzipper parse-datetime 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)
+ */
+/**
+ * Dates in zip file entries are stored as DosDateTime
+ * Spec is here: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+ */
+export function parseDateTime(date, time) {
+    const day = date & 0x1f;
+    const month = (date >> 5) & 0x0f;
+    const year = ((date >> 9) & 0x7f) + 1980;
+    const seconds = time ? (time & 0x1f) * 2 : 0;
+    const minutes = time ? (time >> 5) & 0x3f : 0;
+    const hours = time ? time >> 11 : 0;
+    return new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+}

package/dist/esm/utils/unzip/parse-extra-field.js

@@ -0,0 +1,49 @@
+/**
+ * Unzipper parse-extra-field 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 { parse } from "./parse-buffer.js";
+export function parseExtraField(extraField, vars) {
+    let extra;
+    // Find the ZIP64 header, if present.
+    while (!extra && extraField && extraField.length) {
+        const candidateExtra = parse(extraField, [
+            ["signature", 2],
+            ["partSize", 2]
+        ]);
+        if (candidateExtra.signature === 0x0001) {
+            // parse buffer based on data in ZIP64 central directory; order is important!
+            const fieldsToExpect = [];
+            if (vars.uncompressedSize === 0xffffffff) {
+                fieldsToExpect.push(["uncompressedSize", 8]);
+            }
+            if (vars.compressedSize === 0xffffffff) {
+                fieldsToExpect.push(["compressedSize", 8]);
+            }
+            if (vars.offsetToLocalFileHeader === 0xffffffff) {
+                fieldsToExpect.push(["offsetToLocalFileHeader", 8]);
+            }
+            // slice off the 4 bytes for signature and partSize
+            extra = parse(extraField.slice(4), fieldsToExpect);
+        }
+        else {
+            // Advance the buffer to the next part.
+            // The total size of this part is the 4 byte header + partsize.
+            extraField = extraField.slice((candidateExtra.partSize || 0) + 4);
+        }
+    }
+    extra = extra || {};
+    if (vars.compressedSize === 0xffffffff) {
+        vars.compressedSize = extra.compressedSize;
+    }
+    if (vars.uncompressedSize === 0xffffffff) {
+        vars.uncompressedSize = extra.uncompressedSize;
+    }
+    if (vars.offsetToLocalFileHeader === 0xffffffff) {
+        vars.offsetToLocalFileHeader = extra.offsetToLocalFileHeader;
+    }
+    return extra;
+}

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);
+}