js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/renameLabels.js

@@ -1,69 +1,145 @@
 "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;
+exports["default"] = _default;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _order = require("../order");
-var _traverse = require("../traverse");
-var _compare = require("../util/compare");
-var _gen = require("../util/gen");
-var _insert = require("../util/insert");
-var _transform = _interopRequireDefault(require("./transform"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * Renames the labels to shorter names.
- */
-class RenameLabels extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.RenameLabels);
-    _defineProperty(this, "gen", void 0);
-    this.gen = this.getGenerator("randomized");
-  }
-  match(object, parents) {
-    return object.type == "LabeledStatement";
-  }
-  transform(object, parents) {
-    return () => {
-      var newName = null;
-      var isRemovable = object.body.type !== "BlockStatement";
-      var labelNeverUsed = true;
-      (0, _traverse.walk)(object, parents, (o, p) => {
-        if (o.type == "BreakStatement" || o.type == "ContinueStatement") {
-          function isContinuableStatement(x, stmtParents) {
-            return (0, _compare.isLoop)(x) && x.type !== "SwitchStatement";
+var _NameGen = require("../utils/NameGen");
+var _assert = require("assert");
+var _probability = require("../probability");
+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; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var LABEL = Symbol("label");
+function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.RenameLabels, {
+    changeData: {
+      labelsRenamed: 0,
+      labelsRemoved: 0
+    }
+  });
+  return {
+    visitor: {
+      Program: function Program(path) {
+        var allLabelInterfaces = [];
+
+        // First pass: Collect all label usages
+        path.traverse({
+          LabeledStatement: function LabeledStatement(labelPath) {
+            var labelInterface = {
+              label: labelPath.node.label.name,
+              removed: false,
+              required: false,
+              paths: []
+            };
+            allLabelInterfaces.push(labelInterface);
+            labelPath.node[LABEL] = labelInterface;
+          },
+          "BreakStatement|ContinueStatement": function BreakStatementContinueStatement(_path) {
+            var path = _path;
+            if (path.node.label) {
+              var labelName = path.node.label.name;
+              var targets = [];
+              var onlySearchLoops = path.isContinueStatement();
+              var currentPath = path;
+              while (currentPath) {
+                if (currentPath.isFor() || currentPath.isWhile() || currentPath.isSwitchStatement()) {
+                  targets.push(currentPath);
+                }
+                if (currentPath.isBlockStatement() && currentPath.parentPath.isLabeledStatement()) {
+                  targets.push(currentPath);
+                }
+                currentPath = currentPath.parentPath;
+              }
+              var target = targets.find(function (label) {
+                return label.parentPath && label.parentPath.isLabeledStatement() && label.parentPath.node.label.name === labelName;
+              });
+              if (onlySearchLoops) {
+                // Remove BlockStatements and SwitchStatements from the list of targets
+                // a continue statement only target loops
+                // This helps remove unnecessary labels when a continue is nested with a block statement
+                // ex: for-loop with if-statement continue
+                targets = targets.filter(function (target) {
+                  return !target.isBlockStatement() && !target.isSwitchStatement();
+                });
+              }
+              (0, _assert.ok)(target);
+              var isRequired = target.isBlockStatement() || targets[0] !== target;
+              var _labelInterface = target.parentPath.node[LABEL];
+              if (isRequired) {
+                _labelInterface.required = true;
+              } else {
+                // Label is not required here, remove it for this particular break/continue statement
+                path.node.label = null;
+              }
+              if (!_labelInterface.paths) {
+                _labelInterface.paths = [];
+              }
+              _labelInterface.paths.push(path);
+            }
           }
-          function isBreakableStatement(x, stmtParents) {
-            return (0, _compare.isLoop)(x) || x.type == "BlockStatement" && o.label && stmtParents[0] && stmtParents[0].type == "LabeledStatement";
+        });
+        var nameGen = new _NameGen.NameGen(me.options.identifierGenerator);
+        for (var _i = 0, _allLabelInterfaces = allLabelInterfaces; _i < _allLabelInterfaces.length; _i++) {
+          var labelInterface = _allLabelInterfaces[_i];
+          var isRequired = labelInterface.required;
+          if (isRequired) {
+            var newName = labelInterface.label;
+            if ((0, _probability.computeProbabilityMap)(me.options.renameLabels, labelInterface.label)) {
+              newName = nameGen.generate();
+            }
+            labelInterface.renamed = newName;
+            me.changeData.labelsRenamed++;
+          } else {
+            labelInterface.removed = true;
+            me.changeData.labelsRemoved++;
           }
-          var fn = o.type == "ContinueStatement" ? isContinuableStatement : isBreakableStatement;
-          var labelStatement = p.find((node, i) => {
-            return fn(node, p.slice(i + 1));
-          });
-          if (o.label && o.label.name == object.label.name) {
-            if (object.body == labelStatement && isRemovable) {
-              // In same loop
+        }
+
+        // Second pass: Rename labels and remove unused ones
+        path.traverse({
+          LabeledStatement: function LabeledStatement(labelPath) {
+            var labelInterface = labelPath.node[LABEL];
+            if (labelInterface) {
+              // Remove label but replace it with its body
+              if (labelInterface.removed) {
+                labelPath.replaceWith(labelPath.node.body);
+              }
 
-              o.label = null;
-            } else {
-              if (!newName) {
-                newName = this.gen.generate();
+              // Else keep the label but rename it
+              if (typeof labelInterface.renamed === "string") {
+                labelPath.node.label.name = labelInterface.renamed;
+              }
+
+              // Update all break/continue statements
+              var _iterator = _createForOfIteratorHelper(labelInterface.paths),
+                _step;
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  var breakPath = _step.value;
+                  // Remove label from break/continue statement
+                  if (labelInterface.removed) {
+                    breakPath.node.label = null;
+                  } else {
+                    // Update label name
+                    breakPath.node.label = t.identifier(labelInterface.renamed);
+                  }
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
               }
-              o.label = (0, _gen.Identifier)(newName);
-              labelNeverUsed = false;
             }
           }
-        }
-      });
-      if (newName) {
-        object.label = (0, _gen.Identifier)(newName);
-      } else if (isRemovable || labelNeverUsed) {
-        this.replace(object, (0, _insert.clone)(object.body));
+        });
       }
-    };
-  }
-}
-exports.default = RenameLabels;
+    }
+  };
+}

package/dist/transforms/rgf.js

@@ -1,255 +1,157 @@
 "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 _compiler = require("../compiler");
-var _constants = require("../constants");
-var _obfuscator = _interopRequireDefault(require("../obfuscator"));
+exports["default"] = void 0;
 var _order = require("../order");
+var t = _interopRequireWildcard(require("@babel/types"));
+var _obfuscator = _interopRequireDefault(require("../obfuscator"));
 var _probability = require("../probability");
-var _functionLength = require("../templates/functionLength");
-var _globals = require("../templates/globals");
-var _traverse = require("../traverse");
-var _gen = require("../util/gen");
-var _identifiers = require("../util/identifiers");
-var _insert = require("../util/insert");
-var _integrity = _interopRequireDefault(require("./lock/integrity"));
-var _transform = _interopRequireDefault(require("./transform"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * Converts function to `new Function("..code..")` syntax as an alternative to `eval`. Eval is disabled in many environments.
- *
- * `new Function("..code..")` runs in an isolated context, meaning all local variables are undefined and throw errors.
- *
- * Rigorous checks are in place to only include pure functions.
- *
- * `flatten` can attempt to make function reference-less. Recommended to have flatten enabled with RGF.
+var _astUtils = require("../utils/ast-utils");
+var _constants = require("../constants");
+var _functionUtils = require("../utils/function-utils");
+var _node = require("../utils/node");
+var _template = _interopRequireDefault(require("../templates/template"));
+var _tamperProtectionTemplates = require("../templates/tamperProtectionTemplates");
+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; }
+/**
+ * RGF (Runtime-Generated-Function) uses the `new Function("code")` syntax to create executable code from strings.
+ *
+ * Limitations:
+ *
+ * 1. Does not apply to async or generator functions
+ * 2. Does not apply to functions that reference outside variables
  */
-class RGF extends _transform.default {
-  getFunctionLengthName(parents) {
-    if (!this.functionLengthName) {
-      this.functionLengthName = this.getPlaceholder();
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.RGF, {
+    changeData: {
+      functions: 0
     }
-    return this.functionLengthName;
-  }
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.RGF);
-    // Array of all the `new Function` calls
-    _defineProperty(this, "arrayExpressionElements", void 0);
-    // The name of the array holding all the `new Function` expressions
-    _defineProperty(this, "arrayExpressionName", void 0);
-    _defineProperty(this, "functionLengthName", void 0);
-    this.arrayExpressionName = this.getPlaceholder() + "_rgf";
-    this.arrayExpressionElements = [];
-  }
-  apply(tree) {
-    super.apply(tree);
-
-    // Only add the array if there were converted functions
-    if (this.arrayExpressionElements.length > 0) {
-      (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)((0, _gen.Identifier)(this.arrayExpressionName), (0, _gen.ArrayExpression)(this.arrayExpressionElements))));
-    }
-
-    // The function.length helper function must be placed last
-    if (this.functionLengthName) {
-      (0, _insert.prepend)(tree, _functionLength.FunctionLengthTemplate.single({
-        name: this.functionLengthName,
-        ObjectDefineProperty: this.createInitVariable(_globals.ObjectDefineProperty, [tree])
-      }));
-    }
-  }
-  match(object, parents) {
-    return (object.type === "FunctionDeclaration" || object.type === "FunctionExpression") &&
-    // Does not apply to Arrow functions
-    !object.async &&
-    // Does not apply to async/generator functions
-    !object.generator;
-  }
-  transform(object, parents) {
-    var _this$options$lock, _object$id;
-    // 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;
-    }
-
-    // Avoid applying to the countermeasures function
-    if (typeof ((_this$options$lock = this.options.lock) === null || _this$options$lock === void 0 ? void 0 : _this$options$lock.countermeasures) === "string") {
-      // function countermeasures(){...}
-      if (object.type === "FunctionDeclaration" && object.id.type === "Identifier" && object.id.name === this.options.lock.countermeasures) {
-        return;
-      }
-
-      // var countermeasures = function(){...}
-      if (parents[0].type === "VariableDeclarator" && parents[0].init === object && parents[0].id.type === "Identifier" && parents[0].id.name === this.options.lock.countermeasures) {
-        return;
-      }
-    }
-
-    // Check user option
-    if (!(0, _probability.ComputeProbabilityMap)(this.options.rgf, x => x, object === null || object === void 0 ? void 0 : (_object$id = object.id) === null || _object$id === void 0 ? void 0 : _object$id.name)) return;
-
-    // Discard functions that use 'eval' function
-    if (object.$requiresEval) return;
+  });
+  var rgfArrayName = me.getPlaceholder() + "_rgf";
+  var rgfEvalName = me.getPlaceholder() + "_rgf_eval";
+  var rgfArrayExpression = t.arrayExpression([]);
+  var active = true;
+  return {
+    visitor: {
+      Program: {
+        enter: function enter(path) {
+          path.scope.crawl();
+        },
+        exit: function exit(path) {
+          active = false;
+          if (rgfArrayExpression.elements.length === 0) return;
+
+          // Insert the RGF array at the top of the program
+          (0, _astUtils.prepend)(path, t.variableDeclaration("var", [t.variableDeclarator(t.identifier(rgfArrayName), rgfArrayExpression)]));
+          var rgfEvalIntegrity = me.getPlaceholder() + "_rgf_eval_integrity";
+          (0, _astUtils.prepend)(path, new _template["default"]("\n            {EvalIntegrity}\n            var ".concat(rgfEvalIntegrity, " = {EvalIntegrityName}();\n            ")).compile({
+            EvalIntegrity: (0, _tamperProtectionTemplates.createEvalIntegrityTemplate)(me, path),
+            EvalIntegrityName: me.getPlaceholder()
+          }));
+          (0, _astUtils.append)(path, new _template["default"]("\n              function ".concat(rgfEvalName, "(code) {\n                if (").concat(rgfEvalIntegrity, ") {\n                  return eval(code);\n                }\n              }\n              ")).addSymbols(_constants.UNSAFE).single());
+        }
+      },
+      "FunctionDeclaration|FunctionExpression": {
+        exit: function exit(_path) {
+          var _me$options$lock;
+          if (!active) return;
+          var path = _path;
+          if (me.isSkipped(path)) return;
+
+          // Skip async and generator functions
+          if (path.node.async || path.node.generator) return;
+          var name = (0, _astUtils.getFunctionName)(path);
+          if (name === ((_me$options$lock = me.options.lock) === null || _me$options$lock === void 0 ? void 0 : _me$options$lock.countermeasures)) return;
+          if (me.obfuscator.isInternalVariable(name)) return;
+          me.log(name);
+          if (!(0, _probability.computeProbabilityMap)(me.options.rgf, name, path.getFunctionParent() === null)) return;
+
+          // Skip functions with references to outside variables
+          // Check the scope to see if this function relies on any variables defined outside the function
+          var identifierPreventingTransform;
+          path.traverse({
+            Identifier: function Identifier(idPath) {
+              if (!(0, _astUtils.isVariableIdentifier)(idPath)) return;
+              if (idPath.isBindingIdentifier() && (0, _astUtils.isDefiningIdentifier)(idPath)) return;
+              var name = idPath.node.name;
+              // RGF array name is allowed, it is not considered an outside reference
+              if (name === rgfArrayName) return;
+              if (_constants.reservedIdentifiers.has(name)) return;
+              if (me.options.globalVariables.has(name)) return;
+              var binding = idPath.scope.getBinding(name);
+              if (!binding) {
+                identifierPreventingTransform = name;
+                idPath.stop();
+                return;
+              }
 
-    // Check for 'this', 'arguments' (not allowed!)
-    var isIllegal = false;
-    (0, _traverse.walk)(object, parents, (o, p) => {
-      if (o.type === "ThisExpression" || o.type === "Super" || o.type === "Identifier" && o.name === "arguments") {
-        isIllegal = true;
-        return "EXIT";
-      }
-    });
-    if (isIllegal) return;
-    return () => {
-      // Make sure function is 'reference-less'
-      var definedMap = new Map();
-      var isReferenceLess = true;
-      var identifierPreventingTransformation;
-      (0, _traverse.walk)(object, parents, (o, p) => {
-        if (o.type === "Identifier" && o.name !== this.arrayExpressionName && !_constants.reservedIdentifiers.has(o.name) && !this.options.globalVariables.has(o.name)) {
-          var info = (0, _identifiers.getIdentifierInfo)(o, p);
-          if (!info.spec.isReferenced) {
-            return;
-          }
-          if (info.spec.isDefined) {
-            // Add to defined map
-            var definingContext = (0, _insert.getDefiningContext)(o, p);
-            if (!definedMap.has(definingContext)) {
-              definedMap.set(definingContext, new Set([o.name]));
-            } else {
-              definedMap.get(definingContext).add(o.name);
-            }
-          } else {
-            // This approach is dirty and does not account for hoisted FunctionDeclarations
-            var isDefinedAbove = false;
-            for (var pNode of p) {
-              if (definedMap.has(pNode)) {
-                if (definedMap.get(pNode).has(o.name)) {
-                  isDefinedAbove = true;
-                  break;
-                }
+              // If the binding is not in the current scope, it is an outside reference
+              if (binding.scope !== path.scope) {
+                identifierPreventingTransform = name;
+                idPath.stop();
               }
             }
-            if (!isDefinedAbove) {
-              isReferenceLess = false;
-              identifierPreventingTransformation = o.name;
-              return "EXIT";
-            }
+          });
+          if (identifierPreventingTransform) {
+            me.log("Skipping function " + name + " due to reference to outside variable: " + identifierPreventingTransform);
+            return;
           }
+          var embeddedName = me.getPlaceholder() + "_embedded";
+          var replacementName = me.getPlaceholder() + "_replacement";
+          var thisName = me.getPlaceholder() + "_this";
+          var lastNode = t.expressionStatement(t.identifier(embeddedName));
+          lastNode[_constants.SKIP] = true;
+
+          // Transform the function
+          var evalProgram = t.program([t.functionDeclaration(t.identifier(embeddedName), [], t.blockStatement([t.variableDeclaration("var", [t.variableDeclarator(t.arrayPattern([t.identifier(thisName), t.identifier(rgfArrayName)]), t.thisExpression())]), t.functionDeclaration(t.identifier(replacementName), path.node.params, path.node.body), t.returnStatement(t.callExpression(t.memberExpression(t.identifier(replacementName), t.identifier("apply")), [t.identifier(thisName), t.identifier("arguments")]))])), lastNode]);
+          var strictModeEnforcingBlock = path.find(function (p) {
+            return (0, _astUtils.isStrictMode)(p);
+          });
+          if (strictModeEnforcingBlock) {
+            // Preserve 'use strict' directive
+            // This is necessary to enure subsequent transforms (Control Flow Flattening) are aware of the strict mode directive
+            evalProgram.directives.push(t.directive(t.directiveLiteral("use strict")));
+          }
+          var evalFile = t.file(evalProgram);
+          var newObfuscator = new _obfuscator["default"](me.options, me.obfuscator);
+          var hasRan = new Set(me.obfuscator.plugins.filter(function (plugin, i) {
+            return i <= me.obfuscator.index;
+          }).map(function (plugin) {
+            return plugin.pluginInstance.order;
+          }));
+          newObfuscator.plugins = newObfuscator.plugins.filter(function (plugin) {
+            return plugin.pluginInstance.order == _order.Order.Preparation || !hasRan.has(plugin.pluginInstance.order);
+          });
+          newObfuscator.obfuscateAST(evalFile, {
+            disablePack: true
+          });
+          var generated = _obfuscator["default"].generateCode(evalFile);
+          var functionExpression = t.callExpression(t.identifier(rgfEvalName), [t.stringLiteral(generated)]);
+          var index = rgfArrayExpression.elements.length;
+          rgfArrayExpression.elements.push(functionExpression);
+
+          // Params no longer needed, using 'arguments' instead
+          var originalLength = (0, _functionUtils.computeFunctionLength)(path);
+          path.node.params = [];
+
+          // Function is now unsafe
+          path.node[_constants.UNSAFE] = true;
+          // Params changed and using 'arguments'
+          path.node[_constants.PREDICTABLE] = false;
+          me.skip(path);
+
+          // Update body to point to new function
+          path.get("body").replaceWith(t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(rgfArrayName), (0, _node.numericLiteral)(index), true), t.stringLiteral("apply"), true), [t.arrayExpression([t.thisExpression(), t.identifier(rgfArrayName)]), t.identifier("arguments")]))]));
+          me.setFunctionLength(path, originalLength);
+          me.changeData.functions++;
         }
-      });
-
-      // This function is not 'reference-less', cannot be RGF'd
-      if (!isReferenceLess) {
-        if (object.id) {
-          var _object$id2;
-          this.log(`${object === null || object === void 0 ? void 0 : (_object$id2 = object.id) === null || _object$id2 === void 0 ? void 0 : _object$id2.name}() cannot be transformed because of ${identifierPreventingTransformation}`);
-        }
-        return;
-      }
-
-      // 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)
-      var obfuscator = new _obfuscator.default({
-        ...this.options,
-        stringEncoding: false,
-        compact: true
-      });
-      if (obfuscator.options.lock) {
-        delete obfuscator.options.lock.countermeasures;
-
-        // Integrity will not recursively apply to RGF'd functions. This is intended.
-        var lockTransform = obfuscator.transforms["Lock"];
-        if (lockTransform) {
-          lockTransform.before = lockTransform.before.filter(beforeTransform => !(beforeTransform instanceof _integrity.default));
-        }
-      }
-      var transforms = obfuscator.array.filter(x => x.priority > this.priority);
-      var embeddedFunctionName = this.getPlaceholder();
-      var embeddedFunction = {
-        type: "FunctionDeclaration",
-        id: (0, _gen.Identifier)(embeddedFunctionName),
-        body: (0, _gen.BlockStatement)([...object.body.body]),
-        params: object.params,
-        async: false,
-        generator: false
-      };
-
-      // The new program will look like this
-      // new Function(`
-      //  var rgf_array = this[0]
-      //  function greet(message){
-      //      console.log(message)
-      //  }
-      //  return greet.apply(this[1], arguments)
-      // `)
-      //
-      // And called like
-      // f.apply([ rgf_array, this ], arguments)
-      var tree = {
-        type: "Program",
-        body: [(0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.arrayExpressionName, (0, _gen.MemberExpression)((0, _gen.ThisExpression)(), (0, _gen.Literal)(0)))), embeddedFunction, (0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(embeddedFunctionName), (0, _gen.Literal)("apply"), true), [(0, _gen.MemberExpression)((0, _gen.ThisExpression)(), (0, _gen.Literal)(1)), (0, _gen.Identifier)("arguments")]))]
-      };
-      transforms.forEach(transform => {
-        transform.apply(tree);
-      });
-      var toString = (0, _compiler.compileJsSync)(tree, obfuscator.options);
-
-      // new Function(code)
-      var newFunctionExpression = (0, _gen.NewExpression)((0, _gen.Identifier)("Function"), [(0, _gen.Literal)(toString)]);
-
-      // The index where this function is placed in the array
-      var newFunctionExpressionIndex = this.arrayExpressionElements.length;
-
-      // Add it to the array
-      this.arrayExpressionElements.push(newFunctionExpression);
-
-      // The member expression to retrieve this function
-      var memberExpression = (0, _gen.MemberExpression)((0, _gen.Identifier)(this.arrayExpressionName), (0, _gen.Literal)(newFunctionExpressionIndex), true);
-      var originalFunctionLength = (0, _insert.computeFunctionLength)(object.params);
-
-      // Replace based on type
-
-      // (1) Function Declaration:
-      // - Replace body with call to new function
-      if (object.type === "FunctionDeclaration") {
-        object.body = (0, _gen.BlockStatement)([(0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)(memberExpression, (0, _gen.Literal)("apply"), true), [(0, _gen.ArrayExpression)([(0, _gen.Identifier)(this.arrayExpressionName), (0, _gen.ThisExpression)()]), (0, _gen.Identifier)("arguments")]))]);
-
-        // The parameters are no longer needed ('arguments' is used to capture them)
-        object.params = [];
-
-        // The function is no longer guaranteed to not have extraneous parameters passed in
-        object[_constants.predictableFunctionTag] = false;
-        if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
-          var body = parents[0];
-          body.splice(body.indexOf(object), 0, (0, _gen.ExpressionStatement)((0, _gen.CallExpression)((0, _gen.Identifier)(this.getFunctionLengthName(parents)), [(0, _gen.Identifier)(object.id.name), (0, _gen.Literal)(originalFunctionLength)])));
-        }
-        return;
-      }
-
-      // (2) Function Expression:
-      // - Replace expression with member expression pointing to new function
-      if (object.type === "FunctionExpression") {
-        if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
-          memberExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(this.getFunctionLengthName(parents)), [memberExpression, (0, _gen.Literal)(originalFunctionLength)]);
-        }
-        this.replace(object, memberExpression);
-        return;
       }
-    };
-  }
-}
-exports.default = RGF;
+    }
+  };
+};