@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

package/dist/esm/modules/stream/types.js

@@ -0,0 +1,7 @@
+/**
+ * Stream Module - Shared Types
+ *
+ * Common type definitions for stream operations across Node.js and Browser.
+ * These types provide a unified interface regardless of the underlying implementation.
+ */
+export {};

package/dist/esm/modules/stream/utils.js

@@ -0,0 +1,85 @@
+/**
+ * Stream Utilities
+ *
+ * Small, cross-platform helpers built on top of the platform stream
+ * implementation selected by `./streams` (Node.js or browser).
+ */
+import { createReadableFromArray, createTransform } from "./streams.js";
+import { stringToUint8Array as _stringToUint8Array, uint8ArrayToString as _uint8ArrayToString } from "./shared.js";
+// =============================================================================
+// High-Level Stream Consumers
+// =============================================================================
+export async function collect(stream) {
+    const result = [];
+    for await (const chunk of stream) {
+        result.push(chunk);
+    }
+    return result;
+}
+export async function text(stream) {
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    if (chunks.length === 1) {
+        return _uint8ArrayToString(chunks[0]);
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0, len = chunks.length; i < len; i++) {
+        const c = chunks[i];
+        result.set(c, offset);
+        offset += c.length;
+    }
+    return _uint8ArrayToString(result);
+}
+export async function json(stream) {
+    const str = await text(stream);
+    return JSON.parse(str);
+}
+export async function bytes(stream) {
+    const chunks = [];
+    let totalLength = 0;
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+        totalLength += chunk.length;
+    }
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (let i = 0, len = chunks.length; i < len; i++) {
+        const c = chunks[i];
+        result.set(c, offset);
+        offset += c.length;
+    }
+    return result;
+}
+// =============================================================================
+// Stream Factory Helpers
+// =============================================================================
+export function fromString(str) {
+    return createReadableFromArray([_stringToUint8Array(str)], {
+        objectMode: false
+    });
+}
+export function fromJSON(data) {
+    return fromString(JSON.stringify(data));
+}
+export function fromBytes(data) {
+    return createReadableFromArray([data], { objectMode: false });
+}
+export function transform(fn) {
+    return createTransform(fn);
+}
+export function filter(predicate) {
+    return createTransform(async (chunk) => {
+        if (await predicate(chunk)) {
+            return chunk;
+        }
+        return undefined;
+    }, { objectMode: true });
+}

package/dist/esm/utils/browser.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Prefer sibling `.browser.*` implementation when it exists.
+ *
+ * Example:
+ * - resolved: `/abs/path/to/streams.ts`
+ * - if `/abs/path/to/streams.browser.ts` exists => use it
+ */
+export function preferBrowserFilesPlugin() {
+    return {
+        name: "excelts-prefer-browser-files",
+        enforce: "pre",
+        async resolveId(source, importer) {
+            if (source.startsWith("\0") || source.startsWith("virtual:") || source.startsWith("node:")) {
+                return null;
+            }
+            const resolved = await this.resolve(source, importer, {
+                skipSelf: true
+            });
+            if (!resolved) {
+                return null;
+            }
+            if (typeof resolved === "object" && resolved.external) {
+                return resolved;
+            }
+            const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
+            if (typeof resolvedId !== "string") {
+                return resolved;
+            }
+            const cleanId = resolvedId.split("?")[0].split("#")[0];
+            if (!path.isAbsolute(cleanId)) {
+                return resolved;
+            }
+            if (cleanId.includes(".browser.")) {
+                return resolved;
+            }
+            const ext = path.extname(cleanId);
+            if (!ext || cleanId.endsWith(".d.ts")) {
+                return resolved;
+            }
+            const candidate = cleanId.slice(0, -ext.length) + ".browser" + ext;
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+            return resolved;
+        }
+    };
+}

package/dist/esm/utils/env.js

@@ -0,0 +1,18 @@
+/**
+ * Environment detection utilities
+ * Common functions to detect runtime environment (Node.js vs Browser)
+ */
+/**
+ * Check if running in Node.js environment
+ * Returns true if process.versions.node exists
+ */
+export function isNode() {
+    return typeof process !== "undefined" && !!process.versions?.node;
+}
+/**
+ * Check if running in browser environment
+ * Returns true if window and document are defined
+ */
+export function isBrowser() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+}

package/dist/esm/utils/utils.base.js

@@ -1,7 +1,29 @@
 /**
  * Base utility functions shared between Node.js and Browser
- * Platform-independent implementations only
+ * All functions use standard Web APIs that work in both environments
+ * (Node.js 16+ supports atob/btoa/TextEncoder/TextDecoder globally)
  */
+import { isNode } from "./env.js";
+// =============================================================================
+// Base64 utilities (with native Buffer optimization for Node.js)
+// =============================================================================
+/**
+ * Convert base64 string to Uint8Array
+ * Uses native Buffer in Node.js for better performance
+ */
+export function base64ToUint8Array(base64) {
+    // Node.js: use native Buffer (fast, C++ implementation)
+    if (isNode()) {
+        return Buffer.from(base64, "base64");
+    }
+    // Browser: use atob
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
 // =============================================================================
 // Basic utilities
 // =============================================================================
@@ -70,15 +92,78 @@ const xmlDecodingMap = {
     apos: "'"
 };
 export function xmlDecode(text) {
+    if (text.indexOf("&") === -1) {
+        return text;
+    }
     return text.replace(/&(#\d+|#x[0-9A-Fa-f]+|\w+);/g, (match, entity) => {
         if (entity[0] === "#") {
             // Numeric character reference
             const code = entity[1] === "x" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1));
+            if (Number.isNaN(code)) {
+                return match;
+            }
             return String.fromCodePoint(code);
         }
         return xmlDecodingMap[entity] || match;
     });
 }
+// oxlint-disable-next-line no-control-regex -- Control characters are intentionally matched for XML encoding
+const xmlEncodeRegex = /[<>&'"\x7F\x00-\x08\x0B-\x0C\x0E-\x1F]/;
+/**
+ * Encode special characters for XML output
+ * Handles XML entities (< > & " ') and removes invalid control characters
+ */
+export function xmlEncode(text) {
+    const regexResult = xmlEncodeRegex.exec(text);
+    if (!regexResult) {
+        return text;
+    }
+    const parts = [];
+    let lastIndex = 0;
+    for (let i = regexResult.index; i < text.length; i++) {
+        const charCode = text.charCodeAt(i);
+        let escape = null;
+        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))) {
+                    // Remove invalid control characters
+                    escape = "";
+                    break;
+                }
+                continue;
+            }
+        }
+        if (lastIndex !== i) {
+            parts.push(text.substring(lastIndex, i));
+        }
+        lastIndex = i + 1;
+        if (escape) {
+            parts.push(escape);
+        }
+    }
+    if (lastIndex < text.length) {
+        parts.push(text.substring(lastIndex));
+    }
+    return parts.join("");
+}
 // =============================================================================
 // Parsing utilities
 // =============================================================================
@@ -95,7 +180,7 @@ export function isDateFmt(fmt) {
         return false;
     }
     // must remove all chars inside quotes and []
-    let cleanFmt = fmt.replace(/\[[^\]]*]/g, "");
+    let cleanFmt = fmt.replace(/\[[^\]]*\]/g, "");
     cleanFmt = cleanFmt.replace(/"[^"]*"/g, "");
     // then check for date formatting chars
     return cleanFmt.match(/[ymdhMsb]+/) !== null;
@@ -130,6 +215,15 @@ export function objectFromProps(props, value = null) {
 // Buffer utilities (cross-platform)
 // =============================================================================
 const textDecoder = new TextDecoder("utf-8");
+let latin1Decoder;
+try {
+    // Faster base64 encoding path in browsers: decode bytes into a binary string once.
+    // Some environments may not support this encoding.
+    latin1Decoder = new TextDecoder("latin1");
+}
+catch {
+    latin1Decoder = undefined;
+}
 /**
  * Convert a Buffer, ArrayBuffer, or Uint8Array to a UTF-8 string
  * Works in both Node.js and browser environments
@@ -140,3 +234,42 @@ export function bufferToString(chunk) {
     }
     return textDecoder.decode(chunk);
 }
+/**
+ * Convert Uint8Array to base64 string
+ * Uses native Buffer in Node.js, optimized chunked conversion in browser
+ */
+export function uint8ArrayToBase64(bytes) {
+    if (isNode()) {
+        return Buffer.from(bytes).toString("base64");
+    }
+    // Browser: fastest path when latin1 TextDecoder exists.
+    // Some environments can still throw on `btoa(...)` (e.g. if decoding yields non-Latin1 chars),
+    // so fall back to a guaranteed-binary string conversion.
+    if (latin1Decoder) {
+        try {
+            return btoa(latin1Decoder.decode(bytes));
+        }
+        catch {
+            // fall through
+        }
+    }
+    // Browser: chunked String.fromCharCode.apply to avoid stack overflow and reduce string concatenation
+    const CHUNK_SIZE = 0x8000; // 32KB chunks
+    const chunks = [];
+    for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+        chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK_SIZE)));
+    }
+    return btoa(chunks.join(""));
+}
+/**
+ * Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
+ */
+export function stringToUtf16Le(str) {
+    const bytes = new Uint8Array(str.length * 2);
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        bytes[i * 2] = code & 0xff;
+        bytes[i * 2 + 1] = (code >> 8) & 0xff;
+    }
+    return bytes;
+}

package/dist/esm/utils/utils.browser.js

@@ -3,66 +3,10 @@
  * Re-exports shared utilities and adds browser-specific implementations
  */
 // Re-export all shared utilities
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base.js";
-// =============================================================================
-// XML encoding (Browser version with full Unicode support)
-// =============================================================================
-const xmlEncodingMap = {
-    "<": "&lt;",
-    ">": "&gt;",
-    "&": "&amp;",
-    '"': "&quot;",
-    "'": "&apos;"
-};
-export function xmlEncode(text) {
-    // Handles special characters:
-    // 1. XML entities: < > & " '
-    // 2. Control characters (0x00-0x1F except tab, newline, carriage return)
-    // 3. Invalid XML characters: 0xFFFE, 0xFFFF
-    // 4. Characters that need escaping in attributes
-    // First pass: escape XML entities
-    let result = text.replace(/[<>&"']/g, char => xmlEncodingMap[char] || char);
-    // Second pass: handle control characters and invalid XML characters
-    // Valid XML chars: #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
-    // oxlint-disable-next-line no-control-regex
-    result = result.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F\uFFFE\uFFFF]/g, char => {
-        const code = char.charCodeAt(0);
-        // For control characters, use numeric character reference
-        return `&#x${code.toString(16).toUpperCase()};`;
-    });
-    // Third pass: handle invalid surrogate pairs
-    result = result.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, () => "\uFFFD" // replacement character
-    );
-    return result;
-}
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
 // =============================================================================
 // File system utilities (Browser stub - always returns false)
 // =============================================================================
 export function fileExists(_path) {
     return Promise.resolve(false);
 }
-// =============================================================================
-// Legacy export for backward compatibility
-// =============================================================================
-import { nop, inherits, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base.js";
-/** @deprecated Import functions directly instead of using the utils object */
-export const utils = {
-    nop,
-    inherits,
-    dateToExcel,
-    excelToDate,
-    parsePath,
-    getRelsPath,
-    xmlEncode,
-    xmlDecode,
-    validInt,
-    isDateFmt,
-    fs: {
-        exists: fileExists
-    },
-    toIsoDateString,
-    parseBoolean,
-    range,
-    toSortedArray,
-    objectFromProps
-};

package/dist/esm/utils/utils.js

@@ -4,95 +4,16 @@
  */
 import fs from "fs";
 // Re-export all shared utilities
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base.js";
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
 // =============================================================================
-// XML encoding (Node.js optimized version)
+// File system utilities (Node.js only)
 // =============================================================================
-// 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;
-        }
+export async function fileExists(path) {
+    try {
+        await fs.promises.access(path, fs.constants.F_OK);
+        return true;
     }
-    if (lastIndex !== i) {
-        return result + text.substring(lastIndex, i);
+    catch {
+        return false;
     }
-    return result;
-}
-// =============================================================================
-// File system utilities (Node.js only)
-// =============================================================================
-export function fileExists(path) {
-    return new Promise(resolve => {
-        fs.access(path, fs.constants.F_OK, err => {
-            resolve(!err);
-        });
-    });
 }
-// =============================================================================
-// Legacy export for backward compatibility
-// =============================================================================
-import { nop, inherits, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base.js";
-/** @deprecated Import functions directly instead of using the utils object */
-export const utils = {
-    nop,
-    inherits,
-    dateToExcel,
-    excelToDate,
-    parsePath,
-    getRelsPath,
-    xmlEncode,
-    xmlDecode,
-    validInt,
-    isDateFmt,
-    fs: {
-        exists: fileExists
-    },
-    toIsoDateString,
-    parseBoolean,
-    range,
-    toSortedArray,
-    objectFromProps
-};

package/dist/esm/utils/uuid.js

@@ -0,0 +1,55 @@
+function toHex(byte) {
+    return byte.toString(16).padStart(2, "0");
+}
+function bytesToUuidV4(bytes) {
+    // RFC 4122, version 4 UUID
+    // Set version (4) and variant (10xx)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const b = bytes;
+    return (toHex(b[0]) +
+        toHex(b[1]) +
+        toHex(b[2]) +
+        toHex(b[3]) +
+        "-" +
+        toHex(b[4]) +
+        toHex(b[5]) +
+        "-" +
+        toHex(b[6]) +
+        toHex(b[7]) +
+        "-" +
+        toHex(b[8]) +
+        toHex(b[9]) +
+        "-" +
+        toHex(b[10]) +
+        toHex(b[11]) +
+        toHex(b[12]) +
+        toHex(b[13]) +
+        toHex(b[14]) +
+        toHex(b[15]));
+}
+/**
+ * Generate a UUID v4.
+ *
+ * This exists to avoid a hard dependency on `crypto.randomUUID()` so that
+ * older supported browsers can still generate UUIDs.
+ *
+ * - Prefers `crypto.randomUUID()` when available.
+ * - Falls back to `crypto.getRandomValues()`.
+ * - Last-resort fallback uses `Math.random()` (NOT cryptographically secure).
+ */
+export function uuidV4() {
+    const cryptoObj = globalThis.crypto;
+    if (cryptoObj?.randomUUID) {
+        return cryptoObj.randomUUID();
+    }
+    const bytes = new Uint8Array(16);
+    if (cryptoObj?.getRandomValues) {
+        cryptoObj.getRandomValues(bytes);
+        return bytesToUuidV4(bytes);
+    }
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return bytesToUuidV4(bytes);
+}