js-confuser 1.7.3 → 2.0.0-alpha.0

package/dist/templates/template.js

@@ -3,79 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _parser = require("../parser");
+exports["default"] = void 0;
+var babelTypes = _interopRequireWildcard(require("@babel/types"));
+var _parser = require("@babel/parser");
+var _traverse = _interopRequireDefault(require("@babel/traverse"));
 var _assert = require("assert");
-var _random = require("../util/random");
-var _traverse = _interopRequireDefault(require("../traverse"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _randomUtils = require("../utils/random-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 _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); }
+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; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), 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); }
-/**
- * Templates provides an easy way to parse code snippets into AST subtrees.
- *
- * These AST subtrees can added to the obfuscated code, tailored with variable names.
- *
- * 1. Basic string interpolation
- *
- * ```js
- * var Base64Template = new Template(`
- * function {name}(str){
- *   return btoa(str)
- * }
- * `);
- *
- * var functionDeclaration = Base64Template.single({ name: "atob" });
- * ```
- *
- * 2. AST subtree insertion
- *
- * ```js
- * var Base64Template = new Template(`
- * function {name}(str){
- *   {getWindow}
- *
- *   return {getWindowName}btoa(str)
- * }`)
- *
- * var functionDeclaration = Base64Template.single({
- *  name: "atob",
- *  getWindowName: "newWindow",
- *  getWindow: () => {
- *    return acorn.parse("var newWindow = {}").body[0];
- *  }
- * });
- * ```
- *
- * Here, the `getWindow` variable is a function that returns an AST subtree. This must be a `Node[]` array or Template.
- * Optionally, the function can be replaced with just the `Node[]` array or Template if it's already computed.
- *
- * 3. Template subtree insertion
- *
- * ```js
- * var NewWindowTemplate = new Template(`
- *   var newWindow = {};
- * `);
- *
- * var Base64Template = new Template(`
- * function {name}(str){
- *   {NewWindowTemplate}
- *
- *   return newWindow.btoa(str)
- * }`)
- *
- * var functionDeclaration = Base64Template.single({
- *  name: "atob",
- *  NewWindowTemplate: NewWindowTemplate
- * });
- * ```
- */
-class Template {
-  constructor() {
-    _defineProperty(this, "templates", void 0);
-    _defineProperty(this, "defaultVariables", void 0);
-    _defineProperty(this, "requiredVariables", void 0);
+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); }
+// Create a union type of the symbol keys in NodeSymbol
+var Template = exports["default"] = /*#__PURE__*/function () {
+  function Template() {
+    _classCallCheck(this, Template);
+    _defineProperty(this, "astIdentifierPrefix", "__t_" + (0, _randomUtils.getRandomString)(6));
+    _defineProperty(this, "symbols", []);
     for (var _len = arguments.length, templates = new Array(_len), _key = 0; _key < _len; _key++) {
       templates[_key] = arguments[_key];
     }
@@ -84,128 +38,189 @@ class Template {
     this.requiredVariables = new Set();
     this.findRequiredVariables();
   }
-  setDefaultVariables(defaultVariables) {
-    this.defaultVariables = defaultVariables;
-    return this;
-  }
-  findRequiredVariables() {
-    var matches = this.templates[0].match(/{[$A-z0-9_]+}/g);
-    if (matches !== null) {
-      matches.forEach(variable => {
-        var name = variable.slice(1, -1);
-
-        // $ variables are for default variables
-        if (name.startsWith("$")) {
-          throw new Error("Default variables are no longer supported.");
-        } else {
-          this.requiredVariables.add(name);
-        }
-      });
+  return _createClass(Template, [{
+    key: "addSymbols",
+    value: function addSymbols() {
+      var _this$symbols;
+      (_this$symbols = this.symbols).push.apply(_this$symbols, arguments);
+      return this;
     }
-  }
-
-  /**
-   * Interpolates the template with the given variables.
-   *
-   * Prepares the template string for AST parsing.
-   *
-   * @param variables
-   */
-  interpolateTemplate() {
-    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var allVariables = {
-      ...this.defaultVariables,
-      ...variables
-    };
-
-    // Validate all variables were passed in
-    for (var requiredVariable of this.requiredVariables) {
-      if (typeof allVariables[requiredVariable] === "undefined") {
-        throw new Error(this.templates[0] + " missing variable: " + requiredVariable + " from " + JSON.stringify(allVariables));
+  }, {
+    key: "setDefaultVariables",
+    value: function setDefaultVariables(defaultVariables) {
+      this.defaultVariables = defaultVariables;
+      return this;
+    }
+  }, {
+    key: "findRequiredVariables",
+    value: function findRequiredVariables() {
+      var _this = this;
+      var matches = this.templates[0].match(/{[$A-Za-z0-9_]+}/g);
+      if (matches !== null) {
+        matches.forEach(function (variable) {
+          var name = variable.slice(1, -1);
+          _this.requiredVariables.add(name);
+        });
       }
     }
-    var template = (0, _random.choice)(this.templates);
-    var output = template;
-    Object.keys(allVariables).forEach(name => {
-      var bracketName = "{" + name.replace("$", "\\$") + "}";
-      var value = allVariables[name] + "";
-      if (typeof allVariables[name] !== "string") {
-        value = name;
+  }, {
+    key: "interpolateTemplate",
+    value: function interpolateTemplate(variables) {
+      var _this2 = this;
+      var allVariables = _objectSpread(_objectSpread({}, this.defaultVariables), variables);
+      var _iterator = _createForOfIteratorHelper(this.requiredVariables),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var requiredVariable = _step.value;
+          if (typeof allVariables[requiredVariable] === "undefined") {
+            throw new Error("".concat(this.templates[0], " missing variable: ").concat(requiredVariable, " from ").concat(JSON.stringify(allVariables)));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
       }
-      var reg = new RegExp(bracketName, "g");
-      output = output.replace(reg, value);
-    });
-    return {
-      output,
-      template
-    };
-  }
+      var template = this.templates[Math.floor(Math.random() * this.templates.length)];
+      var output = template;
+      this.astVariableMappings = new Map();
+      Object.keys(allVariables).forEach(function (name) {
+        var bracketName = "{".concat(name.replace("$", "\\$"), "}");
+        var value = allVariables[name];
+        if (_this2.isASTVariable(value)) {
+          var astIdentifierName = _this2.astIdentifierPrefix + name;
+          _this2.astVariableMappings.set(name, astIdentifierName);
+          value = astIdentifierName;
+        }
+        var reg = new RegExp(bracketName, "g");
+        output = output.replace(reg, value);
+      });
+      return {
+        output: output,
+        template: template
+      };
+    }
+  }, {
+    key: "isASTVariable",
+    value: function isASTVariable(variable) {
+      return typeof variable !== "string" && typeof variable !== "number";
+    }
+  }, {
+    key: "interpolateAST",
+    value: function interpolateAST(ast, variables) {
+      if (this.astVariableMappings.size === 0) return;
+      var allVariables = _objectSpread(_objectSpread({}, this.defaultVariables), variables);
+      var template = this;
 
-  /**
-   * Finds the variables in the AST and replaces them with the given values.
-   *
-   * Note: Mutates the AST.
-   * @param ast
-   * @param variables
-   */
-  interpolateAST(ast, variables) {
-    var allVariables = {
-      ...this.defaultVariables,
-      ...variables
-    };
-    var astNames = new Set(Object.keys(allVariables).filter(name => {
-      return typeof allVariables[name] !== "string";
-    }));
-    if (astNames.size === 0) return;
-    (0, _traverse.default)(ast, (o, p) => {
-      if (o.type === "Identifier" && allVariables[o.name]) {
-        return () => {
-          var value = allVariables[o.name];
-          (0, _assert.ok)(typeof value !== "string");
-          var insertNodes = typeof value === "function" ? value() : value;
-          if (insertNodes instanceof Template) {
-            insertNodes = insertNodes.compile(allVariables);
+      // Reverse the lookup map
+      // Before {name -> __t_m4H6nk_name}
+      // After {__t_m4H6nk_name -> name}
+      var reverseMappings = new Map();
+      this.astVariableMappings.forEach(function (value, key) {
+        reverseMappings.set(value, key);
+      });
+      var insertedVariables = new Set();
+      (0, _traverse["default"])(ast, {
+        Identifier: function Identifier(path) {
+          var idName = path.node.name;
+          if (!idName.startsWith(template.astIdentifierPrefix)) return;
+          var variableName = reverseMappings.get(idName);
+          (0, _assert.ok)(variableName, "Variable ".concat(idName, " not found in mappings"));
+          var value = allVariables[variableName];
+          var isSingleUse = true; // Hard-coded nodes are deemed 'single use'
+          if (typeof value === "function") {
+            value = value();
+            isSingleUse = false;
+          }
+          if (value instanceof Template) {
+            value = value.compile(allVariables);
+            isSingleUse = false;
+          }
+
+          // Duplicate node check
+          if (isSingleUse) {
+            if (insertedVariables.has(variableName)) {
+              (0, _assert.ok)(false, "Duplicate node inserted for variable: " + variableName);
+            }
+            insertedVariables.add(variableName);
           }
-          if (!Array.isArray(insertNodes)) {
-            // Replace with expression
 
-            Object.assign(o, insertNodes);
+          // Insert new nodes
+          if (!Array.isArray(value)) {
+            path.replaceWith(value);
           } else {
-            // Insert multiple statements/declarations
-            var expressionStatement = p[0];
-            var body = p[1];
-            (0, _assert.ok)(expressionStatement.type === "ExpressionStatement");
-            (0, _assert.ok)(Array.isArray(body));
-            var index = body.indexOf(expressionStatement);
-            body.splice(index, 1, ...insertNodes);
+            path.replaceWithMultiple(value);
           }
-        };
+          path.skip();
+        }
+      });
+    }
+  }, {
+    key: "file",
+    value: function file() {
+      var _this3 = this;
+      var variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var _this$interpolateTemp = this.interpolateTemplate(variables),
+        output = _this$interpolateTemp.output;
+      var file;
+      try {
+        file = (0, _parser.parse)(output, {
+          sourceType: "module",
+          allowReturnOutsideFunction: true
+        });
+      } catch (e) {
+        throw new Error(output + "\n" + "Template failed to parse: " + e.message);
       }
-    });
-  }
-  compile() {
-    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var {
-      output,
-      template
-    } = this.interpolateTemplate(variables);
-    var program;
-    try {
-      program = (0, _parser.parseSnippet)(output);
-    } catch (e) {
-      throw new Error(output + "\n" + "Template failed to parse: " + e.message);
+      this.interpolateAST(file, variables);
+      if (this.symbols.length > 0) {
+        file.program.body.forEach(function (node) {
+          var _iterator2 = _createForOfIteratorHelper(_this3.symbols),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var symbol = _step2.value;
+              node[symbol] = true;
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        });
+      }
+      return file;
     }
-    this.interpolateAST(program, variables);
-    return program.body;
-  }
-  single() {
-    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var nodes = this.compile(variables);
-    if (nodes.length !== 1) {
-      nodes = nodes.filter(node => node.type !== "EmptyStatement");
-      (0, _assert.ok)(nodes.length === 1, `Expected single node, got ${nodes.map(node => node.type).join(", ")}`);
+  }, {
+    key: "compile",
+    value: function compile() {
+      var variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var file = this.file(variables);
+      return file.program.body;
     }
-    return nodes[0];
-  }
-}
-exports.default = Template;
+  }, {
+    key: "single",
+    value: function single() {
+      var variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var nodes = this.compile(variables);
+      if (nodes.length !== 1) {
+        var filteredNodes = nodes.filter(function (node) {
+          return node.type !== "EmptyStatement";
+        });
+        (0, _assert.ok)(filteredNodes.length === 1, "Expected single node, got ".concat(filteredNodes.map(function (node) {
+          return node.type;
+        }).join(", ")));
+        return filteredNodes[0];
+      }
+      return nodes[0];
+    }
+  }, {
+    key: "expression",
+    value: function expression() {
+      var variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var statement = this.single(variables);
+      babelTypes.assertExpressionStatement(statement);
+      return statement.expression;
+    }
+  }]);
+}();

package/dist/transforms/astScrambler.js

@@ -0,0 +1,100 @@
+"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 t = _interopRequireWildcard(require("@babel/types"));
+var _assert = require("assert");
+var _order = require("../order");
+var _constants = require("../constants");
+var _template = _interopRequireDefault(require("../templates/template"));
+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 _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.AstScrambler, {
+    changeData: {
+      expressions: 0
+    }
+  });
+  var callExprName;
+  return {
+    visitor: {
+      "Block|SwitchCase": {
+        exit: function exit(_path) {
+          var path = _path;
+          var isProgram = path.isProgram();
+          var containerKey;
+          if (path.isSwitchCase()) {
+            containerKey = "consequent";
+          } else if (path.isBlock()) {
+            containerKey = "body";
+          }
+          var container = path.node[containerKey];
+          var newContainer = [];
+          (0, _assert.ok)(Array.isArray(container));
+          var expressions = [];
+          var flushExpressions = function flushExpressions() {
+            if (!expressions.length) return;
+
+            // Not enough expressions to require a call expression
+            if (expressions.length === 1) {
+              newContainer.push(t.expressionStatement(expressions[0]));
+              expressions = [];
+              return;
+            }
+            if (!callExprName) {
+              callExprName = me.getPlaceholder() + "_ast";
+            }
+            me.changeData.expressions += expressions.length;
+            newContainer.push(t.expressionStatement(t.callExpression(t.identifier(callExprName), expressions)));
+            expressions = [];
+          };
+          var _iterator = _createForOfIteratorHelper(container),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var statement = _step.value;
+              if (
+              // Preserve last expression at the top level
+              (isProgram ? statement !== container.at(-1) : true) && t.isExpressionStatement(statement) && !statement[_constants.SKIP]) {
+                if (t.isSequenceExpression(statement.expression)) {
+                  var _expressions;
+                  (_expressions = expressions).push.apply(_expressions, _toConsumableArray(statement.expression.expressions));
+                } else {
+                  expressions.push(statement.expression);
+                }
+              } else {
+                flushExpressions();
+                newContainer.push(statement);
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          flushExpressions();
+          path.node[containerKey] = newContainer;
+          if (path.isProgram()) {
+            if (callExprName) {
+              var functionDeclaration = new _template["default"]("\n                function ".concat(callExprName, "(){\n                  ").concat(callExprName, " = function(){};\n                }\n                ")).single();
+              (0, _astUtils.append)(path, functionDeclaration);
+            }
+          }
+        }
+      }
+    }
+  };
+};