js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/string/stringSplitting.js

@@ -3,61 +3,60 @@
 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");
-var _order = require("../../order");
-var _compare = require("../../util/compare");
-var _assert = require("assert");
+exports["default"] = void 0;
+var _randomUtils = require("../../utils/random-utils");
 var _probability = require("../../probability");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _types = require("@babel/types");
+var _assert = require("assert");
+var _order = require("../../order");
+var _astUtils = require("../../utils/ast-utils");
+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 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 _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); }
-class StringSplitting extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.StringSplitting);
-    _defineProperty(this, "joinPrototype", void 0);
-    _defineProperty(this, "strings", void 0);
-    _defineProperty(this, "adders", void 0);
-    _defineProperty(this, "vars", void 0);
-    this.joinPrototype = null;
-    this.strings = Object.create(null);
-    this.adders = [];
-    this.vars = [];
-  }
-  match(object, parents) {
-    return object.type == "Literal" && typeof object.value === "string" && object.value.length >= 8 && !(0, _compare.isModuleSource)(object, parents) && !(0, _compare.isDirective)(object, parents);
-  }
-  transform(object, parents) {
-    return () => {
-      var size = Math.round(Math.max(6, object.value.length / (0, _random.getRandomInteger)(3, 8)));
-      if (object.value.length <= size) {
-        return;
-      }
-      var chunks = (0, _random.splitIntoChunks)(object.value, size);
-      if (!chunks || chunks.length <= 1) {
-        return;
-      }
-      if (!(0, _probability.ComputeProbabilityMap)(this.options.stringSplitting, x => x, object.value)) {
-        return;
-      }
-      var binaryExpression;
-      var parent;
-      var last = chunks.pop();
-      chunks.forEach((chunk, i) => {
-        if (i == 0) {
-          parent = binaryExpression = (0, _gen.BinaryExpression)("+", (0, _gen.Literal)(chunk), (0, _gen.Literal)(""));
-        } else {
-          binaryExpression.left = (0, _gen.BinaryExpression)("+", (0, _insert.clone)(binaryExpression.left), (0, _gen.Literal)(chunk));
-          (0, _assert.ok)(binaryExpression);
+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); }
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.StringSplitting, {
+    changeData: {
+      strings: 0
+    }
+  });
+  return {
+    visitor: {
+      StringLiteral: {
+        exit: function exit(path) {
+          var object = path.node;
+          var size = Math.round(Math.max(6, object.value.length / (0, _randomUtils.getRandomInteger)(3, 8)));
+          if (object.value.length <= size) {
+            return;
+          }
+          var chunks = (0, _randomUtils.splitIntoChunks)(object.value, size);
+          if (!chunks || chunks.length <= 1) {
+            return;
+          }
+          if (!(0, _probability.computeProbabilityMap)(me.options.stringSplitting, object.value)) {
+            return;
+          }
+          var binExpr;
+          var parent;
+          var last = chunks.pop();
+          chunks.forEach(function (chunk, i) {
+            if (i == 0) {
+              parent = binExpr = (0, _types.binaryExpression)("+", (0, _types.stringLiteral)(chunk), (0, _types.stringLiteral)(""));
+            } else {
+              binExpr.left = (0, _types.binaryExpression)("+", _objectSpread({}, binExpr.left), (0, _types.stringLiteral)(chunk));
+              (0, _assert.ok)(binExpr);
+            }
+          });
+          parent.right = (0, _types.stringLiteral)(last);
+          me.changeData.strings++;
+          (0, _astUtils.ensureComputedExpression)(path);
+          path.replaceWith(parent);
+          path.skip();
         }
-      });
-      parent.right = (0, _gen.Literal)(last);
-      this.replaceIdentifierOrLiteral(object, parent, parents);
-    };
-  }
-}
-exports.default = StringSplitting;
+      }
+    }
+  };
+};

package/dist/transforms/variableMasking.js

@@ -0,0 +1,232 @@
+"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 _template = _interopRequireDefault(require("../templates/template"));
+var _probability = require("../probability");
+var _order = require("../order");
+var _constants = require("../constants");
+var _astUtils = require("../utils/ast-utils");
+var _functionUtils = require("../utils/function-utils");
+var _assert = require("assert");
+var _NameGen = require("../utils/NameGen");
+var _randomUtils = require("../utils/random-utils");
+var _node = require("../utils/node");
+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 _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.VariableMasking, {
+    changeData: {
+      functions: 0
+    }
+  });
+  var transformFunction = function transformFunction(fnPath) {
+    // Do not apply to getter/setter methods
+    if (fnPath.isObjectMethod() && fnPath.node.kind !== "method") {
+      return;
+    }
+
+    // Do not apply to class getters/setters
+    if (fnPath.isClassMethod() && fnPath.node.kind !== "method") {
+      return;
+    }
+
+    // Do not apply to async or generator functions
+    if (fnPath.node.generator || fnPath.node.async) {
+      return;
+    }
+
+    // Do not apply to functions with rest parameters or destructuring
+    if (fnPath.node.params.some(function (param) {
+      return !t.isIdentifier(param);
+    })) {
+      return;
+    }
+
+    // Do not apply to 'use strict' functions
+    if ((0, _astUtils.isStrictMode)(fnPath)) return;
+
+    // Do not apply to functions marked unsafe
+    if (fnPath.node[_constants.UNSAFE]) return;
+    var functionName = (0, _astUtils.getFunctionName)(fnPath);
+    if (!(0, _probability.computeProbabilityMap)(me.options.variableMasking, functionName)) {
+      return;
+    }
+    var stackName = me.getPlaceholder() + "_varMask";
+    var stackMap = new Map();
+    var propertyGen = new _NameGen.NameGen("mangled");
+    var stackKeys = new Set();
+    var needsStack = false;
+    var illegalBindings = new Set();
+    function checkBinding(binding) {
+      // Custom illegal check
+      // Variable Declarations with more than one declarator are not supported
+      // They can be inserted from the user's code even though Preparation phase should prevent it
+      // String Compression library includes such code
+      // TODO: Support multiple declarators
+      var variableDeclaration = binding.path.find(function (p) {
+        return p.isVariableDeclaration();
+      });
+      if (variableDeclaration && variableDeclaration.node.declarations.length > 1) {
+        return false;
+      }
+      function checkForUnsafe(valuePath) {
+        var hasUnsafeNode = false;
+        valuePath.traverse({
+          ThisExpression: function ThisExpression(path) {
+            hasUnsafeNode = true;
+            path.stop();
+          },
+          Function: function Function(path) {
+            if (path.node[_constants.UNSAFE]) {
+              hasUnsafeNode = true;
+              path.stop();
+            }
+          }
+        });
+        return hasUnsafeNode;
+      }
+
+      // Check function value for 'this'
+      // Adding function expression to the stack (member expression)
+      // would break the 'this' context
+      if (binding.path.isVariableDeclarator()) {
+        var init = binding.path.get("init");
+        if (init.node) {
+          if (checkForUnsafe(init)) return false;
+        }
+      }
+
+      // x = function(){ return this }
+      // Cannot be transformed to x = stack[0] as 'this' would change
+      var _iterator = _createForOfIteratorHelper(binding.constantViolations),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var assignment = _step.value;
+          if (checkForUnsafe(assignment)) return false;
+        }
+
+        // __JS_CONFUSER_VAR__(identifier) -> __JS_CONFUSER_VAR__(stack.identifier)
+        // This cannot be transformed as it would break the user's code
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var _iterator2 = _createForOfIteratorHelper(binding.referencePaths),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var referencePath = _step2.value;
+          if ((0, _functionUtils.isVariableFunctionIdentifier)(referencePath)) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return true;
+    }
+    var _iterator3 = _createForOfIteratorHelper(fnPath.get("params")),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var param = _step3.value;
+        (0, _assert.ok)(param.isIdentifier());
+        var paramName = param.node.name;
+        var binding = param.scope.getBinding(paramName);
+        if (!binding || !checkBinding(binding)) return;
+        (0, _assert.ok)(!stackMap.has(binding));
+        stackKeys.add(stackMap.size.toString());
+        stackMap.set(binding, stackMap.size);
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    fnPath.traverse({
+      Identifier: function Identifier(path) {
+        if (!(0, _astUtils.isVariableIdentifier)(path)) return;
+        if (_constants.reservedIdentifiers.has(path.node.name)) return;
+        if (me.options.globalVariables.has(path.node.name)) return;
+        if (path.node.name === stackName) return;
+        if (path.node.name === _constants.variableFunctionName) return;
+        var binding = path.scope.getBinding(path.node.name);
+        if (!binding || binding.scope !== fnPath.scope) return;
+        if (illegalBindings.has(binding)) return;
+        needsStack = true;
+        var index = stackMap.get(binding);
+        if (typeof index === "undefined") {
+          // Only transform var and let bindings
+          // Function declarations could be hoisted and changing them to declarations is breaking
+          if (!["var", "let"].includes(binding.kind)) {
+            illegalBindings.add(binding);
+            return;
+          }
+          if (!checkBinding(binding)) {
+            illegalBindings.add(binding);
+            return;
+          }
+          do {
+            index = (0, _randomUtils.choice)([stackMap.size, propertyGen.generate(), (0, _randomUtils.getRandomInteger)(-250, 250)]);
+          } while (!index || stackKeys.has(index.toString()));
+          stackMap.set(binding, index);
+          stackKeys.add(index.toString());
+        }
+        var memberExpression = t.memberExpression(t.identifier(stackName), (0, _node.createLiteral)(index), true);
+        if ((0, _astUtils.isDefiningIdentifier)(path)) {
+          (0, _astUtils.replaceDefiningIdentifierToMemberExpression)(path, memberExpression);
+          return;
+        }
+        (0, _astUtils.ensureComputedExpression)(path);
+        path.replaceWith(memberExpression);
+      }
+    });
+    if (!needsStack) return;
+    var originalParamCount = fnPath.node.params.length;
+    var originalLength = (0, _functionUtils.computeFunctionLength)(fnPath);
+    fnPath.node.params = [t.restElement(t.identifier(stackName))];
+
+    // Discard extraneous parameters
+    // Predictable functions are guaranteed to not have extraneous parameters
+    if (!fnPath.node[_constants.PREDICTABLE]) {
+      (0, _astUtils.prepend)(fnPath, new _template["default"]("".concat(stackName, "[\"length\"] = {originalParamCount};")).single({
+        originalParamCount: t.numericLiteral(originalParamCount)
+      }));
+    }
+
+    // Function is no longer predictable
+    fnPath.node[_constants.PREDICTABLE] = false;
+    fnPath.scope.registerBinding("param", fnPath.get("params")[0], fnPath);
+    me.setFunctionLength(fnPath, originalLength);
+    me.changeData.functions++;
+  };
+  return {
+    visitor: {
+      Function: {
+        exit: function exit(path) {
+          if (!path.get("body").isBlockStatement()) return;
+          transformFunction(path);
+        }
+      },
+      Program: {
+        enter: function enter(path) {
+          path.scope.crawl();
+        }
+      }
+    }
+  };
+};

package/dist/utils/ControlObject.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _NameGen = require("./NameGen");
+var _astUtils = require("./ast-utils");
+var _randomUtils = require("./random-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 _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 _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); }
+/**
+ * A Control Object is an object that is used to store properties that are used in multiple places.
+ */
+var ControlObject = exports["default"] = /*#__PURE__*/function () {
+  function ControlObject(me, blockPath) {
+    _classCallCheck(this, ControlObject);
+    _defineProperty(this, "propertyNames", new Set());
+    _defineProperty(this, "objectName", null);
+    _defineProperty(this, "objectPath", null);
+    _defineProperty(this, "objectExpression", null);
+    this.me = me;
+    this.blockPath = blockPath;
+    this.nameGen = new _NameGen.NameGen(me.options.identifierGenerator, {
+      avoidReserved: true,
+      avoidObjectPrototype: true
+    });
+  }
+  return _createClass(ControlObject, [{
+    key: "createMemberExpression",
+    value: function createMemberExpression(propertyName) {
+      return t.memberExpression(t.identifier(this.objectName), t.stringLiteral(propertyName), true);
+    }
+  }, {
+    key: "createPredicate",
+    value: function createPredicate() {
+      this.ensureCreated();
+      var propertyName = (0, _randomUtils.choice)(Array.from(this.propertyNames));
+      if (!propertyName || (0, _randomUtils.chance)(50)) {
+        propertyName = this.nameGen.generate();
+      }
+      return {
+        node: t.binaryExpression("in", t.stringLiteral(propertyName), t.identifier(this.objectName)),
+        value: this.propertyNames.has(propertyName)
+      };
+    }
+  }, {
+    key: "createTruePredicate",
+    value: function createTruePredicate() {
+      var _this$createPredicate = this.createPredicate(),
+        node = _this$createPredicate.node,
+        value = _this$createPredicate.value;
+      if (value) {
+        return node;
+      }
+      return t.unaryExpression("!", node);
+    }
+  }, {
+    key: "createFalsePredicate",
+    value: function createFalsePredicate() {
+      var _this$createPredicate2 = this.createPredicate(),
+        node = _this$createPredicate2.node,
+        value = _this$createPredicate2.value;
+      if (!value) {
+        return node;
+      }
+      return t.unaryExpression("!", node);
+    }
+  }, {
+    key: "ensureCreated",
+    value: function ensureCreated(node) {
+      if (!this.objectName) {
+        // Object hasn't been created yet
+        this.objectName = this.me.getPlaceholder() + "_controlObject";
+        if (node && t.isFunctionExpression(node) && !node.id) {
+          // Use function declaration as object
+
+          var newNode = node;
+          newNode.type = "FunctionDeclaration";
+          newNode.id = t.identifier(this.objectName);
+          var newPath = (0, _astUtils.prepend)(this.blockPath, newNode)[0];
+          this.me.skip(newPath);
+          this.objectPath = newPath;
+          return t.identifier(this.objectName);
+        } else {
+          // Create plain object
+          var _newPath = (0, _astUtils.prepend)(this.blockPath, t.variableDeclaration("var", [t.variableDeclarator(t.identifier(this.objectName), t.objectExpression([]))]))[0];
+          this.me.skip(_newPath);
+          this.objectPath = _newPath;
+          var objectExpression = _newPath.node.declarations[0].init;
+          this.objectExpression = objectExpression;
+          this.me.skip(this.objectExpression);
+        }
+      }
+    }
+  }, {
+    key: "addProperty",
+    value: function addProperty(node) {
+      var initialNode = this.ensureCreated(node);
+      if (initialNode) return initialNode;
+      var propertyName = this.nameGen.generate();
+      this.propertyNames.add(propertyName);
+
+      // Add an initial property
+      if (this.objectExpression) {
+        this.objectExpression.properties.push(t.objectProperty(t.identifier(propertyName), node));
+      } else {
+        // Add as assignment expression
+
+        var assignment = t.assignmentExpression("=", this.createMemberExpression(propertyName), node);
+        var newPath = this.objectPath.insertAfter(t.expressionStatement(assignment))[0];
+        this.me.skip(newPath);
+      }
+      return this.createMemberExpression(propertyName);
+    }
+  }]);
+}();

package/dist/utils/IntGen.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IntGen = void 0;
+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 _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 _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); }
+var IntGen = exports.IntGen = /*#__PURE__*/function () {
+  function IntGen() {
+    var min = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -250;
+    var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 250;
+    _classCallCheck(this, IntGen);
+    this.min = min;
+    this.max = max;
+    this.generatedInts = new Set();
+  }
+  return _createClass(IntGen, [{
+    key: "getRandomInt",
+    value: function getRandomInt(min, max) {
+      return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+  }, {
+    key: "generate",
+    value: function generate() {
+      var randomInt;
+
+      // Keep generating until we find a unique integer
+      do {
+        randomInt = this.getRandomInt(this.min, this.max);
+
+        // Expand the range if most integers in the current range are exhausted
+        if (this.generatedInts.size >= 0.8 * (this.max - this.min)) {
+          this.min -= 100;
+          this.max += 100;
+        }
+      } while (this.generatedInts.has(randomInt));
+      this.generatedInts.add(randomInt);
+      return randomInt;
+    }
+  }]);
+}();

package/dist/utils/NameGen.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NameGen = void 0;
+var _assert = require("assert");
+var _genUtils = require("./gen-utils");
+var _randomUtils = require("./random-utils");
+var _probability = require("../probability");
+var _constants = require("../constants");
+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 _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 _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 _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 _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 _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); }
+/**
+ * Generate random names for variables and properties.
+ */
+var NameGen = exports.NameGen = /*#__PURE__*/function () {
+  function NameGen() {
+    var identifierGenerator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "randomized";
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      avoidReserved: false,
+      avoidObjectPrototype: false
+    };
+    _classCallCheck(this, NameGen);
+    _defineProperty(this, "generatedNames", new Set());
+    _defineProperty(this, "notSafeForReuseNames", new Set());
+    _defineProperty(this, "counter", 1);
+    _defineProperty(this, "zeroWidthGenerator", (0, _genUtils.createZeroWidthGenerator)());
+    this.identifierGenerator = identifierGenerator;
+    this.options = options;
+  }
+  return _createClass(NameGen, [{
+    key: "attemptGenerate",
+    value: function attemptGenerate() {
+      if (typeof this.identifierGenerator === "function") {
+        var value = this.identifierGenerator();
+        (0, _assert.ok)(typeof value === "string", "Custom identifier generator must return a string");
+        return value;
+      }
+      var mode = (0, _probability.computeProbabilityMap)(this.identifierGenerator);
+      var randomizedLength = (0, _randomUtils.getRandomInteger)(6, 8);
+      switch (mode) {
+        case "randomized":
+          var characters = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");
+          var numbers = "0123456789".split("");
+          var combined = [].concat(_toConsumableArray(characters), _toConsumableArray(numbers));
+          var result = "";
+          for (var i = 0; i < randomizedLength; i++) {
+            result += (0, _randomUtils.choice)(i == 0 ? characters : combined);
+          }
+          return result;
+        case "hexadecimal":
+          return "_0x" + (0, _randomUtils.getRandomHexString)(randomizedLength);
+        case "mangled":
+          var mangledName = "";
+          do {
+            mangledName = (0, _genUtils.alphabeticalGenerator)(this.counter++);
+          } while (_constants.reservedKeywords.includes(mangledName));
+          return mangledName;
+        case "number":
+          return "var_" + this.counter++;
+        case "zeroWidth":
+          return this.zeroWidthGenerator.generate();
+        default:
+          throw new Error("Invalid identifier generator mode: " + this.identifierGenerator);
+      }
+    }
+  }, {
+    key: "generate",
+    value: function generate() {
+      var isSafeForReuse = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var name;
+      do {
+        name = this.attemptGenerate();
+
+        // Avoid reserved keywords
+        if (this.options.avoidReserved && _constants.reservedKeywords.includes(name)) {
+          name = "";
+          continue;
+        }
+
+        // Avoid reserved object prototype properties
+        if (this.options.avoidObjectPrototype && _constants.reservedObjectPrototype.has(name)) {
+          name = "";
+          continue;
+        }
+      } while (!name || this.generatedNames.has(name));
+      this.generatedNames.add(name);
+      if (!isSafeForReuse) {
+        this.notSafeForReuseNames.add(name);
+      }
+      return name;
+    }
+  }]);
+}();