js-confuser 1.5.5 → 1.5.6

package/CHANGELOG.md

@@ -1,8 +1,26 @@
+# `1.5.6`
+Website changed and RGF fixes
+
+The website is back at a different domain now: [https://master--hungry-shannon-c1ce6b.netlify.app/](https://master--hungry-shannon-c1ce6b.netlify.app/)
+
+This update focuses on fixing RGF bugs
+
+- Fixed [#64](https://github.com/MichaelXF/js-confuser/issues/64)
+- - RGF to properly handle Arrow functions and function expressions
+
+- RGF will no longer change getter/setter methods
+
+- RGF will no longer change class methods
+
+- RGF now works when using `mangled` variable names
+
+- Minify will remove unreachable code following a Throw statement
+
 # `1.5.5`
 Updates
 
 - Fixed [#53](https://github.com/MichaelXF/js-confuser/issues/53)
-- - Shuffle to not use common varialbe names like `x`
+- - Shuffle to not use common variable names like `x`
 
 - Fixed [#60](https://github.com/MichaelXF/js-confuser/issues/60)
 - - Rename Variables to properly handle function parameters
@@ -447,7 +465,7 @@ Available now on NPM: https://www.npmjs.com/package/js-confuser
 # `1.1.7`
 Website is Live
 
-- [JsConfuser.com](https://jsconfuser.com) is live!
+- [https://master--hungry-shannon-c1ce6b.netlify.app/](https://master--hungry-shannon-c1ce6b.netlify.app/) is live!
 - Check out the [js-confuser-website](https://github.com/MichaelXF/js-confuser-website) repo for more info
 
 - **⚠️ Breaking change**: `Rename Globals` is now enabled by default

package/README.md

@@ -1,8 +1,8 @@
 # JS Confuser
 
-JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://jsconfuser.com).
+JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://master--hungry-shannon-c1ce6b.netlify.app/).
 
-  [![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)
+  [![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://master--hungry-shannon-c1ce6b.netlify.app/)
 
 ## Key features
 

package/dist/transforms/flatten.js

@@ -224,7 +224,7 @@ class Flatten extends _transform.default {
 
       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.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(propName), false), (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.Literal)("pop"), true), []); // var result = newFn.call([...refs], ...arguments)
       // modified1 = result.pop();
       // modified2 = result.pop();
       // ...modifiedN = result.pop();...

package/dist/transforms/identifier/variableAnalysis.js

@@ -103,8 +103,10 @@ class VariableAnalysis extends _transform.default {
         var definingContexts = info.spec.isDefined ? (0, _insert.getAllDefiningContexts)(o, p) : (0, _insert.getReferencingContexts)(o, p, info);
         (0, _assert.ok)(definingContexts.length);
         definingContexts.forEach(definingContext => {
-          (0, _assert.ok)((0, _insert.isContext)(definingContext), "".concat(definingContext.type, " is not a context"));
-
+          // ok(
+          //   isContext(definingContext),
+          //   `${definingContext.type} is not a context`
+          // );
           if (isDefined) {
             // Add to defined Map
             if (!this.defined.has(definingContext)) {

package/dist/transforms/minify.js

@@ -53,7 +53,7 @@ class Minify extends _transform.default {
         var earlyReturn = body.length;
         var fnDecs = [];
         body.forEach((stmt, i) => {
-          if (stmt.type == "ReturnStatement" || stmt.type == "BreakStatement" || stmt.type == "ContinueStatement") {
+          if (stmt.type === "ReturnStatement" || stmt.type === "BreakStatement" || stmt.type === "ContinueStatement" || stmt.type === "ThrowStatement") {
             if (earlyReturn > i + 1) {
               earlyReturn = i + 1;
             }
@@ -136,7 +136,7 @@ class Minify extends _transform.default {
               if (!lastDec || lastDec.kind !== x.kind || !lastDec.declarations.length) {
                 lastDec = x;
               } else {
-                lastDec.declarations.push(...x.declarations);
+                lastDec.declarations.push(...(0, _insert.clone)(x.declarations));
                 remove.unshift(i);
               }
             } else {

package/dist/transforms/rgf.js

@@ -25,6 +25,8 @@ var _identifiers = require("../util/identifiers");
 
 var _insert = require("../util/insert");
 
+var _random = require("../util/random");
+
 var _transform = _interopRequireDefault(require("./transform"));
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
@@ -69,9 +71,22 @@ class RGF extends _transform.default {
       var collect = [];
       var queue = [];
       var names = new Map();
+      var referenceSignatures = {};
       var definingNodes = new Map();
       (0, _traverse.walk)(contextObject, contextParents, (object, parents) => {
         if (object !== contextObject && (0, _insert.isFunction)(object) && !object.$requiresEval && !object.async && !object.generator && (0, _insert.getVarContext)(parents[0], parents.slice(1)) === contextObject) {
+          // Discard getter/setter methods
+          if (parents[0].type === "Property" && parents[0].value === object) {
+            if (parents[0].method || parents[0].kind === "get" || parents[0].kind === "set") {
+              return;
+            }
+          } // Discard class methods
+
+
+          if (parents[0].type === "MethodDefinition" && parents[0].value === object) {
+            return;
+          }
+
           var defined = new Set(),
               referenced = new Set();
           var isBound = false;
@@ -159,6 +174,7 @@ class RGF extends _transform.default {
           if (object.type == "FunctionDeclaration" && typeof object.id.name === "string") {
             var index = names.size;
             names.set(object.id.name, index);
+            referenceSignatures[index] = (0, _random.getRandomString)(10);
             definingNodes.set(object.id.name, object.id);
           }
         }
@@ -166,9 +182,10 @@ class RGF extends _transform.default {
 
       if (!queue.length) {
         return;
-      }
+      } // An array containing all the function declarations
+
 
-      var referenceArray = this.generateIdentifier();
+      var referenceArray = "_" + (0, _random.getRandomString)(10);
       (0, _traverse.walk)(contextObject, contextParents, (o, p) => {
         if (o.type == "Identifier" && !_constants.reservedIdentifiers.has(o.name)) {
           var index = names.get(o.name);
@@ -185,7 +202,19 @@ class RGF extends _transform.default {
 
                 if (pointingTo == shouldBe) {
                   this.log(o.name, "->", "".concat(referenceArray, "[").concat(index, "]"));
-                  this.replace(o, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(referenceArray), (0, _gen.Literal)(index), true), [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]));
+                  var memberExpression = (0, _gen.MemberExpression)((0, _gen.Identifier)(referenceArray), (0, _gen.Literal)(index), true); // Allow re-assignment to the RGF function
+
+                  if (p[0] && p[0].type === "AssignmentExpression" && p[0].left === o) {
+                    // fn = ...
+                    this.replace(o, memberExpression);
+                  } else {
+                    // fn()
+                    // fn
+                    // In most cases the identifier is being used like this (call expression, or referenced to be called later)
+                    // Replace it with a simple wrapper function that will pass on the reference array
+                    var conditionalExpression = (0, _gen.ConditionalExpression)((0, _template.default)("typeof ".concat(referenceArray, "[").concat(index, "] === \"function\" && ").concat(referenceArray, "[").concat(index, "][\"").concat(referenceSignatures[index] || "_", "\"]")).single().expression, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)(memberExpression, [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]), memberExpression);
+                    this.replace(o, conditionalExpression);
+                  }
                 }
               }
             }
@@ -202,6 +231,7 @@ class RGF extends _transform.default {
         var name = object === null || object === void 0 ? void 0 : (_object$id2 = object.id) === null || _object$id2 === void 0 ? void 0 : _object$id2.name;
         var hasName = !!name;
         var params = object.params.map(x => x.name) || [];
+        var signature = referenceSignatures[names.get(name)];
         var embeddedName = name || this.getPlaceholder(); // Since `new Function` is completely isolated, create an entire new obfuscator and run remaining transformations.
         // RGF runs early and needs completed code before converting to a string.
         // (^ the variables haven't been renamed yet)
@@ -222,7 +252,7 @@ class RGF extends _transform.default {
         };
         var tree = {
           type: "Program",
-          body: [embeddedFunction, (0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(embeddedName), (0, _gen.Identifier)("call"), false), [(0, _gen.ThisExpression)(), (0, _gen.SpreadElement)((0, _template.default)("Array.prototype.slice.call(arguments, 1)").single().expression)]))]
+          body: [embeddedFunction, (0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(embeddedName), (0, _gen.Literal)("call"), true), [(0, _gen.Identifier)("undefined"), (0, _gen.SpreadElement)((0, _template.default)("Array.prototype.slice.call(arguments, 1)").single().expression)]))]
         };
         tree.__hiddenDeclarations = (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(referenceArray));
         tree.__hiddenDeclarations.hidden = true;
@@ -241,8 +271,17 @@ class RGF extends _transform.default {
         var toString = (0, _compiler.compileJsSync)(tree, this.options);
         var newFunction = (0, _gen.NewExpression)((0, _gen.Identifier)("Function"), [(0, _gen.Literal)(referenceArray), (0, _gen.Literal)(toString)]);
 
-        if (hasName) {
-          arrayExpression.elements[names.get(name)] = newFunction;
+        function applySignature(fn) {
+          if (!signature) {
+            return fn;
+          } // This code marks the function object with a unique property
+
+
+          return (0, _gen.CallExpression)((0, _gen.FunctionExpression)([], [(0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)("fn", fn)), (0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.MemberExpression)((0, _gen.Identifier)("fn"), (0, _gen.Literal)(signature), true), (0, _gen.Literal)(true))), (0, _gen.ReturnStatement)((0, _gen.Identifier)("fn"))]), []);
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          arrayExpression.elements[names.get(name)] = applySignature(newFunction);
 
           if (Array.isArray(parents[0])) {
             parents[0].splice(parents[0].indexOf(object), 1);
@@ -250,7 +289,9 @@ class RGF extends _transform.default {
             this.error(new Error("Error deleting function declaration: " + parents.map(x => x.type).join(",")));
           }
         } else {
-          this.replace(object, newFunction);
+          // The wrapper function passes the reference array around
+          var wrapperFunction = (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)(newFunction, (0, _gen.Literal)("call"), true), [(0, _gen.Identifier)("undefined"), (0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]);
+          this.replace(object, applySignature(wrapperFunction));
         }
       });
     };

package/dist/transforms/string/stringSplitting.js

@@ -45,28 +45,8 @@ class StringSplitting extends _transform.default {
     this.vars = [];
   }
 
-  apply(tree) {
-    super.apply(tree);
-
-    if (this.vars.length) {
-      (0, _random.shuffle)(this.adders);
-      (0, _random.shuffle)(this.vars);
-      var body = tree.body;
-      this.adders.forEach(nodes => {
-        nodes.forEach(x => body.unshift(x));
-      });
-      var variableDeclaration = {
-        type: "VariableDeclaration",
-        declarations: [],
-        kind: "var"
-      };
-      this.vars.forEach(node => variableDeclaration.declarations.push(node));
-      body.unshift(variableDeclaration);
-    }
-  }
-
   match(object, parents) {
-    return object.type == "Literal" && typeof object.value === "string" && !(0, _stringConcealing.isModuleSource)(object, parents) && !(0, _compare.isDirective)(object, parents);
+    return object.type == "Literal" && typeof object.value === "string" && object.value.length >= 8 && !(0, _stringConcealing.isModuleSource)(object, parents) && !(0, _compare.isDirective)(object, parents);
   }
 
   transform(object, parents) {
@@ -92,7 +72,6 @@ class StringSplitting extends _transform.default {
       var last = chunks.pop();
       chunks.forEach((chunk, i) => {
         if (i == 0) {
-          (0, _assert.ok)(i == 0);
           parent = binaryExpression = (0, _gen.BinaryExpression)("+", (0, _gen.Literal)(chunk), (0, _gen.Literal)(""));
         } else {
           binaryExpression.left = (0, _gen.BinaryExpression)("+", (0, _insert.clone)(binaryExpression.left), (0, _gen.Literal)(chunk));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -45,7 +45,7 @@
   "bugs": {
     "url": "https://github.com/MichaelXF/js-confuser/issues"
   },
-  "homepage": "https://jsconfuser.com",
+  "homepage": "https://master--hungry-shannon-c1ce6b.netlify.app/",
   "jest": {
     "coverageReporters": [
       "html"

package/src/transforms/flatten.ts

@@ -328,8 +328,8 @@ export default class Flatten extends Transform {
       var pop = CallExpression(
         MemberExpression(
           MemberExpression(Identifier(resultName), Identifier(propName), false),
-          Identifier("pop"),
-          false
+          Literal("pop"),
+          true
         ),
         []
       );

package/src/transforms/identifier/variableAnalysis.ts

@@ -93,10 +93,10 @@ export default class VariableAnalysis extends Transform {
         ok(definingContexts.length);
 
         definingContexts.forEach((definingContext) => {
-          ok(
-            isContext(definingContext),
-            `${definingContext.type} is not a context`
-          );
+          // ok(
+          //   isContext(definingContext),
+          //   `${definingContext.type} is not a context`
+          // );
 
           if (isDefined) {
             // Add to defined Map

package/src/transforms/minify.ts

@@ -61,9 +61,10 @@ export default class Minify extends Transform {
 
         body.forEach((stmt, i) => {
           if (
-            stmt.type == "ReturnStatement" ||
-            stmt.type == "BreakStatement" ||
-            stmt.type == "ContinueStatement"
+            stmt.type === "ReturnStatement" ||
+            stmt.type === "BreakStatement" ||
+            stmt.type === "ContinueStatement" ||
+            stmt.type === "ThrowStatement"
           ) {
             if (earlyReturn > i + 1) {
               earlyReturn = i + 1;
@@ -156,7 +157,7 @@ export default class Minify extends Transform {
               ) {
                 lastDec = x;
               } else {
-                lastDec.declarations.push(...x.declarations);
+                lastDec.declarations.push(...clone(x.declarations));
                 remove.unshift(i);
               }
             } else {

package/src/transforms/rgf.ts

@@ -7,7 +7,10 @@ import Template from "../templates/template";
 import traverse, { walk } from "../traverse";
 import {
   ArrayExpression,
+  AssignmentExpression,
   CallExpression,
+  ConditionalExpression,
+  ExpressionStatement,
   FunctionExpression,
   Identifier,
   Literal,
@@ -28,6 +31,7 @@ import {
   isFunction,
   prepend,
 } from "../util/insert";
+import { getRandomString } from "../util/random";
 import Transform from "./transform";
 
 /**
@@ -70,6 +74,8 @@ export default class RGF extends Transform {
       }[] = [];
       var queue: Location[] = [];
       var names = new Map<string, number>();
+      var referenceSignatures: { [name: string]: string } = {};
+
       var definingNodes = new Map<string, Node>();
 
       walk(contextObject, contextParents, (object, parents) => {
@@ -81,6 +87,25 @@ export default class RGF extends Transform {
           !object.generator &&
           getVarContext(parents[0], parents.slice(1)) === contextObject
         ) {
+          // Discard getter/setter methods
+          if (parents[0].type === "Property" && parents[0].value === object) {
+            if (
+              parents[0].method ||
+              parents[0].kind === "get" ||
+              parents[0].kind === "set"
+            ) {
+              return;
+            }
+          }
+
+          // Discard class methods
+          if (
+            parents[0].type === "MethodDefinition" &&
+            parents[0].value === object
+          ) {
+            return;
+          }
+
           var defined = new Set<string>(),
             referenced = new Set<string>();
 
@@ -177,6 +202,8 @@ export default class RGF extends Transform {
             var index = names.size;
 
             names.set(object.id.name, index);
+            referenceSignatures[index] = getRandomString(10);
+
             definingNodes.set(object.id.name, object.id);
           }
         }
@@ -186,7 +213,8 @@ export default class RGF extends Transform {
         return;
       }
 
-      var referenceArray = this.generateIdentifier();
+      // An array containing all the function declarations
+      var referenceArray = "_" + getRandomString(10);
 
       walk(contextObject, contextParents, (o, p) => {
         if (o.type == "Identifier" && !reservedIdentifiers.has(o.name)) {
@@ -204,27 +232,50 @@ export default class RGF extends Transform {
                 if (pointingTo == shouldBe) {
                   this.log(o.name, "->", `${referenceArray}[${index}]`);
 
-                  this.replace(
-                    o,
-                    FunctionExpression(
-                      [],
-                      [
-                        ReturnStatement(
-                          CallExpression(
-                            MemberExpression(
-                              Identifier(referenceArray),
-                              Literal(index),
-                              true
-                            ),
-                            [
+                  var memberExpression = MemberExpression(
+                    Identifier(referenceArray),
+                    Literal(index),
+                    true
+                  );
+
+                  // Allow re-assignment to the RGF function
+                  if (
+                    p[0] &&
+                    p[0].type === "AssignmentExpression" &&
+                    p[0].left === o
+                  ) {
+                    // fn = ...
+
+                    this.replace(o, memberExpression);
+                  } else {
+                    // fn()
+                    // fn
+
+                    // In most cases the identifier is being used like this (call expression, or referenced to be called later)
+                    // Replace it with a simple wrapper function that will pass on the reference array
+
+                    var conditionalExpression = ConditionalExpression(
+                      Template(
+                        `typeof ${referenceArray}[${index}] === "function" && ${referenceArray}[${index}]["${
+                          referenceSignatures[index] || "_"
+                        }"]`
+                      ).single().expression,
+                      FunctionExpression(
+                        [],
+                        [
+                          ReturnStatement(
+                            CallExpression(memberExpression, [
                               Identifier(referenceArray),
                               SpreadElement(Identifier("arguments")),
-                            ]
-                          )
-                        ),
-                      ]
-                    )
-                  );
+                            ])
+                          ),
+                        ]
+                      ),
+                      memberExpression
+                    );
+
+                    this.replace(o, conditionalExpression);
+                  }
                 }
               }
             }
@@ -243,6 +294,7 @@ export default class RGF extends Transform {
         var name = object?.id?.name;
         var hasName = !!name;
         var params = object.params.map((x) => x.name) || [];
+        var signature = referenceSignatures[names.get(name)];
 
         var embeddedName = name || this.getPlaceholder();
 
@@ -280,11 +332,11 @@ export default class RGF extends Transform {
               CallExpression(
                 MemberExpression(
                   Identifier(embeddedName),
-                  Identifier("call"),
-                  false
+                  Literal("call"),
+                  true
                 ),
                 [
-                  ThisExpression(),
+                  Identifier("undefined"),
                   SpreadElement(
                     Template(
                       `Array.prototype.slice.call(arguments, 1)`
@@ -322,8 +374,38 @@ export default class RGF extends Transform {
           Literal(toString),
         ]);
 
-        if (hasName) {
-          arrayExpression.elements[names.get(name)] = newFunction;
+        function applySignature(fn) {
+          if (!signature) {
+            return fn;
+          }
+
+          // This code marks the function object with a unique property
+          return CallExpression(
+            FunctionExpression(
+              [],
+              [
+                VariableDeclaration(VariableDeclarator("fn", fn)),
+                ExpressionStatement(
+                  AssignmentExpression(
+                    "=",
+                    MemberExpression(
+                      Identifier("fn"),
+                      Literal(signature),
+                      true
+                    ),
+                    Literal(true)
+                  )
+                ),
+                ReturnStatement(Identifier("fn")),
+              ]
+            ),
+            []
+          );
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          arrayExpression.elements[names.get(name)] =
+            applySignature(newFunction);
 
           if (Array.isArray(parents[0])) {
             parents[0].splice(parents[0].indexOf(object), 1);
@@ -336,7 +418,24 @@ export default class RGF extends Transform {
             );
           }
         } else {
-          this.replace(object, newFunction);
+          // The wrapper function passes the reference array around
+          var wrapperFunction = FunctionExpression(
+            [],
+            [
+              ReturnStatement(
+                CallExpression(
+                  MemberExpression(newFunction, Literal("call"), true),
+                  [
+                    Identifier("undefined"),
+                    Identifier(referenceArray),
+                    SpreadElement(Identifier("arguments")),
+                  ]
+                )
+              ),
+            ]
+          );
+
+          this.replace(object, applySignature(wrapperFunction));
         }
       });
     };

package/src/transforms/string/stringSplitting.ts

@@ -25,34 +25,11 @@ export default class StringSplitting extends Transform {
     this.vars = [];
   }
 
-  apply(tree) {
-    super.apply(tree);
-
-    if (this.vars.length) {
-      shuffle(this.adders);
-      shuffle(this.vars);
-
-      var body: Node[] = tree.body;
-
-      this.adders.forEach((nodes) => {
-        nodes.forEach((x) => body.unshift(x));
-      });
-
-      var variableDeclaration = {
-        type: "VariableDeclaration",
-        declarations: [],
-        kind: "var",
-      };
-      this.vars.forEach((node) => variableDeclaration.declarations.push(node));
-
-      body.unshift(variableDeclaration);
-    }
-  }
-
   match(object: Node, parents: Node[]) {
     return (
       object.type == "Literal" &&
       typeof object.value === "string" &&
+      object.value.length >= 8 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents)
     );
@@ -87,7 +64,6 @@ export default class StringSplitting extends Transform {
       var last = chunks.pop();
       chunks.forEach((chunk, i) => {
         if (i == 0) {
-          ok(i == 0);
           parent = binaryExpression = BinaryExpression(
             "+",
             Literal(chunk),

package/test/transforms/minify.test.ts

@@ -301,9 +301,9 @@ test("Variant #15: Removing implied 'return'", async () => {
 });
 
 // https://github.com/MichaelXF/js-confuser/issues/43
-test("Variant #16: Handle deconstructuring in for loop", async ()=>{
-// Valid
-var output = await JsConfuser(
+test("Variant #16: Handle deconstructuring in for loop", async () => {
+  // Valid
+  var output = await JsConfuser(
     `
     for(const [a] of [[1]]) {
         input(a);
@@ -313,11 +313,56 @@ var output = await JsConfuser(
   );
 
   var value;
-  function input(valueIn){
+  function input(valueIn) {
     value = valueIn;
   }
 
   eval(output);
 
   expect(value).toStrictEqual(1);
-})
+});
+
+test("Variant #17: Remove unreachable code following a return statement", async () => {
+  var output = await JsConfuser(
+    `
+    function myFunction(){
+      return;
+      unreachableStmt;
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});
+
+test("Variant #18: Remove unreachable code following a continue or break statement", async () => {
+  var output = await JsConfuser(
+    `
+    for(var i =0; i < 10; i++){
+      continue;
+      unreachableStmt
+    }
+
+    while(true){
+      break;
+      unreachableStmt
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});
+
+test("Variant #19: Remove unreachable code following a throw statement", async () => {
+  var output = await JsConfuser(
+    `
+    throw new Error("No more code to run");
+    unreachableStmt;
+  `,
+    { target: "node", minify: true }
+  );
+
+  expect(output).not.toContain("unreachableStmt");
+});

package/test/transforms/rgf.test.ts

@@ -154,6 +154,103 @@ input(console.log, result)
     eval(output);
     expect(value).toStrictEqual(60);
   });
+
+  // https://github.com/MichaelXF/js-confuser/issues/64
+  it("should work on Arrow Functions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var double = (num)=>num*2;
+      TEST_VALUE = double(10);
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual(20);
+  });
+
+  it("should work on Function Expressions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var double = function(num){
+        return num * 2
+      };
+      TEST_VALUE = double(10);
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual(20);
+  });
+
+  it("should work on re-assigned functions", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var fn1 = ()=>{
+        return "FN1";
+      }
+      var fn2 = ()=>{
+        fn1 = ()=>{
+          return "FN1 - Modified"
+        }
+      }
+      fn2();
+      TEST_VALUE = fn1();
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual("FN1 - Modified");
+  });
+
+  it("should work on re-assigned functions to non-function values", async () => {
+    var output = await JsConfuser.obfuscate(
+      `
+      var fn1 = ()=>{
+        return "FN1";
+      }
+      var fn2 = ()=>{
+        fn1 = undefined;
+      }
+      fn2();
+      TEST_VALUE = typeof fn1;
+      `,
+      {
+        target: "node",
+        rgf: true,
+      }
+    );
+
+    expect(output).toContain("new Function");
+
+    var TEST_VALUE;
+
+    eval(output);
+    expect(TEST_VALUE).toStrictEqual("undefined");
+  });
 });
 
 describe("RGF with the 'all' mode", () => {