Incorrect Javascript minification

[biagimarco]

Hi @tdewolff!

First of all, thanks for this great project!

I recently found an example where the minifier produces JavaScript that throws at runtime, while the original code executes correctly.

Create a file example.js with the following content:

function Rh(){return[0,0,0]}
function ka(){return[function(){return[0,0]},0]}
function sr(){return 0}
function my(){return 0}
var h={useState:()=>[0,()=>{}],useRef:()=>({current:0})}
function Zo(f){return f}
function ku(x){return x}

var Ow = ["E", " "],
  uoe = ["AD", "PU", "H"],
  SE = ["AU", "PD", "E"],
  doe = [...uoe, ...SE],
  hoe = { ltr: [...Ow, "AR"], rtl: [...Ow, "AL"] },
  goe = { ltr: ["AL"], rtl: ["AR"] },
  Jh = "M",
  [mh, poe, foe] = Rh(Jh),
  [gl, CE] = ka(Jh, [foe, sr, my]),
  gy = sr(),
  EE = my(),
  [boe, pl] = gl(Jh),
  [yoe, eg] = gl(Jh),
  AE = e => {
    const { __scopeMenu: o, open: t = !1, children: a, dir: i, onOpenChange: r, modal: n = !0 } = e,
      c = gy(o),
      [l, m] = h.useState(null),
      u = h.useRef(!1),
      d = Zo(r),
      g = ku(i);
  };

console.log("Everything ok!")

Run it, for instance node example.js.
Output Everything ok!.

Minify it:

./minify --type js < example.js > output.js

Run the minified version, for instance node output.js.
Output:

TypeError: Ow is not iterable
    at Object.<anonymous> (.../test-minify-js/output/repro-minify.js:1:347)
    at Module._compile (node:internal/modules/cjs/loader:1829:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1969:10)
    at Module.load (node:internal/modules/cjs/loader:1552:32)
    at Module._load (node:internal/modules/cjs/loader:1354:12)
    at wrapModuleLoad (node:internal/modules/cjs/loader:255:19)
    at Module.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:154:5)
    at node:internal/main/run_main_module:33:47

The minifier seems to reorder parts of the chained var declaration without respecting dependencies between initializers.

Thanks,
Marco

[biagimarco]

I think this simplifies it even more:

var a = [1],
    b = [...a],
    [c] = [0];

var d;

console.log(b);

Should print [ 1 ], but once minified we obtain this:

var[c]=[0],d,b=[...a],a=[1];console.log(b)

Which results in:

TypeError: a is not iterable
    at Object.<anonymous> (/Users/marcobiagi/dev/experiments/test-minify-js/output/repro-minify.js:1:20)
    at Module._compile (node:internal/modules/cjs/loader:1829:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1969:10)
    at Module.load (node:internal/modules/cjs/loader:1552:32)
    at Module._load (node:internal/modules/cjs/loader:1354:12)
    at wrapModuleLoad (node:internal/modules/cjs/loader:255:19)
    at Module.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:154:5)
    at node:internal/main/run_main_module:33:47

So I think the problem could be in js/vars.go in the hoistVars function.

[biagimarco]

I'm not familiar with the codebase, but looking at the code I believe the problem is in the BeginArrayObject section of hoistVars. If I understand correctly, to save one character, it tries to move the first array/object destructuring to position 0, so the output can be var[, saving a space.

The issue is in how it does that:

decl.List[0], decl.List[i] = decl.List[i], decl.List[0]

This swaps the destructuring directly with the first element, without checking whether displacing the first element to a later position breaks dependencies for items in between. That's exactly what happens in the example above: position 0 variable gets moved past items that depend on it.

A few possible fixes:
1- Remove this optimization entirely (if speed is favored over saving one byte in each group of var)
2- Use a shift instead of a swap, so all elements between 0 and i preserve their relative order
3- Add a check to detect when the swap would break dependencies

You could also combine approaches: use a shift (fix 2) but only when i is small, and skip the optimization otherwise. That way the shift cost stays negligible, similar in spirit to the if 10000 < len(decl.List) guard already present. But probably this just add complexity that personally I don't like 😄

Probably I would prefer 2 or 1.

For example, replace:

decl.List[0], decl.List[i] = decl.List[i], decl.List[0]

With (or an utiliy function for the shift):

toBeFirst := decl.List[i] 
copy(decl.List[1:i+1], decl.List[0:i]) 
decl.List[0] = toBeFirst

[tdewolff]

Thank you for the in-depth review, I have limited time but I'll try to fix soon. Kind regards, Taco de Wolff

…

On Sat, Mar 14, 2026, 11:43 Marco Biagi ***@***.***> wrote: *biagimarco* left a comment (tdewolff/minify#926) <#926 (comment)> I'm not deeply familiar with the codebase, but looking at the code I believe the problem is in the BeginArrayObject section of hoistVars. If I understand correctly, to save one character, it tries to move the first array/object destructuring to position 0, so the output can be var[, saving a space. The issue is in how it does that: decl.List[0], decl.List[i] = decl.List[i], decl.List[0] This swaps the destructuring directly with the first element, without checking whether displacing the first element to a later position breaks dependencies for items in between. That's exactly what happens in the example above: position 0 variable gets moved past items that depend on it. A few possible fixes: 1- Remove this optimization entirely (if speed is favored over saving one byte in each group of var) 2- Use a shift instead of a swap, so all elements between *0* and *i* preserve their relative order 3- Add a check to detect when the swap would break dependencies Probably I would prefer 1 or 2. — Reply to this email directly, view it on GitHub <#926 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABKOGHQSJ3ES55RZYVU32PT4QVVZHAVCNFSM6AAAAACWRETCG6VHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHM2DANRQGY2TMOBQGU> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[biagimarco]

Last message 😇
As I fixed it locally, this would be the diff of the proposed change (note that I had to use the shift approach in multiple places):

diff --git a/js/js_test.go b/js/js_test.go
index 08f20b8..a44fc64 100644
--- a/js/js_test.go
+++ b/js/js_test.go
@@ -375,6 +375,7 @@ func TestJS(t *testing.T) {
                {`var result=[];for(var a=0,array=d;a<array.length;a++){var v=array[a]}`, `for(var v,result=[],a=0,array=d;a<array.length;a++)v=array[a]`},
                //{`var name=function name(){name()}`, `var name=function(){name()}`}, // TODO
                {`var a=0,b=a;var c=1,d=2,e=3`, `var a=0,b=a,c=1,d=2,e=3`},
+               {`var a = [1],b = [...a],[c] = [0];var d`, `var[c]=[0],d,a=[1],b=[...a]`},
 
                // TODO: test for variables renaming (first rename, then merge vars)
 
diff --git a/js/util.go b/js/util.go
index 283270b..37a3c5c 100644
--- a/js/util.go
+++ b/js/util.go
@@ -1463,3 +1463,9 @@ func hexadecimalNumber(num []byte, prec int) []byte {
        }
        return minify.Number(b, prec)
 }
+
+func shiftToFront[T any](list []T, i int) {
+      toBeFirst := list[i]
+      copy(list[1:i+1], list[0:i])
+      list[0] = toBeFirst
+  }
\ No newline at end of file
diff --git a/js/util_test.go b/js/util_test.go
index 038884b..11735a3 100644
--- a/js/util_test.go
+++ b/js/util_test.go
@@ -142,3 +142,21 @@ func TestHasSideEffects(t *testing.T) {
                })
        }
 }
+
+func TestShiftToFront(t *testing.T) {
+       tests := []struct {
+               input    []int
+               index    int
+               expected []int
+       }{
+               {[]int{1, 2, 3}, 0, []int{1, 2, 3}},
+               {[]int{1, 2, 3}, 1, []int{2, 1, 3}},
+               {[]int{1, 2, 3}, 2, []int{3, 1, 2}},
+               {[]int{1, 2, 3, 4, 5}, 3, []int{4, 1, 2, 3, 5}},
+       }
+
+       for _, tt := range tests {
+               shiftToFront(tt.input, tt.index)
+               test.T(t, tt.input, tt.expected)
+       }
+}
\ No newline at end of file
diff --git a/js/vars.go b/js/vars.go
index 12ad46c..01336b5 100644
--- a/js/vars.go
+++ b/js/vars.go
@@ -370,12 +370,12 @@ func (m *jsMinifier) hoistVars(body *js.BlockStmt) {
                                        // move arrays/objects to the front (saves a space)
                                        if _, ok := item.Binding.(*js.BindingObject); ok {
                                                if j != 0 && nArrays == 0 && nObjects == 0 {
-                                                       varDecl.List[0], varDecl.List[j] = varDecl.List[j], varDecl.List[0]
+                                                       shiftToFront(varDecl.List, j)
                                                }
                                                nObjects++
                                        } else if _, ok := item.Binding.(*js.BindingArray); ok {
                                                if j != 0 && nArrays == 0 && nObjects == 0 {
-                                                       varDecl.List[0], varDecl.List[j] = varDecl.List[j], varDecl.List[0]
+                                                       shiftToFront(varDecl.List, j)
                                                }
                                                nArrays++
                                        }
@@ -480,7 +480,7 @@ func (m *jsMinifier) hoistVars(body *js.BlockStmt) {
                                                }
                                        }
                                        if !interferes {
-                                               decl.List[0], decl.List[i] = decl.List[i], decl.List[0]
+                                               shiftToFront(decl.List, i)
                                                break BeginArrayObject
                                        }
                                } else {

Also opened a PR: #934