@leofcoin/chain 1.10.2 → 1.10.4

package/exports/browser/{constants-CUoFxEp2.js → constants-CVkCJ-VS.js}

@@ -1,144 +1,341 @@
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base = (ALPHABET) => {
-    if (ALPHABET.length >= 255) {
-        throw new TypeError('Alphabet too long');
-    }
-    const BASE_MAP = new Uint8Array(256);
-    for (let j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-    }
-    for (let i = 0; i < ALPHABET.length; i++) {
-        const x = ALPHABET.charAt(i);
-        const xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + ' is ambiguous');
-        }
-        BASE_MAP[xc] = i;
-    }
-    const BASE = ALPHABET.length;
-    const LEADER = ALPHABET.charAt(0);
-    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    const encode = (source) => {
-        if (source instanceof Uint8Array) ;
-        else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        }
-        else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-            throw new TypeError('Expected Uint8Array');
-        }
-        if (source.length === 0) {
-            return '';
-        }
-        // Skip & count leading zeroes.
-        let zeroes = 0;
-        let length = 0;
-        let pbegin = 0;
-        const pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-        }
-        // Allocate enough space in big-endian base58 representation.
-        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        const b58 = new Uint8Array(size);
-        // Process the bytes.
-        while (pbegin !== pend) {
-            let carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-            let i = 0;
-            for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-                carry += (256 * b58[it1]) >>> 0;
-                b58[it1] = (carry % BASE) >>> 0;
-                carry = (carry / BASE) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            pbegin++;
-        }
-        // Skip leading zeroes in base58 result.
-        let it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-            it2++;
-        }
-        // Translate the result into a string.
-        let str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-    };
-    const decodeUnsafe = (source) => {
-        if (typeof source !== 'string') {
-            throw new TypeError('Expected String');
-        }
-        if (source.length === 0) {
-            return new Uint8Array();
-        }
-        let psz = 0;
-        // Skip and count leading '1's.
-        let zeroes = 0;
-        let length = 0;
-        while (source[psz] === LEADER) {
-            zeroes++;
-            psz++;
-        }
-        // Allocate enough space in big-endian base256 representation.
-        const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-        let b256 = new Uint8Array(size);
-        // Process the characters.
-        while (source[psz]) {
-            // Decode character
-            let carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-            if (carry === 255) {
-                return;
-            }
-            let i = 0;
-            for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-                carry += (BASE * b256[it3]) >>> 0;
-                b256[it3] = (carry % 256) >>> 0;
-                carry = (carry / 256) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            psz++;
-        }
-        // Skip leading zeroes in b256.
-        let it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-            it4++;
-        }
-        let vch = new Uint8Array(zeroes + (size - it4));
-        let j = zeroes;
-        while (it4 !== size) {
-            vch[j++] = b256[it4++];
-        }
-        return vch;
-    };
-    const decode = (string) => {
-        const buffer = decodeUnsafe(string);
-        if (buffer) {
-            return buffer;
-        }
-        throw new Error('Non-base' + BASE + ' character');
-    };
-    return {
-        encode,
-        decodeUnsafe,
-        decode
-    };
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Copyright (c) 2026 Vandeuren Glenn
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+const base = (ALPHABET, options = {}) => {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError("Alphabet too long");
+    }
+    const BASE_MAP = new Uint8Array(256);
+    for (let j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (let i = 0; i < ALPHABET.length; i++) {
+        const x = ALPHABET.charAt(i);
+        const xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + " is ambiguous");
+        }
+        BASE_MAP[xc] = i;
+    }
+    const BASE = ALPHABET.length;
+    const LEADER = ALPHABET.charAt(0);
+    const LEADER_CODE = ALPHABET.charCodeAt(0);
+    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    // Optimization: If BASE is a power of 2, we can use bitwise operations
+    // This is much faster than the generic algorithm (approx 10x-20x)
+    const isPowerOfTwo = (BASE & (BASE - 1)) === 0;
+    if (isPowerOfTwo) {
+        const k = Math.log2(BASE);
+        const mask = (1 << k) - 1;
+        if (options.rfc4648) {
+            // RFC 4648 Mode
+            const encode = (source) => {
+                if (source instanceof Uint8Array) ;
+                else if (ArrayBuffer.isView(source)) {
+                    source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+                }
+                else if (Array.isArray(source)) {
+                    source = Uint8Array.from(source);
+                }
+                if (!(source instanceof Uint8Array)) {
+                    throw new TypeError("Expected Uint8Array");
+                }
+                if (source.length === 0) {
+                    return "";
+                }
+                let str = "";
+                let currentValue = 0;
+                let currentBits = 0;
+                for (let i = 0; i < source.length; i++) {
+                    currentValue = (currentValue << 8) | source[i];
+                    currentBits += 8;
+                    while (currentBits >= k) {
+                        currentBits -= k;
+                        str += ALPHABET.charAt((currentValue >>> currentBits) & mask);
+                    }
+                }
+                // Leftover bits (padding logic for the last character)
+                if (currentBits > 0) {
+                    str += ALPHABET.charAt((currentValue << (k - currentBits)) & mask);
+                }
+                // Add padding chars '=' if required
+                while ((str.length * k) % 8 !== 0) {
+                    str += "=";
+                }
+                return str;
+            };
+            const decodeUnsafe = (source) => {
+                if (typeof source !== "string") {
+                    throw new TypeError("Expected String");
+                }
+                if (source.length === 0) {
+                    return new Uint8Array();
+                }
+                // Strip padding
+                let end = source.length;
+                while (end > 0 && source[end - 1] === "=") {
+                    end--;
+                }
+                source = source.substring(0, end);
+                let currentValue = 0;
+                let currentBits = 0;
+                // Estimate size: source.length * k / 8
+                const buffer = new Uint8Array((source.length * k) >>> 3);
+                let ptr = 0;
+                for (let i = 0; i < source.length; i++) {
+                    const char = source.charCodeAt(i);
+                    const val = BASE_MAP[char];
+                    if (val === 255)
+                        return undefined;
+                    currentValue = (currentValue << k) | val;
+                    currentBits += k;
+                    if (currentBits >= 8) {
+                        currentBits -= 8;
+                        buffer[ptr++] = (currentValue >>> currentBits) & 0xff;
+                    }
+                }
+                return buffer;
+            };
+            const decode = (string) => {
+                const buffer = decodeUnsafe(string);
+                if (buffer)
+                    return buffer;
+                throw new Error("Non-base" + BASE + " character");
+            };
+            return { encode, decodeUnsafe, decode };
+        }
+        // Standard Mode (Bitwise)
+        const encode = (source) => {
+            if (source instanceof Uint8Array) ;
+            else if (ArrayBuffer.isView(source)) {
+                source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+            }
+            else if (Array.isArray(source)) {
+                source = Uint8Array.from(source);
+            }
+            if (!(source instanceof Uint8Array)) {
+                throw new TypeError("Expected Uint8Array");
+            }
+            if (source.length === 0) {
+                return "";
+            }
+            let zeroes = 0;
+            let pbegin = 0;
+            const pend = source.length;
+            while (pbegin !== pend && source[pbegin] === 0) {
+                pbegin++;
+                zeroes++;
+            }
+            let str = LEADER.repeat(zeroes);
+            if (pbegin === pend)
+                return str;
+            // Bitwise conversion
+            let currentValue = 0;
+            let currentBits = 0;
+            const totalBits = (pend - pbegin) * 8;
+            let remainder = totalBits % k;
+            // Handling the initial alignment to the most significant bits
+            // If total bits isn't divisible by k, the first digit uses 'remainder' bits
+            if (remainder === 0)
+                remainder = k; // effectively divisible, treating first k bits normally
+            let seenNonZero = false;
+            let firstChunk = true;
+            for (let i = pbegin; i < pend; i++) {
+                currentValue = (currentValue << 8) | source[i];
+                currentBits += 8;
+                while (currentBits >= k || (firstChunk && currentBits >= remainder)) {
+                    let bitsToExtract = k;
+                    if (firstChunk) {
+                        if (totalBits % k !== 0) {
+                            bitsToExtract = totalBits % k;
+                        }
+                        firstChunk = false;
+                    }
+                    const shift = currentBits - bitsToExtract;
+                    const digit = (currentValue >>> shift) & ((1 << bitsToExtract) - 1);
+                    currentBits -= bitsToExtract;
+                    if (seenNonZero || digit !== 0) {
+                        str += ALPHABET.charAt(digit);
+                        seenNonZero = true;
+                    }
+                }
+            }
+            return str;
+        };
+        const decodeUnsafe = (source) => {
+            if (typeof source !== "string") {
+                throw new TypeError("Expected String");
+            }
+            if (source.length === 0) {
+                return new Uint8Array();
+            }
+            let psz = 0;
+            let zeroes = 0;
+            while (source.charCodeAt(psz) === LEADER_CODE) {
+                zeroes++;
+                psz++;
+            }
+            // Accumulate bits
+            // We must handle alignment.
+            const length = source.length - psz;
+            const totalBits = length * k;
+            let currentBits = (8 - (totalBits % 8)) % 8; // align to byte boundary
+            const result = new Uint8Array((totalBits + 7) >>> 3); // (totalBits + 7) / 8
+            let rIdx = 0;
+            let currentValue = 0;
+            for (let i = psz; i < source.length; i++) {
+                const char = source.charCodeAt(i);
+                const val = BASE_MAP[char];
+                if (val === 255)
+                    return;
+                currentValue = (currentValue << k) | val;
+                currentBits += k;
+                if (currentBits >= 8) {
+                    const shift = currentBits - 8;
+                    result[rIdx++] = (currentValue >>> shift) & 0xff;
+                    currentBits -= 8;
+                    // Keep only the remaining bits to avoid overflow
+                    currentValue &= (1 << currentBits) - 1;
+                }
+            }
+            // Skip leading zeroes in result buffer
+            let skip = 0;
+            while (skip < rIdx && result[skip] === 0) {
+                skip++;
+            }
+            // Combine with zeroes
+            const final = new Uint8Array(zeroes + (rIdx - skip));
+            // zeroes are 0, so just copy result
+            final.set(result.subarray(skip, rIdx), zeroes);
+            return final;
+        };
+        const decode = (string) => {
+            const buffer = decodeUnsafe(string);
+            if (buffer)
+                return buffer;
+            throw new Error("Non-base" + BASE + " character");
+        };
+        return { encode, decodeUnsafe, decode };
+    }
+    const encode = (source) => {
+        if (source instanceof Uint8Array) ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError("Expected Uint8Array");
+        }
+        if (source.length === 0) {
+            return "";
+        }
+        // Skip & count leading zeroes.
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        const b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            let carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            let i = 0;
+            for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+                carry += (b58[it1] << 8) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error("Non-zero carry");
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        let str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    };
+    const decodeUnsafe = (source) => {
+        if (typeof source !== "string") {
+            throw new TypeError("Expected String");
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        let psz = 0;
+        // Skip and count leading '1's.
+        let zeroes = 0;
+        let length = 0;
+        while (source.charCodeAt(psz) === LEADER_CODE) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        const size = ((source.length - psz) * FACTOR + 1) >>> 0; // log(58) / log(256), rounded up.
+        let b256 = new Uint8Array(size);
+        // Process the characters.
+        for (; psz < source.length; psz++) {
+            // Decode character
+            let carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            let i = 0;
+            for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry & 0xff) >>> 0;
+                carry = (carry >> 8) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error("Non-zero carry");
+            }
+            length = i;
+        }
+        // Skip leading zeroes in b256.
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        let vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    };
+    const decode = (string) => {
+        const buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error("Non-base" + BASE + " character");
+    };
+    return {
+        encode,
+        decodeUnsafe,
+        decode,
+    };
 };
 
 const ALPHABET$3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
@@ -325,7 +522,7 @@ var index$3 = (input, prefix) => {
     return typedArray;
 };
 
-/*! 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) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
 //
@@ -1747,7 +1944,7 @@ const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = tr
 
 const {
   Z_NO_FLUSH: Z_NO_FLUSH$2, Z_PARTIAL_FLUSH, Z_FULL_FLUSH: Z_FULL_FLUSH$1, Z_FINISH: Z_FINISH$3, Z_BLOCK: Z_BLOCK$1,
-  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$1,
+  Z_OK: Z_OK$3, Z_STREAM_END: Z_STREAM_END$3, Z_STREAM_ERROR: Z_STREAM_ERROR$2, Z_DATA_ERROR: Z_DATA_ERROR$2, Z_BUF_ERROR: Z_BUF_ERROR$2,
   Z_DEFAULT_COMPRESSION: Z_DEFAULT_COMPRESSION$1,
   Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED, Z_DEFAULT_STRATEGY: Z_DEFAULT_STRATEGY$1,
   Z_UNKNOWN,
@@ -1846,11 +2043,35 @@ const slide_hash = (s) => {
 };
 
 /* eslint-disable new-cap */
-let HASH_ZLIB = (s, prev, data) => ((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;
-let HASH = HASH_ZLIB;
+let HASH = (s, prev, data) => ((prev << s.hash_shift) ^ data) & s.hash_mask;
+
+
+/* ===========================================================================
+ * 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).
+ */
+const INSERT_STRING = (s, str) => {
+  let 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.
+    const w = s.window;
+    // Read 4 bytes little-endian. Math.imul reproduces C uint32 overflow in
+    // `(value * 66521 + 66521) >> 16` exactly.
+    const 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;
+  }
+  const hash_head = s.prev[str & s.w_mask] = s.head[h];
+  s.head[h] = str;
+  return hash_head;
+};
 
 
 /* =========================================================================
@@ -2124,7 +2345,20 @@ const fill_window = (s) => {
     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];
 
@@ -2134,11 +2368,7 @@ const fill_window = (s) => {
 //        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) {
@@ -2436,11 +2666,7 @@ const deflate_fast = (s, flush) => {
      */
     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.
@@ -2470,11 +2696,7 @@ const deflate_fast = (s, flush) => {
         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.
            */
@@ -2484,16 +2706,18 @@ const deflate_fast = (s, flush) => {
       {
         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 (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.
-         */
+          /* 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 */
@@ -2566,11 +2790,7 @@ const deflate_slow = (s, flush) => {
      */
     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.
@@ -2618,11 +2838,7 @@ const deflate_slow = (s, flush) => {
       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;
@@ -2947,6 +3163,7 @@ function DeflateState() {
   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 */
@@ -3169,7 +3386,7 @@ const deflateSetHeader = (strm, head) => {
 };
 
 
-const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
+const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy, legacyHash) => {
 
   if (!strm) { // === Z_NULL
     return Z_STREAM_ERROR$2;
@@ -3215,7 +3432,13 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
   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);
@@ -3307,7 +3530,7 @@ const deflate$2 = (strm, flush) => {
   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);
   }
 
   const old_flush = s.last_flush;
@@ -3333,12 +3556,12 @@ const deflate$2 = (strm, flush) => {
      */
   } 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 */
@@ -3719,12 +3942,7 @@ const deflateSetDictionary = (strm, dictionary) => {
     let str = s.strstart;
     let 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;
@@ -3848,7 +4066,7 @@ const _utf8len = new Uint8Array(256);
 for (let 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)
@@ -4069,6 +4287,15 @@ const {
 
 /* ===========================================================================*/
 
+const defaultOptions$1 = {
+  level: Z_DEFAULT_COMPRESSION,
+  method: Z_DEFLATED$1,
+  chunkSize: 16384,
+  windowBits: 15,
+  memLevel: 8,
+  strategy: Z_DEFAULT_STRATEGY,
+  legacyHash: true
+};
 
 /**
  * class Deflate
@@ -4124,6 +4351,10 @@ const {
  * [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)
@@ -4156,14 +4387,7 @@ const {
  * ```
  **/
 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 || {});
 
   let opt = this.options;
 
@@ -4189,7 +4413,8 @@ function Deflate$1(options) {
     opt.method,
     opt.windowBits,
     opt.memLevel,
-    opt.strategy
+    opt.strategy,
+    opt.legacyHash
   );
 
   if (status !== Z_OK$2) {
@@ -4809,7 +5034,7 @@ const lbase = new Uint16Array([ /* Length codes 257..285 base */
 
 const 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
+  19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 75
 ]);
 
 const dbase = new Uint16Array([ /* Distance codes 0..29 base */
@@ -5146,7 +5371,7 @@ const DISTS = 2;
 
 const {
   Z_FINISH: Z_FINISH$1, Z_BLOCK, Z_TREES,
-  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR,
+  Z_OK: Z_OK$1, Z_STREAM_END: Z_STREAM_END$1, Z_NEED_DICT: Z_NEED_DICT$1, Z_STREAM_ERROR: Z_STREAM_ERROR$1, Z_DATA_ERROR: Z_DATA_ERROR$1, Z_MEM_ERROR: Z_MEM_ERROR$1, Z_BUF_ERROR: Z_BUF_ERROR$1,
   Z_DEFLATED
 } = constants$2;
 
@@ -5456,11 +5681,14 @@ const updatewindow = (strm, src, end, copy) => {
 
   /* 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 */
@@ -6586,7 +6814,7 @@ const inflate$2 = (strm, flush) => {
                     (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;
 };
@@ -6758,11 +6986,16 @@ const toString$2 = Object.prototype.toString;
 
 const {
   Z_NO_FLUSH, Z_FINISH,
-  Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR
+  Z_OK, Z_STREAM_END, Z_NEED_DICT, Z_STREAM_ERROR, Z_DATA_ERROR, Z_MEM_ERROR, Z_BUF_ERROR
 } = constants$2;
 
 /* ===========================================================================*/
 
+const defaultOptions = {
+  chunkSize: 1024 * 64,
+  windowBits: 15,
+  to: ''
+};
 
 /**
  * class Inflate
@@ -6842,11 +7075,7 @@ const {
  * ```
  **/
 function Inflate$1(options) {
-  this.options = common.assign({
-    chunkSize: 1024 * 64,
-    windowBits: 15,
-    to: ''
-  }, options || {});
+  this.options = common.assign({}, defaultOptions, options || {});
 
   const opt = this.options;
 
@@ -6977,11 +7206,19 @@ Inflate$1.prototype.push = function (data, flush_mode) {
       }
     }
 
-    // Skip snyc markers if more data follows and not raw mode
+    // 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 > 0 &&
-           data[strm.next_in] !== 0)
+           (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);
@@ -7002,7 +7239,9 @@ Inflate$1.prototype.push = function (data, flush_mode) {
     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') {
 
@@ -7020,12 +7259,22 @@ Inflate$1.prototype.push = function (data, flush_mode) {
 
         } 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) {
@@ -7035,7 +7284,23 @@ Inflate$1.prototype.push = function (data, flush_mode) {
       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;
@@ -7121,7 +7386,7 @@ Inflate$1.prototype.onEnd = function (status) {
 function inflate$1(input, options) {
   const 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];
@@ -7271,10 +7536,14 @@ var index$2 = (typedArray, prefix) => {
 };
 
 const ALPHABET$1 = '0123456789ABCDEF';
-base(ALPHABET$1);
+const base16 = base(ALPHABET$1);
+base16.decode;
+base16.encode;
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-base(ALPHABET);
+const base64 = base(ALPHABET);
+base64.decode;
+base64.encode;
 
 /**
  * Returns a Uint8Array as String