@cj-tech-master/excelts 1.6.3-canary.20251224193747.e89b618 → 1.6.3-canary.20251226035947.ef0b4f2

package/dist/esm/utils/unzip/zip-parser.js

@@ -427,6 +427,17 @@ export class ZipParser {
         }
         return result;
     }
+    /**
+     * Extract all files (sync, Node.js only)
+     * Returns object with file paths as keys and Uint8Array content as values
+     */
+    extractAllSync() {
+        const result = {};
+        for (const entry of this.entries) {
+            result[entry.path] = extractEntryDataSync(this.data, entry);
+        }
+        return result;
+    }
     /**
      * Iterate over entries with async callback
      */

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

@@ -4,6 +4,9 @@
  *
  * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
  * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ *
+ * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
+ * see deflate-fallback.ts for pure JS implementation
  */
 /**
  * Check if CompressionStream is available

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

@@ -1,12 +1,53 @@
 /**
- * Browser compression utilities using Web Streams API
+ * Browser compression utilities
  *
- * Uses CompressionStream API (Chrome 80+, Firefox 113+, Safari 16.4+)
- * with "deflate-raw" format (required for ZIP files)
+ * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
+ * Fallback: Pure JS DEFLATE implementation for older browsers
+ *
+ * Supported browsers with fallback:
+ * - Chrome >= 85
+ * - Firefox >= 79
+ * - Safari >= 14
+ * - Edge >= 85
+ */
+import { compressWithStream, decompressWithStream } from "./compress.base.js";
+import { inflateRaw, deflateRawCompressed, deflateRawStore } from "./deflate-fallback.js";
+// Re-export shared types
+export {};
+/**
+ * Check if CompressionStream with "deflate-raw" is available
+ * Note: Chrome 80-102 has CompressionStream but not deflate-raw support
+ */
+export function hasCompressionStream() {
+    if (typeof CompressionStream === "undefined") {
+        return false;
+    }
+    // Test if deflate-raw is supported (not just CompressionStream existence)
+    try {
+        new CompressionStream("deflate-raw");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Cache the detection result for performance
+let _hasDeflateRaw = null;
+/**
+ * Check if deflate-raw is supported, with caching for performance.
+ * The cache is bypassed if CompressionStream is undefined (for testing).
  */
-import { hasCompressionStream, compressWithStream, decompressWithStream } from "./compress.base.js";
-// Re-export shared types and utilities
-export { hasCompressionStream };
+function hasDeflateRawSupport() {
+    // If API doesn't exist, return false immediately (bypass cache for tests)
+    if (typeof CompressionStream === "undefined") {
+        return false;
+    }
+    // Use cached result for performance
+    if (_hasDeflateRaw === null) {
+        _hasDeflateRaw = hasCompressionStream();
+    }
+    return _hasDeflateRaw;
+}
 /**
  * Check if native zlib is available (always false in browser)
  */
@@ -14,7 +55,7 @@ export function hasNativeZlib() {
     return false;
 }
 /**
- * Compress data using browser's native CompressionStream
+ * Compress data using browser's native CompressionStream or JS fallback
  *
  * @param data - Data to compress
  * @param options - Compression options
@@ -28,49 +69,53 @@ export function hasNativeZlib() {
  */
 export async function compress(data, options = {}) {
     const level = options.level ?? 6;
-    // Level 0 means no compression
+    // Level 0 means no compression (STORE mode)
     if (level === 0) {
-        return data;
+        return deflateRawStore(data);
     }
-    // Use CompressionStream
-    if (typeof CompressionStream !== "undefined") {
+    // Use native CompressionStream if available
+    if (hasDeflateRawSupport()) {
         return compressWithStream(data);
     }
-    // No compression available - return original data
-    console.warn("No native compression available, returning uncompressed data");
-    return data;
+    // Fallback to pure JS implementation
+    return deflateRawCompressed(data);
 }
 /**
- * Compress data synchronously
- * Not available in browser - throws error
+ * Compress data synchronously using pure JS implementation
  *
- * @param _data - Data to compress
- * @param _options - Compression options
- * @throws Error always - sync compression not available in browser
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
  */
-export function compressSync(_data, _options = {}) {
-    throw new Error("Synchronous compression is not available in browser environment");
+export function compressSync(data, options = {}) {
+    const level = options.level ?? 6;
+    // Level 0 means no compression (STORE mode)
+    if (level === 0) {
+        return deflateRawStore(data);
+    }
+    // Pure JS implementation
+    return deflateRawCompressed(data);
 }
 /**
- * Decompress data using browser's native DecompressionStream
+ * Decompress data using browser's native DecompressionStream or JS fallback
  *
  * @param data - Compressed data (deflate-raw format)
  * @returns Decompressed data
  */
 export async function decompress(data) {
-    // Use DecompressionStream
-    if (typeof DecompressionStream !== "undefined") {
+    // Use native DecompressionStream if available
+    if (hasDeflateRawSupport()) {
         return decompressWithStream(data);
     }
-    throw new Error("No native decompression available in browser");
+    // Fallback to pure JS implementation
+    return inflateRaw(data);
 }
 /**
- * Decompress data synchronously
- * Not available in browser - throws error
+ * Decompress data synchronously using pure JS implementation
  *
- * @param _data - Compressed data
- * @throws Error always - sync decompression not available in browser
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
  */
-export function decompressSync(_data) {
-    throw new Error("Synchronous decompression is not available in browser environment");
+export function decompressSync(data) {
+    return inflateRaw(data);
 }