js-confuser 1.7.3 → 2.0.0-alpha.0

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, new _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.$multiTransformSkip || 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;
+    }
+  };
+};