js-confuser 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+# `1.5.2`
+Mini fixes
+
+- Fixed [#41](https://github.com/MichaelXF/js-confuser/issues/41)
+- - Obfuscator mishandled switch statements with a `default` case
+
+- Fixed [#43](https://github.com/MichaelXF/js-confuser/issues/43)
+- - Obfuscator mishandled variable destructuring in for-loops
+
+# `1.5.1`
+Object Extraction Fix
+
+- Fixed [#37](https://github.com/MichaelXF/js-confuser/issues/37)
+- - Object Extraction was applying to objects with get/set methods, fixed in this version.
+
+- Slight improvement to `Flatten`
+
 # `1.5.0`
 Hexadecimal Numbers
 

package/README.md

@@ -2,6 +2,8 @@
 
 JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://jsconfuser.com).
 
+  [![NPM](https://img.shields.io/badge/NPM-%23000000.svg?style=for-the-badge&logo=npm&logoColor=white)](https://npmjs.com/package/js-confuser) [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/MichaelXF/js-confuser) [![Netlify](https://img.shields.io/badge/netlify-%23000000.svg?style=for-the-badge&logo=netlify&logoColor=#00C7B7)](https://jsconfuser.com)
+
 ## Key features
 
 - Variable renaming

package/dist/transforms/controlFlowFlattening/switchCaseObfuscation.js

@@ -28,7 +28,7 @@ class SwitchCaseObfuscation extends _transform.default {
   }
 
   match(object, parents) {
-    return object.type == "SwitchStatement" && !object.cases.find(x => !(x.test.type == "Literal" && typeof x.test.value === "number" && Math.abs(x.test.value) < 100000));
+    return object.type == "SwitchStatement" && !object.cases.find(x => !(x.test && typeof x.test === "object" && x.test.type == "Literal" && typeof x.test.value === "number" && Math.abs(x.test.value) < 100000));
   }
 
   transform(object, parents) {

package/dist/transforms/extraction/objectExtraction.js

@@ -23,6 +23,8 @@ var _probability = require("../../probability");
 
 var _assert = require("assert");
 
+var _guard = require("../../util/guard");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -84,17 +86,18 @@ class ObjectExtraction extends _transform.default {
                 illegal.add(name);
                 return;
               } // check for computed properties
+              // Change String literals to non-computed
 
 
               object.properties.forEach(prop => {
-                if (prop.computed && prop.key.type == "Literal") {
+                if (prop.computed && (0, _guard.isStringLiteral)(prop.key)) {
                   prop.computed = false;
                 }
               });
-              var computed = object.properties.find(x => x.computed);
+              var nonInitOrComputed = object.properties.find(x => x.kind !== "init" || x.computed);
 
-              if (computed) {
-                this.log(name + " has computed property: " + computed.key.name || computed.key.value);
+              if (nonInitOrComputed) {
+                this.log(name + " has non-init/computed property: " + nonInitOrComputed.key.name || nonInitOrComputed.key.value);
                 illegal.add(name);
                 return;
               } else {

package/dist/transforms/flatten.js

@@ -17,6 +17,8 @@ var _identifiers = require("../util/identifiers");
 
 var _insert = require("../util/insert");
 
+var _random = require("../util/random");
+
 var _transform = _interopRequireDefault(require("./transform"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -44,7 +46,16 @@ class Flatten extends _transform.default {
 
     _defineProperty(this, "definedNames", void 0);
 
+    _defineProperty(this, "flatMapName", void 0);
+
+    _defineProperty(this, "flatNode", void 0);
+
+    _defineProperty(this, "gen", void 0);
+
     this.definedNames = new Map();
+    this.flatMapName = null;
+    this.flatNode = null;
+    this.gen = this.getGenerator();
   }
 
   apply(tree) {
@@ -175,7 +186,10 @@ class Flatten extends _transform.default {
       }
 
       var output = Array.from(modified);
-      var newName = "flatten" + this.getPlaceholder() + "_" + (object.id && object.id.name || "fn");
+      var newName = this.gen.generate();
+      var valName = this.getPlaceholder();
+      var resultName = this.getPlaceholder();
+      var propName = this.gen.generate();
       (0, _insert.getBlockBody)(object.body).push((0, _gen.ReturnStatement)());
       (0, _traverse.walk)(object.body, [object, ...parents], (o, p) => {
         return () => {
@@ -187,33 +201,51 @@ class Flatten extends _transform.default {
             }
 
             o.argument = (0, _gen.ArrayExpression)(elements);
+            o.argument = (0, _gen.AssignmentExpression)("=", (0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(propName), false), o.argument);
           }
         };
       });
       var newBody = (0, _insert.getBlockBody)(object.body);
+      newBody.unshift((0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)((0, _gen.ArrayPattern)([(0, _gen.ArrayPattern)(input.map(_gen.Identifier)), (0, _gen.ArrayPattern)((0, _insert.clone)(object.params)), (0, _gen.Identifier)(resultName)]), (0, _gen.Identifier)(valName))));
 
-      if (input.length) {
-        newBody.unshift((0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)((0, _gen.ArrayPattern)(input.map(_gen.Identifier)), (0, _gen.ThisExpression)())));
+      if (!this.flatMapName) {
+        this.flatMapName = this.getPlaceholder();
+        (0, _insert.prepend)(parents[parents.length - 1], (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.flatMapName, this.flatNode = (0, _gen.ObjectExpression)([]))));
       }
 
-      var newFunctionDeclaration = (0, _gen.FunctionDeclaration)(newName, (0, _insert.clone)(object.params), newBody);
-      newFunctionDeclaration.async = !!object.async;
-      newFunctionDeclaration.generator = !!object.generator;
-      (0, _insert.prepend)(parents[parents.length - 1], newFunctionDeclaration);
+      var newFunctionExpression = (0, _gen.FunctionExpression)([(0, _gen.Identifier)(valName)], newBody);
+      newFunctionExpression.async = !!object.async;
+      newFunctionExpression.generator = !!object.generator;
+      var property = (0, _gen.Property)((0, _gen.Identifier)(newName), newFunctionExpression, false);
+      property.kind = "set";
+      this.flatNode.properties.push(property);
+      var identifier = (0, _gen.MemberExpression)((0, _gen.Identifier)(this.flatMapName), (0, _gen.Identifier)(newName), false);
       var newParamNodes = object.params.map(() => (0, _gen.Identifier)(this.getPlaceholder())); // var result = newFn.call([...refs], ...arguments)
 
-      var call = (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)("result", (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(newName), (0, _gen.Identifier)("call"), false), [(0, _gen.ArrayExpression)(input.map(_gen.Identifier)), ...newParamNodes]))); // result.pop()
+      var call = (0, _gen.VariableDeclaration)([(0, _gen.VariableDeclarator)(resultName, (0, _gen.ArrayExpression)([])), (0, _gen.VariableDeclarator)("_", (0, _gen.AssignmentExpression)("=", identifier, (0, _gen.ArrayExpression)([(0, _gen.ArrayExpression)(input.map(_gen.Identifier)), (0, _gen.ArrayExpression)([...newParamNodes]), (0, _gen.Identifier)(resultName)])))]); // result.pop()
 
-      var pop = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)("result"), (0, _gen.Identifier)("pop"), false), []); // var result = newFn.call([...refs], ...arguments)
+      var pop = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(propName), false), (0, _gen.Identifier)("pop"), false), []); // var result = newFn.call([...refs], ...arguments)
       // modified1 = result.pop();
       // modified2 = result.pop();
       // ...modifiedN = result.pop();...
       //
       // return result.pop()
 
-      object.body = (0, _gen.BlockStatement)([call, ...[...output].reverse().map(name => {
+      var newObjectBody = [call];
+      var outputReversed = [...output].reverse(); // DECOY STATEMENTS
+
+      var decoyKey = this.gen.generate();
+      var decoyNodes = [(0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(this.gen.generate()), false), [(0, _gen.ThrowStatement)((0, _gen.NewExpression)((0, _gen.Identifier)("Error"), [(0, _gen.Literal)(this.getPlaceholder())]))]), (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(this.gen.generate()), false), [(0, _gen.ReturnStatement)((0, _gen.Identifier)(resultName))]), (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(this.gen.generate()), false), [(0, _gen.ReturnStatement)((0, _gen.Identifier)(resultName))]), (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(decoyKey), false), [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(decoyKey), false))]), (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(this.gen.generate()), false), [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(this.gen.generate()), false))])];
+      (0, _random.shuffle)(decoyNodes);
+      decoyNodes.forEach(decoyNode => {
+        if (Math.random() < 0.5) {
+          newObjectBody.push(decoyNode);
+        }
+      });
+      newObjectBody.push(...outputReversed.map(name => {
         return (0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(name), (0, _insert.clone)(pop)));
-      }), (0, _gen.ReturnStatement)((0, _insert.clone)(pop))]);
+      }), (0, _gen.ReturnStatement)((0, _insert.clone)(pop)));
+      object.body = (0, _gen.BlockStatement)(newObjectBody);
       object.params = newParamNodes;
     };
   }

package/dist/transforms/minify.js

@@ -457,7 +457,7 @@ class Minify extends _transform.default {
       } // check for redundant patterns
 
 
-      if (object.id.type == "ArrayPattern" && object.init.type == "ArrayExpression") {
+      if (object.id.type == "ArrayPattern" && object.init && typeof object.init === "object" && object.init.type == "ArrayExpression") {
         if (object.id.elements.length == 1 && object.init.elements.length == 1) {
           object.id = object.id.elements[0];
           object.init = object.init.elements[0];

package/dist/util/guard.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isStringLiteral = isStringLiteral;
+
+function isStringLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "string" && !node.regex;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/transforms/controlFlowFlattening/switchCaseObfuscation.ts

@@ -27,6 +27,8 @@ export default class SwitchCaseObfuscation extends Transform {
       !object.cases.find(
         (x) =>
           !(
+            x.test &&
+            typeof x.test === "object" &&
             x.test.type == "Literal" &&
             typeof x.test.value === "number" &&
             Math.abs(x.test.value) < 100_000

package/src/transforms/extraction/objectExtraction.ts

@@ -19,6 +19,7 @@ import { getIdentifierInfo } from "../../util/identifiers";
 import { isValidIdentifier } from "../../util/compare";
 import { ComputeProbabilityMap } from "../../probability";
 import { ok } from "assert";
+import { isStringLiteral } from "../../util/guard";
 
 /**
  * Extracts keys out of an object if possible.
@@ -87,17 +88,22 @@ export default class ObjectExtraction extends Transform {
               }
 
               // check for computed properties
+              // Change String literals to non-computed
               object.properties.forEach((prop) => {
-                if (prop.computed && prop.key.type == "Literal") {
+                if (prop.computed && isStringLiteral(prop.key)) {
                   prop.computed = false;
                 }
               });
 
-              var computed = object.properties.find((x) => x.computed);
-              if (computed) {
+              var nonInitOrComputed = object.properties.find(
+                (x) => x.kind !== "init" || x.computed
+              );
+
+              if (nonInitOrComputed) {
                 this.log(
-                  name + " has computed property: " + computed.key.name ||
-                    computed.key.value
+                  name +
+                    " has non-init/computed property: " +
+                    nonInitOrComputed.key.name || nonInitOrComputed.key.value
                 );
                 illegal.add(name);
                 return;

package/src/transforms/flatten.ts

@@ -16,6 +16,14 @@ import {
   Node,
   BlockStatement,
   ArrayPattern,
+  FunctionExpression,
+  ObjectExpression,
+  Property,
+  SpreadElement,
+  Literal,
+  IfStatement,
+  ThrowStatement,
+  NewExpression,
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import {
@@ -25,6 +33,7 @@ import {
   prepend,
   clone,
 } from "../util/insert";
+import { shuffle } from "../util/random";
 import Transform from "./transform";
 
 /**
@@ -41,10 +50,17 @@ import Transform from "./transform";
 export default class Flatten extends Transform {
   definedNames: Map<Node, Set<string>>;
 
+  flatMapName: string;
+  flatNode: Node;
+  gen: any;
+
   constructor(o) {
     super(o, ObfuscateOrder.Flatten);
 
     this.definedNames = new Map();
+    this.flatMapName = null;
+    this.flatNode = null;
+    this.gen = this.getGenerator();
   }
 
   apply(tree) {
@@ -200,11 +216,10 @@ export default class Flatten extends Transform {
 
       var output = Array.from(modified);
 
-      var newName =
-        "flatten" +
-        this.getPlaceholder() +
-        "_" +
-        ((object.id && object.id.name) || "fn");
+      var newName = this.gen.generate();
+      var valName = this.getPlaceholder();
+      var resultName = this.getPlaceholder();
+      var propName = this.gen.generate();
 
       getBlockBody(object.body).push(ReturnStatement());
       walk(object.body, [object, ...parents], (o, p) => {
@@ -222,51 +237,100 @@ export default class Flatten extends Transform {
             }
 
             o.argument = ArrayExpression(elements);
+
+            o.argument = AssignmentExpression(
+              "=",
+              MemberExpression(
+                Identifier(resultName),
+                Identifier(propName),
+                false
+              ),
+              o.argument
+            );
           }
         };
       });
 
       var newBody = getBlockBody(object.body);
 
-      if (input.length) {
-        newBody.unshift(
+      newBody.unshift(
+        VariableDeclaration(
+          VariableDeclarator(
+            ArrayPattern([
+              ArrayPattern(input.map(Identifier)),
+              ArrayPattern(clone(object.params)),
+              Identifier(resultName),
+            ]),
+
+            Identifier(valName)
+          )
+        )
+      );
+
+      if (!this.flatMapName) {
+        this.flatMapName = this.getPlaceholder();
+        prepend(
+          parents[parents.length - 1],
           VariableDeclaration(
             VariableDeclarator(
-              ArrayPattern(input.map(Identifier)),
-              ThisExpression()
+              this.flatMapName,
+              (this.flatNode = ObjectExpression([]))
             )
           )
         );
       }
 
-      var newFunctionDeclaration = FunctionDeclaration(
-        newName,
-        clone(object.params),
+      var newFunctionExpression = FunctionExpression(
+        [Identifier(valName)],
         newBody
       );
-      newFunctionDeclaration.async = !!object.async;
-      newFunctionDeclaration.generator = !!object.generator;
 
-      prepend(parents[parents.length - 1], newFunctionDeclaration);
+      newFunctionExpression.async = !!object.async;
+      newFunctionExpression.generator = !!object.generator;
+
+      var property = Property(
+        Identifier(newName),
+        newFunctionExpression,
+        false
+      );
+      property.kind = "set";
+
+      this.flatNode.properties.push(property);
+
+      var identifier = MemberExpression(
+        Identifier(this.flatMapName),
+        Identifier(newName),
+        false
+      );
 
       var newParamNodes = object.params.map(() =>
         Identifier(this.getPlaceholder())
       );
 
       // var result = newFn.call([...refs], ...arguments)
-      var call = VariableDeclaration(
+      var call = VariableDeclaration([
+        VariableDeclarator(resultName, ArrayExpression([])),
         VariableDeclarator(
-          "result",
-          CallExpression(
-            MemberExpression(Identifier(newName), Identifier("call"), false),
-            [ArrayExpression(input.map(Identifier)), ...newParamNodes]
+          "_",
+          AssignmentExpression(
+            "=",
+            identifier,
+            ArrayExpression([
+              ArrayExpression(input.map(Identifier)),
+              ArrayExpression([...newParamNodes]),
+              Identifier(resultName),
+            ])
           )
-        )
-      );
+        ),
+      ]);
 
       // result.pop()
       var pop = CallExpression(
-        MemberExpression(Identifier("result"), Identifier("pop"), false),
+        MemberExpression(
+          MemberExpression(Identifier(resultName), Identifier(propName), false),
+          Identifier("pop"),
+          false
+        ),
         []
       );
 
@@ -277,16 +341,90 @@ export default class Flatten extends Transform {
       //
       // return result.pop()
 
-      object.body = BlockStatement([
-        call,
-        ...[...output].reverse().map((name) => {
+      var newObjectBody: Node[] = [call];
+      var outputReversed = [...output].reverse();
+
+      // DECOY STATEMENTS
+      var decoyKey = this.gen.generate();
+      var decoyNodes = [
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Identifier(this.gen.generate()),
+            false
+          ),
+          [
+            ThrowStatement(
+              NewExpression(Identifier("Error"), [
+                Literal(this.getPlaceholder()),
+              ])
+            ),
+          ]
+        ),
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Identifier(this.gen.generate()),
+            false
+          ),
+          [ReturnStatement(Identifier(resultName))]
+        ),
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Identifier(this.gen.generate()),
+            false
+          ),
+          [ReturnStatement(Identifier(resultName))]
+        ),
+        IfStatement(
+          MemberExpression(Identifier(resultName), Identifier(decoyKey), false),
+          [
+            ReturnStatement(
+              MemberExpression(
+                Identifier(resultName),
+                Identifier(decoyKey),
+                false
+              )
+            ),
+          ]
+        ),
+        IfStatement(
+          MemberExpression(
+            Identifier(resultName),
+            Identifier(this.gen.generate()),
+            false
+          ),
+          [
+            ReturnStatement(
+              MemberExpression(
+                Identifier(resultName),
+                Identifier(this.gen.generate()),
+                false
+              )
+            ),
+          ]
+        ),
+      ];
+
+      shuffle(decoyNodes);
+      decoyNodes.forEach((decoyNode) => {
+        if (Math.random() < 0.5) {
+          newObjectBody.push(decoyNode);
+        }
+      });
+
+      newObjectBody.push(
+        ...outputReversed.map((name) => {
           return ExpressionStatement(
             AssignmentExpression("=", Identifier(name), clone(pop))
           );
         }),
 
-        ReturnStatement(clone(pop)),
-      ]);
+        ReturnStatement(clone(pop))
+      );
+
+      object.body = BlockStatement(newObjectBody);
 
       object.params = newParamNodes;
     };

package/src/transforms/minify.ts

@@ -595,6 +595,8 @@ export default class Minify extends Transform {
       // check for redundant patterns
       if (
         object.id.type == "ArrayPattern" &&
+        object.init &&
+        typeof object.init === "object" &&
         object.init.type == "ArrayExpression"
       ) {
         if (

package/src/util/gen.ts

@@ -58,7 +58,7 @@ export type EvalCallback = {
  */
 export type Chain = Node[];
 
-export function Literal(value: string | number | boolean) {
+export function Literal(value: string | number | boolean): Node {
   if (typeof value === "undefined") {
     throw new Error("value is undefined");
   }

package/src/util/guard.ts

@@ -0,0 +1,7 @@
+import { Node } from "./gen";
+
+export function isStringLiteral(node: Node) {
+  return (
+    node.type === "Literal" && typeof node.value === "string" && !node.regex
+  );
+}

package/test/transforms/controlFlowFlattening/switchCaseObfuscation.test.ts

@@ -74,3 +74,47 @@ it("should not obfuscate switch statements with complex discriminants (SwitchCas
 
   eval(output);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/41
+it("Not apply to switch statements with default cases", async ()=>{
+
+    var code = `
+    var array = [];
+
+    function runOnce(stateParam){
+      switch(stateParam){
+        case 1: array.push(1, 2, 3); break;
+        case 2: array.push(4, 5, 6); break;
+        case 3: array.push(7, 8, 9); break;
+        default: array.push(10); break;
+      }
+    }
+
+    runOnce(1);
+    runOnce(2);
+    runOnce(3);
+    runOnce(-1); // default case
+
+    input(array);
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    controlFlowFlattening: true,
+  });
+
+  expect(
+    output.includes("case 1:") &&
+      output.includes("case 2:") &&
+      output.includes("case 3:") 
+  ).toStrictEqual(true);
+
+  function input(array) {
+    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  }
+
+  eval(output);
+
+
+
+});

package/test/transforms/extraction/objectExtraction.test.ts

@@ -423,3 +423,26 @@ it("should properly use custom callback to exclude certain names from being chan
 
   eval(output);
 });
+
+it("should not apply to objects with non-init properties (method, set, get)", async () => {
+  var code = `
+    
+    var realValue = 0;
+    var TEST_OBJECT = {
+      set key(newValue){
+        realValue = newValue;
+      },
+      get key(){
+        return realValue;
+      }
+    };
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "node",
+    objectExtraction: true,
+  });
+
+  expect(output).toContain("TEST_OBJECT");
+  expect(output).toContain("set ");
+});

package/test/transforms/flatten.test.ts

@@ -17,7 +17,7 @@ it("should bring independent to the global level", async () => {
     }
   );
 
-  expect(output.startsWith("function flatten_")).toStrictEqual(true);
+  expect(output).toContain("set");
 });
 
 it("should have correct return values", async () => {
@@ -227,7 +227,7 @@ it("should not change functions with const", async () => {
     }
   );
 
-  expect(output).not.toContain("this");
+  expect(output).not.toContain("set");
 
   var value = "never_called",
     input = (x) => (value = x);
@@ -255,7 +255,7 @@ it("should work when pattern-based assignment expressions are involved", async (
     }
   );
 
-  expect(output).toContain("this");
+  expect(output).toContain("set");
 
   var value = "never_called",
     input = (x) => (value = x);

package/test/transforms/minify.test.ts

@@ -299,3 +299,25 @@ test("Variant #15: Removing implied 'return'", async () => {
 
   expect(output2).toContain("return");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/43
+test("Variant #16: Handle deconstructuring in for loop", async ()=>{
+// Valid
+var output = await JsConfuser(
+    `
+    for(const [a] of [[1]]) {
+        input(a);
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  var value;
+  function input(valueIn){
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toStrictEqual(1);
+})