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

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

@@ -0,0 +1,65 @@
+// StringBuf - a way to keep string memory operations to a minimum
+// while building the strings for the xml files
+class StringBuf {
+    constructor(options) {
+        this._buf = Buffer.alloc((options && options.size) || 16384);
+        this._encoding = (options && options.encoding) || "utf8";
+        // where in the buffer we are at
+        this._inPos = 0;
+        // for use by toBuffer()
+        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 = Buffer.alloc(this.length);
+            this._buf.copy(this._buffer, 0, 0, this.length);
+        }
+        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 = Buffer.alloc(size);
+        this._buf.copy(buf, 0);
+        this._buf = buf;
+    }
+    addText(text) {
+        this._buffer = undefined;
+        let inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+        // if we've hit (or nearing capacity), grow the buf
+        while (inPos >= this._buf.length - 4) {
+            this._grow(this._inPos + text.length);
+            // keep trying to write until we've completely written the text
+            inPos = this._inPos + this._buf.write(text, this._inPos, this._encoding);
+        }
+        this._inPos = inPos;
+    }
+    addStringBuf(inBuf) {
+        if (inBuf.length) {
+            this._buffer = undefined;
+            if (this.length + inBuf.length > this.capacity) {
+                this._grow(this.length + inBuf.length);
+            }
+            inBuf._buf.copy(this._buf, this._inPos, 0, inBuf.length);
+            this._inPos += inBuf.length;
+        }
+    }
+}
+export { StringBuf };

package/dist/esm/utils/under-dash.js

@@ -0,0 +1,171 @@
+const { toString } = Object.prototype;
+const escapeHtmlRegex = /["&<>]/;
+export function isEqual(a, b) {
+    const aType = typeof a;
+    const bType = typeof b;
+    const aArray = Array.isArray(a);
+    const bArray = Array.isArray(b);
+    let keys;
+    if (aType !== bType) {
+        return false;
+    }
+    switch (typeof a) {
+        case "object":
+            if (aArray || bArray) {
+                if (aArray && bArray) {
+                    return (a.length === b.length &&
+                        a.every((aValue, index) => {
+                            const bValue = b[index];
+                            return isEqual(aValue, bValue);
+                        }));
+                }
+                return false;
+            }
+            if (a === null || b === null) {
+                return a === b;
+            }
+            // Compare object keys and values
+            keys = Object.keys(a);
+            if (Object.keys(b).length !== keys.length) {
+                return false;
+            }
+            for (const key of keys) {
+                if (!Object.prototype.hasOwnProperty.call(b, key)) {
+                    return false;
+                }
+            }
+            return keys.every(key => {
+                const aValue = a[key];
+                const bValue = b[key];
+                return isEqual(aValue, bValue);
+            });
+        default:
+            return a === b;
+    }
+}
+export function escapeHtml(html) {
+    const regexResult = escapeHtmlRegex.exec(html);
+    if (!regexResult) {
+        return html;
+    }
+    let result = "";
+    let escape = "";
+    let lastIndex = 0;
+    let i = regexResult.index;
+    for (; i < html.length; i++) {
+        switch (html.charAt(i)) {
+            case '"':
+                escape = "&quot;";
+                break;
+            case "&":
+                escape = "&amp;";
+                break;
+            case "<":
+                escape = "&lt;";
+                break;
+            case ">":
+                escape = "&gt;";
+                break;
+            default:
+                continue;
+        }
+        if (lastIndex !== i) {
+            result += html.substring(lastIndex, i);
+        }
+        lastIndex = i + 1;
+        result += escape;
+    }
+    if (lastIndex !== i) {
+        return result + html.substring(lastIndex, i);
+    }
+    return result;
+}
+export function isUndefined(val) {
+    return toString.call(val) === "[object Undefined]";
+}
+export function isObject(val) {
+    return toString.call(val) === "[object Object]";
+}
+export function deepMerge(...args) {
+    const target = args[0] || {};
+    const { length } = args;
+    let src, clone, copyIsArray;
+    function assignValue(val, key) {
+        src = target[key];
+        copyIsArray = Array.isArray(val);
+        if (isObject(val) || copyIsArray) {
+            if (copyIsArray) {
+                copyIsArray = false;
+                clone = src && Array.isArray(src) ? src : [];
+            }
+            else {
+                clone = src && isObject(src) ? src : {};
+            }
+            target[key] = deepMerge(clone, val);
+        }
+        else if (!isUndefined(val)) {
+            target[key] = val;
+        }
+    }
+    for (let i = 0; i < length; i++) {
+        const arg = args[i];
+        if (arg) {
+            if (Array.isArray(arg)) {
+                arg.forEach((val, index) => assignValue(val, index));
+            }
+            else {
+                Object.entries(arg).forEach(([key, val]) => {
+                    // Prevent prototype pollution
+                    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+                        return;
+                    }
+                    assignValue(val, key);
+                });
+            }
+        }
+    }
+    return target;
+}
+export function cloneDeep(obj, preserveUndefined) {
+    if (preserveUndefined === undefined) {
+        preserveUndefined = true;
+    }
+    let clone;
+    if (obj === null) {
+        return null;
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (obj instanceof Array) {
+        clone = [];
+        obj.forEach((value, index) => {
+            if (value !== undefined) {
+                clone[index] = cloneDeep(value, preserveUndefined);
+            }
+            else if (preserveUndefined) {
+                clone[index] = undefined;
+            }
+        });
+    }
+    else if (typeof obj === "object") {
+        clone = {};
+        Object.keys(obj).forEach(name => {
+            const value = obj[name];
+            if (value !== undefined) {
+                clone[name] = cloneDeep(value, preserveUndefined);
+            }
+            else if (preserveUndefined) {
+                clone[name] = undefined;
+            }
+        });
+    }
+    else {
+        return obj;
+    }
+    return clone;
+}
+export function get(obj, path, defaultValue) {
+    const keys = path.split(".");
+    return keys.reduce((result, key) => result?.[key], obj) ?? defaultValue;
+}

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/extract.js

@@ -0,0 +1,106 @@
+/**
+ * Simple ZIP extraction utilities
+ * Provides easy-to-use Promise-based API for extracting ZIP files
+ * Works in both Node.js and browser environments
+ */
+import { ZipParser } from "./zip-parser.js";
+/**
+ * Extract all files from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @returns Map of file paths to their content
+ *
+ * @example
+ * ```ts
+ * import { extractAll } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const files = await extractAll(zipData);
+ *
+ * for (const [path, file] of files) {
+ *   console.log(`${path}: ${file.data.length} bytes`);
+ * }
+ * ```
+ */
+export async function extractAll(zipData) {
+    const files = new Map();
+    const parser = new ZipParser(zipData);
+    for (const entry of parser.getEntries()) {
+        const data = await parser.extract(entry.path);
+        files.set(entry.path, {
+            path: entry.path,
+            data: data || new Uint8Array(0),
+            isDirectory: entry.isDirectory,
+            size: entry.uncompressedSize
+        });
+    }
+    return files;
+}
+/**
+ * Extract a single file from a ZIP buffer
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @param filePath - Path of the file to extract
+ * @returns File content as Uint8Array, or null if not found
+ *
+ * @example
+ * ```ts
+ * import { extractFile } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const content = await extractFile(zipData, "readme.txt");
+ * if (content) {
+ *   console.log(new TextDecoder().decode(content));
+ * }
+ * ```
+ */
+export async function extractFile(zipData, filePath) {
+    const parser = new ZipParser(zipData);
+    return parser.extract(filePath);
+}
+/**
+ * List all file paths in a ZIP buffer (without extracting content)
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @returns Array of file paths
+ *
+ * @example
+ * ```ts
+ * import { listFiles } from "./utils/unzip/extract.js";
+ *
+ * const zipData = fs.readFileSync("archive.zip");
+ * const paths = await listFiles(zipData);
+ * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
+ * ```
+ */
+export async function listFiles(zipData) {
+    const parser = new ZipParser(zipData);
+    return parser.listFiles();
+}
+/**
+ * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
+ *
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
+ * @param callback - Async callback for each entry, return false to stop iteration
+ *
+ * @example
+ * ```ts
+ * import { forEachEntry } from "./utils/unzip/extract.js";
+ *
+ * await forEachEntry(zipData, async (path, getData) => {
+ *   if (path.endsWith(".xml")) {
+ *     const content = await getData();
+ *     console.log(new TextDecoder().decode(content));
+ *   }
+ *   return true; // continue iteration
+ * });
+ * ```
+ */
+export async function forEachEntry(zipData, callback) {
+    const parser = new ZipParser(zipData);
+    await parser.forEach(async (entry, getData) => {
+        return callback(entry.path, getData, entry);
+    });
+}
+// Re-export ZipParser for advanced usage
+export { ZipParser } from "./zip-parser.js";

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

@@ -0,0 +1,29 @@
+/**
+ * Unzip utilities for parsing ZIP archives
+ *
+ * Two APIs are provided:
+ *
+ * 1. **Stream-based API** (Node.js only):
+ *    - `Parse`, `createParse` - Parse ZIP files as a stream
+ *    - Best for large files where you don't want to load entire file into memory
+ *    - Requires Node.js `stream` module
+ *
+ * 2. **Buffer-based API** (Browser + Node.js):
+ *    - `extractAll`, `extractFile`, `listFiles`, `forEachEntry`, `ZipParser`
+ *    - Works in both Node.js and browser environments
+ *    - Uses native `DecompressionStream` in browser, `zlib` in Node.js
+ *    - Best for files already loaded into memory (ArrayBuffer, Uint8Array)
+ *
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ */
+// Stream-based API (Node.js only - requires stream module)
+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";
+// Buffer-based API (Browser + Node.js - cross-platform)
+export { extractAll, extractFile, listFiles, forEachEntry, ZipParser } from "./extract.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;
+}