@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/esm/utils/utils.js

@@ -0,0 +1,210 @@
+import fs from "fs";
+export function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function nop() { }
+export function promiseImmediate(value) {
+    return new Promise(resolve => {
+        if (global.setImmediate) {
+            setImmediate(() => {
+                resolve(value);
+            });
+        }
+        else {
+            // poorman's setImmediate - must wait at least 1ms
+            setTimeout(() => {
+                resolve(value);
+            }, 1);
+        }
+    });
+}
+// useful stuff
+export const inherits = function (cls, superCtor, statics, prototype) {
+    cls.super_ = superCtor;
+    if (!prototype) {
+        prototype = statics;
+        statics = null;
+    }
+    if (statics) {
+        Object.keys(statics).forEach(i => {
+            Object.defineProperty(cls, i, Object.getOwnPropertyDescriptor(statics, i));
+        });
+    }
+    const properties = {
+        constructor: {
+            value: cls,
+            enumerable: false,
+            writable: false,
+            configurable: true
+        }
+    };
+    if (prototype) {
+        Object.keys(prototype).forEach(i => {
+            properties[i] = Object.getOwnPropertyDescriptor(prototype, i);
+        });
+    }
+    cls.prototype = Object.create(superCtor.prototype, properties);
+};
+export function dateToExcel(d, date1904) {
+    return 25569 + d.getTime() / (24 * 3600 * 1000) - (date1904 ? 1462 : 0);
+}
+export function excelToDate(v, date1904) {
+    const millisecondSinceEpoch = Math.round((v - 25569 + (date1904 ? 1462 : 0)) * 24 * 3600 * 1000);
+    return new Date(millisecondSinceEpoch);
+}
+export function parsePath(filepath) {
+    const last = filepath.lastIndexOf("/");
+    return {
+        path: filepath.substring(0, last),
+        name: filepath.substring(last + 1)
+    };
+}
+export function getRelsPath(filepath) {
+    const path = parsePath(filepath);
+    return `${path.path}/_rels/${path.name}.rels`;
+}
+// oxlint-disable-next-line no-control-regex -- Control characters are intentionally matched for XML encoding
+const xmlDecodeRegex = /[<>&'"\x7F\x00-\x08\x0B-\x0C\x0E-\x1F]/;
+export function xmlEncode(text) {
+    const regexResult = xmlDecodeRegex.exec(text);
+    if (!regexResult) {
+        return text;
+    }
+    let result = "";
+    let escape = "";
+    let lastIndex = 0;
+    let i = regexResult.index;
+    for (; i < text.length; i++) {
+        const charCode = text.charCodeAt(i);
+        switch (charCode) {
+            case 34: // "
+                escape = "&quot;";
+                break;
+            case 38: // &
+                escape = "&amp;";
+                break;
+            case 39: // '
+                escape = "&apos;";
+                break;
+            case 60: // <
+                escape = "&lt;";
+                break;
+            case 62: // >
+                escape = "&gt;";
+                break;
+            case 127:
+                escape = "";
+                break;
+            default: {
+                if (charCode <= 31 && (charCode <= 8 || (charCode >= 11 && charCode !== 13))) {
+                    escape = "";
+                    break;
+                }
+                continue;
+            }
+        }
+        if (lastIndex !== i) {
+            result += text.substring(lastIndex, i);
+        }
+        lastIndex = i + 1;
+        if (escape) {
+            result += escape;
+        }
+    }
+    if (lastIndex !== i) {
+        return result + text.substring(lastIndex, i);
+    }
+    return result;
+}
+export function xmlDecode(text) {
+    return text.replace(/&([a-z]*);/g, c => {
+        switch (c) {
+            case "&lt;":
+                return "<";
+            case "&gt;":
+                return ">";
+            case "&amp;":
+                return "&";
+            case "&apos;":
+                return "'";
+            case "&quot;":
+                return '"';
+            default:
+                return c;
+        }
+    });
+}
+export function validInt(value) {
+    const i = parseInt(value, 10);
+    return !Number.isNaN(i) ? i : 0;
+}
+export function isDateFmt(fmt) {
+    if (!fmt) {
+        return false;
+    }
+    // must remove all chars inside quotes and []
+    fmt = fmt.replace(/\[[^\]]*]/g, "");
+    fmt = fmt.replace(/"[^"]*"/g, "");
+    // then check for date formatting chars
+    const result = fmt.match(/[ymdhMsb]+/) !== null;
+    return result;
+}
+export function fileExists(path) {
+    return new Promise(resolve => {
+        fs.access(path, fs.constants.F_OK, err => {
+            resolve(!err);
+        });
+    });
+}
+export function toIsoDateString(dt) {
+    return dt.toISOString().substr(0, 10);
+}
+export function parseBoolean(value) {
+    return value === true || value === "true" || value === 1 || value === "1";
+}
+export function* range(start, stop, step = 1) {
+    const compareOrder = step > 0 ? (a, b) => a < b : (a, b) => a > b;
+    for (let value = start; compareOrder(value, stop); value += step) {
+        yield value;
+    }
+}
+export function toSortedArray(values) {
+    const result = Array.from(values);
+    // Note: per default, `Array.prototype.sort()` converts values
+    // to strings when comparing. Here, if we have numbers, we use
+    // numeric sort.
+    if (result.every(item => Number.isFinite(item))) {
+        const compareNumbers = (a, b) => a - b;
+        return result.sort(compareNumbers);
+    }
+    return result.sort();
+}
+export function objectFromProps(props, value = null) {
+    return props.reduce((result, property) => {
+        result[property] = value;
+        return result;
+    }, {});
+}
+// Legacy export for backward compatibility
+/** @deprecated Import functions directly instead of using the utils object */
+export const utils = {
+    nop,
+    promiseImmediate,
+    inherits,
+    dateToExcel,
+    excelToDate,
+    parsePath,
+    getRelsPath,
+    xmlEncode,
+    xmlDecode,
+    validInt,
+    isDateFmt,
+    fs: {
+        exists: fileExists
+    },
+    toIsoDateString,
+    parseBoolean,
+    range,
+    toSortedArray,
+    objectFromProps
+};

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

@@ -0,0 +1,146 @@
+import { xmlEncode } from "./utils.js";
+// constants
+const OPEN_ANGLE = "<";
+const CLOSE_ANGLE = ">";
+const OPEN_ANGLE_SLASH = "</";
+const CLOSE_SLASH_ANGLE = "/>";
+function pushAttribute(xml, name, value) {
+    xml.push(` ${name}="${xmlEncode(value.toString())}"`);
+}
+function pushAttributes(xml, attributes) {
+    if (attributes) {
+        const tmp = [];
+        Object.entries(attributes).forEach(([name, value]) => {
+            if (value !== undefined) {
+                pushAttribute(tmp, name, value);
+            }
+        });
+        xml.push(tmp.join(""));
+    }
+}
+class XmlStream {
+    constructor() {
+        this._xml = [];
+        this._stack = [];
+        this._rollbacks = [];
+    }
+    get tos() {
+        return this._stack.length ? this._stack[this._stack.length - 1] : undefined;
+    }
+    get cursor() {
+        // handy way to track whether anything has been added
+        return this._xml.length;
+    }
+    openXml(docAttributes) {
+        const xml = this._xml;
+        // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        xml.push("<?xml");
+        pushAttributes(xml, docAttributes);
+        xml.push("?>\n");
+    }
+    openNode(name, attributes) {
+        const parent = this.tos;
+        const xml = this._xml;
+        if (parent && this.open) {
+            xml.push(CLOSE_ANGLE);
+        }
+        this._stack.push(name);
+        // start streaming node
+        xml.push(OPEN_ANGLE);
+        xml.push(name);
+        pushAttributes(xml, attributes);
+        this.leaf = true;
+        this.open = true;
+    }
+    addAttribute(name, value) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        if (value !== undefined) {
+            pushAttribute(this._xml, name, value);
+        }
+    }
+    addAttributes(attrs) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        pushAttributes(this._xml, attrs);
+    }
+    writeText(text) {
+        const xml = this._xml;
+        if (this.open) {
+            xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        xml.push(xmlEncode(text.toString()));
+    }
+    writeXml(xml) {
+        if (this.open) {
+            this._xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        this._xml.push(xml);
+    }
+    closeNode() {
+        const node = this._stack.pop();
+        const xml = this._xml;
+        if (this.leaf) {
+            xml.push(CLOSE_SLASH_ANGLE);
+        }
+        else {
+            xml.push(OPEN_ANGLE_SLASH);
+            xml.push(node);
+            xml.push(CLOSE_ANGLE);
+        }
+        this.open = false;
+        this.leaf = false;
+    }
+    leafNode(name, attributes, text) {
+        this.openNode(name, attributes);
+        if (text !== undefined) {
+            // zeros need to be written
+            this.writeText(text);
+        }
+        this.closeNode();
+    }
+    closeAll() {
+        while (this._stack.length) {
+            this.closeNode();
+        }
+    }
+    addRollback() {
+        this._rollbacks.push({
+            xml: this._xml.length,
+            stack: this._stack.length,
+            leaf: this.leaf,
+            open: this.open
+        });
+        return this.cursor;
+    }
+    commit() {
+        this._rollbacks.pop();
+    }
+    rollback() {
+        const r = this._rollbacks.pop();
+        if (this._xml.length > r.xml) {
+            this._xml.splice(r.xml, this._xml.length - r.xml);
+        }
+        if (this._stack.length > r.stack) {
+            this._stack.splice(r.stack, this._stack.length - r.stack);
+        }
+        this.leaf = r.leaf;
+        this.open = r.open;
+    }
+    get xml() {
+        this.closeAll();
+        return this._xml.join("");
+    }
+}
+XmlStream.StdDocAttributes = {
+    version: "1.0",
+    encoding: "UTF-8",
+    standalone: "yes"
+};
+export { XmlStream };

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

@@ -0,0 +1,117 @@
+import events from "events";
+import { Zip, ZipPassThrough } from "fflate";
+import { StreamBuf } from "./stream-buf.js";
+import { stringToBuffer } from "./browser-buffer-encode.js";
+import { isBrowser } from "./browser.js";
+// =============================================================================
+// The ZipWriter class
+// Packs streamed data into an output zip stream
+class ZipWriter extends events.EventEmitter {
+    constructor(options) {
+        super();
+        this.options = Object.assign({
+            type: "nodebuffer",
+            compression: "DEFLATE"
+        }, options);
+        this.files = {};
+        this.stream = new StreamBuf();
+        this.finalized = false;
+        // Create fflate Zip instance for streaming compression
+        this.zip = new Zip((err, data, final) => {
+            if (err) {
+                this.stream.emit("error", err);
+            }
+            else {
+                this.stream.write(Buffer.from(data));
+                if (final) {
+                    this.stream.end();
+                }
+            }
+        });
+    }
+    append(data, options) {
+        let buffer;
+        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
+            // Use Buffer.from for efficient base64 decoding
+            const base64Data = typeof data === "string" ? data : data.toString();
+            if (isBrowser) {
+                // Browser: use atob with optimized Uint8Array conversion
+                const binaryString = atob(base64Data);
+                const len = binaryString.length;
+                buffer = new Uint8Array(len);
+                // Use a single loop with cached length for better performance
+                for (let i = 0; i < len; i++) {
+                    buffer[i] = binaryString.charCodeAt(i);
+                }
+            }
+            else {
+                // Node.js: use efficient Buffer.from
+                buffer = Buffer.from(base64Data, "base64");
+            }
+        }
+        else {
+            if (typeof data === "string") {
+                // Convert string to Uint8Array
+                if (isBrowser) {
+                    buffer = stringToBuffer(data);
+                }
+                else {
+                    buffer = Buffer.from(data, "utf8");
+                }
+            }
+            else if (Buffer.isBuffer(data)) {
+                buffer = new Uint8Array(data);
+            }
+            else {
+                buffer = data;
+            }
+        }
+        // Add file to zip using streaming API
+        const zipFile = new ZipPassThrough(options.name);
+        this.zip.add(zipFile);
+        zipFile.push(buffer, true); // true = final chunk
+    }
+    push(chunk) {
+        return this.stream.push(chunk);
+    }
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        // End the zip stream
+        this.zip.end();
+        this.emit("finish");
+    }
+    // ==========================================================================
+    // Stream.Readable interface
+    read(size) {
+        return this.stream.read(size);
+    }
+    setEncoding(encoding) {
+        return this.stream.setEncoding(encoding);
+    }
+    pause() {
+        return this.stream.pause();
+    }
+    resume() {
+        return this.stream.resume();
+    }
+    isPaused() {
+        return this.stream.isPaused();
+    }
+    pipe(destination, options) {
+        return this.stream.pipe(destination, options);
+    }
+    unpipe(destination) {
+        return this.stream.unpipe(destination);
+    }
+    unshift(chunk) {
+        return this.stream.unshift(chunk);
+    }
+    wrap(stream) {
+        return this.stream.wrap(stream);
+    }
+}
+// =============================================================================
+export { ZipWriter };

package/dist/esm/xlsx/defaultnumformats.js

@@ -0,0 +1,149 @@
+const defaultNumFormats = {
+    0: { f: "General" },
+    1: { f: "0" },
+    2: { f: "0.00" },
+    3: { f: "#,##0" },
+    4: { f: "#,##0.00" },
+    9: { f: "0%" },
+    10: { f: "0.00%" },
+    11: { f: "0.00E+00" },
+    12: { f: "# ?/?" },
+    13: { f: "# ??/??" },
+    14: { f: "mm-dd-yy" },
+    15: { f: "d-mmm-yy" },
+    16: { f: "d-mmm" },
+    17: { f: "mmm-yy" },
+    18: { f: "h:mm AM/PM" },
+    19: { f: "h:mm:ss AM/PM" },
+    20: { f: "h:mm" },
+    21: { f: "h:mm:ss" },
+    22: { f: 'm/d/yy "h":mm' },
+    27: {
+        "zh-tw": "[$-404]e/m/d",
+        "zh-cn": 'yyyy"年"m"月"',
+        "ja-jp": "[$-411]ge.m.d",
+        "ko-kr": 'yyyy"年" mm"月" dd"日"'
+    },
+    28: {
+        "zh-tw": '[$-404]e"年"m"月"d"日"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": '[$-411]ggge"年"m"月"d"日"',
+        "ko-kr": "mm-dd"
+    },
+    29: {
+        "zh-tw": '[$-404]e"年"m"月"d"日"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": '[$-411]ggge"年"m"月"d"日"',
+        "ko-kr": "mm-dd"
+    },
+    30: { "zh-tw": "m/d/yy ", "zh-cn": "m-d-yy", "ja-jp": "m/d/yy", "ko-kr": "mm-dd-yy" },
+    31: {
+        "zh-tw": 'yyyy"年"m"月"d"日"',
+        "zh-cn": 'yyyy"年"m"月"d"日"',
+        "ja-jp": 'yyyy"年"m"月"d"日"',
+        "ko-kr": 'yyyy"년" mm"월" dd"일"'
+    },
+    32: {
+        "zh-tw": 'hh"時"mm"分"',
+        "zh-cn": 'h"时"mm"分"',
+        "ja-jp": 'h"時"mm"分"',
+        "ko-kr": 'h"시" mm"분"'
+    },
+    33: {
+        "zh-tw": 'hh"時"mm"分"ss"秒"',
+        "zh-cn": 'h"时"mm"分"ss"秒"',
+        "ja-jp": 'h"時"mm"分"ss"秒"',
+        "ko-kr": 'h"시" mm"분" ss"초"'
+    },
+    34: {
+        "zh-tw": '上午/下午 hh"時"mm"分"',
+        "zh-cn": '上午/下午 h"时"mm"分"',
+        "ja-jp": 'yyyy"年"m"月"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    35: {
+        "zh-tw": '上午/下午 hh"時"mm"分"ss"秒"',
+        "zh-cn": '上午/下午 h"时"mm"分"ss"秒"',
+        "ja-jp": 'm"月"d"日"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    36: {
+        "zh-tw": "[$-404]e/m/d",
+        "zh-cn": 'yyyy"年"m"月"',
+        "ja-jp": "[$-411]ge.m.d",
+        "ko-kr": 'yyyy"年" mm"月" dd"日"'
+    },
+    37: { f: "#,##0 ;(#,##0)" },
+    38: { f: "#,##0 ;[Red](#,##0)" },
+    39: { f: "#,##0.00 ;(#,##0.00)" },
+    40: { f: "#,##0.00 ;[Red](#,##0.00)" },
+    45: { f: "mm:ss" },
+    46: { f: "[h]:mm:ss" },
+    47: { f: "mmss.0" },
+    48: { f: "##0.0E+0" },
+    49: { f: "@" },
+    50: {
+        "zh-tw": "[$-404]e/m/d",
+        "zh-cn": 'yyyy"年"m"月"',
+        "ja-jp": "[$-411]ge.m.d",
+        "ko-kr": 'yyyy"年" mm"月" dd"日"'
+    },
+    51: {
+        "zh-tw": '[$-404]e"年"m"月"d"日"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": '[$-411]ggge"年"m"月"d"日"',
+        "ko-kr": "mm-dd"
+    },
+    52: {
+        "zh-tw": '上午/下午 hh"時"mm"分"',
+        "zh-cn": 'yyyy"年"m"月"',
+        "ja-jp": 'yyyy"年"m"月"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    53: {
+        "zh-tw": '上午/下午 hh"時"mm"分"ss"秒"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": 'm"月"d"日"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    54: {
+        "zh-tw": '[$-404]e"年"m"月"d"日"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": '[$-411]ggge"年"m"月"d"日"',
+        "ko-kr": "mm-dd"
+    },
+    55: {
+        "zh-tw": '上午/下午 hh"時"mm"分"',
+        "zh-cn": '上午/下午 h"时"mm"分"',
+        "ja-jp": 'yyyy"年"m"月"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    56: {
+        "zh-tw": '上午/下午 hh"時"mm"分"ss"秒"',
+        "zh-cn": '上午/下午 h"时"mm"分"ss"秒"',
+        "ja-jp": 'm"月"d"日"',
+        "ko-kr": "yyyy-mm-dd"
+    },
+    57: {
+        "zh-tw": "[$-404]e/m/d",
+        "zh-cn": 'yyyy"年"m"月"',
+        "ja-jp": "[$-411]ge.m.d",
+        "ko-kr": 'yyyy"年" mm"月" dd"日"'
+    },
+    58: {
+        "zh-tw": '[$-404]e"年"m"月"d"日"',
+        "zh-cn": 'm"月"d"日"',
+        "ja-jp": '[$-411]ggge"年"m"月"d"日"',
+        "ko-kr": "mm-dd"
+    },
+    59: { "th-th": "t0" },
+    60: { "th-th": "t0.00" },
+    61: { "th-th": "t#,##0" },
+    62: { "th-th": "t#,##0.00" },
+    67: { "th-th": "t0%" },
+    68: { "th-th": "t0.00%" },
+    69: { "th-th": "t# ?/?" },
+    70: { "th-th": "t# ??/??" },
+    81: { "th-th": "d/m/bb" }
+};
+export { defaultNumFormats };

package/dist/esm/xlsx/rel-type.js

@@ -0,0 +1,19 @@
+const RelType = {
+    OfficeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+    Worksheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+    CalcChain: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain",
+    SharedStrings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+    Styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+    Theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+    Hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+    Image: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+    CoreProperties: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+    ExtenderProperties: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+    Comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+    VmlDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing",
+    Table: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table",
+    PivotCacheDefinition: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
+    PivotCacheRecords: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords",
+    PivotTable: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable"
+};
+export { RelType };