js-confuser 1.7.3 → 2.0.0-alpha.0

package/dist/transforms/opaquePredicates.js

@@ -1,133 +1,80 @@
 "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 _random = require("../util/random");
+exports["default"] = void 0;
 var _order = require("../order");
-var _insert = require("../util/insert");
-var _template = _interopRequireDefault(require("../templates/template"));
+var t = _interopRequireWildcard(require("@babel/types"));
+var _astUtils = require("../utils/ast-utils");
+var _randomUtils = require("../utils/random-utils");
 var _probability = require("../probability");
-var _assert = require("assert");
-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 testTypes = new Set(["ForStatement", "WhileStatement", "DoWhileStatement", "IfStatement", "ConditionExpression"]);
-function isTestExpression(object, parents) {
-  if (!object || !parents[0]) {
-    return false;
+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; }
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.OpaquePredicates, {
+    changeData: {
+      opaquePredicates: 0
+    }
+  });
+  function createTruePredicate(path) {
+    var controlObject = me.getControlObject((0, _astUtils.getBlock)(path));
+    var trueValue = controlObject.createTruePredicate();
+    return trueValue;
   }
-  if (testTypes.has(parents[0].type) && parents[0].test === object) {
-    return true;
+  var active = true;
+  var transformCount = 0;
+  function shouldTransform(path) {
+    if (!active) return false;
+    if (path.find(function (p) {
+      return me.isSkipped(p);
+    })) return false;
+    if (!(0, _probability.computeProbabilityMap)(me.options.opaquePredicates)) return false;
+    transformCount++;
+    var depth = path.getAncestry().length;
+    return (0, _randomUtils.chance)(1000 - transformCount - depth * 100);
   }
-  return false;
-}
-
-/**
- * Changes test expression (such as if statements, for loops) to add predicates.
- *
- * Predicates are computed at runtime.
- */
-class OpaquePredicates extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.OpaquePredicates);
-    _defineProperty(this, "undefinedVar", void 0);
-    _defineProperty(this, "nullVar", void 0);
-    _defineProperty(this, "numberVar", void 0);
-    _defineProperty(this, "predicateName", void 0);
-    _defineProperty(this, "predicate", void 0);
-    _defineProperty(this, "predicates", void 0);
-    _defineProperty(this, "gen", void 0);
-    _defineProperty(this, "made", void 0);
-    this.predicates = Object.create(null);
-    this.gen = this.getGenerator();
-    this.made = 0;
-  }
-  match(object, parents) {
-    return (isTestExpression(object, parents) || object.type == "SwitchCase") && !parents.find(x => x.$multiTransformSkip || x.type == "AwaitExpression");
+  function wrapWithPredicate(path) {
+    var newExpression = t.logicalExpression("&&", createTruePredicate(path), path.node);
+    me.changeData.opaquePredicates++;
+    path.replaceWith(me.skip(newExpression));
   }
-  transform(object, parents) {
-    return () => {
-      if (!(0, _probability.ComputeProbabilityMap)(this.options.opaquePredicates)) {
-        return;
-      }
-      this.made++;
-      if (this.made > 150) {
-        return;
-      }
-      if (!this.predicate) {
-        this.predicateName = this.getPlaceholder();
-        this.predicate = (0, _gen.ObjectExpression)([]);
-        var tempName = this.getPlaceholder();
-        (0, _insert.prepend)(parents[parents.length - 1] || object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.predicateName, (0, _gen.CallExpression)((0, _gen.FunctionExpression)([], [(0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(tempName, this.predicate)), (0, _gen.ReturnStatement)((0, _gen.Identifier)(tempName))]), []))));
-      }
-      var expr = (0, _random.choice)(Object.values(this.predicates));
-      if (!expr || Math.random() < 0.5 / (Object.keys(this.predicates).length || 1)) {
-        var prop = this.gen.generate();
-        var accessor = (0, _gen.MemberExpression)((0, _gen.Identifier)(this.predicateName), (0, _gen.Identifier)(prop), false);
-        switch ((0, _random.choice)(["array", "number", "string"])) {
-          case "array":
-            var arrayProp = this.gen.generate();
-            this.predicate.properties.push((0, _gen.Property)((0, _gen.Identifier)(arrayProp), (0, _gen.ArrayExpression)([])));
-            var paramName = this.getPlaceholder();
-            this.predicate.properties.push((0, _gen.Property)((0, _gen.Identifier)(prop), (0, _gen.FunctionExpression)([(0, _gen.AssignmentPattern)((0, _gen.Identifier)(paramName), (0, _gen.Literal)("length"))], new _template.default(`
-                  if ( !${this.predicateName}.${arrayProp}[0] ) {
-                    ${this.predicateName}.${arrayProp}.push(${(0, _random.getRandomInteger)(-100, 100)});
-                  }
-                  return ${this.predicateName}.${arrayProp}[${paramName}];
-                `).compile())));
-            expr = (0, _gen.CallExpression)(accessor, []);
-            break;
-          case "number":
-            this.predicate.properties.push((0, _gen.Property)((0, _gen.Identifier)(prop), (0, _gen.Literal)((0, _random.getRandomInteger)(15, 90))));
-            expr = (0, _gen.BinaryExpression)(">", accessor, (0, _gen.Literal)((0, _random.getRandomInteger)(-90, 10)));
-            break;
-          case "string":
-            var str = this.gen.generate();
-            var index = (0, _random.getRandomInteger)(0, str.length);
-            var fn = Math.random() > 0.5 ? "charAt" : "charCodeAt";
-            this.predicate.properties.push((0, _gen.Property)((0, _gen.Identifier)(prop), (0, _gen.Literal)(str)));
-            expr = (0, _gen.BinaryExpression)("==", (0, _gen.CallExpression)((0, _gen.MemberExpression)(accessor, (0, _gen.Literal)(fn), true), [(0, _gen.Literal)(index)]), (0, _gen.Literal)(str[fn](index)));
-            break;
-        }
-        (0, _assert.ok)(expr);
-        this.predicates[prop] = expr;
-        if (Math.random() > 0.8) {
-          (0, _random.shuffle)(this.predicate.properties);
+  return {
+    visitor: {
+      // if (test) -> if (PREDICATE() && test) {}
+      IfStatement: {
+        exit: function exit(path) {
+          if (!shouldTransform(path)) return;
+          wrapWithPredicate(path.get("test"));
         }
-      }
-      var cloned = (0, _insert.clone)(expr);
-      if (object.type == "SwitchCase" && object.test) {
-        var matching = (0, _gen.Identifier)((0, _random.choice)(["undefined", "null"]));
-        var test = object.test;
-        if (test.type == "Literal") {
-          if (typeof test.value === "number") {
-            matching = (0, _gen.Literal)((0, _random.getRandomInteger)(-250, 250));
-          } else if (typeof test.value === "string") {
-            matching = (0, _gen.Literal)((0, _random.getRandomString)(4));
-          }
+      },
+      // test ? a : b -> PREDICATE() && test ? a : b
+      ConditionalExpression: {
+        exit: function exit(path) {
+          if (!shouldTransform(path)) return;
+          wrapWithPredicate(path.get("test"));
         }
-        var conditionalExpression = (0, _gen.ConditionalExpression)(cloned, (0, _insert.clone)(test), matching);
-        if (Math.random() > 0.5) {
-          conditionalExpression = (0, _gen.ConditionalExpression)((0, _gen.UnaryExpression)("!", cloned), matching, (0, _insert.clone)(test));
+      },
+      // case test: -> case PREDICATE() && test:
+      SwitchCase: {
+        exit: function exit(path) {
+          if (!path.node.test) return;
+          if (!shouldTransform(path)) return;
+          wrapWithPredicate(path.get("test"));
         }
-        this.replace(test, conditionalExpression);
-      } else if (isTestExpression(object, parents)) {
-        if (object.type == "Literal" && !object.regex) {
-          if (object.value) {
-            this.replace(object, cloned);
-          } else {
-            this.replace(object, (0, _gen.UnaryExpression)("!", cloned));
-          }
-        } else {
-          this.replace(object, (0, _gen.LogicalExpression)("&&", (0, _insert.clone)(object), cloned));
+      },
+      // return test -> if (predicate()) { return test } else { return fake }
+      ReturnStatement: {
+        exit: function exit(path) {
+          if (!path.node.argument) return;
+          if (!shouldTransform(path)) return;
+          me.changeData.opaquePredicates++;
+          path.replaceWith(t.ifStatement(createTruePredicate(path), t.blockStatement([t.returnStatement(path.node.argument)]), t.blockStatement([t.returnStatement(t.stringLiteral((0, _randomUtils.getRandomString)(6)))])));
+          me.skip(path);
         }
       }
-    };
-  }
-}
-exports.default = OpaquePredicates;
+    }
+  };
+};

package/dist/transforms/pack.js

@@ -0,0 +1,160 @@
+"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"] = pack;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _obfuscator = _interopRequireDefault(require("../obfuscator"));
+var _template = _interopRequireDefault(require("../templates/template"));
+var _astUtils = require("../utils/ast-utils");
+var _constants = require("../constants");
+var _order = require("../order");
+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 _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function 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); }
+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 pack(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Pack, {
+    changeData: {
+      globals: 0
+    }
+  });
+  var _objectName = me.obfuscator.nameGen.generate();
+  var mappings = new Map();
+  var setterPropsNeeded = new Set();
+  var typeofMappings = new Map();
+  var prependNodes = [];
+  return {
+    // Transform identifiers, preserve import statements
+    visitor: {
+      ImportDeclaration: function ImportDeclaration(path) {
+        prependNodes.push(path.node);
+        path.remove();
+
+        // Ensure bindings are removed -> variable becomes a global -> added to mappings object
+        path.scope.crawl();
+      },
+      Program: function Program(path) {
+        path.scope.crawl();
+      },
+      Identifier: {
+        exit: function exit(path) {
+          if (!(0, _astUtils.isVariableIdentifier)(path)) return;
+          if ((0, _astUtils.isDefiningIdentifier)(path)) return;
+          if (path.node[_constants.GEN_NODE]) return;
+          if (path.node[_constants.WITH_STATEMENT]) return;
+          var identifierName = path.node.name;
+          if (_constants.reservedIdentifiers.has(identifierName)) return;
+          if (me.obfuscator.options.globalVariables.has(identifierName)) return;
+          if (identifierName === _constants.variableFunctionName) return;
+          if (!path.scope.hasGlobal(identifierName)) return;
+          if (path.key === "argument" && path.parentPath.isUnaryExpression({
+            operator: "typeof"
+          })) {
+            var unaryExpression = path.parentPath;
+            var _propertyName = typeofMappings.get(identifierName);
+            if (!_propertyName) {
+              _propertyName = me.obfuscator.nameGen.generate();
+              typeofMappings.set(identifierName, _propertyName);
+            }
+            unaryExpression.replaceWith(t.memberExpression(t.identifier(_objectName), t.stringLiteral(_propertyName), true));
+            return;
+          }
+          var propertyName = mappings.get(identifierName);
+          if (!propertyName) {
+            propertyName = me.obfuscator.nameGen.generate();
+            mappings.set(identifierName, propertyName);
+          }
+
+          // Only add setter if the identifier is modified
+          if ((0, _astUtils.isModifiedIdentifier)(path)) {
+            setterPropsNeeded.add(identifierName);
+          }
+          path.replaceWith(t.memberExpression(t.identifier(_objectName), t.stringLiteral(propertyName), true));
+        }
+      }
+    },
+    // Final AST handler
+    // Very last step in the obfuscation process
+    finalASTHandler: function finalASTHandler(ast) {
+      // Create object expression
+      // Very similar to flatten, maybe refactor to use the same code
+      var objectProperties = [];
+      me.changeData.globals = mappings.size;
+      var _iterator = _createForOfIteratorHelper(mappings),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            identifierName = _step$value[0],
+            propertyName = _step$value[1];
+          // get identifier() { return identifier; }
+          objectProperties.push(t.objectMethod("get", t.stringLiteral(propertyName), [], t.blockStatement([t.returnStatement(t.identifier(identifierName))])));
+
+          // Only add setter if the identifier is modified
+          if (setterPropsNeeded.has(identifierName)) {
+            // set identifier(value) { return identifier = value; }
+            objectProperties.push(t.objectMethod("set", t.stringLiteral(propertyName), [t.identifier(_objectName)], t.blockStatement([t.returnStatement(t.assignmentExpression("=", t.identifier(identifierName), t.identifier(_objectName)))])));
+          }
+        }
+
+        // Add typeof mappings
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var _iterator2 = _createForOfIteratorHelper(typeofMappings),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            _identifierName = _step2$value[0],
+            _propertyName2 = _step2$value[1];
+          // get typeof identifier() { return typeof identifier; }
+          objectProperties.push(t.objectMethod("get", t.stringLiteral(_propertyName2), [], t.blockStatement([t.returnStatement(t.unaryExpression("typeof", t.identifier(_identifierName)))])));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var objectExpression = t.objectExpression(objectProperties);
+
+      // Convert last expression to return statement
+      // This preserves the last expression in the packed code
+      var lastStatement = ast.program.body.at(-1);
+      if (lastStatement && t.isExpressionStatement(lastStatement)) {
+        Object.assign(lastStatement, t.returnStatement(lastStatement.expression));
+      }
+      var _outputCode = _obfuscator["default"].generateCode(ast, _objectSpread(_objectSpread({}, me.obfuscator.options), {}, {
+        compact: true
+      }));
+      var newAST = new _template["default"]("\n    {prependNodes}\n    Function({objectName}, {outputCode})({objectExpression});\n  ").file({
+        objectName: function objectName() {
+          return t.stringLiteral(_objectName);
+        },
+        outputCode: function outputCode() {
+          return t.stringLiteral(_outputCode);
+        },
+        objectExpression: objectExpression,
+        prependNodes: prependNodes
+      });
+      return newAST;
+    }
+  };
+}

package/dist/transforms/plugin.js

@@ -0,0 +1,179 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginInstance = void 0;
+var _randomUtils = require("../utils/random-utils");
+var t = _interopRequireWildcard(require("@babel/types"));
+var _constants = require("../constants");
+var _setFunctionLengthTemplate = require("../templates/setFunctionLengthTemplate");
+var _astUtils = require("../utils/ast-utils");
+var _ControlObject = _interopRequireDefault(require("../utils/ControlObject"));
+var _assert = require("assert");
+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 _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); }
+var PluginInstance = exports.PluginInstance = /*#__PURE__*/function () {
+  function PluginInstance(pluginOptions, obfuscator) {
+    _classCallCheck(this, PluginInstance);
+    _defineProperty(this, "changeData", {});
+    this.pluginOptions = pluginOptions;
+    this.obfuscator = obfuscator;
+  }
+  return _createClass(PluginInstance, [{
+    key: "name",
+    get: function get() {
+      return this.pluginOptions.name || "unnamed";
+    }
+  }, {
+    key: "order",
+    get: function get() {
+      return this.pluginOptions.order;
+    }
+  }, {
+    key: "options",
+    get: function get() {
+      return this.obfuscator.options;
+    }
+  }, {
+    key: "globalState",
+    get: function get() {
+      return this.obfuscator.globalState;
+    }
+  }, {
+    key: "skip",
+    value: function skip(path) {
+      var _this = this;
+      if (Array.isArray(path)) {
+        path.forEach(function (p) {
+          return _this.skip(p);
+        });
+      } else {
+        var any = path;
+        var node = any.isNodeType ? any.node : any;
+        node[_constants.SKIP] = this.order;
+        return node;
+      }
+    }
+
+    /**
+     * Returns `true` if the given path has been skipped by this plugin.
+     */
+  }, {
+    key: "isSkipped",
+    value: function isSkipped(path) {
+      return path.node[_constants.SKIP] === this.order;
+    }
+  }, {
+    key: "setFunctionLength",
+    value: function setFunctionLength(path, originalLength) {
+      path.node[_constants.FN_LENGTH] = originalLength;
+
+      // Function length
+      if (this.options.preserveFunctionLength && originalLength > 0) {
+        if (!this.setFunctionLengthName) {
+          this.setFunctionLengthName = this.getPlaceholder("fnLength");
+          this.skip((0, _astUtils.prependProgram)(path, _setFunctionLengthTemplate.SetFunctionLengthTemplate.compile({
+            fnName: this.setFunctionLengthName
+          })));
+        }
+        if (t.isFunctionDeclaration(path.node)) {
+          (0, _astUtils.prepend)(path.parentPath, t.expressionStatement(t.callExpression(t.identifier(this.setFunctionLengthName), [t.identifier(path.node.id.name), (0, _node.numericLiteral)(originalLength)])));
+        } else if (t.isFunctionExpression(path.node) || t.isArrowFunctionExpression(path.node)) {
+          path.replaceWith(t.callExpression(t.identifier(this.setFunctionLengthName), [path.node, (0, _node.numericLiteral)(originalLength)]));
+        } else {
+          // TODO
+        }
+      }
+    }
+
+    /**
+     * Returns a random string.
+     *
+     * Used for creating temporary variables names, typically before RenameVariables has ran.
+     *
+     * These long temp names will be converted to short, mangled names by RenameVariables.
+     */
+  }, {
+    key: "getPlaceholder",
+    value: function getPlaceholder() {
+      var suffix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+      return "__p_" + (0, _randomUtils.getRandomString)(4) + (suffix ? "_" + suffix : "");
+    }
+
+    /**
+     * Retrieves (or creates) a `ControlObject` for the given `blockPath`.
+     */
+  }, {
+    key: "getControlObject",
+    value: function getControlObject(blockPath) {
+      var createMultiple = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      (0, _assert.ok)(blockPath.isBlock());
+      var controlObjects = blockPath.node[_constants.CONTROL_OBJECTS];
+      if (!controlObjects) {
+        controlObjects = [];
+      }
+      if (controlObjects.length === 0 || createMultiple && (0, _randomUtils.chance)(controlObjects[0].propertyNames.size - 15 * controlObjects.length)) {
+        var newControlObject = new _ControlObject["default"](this, blockPath);
+        controlObjects.push(newControlObject);
+        blockPath.node[_constants.CONTROL_OBJECTS] = controlObjects;
+        return newControlObject;
+      }
+      return (0, _randomUtils.choice)(controlObjects);
+    }
+
+    /**
+     * Logs a message to the console, only if `verbose` is enabled.
+     * @param messages
+     */
+  }, {
+    key: "log",
+    value: function log() {
+      if (this.options.verbose) {
+        var _console;
+        for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {
+          messages[_key] = arguments[_key];
+        }
+        (_console = console).log.apply(_console, ["[".concat(this.name, "]")].concat(messages));
+      }
+    }
+
+    /**
+     * Logs a warning to the console, only if `verbose` is enabled.
+     * @param messages
+     */
+  }, {
+    key: "warn",
+    value: function warn() {
+      if (this.options.verbose) {
+        var _console2;
+        for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          messages[_key2] = arguments[_key2];
+        }
+        (_console2 = console).log.apply(_console2, ["WARN [".concat(this.name, "]")].concat(messages));
+      }
+    }
+
+    /**
+     * Throws an error with the given message.
+     * @param messages
+     */
+  }, {
+    key: "error",
+    value: function error() {
+      for (var _len3 = arguments.length, messages = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        messages[_key3] = arguments[_key3];
+      }
+      throw new Error("[".concat(this.name, "] ").concat(messages.join(", ")));
+    }
+  }]);
+}();