js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/identifier/movedDeclarations.js

@@ -1,109 +1,185 @@
 "use strict";
 
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _transform = _interopRequireDefault(require("../transform"));
-var _gen = require("../../util/gen");
-var _insert = require("../../util/insert");
-var _assert = require("assert");
+exports["default"] = void 0;
 var _order = require("../../order");
 var _constants = require("../../constants");
-var _compare = require("../../util/compare");
-var _identifiers = require("../../util/identifiers");
-var _scope = require("../../util/scope");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var t = _interopRequireWildcard(require("@babel/types"));
+var _staticUtils = require("../../utils/static-utils");
+var _astUtils = require("../../utils/ast-utils");
+var _template = _interopRequireDefault(require("../../templates/template"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
 /**
- * Defines all the names at the top of every lexical block.
+ * Moved Declarations moves variables in two ways:
+ *
+ * 1) Move variables to top of the current block
+ * 2) Move variables as unused function parameters
  */
-class MovedDeclarations extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.MovedDeclarations);
-  }
-  match(object, parents) {
-    return object.type === "VariableDeclaration" && object.kind === "var" && object.declarations.length === 1 && object.declarations[0].id.type === "Identifier";
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.MovedDeclarations, {
+    changeData: {
+      variableDeclarations: 0,
+      functionParameters: 0
+    }
+  });
+  function isFunctionEligibleForParameterPacking(functionPath, proposedParameterName) {
+    // Getter/setter functions must have zero or one formal parameter
+    // We cannot add extra parameters to them
+    if (functionPath.isObjectMethod() || functionPath.isClassMethod()) {
+      if (functionPath.node.kind !== "method") {
+        return false;
+      }
+    }
+
+    // Rest params check
+    if (functionPath.get("params").find(function (p) {
+      return p.isRestElement();
+    })) return false;
+
+    // Max 1,000 parameters
+    if (functionPath.get("params").length > 1000) return false;
+
+    // Check for duplicate parameter names
+    var bindingIdentifiers = (0, _astUtils.getPatternIdentifierNames)(functionPath.get("params"));
+
+    // Duplicate parameter name not allowed
+    if (bindingIdentifiers.has(proposedParameterName)) return false;
+    return true;
   }
-  transform(object, parents) {
-    return () => {
-      var _parents, _parents2;
-      var forInitializeType = (0, _insert.isForInitialize)(object, parents);
+  return {
+    visitor: {
+      FunctionDeclaration: {
+        exit: function exit(path) {
+          var functionPath = path.findParent(function (path) {
+            return path.isFunction();
+          });
+          if (!functionPath || !functionPath.node[_constants.PREDICTABLE]) return;
 
-      // Get the block statement or Program node
-      var blockIndex = parents.findIndex(x => (0, _scope.isLexicalScope)(x));
-      var block = parents[blockIndex];
-      var body = block.type === "SwitchCase" ? block.consequent : block.body;
-      (0, _assert.ok)(Array.isArray(body), "No body array found.");
-      var bodyObject = parents[blockIndex - 2] || object;
-      var index = body.indexOf(bodyObject);
-      var varName = object.declarations[0].id.name;
-      (0, _assert.ok)(typeof varName === "string");
-      var predictableFunctionIndex = parents.findIndex(x => (0, _insert.isFunction)(x));
-      var predictableFunction = parents[predictableFunctionIndex];
-      var deleteStatement = false;
-      if (predictableFunction && (predictableFunction.id && predictableFunction.id.name.includes(_constants.predictableFunctionTag) || predictableFunction[_constants.predictableFunctionTag]) &&
-      // Must have predictableFunctionTag in the name, or on object
-      predictableFunction[_constants.predictableFunctionTag] !== false &&
-      // If === false, the function is deemed not predictable
-      predictableFunction.params.length < 1000 &&
-      // Max 1,000 parameters
-      !predictableFunction.params.find(x => x.type === "RestElement") &&
-      // Cannot add parameters after spread operator
-      !(["Property", "MethodDefinition"].includes((_parents = parents[predictableFunctionIndex + 1]) === null || _parents === void 0 ? void 0 : _parents.type) && ((_parents2 = parents[predictableFunctionIndex + 1]) === null || _parents2 === void 0 ? void 0 : _parents2.kind) !== "init") &&
-      // Preserve getter/setter methods
-      !(0, _identifiers.getFunctionParameters)(predictableFunction, parents.slice(predictableFunctionIndex)).find(entry => entry[0].name === varName) // Ensure not duplicate param name
-      ) {
-        // Use function f(..., x, y, z) to declare name
+          // Must be direct child of the function
+          if (path.parentPath !== functionPath.get("body")) return;
+          var functionName = path.node.id.name;
 
-        var value = object.declarations[0].init;
-        var isPredictablyComputed = predictableFunction.body === block && !(0, _insert.isStrictModeFunction)(predictableFunction) && value && (0, _compare.isIndependent)(value, []) && (0, _compare.isMoveable)(value, [object.declarations[0], object, ...parents]);
-        var defineWithValue = isPredictablyComputed;
-        if (defineWithValue) {
-          predictableFunction.params.push((0, _gen.AssignmentPattern)((0, _gen.Identifier)(varName), value));
-          object.declarations[0].init = null;
-          deleteStatement = true;
-        } else {
-          predictableFunction.params.push((0, _gen.Identifier)(varName));
-        }
-      } else {
-        // Use 'var x, y, z' to declare name
+          // Must be eligible for parameter packing
+          if (!isFunctionEligibleForParameterPacking(functionPath, functionName)) return;
+          var strictMode = (0, _astUtils.isStrictMode)(functionPath);
+
+          // Default parameters are not allowed when 'use strict' is declared
+          if (strictMode) return;
+          var functionExpression = path.node;
+          functionExpression.type = "FunctionExpression";
+          functionExpression.id = null;
+          var identifier = t.identifier(functionName);
+          functionPath.node.params.push(identifier);
+          var paramPath = functionPath.get("params").at(-1);
 
-        // Make sure in the block statement, and not already at the top of it
-        if (index === -1 || index === 0) return;
-        var topVariableDeclaration;
-        if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
-          topVariableDeclaration = body[0];
-        } else {
-          topVariableDeclaration = {
-            type: "VariableDeclaration",
-            declarations: [],
-            kind: "var"
-          };
-          (0, _insert.prepend)(block, topVariableDeclaration);
+          // Update binding to point to new path
+          var binding = functionPath.scope.getBinding(functionName);
+          if (binding) {
+            binding.kind = "param";
+            binding.path = paramPath;
+            binding.identifier = identifier;
+          }
+          (0, _astUtils.prepend)(functionPath, new _template["default"]("\n              if(!".concat(functionName, ") {\n                ").concat(functionName, " = {functionExpression};\n              }\n              ")).single({
+            functionExpression: functionExpression
+          }));
+          path.remove();
+          me.changeData.functionParameters++;
         }
+      },
+      VariableDeclaration: {
+        exit: function exit(path) {
+          if (path.node.kind !== "var") return;
+          if (path.node.declarations.length !== 1) return;
+          var insertionMethod = "variableDeclaration";
+          var functionPath = path.findParent(function (path) {
+            return path.isFunction();
+          });
+          var declaration = path.node.declarations[0];
+          if (!t.isIdentifier(declaration.id)) return;
+          var varName = declaration.id.name;
+          var allowDefaultParamValue = true;
+          if (functionPath && functionPath.node[_constants.PREDICTABLE]) {
+            // Check for "use strict" directive
+            // Strict mode disallows non-simple parameters
+            // So we can't move the declaration to the function parameters
+            var strictMode = (0, _astUtils.isStrictMode)(functionPath);
+            if (strictMode) {
+              allowDefaultParamValue = false;
+            }
 
-        // Add `var x` at the top of the block
-        topVariableDeclaration.declarations.push((0, _gen.VariableDeclarator)((0, _gen.Identifier)(varName)));
-      }
-      var assignmentExpression = (0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(varName), object.declarations[0].init || (0, _gen.Identifier)(varName));
-      if (forInitializeType) {
-        if (forInitializeType === "initializer") {
-          // Replace `for (var i = 0...)` to `for (i = 0...)`
-          this.replace(object, assignmentExpression);
-        } else if (forInitializeType === "left-hand") {
-          // Replace `for (var k in...)` to `for (k in ...)`
+            // Cannot add variables after rest element
+            // Cannot add over 1,000 parameters
+            if (isFunctionEligibleForParameterPacking(functionPath, varName)) {
+              insertionMethod = "functionParameter";
+            }
+          }
+          var name = declaration.id.name;
+          var value = declaration.init || t.identifier("undefined");
+          var isStatic = (0, _staticUtils.isStaticValue)(value);
+          var isDefinedAtTop = false;
+          var parentPath = path.parentPath;
+          if (parentPath.isBlock()) {
+            isDefinedAtTop = parentPath.get("body").indexOf(path) === 0;
+          }
 
-          this.replace(object, (0, _gen.Identifier)(varName));
-        }
-      } else {
-        if (deleteStatement && index !== -1) {
-          body.splice(index, 1);
-        } else {
-          // Replace `var x = value` to `x = value`
-          this.replace(object, (0, _gen.ExpressionStatement)(assignmentExpression));
+          // Already at the top - nothing will change
+          if (insertionMethod === "variableDeclaration" && isDefinedAtTop) {
+            return;
+          }
+          var defaultParamValue;
+          if (insertionMethod === "functionParameter" && isStatic && isDefinedAtTop && allowDefaultParamValue) {
+            defaultParamValue = value;
+            path.remove();
+          } else {
+            // For-in / For-of can only reference the variable name
+            if (parentPath.isForInStatement() || parentPath.isForOfStatement()) {
+              path.replaceWith(t.identifier(name));
+            } else {
+              path.replaceWith(t.assignmentExpression("=", t.identifier(name), declaration.init || t.identifier("undefined")));
+            }
+          }
+          switch (insertionMethod) {
+            case "functionParameter":
+              var identifier = t.identifier(name);
+              var param = identifier;
+              if (allowDefaultParamValue && defaultParamValue) {
+                param = t.assignmentPattern(param, defaultParamValue);
+              }
+              functionPath.node.params.push(param);
+              var paramPath = functionPath.get("params").at(-1);
+
+              // Update binding to point to new path
+              var binding = functionPath.scope.getBinding(name);
+              if (binding) {
+                binding.kind = "param";
+                binding.path = paramPath;
+                binding.identifier = identifier;
+              }
+              me.changeData.functionParameters++;
+              break;
+            case "variableDeclaration":
+              var block = path.findParent(function (path) {
+                return path.isBlock();
+              });
+              var topNode = block.node.body[0];
+              var variableDeclarator = t.variableDeclarator(t.identifier(name));
+              if (t.isVariableDeclaration(topNode) && topNode.kind === "var") {
+                topNode.declarations.push(variableDeclarator);
+                break;
+              } else {
+                block.node.body.unshift(t.variableDeclaration("var", [variableDeclarator]));
+              }
+              me.changeData.variableDeclarations++;
+              break;
+          }
         }
       }
-    };
-  }
-}
-exports.default = MovedDeclarations;
+    }
+  };
+};