js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/flatten.js

@@ -1,311 +1,310 @@
 "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 _assert = require("assert");
-var _constants = require("../constants");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _astUtils = require("../utils/ast-utils");
+var _probability = require("../probability");
 var _order = require("../order");
-var _traverse = require("../traverse");
-var _gen = require("../util/gen");
-var _identifiers = require("../util/identifiers");
-var _insert = require("../util/insert");
-var _random = require("../util/random");
-var _transform = _interopRequireDefault(require("./transform"));
-var _functionLength = require("../templates/functionLength");
-var _globals = require("../templates/globals");
-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); }
-/**
- * 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.
- *
- * The `flatObject` uses `get` and `set` properties to allow easy an AST transformation:
- *
- * ```js
- * // 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 {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Flatten);
-    _defineProperty(this, "isDebug", false);
-    _defineProperty(this, "definedNames", void 0);
-    // Array of FunctionDeclaration nodes
-    _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("mangled");
-    if (this.isDebug) {
-      console.warn("Flatten debug mode");
+var _constants = require("../constants");
+var _functionUtils = require("../utils/function-utils");
+var _assert = require("assert");
+var _NameGen = require("../utils/NameGen");
+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 _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+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 _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Flatten, {
+    changeData: {
+      functions: 0
     }
-  }
-  apply(tree) {
-    super.apply(tree);
-    if (this.flattenedFns.length) {
-      (0, _insert.prepend)(tree, ...this.flattenedFns);
+  });
+  var isDebug = false;
+  function flattenFunction(fnPath) {
+    // Skip if already processed
+    if (me.isSkipped(fnPath)) return;
+
+    // Don't apply to generator functions
+    if (fnPath.node.generator) return;
+
+    // Skip getter/setter methods
+    if (fnPath.isObjectMethod() || fnPath.isClassMethod()) {
+      if (fnPath.node.kind !== "method") return;
     }
-  }
-  match(object, parents) {
-    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) {
-    return () => {
-      var _object$id, _parents$, _parents$0$id, _parents$0$id2, _parents$2, _parents$3;
-      if (parents[0]) {
-        // Don't change class methods
-        if (parents[0].type === "MethodDefinition" && parents[0].value === object) {
-          return;
-        }
 
-        // Don't change getter/setter methods
-        if (parents[0].type === "Property" && parents[0].value === object && (parents[0].kind !== "init" || parents[0].method)) {
-          return;
-        }
-      }
-      (0, _assert.ok)(object.type === "FunctionDeclaration" || object.type === "FunctionExpression");
+    // Do not apply to arrow functions
+    if (t.isArrowFunctionExpression(fnPath.node)) return;
+    if (!t.isBlockStatement(fnPath.node.body)) return;
 
-      // The name is purely for debugging purposes
-      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;
-        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 definedMap = new Map();
-      var illegal = new Set();
-      var isIllegal = false;
-      var identifierNodes = [];
-      (0, _traverse.walk)(object, parents, (o, p) => {
-        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" && 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 (info.spec.isExported || o.name.startsWith(_constants.noRenameVariablePrefix)) {
-            illegal.add(o.name);
+    // Skip if marked as unsafe
+    if (fnPath.node[_constants.UNSAFE]) return;
+    var program = fnPath.findParent(function (p) {
+      return p.isProgram();
+    });
+    var functionName = (0, _astUtils.getFunctionName)(fnPath);
+    if (!t.isValidIdentifier(functionName, true)) {
+      functionName = "anonymous";
+    }
+    if (!(0, _probability.computeProbabilityMap)(me.options.flatten, functionName)) {
+      return;
+    }
+    var strictMode = fnPath.find(function (path) {
+      return (0, _astUtils.isStrictMode)(path);
+    });
+    if (strictMode === fnPath) return;
+    me.log("Transforming", functionName);
+    var flatObjectName = "".concat(me.getPlaceholder(), "_flat_object");
+    var newFnName = "".concat(me.getPlaceholder(), "_flat_").concat(functionName);
+    var nameGen = new _NameGen.NameGen(me.options.identifierGenerator);
+    function generateProp(originalName, type) {
+      var newPropertyName;
+      do {
+        newPropertyName = isDebug ? type + "_" + originalName : nameGen.generate();
+      } while (allPropertyNames.has(newPropertyName));
+      allPropertyNames.add(newPropertyName);
+      return newPropertyName;
+    }
+    var standardProps = new Map();
+    var setterPropsNeeded = new Set();
+    var typeofProps = new Map();
+    var functionCallProps = new Map();
+    var allPropertyNames = new Set();
+    var identifierPaths = [];
+
+    // Traverse function to identify variables to be replaced with flat object properties
+    fnPath.traverse({
+      Identifier: {
+        exit: function exit(identifierPath) {
+          if (!(0, _astUtils.isVariableIdentifier)(identifierPath)) return;
+          if (identifierPath.isBindingIdentifier() && (0, _astUtils.isDefiningIdentifier)(identifierPath)) return;
+          if ((0, _functionUtils.isVariableFunctionIdentifier)(identifierPath)) return;
+          if (identifierPath.node[_constants.UNSAFE]) return;
+          var identifierName = identifierPath.node.name;
+          if (identifierName === "arguments") return;
+          var binding = identifierPath.scope.getBinding(identifierName);
+          if (!binding) {
             return;
           }
-          if (info.spec.isDefined) {
-            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);
+          var definedLocal = identifierPath.scope;
+          do {
+            if (definedLocal.hasOwnBinding(identifierName)) return;
+            if (definedLocal === fnPath.scope) break;
+            definedLocal = definedLocal.parent;
+            if (definedLocal === program.scope) (0, _assert.ok)(functionName + ":" + identifierName);
+          } while (definedLocal);
+          var cursor = fnPath.scope.parent;
+          var isOutsideVariable = false;
+          do {
+            if (cursor.hasBinding(identifierName)) {
+              isOutsideVariable = true;
+              break;
             }
+            cursor = cursor.parent;
+          } while (cursor);
+          if (!isOutsideVariable) {
             return;
           }
-          var isDefined = p.find(x => definedMap.has(x) && definedMap.get(x).has(o.name));
-          if (!isDefined) {
-            identifierNodes.push([o, p, info]);
-          }
+          identifierPaths.push(identifierPath);
         }
-        if (o.type == "TryStatement") {
-          isIllegal = true;
-          return "EXIT";
-        }
-      });
-      if (isIllegal) {
-        return;
       }
-      if (illegal.size) {
-        return;
-      }
-      var newFnName = this.getPlaceholder() + "_flat_" + currentFnName + _constants.predictableFunctionTag;
-      var flatObjectName = this.getPlaceholder() + "_flat_object";
-      const getFlatObjectMember = propertyName => {
-        return (0, _gen.MemberExpression)((0, _gen.Identifier)(flatObjectName), (0, _gen.Literal)(propertyName), true);
-      };
-      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;
-            }
+    });
+    me.log("Function ".concat(functionName), "requires", Array.from(new Set(identifierPaths.map(function (x) {
+      return x.node.name;
+    }))));
+    for (var _i = 0, _identifierPaths = identifierPaths; _i < _identifierPaths.length; _i++) {
+      var identifierPath = _identifierPaths[_i];
+      var identifierName = identifierPath.node.name;
+      if (typeof identifierName !== "string") continue;
+      var isTypeof = identifierPath.parentPath.isUnaryExpression({
+        operator: "typeof"
+      });
+      var isFunctionCall = identifierPath.parentPath.isCallExpression() && identifierPath.parentPath.node.callee === identifierPath.node;
+      if (isTypeof) {
+        var typeofProp = typeofProps.get(identifierName);
+        if (!typeofProp) {
+          typeofProp = generateProp(identifierName, "typeof");
+          typeofProps.set(identifierName, typeofProp);
+        }
+        (0, _astUtils.ensureComputedExpression)(identifierPath.parentPath);
+        identifierPath.parentPath.replaceWith(t.memberExpression(t.identifier(flatObjectName), t.stringLiteral(typeofProp), true))[0].skip();
+      } else if (isFunctionCall) {
+        var functionCallProp = functionCallProps.get(identifierName);
+        if (!functionCallProp) {
+          functionCallProp = generateProp(identifierName, "call");
+          functionCallProps.set(identifierName, functionCallProp);
+        }
+        (0, _astUtils.ensureComputedExpression)(identifierPath);
 
-            // 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 identifier with a reference to the flat object property
+        identifierPath.replaceWith(t.memberExpression(t.identifier(flatObjectName), t.stringLiteral(functionCallProp), true))[0].skip();
+      } else {
+        var standardProp = standardProps.get(identifierName);
+        if (!standardProp) {
+          standardProp = generateProp(identifierName, "standard");
+          standardProps.set(identifierName, standardProp);
+        }
+        if (!setterPropsNeeded.has(identifierName)) {
+          // Only provide 'set' method if the variable is modified
+          var isModification = (0, _astUtils.isModifiedIdentifier)(identifierPath);
+          if (isModification) {
+            setterPropsNeeded.add(identifierName);
+          }
+        }
+        (0, _astUtils.ensureComputedExpression)(identifierPath);
 
-              // Replace the entire unary expression not just the identifier node
-              // calls flatObject.get_typeof_identifier()
-              this.replace(p[0], getFlatObjectMember(typeofPropName));
-              break;
-            }
+        // Replace identifier with a reference to the flat object property
+        identifierPath.replaceWith(t.memberExpression(t.identifier(flatObjectName), t.stringLiteral(standardProp), true))[0].skip();
+      }
+    }
 
-            // 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;
-              }
+    // for (const prop of [...typeofProps.keys(), ...functionCallProps.keys()]) {
+    //   if (!standardProps.has(prop)) {
+    //     standardProps.set(prop, generateProp());
+    //   }
+    // }
 
-              // 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;
-            }
+    var flatObjectProperties = [];
+    var _iterator = _createForOfIteratorHelper(standardProps),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        var _entry = entry,
+          _entry2 = _slicedToArray(_entry, 2),
+          _identifierName = _entry2[0],
+          objectProp = _entry2[1];
+        flatObjectProperties.push(me.skip(t.objectMethod("get", t.stringLiteral(objectProp), [], t.blockStatement([t.returnStatement(t.identifier(_identifierName))]), false, false, false)));
 
-            // calls flatObject.get_identifier_value()
-            this.replace(o, getFlatObjectMember(getterPropName));
-            break;
+        // Not all properties need a setter
+        if (setterPropsNeeded.has(_identifierName)) {
+          var valueArgName = me.getPlaceholder() + "_value";
+          flatObjectProperties.push(me.skip(t.objectMethod("set", t.stringLiteral(objectProp), [t.identifier(valueArgName)], t.blockStatement([t.expressionStatement(t.assignmentExpression("=", t.identifier(_identifierName), t.identifier(valueArgName)))]), false, false, false)));
         }
       }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    var _iterator2 = _createForOfIteratorHelper(typeofProps),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _entry3 = _step2.value;
+        var _entry4 = _slicedToArray(_entry3, 2),
+          _identifierName2 = _entry4[0],
+          _objectProp = _entry4[1];
+        flatObjectProperties.push(me.skip(t.objectMethod("get", t.stringLiteral(_objectProp), [], t.blockStatement([t.returnStatement(t.unaryExpression("typeof", t.identifier(_identifierName2)))]), false, false, false)));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var _iterator3 = _createForOfIteratorHelper(functionCallProps),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _entry5 = _step3.value;
+        var _entry6 = _slicedToArray(_entry5, 2),
+          _identifierName3 = _entry6[0],
+          _objectProp2 = _entry6[1];
+        flatObjectProperties.push(me.skip(t.objectMethod("method", t.stringLiteral(_objectProp2), [t.restElement(t.identifier("args"))], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(_identifierName3), [t.spreadElement(t.identifier("args"))]))]), false, false, false)));
+      }
 
-      // Create the getter and setter functions
-      var flatObjectProperties = [];
+      // Create the new flattened function
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    var flattenedFunctionDeclaration = t.functionDeclaration(t.identifier(newFnName), [t.arrayPattern(_toConsumableArray(fnPath.node.params)), t.identifier(flatObjectName)], t.blockStatement(_toConsumableArray(fnPath.node.body.body).concat()), false, fnPath.node.async);
 
-      // 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"));
-      }
+    // Create the flat object variable declaration
+    var flatObjectDeclaration = t.variableDeclaration("var", [t.variableDeclarator(t.identifier(flatObjectName), t.objectExpression(flatObjectProperties))]);
+    var argName = me.getPlaceholder() + "_args";
 
-      // 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"));
-      }
+    // Replace original function body with a call to the flattened function
+    fnPath.node.body = t.blockStatement([flatObjectDeclaration, t.returnStatement(t.callExpression(t.identifier(newFnName), [t.identifier(argName), t.identifier(flatObjectName)]))]);
+    var originalLength = (0, _functionUtils.computeFunctionLength)(fnPath);
+    fnPath.node.params = [t.restElement(t.identifier(argName))];
 
-      // 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));
-      }
+    // Ensure updated parameter gets registered in the function scope
+    fnPath.scope.crawl();
+    fnPath.skip();
 
-      // 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"));
-      }
-      if (!this.isDebug) {
-        (0, _random.shuffle)(flatObjectProperties);
-      }
-      var newBody = (0, _insert.getBlockBody)(object.body);
+    // Add the new flattened function at the top level
+    var newPath = (0, _astUtils.prependProgram)(program, flattenedFunctionDeclaration)[0];
+    me.skip(newPath);
 
-      // Remove 'use strict' directive
-      if (newBody.length > 0 && newBody[0].directive) {
-        newBody.shift();
+    // Copy over all properties except the predictable flag
+    var _iterator4 = _createForOfIteratorHelper(Object.getOwnPropertySymbols(fnPath.node)),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var symbol = _step4.value;
+        if (symbol !== _constants.PREDICTABLE) {
+          newPath.node[symbol] = fnPath.node[symbol];
+        }
       }
-      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);
+      // Old function is no longer predictable (rest element parameter)
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    fnPath.node[_constants.PREDICTABLE] = false;
+    // Old function is unsafe (uses arguments, this)
+    fnPath.node[_constants.UNSAFE] = true;
+    newPath.node[_constants.PREDICTABLE] = true;
 
-      // Preserve function.length property
-      var originalFunctionLength = (0, _insert.computeFunctionLength)(object.params);
-      object.params = [(0, _gen.RestElement)((0, _gen.Identifier)(argumentsName))];
-      if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
-        if (!this.functionLengthName) {
-          this.functionLengthName = this.getPlaceholder();
-          (0, _insert.prepend)(parents[parents.length - 1] || object, _functionLength.FunctionLengthTemplate.single({
-            name: this.functionLengthName,
-            ObjectDefineProperty: this.createInitVariable(_globals.ObjectDefineProperty, parents)
-          }));
-        }
-        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)])));
-          }
-        } else {
-          (0, _assert.ok)(object.type === "FunctionExpression");
-          this.replace(object, (0, _gen.CallExpression)((0, _gen.Identifier)(this.functionLengthName), [{
-            ...object
-          }, (0, _gen.Literal)(originalFunctionLength)]));
+    // Carry over 'use strict' directive if not already present
+    if (strictMode) {
+      newPath.node.body.directives.push(t.directive(t.directiveLiteral("use strict")));
+
+      // Non-simple parameter list conversion
+      (0, _astUtils.prepend)(newPath, t.variableDeclaration("var", [t.variableDeclarator(t.arrayPattern(newPath.node.params), t.identifier("arguments"))]));
+      newPath.node.params = [];
+      // Using 'arguments' is unsafe
+      newPath.node[_constants.UNSAFE] = true;
+      // Params changed and using 'arguments'
+      newPath.node[_constants.PREDICTABLE] = false;
+    }
+
+    // Ensure parameters are registered in the new function scope
+    newPath.scope.crawl();
+    newPath.skip();
+    me.skip(newPath);
+
+    // Set function length
+    me.setFunctionLength(fnPath, originalLength);
+    me.changeData.functions++;
+  }
+  return {
+    visitor: {
+      Function: {
+        exit: function exit(path) {
+          flattenFunction(path);
         }
+      },
+      Program: function Program(path) {
+        path.scope.crawl();
       }
-    };
-  }
-}
-exports.default = Flatten;
+    }
+  };
+};