js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/templates/template.js

@@ -3,104 +3,224 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = Template;
-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 _constants = require("../constants");
-function Template() {
-  for (var _len = arguments.length, templates = new Array(_len), _key = 0; _key < _len; _key++) {
-    templates[_key] = arguments[_key];
+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); }
+// 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];
+    }
+    this.templates = templates;
+    this.defaultVariables = Object.create(null);
+    this.requiredVariables = new Set();
+    this.findRequiredVariables();
   }
-  (0, _assert.ok)(templates.length);
-  var requiredVariables = new Set();
-  var providedVariables = {};
-  var defaultVariables = Object.create(null);
+  return _createClass(Template, [{
+    key: "addSymbols",
+    value: function addSymbols() {
+      var _this$symbols;
+      (_this$symbols = this.symbols).push.apply(_this$symbols, arguments);
+      return this;
+    }
+  }, {
+    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);
+        });
+      }
+    }
+  }, {
+    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 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;
 
-  // This may picked up "$mb[pP`x]" from String Encoding function
-  // ignoreMissingVariables() prevents this
-  var matches = templates[0].match(/{[$A-z0-9_]+}/g);
-  if (matches !== null) {
-    matches.forEach(variable => {
-      var name = variable.slice(1, -1);
+      // 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;
+          }
 
-      // $ variables are for default variables
-      if (name.startsWith("$")) {
-        defaultVariables[name] = _constants.placeholderVariablePrefix + "td_" + Object.keys(defaultVariables).length;
-      } else {
-        requiredVariables.add(name);
-      }
-    });
-  }
-  function fill() {
-    let variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Object.create(null);
-    var userVariables = {
-      ...providedVariables,
-      ...variables
-    };
+          // Duplicate node check
+          if (isSingleUse) {
+            if (insertedVariables.has(variableName)) {
+              (0, _assert.ok)(false, "Duplicate node inserted for variable: " + variableName);
+            }
+            insertedVariables.add(variableName);
+          }
 
-    // Validate all variables were passed in
-    for (var requiredVariable of requiredVariables) {
-      if (typeof userVariables[requiredVariable] === "undefined") {
-        throw new Error(templates[0] + " missing variable: " + requiredVariable + " from " + JSON.stringify(userVariables));
+          // Insert new nodes
+          if (!Array.isArray(value)) {
+            path.replaceWith(value);
+          } else {
+            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);
+      }
+      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;
     }
-    var template = (0, _random.choice)(templates);
-    var output = template;
-    var allVariables = {
-      ...defaultVariables,
-      ...userVariables
-    };
-    Object.keys(allVariables).forEach(name => {
-      var bracketName = "{" + name.replace("$", "\\$") + "}";
-      var value = allVariables[name] + "";
-      var reg = new RegExp(bracketName, "g");
-      output = output.replace(reg, value);
-    });
-    return {
-      output,
-      template
-    };
-  }
-  function compile(variables) {
-    var {
-      output,
-      template
-    } = fill(variables);
-    try {
-      var program = (0, _parser.parseSnippet)(output);
-      return program.body;
-    } catch (e) {
-      console.error(e);
-      console.error(template);
-      console.error({
-        ...providedVariables,
-        ...variables
-      });
-      throw new Error("Template failed to parse: OUTPUT= " + output + " SOURCE= " + template);
+  }, {
+    key: "compile",
+    value: function compile() {
+      var variables = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var file = this.file(variables);
+      return file.program.body;
     }
-  }
-  function single(variables) {
-    var nodes = compile(variables);
-    return nodes[0];
-  }
-  function variables(newVariables) {
-    Object.assign(providedVariables, newVariables);
-    return obj;
-  }
-  function ignoreMissingVariables() {
-    defaultVariables = Object.create(null);
-    requiredVariables.clear();
-    return obj;
-  }
-  var obj = {
-    fill,
-    compile,
-    single,
-    templates,
-    variables,
-    ignoreMissingVariables,
-    source: templates[0]
-  };
-  return obj;
-}
+  }, {
+    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);
+            }
+          }
+        }
+      }
+    }
+  };
+};

package/dist/transforms/calculator.js

@@ -1,140 +1,83 @@
 "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 _transform = _interopRequireDefault(require("./transform"));
-var _gen = require("../util/gen");
-var _insert = require("../util/insert");
-var _random = require("../util/random");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _order = require("../order");
 var _assert = require("assert");
-var _precedence = require("../precedence");
-var _template = _interopRequireDefault(require("../templates/template"));
-var _probability = require("../probability");
-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); }
-const allowedBinaryOperators = new Set(["+", "-", "*", "/"]);
-const allowedUnaryOperators = new Set(["!", "void", "typeof", "-", "~", "+"]);
-class Calculator extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Calculator);
-    _defineProperty(this, "gen", void 0);
-    _defineProperty(this, "ops", void 0);
-    _defineProperty(this, "statesUsed", void 0);
-    _defineProperty(this, "calculatorFn", void 0);
-    _defineProperty(this, "calculatorOpVar", void 0);
-    _defineProperty(this, "calculatorSetOpFn", void 0);
-    this.ops = Object.create(null);
-    this.statesUsed = new Set();
-    this.calculatorFn = this.getPlaceholder() + "_calc";
-    this.calculatorOpVar = this.getPlaceholder();
-    this.calculatorSetOpFn = this.getPlaceholder();
-    this.gen = this.getGenerator();
-  }
-  apply(tree) {
-    super.apply(tree);
-    if (Object.keys(this.ops).length == 0) {
-      return;
+var _NameGen = require("../utils/NameGen");
+var _astUtils = require("../utils/ast-utils");
+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 _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 _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; }
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Calculator, {
+    changeData: {
+      expressions: 0
     }
-    var leftArg = this.getPlaceholder();
-    var rightArg = this.getPlaceholder();
-    var switchCases = [];
-    Object.keys(this.ops).forEach(opKey => {
-      var [type, operator] = opKey.split("_");
-      var code = this.ops[opKey];
-      var body = [];
-      if (type === "Binary") {
-        body = [(0, _gen.ReturnStatement)((0, _gen.BinaryExpression)(operator, (0, _gen.Identifier)(leftArg), (0, _gen.Identifier)(rightArg)))];
-      } else if (type === "Unary") {
-        body = [(0, _gen.ReturnStatement)((0, _gen.UnaryExpression)(operator, (0, _gen.Identifier)(leftArg)))];
-      } else {
-        throw new Error("Unknown type: " + type);
-      }
-      switchCases.push((0, _gen.SwitchCase)((0, _gen.Literal)(code), body));
-    });
-    var func = (0, _gen.FunctionDeclaration)(this.calculatorFn, [leftArg, rightArg].map(x => (0, _gen.Identifier)(x)), [(0, _gen.SwitchStatement)((0, _gen.Identifier)(this.calculatorOpVar), switchCases)]);
-    (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.calculatorOpVar)));
-    (0, _insert.prepend)(tree, (0, _template.default)(`function {name}(a){
-        a = {b} + ({b}=a, 0);
-        return a;
-      }`).single({
-      name: this.calculatorSetOpFn,
-      b: this.calculatorOpVar
-    }));
-    (0, _insert.prepend)(tree, func);
-  }
-  match(object, parents) {
-    return object.type === "BinaryExpression" || object.type === "UnaryExpression";
-  }
-  transform(object, parents) {
-    // Allow percentage
-    if (!(0, _probability.ComputeProbabilityMap)(this.options.calculator)) {
-      return;
-    }
-    var operator = object.operator;
-    var type;
-    if (object.type === "BinaryExpression") {
-      type = "Binary";
-      if (!allowedBinaryOperators.has(operator)) {
-        return;
-      }
+  });
+  var nameGen = new _NameGen.NameGen(me.options.identifierGenerator);
+  return {
+    visitor: {
+      Program: {
+        exit: function exit(programPath) {
+          var allowedBinaryOperators = new Set(["+", "-", "*", "/"]);
+          var operatorsMap = new Map();
+          var calculatorFnName = me.getPlaceholder() + "_calc";
+          programPath.traverse({
+            BinaryExpression: {
+              exit: function exit(path) {
+                var operator = path.node.operator;
+                if (t.isPrivate(path.node.left)) return;
 
-      // Additional checks to ensure complex expressions still work
-      var myPrecedence = _precedence.OPERATOR_PRECEDENCE[operator] + Object.keys(_precedence.OPERATOR_PRECEDENCE).indexOf(operator) / 100;
-      var precedences = parents.map(x => x.type == "BinaryExpression" && _precedence.OPERATOR_PRECEDENCE[x.operator] + Object.keys(_precedence.OPERATOR_PRECEDENCE).indexOf(x.operator) / 100);
+                // TODO: Improve precedence handling or remove this transformation entirely
+                if (!t.isNumericLiteral(path.node.right)) return;
+                if (!t.isNumericLiteral(path.node.left)) return;
+                if (!allowedBinaryOperators.has(operator)) return;
+                var mapKey = "binaryExpression_" + operator;
+                var operatorKey = operatorsMap.get(mapKey);
 
-      // corrupt AST
-      if (precedences.find(x => x >= myPrecedence)) {
-        return;
-      }
-      if (parents.find(x => x.$dispatcherSkip || x.type == "BinaryExpression")) {
-        return;
-      }
-    }
-    if (object.type === "UnaryExpression") {
-      type = "Unary";
-      if (!allowedUnaryOperators.has(operator)) {
-        return;
-      }
+                // Add binary operator to the map if it doesn't exist
+                if (typeof operatorKey === "undefined") {
+                  operatorKey = nameGen.generate();
+                  operatorsMap.set(mapKey, operatorKey);
+                }
+                (0, _assert.ok)(operatorKey);
+                me.changeData.expressions++;
+                path.replaceWith(t.callExpression(t.identifier(calculatorFnName), [t.stringLiteral(operatorKey), path.node.left, path.node.right]));
+              }
+            }
+          });
 
-      // Typeof expression fix
-      if (operator === "typeof" && object.argument.type === "Identifier") {
-        // `typeof name` is special because it can reference the variable `name` without
-        // throwing any errors. If changed, an error could be thrown, breaking the users code
-        return;
-      }
-    }
-    return () => {
-      const opKey = type + "_" + operator;
-      if (typeof this.ops[opKey] !== "number") {
-        var newState;
-        do {
-          newState = (0, _random.getRandomInteger)(-50, 50 + Object.keys(this.ops).length * 5);
-        } while (this.statesUsed.has(newState));
-        (0, _assert.ok)(!isNaN(newState));
-        this.statesUsed.add(newState);
-        this.ops[opKey] = newState;
-        if (type === "Binary") {
-          this.log(`left ${operator} right ->`, `${this.calculatorFn}((${newState}, left, right)`);
-        } else if (type === "Unary") {
-          this.log(`${operator}(argument) ->`, `${this.calculatorFn}(${newState}, argument)`);
-        }
-      }
+          // No operators created
+          if (operatorsMap.size < 1) {
+            return;
+          }
 
-      // The operator expression sets the operator to be used
-      var operatorExpression = (0, _random.choice)([(0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(this.calculatorOpVar), (0, _gen.Literal)(this.ops[opKey])), (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorSetOpFn), [(0, _gen.Literal)(this.ops[opKey])])]);
-      var newExpression;
-      if (type === "Binary") {
-        newExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorFn), [object.left, object.right, operatorExpression]);
-      } else {
-        newExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(this.calculatorFn), [object.argument, operatorExpression]);
+          // Create the calculator function and insert into program path
+          var switchCases = Array.from(operatorsMap.entries()).map(function (_ref2) {
+            var _ref3 = _slicedToArray(_ref2, 2),
+              mapKey = _ref3[0],
+              key = _ref3[1];
+            var _mapKey$split = mapKey.split("_"),
+              _mapKey$split2 = _slicedToArray(_mapKey$split, 2),
+              type = _mapKey$split2[0],
+              operator = _mapKey$split2[1];
+            var expression = t.binaryExpression(operator, t.identifier("a"), t.identifier("b"));
+            return t.switchCase(t.stringLiteral(key), [t.returnStatement(expression)]);
+          });
+          (0, _astUtils.prependProgram)(programPath, t.functionDeclaration(t.identifier(calculatorFnName), [t.identifier("operator"), t.identifier("a"), t.identifier("b")], t.blockStatement([t.switchStatement(t.identifier("operator"), switchCases)])));
+        }
       }
-      this.replace(object, newExpression);
-    };
-  }
-}
-exports.default = Calculator;
+    }
+  };
+};