js-confuser 2.0.0-alpha.4 → 2.0.0-alpha.5

package/dist/constants.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.variableFunctionName = exports.reservedObjectPrototype = exports.reservedNodeModuleIdentifiers = exports.reservedKeywords = exports.reservedIdentifiers = exports.predictableFunctionTag = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.WITH_STATEMENT = exports.UNSAFE = exports.SKIP = exports.PREDICTABLE = exports.NO_RENAME = exports.NO_REMOVE = exports.MULTI_TRANSFORM = exports.GEN_NODE = exports.FN_LENGTH = void 0;
-var predictableFunctionTag = exports.predictableFunctionTag = "__JS_PREDICT__";
-
+exports.variableFunctionName = exports.reservedObjectPrototype = exports.reservedNodeModuleIdentifiers = exports.reservedKeywords = exports.reservedIdentifiers = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.WITH_STATEMENT = exports.UNSAFE = exports.SKIP = exports.PREDICTABLE = exports.NO_RENAME = exports.NO_REMOVE = exports.MULTI_TRANSFORM = exports.GEN_NODE = exports.FN_LENGTH = void 0;
 /**
  * A function is 'unsafe' if it requires 'eval', 'arguments' or 'this'
  *
@@ -89,6 +87,6 @@ var reservedObjectPrototype = exports.reservedObjectPrototype = new Set(["toStri
 /**
  * For Zero Width generator - Mangled variable names
  */
-var reservedKeywords = exports.reservedKeywords = ["if", "in", "for", "let", "new", "try", "var", "case", "else", "null", "break", "catch", "class", "const", "super", "throw", "while", "yield", "delete", "export", "import", "public", "return", "switch", "default", "finally", "private", "continue", "debugger", "function", "arguments", "protected", "instanceof", "await", "async",
+var reservedKeywords = exports.reservedKeywords = ["if", "in", "do", "for", "let", "new", "try", "var", "case", "else", "null", "with", "break", "catch", "class", "const", "super", "throw", "while", "yield", "delete", "export", "import", "public", "return", "switch", "default", "finally", "private", "continue", "debugger", "function", "arguments", "protected", "instanceof", "await", "async",
 // new key words and other fun stuff :P
 "NaN", "undefined", "true", "false", "typeof", "this", "static", "void", "of"];

package/dist/index.js

@@ -119,8 +119,13 @@ function _obfuscateWithProfiler() {
                 changeData: {}
               };
               transformMap[log.currentTransform] = entry;
-              currentTransformTime = nowTime;
+
+              // (JS-Confuser.com can run performance benchmark tests here)
               (_profiler$callback = _profiler.callback) === null || _profiler$callback === void 0 || _profiler$callback.call(_profiler, log, entry, ast);
+
+              // The profiler.callback() function may take a long time to execute,
+              // so we need to update the currentTransformTime here for accurate profiling.
+              currentTransformTime = performance.now();
             }
           });
           obfuscator.plugins.forEach(function (_ref) {

package/dist/transforms/controlFlowFlattening.js

@@ -154,7 +154,6 @@ var _default = exports["default"] = function _default(_ref) {
             if (functionPath.node.async || functionPath.node.generator) return;
           }
           programOrFunctionPath.scope.crawl();
-          var blockFnParent = (0, _astUtils.getParentFunctionOrProgram)(blockPath);
           var hasIllegalNode = false;
           var bindingNames = new Set();
           blockPath.traverse({
@@ -204,6 +203,7 @@ var _default = exports["default"] = function _default(_ref) {
             return withIdentifier("state_".concat(i));
           });
           var argVar = withIdentifier("_arg");
+          var usedArgVar = false;
           var _didReturnVar = withIdentifier("return");
           var basicBlocks = new Map();
 
@@ -220,11 +220,6 @@ var _default = exports["default"] = function _default(_ref) {
           var withProperty = isDebug ? "with" : scopeNameGen.generate(false);
           var withMemberExpression = new _template["default"]("".concat(scopeVar.name, "[\"").concat(withProperty, "\"]")).expression();
           withMemberExpression.object[_constants.NO_RENAME] = cffIndex;
-
-          // Create 'resetWith' function - Safely resets the 'with' object to none
-          var resetWithProperty = isDebug ? "resetWith" : scopeNameGen.generate(false);
-          var resetWithMemberExpression = new _template["default"]("".concat(scopeVar.name, "[\"").concat(resetWithProperty, "\"]")).expression();
-          resetWithMemberExpression.object[_constants.NO_RENAME] = cffIndex;
           var ScopeManager = /*#__PURE__*/function () {
             function ScopeManager(scope, initializingBasicBlock) {
               _classCallCheck(this, ScopeManager);
@@ -234,14 +229,17 @@ var _default = exports["default"] = function _default(_ref) {
               _defineProperty(this, "nameGen", addWithStatement ? me.obfuscator.nameGen : new _NameGen.NameGen(me.options.identifierGenerator));
               this.scope = scope;
               this.initializingBasicBlock = initializingBasicBlock;
-              this.propertyName = isDebug ? "_" + scopeCounter++ : scopeNameGen.generate();
+              this.propertyName = isDebug ? "_" + cffIndex + "_" + scopeCounter++ : scopeNameGen.generate();
             }
             return _createClass(ScopeManager, [{
               key: "findBestWithDiscriminant",
               value: function findBestWithDiscriminant(basicBlock) {
                 var _this$parent;
+                // This initializing block is forbidden to have a with discriminant
+                // (As no previous code is able to prepare the with discriminant)
                 if (basicBlock !== this.initializingBasicBlock) {
-                  if (this.nameMap.size > 0) return this;
+                  // If no variables were defined in this scope, don't use it
+                  if (Object.keys(this.scope.bindings).length > 0) return this;
                 }
                 return (_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.findBestWithDiscriminant(basicBlock);
               }
@@ -290,7 +288,8 @@ var _default = exports["default"] = function _default(_ref) {
             }, {
               key: "getMemberExpression",
               value: function getMemberExpression(name) {
-                var memberExpression = t.memberExpression(this.getScopeObject(), t.stringLiteral(name), true);
+                var object = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getScopeObject();
+                var memberExpression = t.memberExpression(object, t.stringLiteral(name), true);
                 return memberExpression;
               }
             }, {
@@ -316,13 +315,6 @@ var _default = exports["default"] = function _default(_ref) {
                 for (var key in propertyMap) {
                   properties.push(t.objectProperty(t.stringLiteral(key), propertyMap[key], true));
                 }
-                if (this === mainScope) {
-                  // Reset With logic
-                  properties.push(t.objectProperty(t.stringLiteral(resetWithProperty), new _template["default"]("\n                        (function(newStateValues, alwaysUndefined){\n                          {withMemberExpression} = alwaysUndefined;\n                          {arrayPattern} = newStateValues\n                        })\n                      ").expression({
-                    withMemberExpression: (0, _node.deepClone)(withMemberExpression),
-                    arrayPattern: t.arrayPattern((0, _node.deepClone)(stateVars))
-                  }), true));
-                }
                 return t.objectExpression(properties);
               }
             }, {
@@ -396,7 +388,7 @@ var _default = exports["default"] = function _default(_ref) {
             return _createClass(BasicBlock, [{
               key: "withDiscriminant",
               get: function get() {
-                if (!this.allowWithDiscriminant) return null;
+                if (!this.allowWithDiscriminant) return;
                 return this.bestWithDiscriminant;
               }
             }, {
@@ -599,8 +591,9 @@ var _default = exports["default"] = function _default(_ref) {
                     fnTopBlock.body.unshift(t.expressionStatement(t.stringLiteral("Function " + statement.node.id.name + " -> Renamed to " + rename)));
                   }
 
-                  // Unpack parameters
+                  // Unpack parameters from the parameter 'argVar'
                   if (statement.node.params.length > 0) {
+                    usedArgVar = true;
                     fnTopBlock.body.unshift(t.variableDeclaration("var", [t.variableDeclarator(t.arrayPattern(statement.node.params), (0, _node.deepClone)(argVar))]));
 
                     // Change bindings from 'param' to 'var'
@@ -838,6 +831,8 @@ var _default = exports["default"] = function _default(_ref) {
                     if (!(0, _astUtils.isVariableIdentifier)(path)) return;
                     if (me.isSkipped(path)) return;
                     if (path.node[_constants.NO_RENAME] === cffIndex) return;
+                    // For identifiers using implicit with discriminant, skip
+                    if (path.node[_constants.WITH_STATEMENT]) return;
                     var identifierName = path.node.name;
                     if (identifierName === gotoFunctionName) return;
                     var binding = path.scope.getBinding(identifierName);
@@ -847,22 +842,29 @@ var _default = exports["default"] = function _default(_ref) {
                     if (binding.kind === "var" || binding.kind === "let" || binding.kind === "const") {} else {
                       return;
                     }
-
-                    // console.log("No binding found for " + identifierName);
-
                     var scopeManager = scopeToScopeManager.get(binding.scope);
                     if (!scopeManager) return;
                     var newName = scopeManager.getNewName(identifierName, path.node);
                     var memberExpression = scopeManager.getMemberExpression(newName);
                     scopeManager.isNotUsed = false;
+
+                    // Scope object as with discriminant? Use identifier
+                    if (typeof basicBlock.withDiscriminant === "undefined") {
+                      var id = t.identifier(scopeManager.propertyName);
+                      id[_constants.WITH_STATEMENT] = true;
+                      id[_constants.NO_RENAME] = cffIndex;
+                      memberExpression = scopeManager.getMemberExpression(newName, id);
+                    }
                     if ((0, _astUtils.isDefiningIdentifier)(path)) {
                       (0, _astUtils.replaceDefiningIdentifierToMemberExpression)(path, memberExpression);
                       return;
                     }
                     if (!path.container) return;
-                    var isModified = (0, _astUtils.isModifiedIdentifier)(path);
                     if (basicBlock.withDiscriminant && basicBlock.withDiscriminant === scopeManager && basicBlock.withDiscriminant.hasOwnName(identifierName)) {
-                      if (!isModified) {
+                      // The defining mode must directly append to the scope object
+                      // Subsequent uses can use the identifier
+                      var isDefiningNode = path.node === binding.identifier;
+                      if (!isDefiningNode) {
                         memberExpression = basicBlock.identifier(newName, scopeManager);
                       }
                     }
@@ -902,28 +904,28 @@ var _default = exports["default"] = function _default(_ref) {
                       var newStateValues = jumpBlock.stateValues,
                         newTotalState = jumpBlock.totalState;
                       var assignments = [];
-                      var needsIndividualAssignments = true;
                       if (jumpBlock.withDiscriminant) {
                         assignments.push(t.assignmentExpression("=", (0, _node.deepClone)(withMemberExpression), jumpBlock.withDiscriminant.getScopeObject()));
                       } else if (basicBlock.withDiscriminant) {
-                        assignments.push(t.callExpression((0, _node.deepClone)(resetWithMemberExpression), [t.arrayExpression(newStateValues.map(_node.numericLiteral))]));
-                        needsIndividualAssignments = false;
+                        // Reset the with discriminant to undefined using fake property
+                        // scope["fake"] -> undefined
+
+                        var fakeProperty = scopeNameGen.generate();
+                        assignments.push(t.assignmentExpression("=", (0, _node.deepClone)(withMemberExpression), t.memberExpression((0, _node.deepClone)(scopeVar), t.stringLiteral(fakeProperty), true)));
                       }
-                      if (needsIndividualAssignments) {
-                        for (var _i8 = 0; _i8 < stateVars.length; _i8++) {
-                          var oldValue = currentStateValues[_i8];
-                          var newValue = newStateValues[_i8];
-
-                          // console.log(oldValue, newValue);
-                          if (oldValue === newValue) continue; // No diff needed if the value doesn't change
-
-                          var assignment = t.assignmentExpression("=", (0, _node.deepClone)(stateVars[_i8]), (0, _node.numericLiteral)(newValue));
-                          if (!isDebug && addRelativeAssignments) {
-                            // Use diffs to create confusing code
-                            assignment = t.assignmentExpression("+=", (0, _node.deepClone)(stateVars[_i8]), (0, _node.numericLiteral)(newValue - oldValue));
-                          }
-                          assignments.push(assignment);
+                      for (var _i8 = 0; _i8 < stateVars.length; _i8++) {
+                        var oldValue = currentStateValues[_i8];
+                        var newValue = newStateValues[_i8];
+
+                        // console.log(oldValue, newValue);
+                        if (oldValue === newValue) continue; // No diff needed if the value doesn't change
+
+                        var assignment = t.assignmentExpression("=", (0, _node.deepClone)(stateVars[_i8]), (0, _node.numericLiteral)(newValue));
+                        if (!isDebug && addRelativeAssignments) {
+                          // Use diffs to create confusing code
+                          assignment = t.assignmentExpression("+=", (0, _node.deepClone)(stateVars[_i8]), (0, _node.numericLiteral)(newValue - oldValue));
                         }
+                        assignments.push(assignment);
                       }
 
                       // Add debug label
@@ -1113,10 +1115,11 @@ var _default = exports["default"] = function _default(_ref) {
           var switchStatement = t.labeledStatement(t.identifier(switchLabel), t.switchStatement(discriminant, switchCases));
           var startStateValues = basicBlocks.get(startLabel).stateValues;
           var endTotalState = basicBlocks.get(endLabel).totalState;
-          var whileStatement = t.whileStatement(t.binaryExpression("!==", (0, _node.deepClone)(discriminant), (0, _node.numericLiteral)(endTotalState)), t.blockStatement([t.withStatement(new _template["default"]("{withDiscriminant} || {}").expression({
-            withDiscriminant: (0, _node.deepClone)(withMemberExpression)
+          var whileStatement = t.whileStatement(t.binaryExpression("!==", (0, _node.deepClone)(discriminant), (0, _node.numericLiteral)(endTotalState)), t.blockStatement([t.withStatement(new _template["default"]("{withDiscriminant} || {scopeVar}").expression({
+            withDiscriminant: (0, _node.deepClone)(withMemberExpression),
+            scopeVar: (0, _node.deepClone)(scopeVar)
           }), t.blockStatement([switchStatement]))]));
-          var parameters = [].concat(_toConsumableArray(stateVars), [argVar, scopeVar]).map(function (id) {
+          var parameters = [].concat(_toConsumableArray(stateVars), [scopeVar, argVar]).map(function (id) {
             return (0, _node.deepClone)(id);
           });
           var parametersNames = parameters.map(function (id) {
@@ -1152,24 +1155,38 @@ var _default = exports["default"] = function _default(_ref) {
                   (0, _assert.ok)(false);
                 }
               }
+
+              // Ensure parameter is added (No effect if not added in this case)
             } catch (err) {
               _iterator4.e(err);
             } finally {
               _iterator4.f();
             }
+            usedArgVar = true;
             Object.assign(fn, new _template["default"]("\n              (function (...".concat(argumentsRestName, "){\n                ").concat(isDebug ? "\"Calling ".concat(originalFnName, ", Label: ").concat(fnLabel, "\";") : "", "\n                return {callExpression}\n              })\n              \n              ")).expression({
               callExpression: t.callExpression((0, _node.deepClone)(mainFnName), argumentsNodes)
             }));
           }
           var startProgramObjectExpression = basicBlocks.get(startLabel).scopeManager.getObjectExpression(startLabel);
           var mainParameters = parameters;
-          var scopeParameter = mainParameters.pop();
-          mainParameters.push(t.assignmentPattern(scopeParameter, startProgramObjectExpression));
+
+          // First state values use the default parameter for initialization
+          // function main(..., scope = { mainScope: {} }, ...){...}
+          mainParameters.splice(mainParameters.findIndex(function (p) {
+            return p.name === scopeVar.name;
+          }), 1, t.assignmentPattern((0, _node.deepClone)(scopeVar), startProgramObjectExpression));
+
+          // Remove parameter 'argVar' if never used (No function calls obfuscated)
+          if (!usedArgVar) {
+            mainParameters.pop();
+          }
           var mainFnDeclaration = t.functionDeclaration((0, _node.deepClone)(mainFnName), parameters, t.blockStatement([whileStatement]));
+
+          // The main function is always called with same number of arguments
           mainFnDeclaration[_constants.PREDICTABLE] = true;
-          var startProgramExpression = t.callExpression((0, _node.deepClone)(mainFnName), [].concat(_toConsumableArray(startStateValues.map(function (stateValue) {
+          var startProgramExpression = t.callExpression((0, _node.deepClone)(mainFnName), _toConsumableArray(startStateValues.map(function (stateValue) {
             return (0, _node.numericLiteral)(stateValue);
-          })), [t.identifier("undefined")]));
+          })));
           var _resultVar = withIdentifier("result");
           var isTopLevel = blockPath.isProgram();
           var allowReturns = !isTopLevel && blockPath.find(function (p) {

package/dist/transforms/plugin.js

@@ -89,10 +89,19 @@ var PluginInstance = exports.PluginInstance = /*#__PURE__*/function () {
           fnName: this.setFunctionLengthName
         })));
       }
+      var createCallArguments = function createCallArguments(node) {
+        var args = [node];
+
+        // 1 is the default value in the setFunction template, can exclude it
+        if (originalLength !== 1) {
+          args.push((0, _node.numericLiteral)(originalLength));
+        }
+        return args;
+      };
       if (t.isFunctionDeclaration(path.node)) {
-        (0, _astUtils.prepend)(path.parentPath, t.expressionStatement(t.callExpression(t.identifier(this.setFunctionLengthName), [t.identifier(path.node.id.name), (0, _node.numericLiteral)(originalLength)])));
+        (0, _astUtils.prepend)(path.parentPath, t.expressionStatement(t.callExpression(t.identifier(this.setFunctionLengthName), createCallArguments(t.identifier(path.node.id.name)))));
       } else if (t.isFunctionExpression(path.node) || t.isArrowFunctionExpression(path.node)) {
-        path.replaceWith(t.callExpression(t.identifier(this.setFunctionLengthName), [path.node, (0, _node.numericLiteral)(originalLength)]));
+        path.replaceWith(t.callExpression(t.identifier(this.setFunctionLengthName), createCallArguments(path.node)));
       } else {
         // TODO
       }
@@ -154,7 +163,7 @@ var PluginInstance = exports.PluginInstance = /*#__PURE__*/function () {
       for (var _len3 = arguments.length, messages = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         messages[_key3] = arguments[_key3];
       }
-      throw new Error("[".concat(this.name, "] ").concat(messages.join(", ")));
+      throw new Error("[".concat(this.name, "] ").concat(messages.join(" ")));
     }
   }]);
 }();

package/dist/utils/ast-utils.js

@@ -212,24 +212,6 @@ function getMemberExpressionPropertyAsString(member) {
   }
   return null; // If the property cannot be determined
 }
-function registerPaths(paths) {
-  var _iterator3 = _createForOfIteratorHelper(paths),
-    _step3;
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var path = _step3.value;
-      if (path.isVariableDeclaration() && path.node.kind === "var") {
-        getParentFunctionOrProgram(path).scope.registerDeclaration(path);
-      }
-      path.scope.registerDeclaration(path);
-    }
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
-  }
-  return paths;
-}
 function nodeListToNodes(nodesIn) {
   var nodes = [];
   if (Array.isArray(nodesIn[0])) {
@@ -258,11 +240,11 @@ function append(path) {
   if (listParent.isProgram()) {
     var lastExpression = listParent.get("body").at(-1);
     if (lastExpression.isExpressionStatement()) {
-      return registerPaths(lastExpression.insertBefore(nodes));
+      return lastExpression.insertBefore(nodes);
     }
   }
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.pushContainer("consequent", nodes));
+    return listParent.pushContainer("consequent", nodes);
   }
   if (listParent.isFunction()) {
     var body = listParent.get("body");
@@ -272,10 +254,10 @@ function append(path) {
       }
     }
     (0, _assert.ok)(body.isBlockStatement());
-    return registerPaths(body.pushContainer("body", nodes));
+    return body.pushContainer("body", nodes);
   }
   (0, _assert.ok)(listParent.isBlock());
-  return registerPaths(listParent.pushContainer("body", nodes));
+  return listParent.pushContainer("body", nodes);
 }
 
 /**
@@ -304,28 +286,28 @@ function prepend(path) {
     // Filter out import declarations
     var _body = listParent.get("body");
     var afterImport = 0;
-    var _iterator4 = _createForOfIteratorHelper(_body),
-      _step4;
+    var _iterator3 = _createForOfIteratorHelper(_body),
+      _step3;
     try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        var stmt = _step4.value;
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var stmt = _step3.value;
         if (!stmt.isImportDeclaration()) {
           break;
         }
         afterImport++;
       }
     } catch (err) {
-      _iterator4.e(err);
+      _iterator3.e(err);
     } finally {
-      _iterator4.f();
+      _iterator3.f();
     }
     if (afterImport === 0) {
       // No import declarations, so we can safely unshift everything
-      return registerPaths(listParent.unshiftContainer("body", nodes));
+      return listParent.unshiftContainer("body", nodes);
     }
 
     // Insert the nodes after the last import declaration
-    return registerPaths(_body[afterImport - 1].insertAfter(nodes));
+    return _body[afterImport - 1].insertAfter(nodes);
   }
   if (listParent.isFunction()) {
     var body = listParent.get("body");
@@ -335,13 +317,13 @@ function prepend(path) {
       }
     }
     (0, _assert.ok)(body.isBlockStatement());
-    return registerPaths(body.unshiftContainer("body", nodes));
+    return body.unshiftContainer("body", nodes);
   }
   if (listParent.isBlock()) {
-    return registerPaths(listParent.unshiftContainer("body", nodes));
+    return listParent.unshiftContainer("body", nodes);
   }
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.unshiftContainer("consequent", nodes));
+    return listParent.unshiftContainer("consequent", nodes);
   }
   (0, _assert.ok)(false);
 }

package/package.json

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

package/src/constants.ts

@@ -1,5 +1,3 @@
-export const predictableFunctionTag = "__JS_PREDICT__";
-
 /**
  * A function is 'unsafe' if it requires 'eval', 'arguments' or 'this'
  *
@@ -121,6 +119,7 @@ export const reservedObjectPrototype = new Set([
 export const reservedKeywords = [
   "if",
   "in",
+  "do",
   "for",
   "let",
   "new",
@@ -129,6 +128,7 @@ export const reservedKeywords = [
   "case",
   "else",
   "null",
+  "with",
   "break",
   "catch",
   "class",

package/src/index.ts

@@ -66,8 +66,13 @@ export async function obfuscateWithProfiler(
       };
 
       transformMap[log.currentTransform] = entry;
-      currentTransformTime = nowTime;
+
+      // (JS-Confuser.com can run performance benchmark tests here)
       profiler.callback?.(log, entry, ast);
+
+      // The profiler.callback() function may take a long time to execute,
+      // so we need to update the currentTransformTime here for accurate profiling.
+      currentTransformTime = performance.now();
     },
   });
 

package/src/templates/integrityTemplate.ts

@@ -1,4 +1,4 @@
-import { MULTI_TRANSFORM, SKIP, UNSAFE } from "../constants";
+import { MULTI_TRANSFORM, SKIP } from "../constants";
 import Template from "./template";
 
 /**

package/src/transforms/controlFlowFlattening.ts

@@ -5,7 +5,6 @@ import {
   ensureComputedExpression,
   getParentFunctionOrProgram,
   isDefiningIdentifier,
-  isModifiedIdentifier,
   isStrictMode,
   isVariableIdentifier,
   replaceDefiningIdentifierToMemberExpression,
@@ -163,8 +162,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           }
           programOrFunctionPath.scope.crawl();
 
-          const blockFnParent = getParentFunctionOrProgram(blockPath);
-
           let hasIllegalNode = false;
           const bindingNames = new Set<string>();
           blockPath.traverse({
@@ -231,6 +228,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             .map((_, i) => withIdentifier(`state_${i}`));
 
           const argVar = withIdentifier("_arg");
+          let usedArgVar = false;
 
           const didReturnVar = withIdentifier("return");
 
@@ -255,16 +253,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           ).expression<t.MemberExpression>();
           withMemberExpression.object[NO_RENAME] = cffIndex;
 
-          // Create 'resetWith' function - Safely resets the 'with' object to none
-          const resetWithProperty = isDebug
-            ? "resetWith"
-            : scopeNameGen.generate(false);
-
-          const resetWithMemberExpression = new Template(
-            `${scopeVar.name}["${resetWithProperty}"]`
-          ).expression<t.MemberExpression>();
-          resetWithMemberExpression.object[NO_RENAME] = cffIndex;
-
           class ScopeManager {
             isNotUsed = true;
             requiresInitializing = true;
@@ -275,8 +263,11 @@ export default ({ Plugin }: PluginArg): PluginObject => {
               : new NameGen(me.options.identifierGenerator);
 
             findBestWithDiscriminant(basicBlock: BasicBlock): ScopeManager {
+              // This initializing block is forbidden to have a with discriminant
+              // (As no previous code is able to prepare the with discriminant)
               if (basicBlock !== this.initializingBasicBlock) {
-                if (this.nameMap.size > 0) return this;
+                // If no variables were defined in this scope, don't use it
+                if (Object.keys(this.scope.bindings).length > 0) return this;
               }
 
               return this.parent?.findBestWithDiscriminant(basicBlock);
@@ -337,9 +328,12 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 : new Template(`({})`).expression();
             }
 
-            getMemberExpression(name: string) {
+            getMemberExpression(
+              name: string,
+              object: t.Expression = this.getScopeObject()
+            ) {
               const memberExpression = t.memberExpression(
-                this.getScopeObject(),
+                object,
                 t.stringLiteral(name),
                 true
               );
@@ -353,7 +347,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
               public initializingBasicBlock: BasicBlock
             ) {
               this.propertyName = isDebug
-                ? "_" + scopeCounter++
+                ? "_" + cffIndex + "_" + scopeCounter++
                 : scopeNameGen.generate();
             }
 
@@ -390,25 +384,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                 );
               }
 
-              if (this === mainScope) {
-                // Reset With logic
-                properties.push(
-                  t.objectProperty(
-                    t.stringLiteral(resetWithProperty),
-                    new Template(`
-                        (function(newStateValues, alwaysUndefined){
-                          {withMemberExpression} = alwaysUndefined;
-                          {arrayPattern} = newStateValues
-                        })
-                      `).expression({
-                      withMemberExpression: deepClone(withMemberExpression),
-                      arrayPattern: t.arrayPattern(deepClone(stateVars)),
-                    }),
-                    true
-                  )
-                );
-              }
-
               return t.objectExpression(properties);
             }
 
@@ -434,7 +409,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             bestWithDiscriminant: ScopeManager;
 
             get withDiscriminant() {
-              if (!this.allowWithDiscriminant) return null;
+              if (!this.allowWithDiscriminant) return;
 
               return this.bestWithDiscriminant;
             }
@@ -774,8 +749,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                   );
                 }
 
-                // Unpack parameters
+                // Unpack parameters from the parameter 'argVar'
                 if (statement.node.params.length > 0) {
+                  usedArgVar = true;
                   fnTopBlock.body.unshift(
                     t.variableDeclaration("var", [
                       t.variableDeclarator(
@@ -1099,6 +1075,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                   if (!isVariableIdentifier(path)) return;
                   if (me.isSkipped(path)) return;
                   if ((path.node as NodeSymbol)[NO_RENAME] === cffIndex) return;
+                  // For identifiers using implicit with discriminant, skip
+                  if ((path.node as NodeSymbol)[WITH_STATEMENT]) return;
 
                   const identifierName = path.node.name;
                   if (identifierName === gotoFunctionName) return;
@@ -1117,8 +1095,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                     return;
                   }
 
-                  // console.log("No binding found for " + identifierName);
-
                   var scopeManager = scopeToScopeManager.get(binding.scope);
                   if (!scopeManager) return;
 
@@ -1132,6 +1108,18 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
                   scopeManager.isNotUsed = false;
 
+                  // Scope object as with discriminant? Use identifier
+                  if (typeof basicBlock.withDiscriminant === "undefined") {
+                    const id = t.identifier(scopeManager.propertyName);
+                    (id as NodeSymbol)[WITH_STATEMENT] = true;
+                    (id as NodeSymbol)[NO_RENAME] = cffIndex;
+
+                    memberExpression = scopeManager.getMemberExpression(
+                      newName,
+                      id
+                    );
+                  }
+
                   if (isDefiningIdentifier(path)) {
                     replaceDefiningIdentifierToMemberExpression(
                       path,
@@ -1142,14 +1130,16 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
                   if (!path.container) return;
 
-                  var isModified = isModifiedIdentifier(path);
-
                   if (
                     basicBlock.withDiscriminant &&
                     basicBlock.withDiscriminant === scopeManager &&
                     basicBlock.withDiscriminant.hasOwnName(identifierName)
                   ) {
-                    if (!isModified) {
+                    // The defining mode must directly append to the scope object
+                    // Subsequent uses can use the identifier
+                    const isDefiningNode = path.node === binding.identifier;
+
+                    if (!isDefiningNode) {
                       memberExpression = basicBlock.identifier(
                         newName,
                         scopeManager
@@ -1218,7 +1208,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                     } = jumpBlock;
 
                     const assignments: t.Expression[] = [];
-                    let needsIndividualAssignments = true;
 
                     if (jumpBlock.withDiscriminant) {
                       assignments.push(
@@ -1229,39 +1218,47 @@ export default ({ Plugin }: PluginArg): PluginObject => {
                         )
                       );
                     } else if (basicBlock.withDiscriminant) {
+                      // Reset the with discriminant to undefined using fake property
+                      // scope["fake"] -> undefined
+
+                      const fakeProperty = scopeNameGen.generate();
+
                       assignments.push(
-                        t.callExpression(deepClone(resetWithMemberExpression), [
-                          t.arrayExpression(newStateValues.map(numericLiteral)),
-                        ])
+                        t.assignmentExpression(
+                          "=",
+                          deepClone(withMemberExpression),
+                          t.memberExpression(
+                            deepClone(scopeVar),
+                            t.stringLiteral(fakeProperty),
+                            true
+                          )
+                        )
                       );
-                      needsIndividualAssignments = false;
                     }
 
-                    if (needsIndividualAssignments) {
-                      for (let i = 0; i < stateVars.length; i++) {
-                        const oldValue = currentStateValues[i];
-                        const newValue = newStateValues[i];
+                    for (let i = 0; i < stateVars.length; i++) {
+                      const oldValue = currentStateValues[i];
+                      const newValue = newStateValues[i];
 
-                        // console.log(oldValue, newValue);
-                        if (oldValue === newValue) continue; // No diff needed if the value doesn't change
+                      // console.log(oldValue, newValue);
+                      if (oldValue === newValue) continue; // No diff needed if the value doesn't change
 
-                        let assignment = t.assignmentExpression(
-                          "=",
+                      let assignment = t.assignmentExpression(
+                        "=",
+                        deepClone(stateVars[i]),
+                        numericLiteral(newValue)
+                      );
+
+                      if (!isDebug && addRelativeAssignments) {
+                        // Use diffs to create confusing code
+                        assignment = t.assignmentExpression(
+                          "+=",
                           deepClone(stateVars[i]),
-                          numericLiteral(newValue)
+                          numericLiteral(newValue - oldValue)
                         );
-
-                        if (!isDebug && addRelativeAssignments) {
-                          // Use diffs to create confusing code
-                          assignment = t.assignmentExpression(
-                            "+=",
-                            deepClone(stateVars[i]),
-                            numericLiteral(newValue - oldValue)
-                          );
-                        }
-
-                        assignments.push(assignment);
                       }
+
+                      assignments.push(assignment);
                     }
 
                     // Add debug label
@@ -1515,8 +1512,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             ),
             t.blockStatement([
               t.withStatement(
-                new Template(`{withDiscriminant} || {}`).expression({
+                new Template(`{withDiscriminant} || {scopeVar}`).expression({
                   withDiscriminant: deepClone(withMemberExpression),
+                  scopeVar: deepClone(scopeVar),
                 }),
                 t.blockStatement([switchStatement])
               ),
@@ -1525,8 +1523,8 @@ export default ({ Plugin }: PluginArg): PluginObject => {
 
           const parameters: t.Identifier[] = [
             ...stateVars,
-            argVar,
             scopeVar,
+            argVar,
           ].map((id) => deepClone(id));
 
           const parametersNames: string[] = parameters.map((id) => id.name);
@@ -1558,6 +1556,9 @@ export default ({ Plugin }: PluginArg): PluginObject => {
               }
             }
 
+            // Ensure parameter is added (No effect if not added in this case)
+            usedArgVar = true;
+
             Object.assign(
               fn,
               new Template(`
@@ -1584,23 +1585,36 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             .scopeManager.getObjectExpression(startLabel);
 
           const mainParameters: t.FunctionDeclaration["params"] = parameters;
-          const scopeParameter = mainParameters.pop() as t.Identifier;
 
-          mainParameters.push(
-            t.assignmentPattern(scopeParameter, startProgramObjectExpression)
+          // First state values use the default parameter for initialization
+          // function main(..., scope = { mainScope: {} }, ...){...}
+          mainParameters.splice(
+            (mainParameters as t.Identifier[]).findIndex(
+              (p) => p.name === scopeVar.name
+            ),
+            1,
+            t.assignmentPattern(
+              deepClone(scopeVar),
+              startProgramObjectExpression
+            )
           );
 
+          // Remove parameter 'argVar' if never used (No function calls obfuscated)
+          if (!usedArgVar) {
+            mainParameters.pop();
+          }
+
           const mainFnDeclaration = t.functionDeclaration(
             deepClone(mainFnName),
             parameters,
             t.blockStatement([whileStatement])
           );
 
+          // The main function is always called with same number of arguments
           (mainFnDeclaration as NodeSymbol)[PREDICTABLE] = true;
 
           var startProgramExpression = t.callExpression(deepClone(mainFnName), [
             ...startStateValues.map((stateValue) => numericLiteral(stateValue)),
-            t.identifier("undefined"),
           ]);
 
           const resultVar = withIdentifier("result");

package/src/transforms/plugin.ts

@@ -97,14 +97,24 @@ export class PluginInstance {
       );
     }
 
+    const createCallArguments = (node: t.Expression): t.Expression[] => {
+      var args = [node];
+
+      // 1 is the default value in the setFunction template, can exclude it
+      if (originalLength !== 1) {
+        args.push(numericLiteral(originalLength));
+      }
+      return args;
+    };
+
     if (t.isFunctionDeclaration(path.node)) {
       prepend(
         path.parentPath,
         t.expressionStatement(
-          t.callExpression(t.identifier(this.setFunctionLengthName), [
-            t.identifier(path.node.id.name),
-            numericLiteral(originalLength),
-          ])
+          t.callExpression(
+            t.identifier(this.setFunctionLengthName),
+            createCallArguments(t.identifier(path.node.id.name))
+          )
         )
       );
     } else if (
@@ -112,10 +122,10 @@ export class PluginInstance {
       t.isArrowFunctionExpression(path.node)
     ) {
       path.replaceWith(
-        t.callExpression(t.identifier(this.setFunctionLengthName), [
-          path.node,
-          numericLiteral(originalLength),
-        ])
+        t.callExpression(
+          t.identifier(this.setFunctionLengthName),
+          createCallArguments(path.node)
+        )
       );
     } else {
       // TODO
@@ -158,6 +168,6 @@ export class PluginInstance {
    * @param messages
    */
   error(...messages: any[]): never {
-    throw new Error(`[${this.name}] ${messages.join(", ")}`);
+    throw new Error(`[${this.name}] ${messages.join(" ")}`);
   }
 }

package/src/utils/ast-utils.ts

@@ -215,17 +215,6 @@ export function getMemberExpressionPropertyAsString(
   return null; // If the property cannot be determined
 }
 
-function registerPaths(paths: NodePath[]) {
-  for (var path of paths) {
-    if (path.isVariableDeclaration() && path.node.kind === "var") {
-      getParentFunctionOrProgram(path).scope.registerDeclaration(path);
-    }
-    path.scope.registerDeclaration(path);
-  }
-
-  return paths;
-}
-
 function nodeListToNodes(nodesIn: (t.Statement | t.Statement[])[]) {
   var nodes: t.Statement[] = [];
   if (Array.isArray(nodesIn[0])) {
@@ -257,12 +246,12 @@ export function append(
   if (listParent.isProgram()) {
     var lastExpression = listParent.get("body").at(-1);
     if (lastExpression.isExpressionStatement()) {
-      return registerPaths(lastExpression.insertBefore(nodes));
+      return lastExpression.insertBefore(nodes);
     }
   }
 
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.pushContainer("consequent", nodes));
+    return listParent.pushContainer("consequent", nodes);
   }
 
   if (listParent.isFunction()) {
@@ -278,11 +267,11 @@ export function append(
 
     ok(body.isBlockStatement());
 
-    return registerPaths(body.pushContainer("body", nodes));
+    return body.pushContainer("body", nodes);
   }
 
   ok(listParent.isBlock());
-  return registerPaths(listParent.pushContainer("body", nodes));
+  return listParent.pushContainer("body", nodes);
 }
 
 /**
@@ -322,11 +311,11 @@ export function prepend(
 
     if (afterImport === 0) {
       // No import declarations, so we can safely unshift everything
-      return registerPaths(listParent.unshiftContainer("body", nodes));
+      return listParent.unshiftContainer("body", nodes);
     }
 
     // Insert the nodes after the last import declaration
-    return registerPaths(body[afterImport - 1].insertAfter(nodes));
+    return body[afterImport - 1].insertAfter(nodes);
   }
 
   if (listParent.isFunction()) {
@@ -342,15 +331,15 @@ export function prepend(
 
     ok(body.isBlockStatement());
 
-    return registerPaths(body.unshiftContainer("body", nodes));
+    return body.unshiftContainer("body", nodes);
   }
 
   if (listParent.isBlock()) {
-    return registerPaths(listParent.unshiftContainer("body", nodes));
+    return listParent.unshiftContainer("body", nodes);
   }
 
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.unshiftContainer("consequent", nodes));
+    return listParent.unshiftContainer("consequent", nodes);
   }
 
   ok(false);
@@ -564,7 +553,7 @@ export function isModifiedIdentifier(identifierPath: NodePath<t.Identifier>) {
 
 export function replaceDefiningIdentifierToMemberExpression(
   path: NodePath<t.Identifier>,
-  memberExpression: t.MemberExpression
+  memberExpression: t.MemberExpression | t.Identifier
 ) {
   // function id(){} -> var id = function() {}
   if (path.key === "id" && path.parentPath.isFunctionDeclaration()) {