fix(es/minifier): Fix analysis of parameters

crates/swc_ecma_minifier/tests/fixture/next/brotli-decompress/config.json

@@ -0,0 +1,5 @@
+{
+    "defaults": false,
+    "toplevel": true,
+    "inline": true
+}

crates/swc_ecma_minifier/tests/fixture/next/brotli-decompress/static/chunks/545-ff8f898b276d138f/input.js

@@ -0,0 +1,135 @@
+(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[545], {
+
+
+  /***/ 966:
+/***/ (function (__unused_webpack_module, exports) {
+
+      function HuffmanCode(bits, value) {
+        this.bits = bits;   /* number of bits used for this symbol */
+        this.value = value; /* symbol value or table offset */
+      }
+
+      exports.h = HuffmanCode;
+
+      var MAX_LENGTH = 15;
+
+      /* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
+         bit-wise reversal of the len least significant bits of key. */
+      function GetNextKey(key, len) {
+        var step = 1 << (len - 1);
+        while (key & step) {
+          step >>= 1;
+        }
+        return (key & (step - 1)) + step;
+      }
+
+      /* Stores code in table[0], table[step], table[2*step], ..., table[end] */
+      /* Assumes that end is an integer multiple of step */
+      function ReplicateValue(table, i, step, end, code) {
+        do {
+          end -= step;
+          table[i + end] = new HuffmanCode(code.bits, code.value);
+        } while (end > 0);
+      }
+
+      /* Returns the table width of the next 2nd level table. count is the histogram
+         of bit lengths for the remaining symbols, len is the code length of the next
+         processed symbol */
+      function NextTableBitSize(count, len, root_bits) {
+        var left = 1 << (len - root_bits);
+        while (len < MAX_LENGTH) {
+          left -= count[len];
+          if (left <= 0) break;
+          ++len;
+          left <<= 1;
+        }
+        return len - root_bits;
+      }
+
+      exports.g = function (root_table, table, root_bits, code_lengths, code_lengths_size) {
+        var start_table = table;
+        var code;            /* current table entry */
+        var len;             /* current code length */
+        var symbol;          /* symbol index in original or sorted table */
+        var key;             /* reversed prefix code */
+        var step;            /* step size to replicate values in current table */
+        var low;             /* low bits for current root entry */
+        var mask;            /* mask for low bits */
+        var table_bits;      /* key length of current table */
+        var table_size;      /* size of current table */
+        var total_size;      /* sum of root table size and 2nd level table sizes */
+        var sorted;          /* symbols sorted by code length */
+        var count = new Int32Array(MAX_LENGTH + 1);  /* number of codes of each length */
+        var offset = new Int32Array(MAX_LENGTH + 1);  /* offsets in sorted table for each length */
+
+        sorted = new Int32Array(code_lengths_size);
+
+        /* build histogram of code lengths */
+        for (symbol = 0; symbol < code_lengths_size; symbol++) {
+          count[code_lengths[symbol]]++;
+        }
+
+        /* generate offsets into sorted symbol table by code length */
+        offset[1] = 0;
+        for (len = 1; len < MAX_LENGTH; len++) {
+          offset[len + 1] = offset[len] + count[len];
+        }
+
+        /* sort symbols by length, by symbol order within each length */
+        for (symbol = 0; symbol < code_lengths_size; symbol++) {
+          if (code_lengths[symbol] !== 0) {
+            sorted[offset[code_lengths[symbol]]++] = symbol;
+          }
+        }
+
+        table_bits = root_bits;
+        table_size = 1 << table_bits;
+        total_size = table_size;
+
+        /* special case code with only one value */
+        if (offset[MAX_LENGTH] === 1) {
+          for (key = 0; key < total_size; ++key) {
+            root_table[table + key] = new HuffmanCode(0, sorted[0] & 0xffff);
+          }
+
+          return total_size;
+        }
+
+        /* fill in root table */
+        key = 0;
+        symbol = 0;
+        for (len = 1, step = 2; len <= root_bits; ++len, step <<= 1) {
+          for (; count[len] > 0; --count[len]) {
+            code = new HuffmanCode(len & 0xff, sorted[symbol++] & 0xffff);
+            ReplicateValue(root_table, table + key, step, table_size, code);
+            key = GetNextKey(key, len);
+          }
+        }
+
+        /* fill in 2nd level tables and add pointers to root table */
+        mask = total_size - 1;
+        low = -1;
+        for (len = root_bits + 1, step = 2; len <= MAX_LENGTH; ++len, step <<= 1) {
+          for (; count[len] > 0; --count[len]) {
+            if ((key & mask) !== low) {
+              table += table_size;
+              table_bits = NextTableBitSize(count, len, root_bits);
+              table_size = 1 << table_bits;
+              total_size += table_size;
+              low = key & mask;
+              root_table[start_table + low] = new HuffmanCode((table_bits + root_bits) & 0xff, ((table - start_table) - low) & 0xffff);
+            }
+            code = new HuffmanCode((len - root_bits) & 0xff, sorted[symbol++] & 0xffff);
+            ReplicateValue(root_table, table + (key >> root_bits), step, table_size, code);
+            key = GetNextKey(key, len);
+          }
+        }
+
+        return total_size;
+      }
+
+
+      /***/
+    }),
+
+}]);

crates/swc_ecma_minifier/tests/fixture/next/brotli-decompress/static/chunks/545-ff8f898b276d138f/output.mangleOnly.js

@@ -0,0 +1,103 @@
+(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
+    [
+        545
+    ],
+    {
+        966: (function(r, n) {
+            function a(r, n) {
+                this.bits = r;
+                this.value = n;
+            }
+            n.h = a;
+            var e = 15;
+            function f(r, n) {
+                var a = 1 << (n - 1);
+                while(r & a){
+                    a >>= 1;
+                }
+                return (r & (a - 1)) + a;
+            }
+            function v(r, n, e, f, v) {
+                do {
+                    f -= e;
+                    r[n + f] = new a(v.bits, v.value);
+                }while (f > 0)
+            }
+            function i(r, n, a) {
+                var f = 1 << (n - a);
+                while(n < e){
+                    f -= r[n];
+                    if (f <= 0) break;
+                    ++n;
+                    f <<= 1;
+                }
+                return n - a;
+            }
+            n.g = function(r, n, t, o, u) {
+                var w = n;
+                var h;
+                var c;
+                var l;
+                var s;
+                var b;
+                var k;
+                var _;
+                var p;
+                var y;
+                var A;
+                var I;
+                var C = new Int32Array(e + 1);
+                var E = new Int32Array(e + 1);
+                I = new Int32Array(u);
+                for(l = 0; l < u; l++){
+                    C[o[l]]++;
+                }
+                E[1] = 0;
+                for(c = 1; c < e; c++){
+                    E[c + 1] = E[c] + C[c];
+                }
+                for(l = 0; l < u; l++){
+                    if (o[l] !== 0) {
+                        I[E[o[l]]++] = l;
+                    }
+                }
+                p = t;
+                y = 1 << p;
+                A = y;
+                if (E[e] === 1) {
+                    for(s = 0; s < A; ++s){
+                        r[n + s] = new a(0, I[0] & 0xffff);
+                    }
+                    return A;
+                }
+                s = 0;
+                l = 0;
+                for(c = 1, b = 2; c <= t; ++c, b <<= 1){
+                    for(; C[c] > 0; --C[c]){
+                        h = new a(c & 0xff, I[l++] & 0xffff);
+                        v(r, n + s, b, y, h);
+                        s = f(s, c);
+                    }
+                }
+                _ = A - 1;
+                k = -1;
+                for(c = t + 1, b = 2; c <= e; ++c, b <<= 1){
+                    for(; C[c] > 0; --C[c]){
+                        if ((s & _) !== k) {
+                            n += y;
+                            p = i(C, c, t);
+                            y = 1 << p;
+                            A += y;
+                            k = s & _;
+                            r[w + k] = new a((p + t) & 0xff, ((n - w) - k) & 0xffff);
+                        }
+                        h = new a((c - t) & 0xff, I[l++] & 0xffff);
+                        v(r, n + (s >> t), b, y, h);
+                        s = f(s, c);
+                    }
+                }
+                return A;
+            };
+        })
+    }
+]);