js-confuser 1.5.9 → 1.7.0

package/dist/transforms/finalizer.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _order = require("../order");
+
+var _gen = require("../util/gen");
+
+var _stringEncoding = _interopRequireDefault(require("./string/stringEncoding"));
+
+var _transform = _interopRequireDefault(require("./transform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * The Finalizer is the last transformation before the code is ready to be generated.
+ *
+ * Hexadecimal numbers:
+ * - Convert integer literals into `Identifier` nodes with the name being a hexadecimal number
+ *
+ * BigInt support:
+ * - Convert BigInt literals into `Identifier` nodes with the name being the raw BigInt string value + "n"
+ *
+ * String Encoding:
+ * - Convert String literals into `Identifier` nodes with the name being a unicode escaped string
+ */
+class Finalizer extends _transform.default {
+  constructor(o) {
+    super(o, _order.ObfuscateOrder.Finalizer);
+
+    _defineProperty(this, "stringEncoding", void 0);
+
+    this.stringEncoding = new _stringEncoding.default(o);
+  }
+
+  isNumberLiteral(object) {
+    return object.type === "Literal" && typeof object.value === "number" && Math.floor(object.value) === object.value;
+  }
+
+  isBigIntLiteral(object) {
+    return object.type === "Literal" && typeof object.value === "bigint";
+  }
+
+  match(object, parents) {
+    return object.type === "Literal";
+  }
+
+  transform(object, parents) {
+    // Hexadecimal Numbers
+    if (this.options.hexadecimalNumbers && this.isNumberLiteral(object)) {
+      return () => {
+        // Technically, a Literal will never be negative because it's supposed to be inside a UnaryExpression with a "-" operator.
+        // This code handles it regardless
+        var isNegative = object.value < 0;
+        var hex = Math.abs(object.value).toString(16);
+        var newStr = (isNegative ? "-" : "") + "0x" + hex;
+        this.replace(object, (0, _gen.Identifier)(newStr));
+      };
+    } // BigInt support
+
+
+    if (this.isBigIntLiteral(object)) {
+      // https://github.com/MichaelXF/js-confuser/issues/79
+      return () => {
+        // Use an Identifier with the raw string
+        this.replace(object, (0, _gen.Identifier)(object.raw));
+      };
+    }
+
+    if (this.options.stringEncoding && this.stringEncoding.match(object, parents)) {
+      return this.stringEncoding.transform(object, parents);
+    }
+  }
+
+}
+
+exports.default = Finalizer;

package/dist/transforms/flatten.js

@@ -11,7 +11,7 @@ var _constants = require("../constants");
 
 var _order = require("../order");
 
-var _traverse = _interopRequireWildcard(require("../traverse"));
+var _traverse = require("../traverse");
 
 var _gen = require("../util/gen");
 
@@ -23,71 +23,87 @@ var _random = require("../util/random");
 
 var _transform = _interopRequireDefault(require("./transform"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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); }
+var _functionLength = require("../templates/functionLength");
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 /**
- * Brings every function to the global level.
+ * Flatten takes functions and isolates them from their original scope, and brings it to the top level of the program.
+ *
+ * An additional `flatObject` parameter is passed in, giving access to the original scoped variables.
  *
- * Functions take parameters, input, have a return value and return modified changes to the scoped variables.
+ * The `flatObject` uses `get` and `set` properties to allow easy an AST transformation:
  *
  * ```js
- * function topLevel(ref1, ref2, refN, param1, param2, paramN){
- *   return [ref1, ref2, refN, returnValue];
+ * // Input
+ * function myFunction(myParam){
+ *    modified = true;
+ *    if(reference) {
+ *
+ *    }
+ *    ...
+ *    console.log(myParam);
+ * }
+ *
+ * // Output
+ * function myFunction_flat([myParam], flatObject){
+ *    flatObject["set_modified"] = true;
+ *    if(flatObject["get_reference"]) {
+ *
+ *    }
+ *    ...
+ *    console.log(myParam)
+ * }
+ *
+ * function myFunction(){
+ *    var flatObject = {
+ *        set set_modified(v) { modified = v }
+ *        get get_reference() { return reference }
+ *    }
+ *    return myFunction_flat([...arguments], flatObject)
  * }
  * ```
  *
  * Flatten is used to make functions eligible for the RGF transformation.
+ *
+ * - `myFunction_flat` is now eligible because it does not rely on outside scoped variables
  */
 class Flatten extends _transform.default {
+  // Array of FunctionDeclaration nodes
   constructor(o) {
     super(o, _order.ObfuscateOrder.Flatten);
 
+    _defineProperty(this, "isDebug", false);
+
     _defineProperty(this, "definedNames", void 0);
 
     _defineProperty(this, "flattenedFns", void 0);
 
     _defineProperty(this, "gen", void 0);
 
+    _defineProperty(this, "functionLengthName", void 0);
+
     this.definedNames = new Map();
     this.flattenedFns = [];
-    this.gen = this.getGenerator();
+    this.gen = this.getGenerator("mangled");
+
+    if (this.isDebug) {
+      console.warn("Flatten debug mode");
+    }
   }
 
   apply(tree) {
-    (0, _traverse.default)(tree, (o, p) => {
-      if (o.type == "Identifier" && !_constants.reservedIdentifiers.has(o.name) && !this.options.globalVariables.has(o.name)) {
-        var info = (0, _identifiers.getIdentifierInfo)(o, p);
-
-        if (info.spec.isReferenced) {
-          if (info.spec.isDefined) {
-            var c = (0, _insert.getVarContext)(o, p);
-
-            if (c) {
-              if (!this.definedNames.has(c)) {
-                this.definedNames.set(c, new Set([o.name]));
-              } else {
-                this.definedNames.get(c).add(o.name);
-              }
-            }
-          }
-        }
-      }
-    });
     super.apply(tree);
 
     if (this.flattenedFns.length) {
-      (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)(this.flattenedFns));
+      (0, _insert.prepend)(tree, ...this.flattenedFns);
     }
   }
 
   match(object, parents) {
-    return (object.type == "FunctionDeclaration" || object.type === "FunctionExpression") && object.body.type == "BlockStatement" && !object.generator && !object.params.find(x => x.type !== "Identifier");
+    return (object.type == "FunctionDeclaration" || object.type === "FunctionExpression") && object.body.type == "BlockStatement" && !object.$requiresEval && !object.generator && !object.params.find(x => x.type !== "Identifier");
   }
 
   transform(object, parents) {
@@ -101,7 +117,7 @@ class Flatten extends _transform.default {
         } // Don't change getter/setter methods
 
 
-        if (parents[0].type === "Property" && parents[0].value === object && parents[0].kind !== "init") {
+        if (parents[0].type === "Property" && parents[0].value === object && (parents[0].kind !== "init" || parents[0].method)) {
           return;
         }
       }
@@ -111,76 +127,54 @@ class Flatten extends _transform.default {
       var currentFnName = object.type === "FunctionDeclaration" ? (_object$id = object.id) === null || _object$id === void 0 ? void 0 : _object$id.name : ((_parents$ = parents[0]) === null || _parents$ === void 0 ? void 0 : _parents$.type) === "VariableDeclarator" && ((_parents$0$id = parents[0].id) === null || _parents$0$id === void 0 ? void 0 : _parents$0$id.type) === "Identifier" && ((_parents$0$id2 = parents[0].id) === null || _parents$0$id2 === void 0 ? void 0 : _parents$0$id2.name);
 
       if (((_parents$2 = parents[0]) === null || _parents$2 === void 0 ? void 0 : _parents$2.type) === "Property" && (_parents$3 = parents[0]) !== null && _parents$3 !== void 0 && _parents$3.key) {
-        var _parents$4, _parents$4$key, _parents$5, _parents$5$key;
+        var _parents$4, _parents$4$key;
 
-        currentFnName = currentFnName || String(((_parents$4 = parents[0]) === null || _parents$4 === void 0 ? void 0 : (_parents$4$key = _parents$4.key) === null || _parents$4$key === void 0 ? void 0 : _parents$4$key.name) || ((_parents$5 = parents[0]) === null || _parents$5 === void 0 ? void 0 : (_parents$5$key = _parents$5.key) === null || _parents$5$key === void 0 ? void 0 : _parents$5$key.value));
+        currentFnName = currentFnName || String((_parents$4 = parents[0]) === null || _parents$4 === void 0 ? void 0 : (_parents$4$key = _parents$4.key) === null || _parents$4$key === void 0 ? void 0 : _parents$4$key.name);
       }
 
       if (!currentFnName) currentFnName = "unnamed";
-      var defined = new Set();
-      var references = new Set();
-      var modified = new Set();
+      var definedMap = new Map();
       var illegal = new Set();
       var isIllegal = false;
-      var definedAbove = new Set(this.options.globalVariables);
-      parents.forEach(x => {
-        var set = this.definedNames.get(x);
-
-        if (set) {
-          set.forEach(name => definedAbove.add(name));
-        }
-      });
+      var identifierNodes = [];
       (0, _traverse.walk)(object, parents, (o, p) => {
-        if (object.id && o === object.id) {
-          return;
+        if (o.type === "Identifier" && o.name === "arguments" || o.type === "UnaryExpression" && o.operator === "delete" || o.type == "ThisExpression" || o.type == "Super" || o.type == "MetaProperty") {
+          isIllegal = true;
+          return "EXIT";
         }
 
-        if (o.type == "Identifier" && !this.options.globalVariables.has(o.name) && !_constants.reservedIdentifiers.has(o.name)) {
+        if (o.type == "Identifier" && o !== object.id && !this.options.globalVariables.has(o.name) && !_constants.reservedIdentifiers.has(o.name)) {
           var info = (0, _identifiers.getIdentifierInfo)(o, p);
 
           if (!info.spec.isReferenced) {
             return;
           }
 
-          if (o.hidden) {
+          if (info.spec.isExported || o.name.startsWith(_constants.noRenameVariablePrefix)) {
             illegal.add(o.name);
-          } else if (info.spec.isDefined) {
-            defined.add(o.name);
-          } else if (info.spec.isModified) {
-            modified.add(o.name);
-          } else {
-            references.add(o.name);
+            return;
           }
-        }
 
-        if (o.type == "TryStatement") {
-          isIllegal = true;
-          return "EXIT";
-        }
+          if (info.spec.isDefined) {
+            var definingContext = (0, _insert.getDefiningContext)(o, p);
 
-        if (o.type == "Identifier") {
-          if (o.name == "arguments") {
-            isIllegal = true;
-            return "EXIT";
-          }
-        }
+            if (!definedMap.has(definingContext)) {
+              definedMap.set(definingContext, new Set([o.name]));
+            } else {
+              definedMap.get(definingContext).add(o.name);
+            }
 
-        if (o.type == "ThisExpression") {
-          isIllegal = true;
-          return "EXIT";
-        }
+            return;
+          }
 
-        if (o.type == "Super") {
-          isIllegal = true;
-          return "EXIT";
-        }
+          var isDefined = p.find(x => definedMap.has(x) && definedMap.get(x).has(o.name));
 
-        if (o.type == "MetaProperty") {
-          isIllegal = true;
-          return "EXIT";
+          if (!isDefined) {
+            identifierNodes.push([o, p, info]);
+          }
         }
 
-        if (o.type == "VariableDeclaration" && o.kind !== "var") {
+        if (o.type == "TryStatement") {
           isIllegal = true;
           return "EXIT";
         }
@@ -194,82 +188,169 @@ class Flatten extends _transform.default {
         return;
       }
 
-      defined.forEach(name => {
-        references.delete(name);
-        modified.delete(name);
-      }); // console.log(object.id.name, illegal, references);
+      var newFnName = this.getPlaceholder() + "_flat_" + currentFnName;
+      var flatObjectName = this.getPlaceholder() + "_flat_object";
 
-      var input = Array.from(new Set([...modified, ...references]));
+      const getFlatObjectMember = propertyName => {
+        return (0, _gen.MemberExpression)((0, _gen.Identifier)(flatObjectName), (0, _gen.Literal)(propertyName), true);
+      };
 
-      if (Array.from(input).find(x => !definedAbove.has(x))) {
-        return;
+      var getterPropNames = Object.create(null);
+      var setterPropNames = Object.create(null);
+      var typeofPropNames = Object.create(null);
+      var callPropNames = Object.create(null);
+
+      for (var [o, p, info] of identifierNodes) {
+        var identifierName = o.name;
+        if (p.find(x => definedMap.has(x) && definedMap.get(x).has(identifierName))) continue;
+        (0, _assert.ok)(!info.spec.isDefined);
+        var type = info.spec.isModified ? "setter" : "getter";
+
+        switch (type) {
+          case "setter":
+            var setterPropName = setterPropNames[identifierName];
+
+            if (typeof setterPropName === "undefined") {
+              // No getter function made yet, make it (Try to re-use getter name if available)
+              setterPropName = getterPropNames[identifierName] || (this.isDebug ? "set_" + identifierName : this.gen.generate());
+              setterPropNames[identifierName] = setterPropName;
+            } // If an update expression, ensure a getter function is also available. Ex: a++
+
+
+            if (p[0].type === "UpdateExpression") {
+              getterPropNames[identifierName] = setterPropName;
+            } else {
+              // If assignment on member expression, ensure a getter function is also available: Ex. myObject.property = ...
+              var assignmentIndex = p.findIndex(x => x.type === "AssignmentExpression");
+
+              if (assignmentIndex !== -1 && p[assignmentIndex].left.type !== "Identifier") {
+                getterPropNames[identifierName] = setterPropName;
+              }
+            } // calls flatObject.set_identifier_value(newValue)
+
+
+            this.replace(o, getFlatObjectMember(setterPropName));
+            break;
+
+          case "getter":
+            var getterPropName = getterPropNames[identifierName];
+
+            if (typeof getterPropName === "undefined") {
+              // No getter function made yet, make it (Try to re-use setter name if available)
+              getterPropName = setterPropNames[identifierName] || (this.isDebug ? "get_" + identifierName : this.gen.generate());
+              getterPropNames[identifierName] = getterPropName;
+            } // Typeof expression check
+
+
+            if (p[0].type === "UnaryExpression" && p[0].operator === "typeof" && p[0].argument === o) {
+              var typeofPropName = typeofPropNames[identifierName];
+
+              if (typeof typeofPropName === "undefined") {
+                // No typeof getter function made yet, make it (Don't re-use getter/setter names)
+                typeofPropName = this.isDebug ? "get_typeof_" + identifierName : this.gen.generate();
+                typeofPropNames[identifierName] = typeofPropName;
+              } // Replace the entire unary expression not just the identifier node
+              // calls flatObject.get_typeof_identifier()
+
+
+              this.replace(p[0], getFlatObjectMember(typeofPropName));
+              break;
+            } // Bound call-expression check
+
+
+            if (p[0].type === "CallExpression" && p[0].callee === o) {
+              var callPropName = callPropNames[identifierName];
+
+              if (typeof callPropName === "undefined") {
+                callPropName = this.isDebug ? "call_" + identifierName : this.gen.generate();
+                callPropNames[identifierName] = callPropName;
+              } // Replace the entire call expression not just the identifier node
+              // calls flatObject.call_identifier(...arguments)
+
+
+              this.replace(p[0], (0, _gen.CallExpression)(getFlatObjectMember(callPropName), p[0].arguments));
+              break;
+            } // calls flatObject.get_identifier_value()
+
+
+            this.replace(o, getFlatObjectMember(getterPropName));
+            break;
+        }
+      } // Create the getter and setter functions
+
+
+      var flatObjectProperties = []; // Getter functions
+
+      for (var identifierName in getterPropNames) {
+        var getterPropName = getterPropNames[identifierName];
+        flatObjectProperties.push((0, _gen.Property)((0, _gen.Literal)(getterPropName), (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.Identifier)(identifierName))]), true, "get"));
+      } // Get typeof functions
+
+
+      for (var identifierName in typeofPropNames) {
+        var typeofPropName = typeofPropNames[identifierName];
+        flatObjectProperties.push((0, _gen.Property)((0, _gen.Literal)(typeofPropName), (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.UnaryExpression)("typeof", (0, _gen.Identifier)(identifierName)))]), true, "get"));
+      } // Call functions
+
+
+      for (var identifierName in callPropNames) {
+        var callPropName = callPropNames[identifierName];
+        var argumentsName = this.getPlaceholder();
+        flatObjectProperties.push((0, _gen.Property)((0, _gen.Literal)(callPropName), (0, _gen.FunctionExpression)([(0, _gen.RestElement)((0, _gen.Identifier)(argumentsName))], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.Identifier)(identifierName), [(0, _gen.SpreadElement)((0, _gen.Identifier)(argumentsName))]))]), true));
+      } // Setter functions
+
+
+      for (var identifierName in setterPropNames) {
+        var setterPropName = setterPropNames[identifierName];
+        var newValueParameterName = this.getPlaceholder();
+        flatObjectProperties.push((0, _gen.Property)((0, _gen.Literal)(setterPropName), (0, _gen.FunctionExpression)([(0, _gen.Identifier)(newValueParameterName)], [(0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(identifierName), (0, _gen.Identifier)(newValueParameterName)))]), true, "set"));
       }
 
-      var output = Array.from(modified);
-      var newName = this.getPlaceholder() + "_flat_" + currentFnName;
-      var resultName = this.getPlaceholder();
-      var propName = this.gen.generate();
-      var newOutputNames = Object.create(null);
-      output.forEach(name => {
-        newOutputNames[name] = this.gen.generate();
-      });
-      var returnOutputName = this.gen.generate();
-      (0, _insert.getBlockBody)(object.body).push((0, _gen.ReturnStatement)());
-      (0, _traverse.walk)(object.body, [object, ...parents], (o, p) => {
-        return () => {
-          // Change return statements from
-          // return (argument)
-          // to
-          // return [ [modifiedRefs],  ]
-          if (o.type == "ReturnStatement" && (0, _insert.getVarContext)(o, p) === object) {
-            var returnObject = (0, _gen.ObjectExpression)(output.map(outputName => (0, _gen.Property)((0, _gen.Literal)(newOutputNames[outputName]), (0, _gen.Identifier)(outputName), true)));
-
-            if (o.argument && !(o.argument.type == "Identifier" && o.argument.name == "undefined")) {
-              returnObject.properties.push((0, _gen.Property)((0, _gen.Literal)(returnOutputName), (0, _insert.clone)(o.argument), true));
-            }
+      if (!this.isDebug) {
+        (0, _random.shuffle)(flatObjectProperties);
+      }
+
+      var newBody = (0, _insert.getBlockBody)(object.body); // Remove 'use strict' directive
+
+      if (newBody.length > 0 && newBody[0].directive) {
+        newBody.shift();
+      }
 
-            o.argument = (0, _gen.AssignmentExpression)("=", (0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Identifier)(propName), false), returnObject);
+      var newFunctionDeclaration = (0, _gen.FunctionDeclaration)(newFnName, [(0, _gen.ArrayPattern)((0, _insert.clone)(object.params)), (0, _gen.Identifier)(flatObjectName)], newBody);
+      newFunctionDeclaration.async = !!object.async;
+      newFunctionDeclaration.generator = false;
+      this.flattenedFns.push(newFunctionDeclaration);
+      var argumentsName = this.getPlaceholder(); // newFn.call([...arguments], flatObject)
+
+      var callExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(newFnName), [(0, _gen.Identifier)(argumentsName), (0, _gen.Identifier)(flatObjectName)]);
+      var newObjectBody = [// var flatObject = { get(), set() };
+      (0, _gen.VariableDeclaration)([(0, _gen.VariableDeclarator)(flatObjectName, (0, _gen.ObjectExpression)(flatObjectProperties))]), (0, _gen.ReturnStatement)(newFunctionDeclaration.async ? (0, _gen.AwaitExpression)(callExpression) : callExpression)];
+      object.body = (0, _gen.BlockStatement)(newObjectBody); // Preserve function.length property
+
+      var originalFunctionLength = (0, _insert.computeFunctionLength)(object.params);
+      object.params = [(0, _gen.SpreadElement)((0, _gen.Identifier)(argumentsName))];
+
+      if (originalFunctionLength !== 0) {
+        if (!this.functionLengthName) {
+          this.functionLengthName = this.getPlaceholder();
+          (0, _insert.prepend)(parents[parents.length - 1] || object, _functionLength.FunctionLengthTemplate.single({
+            name: this.functionLengthName
+          }));
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          var body = parents[0];
+
+          if (Array.isArray(body)) {
+            var index = body.indexOf(object);
+            body.splice(index + 1, 0, (0, _gen.ExpressionStatement)((0, _gen.CallExpression)((0, _gen.Identifier)(this.functionLengthName), [(0, _gen.Identifier)(object.id.name), (0, _gen.Literal)(originalFunctionLength)])));
           }
-        };
-      });
-      var newBody = (0, _insert.getBlockBody)(object.body);
-      var newFunctionExpression = (0, _gen.FunctionExpression)([(0, _gen.ArrayPattern)(input.map(_gen.Identifier)), (0, _gen.ArrayPattern)((0, _insert.clone)(object.params)), (0, _gen.Identifier)(resultName)], newBody);
-      newFunctionExpression.async = !!object.async;
-      newFunctionExpression.generator = !!object.generator;
-      var property = (0, _gen.Property)((0, _gen.Identifier)(newName), newFunctionExpression, false);
-      property.kind = "set";
-      this.flattenedFns.push((0, _gen.VariableDeclarator)(newName, newFunctionExpression));
-      var newParamNodes = object.params.map(() => (0, _gen.Identifier)(this.getPlaceholder())); // result.pop()
-
-      var getOutputMemberExpression = outputName => (0, _gen.MemberExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(propName), true), (0, _gen.Literal)(outputName), true); // newFn.call([...refs], ...arguments, resultObject)
-
-
-      var callExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(newName), [(0, _gen.ArrayExpression)(input.map(_gen.Identifier)), (0, _gen.ArrayExpression)([...newParamNodes]), (0, _gen.Identifier)(resultName)]);
-      var newObjectBody = [// var resultObject = {};
-      (0, _gen.VariableDeclaration)([(0, _gen.VariableDeclarator)(resultName, (0, _gen.ObjectExpression)([]))]), (0, _gen.ExpressionStatement)(newFunctionExpression.async ? (0, _gen.AwaitExpression)(callExpression) : callExpression)];
-      var outputReversed = [...output].reverse(); // realVar
-
-      outputReversed.forEach(outputName => {
-        newObjectBody.push((0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(outputName), getOutputMemberExpression(newOutputNames[outputName]))));
-      }); // DECOY STATEMENTS
-
-      var decoyKey = this.gen.generate();
-      var decoyNodes = [// if (result.random) throw result.prop.random
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ThrowStatement)((0, _gen.NewExpression)((0, _gen.Identifier)("Error"), [getOutputMemberExpression(this.gen.generate())]))]), // if (result.random) return true;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ReturnStatement)((0, _gen.Literal)(true))]), // if (result.random) return result;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ReturnStatement)((0, _gen.Identifier)(resultName))]), // if (result.random) return result.random;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(decoyKey), true), [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(decoyKey), true))]), // if(result.random1) return result.random2;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true))]), // if(result.random) return flatFn;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ReturnStatement)((0, _gen.Identifier)(newName))]), // if(result.random) flatFn = undefined;
-      (0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(this.gen.generate()), true), [(0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(newName), (0, _gen.Identifier)("undefined")))]), // if(!result) return;
-      (0, _gen.IfStatement)((0, _gen.UnaryExpression)("!", (0, _gen.Identifier)(resultName)), [(0, _gen.ReturnStatement)()])].filter(() => Math.random() > 0.25); // if (result.output) return result.output.returnValue;
-      // this is the real return statement, it is always added
-
-      decoyNodes.push((0, _gen.IfStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(resultName), (0, _gen.Literal)(propName), true), [(0, _gen.ReturnStatement)(getOutputMemberExpression(returnOutputName))]));
-      (0, _random.shuffle)(decoyNodes);
-      newObjectBody.push(...decoyNodes);
-      object.body = (0, _gen.BlockStatement)(newObjectBody);
-      object.params = newParamNodes;
+        } else {
+          (0, _assert.ok)(object.type === "FunctionExpression");
+          this.replace(object, (0, _gen.CallExpression)((0, _gen.Identifier)(this.functionLengthName), [{ ...object
+          }, (0, _gen.Literal)(originalFunctionLength)]));
+        }
+      }
     };
   }
 

package/dist/transforms/identifier/globalAnalysis.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../../constants");
+
+var _identifiers = require("../../util/identifiers");
+
+var _transform = _interopRequireDefault(require("../transform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Global Analysis is responsible for finding all the global variables used in the code.
+ *
+ * A 'global variable' is one that is:
+ * - Referenced
+ * - Never defined or overridden
+ */
+class GlobalAnalysis extends _transform.default {
+  constructor(o) {
+    super(o);
+
+    _defineProperty(this, "notGlobals", void 0);
+
+    _defineProperty(this, "globals", void 0);
+
+    this.globals = Object.create(null);
+    this.notGlobals = new Set();
+  }
+
+  match(object, parents) {
+    return object.type == "Identifier" && !_constants.reservedKeywords.has(object.name);
+  }
+
+  transform(object, parents) {
+    // no touching `import()` or `import x from ...`
+    var importIndex = parents.findIndex(x => x.type == "ImportExpression" || x.type == "ImportDeclaration");
+
+    if (importIndex !== -1) {
+      if (parents[importIndex].source === (parents[importIndex - 1] || object)) {
+        return;
+      }
+    }
+
+    var info = (0, _identifiers.getIdentifierInfo)(object, parents);
+
+    if (!info.spec.isReferenced) {
+      return;
+    } // Cannot be defined or overridden
+
+
+    if (info.spec.isDefined || info.spec.isModified) {
+      delete this.globals[object.name];
+      this.notGlobals.add(object.name);
+      return;
+    } // Add to globals
+
+
+    if (!this.notGlobals.has(object.name)) {
+      if (!this.globals[object.name]) {
+        this.globals[object.name] = [];
+      }
+
+      this.globals[object.name].push([object, parents]);
+    }
+
+    var assignmentIndex = parents.findIndex(x => x.type == "AssignmentExpression");
+    var updateIndex = parents.findIndex(x => x.type == "UpdateExpression");
+
+    if (assignmentIndex != -1 && parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object) || updateIndex != -1) {
+      var memberIndex = parents.findIndex(x => x.type == "MemberExpression");
+
+      if (memberIndex == -1 || memberIndex > (assignmentIndex == -1 ? assignmentIndex : updateIndex)) {
+        delete this.globals[object.name];
+        this.notGlobals.add(object.name);
+      }
+    }
+  }
+
+}
+
+exports.default = GlobalAnalysis;