@cj-tech-master/excelts 4.2.0-canary.20260110034516.0919d4d → 4.2.0-canary.20260110111632.c88c61c

package/dist/browser/modules/archive/compress.base.d.ts

@@ -35,6 +35,7 @@ export interface CompressOptions {
  * Default threshold (in bytes) to choose the lower-overhead path.
  *
  * This is a performance knob, not a correctness requirement.
+ * Default: 8MB.
  */
 export declare const DEFAULT_COMPRESS_THRESHOLD_BYTES: number;
 /**

package/dist/browser/modules/archive/compress.base.js

@@ -13,6 +13,7 @@ import { ByteQueue } from "./byte-queue.js";
  * Default threshold (in bytes) to choose the lower-overhead path.
  *
  * This is a performance knob, not a correctness requirement.
+ * Default: 8MB.
  */
 export const DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
 /**

package/dist/browser/modules/archive/compress.browser.d.ts

@@ -22,6 +22,9 @@ export declare function hasCompressionStream(): boolean;
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *
+ * Note: We always prefer native CompressionStream when available because
+ * it's significantly faster than pure JS implementation.
+ *
  * @param data - Data to compress
  * @param options - Compression options
  * @returns Compressed data
@@ -44,7 +47,12 @@ export declare function compressSync(data: Uint8Array, options?: CompressOptions
 /**
  * Decompress data using browser's native DecompressionStream or JS fallback
  *
+ * Note: We always prefer native DecompressionStream when available because
+ * it's significantly faster than pure JS implementation, regardless of data size.
+ * The threshold is only useful for compression where the overhead matters more.
+ *
  * @param data - Compressed data (deflate-raw format)
+ * @param options - Decompression options (kept for API parity; currently unused in browser)
  * @returns Decompressed data
  */
 export declare function decompress(data: Uint8Array, options?: CompressOptions): Promise<Uint8Array>;

package/dist/browser/modules/archive/compress.browser.js

@@ -10,7 +10,7 @@
  * - Safari >= 14.1
  * - Edge >= 89
  */
-import { compressWithStream, decompressWithStream, hasDeflateRawCompressionStream, hasDeflateRawDecompressionStream, resolveCompressThresholdBytes } from "./compress.base.js";
+import { compressWithStream, decompressWithStream, hasDeflateRawCompressionStream, hasDeflateRawDecompressionStream } from "./compress.base.js";
 import { inflateRaw, deflateRawCompressed } from "./deflate-fallback.js";
 import { DEFAULT_COMPRESS_LEVEL } from "./defaults.js";
 // Re-export shared types
@@ -27,6 +27,9 @@ export function hasCompressionStream() {
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *
+ * Note: We always prefer native CompressionStream when available because
+ * it's significantly faster than pure JS implementation.
+ *
  * @param data - Data to compress
  * @param options - Compression options
  * @returns Compressed data
@@ -39,16 +42,15 @@ export function hasCompressionStream() {
  */
 export async function compress(data, options = {}) {
     const level = options.level ?? DEFAULT_COMPRESS_LEVEL;
-    const thresholdBytes = resolveCompressThresholdBytes(options);
     // Level 0 means no compression
     if (level === 0) {
         return data;
     }
-    // Use native CompressionStream only for larger inputs.
-    if (hasDeflateRawCompressionStream() && data.byteLength > thresholdBytes) {
+    // Always use native CompressionStream when available - it's much faster than JS
+    if (hasDeflateRawCompressionStream()) {
         return compressWithStream(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return deflateRawCompressed(data);
 }
 /**
@@ -70,16 +72,21 @@ export function compressSync(data, options = {}) {
 /**
  * Decompress data using browser's native DecompressionStream or JS fallback
  *
+ * Note: We always prefer native DecompressionStream when available because
+ * it's significantly faster than pure JS implementation, regardless of data size.
+ * The threshold is only useful for compression where the overhead matters more.
+ *
  * @param data - Compressed data (deflate-raw format)
+ * @param options - Decompression options (kept for API parity; currently unused in browser)
  * @returns Decompressed data
  */
 export async function decompress(data, options = {}) {
-    const thresholdBytes = resolveCompressThresholdBytes(options);
-    // Use native DecompressionStream only for larger inputs.
-    if (hasDeflateRawDecompressionStream() && data.byteLength > thresholdBytes) {
+    void options;
+    // Always use native DecompressionStream when available - it's much faster than JS
+    if (hasDeflateRawDecompressionStream()) {
         return decompressWithStream(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return inflateRaw(data);
 }
 /**

package/dist/browser/modules/archive/parse.base.d.ts

@@ -142,6 +142,17 @@ export declare function streamUntilValidatedDataDescriptor(options: StreamUntilV
 export interface ParseOptions {
     verbose?: boolean;
     forceStream?: boolean;
+    /**
+     * Threshold (in bytes) for small file optimization.
+     * Files smaller than this will use sync decompression (no stream overhead).
+     *
+     * Note: the optimization is only applied when the entry sizes are trusted
+     * (i.e. no data descriptor) and BOTH compressedSize and uncompressedSize
+     * are below this threshold. This avoids buffering huge highly-compressible
+     * files (e.g. large XML) in memory, which would defeat streaming.
+     * Default: 5MB
+     */
+    thresholdBytes?: number;
 }
 export interface EntryVars {
     versionsNeededToExtract: number | null;
@@ -195,4 +206,14 @@ export interface ParseEmitter {
     emitClose(): void;
 }
 export type InflateFactory = () => Transform | Duplex | PassThrough;
-export declare function runParseLoop(opts: ParseOptions, io: ParseIO, emitter: ParseEmitter, inflateFactory: InflateFactory, state: ParseDriverState): Promise<void>;
+/**
+ * Synchronous inflate function type for small file optimization.
+ * When provided and file size is below threshold, this will be used
+ * instead of streaming decompression for better performance.
+ */
+export type InflateRawSync = (data: Uint8Array) => Uint8Array;
+/**
+ * Default threshold for small file optimization (5MB).
+ */
+export declare const DEFAULT_PARSE_THRESHOLD_BYTES: number;
+export declare function runParseLoop(opts: ParseOptions, io: ParseIO, emitter: ParseEmitter, inflateFactory: InflateFactory, state: ParseDriverState, inflateRawSync?: InflateRawSync): Promise<void>;

package/dist/browser/modules/archive/parse.base.js

@@ -1,5 +1,5 @@
 import { parseDosDateTimeUTC, resolveZipLastModifiedDateFromUnixSeconds } from "./utils/timestamps.js";
-import { Duplex, PassThrough, Transform, concatUint8Arrays, pipeline } from "../stream/index.browser.js";
+import { Duplex, PassThrough, Transform, concatUint8Arrays, pipeline, finished } from "../stream/index.browser.js";
 import { parseTyped as parseBuffer } from "./utils/parse-buffer.js";
 import { ByteQueue } from "./byte-queue.js";
 import { indexOfUint8ArrayPattern } from "./utils/bytes.js";
@@ -499,8 +499,13 @@ export function streamUntilValidatedDataDescriptor(options) {
     queueMicrotask(pull);
     return output;
 }
+/**
+ * Default threshold for small file optimization (5MB).
+ */
+export const DEFAULT_PARSE_THRESHOLD_BYTES = 5 * 1024 * 1024;
 const endDirectorySignature = writeUint32LE(END_OF_CENTRAL_DIR_SIG);
-export async function runParseLoop(opts, io, emitter, inflateFactory, state) {
+export async function runParseLoop(opts, io, emitter, inflateFactory, state, inflateRawSync) {
+    const thresholdBytes = opts.thresholdBytes ?? DEFAULT_PARSE_THRESHOLD_BYTES;
     while (true) {
         const sigBytes = await io.pull(4);
         if (sigBytes.length === 0) {
@@ -514,7 +519,7 @@ export async function runParseLoop(opts, io, emitter, inflateFactory, state) {
             continue;
         }
         if (signature === LOCAL_FILE_HEADER_SIG) {
-            await readFileRecord(opts, io, emitter, inflateFactory, state);
+            await readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync);
             continue;
         }
         if (signature === CENTRAL_DIR_HEADER_SIG) {
@@ -543,7 +548,7 @@ export async function runParseLoop(opts, io, emitter, inflateFactory, state) {
         return;
     }
 }
-async function readFileRecord(opts, io, emitter, inflateFactory, state) {
+async function readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync) {
     const { vars: headerVars, fileNameBuffer, extraFieldData } = await readLocalFileHeader(async (l) => io.pull(l));
     const vars = headerVars;
     if (state.crxHeader) {
@@ -599,6 +604,35 @@ async function readFileRecord(opts, io, emitter, inflateFactory, state) {
             extraFields: entry.extraFields
         });
     }
+    // Small file optimization: use sync decompression if:
+    // 1. Entry sizes are trusted (no data descriptor)
+    // 2. File size is known and below threshold
+    // 3. inflateRawSync is provided
+    // 4. File needs decompression (compressionMethod != 0)
+    // 5. Not autodraining
+    //
+    // We require BOTH compressedSize and uncompressedSize <= thresholdBytes.
+    // This prevents materializing large highly-compressible files in memory,
+    // which can cause massive peak RSS and negate streaming backpressure.
+    const sizesTrusted = !hasDataDescriptorFlag(vars.flags);
+    const compressedSize = vars.compressedSize || 0;
+    const uncompressedSize = vars.uncompressedSize || 0;
+    const useSmallFileOptimization = sizesTrusted &&
+        fileSizeKnown &&
+        inflateRawSync &&
+        vars.compressionMethod !== 0 &&
+        !autodraining &&
+        compressedSize <= thresholdBytes &&
+        uncompressedSize <= thresholdBytes;
+    if (useSmallFileOptimization) {
+        // Read compressed data directly and decompress synchronously
+        const compressedData = await io.pull(compressedSize);
+        const decompressedData = inflateRawSync(compressedData);
+        entry.end(decompressedData);
+        // Wait for entry stream write to complete (not for read/consume)
+        await finished(entry, { readable: false });
+        return;
+    }
     const inflater = vars.compressionMethod && !autodraining ? inflateFactory() : new PassThrough();
     if (fileSizeKnown) {
         await pipeline(io.stream(vars.compressedSize || 0), inflater, entry);

package/dist/browser/modules/archive/parse.browser.js

@@ -341,7 +341,12 @@ export function createParseClass(createInflateRawFn) {
                 }
             };
             queueMicrotask(() => {
-                this._parsingDone = runParseLoop(this._opts, io, emitter, () => createInflateRawFn(), this._driverState);
+                // NOTE: We intentionally do NOT pass inflateRawSync to runParseLoop in browser.
+                // Browser's native DecompressionStream is faster than our pure-JS fallback,
+                // so we always use the streaming path for decompression in browsers.
+                this._parsingDone = runParseLoop(this._opts, io, emitter, () => createInflateRawFn(), this._driverState
+                // No inflateRawSync - always use streaming DecompressionStream in browser
+                );
                 this._parsingDone.catch((e) => {
                     if (!this.__emittedError || this.__emittedError !== e) {
                         this.__emittedError = e;

package/dist/browser/modules/archive/parse.js

@@ -50,7 +50,7 @@ export function createParseClass(createInflateRawFn) {
                 }
             };
             // Parse records as data arrives. Only emit `close` when parsing is complete.
-            runParseLoop(this._opts, io, emitter, createInflateRawFn, this._driverState).catch((e) => {
+            runParseLoop(this._opts, io, emitter, createInflateRawFn, this._driverState, (data) => zlib.inflateRawSync(data)).catch((e) => {
                 if (!this.__emittedError || this.__emittedError !== e) {
                     this.emit("error", e);
                 }

package/dist/browser/modules/excel/form-control.d.ts

@@ -42,6 +42,8 @@ export interface FormCheckboxModel {
     shapeId: number;
     /** Control property ID (rId in relationships) */
     ctrlPropId: number;
+    /** Relationship id (e.g., rId5) in sheet rels for ctrlProp (set during XLSX prepare) */
+    ctrlPropRelId?: string;
     /** Top-left anchor */
     tl: FormControlAnchor;
     /** Bottom-right anchor */

package/dist/browser/modules/excel/form-control.js

@@ -106,25 +106,63 @@ class FormCheckbox {
         let tl;
         let br;
         if (typeof range === "string") {
-            // Parse cell reference like "B2" or "B2:D3"
-            const decoded = colCache.decode(range);
-            if ("top" in decoded) {
-                // It's a range like "B2:D3"
-                tl = {
-                    col: decoded.left - 1, // Convert to 0-based
-                    colOff: DEFAULT_COL_OFF,
-                    row: decoded.top - 1,
-                    rowOff: DEFAULT_ROW_OFF
-                };
-                br = {
-                    col: decoded.right - 1,
-                    colOff: DEFAULT_END_COL_OFF,
-                    row: decoded.bottom - 1,
-                    rowOff: DEFAULT_END_ROW_OFF
-                };
+            // Parse cell reference like "B2" or range like "B2:D3"
+            const isRange = range.includes(":");
+            if (isRange) {
+                const decoded = colCache.decode(range);
+                if ("top" in decoded) {
+                    // Treat 1-cell ranges (e.g., "J4:J4") as a single cell with default checkbox size.
+                    if (decoded.left === decoded.right && decoded.top === decoded.bottom) {
+                        const col = decoded.left - 1;
+                        const row = decoded.top - 1;
+                        tl = {
+                            col,
+                            colOff: DEFAULT_COL_OFF,
+                            row,
+                            rowOff: DEFAULT_ROW_OFF
+                        };
+                        br = {
+                            col: col + 2,
+                            colOff: DEFAULT_END_COL_OFF,
+                            row: row + 1,
+                            rowOff: DEFAULT_END_ROW_OFF
+                        };
+                    }
+                    else {
+                        // Regular range
+                        tl = {
+                            col: decoded.left - 1, // Convert to 0-based
+                            colOff: DEFAULT_COL_OFF,
+                            row: decoded.top - 1,
+                            rowOff: DEFAULT_ROW_OFF
+                        };
+                        br = {
+                            col: decoded.right - 1,
+                            colOff: DEFAULT_END_COL_OFF,
+                            row: decoded.bottom - 1,
+                            rowOff: DEFAULT_END_ROW_OFF
+                        };
+                    }
+                }
+                else {
+                    // Defensive fallback: if the cache returns an address, treat it like a single-cell ref.
+                    tl = {
+                        col: decoded.col - 1,
+                        colOff: DEFAULT_COL_OFF,
+                        row: decoded.row - 1,
+                        rowOff: DEFAULT_ROW_OFF
+                    };
+                    br = {
+                        col: decoded.col + 1,
+                        colOff: DEFAULT_END_COL_OFF,
+                        row: decoded.row,
+                        rowOff: DEFAULT_END_ROW_OFF
+                    };
+                }
             }
             else {
                 // Single cell reference - create default size checkbox
+                const decoded = colCache.decodeAddress(range);
                 tl = {
                     col: decoded.col - 1,
                     colOff: DEFAULT_COL_OFF,

package/dist/browser/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -290,8 +290,10 @@ class WorkSheetXform extends BaseXform {
             for (const control of model.formControls) {
                 const globalCtrlPropId = options.formControlRefs.length + 1;
                 control.ctrlPropId = globalCtrlPropId;
+                const relId = nextRid(rels);
+                control.ctrlPropRelId = relId;
                 rels.push({
-                    Id: nextRid(rels),
+                    Id: relId,
                     Type: RelType.CtrlProp,
                     Target: ctrlPropRelTargetFromWorksheet(globalCtrlPropId)
                 });
@@ -354,15 +356,27 @@ class WorkSheetXform extends BaseXform {
         this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks/colBreaks
         this.map.picture.render(xmlStream, model.background); // Note: must be after drawing
         this.map.tableParts.render(xmlStream, model.tables);
-        this.map.extLst.render(xmlStream, model);
+        // Controls section for legacy form controls (checkboxes, etc.)
+        // Excel expects <controls> entries that reference ctrlProp relationships.
+        if (model.formControls && model.formControls.length > 0) {
+            xmlStream.openNode("controls");
+            for (const control of model.formControls) {
+                if (control.ctrlPropRelId) {
+                    xmlStream.leafNode("control", { shapeId: control.shapeId, "r:id": control.ctrlPropRelId });
+                }
+            }
+            xmlStream.closeNode();
+        }
         if (model.rels) {
-            // add a <legacyDrawing /> node for each comment
+            // Add a <legacyDrawing /> node for each VML drawing relationship (comments and/or form controls).
             model.rels.forEach(rel => {
                 if (rel.Type === RelType.VmlDrawing) {
                     xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
                 }
             });
         }
+        // extLst should be the last element in the worksheet.
+        this.map.extLst.render(xmlStream, model);
         xmlStream.closeNode();
     }
     parseOpen(node) {

package/dist/browser/modules/stream/streams.browser.d.ts

@@ -456,6 +456,8 @@ export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extend
      * Read from the transform stream
      */
     read(size?: number): TOutput | null;
+    /** @internal - list of piped destinations for forwarding auto-consumed data */
+    private _pipeDestinations;
     /**
      * Pipe to another stream (writable, transform, or duplex)
      */

package/dist/browser/modules/stream/streams.browser.js

@@ -384,55 +384,58 @@ export class Readable extends EventEmitter {
         // causing `instanceof Transform/Writable/Duplex` to fail even when the object
         // is a valid destination.
         const dest = destination;
-        // Get the actual writable target.
-        // Prefer internal `_writable` (Transform/Duplex wrappers), else treat the destination as writable-like.
-        const candidate = dest?._writable ?? dest;
-        const hasWrite = typeof candidate?.write === "function";
-        const hasEnd = typeof candidate?.end === "function";
-        const hasOn = typeof candidate?.on === "function";
-        const hasOnce = typeof candidate?.once === "function";
-        const hasOff = typeof candidate?.off === "function";
-        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !candidate?.removeListener)) {
+        // For event handling (drain, once, off), we need the object that emits events.
+        // For write/end, we must call the destination's own write()/end() methods,
+        // NOT the internal _writable, because Transform.write() has important logic
+        // (like auto-consume) that _writable.write() bypasses.
+        const eventTarget = dest;
+        const hasWrite = typeof dest?.write === "function";
+        const hasEnd = typeof dest?.end === "function";
+        const hasOn = typeof eventTarget?.on === "function";
+        const hasOnce = typeof eventTarget?.once === "function";
+        const hasOff = typeof eventTarget?.off === "function";
+        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !eventTarget?.removeListener)) {
             throw new Error("Readable.pipe: invalid destination");
         }
-        const target = candidate;
-        this._pipeTo.push(target);
+        this._pipeTo.push(dest);
         // Create listeners that we can later remove
         const dataListener = (chunk) => {
-            const canWrite = target.write(chunk);
+            // Call destination's write() method (not internal _writable.write())
+            // This ensures Transform.write() logic runs properly
+            const canWrite = dest.write(chunk);
             if (!canWrite) {
                 this.pause();
-                if (typeof target.once === "function") {
-                    target.once("drain", () => this.resume());
+                if (typeof eventTarget.once === "function") {
+                    eventTarget.once("drain", () => this.resume());
                 }
                 else {
                     const resumeOnce = () => {
-                        if (typeof target.off === "function") {
-                            target.off("drain", resumeOnce);
+                        if (typeof eventTarget.off === "function") {
+                            eventTarget.off("drain", resumeOnce);
                         }
-                        else if (typeof target.removeListener === "function") {
-                            target.removeListener("drain", resumeOnce);
+                        else if (typeof eventTarget.removeListener === "function") {
+                            eventTarget.removeListener("drain", resumeOnce);
                         }
                         this.resume();
                     };
-                    target.on("drain", resumeOnce);
+                    eventTarget.on("drain", resumeOnce);
                 }
             }
         };
         const endListener = () => {
-            target.end();
+            dest.end();
         };
         const errorListener = (err) => {
-            if (typeof target.destroy === "function") {
-                target.destroy(err);
+            if (typeof dest.destroy === "function") {
+                dest.destroy(err);
             }
             else {
                 // Best-effort: forward error to the destination if it supports events.
-                target.emit?.("error", err);
+                eventTarget.emit?.("error", err);
             }
         };
         // Store listeners for later removal in unpipe
-        this._pipeListeners.set(target, {
+        this._pipeListeners.set(dest, {
             data: dataListener,
             end: endListener,
             error: errorListener
@@ -1358,6 +1361,8 @@ export class Transform extends EventEmitter {
         this._autoConsumeEnded = false;
         /** @internal - promise that resolves when auto-consume finishes */
         this._autoConsumePromise = null;
+        /** @internal - list of piped destinations for forwarding auto-consumed data */
+        this._pipeDestinations = [];
         this.objectMode = options?.objectMode ?? false;
         const userTransform = options?.transform;
         const userFlush = options?.flush;
@@ -1624,10 +1629,18 @@ export class Transform extends EventEmitter {
                 for await (const chunk of this._readable) {
                     // Buffer the data for later retrieval
                     this._autoConsumedBuffer.push(chunk);
+                    // Forward to any piped destinations
+                    for (const dest of this._pipeDestinations) {
+                        dest.write(chunk);
+                    }
                     // Also emit data event for listeners
                     this.emit("data", chunk);
                 }
                 this._autoConsumeEnded = true;
+                // End all piped destinations
+                for (const dest of this._pipeDestinations) {
+                    dest.end();
+                }
                 this.emit("end");
             }
             catch (err) {
@@ -1677,8 +1690,28 @@ export class Transform extends EventEmitter {
      * Pipe to another stream (writable, transform, or duplex)
      */
     pipe(destination) {
-        // Mark as having consumer to prevent auto-consume conflict
+        // Mark as having consumer to prevent new auto-consume from starting
         this._hasDataConsumer = true;
+        // Get the writable target - handle both Transform (with internal _writable) and plain Writable
+        const dest = destination;
+        const target = dest?._writable ?? dest;
+        // Register destination for forwarding
+        this._pipeDestinations.push(target);
+        // If auto-consume is running or has run, we need to handle buffered data ourselves
+        if (this._readableConsuming) {
+            // Forward any buffered data from auto-consume to the destination
+            for (let i = 0; i < this._autoConsumedBuffer.length; i++) {
+                target.write(this._autoConsumedBuffer[i]);
+            }
+            // If auto-consume has ended, end the destination too
+            if (this._autoConsumeEnded) {
+                target.end();
+            }
+            // Don't call _readable.pipe() - auto-consume already consumed _readable
+            // Future data will be forwarded via the 'data' event listener below
+            return destination;
+        }
+        // No auto-consume running - use normal pipe through _readable
         return this._readable.pipe(destination);
     }
     /**

package/dist/cjs/modules/archive/compress.base.js

@@ -26,6 +26,7 @@ const byte_queue_1 = require("./byte-queue.js");
  * Default threshold (in bytes) to choose the lower-overhead path.
  *
  * This is a performance knob, not a correctness requirement.
+ * Default: 8MB.
  */
 exports.DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
 /**

package/dist/cjs/modules/archive/compress.browser.js

@@ -32,6 +32,9 @@ function hasCompressionStream() {
 /**
  * Compress data using browser's native CompressionStream or JS fallback
  *
+ * Note: We always prefer native CompressionStream when available because
+ * it's significantly faster than pure JS implementation.
+ *
  * @param data - Data to compress
  * @param options - Compression options
  * @returns Compressed data
@@ -44,16 +47,15 @@ function hasCompressionStream() {
  */
 async function compress(data, options = {}) {
     const level = options.level ?? defaults_1.DEFAULT_COMPRESS_LEVEL;
-    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
     // Level 0 means no compression
     if (level === 0) {
         return data;
     }
-    // Use native CompressionStream only for larger inputs.
-    if ((0, compress_base_1.hasDeflateRawCompressionStream)() && data.byteLength > thresholdBytes) {
+    // Always use native CompressionStream when available - it's much faster than JS
+    if ((0, compress_base_1.hasDeflateRawCompressionStream)()) {
         return (0, compress_base_1.compressWithStream)(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return (0, deflate_fallback_1.deflateRawCompressed)(data);
 }
 /**
@@ -75,16 +77,21 @@ function compressSync(data, options = {}) {
 /**
  * Decompress data using browser's native DecompressionStream or JS fallback
  *
+ * Note: We always prefer native DecompressionStream when available because
+ * it's significantly faster than pure JS implementation, regardless of data size.
+ * The threshold is only useful for compression where the overhead matters more.
+ *
  * @param data - Compressed data (deflate-raw format)
+ * @param options - Decompression options (kept for API parity; currently unused in browser)
  * @returns Decompressed data
  */
 async function decompress(data, options = {}) {
-    const thresholdBytes = (0, compress_base_1.resolveCompressThresholdBytes)(options);
-    // Use native DecompressionStream only for larger inputs.
-    if ((0, compress_base_1.hasDeflateRawDecompressionStream)() && data.byteLength > thresholdBytes) {
+    void options;
+    // Always use native DecompressionStream when available - it's much faster than JS
+    if ((0, compress_base_1.hasDeflateRawDecompressionStream)()) {
         return (0, compress_base_1.decompressWithStream)(data);
     }
-    // Fallback to pure JS implementation
+    // Fallback to pure JS implementation only when native is unavailable
     return (0, deflate_fallback_1.inflateRaw)(data);
 }
 /**