js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/dispatcher.js

@@ -1,349 +1,340 @@
 "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 _traverse = require("../traverse");
-var _gen = require("../util/gen");
-var _identifiers = require("../util/identifiers");
-var _insert = require("../util/insert");
-var _transform = _interopRequireDefault(require("./transform"));
-var _compare = require("../util/compare");
-var _random = require("../util/random");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _template = _interopRequireDefault(require("../templates/template"));
+var _assert = require("assert");
+var _randomUtils = require("../utils/random-utils");
 var _probability = require("../probability");
-var _constants = require("../constants");
 var _order = require("../order");
-var _template = _interopRequireDefault(require("../templates/template"));
-var _functionLength = require("../templates/functionLength");
-var _globals = require("../templates/globals");
-var _scope = require("../util/scope");
-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); }
-/**
- * A Dispatcher processes function calls. All the function declarations are brought into a dictionary.
- *
- * ```js
- * var param1;
- * function dispatcher(key){
- *     var fns = {
- *         'fn1': function(){
- *             var [arg1] = [param1];
- *             console.log(arg1);
- *         }
- *     }
- *     return fns[key]();
- * };
- * param1 = "Hello World";
- * dispatcher('fn1'); // > "Hello World"
- * ```
- *
- * Can break code with:
- *
- * 1. testing function equality,
- * 2. using `arguments.callee`,
- * 3. using `this`
- */
-class Dispatcher extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Dispatcher);
-    // Debug mode preserves function names
-    _defineProperty(this, "isDebug", false);
-    _defineProperty(this, "count", void 0);
-    _defineProperty(this, "functionLengthName", void 0);
-    this.count = 0;
-  }
-  apply(tree) {
-    super.apply(tree);
-    if (this.options.preserveFunctionLength && this.functionLengthName) {
-      (0, _insert.prepend)(tree, _functionLength.FunctionLengthTemplate.single({
-        name: this.functionLengthName,
-        ObjectDefineProperty: this.createInitVariable(_globals.ObjectDefineProperty, [tree])
-      }));
-    }
-  }
-  match(object, parents) {
-    if ((0, _compare.isInsideType)("AwaitExpression", object, parents)) {
-      return false;
+var _constants = require("../constants");
+var _functionUtils = require("../utils/function-utils");
+var _setFunctionLengthTemplate = require("../templates/setFunctionLengthTemplate");
+var _node = require("../utils/node");
+var _astUtils = require("../utils/ast-utils");
+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; }
+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 _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 _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.Dispatcher, {
+    changeData: {
+      functions: 0
     }
-    return (0, _insert.isVarContext)(object) && object.type !== "ArrowFunctionExpression" && !object.$dispatcherSkip && !parents.find(x => x.$dispatcherSkip);
-  }
-  transform(object, parents) {
-    return () => {
-      if ((0, _probability.ComputeProbabilityMap)(this.options.dispatcher, mode => mode)) {
-        if (object.type != "Program" && object.body.type != "BlockStatement") {
-          return;
-        }
+  });
+  var dispatcherCounter = 0;
+  var setFunctionLength = me.getPlaceholder("d_fnLength");
 
-        // Map of FunctionDeclarations
-        var functionDeclarations = Object.create(null);
+  // in Debug mode, function names are preserved
+  var isDebug = false;
+  return {
+    visitor: {
+      "Program|Function": {
+        exit: function exit(_path) {
+          var blockPath = _path;
+          if (blockPath.isProgram()) {
+            blockPath.scope.crawl();
 
-        // Array of Identifier nodes
-        var identifiers = [];
-        var illegalFnNames = new Set();
+            // Don't insert function length code when disabled
+            // Instead insert empty function as the identifier is still referenced
+            var insertNode = t.functionDeclaration(t.identifier(setFunctionLength), [], t.blockStatement([]));
+            if (me.options.preserveFunctionLength) {
+              // Insert function length code
+              insertNode = _setFunctionLengthTemplate.SetFunctionLengthTemplate.single({
+                fnName: setFunctionLength
+              });
+            }
+            me.skip((0, _astUtils.prependProgram)(_path, insertNode));
+          }
+          if (blockPath.node[_constants.UNSAFE]) return;
 
-        // New Names for Functions
-        var newFnNames = Object.create(null); // [old name]: randomized name
+          // For testing
+          // if (!blockPath.isProgram()) return;
 
-        var context = (0, _insert.isVarContext)(object) ? object : (0, _insert.getVarContext)(object, parents);
-        var lexicalScope = (0, _insert.isFunction)(context) ? context.body : context;
-        (0, _traverse.walk)(object, parents, (o, p) => {
-          if (object == o) {
-            // Fix 1
-            return;
-          }
-          var c = (0, _insert.getVarContext)(o, p);
-          if (o.type == "FunctionDeclaration") {
-            c = (0, _insert.getVarContext)(p[0], p.slice(1));
-          }
-          if (context === c) {
-            if (o.type == "FunctionDeclaration" && o.id.name) {
-              var name = o.id.name;
-              if (o.$requiresEval || o.async || o.generator || p.find(x => x.$dispatcherSkip || x.type == "MethodDefinition") || o.body.type != "BlockStatement") {
-                illegalFnNames.add(name);
-                return;
-              }
+          var blockStatement = blockPath.isProgram() ? blockPath : blockPath.get("body");
 
-              // Must defined in the same block as the current function being scanned
-              // Solves 'let' and 'class' declaration issue
-              var ls = (0, _scope.getLexicalScope)(o, p);
-              if (ls !== lexicalScope) {
-                illegalFnNames.add(name);
-                return;
-              }
+          // Track functions and illegal ones
+          // A function is illegal if:
+          // - the function is async or generator
+          // - the function is redefined
+          // - the function uses 'this', 'eval', or 'arguments'
+          var functionPaths = new Map();
+          var illegalNames = new Set();
 
-              // If dupe, no routing
-              if (functionDeclarations[name]) {
-                illegalFnNames.add(name);
-                return;
+          // Scan for function declarations
+          blockPath.traverse({
+            // Check for reassigned / redefined functions
+            BindingIdentifier: {
+              exit: function exit(path) {
+                var _path$parentPath;
+                if (!(0, _astUtils.isVariableIdentifier)(path)) return;
+                var name = path.node.name;
+                if (!((_path$parentPath = path.parentPath) !== null && _path$parentPath !== void 0 && _path$parentPath.isFunctionDeclaration())) {
+                  illegalNames.add(name);
+                }
               }
-              (0, _traverse.walk)(o, p, (oo, pp) => {
-                if (oo.type == "Identifier" && oo.name == "arguments" || oo.type == "ThisExpression" || oo.type == "Super") {
-                  if ((0, _insert.getVarContext)(oo, pp) === o) {
-                    illegalFnNames.add(name);
-                    return "EXIT";
-                  }
+            },
+            // Find functions eligible for dispatching
+            FunctionDeclaration: {
+              exit: function exit(path) {
+                var name = path.node.id.name;
+                // If the function is not named, we can't dispatch it
+                if (!name) {
+                  return;
                 }
 
-                // Avoid functions with function expressions as they have a different scope
-                if ((oo.type === "FunctionExpression" || oo.type === "ArrowFunctionExpression") && pp.find(x => x == o.params)) {
-                  illegalFnNames.add(name);
-                  return "EXIT";
+                // Do not apply to async or generator functions
+                if (path.node.async || path.node.generator) {
+                  return;
                 }
-              });
-              functionDeclarations[name] = [o, p];
-            }
-          }
-          if (o.type == "Identifier") {
-            if (_constants.reservedIdentifiers.has(o.name)) {
-              return;
-            }
-            var info = (0, _identifiers.getIdentifierInfo)(o, p);
-            if (!info.spec.isReferenced) {
-              return;
-            }
-            if (info.spec.isDefined) {
-              if (info.isFunctionDeclaration) {
-                if (p[0].id && (!functionDeclarations[p[0].id.name] || functionDeclarations[p[0].id.name][0] !== p[0])) {
-                  illegalFnNames.add(o.name);
+
+                // Do not apply to functions in nested scopes
+                if (path.parentPath !== blockStatement || me.isSkipped(path)) {
+                  illegalNames.add(name);
+                  return;
                 }
-              } else {
-                illegalFnNames.add(o.name);
+                if ((0, _astUtils.isStrictMode)(path)) {
+                  illegalNames.add(name);
+                  return;
+                }
+
+                // Do not apply to unsafe functions, redefined functions, or internal obfuscator functions
+                if (path.node[_constants.UNSAFE] || functionPaths.has(name) || me.obfuscator.isInternalVariable(name)) {
+                  illegalNames.add(name);
+                  return;
+                }
+
+                // Functions with default parameters are not fully supported
+                // (Could be a Function Expression referencing outer scope)
+                if (path.node.params.find(function (x) {
+                  return x.type === "AssignmentPattern";
+                })) {
+                  illegalNames.add(name);
+                  return;
+                }
+                functionPaths.set(name, path);
               }
-            } else if (info.spec.isModified) {
-              illegalFnNames.add(o.name);
-            } else {
-              identifiers.push([o, p]);
             }
+          });
+          var _iterator = _createForOfIteratorHelper(illegalNames),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _name = _step.value;
+              functionPaths["delete"](_name);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
           }
-        });
-        illegalFnNames.forEach(name => {
-          delete functionDeclarations[name];
-        });
-
-        // map original name->new game
-        var gen = this.getGenerator();
-        Object.keys(functionDeclarations).forEach(name => {
-          newFnNames[name] = this.isDebug ? "_dispatcher_" + this.count + "_" + name : gen.generate();
-        });
-        // set containing new name
-        var set = new Set(Object.keys(newFnNames));
+          var _iterator2 = _createForOfIteratorHelper(functionPaths.keys()),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var name = _step2.value;
+              if (!(0, _probability.computeProbabilityMap)(me.options.dispatcher, name)) {
+                functionPaths["delete"](name);
+              }
+            }
 
-        // Only make a dispatcher function if it caught any functions
-        if (set.size > 0) {
-          if (!this.functionLengthName) {
-            this.functionLengthName = this.getPlaceholder();
+            // No functions here to change
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
           }
-          var payloadArg = this.getPlaceholder() + "_dispatcher_" + this.count + "_payload";
-          var dispatcherFnName = this.getPlaceholder() + "_dispatcher_" + this.count + _constants.predictableFunctionTag;
-          this.log(dispatcherFnName, set);
-          this.count++;
-          var expectedGet = gen.generate();
-          var expectedClearArgs = gen.generate();
-          var expectedNew = gen.generate();
-          var returnProp = gen.generate();
-          var newReturnMemberName = gen.generate();
-          var shuffledKeys = (0, _random.shuffle)(Object.keys(functionDeclarations));
-          var mapName = this.getPlaceholder();
-          var cacheName = this.getPlaceholder();
-
-          // creating the dispatcher function
-          // 1. create function map
-          var map = (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(mapName, (0, _gen.ObjectExpression)(shuffledKeys.map(name => {
-            var [def, defParents] = functionDeclarations[name];
-            var body = (0, _insert.getBlockBody)(def.body);
-            var functionExpression = {
-              ...def,
-              expression: false,
-              type: "FunctionExpression",
-              id: null,
-              params: [],
-              [_constants.predictableFunctionTag]: true
-            };
-            this.addComment(functionExpression, name);
-            if (def.params.length > 0) {
-              const fixParam = param => {
-                return param;
-              };
-              var variableDeclaration = (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)({
-                type: "ArrayPattern",
-                elements: def.params.map(fixParam)
-              }, (0, _gen.Identifier)(payloadArg)));
-              (0, _insert.prepend)(def.body, variableDeclaration);
+          if (functionPaths.size === 0) {
+            return;
+          }
+          me.changeData.functions += functionPaths.size;
+          var dispatcherName = me.getPlaceholder() + "_dispatcher_" + dispatcherCounter++;
+          var payloadName = me.getPlaceholder() + "_payload";
+          var cacheName = me.getPlaceholder() + "_cache";
+          var newNameMapping = new Map();
+          var keys = {
+            placeholderNoMeaning: isDebug ? "noMeaning" : (0, _randomUtils.getRandomString)(10),
+            clearPayload: isDebug ? "clearPayload" : (0, _randomUtils.getRandomString)(10),
+            nonCall: isDebug ? "nonCall" : (0, _randomUtils.getRandomString)(10),
+            returnAsObject: isDebug ? "returnAsObject" : (0, _randomUtils.getRandomString)(10),
+            returnAsObjectProperty: isDebug ? "returnAsObjectProperty" : (0, _randomUtils.getRandomString)(10)
+          };
+          var _iterator3 = _createForOfIteratorHelper(functionPaths.keys()),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var name = _step3.value;
+              newNameMapping.set(name, isDebug ? "_" + name : (0, _randomUtils.getRandomString)(6) /**  "_" + name */);
             }
 
-            // For logging purposes
-            var signature = name + "(" + def.params.map(x => x.name || "<>").join(",") + ")";
-            this.log("Added", signature);
-
-            // delete ref in block
-            if (defParents.length) {
-              (0, _insert.deleteDirect)(def, defParents[0]);
-            }
-            this.addComment(functionExpression, signature);
-            return (0, _gen.Property)((0, _gen.Literal)(newFnNames[name]), functionExpression, false);
-          }))));
-          var getterArgName = this.getPlaceholder();
-          var x = this.getPlaceholder();
-          var y = this.getPlaceholder();
-          var z = this.getPlaceholder();
-          function getAccessor() {
-            return (0, _gen.MemberExpression)((0, _gen.Identifier)(mapName), (0, _gen.Identifier)(x), true);
+            // Find identifiers calling/referencing the functions
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
           }
+          blockPath.traverse({
+            ReferencedIdentifier: {
+              exit: function exit(path) {
+                if (path.isJSX()) return;
+                if ((0, _functionUtils.isVariableFunctionIdentifier)(path)) return;
+                var name = path.node.name;
+                var fnPath = functionPaths.get(name);
+                if (!fnPath) return;
+                var newName = newNameMapping.get(name);
 
-          // 2. define it
-          var fn = (0, _gen.FunctionDeclaration)(dispatcherFnName, [(0, _gen.Identifier)(x), (0, _gen.Identifier)(y), (0, _gen.Identifier)(z)], [
-          // Define map of callable functions
-          map,
-          // Set returning variable to undefined
-          (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(returnProp)),
-          // Arg to clear the payload
-          (0, _gen.IfStatement)((0, _gen.BinaryExpression)("==", (0, _gen.Identifier)(y), (0, _gen.Literal)(expectedClearArgs)), [(0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(payloadArg), (0, _gen.ArrayExpression)([])))], null), (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)((0, _gen.Identifier)("lengths"), (0, _gen.ObjectExpression)(!this.options.preserveFunctionLength ? [] : shuffledKeys.map(name => {
-            var [def, defParents] = functionDeclarations[name];
-            return {
-              key: newFnNames[name],
-              value: (0, _insert.computeFunctionLength)(def.params)
-            };
-          }).filter(item => item.value !== 0).map(item => (0, _gen.Property)((0, _gen.Literal)(item.key), (0, _gen.Literal)(item.value)))))), (0, _template.default)(`
-              function makeFn${_constants.predictableFunctionTag}(){
-                var fn = function(...args){
-                  ${payloadArg} = args;
-                  return ${mapName}[${x}].call(this)
-                }, a = lengths[${x}]
+                // Do not replace if not referencing the actual function
+                if (path.scope.getBinding(name).path !== fnPath) {
+                  return;
+                }
+                var createDispatcherCall = function createDispatcherCall(name, flagArg) {
+                  var dispatcherArgs = [t.stringLiteral(name)];
+                  if (flagArg) {
+                    dispatcherArgs.push(t.stringLiteral(flagArg));
+                  }
+                  var asObject = (0, _randomUtils.chance)(50);
+                  if (asObject) {
+                    if (dispatcherArgs.length < 2) {
+                      dispatcherArgs.push(t.stringLiteral(keys.placeholderNoMeaning));
+                    }
+                    dispatcherArgs.push(t.stringLiteral(keys.returnAsObject));
+                  }
+                  var callExpression = t.callExpression(t.identifier(dispatcherName), dispatcherArgs);
+                  if (!asObject) {
+                    return callExpression;
+                  }
+                  if ((0, _randomUtils.chance)(50)) {
+                    callExpression.type = "NewExpression";
+                  }
+                  return t.memberExpression(callExpression, t.stringLiteral(keys.returnAsObjectProperty), true);
+                };
 
-                ${this.options.preserveFunctionLength ? `if(a){
-                    return ${this.functionLengthName}(fn, a)
-                  }` : ""}
-                
-                return fn
+                // Replace the identifier with a call to the function
+                var parentPath = path.parentPath;
+                if (path.key === "callee" && parentPath !== null && parentPath !== void 0 && parentPath.isCallExpression()) {
+                  var expressions = [];
+                  var callArguments = parentPath.node.arguments;
+                  if (callArguments.length === 0) {
+                    expressions.push(
+                    // Call the function
+                    createDispatcherCall(newName, keys.clearPayload));
+                  } else {
+                    expressions.push(
+                    // Prepare the payload arguments
+                    t.assignmentExpression("=", t.identifier(payloadName), t.arrayExpression(callArguments)),
+                    // Call the function
+                    createDispatcherCall(newName));
+                  }
+                  var output = expressions.length === 1 ? expressions[0] : t.sequenceExpression(expressions);
+                  if (!parentPath.container) return;
+                  parentPath.replaceWith(output);
+                } else {
+                  if (!path.container) return;
+                  // Replace non-invocation references with a 'cached' version of the function
+                  path.replaceWith(createDispatcherCall(newName, keys.nonCall));
+                }
               }
-              `).single(),
-          // Arg to get a function reference
-          (0, _gen.IfStatement)((0, _gen.BinaryExpression)("==", (0, _gen.Identifier)(y), (0, _gen.Literal)(expectedGet)), [
-          // Getter flag: return the function object
-          (0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(returnProp), (0, _gen.LogicalExpression)("||", (0, _gen.MemberExpression)((0, _gen.Identifier)(cacheName), (0, _gen.Identifier)(x), true), (0, _gen.AssignmentExpression)("=", (0, _gen.MemberExpression)((0, _gen.Identifier)(cacheName), (0, _gen.Identifier)(x), true), (0, _gen.CallExpression)((0, _gen.Identifier)(`makeFn${_constants.predictableFunctionTag}`), [])))))], [
-          // Call the function, return result
-          (0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(returnProp), (0, _gen.CallExpression)(getAccessor(), [])))]),
-          // Check how the function was invoked (new () vs ())
-          (0, _gen.IfStatement)((0, _gen.BinaryExpression)("==", (0, _gen.Identifier)(z), (0, _gen.Literal)(expectedNew)), [
-          // Wrap in object
-          (0, _gen.ReturnStatement)((0, _gen.ObjectExpression)([(0, _gen.Property)((0, _gen.Identifier)(newReturnMemberName), (0, _gen.Identifier)(returnProp), false)]))], [
-          // Return raw result
-          (0, _gen.ReturnStatement)((0, _gen.Identifier)(returnProp))])]);
-          (0, _insert.append)(object, fn);
-          if (payloadArg) {
-            (0, _insert.prepend)(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(payloadArg, (0, _gen.ArrayExpression)([]))));
-          }
-          identifiers.forEach(_ref => {
-            let [o, p] = _ref;
-            if (o.type != "Identifier") {
-              return;
-            }
-            var newName = newFnNames[o.name];
-            if (!newName || typeof newName !== "string") {
-              return;
             }
-            if (!functionDeclarations[o.name]) {
-              this.error(new Error("newName, missing function declaration"));
-            }
-            var info = (0, _identifiers.getIdentifierInfo)(o, p);
-            if (info.isFunctionCall && p[0].type == "CallExpression" && p[0].callee === o) {
-              // Invoking call expression: `a();`
+          });
+          var fnLengthProperties = [];
 
-              if (o.name == dispatcherFnName) {
-                return;
+          // Create the dispatcher function
+          var objectExpression = t.objectExpression(Array.from(newNameMapping).map(function (_ref2) {
+            var _ref3 = _slicedToArray(_ref2, 2),
+              name = _ref3[0],
+              newName = _ref3[1];
+            var originalPath = functionPaths.get(name);
+            var originalFn = originalPath.node;
+            if (me.options.preserveFunctionLength) {
+              var fnLength = (0, _functionUtils.computeFunctionLength)(originalPath);
+              if (fnLength >= 1) {
+                // 0 is already the default
+                fnLengthProperties.push(t.objectProperty(t.stringLiteral(newName), (0, _node.numericLiteral)(fnLength)));
               }
-              this.log(`${o.name}(${p[0].arguments.map(_ => "<>").join(",")}) -> ${dispatcherFnName}('${newName}')`);
-              var assignmentExpressions = [];
-              var dispatcherArgs = [(0, _gen.Literal)(newName)];
-              if (p[0].arguments.length) {
-                assignmentExpressions = [(0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(payloadArg), (0, _gen.ArrayExpression)(p[0].arguments))];
-              } else {
-                dispatcherArgs.push((0, _gen.Literal)(expectedClearArgs));
-              }
-              var type = (0, _random.choice)(["CallExpression", "NewExpression"]);
-              var callExpression = null;
-              switch (type) {
-                case "CallExpression":
-                  callExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(dispatcherFnName), dispatcherArgs);
-                  break;
-                case "NewExpression":
-                  if (dispatcherArgs.length == 1) {
-                    dispatcherArgs.push((0, _gen.Identifier)("undefined"));
-                  }
-                  callExpression = (0, _gen.MemberExpression)((0, _gen.NewExpression)((0, _gen.Identifier)(dispatcherFnName), [...dispatcherArgs, (0, _gen.Literal)(expectedNew)]), (0, _gen.Identifier)(newReturnMemberName), false);
-                  break;
-              }
-              this.addComment(callExpression, "Calling " + o.name + "(" + p[0].arguments.map(x => x.name).join(", ") + ")");
-              var expr = assignmentExpressions.length ? (0, _gen.SequenceExpression)([...assignmentExpressions, callExpression]) : callExpression;
+            }
+            var newBody = _toConsumableArray(originalFn.body.body);
+            (0, _assert.ok)(Array.isArray(newBody));
 
-              // Replace the parent call expression
-              this.replace(p[0], expr);
-            } else {
-              // Non-invoking reference: `a`
+            // Unpack parameters
+            if (originalFn.params.length > 0) {
+              newBody.unshift(t.variableDeclaration("var", [t.variableDeclarator(t.arrayPattern(_toConsumableArray(originalFn.params)), t.identifier(payloadName))]));
+            }
 
-              if (info.spec.isDefined) {
-                if (info.isFunctionDeclaration) {
-                  this.log("Skipped getter " + o.name + " (function declaration)");
-                } else {
-                  this.log("Skipped getter " + o.name + " (defined)");
-                }
-                return;
-              }
-              if (info.spec.isModified) {
-                this.log("Skipped getter " + o.name + " (modified)");
-                return;
+            // Add debug label
+            if (isDebug) {
+              newBody.unshift(t.expressionStatement(t.stringLiteral("Dispatcher: ".concat(name, " -> ").concat(newName))));
+            }
+            var functionExpression = t.functionExpression(null, [], t.blockStatement(newBody));
+            var _iterator4 = _createForOfIteratorHelper(Object.getOwnPropertySymbols(originalFn)),
+              _step4;
+            try {
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                var symbol = _step4.value;
+                functionExpression[symbol] = originalFn[symbol];
               }
-              this.log(`(getter) ${o.name} -> ${dispatcherFnName}('${newName}')`);
-              this.replace(o, (0, _gen.CallExpression)((0, _gen.Identifier)(dispatcherFnName), [(0, _gen.Literal)(newName), (0, _gen.Literal)(expectedGet)]));
+            } catch (err) {
+              _iterator4.e(err);
+            } finally {
+              _iterator4.f();
             }
+            functionExpression[_constants.PREDICTABLE] = true;
+            return t.objectProperty(t.stringLiteral(newName), functionExpression);
+          }));
+          var fnLengths = t.objectExpression(fnLengthProperties);
+          var dispatcher = new _template["default"]("\n            function ".concat(dispatcherName, "(name, flagArg, returnTypeArg, fnLengths = {fnLengthsObjectExpression}) {\n              var output;\n              var fns = {objectExpression};\n\n              if(flagArg === \"").concat(keys.clearPayload, "\") {\n                ").concat(payloadName, " = [];\n              }\n              if(flagArg === \"").concat(keys.nonCall, "\") {\n                function createFunction(){\n                  var fn = function(...args){ \n                    ").concat(payloadName, " = args;\n                    return fns[name].apply(this);\n                  }\n\n                  var fnLength = fnLengths[name];\n                  if(fnLength) {\n                    ").concat(setFunctionLength, "(fn, fnLength);\n                  }\n\n                  return fn;\n                }\n                output = ").concat(cacheName, "[name] || (").concat(cacheName, "[name] = createFunction());\n              } else {\n                output = fns[name]();\n              }\n\n              if(returnTypeArg === \"").concat(keys.returnAsObject, "\") {\n                return { \"").concat(keys.returnAsObjectProperty, "\": output };\n              } else {\n                return output;\n              }\n            }\n            ")).single({
+            objectExpression: objectExpression,
+            fnLengthsObjectExpression: fnLengths
           });
-          (0, _insert.prepend)(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)((0, _gen.Identifier)(cacheName), (0, _template.default)(`Object.create(null)`).single().expression)));
+          dispatcher[_constants.PREDICTABLE] = true;
+
+          /**
+           * Prepends the node into the block. (And registers the declaration)
+           * @param node
+           */
+          function prepend(node) {
+            var newPath = blockStatement.unshiftContainer("body", node)[0];
+            blockStatement.scope.registerDeclaration(newPath);
+          }
+
+          // Insert the dispatcher function
+          prepend(dispatcher);
+
+          // Insert the payload variable
+          prepend(t.variableDeclaration("var", [t.variableDeclarator(t.identifier(payloadName))]));
+
+          // Insert the cache variable
+          prepend(t.variableDeclaration("var", [t.variableDeclarator(t.identifier(cacheName), new _template["default"]("Object[\"create\"](null)").expression())]));
+
+          // Remove original functions
+          var _iterator5 = _createForOfIteratorHelper(functionPaths.values()),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var path = _step5.value;
+              path.remove();
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
         }
       }
-    };
-  }
-}
-exports.default = Dispatcher;
+    }
+  };
+};