@openclaw/zalouser 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/pako/dist/pako.es5.js

@@ -1,5 +1,5 @@
 
-/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+/*! pako 2.2.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1365,7 +1365,7 @@
     Z_STREAM_END$3 = constants$2.Z_STREAM_END,
     Z_STREAM_ERROR$2 = constants$2.Z_STREAM_ERROR,
     Z_DATA_ERROR$2 = constants$2.Z_DATA_ERROR,
-    Z_BUF_ERROR$1 = constants$2.Z_BUF_ERROR,
+    Z_BUF_ERROR$2 = constants$2.Z_BUF_ERROR,
     Z_DEFAULT_COMPRESSION$1 = constants$2.Z_DEFAULT_COMPRESSION,
     Z_FILTERED = constants$2.Z_FILTERED,
     Z_HUFFMAN_ONLY = constants$2.Z_HUFFMAN_ONLY,
@@ -1462,13 +1462,36 @@
   };
 
   /* eslint-disable new-cap */
-  var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {
+  var HASH = function HASH(s, prev, data) {
     return (prev << s.hash_shift ^ data) & s.hash_mask;
   };
-  // This hash causes less collisions, https://github.com/nodeca/pako/issues/135
-  // But breaks binary compatibility
-  //let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;
-  var HASH = HASH_ZLIB;
+
+  /* ===========================================================================
+   * Insert string str in the dictionary and set match_head to the previous head
+   * of the hash chain (the most recent string with same hash key). Return
+   * the previous length of the hash chain.
+   * IN  assertion: all calls to INSERT_STRING are made with consecutive input
+   *    characters and the first MIN_MATCH bytes of str are valid (except for
+   *    the last MIN_MATCH-1 bytes of the input file).
+   */
+  var INSERT_STRING = function INSERT_STRING(s, str) {
+    var h;
+    if (s.legacy_hash) {
+      /* UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]); */
+      h = s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
+    } else {
+      // ANZAC++ hash: reads 4 bytes, matches node.js zlib output (legacyHash
+      // restores classic zlib hash). Faster, with fewer collisions.
+      var w = s.window;
+      // Read 4 bytes little-endian. Math.imul reproduces C uint32 overflow in
+      // `(value * 66521 + 66521) >> 16` exactly.
+      var value = w[str] | w[str + 1] << 8 | w[str + 2] << 16 | w[str + 3] << 24;
+      h = s.ins_h = Math.imul(value, 66521) + 66521 >>> 16 & s.hash_mask;
+    }
+    var hash_head = s.prev[str & s.w_mask] = s.head[h];
+    s.head[h] = str;
+    return hash_head;
+  };
 
   /* =========================================================================
    * Flush as much pending output as possible. All deflate() output, except for
@@ -1718,7 +1741,20 @@
       s.lookahead += n;
 
       /* Initialize the hash value now that we have some input: */
-      if (s.lookahead + s.insert >= MIN_MATCH) {
+      if (!s.legacy_hash) {
+        /* The 4-byte hash reads one extra byte, so it needs one more available. */
+        if (s.lookahead + s.insert > MIN_MATCH) {
+          str = s.strstart - s.insert;
+          while (s.insert) {
+            INSERT_STRING(s, str);
+            str++;
+            s.insert--;
+            if (s.lookahead + s.insert <= MIN_MATCH) {
+              break;
+            }
+          }
+        }
+      } else if (s.lookahead + s.insert >= MIN_MATCH) {
         str = s.strstart - s.insert;
         s.ins_h = s.window[str];
 
@@ -1728,10 +1764,7 @@
         //        Call update_hash() MIN_MATCH-3 more times
         //#endif
         while (s.insert) {
-          /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-          s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-          s.prev[str & s.w_mask] = s.head[s.ins_h];
-          s.head[s.ins_h] = str;
+          INSERT_STRING(s, str);
           str++;
           s.insert--;
           if (s.lookahead + s.insert < MIN_MATCH) {
@@ -2026,11 +2059,7 @@
        */
       hash_head = 0 /*NIL*/;
       if (s.lookahead >= MIN_MATCH) {
-        /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-        hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-        s.head[s.ins_h] = s.strstart;
-        /***/
+        hash_head = INSERT_STRING(s, s.strstart);
       }
 
       /* Find the longest match, discarding those <= prev_length.
@@ -2060,11 +2089,7 @@
           s.match_length--; /* string at strstart already in table */
           do {
             s.strstart++;
-            /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-            s.head[s.ins_h] = s.strstart;
-            /***/
+            hash_head = INSERT_STRING(s, s.strstart);
             /* strstart never exceeds WSIZE-MAX_MATCH, so there are
              * always MIN_MATCH bytes ahead.
              */
@@ -2073,16 +2098,18 @@
         } else {
           s.strstart += s.match_length;
           s.match_length = 0;
-          s.ins_h = s.window[s.strstart];
-          /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
-          s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);
-
-          //#if MIN_MATCH != 3
-          //                Call UPDATE_HASH() MIN_MATCH-3 more times
-          //#endif
-          /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
-           * matter since it will be recomputed at next deflate call.
-           */
+          if (s.legacy_hash) {
+            s.ins_h = s.window[s.strstart];
+            /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */
+            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]);
+
+            //#if MIN_MATCH != 3
+            //                Call UPDATE_HASH() MIN_MATCH-3 more times
+            //#endif
+            /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+             * matter since it will be recomputed at next deflate call.
+             */
+          }
         }
       } else {
         /* No match, output a literal byte */
@@ -2157,11 +2184,7 @@
        */
       hash_head = 0 /*NIL*/;
       if (s.lookahead >= MIN_MATCH) {
-        /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-        hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-        s.head[s.ins_h] = s.strstart;
-        /***/
+        hash_head = INSERT_STRING(s, s.strstart);
       }
 
       /* Find the longest match, discarding those <= prev_length.
@@ -2205,11 +2228,7 @@
         s.prev_length -= 2;
         do {
           if (++s.strstart <= max_insert) {
-            /*** INSERT_STRING(s, s.strstart, hash_head); ***/
-            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH - 1]);
-            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
-            s.head[s.ins_h] = s.strstart;
-            /***/
+            hash_head = INSERT_STRING(s, s.strstart);
           }
         } while (--s.prev_length !== 0);
         s.match_available = 0;
@@ -2518,6 +2537,7 @@
     this.head = null; /* Heads of the hash chains or NIL. */
 
     this.ins_h = 0; /* hash index of string to be inserted */
+    this.legacy_hash = 0; /* use classic zlib hash instead of default ANZAC++ */
     this.hash_size = 0; /* number of elements in hash table */
     this.hash_bits = 0; /* log2(hash_size) */
     this.hash_mask = 0; /* hash_size-1 */
@@ -2715,7 +2735,7 @@
     strm.state.gzhead = head;
     return Z_OK$3;
   };
-  var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
+  var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy, legacyHash) {
     if (!strm) {
       // === Z_NULL
       return Z_STREAM_ERROR$2;
@@ -2750,7 +2770,12 @@
     s.w_bits = windowBits;
     s.w_size = 1 << s.w_bits;
     s.w_mask = s.w_size - 1;
+    s.legacy_hash = legacyHash ? 1 : 0;
     s.hash_bits = memLevel + 7;
+    /* ANZAC++ hash needs >= 15 hash bits to span its 4 read bytes. */
+    if (!s.legacy_hash && s.hash_bits < 15) {
+      s.hash_bits = 15;
+    }
     s.hash_size = 1 << s.hash_bits;
     s.hash_mask = s.hash_size - 1;
     s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
@@ -2832,7 +2857,7 @@
     }
     var s = strm.state;
     if (!strm.output || strm.avail_in !== 0 && !strm.input || s.status === FINISH_STATE && flush !== Z_FINISH$3) {
-      return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
+      return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR$2 : Z_STREAM_ERROR$2);
     }
     var old_flush = s.last_flush;
     s.last_flush = flush;
@@ -2856,12 +2881,12 @@
        * returning Z_STREAM_END instead of Z_BUF_ERROR.
        */
     } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH$3) {
-      return err(strm, Z_BUF_ERROR$1);
+      return err(strm, Z_BUF_ERROR$2);
     }
 
     /* User must not provide more input after the first FINISH: */
     if (s.status === FINISH_STATE && strm.avail_in !== 0) {
-      return err(strm, Z_BUF_ERROR$1);
+      return err(strm, Z_BUF_ERROR$2);
     }
 
     /* Write the header */
@@ -3223,10 +3248,7 @@
       var str = s.strstart;
       var n = s.lookahead - (MIN_MATCH - 1);
       do {
-        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */
-        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH - 1]);
-        s.prev[str & s.w_mask] = s.head[s.ins_h];
-        s.head[s.ins_h] = str;
+        INSERT_STRING(s, str);
         str++;
       } while (--n);
       s.strstart = str;
@@ -3352,7 +3374,7 @@
   for (var q = 0; q < 256; q++) {
     _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
   }
-  _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
+  _utf8len[254] = _utf8len[255] = 1; // Invalid sequence start
 
   // convert string to array (typed, when possible)
   var string2buf = function string2buf(str) {
@@ -3582,6 +3604,16 @@
 
   /* ===========================================================================*/
 
+  var defaultOptions$1 = {
+    level: Z_DEFAULT_COMPRESSION,
+    method: Z_DEFLATED$1,
+    chunkSize: 16384,
+    windowBits: 15,
+    memLevel: 8,
+    strategy: Z_DEFAULT_STRATEGY,
+    legacyHash: true
+  };
+
   /**
    * class Deflate
    *
@@ -3635,6 +3667,10 @@
    * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
    * for more information on these.
    *
+   * - `legacyHash` (Boolean) - use the classic zlib hash (default), which matches
+   *   canonical zlib output byte-for-byte. Set to `false` to use the faster
+   *   ANZAC++ hash, which matches recent (chromium) node.js output instead.
+   *
    * Additional options, for internal needs:
    *
    * - `chunkSize` - size of generated data chunks (16K by default)
@@ -3667,14 +3703,7 @@
    * ```
    **/
   function Deflate$1(options) {
-    this.options = common.assign({
-      level: Z_DEFAULT_COMPRESSION,
-      method: Z_DEFLATED$1,
-      chunkSize: 16384,
-      windowBits: 15,
-      memLevel: 8,
-      strategy: Z_DEFAULT_STRATEGY
-    }, options || {});
+    this.options = common.assign({}, defaultOptions$1, options || {});
     var opt = this.options;
     if (opt.raw && opt.windowBits > 0) {
       opt.windowBits = -opt.windowBits;
@@ -3688,7 +3717,7 @@
 
     this.strm = new zstream();
     this.strm.avail_out = 0;
-    var status = deflate_1$2.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);
+    var status = deflate_1$2.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy, opt.legacyHash);
     if (status !== Z_OK$2) {
       throw new Error(messages[status]);
     }
@@ -4282,7 +4311,7 @@
   var lbase = new Uint16Array([/* Length codes 257..285 base */
   3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0]);
   var lext = new Uint8Array([/* Length codes 257..285 extra */
-  16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78]);
+  16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 75]);
   var dbase = new Uint16Array([/* Distance codes 0..29 base */
   1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0]);
   var dext = new Uint8Array([/* Distance codes 0..29 extra */
@@ -4605,7 +4634,7 @@
     Z_STREAM_ERROR$1 = constants$2.Z_STREAM_ERROR,
     Z_DATA_ERROR$1 = constants$2.Z_DATA_ERROR,
     Z_MEM_ERROR$1 = constants$2.Z_MEM_ERROR,
-    Z_BUF_ERROR = constants$2.Z_BUF_ERROR,
+    Z_BUF_ERROR$1 = constants$2.Z_BUF_ERROR,
     Z_DEFLATED = constants$2.Z_DEFLATED;
 
   /* STATES ====================================================================*/
@@ -4897,10 +4926,14 @@
 
     /* if it hasn't been done already, allocate space for the window */
     if (state.window === null) {
+      state.window = new Uint8Array(1 << state.wbits);
+    }
+
+    /* if window not in use yet, initialize */
+    if (state.wsize === 0) {
       state.wsize = 1 << state.wbits;
       state.wnext = 0;
       state.whave = 0;
-      state.window = new Uint8Array(state.wsize);
     }
 
     /* copy state->wsize or less output bytes into the circular window */
@@ -6104,7 +6137,7 @@
     }
     strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
     if ((_in === 0 && _out === 0 || flush === Z_FINISH$1) && ret === Z_OK$1) {
-      ret = Z_BUF_ERROR;
+      ret = Z_BUF_ERROR$1;
     }
     return ret;
   };
@@ -6272,10 +6305,17 @@
     Z_NEED_DICT = constants$2.Z_NEED_DICT,
     Z_STREAM_ERROR = constants$2.Z_STREAM_ERROR,
     Z_DATA_ERROR = constants$2.Z_DATA_ERROR,
-    Z_MEM_ERROR = constants$2.Z_MEM_ERROR;
+    Z_MEM_ERROR = constants$2.Z_MEM_ERROR,
+    Z_BUF_ERROR = constants$2.Z_BUF_ERROR;
 
   /* ===========================================================================*/
 
+  var defaultOptions = {
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ''
+  };
+
   /**
    * class Inflate
    *
@@ -6353,11 +6393,7 @@
    * ```
    **/
   function Inflate$1(options) {
-    this.options = common.assign({
-      chunkSize: 1024 * 64,
-      windowBits: 15,
-      to: ''
-    }, options || {});
+    this.options = common.assign({}, defaultOptions, options || {});
     var opt = this.options;
 
     // Force window size for `raw` data, if not set directly,
@@ -6473,8 +6509,16 @@
         }
       }
 
-      // Skip snyc markers if more data follows and not raw mode
-      while (strm.avail_in > 0 && status === Z_STREAM_END && strm.state.wrap > 0 && data[strm.next_in] !== 0) {
+      // Only the gzip format defines concatenated members (RFC 1952: a gzip file
+      // is "a series of members"). A zlib stream (RFC 1950) ends after its
+      // ADLER32, and a raw DEFLATE stream (RFC 1951) ends after its final block -
+      // neither format allows anything to follow, so bytes after the end are not
+      // ours to interpret and must be left in the input. Restart decoding only
+      // for a gzip member: `state.flags` is non-zero only once a gzip header has
+      // actually been decoded (it stays 0 for a zlib member, even when the format
+      // was auto-detected and the gzip bit of `wrap` is set). A trailing zero
+      // byte is padding, not the start of a member (no member can begin with 0).
+      while (strm.avail_in > 0 && status === Z_STREAM_END && strm.state.wrap & 2 && strm.state.flags !== 0 && strm.input[strm.next_in] !== 0) {
         inflate_1$2.inflateReset(strm);
         status = inflate_1$2.inflate(strm, _flush_mode);
       }
@@ -6492,7 +6536,9 @@
       // to align utf8 strings boundaries.
       last_avail_out = strm.avail_out;
       if (strm.next_out) {
-        if (strm.avail_out === 0 || status === Z_STREAM_END) {
+        // Flush output if buffer is full, stream ended, or an explicit flush was
+        // requested (e.g. Z_SYNC_FLUSH) - to push out the tail, same as node's zlib.
+        if (strm.avail_out === 0 || status === Z_STREAM_END || _flush_mode > 0) {
           if (this.options.to === 'string') {
             var next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
             var tail = strm.next_out - next_out_utf8;
@@ -6505,12 +6551,22 @@
             this.onData(utf8str);
           } else {
             this.onData(strm.output.length === strm.next_out ? strm.output : strm.output.subarray(0, strm.next_out));
+
+            // Force a fresh output buffer on next iteration / next push, so the
+            // already emitted tail is not sent again.
+            strm.avail_out = 0;
+            strm.next_out = 0;
           }
         }
       }
 
-      // Must repeat iteration if out buffer is full
-      if (status === Z_OK && last_avail_out === 0) continue;
+      // A full output buffer means there may be more to produce - allocate a new
+      // one and call inflate again. The status depends on the flush mode: with
+      // Z_NO_FLUSH a full buffer is reported as Z_OK, but with Z_FINISH the same
+      // situation is reported as Z_BUF_ERROR ("could not make progress now",
+      // non-fatal) even though output is still pending. Both must continue; the
+      // distinction that matters is purely "was the output buffer exhausted".
+      if ((status === Z_OK || status === Z_BUF_ERROR) && last_avail_out === 0) continue;
 
       // Finalize if end of stream reached.
       if (status === Z_STREAM_END) {
@@ -6519,7 +6575,23 @@
         this.ended = true;
         return true;
       }
-      if (strm.avail_in === 0) break;
+      if (strm.avail_in === 0) {
+        // Input is exhausted. If the caller declared this the end of the stream
+        // (Z_FINISH) but we never saw Z_STREAM_END, the compressed data ended
+        // before its terminating marker - i.e. it is truncated/incomplete. That
+        // is an error: returning the partial output as success would be
+        // indistinguishable from a complete decode, hiding the data loss. Report
+        // it via Z_BUF_ERROR. (Reached only when the output buffer still had room
+        // - a full buffer is handled by the `continue` above - so this genuinely
+        // means "ran out of input", not "ran out of output".)
+        if (_flush_mode === Z_FINISH) {
+          status = inflate_1$2.inflateEnd(this.strm);
+          this.onEnd(status === Z_OK ? Z_BUF_ERROR : status);
+          this.ended = true;
+          return false;
+        }
+        break;
+      }
     }
     return true;
   };
@@ -6600,7 +6672,7 @@
    **/
   function inflate$1(input, options) {
     var inflator = new Inflate$1(options);
-    inflator.push(input);
+    inflator.push(input, true);
 
     // That will never happens, if you don't cheat with options :)
     if (inflator.err) throw inflator.msg || messages[inflator.err];