es6 to es5 with babel compilation

dist/index.js

@@ -1,5 +1,2371 @@
-"use strict";
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
 
-require("babel-polyfill");
-var JavaScriptObfuscator_1 = require('./src/JavaScriptObfuscator');
-module.exports = JavaScriptObfuscator_1.JavaScriptObfuscator;
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	__webpack_require__(1);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	module.exports = JavaScriptObfuscator_1.JavaScriptObfuscator;
+
+/***/ },
+/* 1 */
+/***/ function(module, exports) {
+
+	module.exports = require("babel-polyfill");
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var esprima = __webpack_require__(3);
+	var escodegen = __webpack_require__(4);
+	var DefaultPreset_1 = __webpack_require__(5);
+	var Obfuscator_1 = __webpack_require__(6);
+	var OptionsNormalizer_1 = __webpack_require__(37);
+
+	var JavaScriptObfuscator = function () {
+	    function JavaScriptObfuscator() {
+	        _classCallCheck(this, JavaScriptObfuscator);
+	    }
+
+	    _createClass(JavaScriptObfuscator, null, [{
+	        key: 'obfuscate',
+	        value: function obfuscate(sourceCode, customOptions) {
+	            var astTree = esprima.parse(sourceCode),
+	                options = OptionsNormalizer_1.OptionsNormalizer.normalize(Object.assign({}, DefaultPreset_1.DEFAULT_PRESET, customOptions)),
+	                obfuscator = new Obfuscator_1.Obfuscator(options);
+	            astTree = obfuscator.obfuscateNode(astTree);
+	            return JavaScriptObfuscator.generateCode(astTree, options);
+	        }
+	    }, {
+	        key: 'generateCode',
+	        value: function generateCode(astTree, options) {
+	            var escodegenParams = Object.assign({}, JavaScriptObfuscator.escodegenParams);
+	            if (options.hasOwnProperty('compact')) {
+	                escodegenParams.format = {
+	                    compact: options.compact
+	                };
+	            }
+	            return escodegen.generate(astTree, escodegenParams);
+	        }
+	    }]);
+
+	    return JavaScriptObfuscator;
+	}();
+
+	JavaScriptObfuscator.escodegenParams = {
+	    verbatim: 'x-verbatim-property'
+	};
+	exports.JavaScriptObfuscator = JavaScriptObfuscator;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = require("esprima");
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	module.exports = require("escodegen");
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.DEFAULT_PRESET = Object.freeze({
+	    compact: true,
+	    debugProtection: false,
+	    debugProtectionInterval: false,
+	    disableConsoleOutput: true,
+	    encodeUnicodeLiterals: false,
+	    reservedNames: [],
+	    rotateUnicodeArray: true,
+	    selfDefending: true,
+	    unicodeArray: true,
+	    unicodeArrayThreshold: 0.8,
+	    wrapUnicodeArrayCalls: true
+	});
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var estraverse = __webpack_require__(7);
+	var AppendState_1 = __webpack_require__(8);
+	var NodeType_1 = __webpack_require__(9);
+	var CatchClauseObfuscator_1 = __webpack_require__(12);
+	var ConsoleOutputDisableExpressionNode_1 = __webpack_require__(15);
+	var DebugProtectionNodesGroup_1 = __webpack_require__(17);
+	var FunctionDeclarationObfuscator_1 = __webpack_require__(22);
+	var FunctionObfuscator_1 = __webpack_require__(23);
+	var LiteralObfuscator_1 = __webpack_require__(24);
+	var MemberExpressionObfuscator_1 = __webpack_require__(25);
+	var MethodDefinitionObfuscator_1 = __webpack_require__(26);
+	var NodeUtils_1 = __webpack_require__(14);
+	var ObjectExpressionObfuscator_1 = __webpack_require__(27);
+	var SelfDefendingNodesGroup_1 = __webpack_require__(28);
+	var UnicodeArrayNodesGroup_1 = __webpack_require__(31);
+	var VariableDeclarationObfuscator_1 = __webpack_require__(36);
+
+	var Obfuscator = function () {
+	    function Obfuscator() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, Obfuscator);
+
+	        this.nodes = new Map();
+	        this.nodeObfuscators = new Map([[NodeType_1.NodeType.ArrowFunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.ClassDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator]], [NodeType_1.NodeType.CatchClause, [CatchClauseObfuscator_1.CatchClauseObfuscator]], [NodeType_1.NodeType.FunctionDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator, FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.FunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.MemberExpression, [MemberExpressionObfuscator_1.MemberExpressionObfuscator]], [NodeType_1.NodeType.MethodDefinition, [MethodDefinitionObfuscator_1.MethodDefinitionObfuscator]], [NodeType_1.NodeType.ObjectExpression, [ObjectExpressionObfuscator_1.ObjectExpressionObfuscator]], [NodeType_1.NodeType.VariableDeclaration, [VariableDeclarationObfuscator_1.VariableDeclarationObfuscator]], [NodeType_1.NodeType.Literal, [LiteralObfuscator_1.LiteralObfuscator]]]);
+	        this.options = options;
+	    }
+
+	    _createClass(Obfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(node) {
+	            this.setNewNodes();
+	            NodeUtils_1.NodeUtils.parentize(node);
+	            this.beforeObfuscation(node);
+	            this.obfuscate(node);
+	            this.afterObfuscation(node);
+	            return node;
+	        }
+	    }, {
+	        key: 'setNode',
+	        value: function setNode(nodeName, node) {
+	            this.nodes.set(nodeName, node);
+	        }
+	    }, {
+	        key: 'setNodesGroup',
+	        value: function setNodesGroup(nodesGroup) {
+	            var _this = this;
+
+	            var nodes = nodesGroup.getNodes();
+	            nodes.forEach(function (node, key) {
+	                _this.nodes.set(key, node);
+	            });
+	        }
+	    }, {
+	        key: 'afterObfuscation',
+	        value: function afterObfuscation(astTree) {
+	            this.nodes.forEach(function (node) {
+	                if (node.getAppendState() === AppendState_1.AppendState.AfterObfuscation) {
+	                    node.appendNode(astTree);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'beforeObfuscation',
+	        value: function beforeObfuscation(astTree) {
+	            this.nodes.forEach(function (node) {
+	                if (node.getAppendState() === AppendState_1.AppendState.BeforeObfuscation) {
+	                    node.appendNode(astTree);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'initializeNodeObfuscators',
+	        value: function initializeNodeObfuscators(node, parentNode) {
+	            var _this2 = this;
+
+	            if (!this.nodeObfuscators.has(node.type)) {
+	                return;
+	            }
+	            this.nodeObfuscators.get(node.type).forEach(function (obfuscator) {
+	                new obfuscator(_this2.nodes, _this2.options).obfuscateNode(node, parentNode);
+	            });
+	        }
+	    }, {
+	        key: 'obfuscate',
+	        value: function obfuscate(node) {
+	            var _this3 = this;
+
+	            estraverse.replace(node, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.initializeNodeObfuscators(node, parentNode);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'setNewNodes',
+	        value: function setNewNodes() {
+	            if (this.options['selfDefending']) {
+	                this.setNodesGroup(new SelfDefendingNodesGroup_1.SelfDefendingNodesGroup(this.options));
+	            }
+	            if (this.options['disableConsoleOutput']) {
+	                this.setNode('consoleOutputDisableExpressionNode', new ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode());
+	            }
+	            if (this.options['debugProtection']) {
+	                this.setNodesGroup(new DebugProtectionNodesGroup_1.DebugProtectionNodesGroup(this.options));
+	            }
+	            if (this.options['unicodeArray']) {
+	                this.setNodesGroup(new UnicodeArrayNodesGroup_1.UnicodeArrayNodesGroup(this.options));
+	            }
+	        }
+	    }]);
+
+	    return Obfuscator;
+	}();
+
+	exports.Obfuscator = Obfuscator;
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	module.exports = require("estraverse");
+
+/***/ },
+/* 8 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	(function (AppendState) {
+	    AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation";
+	    AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation";
+	})(exports.AppendState || (exports.AppendState = {}));
+	var AppendState = exports.AppendState;
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var Utils_1 = __webpack_require__(10);
+	exports.NodeType = Utils_1.Utils.strEnumify({
+	    ArrayExpression: 'ArrayExpression',
+	    ArrowFunctionExpression: 'ArrowFunctionExpression',
+	    AssignmentExpression: 'AssignmentExpression',
+	    BinaryExpression: 'BinaryExpression',
+	    BlockStatement: 'BlockStatement',
+	    CallExpression: 'CallExpression',
+	    CatchClause: 'CatchClause',
+	    ClassDeclaration: 'ClassDeclaration',
+	    ExpressionStatement: 'ExpressionStatement',
+	    FunctionDeclaration: 'FunctionDeclaration',
+	    FunctionExpression: 'FunctionExpression',
+	    Identifier: 'Identifier',
+	    IfStatement: 'IfStatement',
+	    Literal: 'Literal',
+	    LogicalExpression: 'LogicalExpression',
+	    MemberExpression: 'MemberExpression',
+	    MethodDefinition: 'MethodDefinition',
+	    ObjectExpression: 'ObjectExpression',
+	    Program: 'Program',
+	    Property: 'Property',
+	    ReturnStatement: 'ReturnStatement',
+	    TryStatement: 'TryStatement',
+	    UnaryExpression: 'UnaryExpression',
+	    UpdateExpression: 'UpdateExpression',
+	    VariableDeclaration: 'VariableDeclaration',
+	    VariableDeclarator: 'VariableDeclarator',
+	    WhileStatement: 'WhileStatement'
+	});
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var JSFuck_1 = __webpack_require__(11);
+
+	var Utils = function () {
+	    function Utils() {
+	        _classCallCheck(this, Utils);
+	    }
+
+	    _createClass(Utils, null, [{
+	        key: 'arrayContains',
+	        value: function arrayContains(array, searchElement) {
+	            return array.indexOf(searchElement) >= 0;
+	        }
+	    }, {
+	        key: 'arrayRotate',
+	        value: function arrayRotate(array, times) {
+	            var reverse = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];
+
+	            if (times < 0) {
+	                return;
+	            }
+	            var newArray = array,
+	                temp = void 0;
+	            while (times--) {
+	                if (!reverse) {
+	                    temp = newArray.pop();
+	                    newArray.unshift(temp);
+	                } else {
+	                    temp = newArray.shift();
+	                    newArray.push(temp);
+	                }
+	            }
+	            return newArray;
+	        }
+	    }, {
+	        key: 'btoa',
+	        value: function btoa(string) {
+	            return new Buffer(encodeURI(string)).toString('base64');
+	        }
+	    }, {
+	        key: 'decToHex',
+	        value: function decToHex(dec) {
+	            var decToHexSliceValue = -6,
+	                exponent = 6,
+	                radix = 16;
+	            return (dec + Math.pow(radix, exponent)).toString(radix).substr(decToHexSliceValue).replace(Utils.hexRepetitiveZerosRegExp, '');
+	        }
+	    }, {
+	        key: 'getRandomInteger',
+	        value: function getRandomInteger(min, max) {
+	            return Math.round(Math.floor(Math.random() * (max - min + 1)) + min);
+	        }
+	    }, {
+	        key: 'getRandomVariableName',
+	        value: function getRandomVariableName() {
+	            var length = arguments.length <= 0 || arguments[0] === undefined ? 6 : arguments[0];
+
+	            var rangeMinInteger = 10000,
+	                rangeMaxInteger = 99999999,
+	                prefix = '_0x';
+	            return '' + prefix + Utils.decToHex(Utils.getRandomInteger(rangeMinInteger, rangeMaxInteger)).substr(0, length);
+	        }
+	    }, {
+	        key: 'isInteger',
+	        value: function isInteger(number) {
+	            return number % 1 === 0;
+	        }
+	    }, {
+	        key: 'strEnumify',
+	        value: function strEnumify(obj) {
+	            return obj;
+	        }
+	    }, {
+	        key: 'stringToJSFuck',
+	        value: function stringToJSFuck(string) {
+	            return Array.from(string).map(function (character) {
+	                return JSFuck_1.JSFuck[character] || character;
+	            }).join(' + ');
+	        }
+	    }, {
+	        key: 'stringToUnicode',
+	        value: function stringToUnicode(string) {
+	            var radix = 16;
+	            var prefix = void 0,
+	                regexp = new RegExp('[\x00-\x7F]'),
+	                template = void 0;
+	            return '\'' + string.replace(/[\s\S]/g, function (escape) {
+	                if (regexp.test(escape)) {
+	                    prefix = '\\x';
+	                    template = '0'.repeat(2);
+	                } else {
+	                    prefix = '\\u';
+	                    template = '0'.repeat(4);
+	                }
+	                return '' + prefix + (template + escape.charCodeAt(0).toString(radix)).slice(-template.length);
+	            }) + '\'';
+	        }
+	    }]);
+
+	    return Utils;
+	}();
+
+	Utils.hexRepetitiveZerosRegExp = new RegExp('^(0{2,})+(?!$)', '');
+	exports.Utils = Utils;
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.JSFuck = {
+	    Window: '[]["filter"]["constructor"]("return this")()',
+	    False: '![]',
+	    True: '!![]',
+	    a: '(false+"")[1]',
+	    b: '([]["entries"]()+"")[2]',
+	    c: '([]["fill"]+"")[3]',
+	    d: '(undefined+"")[2]',
+	    e: '(true+"")[3]',
+	    f: '(false+"")[0]',
+	    g: '(false+[0]+String)[20]',
+	    h: '(+(101))["to"+String["name"]](21)[1]',
+	    i: '([false]+undefined)[10]',
+	    j: '([]["entries"]()+"")[3]',
+	    k: '(+(20))["to"+String["name"]](21)',
+	    l: '(false+"")[2]',
+	    m: '(Number+"")[11]',
+	    n: '(undefined+"")[1]',
+	    o: '(true+[]["fill"])[10]',
+	    p: '(+(211))["to"+String["name"]](31)[1]',
+	    q: '(+(212))["to"+String["name"]](31)[1]',
+	    r: '(true+"")[1]',
+	    s: '(false+"")[3]',
+	    t: '(true+"")[0]',
+	    u: '(undefined+"")[0]',
+	    v: '(+(31))["to"+String["name"]](32)',
+	    w: '(+(32))["to"+String["name"]](33)',
+	    x: '(+(101))["to"+String["name"]](34)[1]',
+	    y: '(NaN+[Infinity])[10]',
+	    z: '(+(35))["to"+String["name"]](36)',
+	    A: '(+[]+Array)[10]',
+	    B: '(+[]+Boolean)[10]',
+	    C: 'Function("return escape")()(("")["italics"]())[2]',
+	    D: 'Function("return escape")()([]["fill"])["slice"]("-1")',
+	    E: '(RegExp+"")[12]',
+	    F: '(+[]+Function)[10]',
+	    G: '(false+Function("return Date")()())[30]',
+	    H: '\'H\'',
+	    I: '(Infinity+"")[0]',
+	    J: '\'J\'',
+	    K: '\'K\'',
+	    L: '\'L\'',
+	    M: '(true+Function("return Date")()())[30]',
+	    N: '(NaN+"")[0]',
+	    O: '(NaN+Function("return{}")())[11]',
+	    P: '\'P\'',
+	    Q: '\'Q\'',
+	    R: '(+[]+RegExp)[10]',
+	    S: '(+[]+String)[10]',
+	    T: '(NaN+Function("return Date")()())[30]',
+	    U: '(NaN+Function("return{}")()["to"+String["name"]]["call"]())[11]',
+	    V: '\'V\'',
+	    W: '\'W\'',
+	    X: '\'X\'',
+	    Y: '\'Y\'',
+	    Z: '\'Z\''
+	};
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var CatchClauseObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(CatchClauseObfuscator, _NodeObfuscator_1$Nod);
+
+	    function CatchClauseObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, CatchClauseObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(CatchClauseObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.catchClauseParam = new Map();
+	        return _this;
+	    }
+
+	    _createClass(CatchClauseObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(catchClauseNode) {
+	            this.replaceCatchClauseParam(catchClauseNode);
+	            this.replaceCatchClauseParamInBlock(catchClauseNode);
+	        }
+	    }, {
+	        key: 'replaceCatchClauseParam',
+	        value: function replaceCatchClauseParam(catchClauseNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(catchClauseNode.param, {
+	                leave: function leave(node, parentNode) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                        _this2.catchClauseParam.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                        node.name = _this2.catchClauseParam.get(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'replaceCatchClauseParamInBlock',
+	        value: function replaceCatchClauseParamInBlock(catchClauseNode) {
+	            var _this3 = this;
+
+	            estraverse.replace(catchClauseNode.body, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.catchClauseParam);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return CatchClauseObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.CatchClauseObfuscator = CatchClauseObfuscator;
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var JSFuck_1 = __webpack_require__(11);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var NodeObfuscator = function () {
+	    function NodeObfuscator(nodes) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, NodeObfuscator);
+
+	        this.nodes = nodes;
+	        this.options = options;
+	    }
+
+	    _createClass(NodeObfuscator, [{
+	        key: "isReservedName",
+	        value: function isReservedName(name) {
+	            return this.options['reservedNames'].some(function (reservedName) {
+	                return new RegExp(reservedName, 'g').test(name);
+	            });
+	        }
+	    }, {
+	        key: "replaceNodeIdentifierByNewValue",
+	        value: function replaceNodeIdentifierByNewValue(node, parentNode, namesMap) {
+	            if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) {
+	                var parentNodeIsAPropertyNode = NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === node,
+	                    parentNodeIsAMemberExpressionNode = NodeUtils_1.NodeUtils.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node;
+	                if (parentNodeIsAPropertyNode || parentNodeIsAMemberExpressionNode) {
+	                    return;
+	                }
+	                node.name = namesMap.get(node.name);
+	            }
+	        }
+	    }, {
+	        key: "replaceLiteralBooleanByJSFuck",
+	        value: function replaceLiteralBooleanByJSFuck(nodeValue) {
+	            return nodeValue ? JSFuck_1.JSFuck.True : JSFuck_1.JSFuck.False;
+	        }
+	    }, {
+	        key: "replaceLiteralNumberByHexadecimalValue",
+	        value: function replaceLiteralNumberByHexadecimalValue(nodeValue) {
+	            var prefix = '0x';
+	            if (!Utils_1.Utils.isInteger(nodeValue)) {
+	                return String(nodeValue);
+	            }
+	            return "" + prefix + Utils_1.Utils.decToHex(nodeValue);
+	        }
+	    }, {
+	        key: "replaceLiteralValueByUnicodeValue",
+	        value: function replaceLiteralValueByUnicodeValue(nodeValue) {
+	            var value = nodeValue,
+	                replaceByUnicodeArrayFlag = Math.random() <= this.options['unicodeArrayThreshold'];
+	            if (this.options['encodeUnicodeLiterals'] && replaceByUnicodeArrayFlag) {
+	                value = Utils_1.Utils.btoa(value);
+	            }
+	            value = Utils_1.Utils.stringToUnicode(value);
+	            if (!this.options['unicodeArray'] || !replaceByUnicodeArrayFlag) {
+	                return value;
+	            }
+	            return this.replaceLiteralValueByUnicodeArrayCall(value);
+	        }
+	    }, {
+	        key: "replaceLiteralValueByUnicodeArrayCall",
+	        value: function replaceLiteralValueByUnicodeArrayCall(value) {
+	            var unicodeArrayNode = this.nodes.get('unicodeArrayNode'),
+	                unicodeArray = unicodeArrayNode.getNodeData(),
+	                sameIndex = unicodeArray.indexOf(value),
+	                index = void 0,
+	                hexadecimalIndex = void 0;
+	            if (sameIndex >= 0) {
+	                index = sameIndex;
+	            } else {
+	                index = unicodeArray.length;
+	                unicodeArrayNode.updateNodeData(value);
+	            }
+	            hexadecimalIndex = this.replaceLiteralNumberByHexadecimalValue(index);
+	            if (this.options['wrapUnicodeArrayCalls']) {
+	                return this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier() + "('" + hexadecimalIndex + "')";
+	            }
+	            return unicodeArrayNode.getNodeIdentifier() + "[" + hexadecimalIndex + "]";
+	        }
+	    }]);
+
+	    return NodeObfuscator;
+	}();
+
+	exports.NodeObfuscator = NodeObfuscator;
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var Utils_1 = __webpack_require__(10);
+
+	var NodeUtils = function () {
+	    function NodeUtils() {
+	        _classCallCheck(this, NodeUtils);
+	    }
+
+	    _createClass(NodeUtils, null, [{
+	        key: "addXVerbatimPropertyToLiterals",
+	        value: function addXVerbatimPropertyToLiterals(node) {
+	            estraverse.replace(node, {
+	                enter: function enter(node, parentNode) {
+	                    if (NodeUtils.isLiteralNode(node)) {
+	                        node['x-verbatim-property'] = node.raw;
+	                    }
+	                }
+	            });
+	        }
+	    }, {
+	        key: "appendNode",
+	        value: function appendNode(blockScopeBody, node) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.push(node);
+	        }
+	    }, {
+	        key: "getBlockScopeNodeByIndex",
+	        value: function getBlockScopeNodeByIndex(node) {
+	            var index = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+
+	            if (NodeUtils.isNodeHasBlockScope(node) && node.body[index]) {
+	                return node.body[index];
+	            }
+	            return node;
+	        }
+	    }, {
+	        key: "getBlockScopeOfNode",
+	        value: function getBlockScopeOfNode(node) {
+	            var depth = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+
+	            if (!node.parentNode) {
+	                throw new ReferenceError('`parentNode` property of given node is `undefined`');
+	            }
+	            if (node.parentNode.type === NodeType_1.NodeType.Program) {
+	                return node.parentNode;
+	            }
+	            if (!Utils_1.Utils.arrayContains(NodeUtils.scopeNodes, node.parentNode.type)) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode, depth);
+	            }
+	            if (depth > 0) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode, --depth);
+	            }
+	            if (node.type !== NodeType_1.NodeType.BlockStatement) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode);
+	            }
+	            return node;
+	        }
+	    }, {
+	        key: "getProgramNode",
+	        value: function getProgramNode(bodyNode) {
+	            return {
+	                'type': NodeType_1.NodeType.Program,
+	                'body': bodyNode
+	            };
+	        }
+	    }, {
+	        key: "insertNodeAtIndex",
+	        value: function insertNodeAtIndex(blockScopeBody, node, index) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.splice(index, 0, node);
+	        }
+	    }, {
+	        key: "isBlockStatementNode",
+	        value: function isBlockStatementNode(node) {
+	            return node.type === NodeType_1.NodeType.BlockStatement;
+	        }
+	    }, {
+	        key: "isIdentifierNode",
+	        value: function isIdentifierNode(node) {
+	            return node.type === NodeType_1.NodeType.Identifier;
+	        }
+	    }, {
+	        key: "isLiteralNode",
+	        value: function isLiteralNode(node) {
+	            return node.type === NodeType_1.NodeType.Literal;
+	        }
+	    }, {
+	        key: "isMemberExpressionNode",
+	        value: function isMemberExpressionNode(node) {
+	            return node.type === NodeType_1.NodeType.MemberExpression;
+	        }
+	    }, {
+	        key: "isNodeHasBlockScope",
+	        value: function isNodeHasBlockScope(node) {
+	            return node.hasOwnProperty('body');
+	        }
+	    }, {
+	        key: "isProgramNode",
+	        value: function isProgramNode(node) {
+	            return node.type === NodeType_1.NodeType.Program;
+	        }
+	    }, {
+	        key: "isPropertyNode",
+	        value: function isPropertyNode(node) {
+	            return node.type === NodeType_1.NodeType.Property;
+	        }
+	    }, {
+	        key: "isVariableDeclaratorNode",
+	        value: function isVariableDeclaratorNode(node) {
+	            return node.type === NodeType_1.NodeType.VariableDeclarator;
+	        }
+	    }, {
+	        key: "parentize",
+	        value: function parentize(node) {
+	            var isRootNode = true;
+	            estraverse.replace(node, {
+	                enter: function enter(node, parentNode) {
+	                    Object.defineProperty(node, 'parentNode', {
+	                        configurable: true,
+	                        enumerable: true,
+	                        value: isRootNode ? NodeUtils.getProgramNode([node]) : parentNode || node,
+	                        writable: true
+	                    });
+	                    isRootNode = false;
+	                }
+	            });
+	        }
+	    }, {
+	        key: "prependNode",
+	        value: function prependNode(blockScopeBody, node) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.unshift(node);
+	        }
+	    }, {
+	        key: "validateNode",
+	        value: function validateNode(node) {
+	            return !!node;
+	        }
+	    }]);
+
+	    return NodeUtils;
+	}();
+
+	NodeUtils.scopeNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression, NodeType_1.NodeType.MethodDefinition];
+	exports.NodeUtils = NodeUtils;
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var ConsoleOutputDisableExpressionNode = function (_Node_1$Node) {
+	    _inherits(ConsoleOutputDisableExpressionNode, _Node_1$Node);
+
+	    function ConsoleOutputDisableExpressionNode() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, ConsoleOutputDisableExpressionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ConsoleOutputDisableExpressionNode).call(this, options));
+
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(ConsoleOutputDisableExpressionNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                (function () {\n                    var _ = \'(\u0004\u0006\u0003\u0005[]\' + \'["filter"]["\u0007tructor"]\' + \'("return this")()\' + \'.\' + \'\u0003;\u0006\u0002\u0005\u0004};\' + \'_\u0003.log\u0001.in\' + \'fo\u0001.\' + \'war\' + \'n\u0001.er\' + \'r\' + \'or\u0001})();\' + \'\u0001\u0005_\u0002;\' + \'_\u0003\u0002function\' + \'\u0003\u0007ole\u0004\u0002 ()\' + \'{\u0005 = \u0006var \' + \'_\u0007cons\', \n                        Y, \n                        $;\n                    \n                    for (Y in $ = "\u0007\u0006\u0005\u0004\u0003\u0002\u0001") {\n                      var arr = _.split($[Y]);\n                      _ = arr.join(arr.pop());\n                    }\n                    \n                    []["filter"]["constructor"](_)();\n                })()\n            '));
+	        }
+	    }]);
+
+	    return ConsoleOutputDisableExpressionNode;
+	}(Node_1.Node);
+
+	exports.ConsoleOutputDisableExpressionNode = ConsoleOutputDisableExpressionNode;
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var AppendState_1 = __webpack_require__(8);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var Node = function () {
+	    function Node() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, Node);
+
+	        this.appendState = AppendState_1.AppendState.BeforeObfuscation;
+	        this.options = options;
+	    }
+
+	    _createClass(Node, [{
+	        key: "getAppendState",
+	        value: function getAppendState() {
+	            return this.appendState;
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            NodeUtils_1.NodeUtils.parentize(this.node);
+	            return this.node;
+	        }
+	    }, {
+	        key: "setNode",
+	        value: function setNode(node) {
+	            this.node = node;
+	        }
+	    }, {
+	        key: "updateNode",
+	        value: function updateNode() {
+	            this.node = this.getNodeStructure();
+	        }
+	    }]);
+
+	    return Node;
+	}();
+
+	exports.Node = Node;
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var DebugProtectionFunctionCallNode_1 = __webpack_require__(18);
+	var DebugProtectionFunctionIntervalNode_1 = __webpack_require__(19);
+	var DebugProtectionFunctionNode_1 = __webpack_require__(20);
+	var NodesGroup_1 = __webpack_require__(21);
+	var Utils_1 = __webpack_require__(10);
+
+	var DebugProtectionNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(DebugProtectionNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function DebugProtectionNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, DebugProtectionNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionNodesGroup).call(this, options));
+
+	        _this.debugProtectionFunctionIdentifier = Utils_1.Utils.getRandomVariableName();
+	        _this.nodes.set('debugProtectionFunctionNode', new DebugProtectionFunctionNode_1.DebugProtectionFunctionNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        _this.nodes.set('debugProtectionFunctionCallNode', new DebugProtectionFunctionCallNode_1.DebugProtectionFunctionCallNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        if (_this.options['debugProtectionInterval']) {
+	            _this.nodes.set('debugProtectionFunctionIntervalNode', new DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        }
+	        return _this;
+	    }
+
+	    return DebugProtectionNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.DebugProtectionNodesGroup = DebugProtectionNodesGroup;
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var DebugProtectionFunctionCallNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionCallNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionCallNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionCallNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionCallNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionCallNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.ExpressionStatement,
+	                'expression': {
+	                    'type': NodeType_1.NodeType.CallExpression,
+	                    'callee': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': this.debugProtectionFunctionName
+	                    },
+	                    'arguments': []
+	                }
+	            };
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionCallNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionCallNode = DebugProtectionFunctionCallNode;
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var DebugProtectionFunctionIntervalNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionIntervalNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionIntervalNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionIntervalNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionIntervalNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionIntervalNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.ExpressionStatement,
+	                'expression': {
+	                    'type': NodeType_1.NodeType.CallExpression,
+	                    'callee': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': 'setInterval'
+	                    },
+	                    'arguments': [{
+	                        'type': NodeType_1.NodeType.FunctionExpression,
+	                        'id': null,
+	                        'params': [],
+	                        'defaults': [],
+	                        'body': {
+	                            'type': NodeType_1.NodeType.BlockStatement,
+	                            'body': [{
+	                                'type': NodeType_1.NodeType.ExpressionStatement,
+	                                'expression': {
+	                                    'type': NodeType_1.NodeType.CallExpression,
+	                                    'callee': {
+	                                        'type': NodeType_1.NodeType.Identifier,
+	                                        'name': this.debugProtectionFunctionName
+	                                    },
+	                                    'arguments': []
+	                                }
+	                            }]
+	                        },
+	                        'generator': false,
+	                        'expression': false
+	                    }, {
+	                        'type': NodeType_1.NodeType.Literal,
+	                        'value': 4000,
+	                        'raw': '4000'
+	                    }]
+	                }
+	            };
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionIntervalNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionIntervalNode = DebugProtectionFunctionIntervalNode;
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var DebugProtectionFunctionNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            var programBodyLength = blockScopeNode.body.length,
+	                randomIndex = Utils_1.Utils.getRandomInteger(0, programBodyLength);
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
+	        }
+	    }, {
+	        key: 'getNodeIdentifier',
+	        value: function getNodeIdentifier() {
+	            return this.debugProtectionFunctionName;
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                var ' + this.debugProtectionFunctionName + ' = function () {\n                    function debuggerProtection (counter) {\n                        if ((\'\' + counter / counter)[\'length\'] !== 1 || counter % 20 === 0) {\n                            (function () {}.constructor(\'debugger\')());\n                        } else {\n                            [].filter.constructor(' + Utils_1.Utils.stringToJSFuck('debugger') + ')();\n                        }\n                        \n                        debuggerProtection(++counter);\n                    }\n                    \n                    try {\n                        debuggerProtection(0);\n                    } catch (y) {}\n                };\n            '));
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionNode = DebugProtectionFunctionNode;
+
+/***/ },
+/* 21 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var NodesGroup = function () {
+	    function NodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, NodesGroup);
+
+	        this.nodes = new Map();
+	        this.options = options;
+	    }
+
+	    _createClass(NodesGroup, [{
+	        key: "getNodes",
+	        value: function getNodes() {
+	            return this.nodes;
+	        }
+	    }]);
+
+	    return NodesGroup;
+	}();
+
+	exports.NodesGroup = NodesGroup;
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var FunctionDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(FunctionDeclarationObfuscator, _NodeObfuscator_1$Nod);
+
+	    function FunctionDeclarationObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, FunctionDeclarationObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.functionName = new Map();
+	        return _this;
+	    }
+
+	    _createClass(FunctionDeclarationObfuscator, [{
+	        key: "obfuscateNode",
+	        value: function obfuscateNode(functionDeclarationNode, parentNode) {
+	            if (parentNode.type === NodeType_1.NodeType.Program) {
+	                return;
+	            }
+	            this.replaceFunctionName(functionDeclarationNode);
+	            this.replaceFunctionCalls(functionDeclarationNode);
+	        }
+	    }, {
+	        key: "replaceFunctionName",
+	        value: function replaceFunctionName(functionDeclarationNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(functionDeclarationNode.id, {
+	                leave: function leave(node) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                        _this2.functionName.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                        node.name = _this2.functionName.get(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }, {
+	        key: "replaceFunctionCalls",
+	        value: function replaceFunctionCalls(functionDeclarationNode) {
+	            var _this3 = this;
+
+	            var scopeNode = NodeUtils_1.NodeUtils.getBlockScopeOfNode(functionDeclarationNode);
+	            estraverse.replace(scopeNode, {
+	                enter: function enter(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionName);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return FunctionDeclarationObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.FunctionDeclarationObfuscator = FunctionDeclarationObfuscator;
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var FunctionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(FunctionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function FunctionObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, FunctionObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.functionParams = new Map();
+	        return _this;
+	    }
+
+	    _createClass(FunctionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(functionNode) {
+	            this.replaceFunctionParams(functionNode);
+	            this.replaceFunctionParamsInBody(functionNode);
+	        }
+	    }, {
+	        key: 'replaceFunctionParams',
+	        value: function replaceFunctionParams(functionNode) {
+	            var _this2 = this;
+
+	            functionNode.params.forEach(function (paramsNode) {
+	                estraverse.replace(paramsNode, {
+	                    leave: function leave(node) {
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                            _this2.functionParams.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                            node.name = _this2.functionParams.get(node.name);
+	                            return;
+	                        }
+	                        return estraverse.VisitorOption.Skip;
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: 'replaceFunctionParamsInBody',
+	        value: function replaceFunctionParamsInBody(functionNode) {
+	            var _this3 = this;
+
+	            estraverse.replace(functionNode.body, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionParams);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return FunctionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.FunctionObfuscator = FunctionObfuscator;
+
+/***/ },
+/* 24 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var LiteralObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(LiteralObfuscator, _NodeObfuscator_1$Nod);
+
+	    function LiteralObfuscator() {
+	        _classCallCheck(this, LiteralObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(LiteralObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(LiteralObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(literalNode, parentNode) {
+	            if (NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+	                return;
+	            }
+	            if (literalNode['x-verbatim-property']) {
+	                return;
+	            }
+	            var content = void 0;
+	            switch (_typeof(literalNode.value)) {
+	                case 'boolean':
+	                    content = this.replaceLiteralBooleanByJSFuck(literalNode.value);
+	                    break;
+	                case 'number':
+	                    content = this.replaceLiteralNumberByHexadecimalValue(literalNode.value);
+	                    break;
+	                case 'string':
+	                    content = this.replaceLiteralValueByUnicodeValue(literalNode.value);
+	                    break;
+	                default:
+	                    return;
+	            }
+	            literalNode['x-verbatim-property'] = {
+	                content: content,
+	                precedence: escodegen.Precedence.Primary
+	            };
+	        }
+	    }]);
+
+	    return LiteralObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.LiteralObfuscator = LiteralObfuscator;
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var MemberExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(MemberExpressionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function MemberExpressionObfuscator() {
+	        _classCallCheck(this, MemberExpressionObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(MemberExpressionObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(MemberExpressionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(memberExpressionNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(memberExpressionNode.property, {
+	                leave: function leave(node, parentNode) {
+	                    if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
+	                        _this2.literalNodeController(node);
+	                        return;
+	                    }
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+	                        if (memberExpressionNode.computed) {
+	                            return;
+	                        }
+	                        memberExpressionNode.computed = true;
+	                        _this2.identifierNodeController(node);
+	                    }
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'identifierNodeController',
+	        value: function identifierNodeController(node) {
+	            var nodeValue = node.name,
+	                literalNode = {
+	                raw: '\'' + nodeValue + '\'',
+	                'x-verbatim-property': {
+	                    content: this.replaceLiteralValueByUnicodeValue(nodeValue),
+	                    precedence: escodegen.Precedence.Primary
+	                },
+	                type: NodeType_1.NodeType.Literal,
+	                value: nodeValue
+	            };
+	            delete node.name;
+	            Object.assign(node, literalNode);
+	        }
+	    }, {
+	        key: 'literalNodeController',
+	        value: function literalNodeController(node) {
+	            switch (_typeof(node.value)) {
+	                case 'string':
+	                    if (node['x-verbatim-property']) {
+	                        break;
+	                    }
+	                    node['x-verbatim-property'] = {
+	                        content: this.replaceLiteralValueByUnicodeValue(node.value),
+	                        precedence: escodegen.Precedence.Primary
+	                    };
+	                    break;
+	                default:
+	                    break;
+	            }
+	        }
+	    }]);
+
+	    return MemberExpressionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.MemberExpressionObfuscator = MemberExpressionObfuscator;
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var MethodDefinitionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(MethodDefinitionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function MethodDefinitionObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, MethodDefinitionObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(MethodDefinitionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.ignoredNames = ['constructor'];
+	        return _this;
+	    }
+
+	    _createClass(MethodDefinitionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(methodDefinitionNode, parentNode) {
+	            this.replaceMethodName(methodDefinitionNode);
+	        }
+	    }, {
+	        key: 'replaceMethodName',
+	        value: function replaceMethodName(methodDefinitionNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(methodDefinitionNode.key, {
+	                leave: function leave(node) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !Utils_1.Utils.arrayContains(_this2.ignoredNames, node.name) && methodDefinitionNode.computed === false) {
+	                        methodDefinitionNode.computed = true;
+	                        node.name = _this2.replaceLiteralValueByUnicodeValue(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }]);
+
+	    return MethodDefinitionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.MethodDefinitionObfuscator = MethodDefinitionObfuscator;
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var ObjectExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(ObjectExpressionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function ObjectExpressionObfuscator() {
+	        _classCallCheck(this, ObjectExpressionObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(ObjectExpressionObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(ObjectExpressionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(objectExpressionNode) {
+	            var _this2 = this;
+
+	            objectExpressionNode.properties.forEach(function (property) {
+	                estraverse.replace(property.key, {
+	                    leave: function leave(node, parentNode) {
+	                        if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
+	                            _this2.literalNodeController(node);
+	                            return;
+	                        }
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+	                            _this2.identifierNodeController(node);
+	                        }
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: 'literalNodeController',
+	        value: function literalNodeController(node) {
+	            switch (_typeof(node.value)) {
+	                case 'string':
+	                    if (node['x-verbatim-property']) {
+	                        break;
+	                    }
+	                    node['x-verbatim-property'] = {
+	                        content: Utils_1.Utils.stringToUnicode(node.value),
+	                        precedence: escodegen.Precedence.Primary
+	                    };
+	                    break;
+	                default:
+	                    break;
+	            }
+	        }
+	    }, {
+	        key: 'identifierNodeController',
+	        value: function identifierNodeController(node) {
+	            var nodeValue = node.name,
+	                literalNode = {
+	                raw: '\'' + nodeValue + '\'',
+	                'x-verbatim-property': {
+	                    content: Utils_1.Utils.stringToUnicode(nodeValue),
+	                    precedence: escodegen.Precedence.Primary
+	                },
+	                type: NodeType_1.NodeType.Literal,
+	                value: nodeValue
+	            };
+	            delete node.name;
+	            Object.assign(node, literalNode);
+	        }
+	    }]);
+
+	    return ObjectExpressionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.ObjectExpressionObfuscator = ObjectExpressionObfuscator;
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodesGroup_1 = __webpack_require__(21);
+	var SelfDefendingUnicodeNode_1 = __webpack_require__(29);
+
+	var SelfDefendingNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(SelfDefendingNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function SelfDefendingNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, SelfDefendingNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingNodesGroup).call(this, options));
+
+	        _this.nodes.set('selfDefendingUnicodeNode', new SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode(_this.options));
+	        return _this;
+	    }
+
+	    return SelfDefendingNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.SelfDefendingNodesGroup = SelfDefendingNodesGroup;
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var SelfDefendingUnicodeNode = function (_Node_1$Node) {
+	    _inherits(SelfDefendingUnicodeNode, _Node_1$Node);
+
+	    function SelfDefendingUnicodeNode() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, SelfDefendingUnicodeNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingUnicodeNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(SelfDefendingUnicodeNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            var programBodyLength = blockScopeNode.body.length,
+	                randomIndex = 0;
+	            if (programBodyLength > 2) {
+	                randomIndex = Utils_1.Utils.getRandomInteger(programBodyLength / 2, programBodyLength - 1);
+	            }
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var node = esprima.parse(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {                                \n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";},\n                        func2 = function () {\n                            return 'window';\n                        };\n                \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? Function(" + Utils_1.Utils.stringToUnicode("return/(\\\\[x|u](\\w){2,4})+/") + ")().test(func2.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET));
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return SelfDefendingUnicodeNode;
+	}(Node_1.Node);
+
+	exports.SelfDefendingUnicodeNode = SelfDefendingUnicodeNode;
+
+/***/ },
+/* 30 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.NO_CUSTOM_NODES_PRESET = Object.freeze({
+	    compact: true,
+	    debugProtection: false,
+	    debugProtectionInterval: false,
+	    disableConsoleOutput: false,
+	    encodeUnicodeLiterals: false,
+	    reservedNames: [],
+	    rotateUnicodeArray: false,
+	    selfDefending: false,
+	    unicodeArray: false,
+	    unicodeArrayThreshold: 0,
+	    wrapUnicodeArrayCalls: false
+	});
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodesGroup_1 = __webpack_require__(21);
+	var UnicodeArrayCallsWrapper_1 = __webpack_require__(32);
+	var UnicodeArrayDecodeNode_1 = __webpack_require__(33);
+	var UnicodeArrayNode_1 = __webpack_require__(34);
+	var UnicodeArrayRotateFunctionNode_1 = __webpack_require__(35);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(UnicodeArrayNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function UnicodeArrayNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, UnicodeArrayNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNodesGroup).call(this, options));
+
+	        _this.unicodeArrayName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
+	        _this.unicodeArrayTranslatorName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
+	        _this.unicodeArrayRotateValue = _this.options['rotateUnicodeArray'] ? Utils_1.Utils.getRandomInteger(100, 500) : 0;
+	        var unicodeArrayNode = new UnicodeArrayNode_1.UnicodeArrayNode(_this.unicodeArrayName, _this.unicodeArrayRotateValue, _this.options),
+	            unicodeArray = unicodeArrayNode.getNodeData();
+	        _this.nodes.set('unicodeArrayNode', unicodeArrayNode);
+	        if (_this.options['wrapUnicodeArrayCalls']) {
+	            _this.nodes.set('unicodeArrayCallsWrapper', new UnicodeArrayCallsWrapper_1.UnicodeArrayCallsWrapper(_this.unicodeArrayTranslatorName, _this.unicodeArrayName, unicodeArray, _this.options));
+	        }
+	        if (_this.options['encodeUnicodeLiterals']) {
+	            _this.nodes.set('unicodeArrayDecodeNode', new UnicodeArrayDecodeNode_1.UnicodeArrayDecodeNode(_this.unicodeArrayName, unicodeArray, _this.options));
+	        }
+	        if (_this.options['rotateUnicodeArray']) {
+	            _this.nodes.set('unicodeArrayRotateFunctionNode', new UnicodeArrayRotateFunctionNode_1.UnicodeArrayRotateFunctionNode(_this.unicodeArrayName, unicodeArray, _this.unicodeArrayRotateValue, _this.options));
+	        }
+	        return _this;
+	    }
+
+	    return UnicodeArrayNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.UnicodeArrayNodesGroup = UnicodeArrayNodesGroup;
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayCallsWrapper = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayCallsWrapper, _Node_1$Node);
+
+	    function UnicodeArrayCallsWrapper(unicodeArrayCallsWrapperName, unicodeArrayName, unicodeArray) {
+	        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
+
+	        _classCallCheck(this, UnicodeArrayCallsWrapper);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayCallsWrapper).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayCallsWrapperName = unicodeArrayCallsWrapperName;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayCallsWrapper, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: "getNodeIdentifier",
+	        value: function getNodeIdentifier() {
+	            return this.unicodeArrayCallsWrapperName;
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayCallsWrapper.prototype), "getNode", this).call(this);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var keyName = Utils_1.Utils.getRandomVariableName(),
+	                node = void 0;
+	            node = esprima.parse("\n            var " + this.unicodeArrayCallsWrapperName + " = function (" + keyName + ") {\n                return " + this.unicodeArrayName + "[parseInt(" + keyName + ", 0x010)];\n            };\n        ");
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayCallsWrapper;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayCallsWrapper = UnicodeArrayCallsWrapper;
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayDecodeNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayDecodeNode, _Node_1$Node);
+
+	    function UnicodeArrayDecodeNode(unicodeArrayName, unicodeArray) {
+	        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+	        _classCallCheck(this, UnicodeArrayDecodeNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayDecodeNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayDecodeNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: 'getNode',
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayDecodeNode.prototype), 'getNode', this).call(this);
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            var environmentName = Utils_1.Utils.getRandomVariableName(),
+	                forLoopFunctionName = Utils_1.Utils.getRandomVariableName(),
+	                indexVariableName = Utils_1.Utils.getRandomVariableName(),
+	                tempArrayName = Utils_1.Utils.getRandomVariableName();
+	            var code = '',
+	                node = void 0;
+	            if (this.options['selfDefending']) {
+	                code = '\n                var ' + environmentName + ' = function(){return ' + Utils_1.Utils.stringToUnicode('dev') + ';};\n                   \n                Function(' + Utils_1.Utils.stringToUnicode('return/\\w+ *\\(\\) *{\\w+ *[\'|"].+[\'|"];? *}/') + ')()[' + Utils_1.Utils.stringToUnicode('test') + '](' + environmentName + '[' + Utils_1.Utils.stringToUnicode('toString') + ']()) !== ' + JSFuck_1.JSFuck.True + ' && !' + this.unicodeArrayName + '++ ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.True + '){}\')() : Function(' + Utils_1.Utils.stringToUnicode('a') + ', atob(' + Utils_1.Utils.stringToUnicode(Utils_1.Utils.btoa('a.call()')) + '))(' + forLoopFunctionName + ') ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')() : [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')();\n            ';
+	            } else {
+	                code = forLoopFunctionName + '();';
+	            }
+	            node = esprima.parse('\n            (function () {\n                ' + JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate('\n                    (function () {\n                        var object = [][\'filter\'][\'constructor\'](\'return this\')();\n                        var chars = \'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\';\n            \n                        object.atob || (\n                            object.atob = function(input) {\n                                var str = String(input).replace(/=+$/, \'\');\n                                for (\n                                    var bc = 0, bs, buffer, idx = 0, output = \'\';\n                                    buffer = str.charAt(idx++);\n                                    ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n                                        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n                                ) {\n                                    buffer = chars.indexOf(buffer);\n                                }\n                            return output;\n                        });\n                    })();\n                ', NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET) + '\n              \n                var ' + forLoopFunctionName + ' = function () {\n                    var ' + tempArrayName + ' = [];\n                    \n                    for (var ' + indexVariableName + ' in ' + this.unicodeArrayName + ') {\n                        ' + tempArrayName + '[' + Utils_1.Utils.stringToUnicode('push') + '](decodeURI(atob(' + this.unicodeArrayName + '[' + indexVariableName + '])));\n                    }\n                    \n                    ' + this.unicodeArrayName + ' = ' + tempArrayName + ';\n                };\n                \n                ' + code + '\n            })();\n        ');
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayDecodeNode;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayDecodeNode = UnicodeArrayDecodeNode;
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var AppendState_1 = __webpack_require__(8);
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayNode, _Node_1$Node);
+
+	    function UnicodeArrayNode(unicodeArrayName) {
+	        var unicodeArrayRotateValue = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+	        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+	        _classCallCheck(this, UnicodeArrayNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArray = [];
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeIdentifier',
+	        value: function getNodeIdentifier() {
+	            return this.unicodeArrayName;
+	        }
+	    }, {
+	        key: 'getNodeData',
+	        value: function getNodeData() {
+	            return this.unicodeArray;
+	        }
+	    }, {
+	        key: 'getNode',
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            Utils_1.Utils.arrayRotate(this.unicodeArray, this.unicodeArrayRotateValue);
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayNode.prototype), 'getNode', this).call(this);
+	        }
+	    }, {
+	        key: 'updateNodeData',
+	        value: function updateNodeData(data) {
+	            this.unicodeArray.push(data);
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.VariableDeclaration,
+	                'declarations': [{
+	                    'type': NodeType_1.NodeType.VariableDeclarator,
+	                    'id': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': this.unicodeArrayName
+	                    },
+	                    'init': {
+	                        'type': NodeType_1.NodeType.ArrayExpression,
+	                        'elements': this.unicodeArray.map(function (value) {
+	                            return {
+	                                'type': NodeType_1.NodeType.Literal,
+	                                'value': value,
+	                                'raw': '\'' + value + '\'',
+	                                'x-verbatim-property': {
+	                                    'content': value,
+	                                    precedence: escodegen.Precedence.Primary
+	                                }
+	                            };
+	                        })
+	                    }
+	                }],
+	                'kind': 'var'
+	            };
+	        }
+	    }]);
+
+	    return UnicodeArrayNode;
+	}(Node_1.Node);
+
+	UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH = 4;
+	exports.UnicodeArrayNode = UnicodeArrayNode;
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayRotateFunctionNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayRotateFunctionNode, _Node_1$Node);
+
+	    function UnicodeArrayRotateFunctionNode(unicodeArrayName, unicodeArray, unicodeArrayRotateValue) {
+	        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
+
+	        _classCallCheck(this, UnicodeArrayRotateFunctionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayRotateFunctionNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayRotateFunctionNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            return _get(Object.getPrototypeOf(UnicodeArrayRotateFunctionNode.prototype), "getNode", this).call(this);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var arrayName = Utils_1.Utils.getRandomVariableName(),
+	                code = '',
+	                timesName = Utils_1.Utils.getRandomVariableName(),
+	                timesArgumentName = Utils_1.Utils.getRandomVariableName(),
+	                whileFunctionName = Utils_1.Utils.getRandomVariableName(),
+	                node = void 0;
+	            if (this.options['selfDefending']) {
+	                code = JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {\n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";};\n                                        \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : Function(" + Utils_1.Utils.stringToUnicode('a') + ", " + Utils_1.Utils.stringToUnicode('b') + ", " + Utils_1.Utils.stringToUnicode('a(++b)') + ")(" + whileFunctionName + ", " + timesName + ") ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET);
+	            } else {
+	                code = whileFunctionName + "(++" + timesName + ")";
+	            }
+	            node = esprima.parse("\n            (function (" + arrayName + ", " + timesName + ") {\n                var " + whileFunctionName + " = function (" + timesArgumentName + ") {\n                    while (--" + timesArgumentName + ") {\n                        " + arrayName + "[" + Utils_1.Utils.stringToUnicode('push') + "](" + arrayName + "[" + Utils_1.Utils.stringToUnicode('shift') + "]());\n                    }\n                };\n                \n                " + code + "\n            })(" + this.unicodeArrayName + ", 0x" + Utils_1.Utils.decToHex(this.unicodeArrayRotateValue) + ");\n        ");
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayRotateFunctionNode;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayRotateFunctionNode = UnicodeArrayRotateFunctionNode;
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var VariableDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(VariableDeclarationObfuscator, _NodeObfuscator_1$Nod);
+
+	    function VariableDeclarationObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, VariableDeclarationObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(VariableDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.variableNames = new Map();
+	        return _this;
+	    }
+
+	    _createClass(VariableDeclarationObfuscator, [{
+	        key: "obfuscateNode",
+	        value: function obfuscateNode(variableDeclarationNode, parentNode) {
+	            if (parentNode.type === NodeType_1.NodeType.Program) {
+	                return;
+	            }
+	            this.replaceVariableName(variableDeclarationNode);
+	            this.replaceVariableCalls(variableDeclarationNode, parentNode);
+	        }
+	    }, {
+	        key: "replaceVariableName",
+	        value: function replaceVariableName(variableDeclarationNode) {
+	            var _this2 = this;
+
+	            variableDeclarationNode.declarations.forEach(function (declarationNode) {
+	                estraverse.replace(declarationNode.id, {
+	                    enter: function enter(node) {
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                            _this2.variableNames.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                            node.name = _this2.variableNames.get(node.name);
+	                            return;
+	                        }
+	                        return estraverse.VisitorOption.Skip;
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: "replaceVariableCalls",
+	        value: function replaceVariableCalls(variableDeclarationNode, variableParentNode) {
+	            var _this3 = this;
+
+	            var scopeNode = void 0;
+	            scopeNode = variableDeclarationNode.kind === 'var' ? NodeUtils_1.NodeUtils.getBlockScopeOfNode(variableDeclarationNode) : variableParentNode;
+	            var isNodeAfterVariableDeclaratorFlag = false;
+	            estraverse.replace(scopeNode, {
+	                enter: function enter(node, parentNode) {
+	                    var functionNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression];
+	                    if (Utils_1.Utils.arrayContains(functionNodes, node.type)) {
+	                        estraverse.replace(node, {
+	                            enter: function enter(node, parentNode) {
+	                                _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
+	                            }
+	                        });
+	                    }
+	                    if (node === variableDeclarationNode) {
+	                        isNodeAfterVariableDeclaratorFlag = true;
+	                    }
+	                    if (isNodeAfterVariableDeclaratorFlag) {
+	                        _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
+	                    }
+	                }
+	            });
+	        }
+	    }]);
+
+	    return VariableDeclarationObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.VariableDeclarationObfuscator = VariableDeclarationObfuscator;
+
+/***/ },
+/* 37 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var OptionsNormalizer = function () {
+	    function OptionsNormalizer() {
+	        _classCallCheck(this, OptionsNormalizer);
+	    }
+
+	    _createClass(OptionsNormalizer, null, [{
+	        key: 'normalize',
+	        value: function normalize(options) {
+	            var normalizedOptions = Object.assign({}, options);
+	            normalizedOptions = OptionsNormalizer.unicodeArrayRule(normalizedOptions);
+	            normalizedOptions = OptionsNormalizer.unicodeArrayThresholdRule(normalizedOptions);
+	            normalizedOptions = OptionsNormalizer.selfDefendingRule(normalizedOptions);
+	            return normalizedOptions;
+	        }
+	    }, {
+	        key: 'selfDefendingRule',
+	        value: function selfDefendingRule(options) {
+	            if (options['selfDefending']) {
+	                Object.assign(options, OptionsNormalizer.SELF_DEFENDING_OPTIONS);
+	            }
+	            return options;
+	        }
+	    }, {
+	        key: 'unicodeArrayRule',
+	        value: function unicodeArrayRule(options) {
+	            if (!options['unicodeArray']) {
+	                Object.assign(options, OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS);
+	            }
+	            return options;
+	        }
+	    }, {
+	        key: 'unicodeArrayThresholdRule',
+	        value: function unicodeArrayThresholdRule(options) {
+	            var minValue = 0,
+	                maxValue = 1;
+	            options['unicodeArrayThreshold'] = Math.min(Math.max(options['unicodeArrayThreshold'], minValue), maxValue);
+	            return options;
+	        }
+	    }]);
+
+	    return OptionsNormalizer;
+	}();
+
+	OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS = {
+	    encodeUnicodeLiterals: false,
+	    rotateUnicodeArray: false,
+	    unicodeArray: false,
+	    unicodeArrayThreshold: 0,
+	    wrapUnicodeArrayCalls: false
+	};
+	OptionsNormalizer.SELF_DEFENDING_OPTIONS = {
+	    compact: true,
+	    selfDefending: true
+	};
+	exports.OptionsNormalizer = OptionsNormalizer;
+
+/***/ }
+/******/ ]);

dist/src/JavaScriptObfuscator.js

@@ -1,46 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var esprima = require('esprima');
-var escodegen = require('escodegen');
-var DefaultPreset_1 = require('./preset-options/DefaultPreset');
-var Obfuscator_1 = require('./Obfuscator');
-var OptionsNormalizer_1 = require("./OptionsNormalizer");
-
-var JavaScriptObfuscator = function () {
-    function JavaScriptObfuscator() {
-        _classCallCheck(this, JavaScriptObfuscator);
-    }
-
-    _createClass(JavaScriptObfuscator, null, [{
-        key: 'obfuscate',
-        value: function obfuscate(sourceCode, customOptions) {
-            var astTree = esprima.parse(sourceCode),
-                options = OptionsNormalizer_1.OptionsNormalizer.normalize(Object.assign({}, DefaultPreset_1.DEFAULT_PRESET, customOptions)),
-                obfuscator = new Obfuscator_1.Obfuscator(options);
-            astTree = obfuscator.obfuscateNode(astTree);
-            return JavaScriptObfuscator.generateCode(astTree, options);
-        }
-    }, {
-        key: 'generateCode',
-        value: function generateCode(astTree, options) {
-            var escodegenParams = Object.assign({}, JavaScriptObfuscator.escodegenParams);
-            if (options.hasOwnProperty('compact')) {
-                escodegenParams.format = {
-                    compact: options.compact
-                };
-            }
-            return escodegen.generate(astTree, escodegenParams);
-        }
-    }]);
-
-    return JavaScriptObfuscator;
-}();
-
-JavaScriptObfuscator.escodegenParams = {
-    verbatim: 'x-verbatim-property'
-};
-exports.JavaScriptObfuscator = JavaScriptObfuscator;

dist/src/NodeUtils.js

@@ -1,158 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var estraverse = require('estraverse');
-var NodeType_1 = require("./enums/NodeType");
-var Utils_1 = require("./Utils");
-
-var NodeUtils = function () {
-    function NodeUtils() {
-        _classCallCheck(this, NodeUtils);
-    }
-
-    _createClass(NodeUtils, null, [{
-        key: "addXVerbatimPropertyToLiterals",
-        value: function addXVerbatimPropertyToLiterals(node) {
-            estraverse.replace(node, {
-                enter: function enter(node, parentNode) {
-                    if (NodeUtils.isLiteralNode(node)) {
-                        node['x-verbatim-property'] = node.raw;
-                    }
-                }
-            });
-        }
-    }, {
-        key: "appendNode",
-        value: function appendNode(blockScopeBody, node) {
-            if (!NodeUtils.validateNode(node)) {
-                return;
-            }
-            blockScopeBody.push(node);
-        }
-    }, {
-        key: "getBlockScopeNodeByIndex",
-        value: function getBlockScopeNodeByIndex(node) {
-            var index = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
-
-            if (NodeUtils.isNodeHasBlockScope(node) && node.body[index]) {
-                return node.body[index];
-            }
-            return node;
-        }
-    }, {
-        key: "getBlockScopeOfNode",
-        value: function getBlockScopeOfNode(node) {
-            var depth = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
-
-            if (!node.parentNode) {
-                throw new ReferenceError('`parentNode` property of given node is `undefined`');
-            }
-            if (node.parentNode.type === NodeType_1.NodeType.Program) {
-                return node.parentNode;
-            }
-            if (!Utils_1.Utils.arrayContains(NodeUtils.scopeNodes, node.parentNode.type)) {
-                return NodeUtils.getBlockScopeOfNode(node.parentNode, depth);
-            }
-            if (depth > 0) {
-                return NodeUtils.getBlockScopeOfNode(node.parentNode, --depth);
-            }
-            if (node.type !== NodeType_1.NodeType.BlockStatement) {
-                return NodeUtils.getBlockScopeOfNode(node.parentNode);
-            }
-            return node;
-        }
-    }, {
-        key: "getProgramNode",
-        value: function getProgramNode(bodyNode) {
-            return {
-                'type': NodeType_1.NodeType.Program,
-                'body': bodyNode
-            };
-        }
-    }, {
-        key: "insertNodeAtIndex",
-        value: function insertNodeAtIndex(blockScopeBody, node, index) {
-            if (!NodeUtils.validateNode(node)) {
-                return;
-            }
-            blockScopeBody.splice(index, 0, node);
-        }
-    }, {
-        key: "isBlockStatementNode",
-        value: function isBlockStatementNode(node) {
-            return node.type === NodeType_1.NodeType.BlockStatement;
-        }
-    }, {
-        key: "isIdentifierNode",
-        value: function isIdentifierNode(node) {
-            return node.type === NodeType_1.NodeType.Identifier;
-        }
-    }, {
-        key: "isLiteralNode",
-        value: function isLiteralNode(node) {
-            return node.type === NodeType_1.NodeType.Literal;
-        }
-    }, {
-        key: "isMemberExpressionNode",
-        value: function isMemberExpressionNode(node) {
-            return node.type === NodeType_1.NodeType.MemberExpression;
-        }
-    }, {
-        key: "isNodeHasBlockScope",
-        value: function isNodeHasBlockScope(node) {
-            return node.hasOwnProperty('body');
-        }
-    }, {
-        key: "isProgramNode",
-        value: function isProgramNode(node) {
-            return node.type === NodeType_1.NodeType.Program;
-        }
-    }, {
-        key: "isPropertyNode",
-        value: function isPropertyNode(node) {
-            return node.type === NodeType_1.NodeType.Property;
-        }
-    }, {
-        key: "isVariableDeclaratorNode",
-        value: function isVariableDeclaratorNode(node) {
-            return node.type === NodeType_1.NodeType.VariableDeclarator;
-        }
-    }, {
-        key: "parentize",
-        value: function parentize(node) {
-            var isRootNode = true;
-            estraverse.replace(node, {
-                enter: function enter(node, parentNode) {
-                    Object.defineProperty(node, 'parentNode', {
-                        configurable: true,
-                        enumerable: true,
-                        value: isRootNode ? NodeUtils.getProgramNode([node]) : parentNode || node,
-                        writable: true
-                    });
-                    isRootNode = false;
-                }
-            });
-        }
-    }, {
-        key: "prependNode",
-        value: function prependNode(blockScopeBody, node) {
-            if (!NodeUtils.validateNode(node)) {
-                return;
-            }
-            blockScopeBody.unshift(node);
-        }
-    }, {
-        key: "validateNode",
-        value: function validateNode(node) {
-            return !!node;
-        }
-    }]);
-
-    return NodeUtils;
-}();
-
-NodeUtils.scopeNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression, NodeType_1.NodeType.MethodDefinition];
-exports.NodeUtils = NodeUtils;

dist/src/Obfuscator.js

@@ -1,122 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var estraverse = require('estraverse');
-var AppendState_1 = require('./enums/AppendState');
-var NodeType_1 = require('./enums/NodeType');
-var CatchClauseObfuscator_1 = require('./node-obfuscators/CatchClauseObfuscator');
-var ConsoleOutputDisableExpressionNode_1 = require('./custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode');
-var DebugProtectionNodesGroup_1 = require('./node-groups/DebugProtectionNodesGroup');
-var FunctionDeclarationObfuscator_1 = require('./node-obfuscators/FunctionDeclarationObfuscator');
-var FunctionObfuscator_1 = require('./node-obfuscators/FunctionObfuscator');
-var LiteralObfuscator_1 = require('./node-obfuscators/LiteralObfuscator');
-var MemberExpressionObfuscator_1 = require('./node-obfuscators/MemberExpressionObfuscator');
-var MethodDefinitionObfuscator_1 = require('./node-obfuscators/MethodDefinitionObfuscator');
-var NodeUtils_1 = require("./NodeUtils");
-var ObjectExpressionObfuscator_1 = require('./node-obfuscators/ObjectExpressionObfuscator');
-var SelfDefendingNodesGroup_1 = require("./node-groups/SelfDefendingNodesGroup");
-var UnicodeArrayNodesGroup_1 = require('./node-groups/UnicodeArrayNodesGroup');
-var VariableDeclarationObfuscator_1 = require('./node-obfuscators/VariableDeclarationObfuscator');
-
-var Obfuscator = function () {
-    function Obfuscator() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, Obfuscator);
-
-        this.nodes = new Map();
-        this.nodeObfuscators = new Map([[NodeType_1.NodeType.ArrowFunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.ClassDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator]], [NodeType_1.NodeType.CatchClause, [CatchClauseObfuscator_1.CatchClauseObfuscator]], [NodeType_1.NodeType.FunctionDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator, FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.FunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.MemberExpression, [MemberExpressionObfuscator_1.MemberExpressionObfuscator]], [NodeType_1.NodeType.MethodDefinition, [MethodDefinitionObfuscator_1.MethodDefinitionObfuscator]], [NodeType_1.NodeType.ObjectExpression, [ObjectExpressionObfuscator_1.ObjectExpressionObfuscator]], [NodeType_1.NodeType.VariableDeclaration, [VariableDeclarationObfuscator_1.VariableDeclarationObfuscator]], [NodeType_1.NodeType.Literal, [LiteralObfuscator_1.LiteralObfuscator]]]);
-        this.options = options;
-    }
-
-    _createClass(Obfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(node) {
-            this.setNewNodes();
-            NodeUtils_1.NodeUtils.parentize(node);
-            this.beforeObfuscation(node);
-            this.obfuscate(node);
-            this.afterObfuscation(node);
-            return node;
-        }
-    }, {
-        key: 'setNode',
-        value: function setNode(nodeName, node) {
-            this.nodes.set(nodeName, node);
-        }
-    }, {
-        key: 'setNodesGroup',
-        value: function setNodesGroup(nodesGroup) {
-            var _this = this;
-
-            var nodes = nodesGroup.getNodes();
-            nodes.forEach(function (node, key) {
-                _this.nodes.set(key, node);
-            });
-        }
-    }, {
-        key: 'afterObfuscation',
-        value: function afterObfuscation(astTree) {
-            this.nodes.forEach(function (node) {
-                if (node.getAppendState() === AppendState_1.AppendState.AfterObfuscation) {
-                    node.appendNode(astTree);
-                }
-            });
-        }
-    }, {
-        key: 'beforeObfuscation',
-        value: function beforeObfuscation(astTree) {
-            this.nodes.forEach(function (node) {
-                if (node.getAppendState() === AppendState_1.AppendState.BeforeObfuscation) {
-                    node.appendNode(astTree);
-                }
-            });
-        }
-    }, {
-        key: 'initializeNodeObfuscators',
-        value: function initializeNodeObfuscators(node, parentNode) {
-            var _this2 = this;
-
-            if (!this.nodeObfuscators.has(node.type)) {
-                return;
-            }
-            this.nodeObfuscators.get(node.type).forEach(function (obfuscator) {
-                new obfuscator(_this2.nodes, _this2.options).obfuscateNode(node, parentNode);
-            });
-        }
-    }, {
-        key: 'obfuscate',
-        value: function obfuscate(node) {
-            var _this3 = this;
-
-            estraverse.replace(node, {
-                leave: function leave(node, parentNode) {
-                    _this3.initializeNodeObfuscators(node, parentNode);
-                }
-            });
-        }
-    }, {
-        key: 'setNewNodes',
-        value: function setNewNodes() {
-            if (this.options['selfDefending']) {
-                this.setNodesGroup(new SelfDefendingNodesGroup_1.SelfDefendingNodesGroup(this.options));
-            }
-            if (this.options['disableConsoleOutput']) {
-                this.setNode('consoleOutputDisableExpressionNode', new ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode());
-            }
-            if (this.options['debugProtection']) {
-                this.setNodesGroup(new DebugProtectionNodesGroup_1.DebugProtectionNodesGroup(this.options));
-            }
-            if (this.options['unicodeArray']) {
-                this.setNodesGroup(new UnicodeArrayNodesGroup_1.UnicodeArrayNodesGroup(this.options));
-            }
-        }
-    }]);
-
-    return Obfuscator;
-}();
-
-exports.Obfuscator = Obfuscator;

dist/src/OptionsNormalizer.js

@@ -1,61 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var OptionsNormalizer = function () {
-    function OptionsNormalizer() {
-        _classCallCheck(this, OptionsNormalizer);
-    }
-
-    _createClass(OptionsNormalizer, null, [{
-        key: 'normalize',
-        value: function normalize(options) {
-            var normalizedOptions = Object.assign({}, options);
-            normalizedOptions = OptionsNormalizer.unicodeArrayRule(normalizedOptions);
-            normalizedOptions = OptionsNormalizer.unicodeArrayThresholdRule(normalizedOptions);
-            normalizedOptions = OptionsNormalizer.selfDefendingRule(normalizedOptions);
-            return normalizedOptions;
-        }
-    }, {
-        key: 'selfDefendingRule',
-        value: function selfDefendingRule(options) {
-            if (options['selfDefending']) {
-                Object.assign(options, OptionsNormalizer.SELF_DEFENDING_OPTIONS);
-            }
-            return options;
-        }
-    }, {
-        key: 'unicodeArrayRule',
-        value: function unicodeArrayRule(options) {
-            if (!options['unicodeArray']) {
-                Object.assign(options, OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS);
-            }
-            return options;
-        }
-    }, {
-        key: 'unicodeArrayThresholdRule',
-        value: function unicodeArrayThresholdRule(options) {
-            var minValue = 0,
-                maxValue = 1;
-            options['unicodeArrayThreshold'] = Math.min(Math.max(options['unicodeArrayThreshold'], minValue), maxValue);
-            return options;
-        }
-    }]);
-
-    return OptionsNormalizer;
-}();
-
-OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS = {
-    encodeUnicodeLiterals: false,
-    rotateUnicodeArray: false,
-    unicodeArray: false,
-    unicodeArrayThreshold: 0,
-    wrapUnicodeArrayCalls: false
-};
-OptionsNormalizer.SELF_DEFENDING_OPTIONS = {
-    compact: true,
-    selfDefending: true
-};
-exports.OptionsNormalizer = OptionsNormalizer;

dist/src/Utils.js

@@ -1,109 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var JSFuck_1 = require('./enums/JSFuck');
-
-var Utils = function () {
-    function Utils() {
-        _classCallCheck(this, Utils);
-    }
-
-    _createClass(Utils, null, [{
-        key: 'arrayContains',
-        value: function arrayContains(array, searchElement) {
-            return array.indexOf(searchElement) >= 0;
-        }
-    }, {
-        key: 'arrayRotate',
-        value: function arrayRotate(array, times) {
-            var reverse = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];
-
-            if (times < 0) {
-                return;
-            }
-            var newArray = array,
-                temp = void 0;
-            while (times--) {
-                if (!reverse) {
-                    temp = newArray.pop();
-                    newArray.unshift(temp);
-                } else {
-                    temp = newArray.shift();
-                    newArray.push(temp);
-                }
-            }
-            return newArray;
-        }
-    }, {
-        key: 'btoa',
-        value: function btoa(string) {
-            return new Buffer(encodeURI(string)).toString('base64');
-        }
-    }, {
-        key: 'decToHex',
-        value: function decToHex(dec) {
-            var decToHexSliceValue = -6,
-                exponent = 6,
-                radix = 16;
-            return (dec + Math.pow(radix, exponent)).toString(radix).substr(decToHexSliceValue).replace(Utils.hexRepetitiveZerosRegExp, '');
-        }
-    }, {
-        key: 'getRandomInteger',
-        value: function getRandomInteger(min, max) {
-            return Math.round(Math.floor(Math.random() * (max - min + 1)) + min);
-        }
-    }, {
-        key: 'getRandomVariableName',
-        value: function getRandomVariableName() {
-            var length = arguments.length <= 0 || arguments[0] === undefined ? 6 : arguments[0];
-
-            var rangeMinInteger = 10000,
-                rangeMaxInteger = 99999999,
-                prefix = '_0x';
-            return '' + prefix + Utils.decToHex(Utils.getRandomInteger(rangeMinInteger, rangeMaxInteger)).substr(0, length);
-        }
-    }, {
-        key: 'isInteger',
-        value: function isInteger(number) {
-            return number % 1 === 0;
-        }
-    }, {
-        key: 'strEnumify',
-        value: function strEnumify(obj) {
-            return obj;
-        }
-    }, {
-        key: 'stringToJSFuck',
-        value: function stringToJSFuck(string) {
-            return Array.from(string).map(function (character) {
-                return JSFuck_1.JSFuck[character] || character;
-            }).join(' + ');
-        }
-    }, {
-        key: 'stringToUnicode',
-        value: function stringToUnicode(string) {
-            var radix = 16;
-            var prefix = void 0,
-                regexp = new RegExp('[\x00-\x7F]'),
-                template = void 0;
-            return '\'' + string.replace(/[\s\S]/g, function (escape) {
-                if (regexp.test(escape)) {
-                    prefix = '\\x';
-                    template = '0'.repeat(2);
-                } else {
-                    prefix = '\\u';
-                    template = '0'.repeat(4);
-                }
-                return '' + prefix + (template + escape.charCodeAt(0).toString(radix)).slice(-template.length);
-            }) + '\'';
-        }
-    }]);
-
-    return Utils;
-}();
-
-Utils.hexRepetitiveZerosRegExp = new RegExp('^(0{2,})+(?!$)', '');
-exports.Utils = Utils;

dist/src/custom-nodes/Node.js

@@ -1,46 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var AppendState_1 = require('../enums/AppendState');
-var NodeUtils_1 = require("../NodeUtils");
-
-var Node = function () {
-    function Node() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, Node);
-
-        this.appendState = AppendState_1.AppendState.BeforeObfuscation;
-        this.options = options;
-    }
-
-    _createClass(Node, [{
-        key: "getAppendState",
-        value: function getAppendState() {
-            return this.appendState;
-        }
-    }, {
-        key: "getNode",
-        value: function getNode() {
-            NodeUtils_1.NodeUtils.parentize(this.node);
-            return this.node;
-        }
-    }, {
-        key: "setNode",
-        value: function setNode(node) {
-            this.node = node;
-        }
-    }, {
-        key: "updateNode",
-        value: function updateNode() {
-            this.node = this.getNodeStructure();
-        }
-    }]);
-
-    return Node;
-}();
-
-exports.Node = Node;

dist/src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.js

@@ -1,44 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-
-var ConsoleOutputDisableExpressionNode = function (_Node_1$Node) {
-    _inherits(ConsoleOutputDisableExpressionNode, _Node_1$Node);
-
-    function ConsoleOutputDisableExpressionNode() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, ConsoleOutputDisableExpressionNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ConsoleOutputDisableExpressionNode).call(this, options));
-
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(ConsoleOutputDisableExpressionNode, [{
-        key: 'appendNode',
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
-        }
-    }, {
-        key: 'getNodeStructure',
-        value: function getNodeStructure() {
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                (function () {\n                    var _ = \'(\u0004\u0006\u0003\u0005[]\' + \'["filter"]["\u0007tructor"]\' + \'("return this")()\' + \'.\' + \'\u0003;\u0006\u0002\u0005\u0004};\' + \'_\u0003.log\u0001.in\' + \'fo\u0001.\' + \'war\' + \'n\u0001.er\' + \'r\' + \'or\u0001})();\' + \'\u0001\u0005_\u0002;\' + \'_\u0003\u0002function\' + \'\u0003\u0007ole\u0004\u0002 ()\' + \'{\u0005 = \u0006var \' + \'_\u0007cons\', \n                        Y, \n                        $;\n                    \n                    for (Y in $ = "\u0007\u0006\u0005\u0004\u0003\u0002\u0001") {\n                      var arr = _.split($[Y]);\n                      _ = arr.join(arr.pop());\n                    }\n                    \n                    []["filter"]["constructor"](_)();\n                })()\n            '));
-        }
-    }]);
-
-    return ConsoleOutputDisableExpressionNode;
-}(Node_1.Node);
-
-exports.ConsoleOutputDisableExpressionNode = ConsoleOutputDisableExpressionNode;

dist/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.js

@@ -1,55 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var NodeType_1 = require("../../enums/NodeType");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-
-var DebugProtectionFunctionCallNode = function (_Node_1$Node) {
-    _inherits(DebugProtectionFunctionCallNode, _Node_1$Node);
-
-    function DebugProtectionFunctionCallNode(debugProtectionFunctionName) {
-        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-        _classCallCheck(this, DebugProtectionFunctionCallNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionCallNode).call(this, options));
-
-        _this.debugProtectionFunctionName = debugProtectionFunctionName;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(DebugProtectionFunctionCallNode, [{
-        key: "appendNode",
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
-        }
-    }, {
-        key: "getNodeStructure",
-        value: function getNodeStructure() {
-            return {
-                'type': NodeType_1.NodeType.ExpressionStatement,
-                'expression': {
-                    'type': NodeType_1.NodeType.CallExpression,
-                    'callee': {
-                        'type': NodeType_1.NodeType.Identifier,
-                        'name': this.debugProtectionFunctionName
-                    },
-                    'arguments': []
-                }
-            };
-        }
-    }]);
-
-    return DebugProtectionFunctionCallNode;
-}(Node_1.Node);
-
-exports.DebugProtectionFunctionCallNode = DebugProtectionFunctionCallNode;

dist/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.js

@@ -1,80 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var NodeType_1 = require('../../enums/NodeType');
-var Node_1 = require('../Node');
-var NodeUtils_1 = require('../../NodeUtils');
-
-var DebugProtectionFunctionIntervalNode = function (_Node_1$Node) {
-    _inherits(DebugProtectionFunctionIntervalNode, _Node_1$Node);
-
-    function DebugProtectionFunctionIntervalNode(debugProtectionFunctionName) {
-        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-        _classCallCheck(this, DebugProtectionFunctionIntervalNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionIntervalNode).call(this, options));
-
-        _this.debugProtectionFunctionName = debugProtectionFunctionName;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(DebugProtectionFunctionIntervalNode, [{
-        key: 'appendNode',
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
-        }
-    }, {
-        key: 'getNodeStructure',
-        value: function getNodeStructure() {
-            return {
-                'type': NodeType_1.NodeType.ExpressionStatement,
-                'expression': {
-                    'type': NodeType_1.NodeType.CallExpression,
-                    'callee': {
-                        'type': NodeType_1.NodeType.Identifier,
-                        'name': 'setInterval'
-                    },
-                    'arguments': [{
-                        'type': NodeType_1.NodeType.FunctionExpression,
-                        'id': null,
-                        'params': [],
-                        'defaults': [],
-                        'body': {
-                            'type': NodeType_1.NodeType.BlockStatement,
-                            'body': [{
-                                'type': NodeType_1.NodeType.ExpressionStatement,
-                                'expression': {
-                                    'type': NodeType_1.NodeType.CallExpression,
-                                    'callee': {
-                                        'type': NodeType_1.NodeType.Identifier,
-                                        'name': this.debugProtectionFunctionName
-                                    },
-                                    'arguments': []
-                                }
-                            }]
-                        },
-                        'generator': false,
-                        'expression': false
-                    }, {
-                        'type': NodeType_1.NodeType.Literal,
-                        'value': 4000,
-                        'raw': '4000'
-                    }]
-                }
-            };
-        }
-    }]);
-
-    return DebugProtectionFunctionIntervalNode;
-}(Node_1.Node);
-
-exports.DebugProtectionFunctionIntervalNode = DebugProtectionFunctionIntervalNode;

dist/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.js

@@ -1,53 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var Node_1 = require('../Node');
-var NodeUtils_1 = require('../../NodeUtils');
-var Utils_1 = require("../../Utils");
-
-var DebugProtectionFunctionNode = function (_Node_1$Node) {
-    _inherits(DebugProtectionFunctionNode, _Node_1$Node);
-
-    function DebugProtectionFunctionNode(debugProtectionFunctionName) {
-        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-        _classCallCheck(this, DebugProtectionFunctionNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionNode).call(this, options));
-
-        _this.debugProtectionFunctionName = debugProtectionFunctionName;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(DebugProtectionFunctionNode, [{
-        key: 'appendNode',
-        value: function appendNode(blockScopeNode) {
-            var programBodyLength = blockScopeNode.body.length,
-                randomIndex = Utils_1.Utils.getRandomInteger(0, programBodyLength);
-            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
-        }
-    }, {
-        key: 'getNodeIdentifier',
-        value: function getNodeIdentifier() {
-            return this.debugProtectionFunctionName;
-        }
-    }, {
-        key: 'getNodeStructure',
-        value: function getNodeStructure() {
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                var ' + this.debugProtectionFunctionName + ' = function () {\n                    function debuggerProtection (counter) {\n                        if ((\'\' + counter / counter)[\'length\'] !== 1 || counter % 20 === 0) {\n                            (function () {}.constructor(\'debugger\')());\n                        } else {\n                            [].filter.constructor(' + Utils_1.Utils.stringToJSFuck('debugger') + ')();\n                        }\n                        \n                        debuggerProtection(++counter);\n                    }\n                    \n                    try {\n                        debuggerProtection(0);\n                    } catch (y) {}\n                };\n            '));
-        }
-    }]);
-
-    return DebugProtectionFunctionNode;
-}(Node_1.Node);
-
-exports.DebugProtectionFunctionNode = DebugProtectionFunctionNode;

dist/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.js

@@ -1,57 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var AppendState_1 = require("../../enums/AppendState");
-var JSFuck_1 = require("../../enums/JSFuck");
-var NoCustomNodesPreset_1 = require("../../preset-options/NoCustomNodesPreset");
-var JavaScriptObfuscator_1 = require("../../JavaScriptObfuscator");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-var Utils_1 = require("../../Utils");
-
-var SelfDefendingUnicodeNode = function (_Node_1$Node) {
-    _inherits(SelfDefendingUnicodeNode, _Node_1$Node);
-
-    function SelfDefendingUnicodeNode() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, SelfDefendingUnicodeNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingUnicodeNode).call(this, options));
-
-        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(SelfDefendingUnicodeNode, [{
-        key: "appendNode",
-        value: function appendNode(blockScopeNode) {
-            var programBodyLength = blockScopeNode.body.length,
-                randomIndex = 0;
-            if (programBodyLength > 2) {
-                randomIndex = Utils_1.Utils.getRandomInteger(programBodyLength / 2, programBodyLength - 1);
-            }
-            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
-        }
-    }, {
-        key: "getNodeStructure",
-        value: function getNodeStructure() {
-            var node = esprima.parse(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {                                \n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";},\n                        func2 = function () {\n                            return 'window';\n                        };\n                \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? Function(" + Utils_1.Utils.stringToUnicode("return/(\\\\[x|u](\\w){2,4})+/") + ")().test(func2.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET));
-            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
-        }
-    }]);
-
-    return SelfDefendingUnicodeNode;
-}(Node_1.Node);
-
-exports.SelfDefendingUnicodeNode = SelfDefendingUnicodeNode;

dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.js

@@ -1,70 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var AppendState_1 = require("../../enums/AppendState");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-var Utils_1 = require("../../Utils");
-
-var UnicodeArrayCallsWrapper = function (_Node_1$Node) {
-    _inherits(UnicodeArrayCallsWrapper, _Node_1$Node);
-
-    function UnicodeArrayCallsWrapper(unicodeArrayCallsWrapperName, unicodeArrayName, unicodeArray) {
-        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
-
-        _classCallCheck(this, UnicodeArrayCallsWrapper);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayCallsWrapper).call(this, options));
-
-        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
-        _this.unicodeArrayCallsWrapperName = unicodeArrayCallsWrapperName;
-        _this.unicodeArrayName = unicodeArrayName;
-        _this.unicodeArray = unicodeArray;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(UnicodeArrayCallsWrapper, [{
-        key: "appendNode",
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
-        }
-    }, {
-        key: "getNodeIdentifier",
-        value: function getNodeIdentifier() {
-            return this.unicodeArrayCallsWrapperName;
-        }
-    }, {
-        key: "getNode",
-        value: function getNode() {
-            if (!this.unicodeArray.length) {
-                return;
-            }
-            this.updateNode();
-            return _get(Object.getPrototypeOf(UnicodeArrayCallsWrapper.prototype), "getNode", this).call(this);
-        }
-    }, {
-        key: "getNodeStructure",
-        value: function getNodeStructure() {
-            var keyName = Utils_1.Utils.getRandomVariableName(),
-                node = void 0;
-            node = esprima.parse("\n            var " + this.unicodeArrayCallsWrapperName + " = function (" + keyName + ") {\n                return " + this.unicodeArrayName + "[parseInt(" + keyName + ", 0x010)];\n            };\n        ");
-            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
-        }
-    }]);
-
-    return UnicodeArrayCallsWrapper;
-}(Node_1.Node);
-
-exports.UnicodeArrayCallsWrapper = UnicodeArrayCallsWrapper;

dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayDecodeNode.js

@@ -1,76 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var JavaScriptObfuscator_1 = require('../../JavaScriptObfuscator');
-var AppendState_1 = require("../../enums/AppendState");
-var JSFuck_1 = require("../../enums/JSFuck");
-var NoCustomNodesPreset_1 = require("../../preset-options/NoCustomNodesPreset");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-var Utils_1 = require("../../Utils");
-
-var UnicodeArrayDecodeNode = function (_Node_1$Node) {
-    _inherits(UnicodeArrayDecodeNode, _Node_1$Node);
-
-    function UnicodeArrayDecodeNode(unicodeArrayName, unicodeArray) {
-        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
-
-        _classCallCheck(this, UnicodeArrayDecodeNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayDecodeNode).call(this, options));
-
-        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
-        _this.unicodeArrayName = unicodeArrayName;
-        _this.unicodeArray = unicodeArray;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(UnicodeArrayDecodeNode, [{
-        key: 'appendNode',
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
-        }
-    }, {
-        key: 'getNode',
-        value: function getNode() {
-            if (!this.unicodeArray.length) {
-                return;
-            }
-            this.updateNode();
-            return _get(Object.getPrototypeOf(UnicodeArrayDecodeNode.prototype), 'getNode', this).call(this);
-        }
-    }, {
-        key: 'getNodeStructure',
-        value: function getNodeStructure() {
-            var environmentName = Utils_1.Utils.getRandomVariableName(),
-                forLoopFunctionName = Utils_1.Utils.getRandomVariableName(),
-                indexVariableName = Utils_1.Utils.getRandomVariableName(),
-                tempArrayName = Utils_1.Utils.getRandomVariableName();
-            var code = '',
-                node = void 0;
-            if (this.options['selfDefending']) {
-                code = '\n                var ' + environmentName + ' = function(){return ' + Utils_1.Utils.stringToUnicode('dev') + ';};\n                   \n                Function(' + Utils_1.Utils.stringToUnicode('return/\\w+ *\\(\\) *{\\w+ *[\'|"].+[\'|"];? *}/') + ')()[' + Utils_1.Utils.stringToUnicode('test') + '](' + environmentName + '[' + Utils_1.Utils.stringToUnicode('toString') + ']()) !== ' + JSFuck_1.JSFuck.True + ' && !' + this.unicodeArrayName + '++ ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.True + '){}\')() : Function(' + Utils_1.Utils.stringToUnicode('a') + ', atob(' + Utils_1.Utils.stringToUnicode(Utils_1.Utils.btoa('a.call()')) + '))(' + forLoopFunctionName + ') ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')() : [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')();\n            ';
-            } else {
-                code = forLoopFunctionName + '();';
-            }
-            node = esprima.parse('\n            (function () {\n                ' + JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate('\n                    (function () {\n                        var object = [][\'filter\'][\'constructor\'](\'return this\')();\n                        var chars = \'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\';\n            \n                        object.atob || (\n                            object.atob = function(input) {\n                                var str = String(input).replace(/=+$/, \'\');\n                                for (\n                                    var bc = 0, bs, buffer, idx = 0, output = \'\';\n                                    buffer = str.charAt(idx++);\n                                    ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n                                        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n                                ) {\n                                    buffer = chars.indexOf(buffer);\n                                }\n                            return output;\n                        });\n                    })();\n                ', NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET) + '\n              \n                var ' + forLoopFunctionName + ' = function () {\n                    var ' + tempArrayName + ' = [];\n                    \n                    for (var ' + indexVariableName + ' in ' + this.unicodeArrayName + ') {\n                        ' + tempArrayName + '[' + Utils_1.Utils.stringToUnicode('push') + '](decodeURI(atob(' + this.unicodeArrayName + '[' + indexVariableName + '])));\n                    }\n                    \n                    ' + this.unicodeArrayName + ' = ' + tempArrayName + ';\n                };\n                \n                ' + code + '\n            })();\n        ');
-            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
-        }
-    }]);
-
-    return UnicodeArrayDecodeNode;
-}(Node_1.Node);
-
-exports.UnicodeArrayDecodeNode = UnicodeArrayDecodeNode;

dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayNode.js

@@ -1,104 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var escodegen = require('escodegen');
-var AppendState_1 = require('../../enums/AppendState');
-var NodeType_1 = require("../../enums/NodeType");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-var Utils_1 = require('../../Utils');
-
-var UnicodeArrayNode = function (_Node_1$Node) {
-    _inherits(UnicodeArrayNode, _Node_1$Node);
-
-    function UnicodeArrayNode(unicodeArrayName) {
-        var unicodeArrayRotateValue = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
-        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
-
-        _classCallCheck(this, UnicodeArrayNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNode).call(this, options));
-
-        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
-        _this.unicodeArray = [];
-        _this.unicodeArrayName = unicodeArrayName;
-        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(UnicodeArrayNode, [{
-        key: 'appendNode',
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
-        }
-    }, {
-        key: 'getNodeIdentifier',
-        value: function getNodeIdentifier() {
-            return this.unicodeArrayName;
-        }
-    }, {
-        key: 'getNodeData',
-        value: function getNodeData() {
-            return this.unicodeArray;
-        }
-    }, {
-        key: 'getNode',
-        value: function getNode() {
-            if (!this.unicodeArray.length) {
-                return;
-            }
-            Utils_1.Utils.arrayRotate(this.unicodeArray, this.unicodeArrayRotateValue);
-            this.updateNode();
-            return _get(Object.getPrototypeOf(UnicodeArrayNode.prototype), 'getNode', this).call(this);
-        }
-    }, {
-        key: 'updateNodeData',
-        value: function updateNodeData(data) {
-            this.unicodeArray.push(data);
-        }
-    }, {
-        key: 'getNodeStructure',
-        value: function getNodeStructure() {
-            return {
-                'type': NodeType_1.NodeType.VariableDeclaration,
-                'declarations': [{
-                    'type': NodeType_1.NodeType.VariableDeclarator,
-                    'id': {
-                        'type': NodeType_1.NodeType.Identifier,
-                        'name': this.unicodeArrayName
-                    },
-                    'init': {
-                        'type': NodeType_1.NodeType.ArrayExpression,
-                        'elements': this.unicodeArray.map(function (value) {
-                            return {
-                                'type': NodeType_1.NodeType.Literal,
-                                'value': value,
-                                'raw': '\'' + value + '\'',
-                                'x-verbatim-property': {
-                                    'content': value,
-                                    precedence: escodegen.Precedence.Primary
-                                }
-                            };
-                        })
-                    }
-                }],
-                'kind': 'var'
-            };
-        }
-    }]);
-
-    return UnicodeArrayNode;
-}(Node_1.Node);
-
-UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH = 4;
-exports.UnicodeArrayNode = UnicodeArrayNode;

dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode.js

@@ -1,76 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var esprima = require('esprima');
-var AppendState_1 = require("../../enums/AppendState");
-var JSFuck_1 = require("../../enums/JSFuck");
-var NoCustomNodesPreset_1 = require("../../preset-options/NoCustomNodesPreset");
-var JavaScriptObfuscator_1 = require("../../JavaScriptObfuscator");
-var Node_1 = require('../Node');
-var NodeUtils_1 = require("../../NodeUtils");
-var Utils_1 = require("../../Utils");
-
-var UnicodeArrayRotateFunctionNode = function (_Node_1$Node) {
-    _inherits(UnicodeArrayRotateFunctionNode, _Node_1$Node);
-
-    function UnicodeArrayRotateFunctionNode(unicodeArrayName, unicodeArray, unicodeArrayRotateValue) {
-        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
-
-        _classCallCheck(this, UnicodeArrayRotateFunctionNode);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayRotateFunctionNode).call(this, options));
-
-        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
-        _this.unicodeArrayName = unicodeArrayName;
-        _this.unicodeArray = unicodeArray;
-        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
-        _this.node = _this.getNodeStructure();
-        return _this;
-    }
-
-    _createClass(UnicodeArrayRotateFunctionNode, [{
-        key: "appendNode",
-        value: function appendNode(blockScopeNode) {
-            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
-        }
-    }, {
-        key: "getNode",
-        value: function getNode() {
-            if (!this.unicodeArray.length) {
-                return;
-            }
-            return _get(Object.getPrototypeOf(UnicodeArrayRotateFunctionNode.prototype), "getNode", this).call(this);
-        }
-    }, {
-        key: "getNodeStructure",
-        value: function getNodeStructure() {
-            var arrayName = Utils_1.Utils.getRandomVariableName(),
-                code = '',
-                timesName = Utils_1.Utils.getRandomVariableName(),
-                timesArgumentName = Utils_1.Utils.getRandomVariableName(),
-                whileFunctionName = Utils_1.Utils.getRandomVariableName(),
-                node = void 0;
-            if (this.options['selfDefending']) {
-                code = JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {\n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";};\n                                        \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : Function(" + Utils_1.Utils.stringToUnicode('a') + ", " + Utils_1.Utils.stringToUnicode('b') + ", " + Utils_1.Utils.stringToUnicode('a(++b)') + ")(" + whileFunctionName + ", " + timesName + ") ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET);
-            } else {
-                code = whileFunctionName + "(++" + timesName + ")";
-            }
-            node = esprima.parse("\n            (function (" + arrayName + ", " + timesName + ") {\n                var " + whileFunctionName + " = function (" + timesArgumentName + ") {\n                    while (--" + timesArgumentName + ") {\n                        " + arrayName + "[" + Utils_1.Utils.stringToUnicode('push') + "](" + arrayName + "[" + Utils_1.Utils.stringToUnicode('shift') + "]());\n                    }\n                };\n                \n                " + code + "\n            })(" + this.unicodeArrayName + ", 0x" + Utils_1.Utils.decToHex(this.unicodeArrayRotateValue) + ");\n        ");
-            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
-            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
-        }
-    }]);
-
-    return UnicodeArrayRotateFunctionNode;
-}(Node_1.Node);
-
-exports.UnicodeArrayRotateFunctionNode = UnicodeArrayRotateFunctionNode;

dist/src/enums/AppendState.js

@@ -1,7 +0,0 @@
-"use strict";
-
-(function (AppendState) {
-    AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation";
-    AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation";
-})(exports.AppendState || (exports.AppendState = {}));
-var AppendState = exports.AppendState;

dist/src/enums/JSFuck.js

@@ -1,59 +0,0 @@
-"use strict";
-
-exports.JSFuck = {
-    Window: '[]["filter"]["constructor"]("return this")()',
-    False: '![]',
-    True: '!![]',
-    a: '(false+"")[1]',
-    b: '([]["entries"]()+"")[2]',
-    c: '([]["fill"]+"")[3]',
-    d: '(undefined+"")[2]',
-    e: '(true+"")[3]',
-    f: '(false+"")[0]',
-    g: '(false+[0]+String)[20]',
-    h: '(+(101))["to"+String["name"]](21)[1]',
-    i: '([false]+undefined)[10]',
-    j: '([]["entries"]()+"")[3]',
-    k: '(+(20))["to"+String["name"]](21)',
-    l: '(false+"")[2]',
-    m: '(Number+"")[11]',
-    n: '(undefined+"")[1]',
-    o: '(true+[]["fill"])[10]',
-    p: '(+(211))["to"+String["name"]](31)[1]',
-    q: '(+(212))["to"+String["name"]](31)[1]',
-    r: '(true+"")[1]',
-    s: '(false+"")[3]',
-    t: '(true+"")[0]',
-    u: '(undefined+"")[0]',
-    v: '(+(31))["to"+String["name"]](32)',
-    w: '(+(32))["to"+String["name"]](33)',
-    x: '(+(101))["to"+String["name"]](34)[1]',
-    y: '(NaN+[Infinity])[10]',
-    z: '(+(35))["to"+String["name"]](36)',
-    A: '(+[]+Array)[10]',
-    B: '(+[]+Boolean)[10]',
-    C: 'Function("return escape")()(("")["italics"]())[2]',
-    D: 'Function("return escape")()([]["fill"])["slice"]("-1")',
-    E: '(RegExp+"")[12]',
-    F: '(+[]+Function)[10]',
-    G: '(false+Function("return Date")()())[30]',
-    H: '\'H\'',
-    I: '(Infinity+"")[0]',
-    J: '\'J\'',
-    K: '\'K\'',
-    L: '\'L\'',
-    M: '(true+Function("return Date")()())[30]',
-    N: '(NaN+"")[0]',
-    O: '(NaN+Function("return{}")())[11]',
-    P: '\'P\'',
-    Q: '\'Q\'',
-    R: '(+[]+RegExp)[10]',
-    S: '(+[]+String)[10]',
-    T: '(NaN+Function("return Date")()())[30]',
-    U: '(NaN+Function("return{}")()["to"+String["name"]]["call"]())[11]',
-    V: '\'V\'',
-    W: '\'W\'',
-    X: '\'X\'',
-    Y: '\'Y\'',
-    Z: '\'Z\''
-};

dist/src/enums/NodeType.js

@@ -1,32 +0,0 @@
-"use strict";
-
-var Utils_1 = require("../Utils");
-exports.NodeType = Utils_1.Utils.strEnumify({
-    ArrayExpression: 'ArrayExpression',
-    ArrowFunctionExpression: 'ArrowFunctionExpression',
-    AssignmentExpression: 'AssignmentExpression',
-    BinaryExpression: 'BinaryExpression',
-    BlockStatement: 'BlockStatement',
-    CallExpression: 'CallExpression',
-    CatchClause: 'CatchClause',
-    ClassDeclaration: 'ClassDeclaration',
-    ExpressionStatement: 'ExpressionStatement',
-    FunctionDeclaration: 'FunctionDeclaration',
-    FunctionExpression: 'FunctionExpression',
-    Identifier: 'Identifier',
-    IfStatement: 'IfStatement',
-    Literal: 'Literal',
-    LogicalExpression: 'LogicalExpression',
-    MemberExpression: 'MemberExpression',
-    MethodDefinition: 'MethodDefinition',
-    ObjectExpression: 'ObjectExpression',
-    Program: 'Program',
-    Property: 'Property',
-    ReturnStatement: 'ReturnStatement',
-    TryStatement: 'TryStatement',
-    UnaryExpression: 'UnaryExpression',
-    UpdateExpression: 'UpdateExpression',
-    VariableDeclaration: 'VariableDeclaration',
-    VariableDeclarator: 'VariableDeclarator',
-    WhileStatement: 'WhileStatement'
-});

dist/src/node-groups/DebugProtectionNodesGroup.js

@@ -1,51 +0,0 @@
-"use strict";
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-
-function _possibleConstructorReturn(self, call) {
-    if (!self) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
-}
-
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
-    }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-}
-
-var DebugProtectionFunctionCallNode_1 = require("../custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode");
-var DebugProtectionFunctionIntervalNode_1 = require("../custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode");
-var DebugProtectionFunctionNode_1 = require("../custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode");
-var NodesGroup_1 = require('./NodesGroup');
-var Utils_1 = require('../Utils');
-
-var DebugProtectionNodesGroup = function (_NodesGroup_1$NodesGr) {
-    _inherits(DebugProtectionNodesGroup, _NodesGroup_1$NodesGr);
-
-    function DebugProtectionNodesGroup() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, DebugProtectionNodesGroup);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionNodesGroup).call(this, options));
-
-        _this.debugProtectionFunctionIdentifier = Utils_1.Utils.getRandomVariableName();
-        _this.nodes.set('debugProtectionFunctionNode', new DebugProtectionFunctionNode_1.DebugProtectionFunctionNode(_this.debugProtectionFunctionIdentifier, _this.options));
-        _this.nodes.set('debugProtectionFunctionCallNode', new DebugProtectionFunctionCallNode_1.DebugProtectionFunctionCallNode(_this.debugProtectionFunctionIdentifier, _this.options));
-        if (_this.options['debugProtectionInterval']) {
-            _this.nodes.set('debugProtectionFunctionIntervalNode', new DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode(_this.debugProtectionFunctionIdentifier, _this.options));
-        }
-        return _this;
-    }
-
-    return DebugProtectionNodesGroup;
-}(NodesGroup_1.NodesGroup);
-
-exports.DebugProtectionNodesGroup = DebugProtectionNodesGroup;

dist/src/node-groups/NodesGroup.js

@@ -1,27 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var NodesGroup = function () {
-    function NodesGroup() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, NodesGroup);
-
-        this.nodes = new Map();
-        this.options = options;
-    }
-
-    _createClass(NodesGroup, [{
-        key: "getNodes",
-        value: function getNodes() {
-            return this.nodes;
-        }
-    }]);
-
-    return NodesGroup;
-}();
-
-exports.NodesGroup = NodesGroup;

dist/src/node-groups/SelfDefendingNodesGroup.js

@@ -1,29 +0,0 @@
-"use strict";
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var NodesGroup_1 = require('./NodesGroup');
-var SelfDefendingUnicodeNode_1 = require("../custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode");
-
-var SelfDefendingNodesGroup = function (_NodesGroup_1$NodesGr) {
-    _inherits(SelfDefendingNodesGroup, _NodesGroup_1$NodesGr);
-
-    function SelfDefendingNodesGroup() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, SelfDefendingNodesGroup);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingNodesGroup).call(this, options));
-
-        _this.nodes.set('selfDefendingUnicodeNode', new SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode(_this.options));
-        return _this;
-    }
-
-    return SelfDefendingNodesGroup;
-}(NodesGroup_1.NodesGroup);
-
-exports.SelfDefendingNodesGroup = SelfDefendingNodesGroup;

dist/src/node-groups/UnicodeArrayNodesGroup.js

@@ -1,47 +0,0 @@
-"use strict";
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var NodesGroup_1 = require('./NodesGroup');
-var UnicodeArrayCallsWrapper_1 = require("../custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper");
-var UnicodeArrayDecodeNode_1 = require("../custom-nodes/unicode-array-nodes/UnicodeArrayDecodeNode");
-var UnicodeArrayNode_1 = require('../custom-nodes/unicode-array-nodes/UnicodeArrayNode');
-var UnicodeArrayRotateFunctionNode_1 = require('../custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode');
-var Utils_1 = require('../Utils');
-
-var UnicodeArrayNodesGroup = function (_NodesGroup_1$NodesGr) {
-    _inherits(UnicodeArrayNodesGroup, _NodesGroup_1$NodesGr);
-
-    function UnicodeArrayNodesGroup() {
-        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-
-        _classCallCheck(this, UnicodeArrayNodesGroup);
-
-        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNodesGroup).call(this, options));
-
-        _this.unicodeArrayName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
-        _this.unicodeArrayTranslatorName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
-        _this.unicodeArrayRotateValue = _this.options['rotateUnicodeArray'] ? Utils_1.Utils.getRandomInteger(100, 500) : 0;
-        var unicodeArrayNode = new UnicodeArrayNode_1.UnicodeArrayNode(_this.unicodeArrayName, _this.unicodeArrayRotateValue, _this.options),
-            unicodeArray = unicodeArrayNode.getNodeData();
-        _this.nodes.set('unicodeArrayNode', unicodeArrayNode);
-        if (_this.options['wrapUnicodeArrayCalls']) {
-            _this.nodes.set('unicodeArrayCallsWrapper', new UnicodeArrayCallsWrapper_1.UnicodeArrayCallsWrapper(_this.unicodeArrayTranslatorName, _this.unicodeArrayName, unicodeArray, _this.options));
-        }
-        if (_this.options['encodeUnicodeLiterals']) {
-            _this.nodes.set('unicodeArrayDecodeNode', new UnicodeArrayDecodeNode_1.UnicodeArrayDecodeNode(_this.unicodeArrayName, unicodeArray, _this.options));
-        }
-        if (_this.options['rotateUnicodeArray']) {
-            _this.nodes.set('unicodeArrayRotateFunctionNode', new UnicodeArrayRotateFunctionNode_1.UnicodeArrayRotateFunctionNode(_this.unicodeArrayName, unicodeArray, _this.unicodeArrayRotateValue, _this.options));
-        }
-        return _this;
-    }
-
-    return UnicodeArrayNodesGroup;
-}(NodesGroup_1.NodesGroup);
-
-exports.UnicodeArrayNodesGroup = UnicodeArrayNodesGroup;

dist/src/node-obfuscators/CatchClauseObfuscator.js

@@ -1,72 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var estraverse = require('estraverse');
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var CatchClauseObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(CatchClauseObfuscator, _NodeObfuscator_1$Nod);
-
-    function CatchClauseObfuscator() {
-        var _Object$getPrototypeO;
-
-        _classCallCheck(this, CatchClauseObfuscator);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-
-        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(CatchClauseObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
-
-        _this.catchClauseParam = new Map();
-        return _this;
-    }
-
-    _createClass(CatchClauseObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(catchClauseNode) {
-            this.replaceCatchClauseParam(catchClauseNode);
-            this.replaceCatchClauseParamInBlock(catchClauseNode);
-        }
-    }, {
-        key: 'replaceCatchClauseParam',
-        value: function replaceCatchClauseParam(catchClauseNode) {
-            var _this2 = this;
-
-            estraverse.replace(catchClauseNode.param, {
-                leave: function leave(node, parentNode) {
-                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
-                        _this2.catchClauseParam.set(node.name, Utils_1.Utils.getRandomVariableName());
-                        node.name = _this2.catchClauseParam.get(node.name);
-                        return;
-                    }
-                    return estraverse.VisitorOption.Skip;
-                }
-            });
-        }
-    }, {
-        key: 'replaceCatchClauseParamInBlock',
-        value: function replaceCatchClauseParamInBlock(catchClauseNode) {
-            var _this3 = this;
-
-            estraverse.replace(catchClauseNode.body, {
-                leave: function leave(node, parentNode) {
-                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.catchClauseParam);
-                }
-            });
-        }
-    }]);
-
-    return CatchClauseObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.CatchClauseObfuscator = CatchClauseObfuscator;

dist/src/node-obfuscators/FunctionDeclarationObfuscator.js

@@ -1,77 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var estraverse = require('estraverse');
-var NodeType_1 = require("../enums/NodeType");
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var FunctionDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(FunctionDeclarationObfuscator, _NodeObfuscator_1$Nod);
-
-    function FunctionDeclarationObfuscator() {
-        var _Object$getPrototypeO;
-
-        _classCallCheck(this, FunctionDeclarationObfuscator);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-
-        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
-
-        _this.functionName = new Map();
-        return _this;
-    }
-
-    _createClass(FunctionDeclarationObfuscator, [{
-        key: "obfuscateNode",
-        value: function obfuscateNode(functionDeclarationNode, parentNode) {
-            if (parentNode.type === NodeType_1.NodeType.Program) {
-                return;
-            }
-            this.replaceFunctionName(functionDeclarationNode);
-            this.replaceFunctionCalls(functionDeclarationNode);
-        }
-    }, {
-        key: "replaceFunctionName",
-        value: function replaceFunctionName(functionDeclarationNode) {
-            var _this2 = this;
-
-            estraverse.replace(functionDeclarationNode.id, {
-                leave: function leave(node) {
-                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
-                        _this2.functionName.set(node.name, Utils_1.Utils.getRandomVariableName());
-                        node.name = _this2.functionName.get(node.name);
-                        return;
-                    }
-                    return estraverse.VisitorOption.Skip;
-                }
-            });
-        }
-    }, {
-        key: "replaceFunctionCalls",
-        value: function replaceFunctionCalls(functionDeclarationNode) {
-            var _this3 = this;
-
-            var scopeNode = NodeUtils_1.NodeUtils.getBlockScopeOfNode(functionDeclarationNode);
-            estraverse.replace(scopeNode, {
-                enter: function enter(node, parentNode) {
-                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionName);
-                }
-            });
-        }
-    }]);
-
-    return FunctionDeclarationObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.FunctionDeclarationObfuscator = FunctionDeclarationObfuscator;

dist/src/node-obfuscators/FunctionObfuscator.js

@@ -1,74 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var estraverse = require('estraverse');
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var FunctionObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(FunctionObfuscator, _NodeObfuscator_1$Nod);
-
-    function FunctionObfuscator() {
-        var _Object$getPrototypeO;
-
-        _classCallCheck(this, FunctionObfuscator);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-
-        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
-
-        _this.functionParams = new Map();
-        return _this;
-    }
-
-    _createClass(FunctionObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(functionNode) {
-            this.replaceFunctionParams(functionNode);
-            this.replaceFunctionParamsInBody(functionNode);
-        }
-    }, {
-        key: 'replaceFunctionParams',
-        value: function replaceFunctionParams(functionNode) {
-            var _this2 = this;
-
-            functionNode.params.forEach(function (paramsNode) {
-                estraverse.replace(paramsNode, {
-                    leave: function leave(node) {
-                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
-                            _this2.functionParams.set(node.name, Utils_1.Utils.getRandomVariableName());
-                            node.name = _this2.functionParams.get(node.name);
-                            return;
-                        }
-                        return estraverse.VisitorOption.Skip;
-                    }
-                });
-            });
-        }
-    }, {
-        key: 'replaceFunctionParamsInBody',
-        value: function replaceFunctionParamsInBody(functionNode) {
-            var _this3 = this;
-
-            estraverse.replace(functionNode.body, {
-                leave: function leave(node, parentNode) {
-                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionParams);
-                }
-            });
-        }
-    }]);
-
-    return FunctionObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.FunctionObfuscator = FunctionObfuscator;

dist/src/node-obfuscators/LiteralObfuscator.js

@@ -1,59 +0,0 @@
-"use strict";
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var escodegen = require('escodegen');
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-
-var LiteralObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(LiteralObfuscator, _NodeObfuscator_1$Nod);
-
-    function LiteralObfuscator() {
-        _classCallCheck(this, LiteralObfuscator);
-
-        return _possibleConstructorReturn(this, Object.getPrototypeOf(LiteralObfuscator).apply(this, arguments));
-    }
-
-    _createClass(LiteralObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(literalNode, parentNode) {
-            if (NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === literalNode) {
-                return;
-            }
-            if (literalNode['x-verbatim-property']) {
-                return;
-            }
-            var content = void 0;
-            switch (_typeof(literalNode.value)) {
-                case 'boolean':
-                    content = this.replaceLiteralBooleanByJSFuck(literalNode.value);
-                    break;
-                case 'number':
-                    content = this.replaceLiteralNumberByHexadecimalValue(literalNode.value);
-                    break;
-                case 'string':
-                    content = this.replaceLiteralValueByUnicodeValue(literalNode.value);
-                    break;
-                default:
-                    return;
-            }
-            literalNode['x-verbatim-property'] = {
-                content: content,
-                precedence: escodegen.Precedence.Primary
-            };
-        }
-    }]);
-
-    return LiteralObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.LiteralObfuscator = LiteralObfuscator;

dist/src/node-obfuscators/MemberExpressionObfuscator.js

@@ -1,87 +0,0 @@
-"use strict";
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var escodegen = require('escodegen');
-var estraverse = require('estraverse');
-var NodeType_1 = require("../enums/NodeType");
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-
-var MemberExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(MemberExpressionObfuscator, _NodeObfuscator_1$Nod);
-
-    function MemberExpressionObfuscator() {
-        _classCallCheck(this, MemberExpressionObfuscator);
-
-        return _possibleConstructorReturn(this, Object.getPrototypeOf(MemberExpressionObfuscator).apply(this, arguments));
-    }
-
-    _createClass(MemberExpressionObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(memberExpressionNode) {
-            var _this2 = this;
-
-            estraverse.replace(memberExpressionNode.property, {
-                leave: function leave(node, parentNode) {
-                    if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
-                        _this2.literalNodeController(node);
-                        return;
-                    }
-                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
-                        if (memberExpressionNode.computed) {
-                            return;
-                        }
-                        memberExpressionNode.computed = true;
-                        _this2.identifierNodeController(node);
-                    }
-                }
-            });
-        }
-    }, {
-        key: 'identifierNodeController',
-        value: function identifierNodeController(node) {
-            var nodeValue = node.name,
-                literalNode = {
-                raw: '\'' + nodeValue + '\'',
-                'x-verbatim-property': {
-                    content: this.replaceLiteralValueByUnicodeValue(nodeValue),
-                    precedence: escodegen.Precedence.Primary
-                },
-                type: NodeType_1.NodeType.Literal,
-                value: nodeValue
-            };
-            delete node.name;
-            Object.assign(node, literalNode);
-        }
-    }, {
-        key: 'literalNodeController',
-        value: function literalNodeController(node) {
-            switch (_typeof(node.value)) {
-                case 'string':
-                    if (node['x-verbatim-property']) {
-                        break;
-                    }
-                    node['x-verbatim-property'] = {
-                        content: this.replaceLiteralValueByUnicodeValue(node.value),
-                        precedence: escodegen.Precedence.Primary
-                    };
-                    break;
-                default:
-                    break;
-            }
-        }
-    }]);
-
-    return MemberExpressionObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.MemberExpressionObfuscator = MemberExpressionObfuscator;

dist/src/node-obfuscators/MethodDefinitionObfuscator.js

@@ -1,60 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var estraverse = require('estraverse');
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require("../Utils");
-
-var MethodDefinitionObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(MethodDefinitionObfuscator, _NodeObfuscator_1$Nod);
-
-    function MethodDefinitionObfuscator() {
-        var _Object$getPrototypeO;
-
-        _classCallCheck(this, MethodDefinitionObfuscator);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-
-        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(MethodDefinitionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
-
-        _this.ignoredNames = ['constructor'];
-        return _this;
-    }
-
-    _createClass(MethodDefinitionObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(methodDefinitionNode, parentNode) {
-            this.replaceMethodName(methodDefinitionNode);
-        }
-    }, {
-        key: 'replaceMethodName',
-        value: function replaceMethodName(methodDefinitionNode) {
-            var _this2 = this;
-
-            estraverse.replace(methodDefinitionNode.key, {
-                leave: function leave(node) {
-                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !Utils_1.Utils.arrayContains(_this2.ignoredNames, node.name) && methodDefinitionNode.computed === false) {
-                        methodDefinitionNode.computed = true;
-                        node.name = _this2.replaceLiteralValueByUnicodeValue(node.name);
-                        return;
-                    }
-                    return estraverse.VisitorOption.Skip;
-                }
-            });
-        }
-    }]);
-
-    return MethodDefinitionObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.MethodDefinitionObfuscator = MethodDefinitionObfuscator;

dist/src/node-obfuscators/NodeObfuscator.js

@@ -1,93 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var JSFuck_1 = require("../enums/JSFuck");
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var NodeObfuscator = function () {
-    function NodeObfuscator(nodes) {
-        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
-
-        _classCallCheck(this, NodeObfuscator);
-
-        this.nodes = nodes;
-        this.options = options;
-    }
-
-    _createClass(NodeObfuscator, [{
-        key: "isReservedName",
-        value: function isReservedName(name) {
-            return this.options['reservedNames'].some(function (reservedName) {
-                return new RegExp(reservedName, 'g').test(name);
-            });
-        }
-    }, {
-        key: "replaceNodeIdentifierByNewValue",
-        value: function replaceNodeIdentifierByNewValue(node, parentNode, namesMap) {
-            if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) {
-                var parentNodeIsAPropertyNode = NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === node,
-                    parentNodeIsAMemberExpressionNode = NodeUtils_1.NodeUtils.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node;
-                if (parentNodeIsAPropertyNode || parentNodeIsAMemberExpressionNode) {
-                    return;
-                }
-                node.name = namesMap.get(node.name);
-            }
-        }
-    }, {
-        key: "replaceLiteralBooleanByJSFuck",
-        value: function replaceLiteralBooleanByJSFuck(nodeValue) {
-            return nodeValue ? JSFuck_1.JSFuck.True : JSFuck_1.JSFuck.False;
-        }
-    }, {
-        key: "replaceLiteralNumberByHexadecimalValue",
-        value: function replaceLiteralNumberByHexadecimalValue(nodeValue) {
-            var prefix = '0x';
-            if (!Utils_1.Utils.isInteger(nodeValue)) {
-                return String(nodeValue);
-            }
-            return "" + prefix + Utils_1.Utils.decToHex(nodeValue);
-        }
-    }, {
-        key: "replaceLiteralValueByUnicodeValue",
-        value: function replaceLiteralValueByUnicodeValue(nodeValue) {
-            var value = nodeValue,
-                replaceByUnicodeArrayFlag = Math.random() <= this.options['unicodeArrayThreshold'];
-            if (this.options['encodeUnicodeLiterals'] && replaceByUnicodeArrayFlag) {
-                value = Utils_1.Utils.btoa(value);
-            }
-            value = Utils_1.Utils.stringToUnicode(value);
-            if (!this.options['unicodeArray'] || !replaceByUnicodeArrayFlag) {
-                return value;
-            }
-            return this.replaceLiteralValueByUnicodeArrayCall(value);
-        }
-    }, {
-        key: "replaceLiteralValueByUnicodeArrayCall",
-        value: function replaceLiteralValueByUnicodeArrayCall(value) {
-            var unicodeArrayNode = this.nodes.get('unicodeArrayNode'),
-                unicodeArray = unicodeArrayNode.getNodeData(),
-                sameIndex = unicodeArray.indexOf(value),
-                index = void 0,
-                hexadecimalIndex = void 0;
-            if (sameIndex >= 0) {
-                index = sameIndex;
-            } else {
-                index = unicodeArray.length;
-                unicodeArrayNode.updateNodeData(value);
-            }
-            hexadecimalIndex = this.replaceLiteralNumberByHexadecimalValue(index);
-            if (this.options['wrapUnicodeArrayCalls']) {
-                return this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier() + "('" + hexadecimalIndex + "')";
-            }
-            return unicodeArrayNode.getNodeIdentifier() + "[" + hexadecimalIndex + "]";
-        }
-    }]);
-
-    return NodeObfuscator;
-}();
-
-exports.NodeObfuscator = NodeObfuscator;

dist/src/node-obfuscators/ObjectExpressionObfuscator.js

@@ -1,86 +0,0 @@
-"use strict";
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var escodegen = require('escodegen');
-var estraverse = require('estraverse');
-var NodeType_1 = require("../enums/NodeType");
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var ObjectExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(ObjectExpressionObfuscator, _NodeObfuscator_1$Nod);
-
-    function ObjectExpressionObfuscator() {
-        _classCallCheck(this, ObjectExpressionObfuscator);
-
-        return _possibleConstructorReturn(this, Object.getPrototypeOf(ObjectExpressionObfuscator).apply(this, arguments));
-    }
-
-    _createClass(ObjectExpressionObfuscator, [{
-        key: 'obfuscateNode',
-        value: function obfuscateNode(objectExpressionNode) {
-            var _this2 = this;
-
-            objectExpressionNode.properties.forEach(function (property) {
-                estraverse.replace(property.key, {
-                    leave: function leave(node, parentNode) {
-                        if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
-                            _this2.literalNodeController(node);
-                            return;
-                        }
-                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
-                            _this2.identifierNodeController(node);
-                        }
-                    }
-                });
-            });
-        }
-    }, {
-        key: 'literalNodeController',
-        value: function literalNodeController(node) {
-            switch (_typeof(node.value)) {
-                case 'string':
-                    if (node['x-verbatim-property']) {
-                        break;
-                    }
-                    node['x-verbatim-property'] = {
-                        content: Utils_1.Utils.stringToUnicode(node.value),
-                        precedence: escodegen.Precedence.Primary
-                    };
-                    break;
-                default:
-                    break;
-            }
-        }
-    }, {
-        key: 'identifierNodeController',
-        value: function identifierNodeController(node) {
-            var nodeValue = node.name,
-                literalNode = {
-                raw: '\'' + nodeValue + '\'',
-                'x-verbatim-property': {
-                    content: Utils_1.Utils.stringToUnicode(nodeValue),
-                    precedence: escodegen.Precedence.Primary
-                },
-                type: NodeType_1.NodeType.Literal,
-                value: nodeValue
-            };
-            delete node.name;
-            Object.assign(node, literalNode);
-        }
-    }]);
-
-    return ObjectExpressionObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.ObjectExpressionObfuscator = ObjectExpressionObfuscator;

dist/src/node-obfuscators/VariableDeclarationObfuscator.js

@@ -1,94 +0,0 @@
-"use strict";
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var estraverse = require('estraverse');
-var NodeType_1 = require("../enums/NodeType");
-var NodeObfuscator_1 = require('./NodeObfuscator');
-var NodeUtils_1 = require("../NodeUtils");
-var Utils_1 = require('../Utils');
-
-var VariableDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
-    _inherits(VariableDeclarationObfuscator, _NodeObfuscator_1$Nod);
-
-    function VariableDeclarationObfuscator() {
-        var _Object$getPrototypeO;
-
-        _classCallCheck(this, VariableDeclarationObfuscator);
-
-        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-
-        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(VariableDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
-
-        _this.variableNames = new Map();
-        return _this;
-    }
-
-    _createClass(VariableDeclarationObfuscator, [{
-        key: "obfuscateNode",
-        value: function obfuscateNode(variableDeclarationNode, parentNode) {
-            if (parentNode.type === NodeType_1.NodeType.Program) {
-                return;
-            }
-            this.replaceVariableName(variableDeclarationNode);
-            this.replaceVariableCalls(variableDeclarationNode, parentNode);
-        }
-    }, {
-        key: "replaceVariableName",
-        value: function replaceVariableName(variableDeclarationNode) {
-            var _this2 = this;
-
-            variableDeclarationNode.declarations.forEach(function (declarationNode) {
-                estraverse.replace(declarationNode.id, {
-                    enter: function enter(node) {
-                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
-                            _this2.variableNames.set(node.name, Utils_1.Utils.getRandomVariableName());
-                            node.name = _this2.variableNames.get(node.name);
-                            return;
-                        }
-                        return estraverse.VisitorOption.Skip;
-                    }
-                });
-            });
-        }
-    }, {
-        key: "replaceVariableCalls",
-        value: function replaceVariableCalls(variableDeclarationNode, variableParentNode) {
-            var _this3 = this;
-
-            var scopeNode = void 0;
-            scopeNode = variableDeclarationNode.kind === 'var' ? NodeUtils_1.NodeUtils.getBlockScopeOfNode(variableDeclarationNode) : variableParentNode;
-            var isNodeAfterVariableDeclaratorFlag = false;
-            estraverse.replace(scopeNode, {
-                enter: function enter(node, parentNode) {
-                    var functionNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression];
-                    if (Utils_1.Utils.arrayContains(functionNodes, node.type)) {
-                        estraverse.replace(node, {
-                            enter: function enter(node, parentNode) {
-                                _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
-                            }
-                        });
-                    }
-                    if (node === variableDeclarationNode) {
-                        isNodeAfterVariableDeclaratorFlag = true;
-                    }
-                    if (isNodeAfterVariableDeclaratorFlag) {
-                        _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
-                    }
-                }
-            });
-        }
-    }]);
-
-    return VariableDeclarationObfuscator;
-}(NodeObfuscator_1.NodeObfuscator);
-
-exports.VariableDeclarationObfuscator = VariableDeclarationObfuscator;

dist/src/preset-options/DefaultPreset.js

@@ -1,15 +0,0 @@
-"use strict";
-
-exports.DEFAULT_PRESET = Object.freeze({
-    compact: true,
-    debugProtection: false,
-    debugProtectionInterval: false,
-    disableConsoleOutput: true,
-    encodeUnicodeLiterals: false,
-    reservedNames: [],
-    rotateUnicodeArray: true,
-    selfDefending: true,
-    unicodeArray: true,
-    unicodeArrayThreshold: 0.8,
-    wrapUnicodeArrayCalls: true
-});

dist/src/preset-options/NoCustomNodesPreset.js

@@ -1,15 +0,0 @@
-"use strict";
-
-exports.NO_CUSTOM_NODES_PRESET = Object.freeze({
-    compact: true,
-    debugProtection: false,
-    debugProtectionInterval: false,
-    disableConsoleOutput: false,
-    encodeUnicodeLiterals: false,
-    reservedNames: [],
-    rotateUnicodeArray: false,
-    selfDefending: false,
-    unicodeArray: false,
-    unicodeArrayThreshold: 0,
-    wrapUnicodeArrayCalls: false
-});

dist/tests/dev-test.js

@@ -1,9 +0,0 @@
-"use strict";
-
-var JavaScriptObfuscator_1 = require('../src/JavaScriptObfuscator');
-var obfuscatedCode = JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n    (function(){\n        var result = 1,\n            term1 = 0,\n            term2 = 1,\n            i = 1;\n        while(i < 10)\n        {\n            var test = 10;\n            result = term1 + term2;\n            console.log(result);\n            term1 = term2;\n            term2 = result;\n            i++;\n        }\n\n        console.log(test);\n        \n        var test = function (test) {\n            console.log(test);\n            \n            if (true) {\n                var test = 5\n            }\n            \n            return test;\n        }\n        \n        console.log(test(1));\n        \n        function test2 (abc) {\n            function test1 () {\n              console.log('inside', abc.item);\n            }\n            \n            console.log('тест', abc);\n            \n            var abc = {};\n            \n            return abc.item = 15, test1();\n        };\n        \n        test2(22);\n        console.log(105.4);\n        console.log(true, false);\n    })();\n    ", {
-    disableConsoleOutput: false,
-    encodeUnicodeLiterals: true
-});
-console.log(obfuscatedCode);
-console.log(eval(obfuscatedCode));

dist/tests/test-bundle.js

@@ -0,0 +1,2370 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var obfuscatedCode = JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n    (function(){\n        var result = 1,\n            term1 = 0,\n            term2 = 1,\n            i = 1;\n        while(i < 10)\n        {\n            var test = 10;\n            result = term1 + term2;\n            console.log(result);\n            term1 = term2;\n            term2 = result;\n            i++;\n        }\n\n        console.log(test);\n        \n        var test = function (test) {\n            console.log(test);\n            \n            if (true) {\n                var test = 5\n            }\n            \n            return test;\n        }\n        \n        console.log(test(1));\n        \n        function test2 (abc) {\n            function test1 () {\n              console.log('inside', abc.item);\n            }\n            \n            console.log('тест', abc);\n            \n            var abc = {};\n            \n            return abc.item = 15, test1();\n        };\n        \n        test2(22);\n        console.log(105.4);\n        console.log(true, false);\n    })();\n    ", {
+	    disableConsoleOutput: false,
+	    encodeUnicodeLiterals: true
+	});
+	console.log(obfuscatedCode);
+	console.log(eval(obfuscatedCode));
+
+/***/ },
+/* 1 */,
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var esprima = __webpack_require__(3);
+	var escodegen = __webpack_require__(4);
+	var DefaultPreset_1 = __webpack_require__(5);
+	var Obfuscator_1 = __webpack_require__(6);
+	var OptionsNormalizer_1 = __webpack_require__(37);
+
+	var JavaScriptObfuscator = function () {
+	    function JavaScriptObfuscator() {
+	        _classCallCheck(this, JavaScriptObfuscator);
+	    }
+
+	    _createClass(JavaScriptObfuscator, null, [{
+	        key: 'obfuscate',
+	        value: function obfuscate(sourceCode, customOptions) {
+	            var astTree = esprima.parse(sourceCode),
+	                options = OptionsNormalizer_1.OptionsNormalizer.normalize(Object.assign({}, DefaultPreset_1.DEFAULT_PRESET, customOptions)),
+	                obfuscator = new Obfuscator_1.Obfuscator(options);
+	            astTree = obfuscator.obfuscateNode(astTree);
+	            return JavaScriptObfuscator.generateCode(astTree, options);
+	        }
+	    }, {
+	        key: 'generateCode',
+	        value: function generateCode(astTree, options) {
+	            var escodegenParams = Object.assign({}, JavaScriptObfuscator.escodegenParams);
+	            if (options.hasOwnProperty('compact')) {
+	                escodegenParams.format = {
+	                    compact: options.compact
+	                };
+	            }
+	            return escodegen.generate(astTree, escodegenParams);
+	        }
+	    }]);
+
+	    return JavaScriptObfuscator;
+	}();
+
+	JavaScriptObfuscator.escodegenParams = {
+	    verbatim: 'x-verbatim-property'
+	};
+	exports.JavaScriptObfuscator = JavaScriptObfuscator;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = require("esprima");
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	module.exports = require("escodegen");
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.DEFAULT_PRESET = Object.freeze({
+	    compact: true,
+	    debugProtection: false,
+	    debugProtectionInterval: false,
+	    disableConsoleOutput: true,
+	    encodeUnicodeLiterals: false,
+	    reservedNames: [],
+	    rotateUnicodeArray: true,
+	    selfDefending: true,
+	    unicodeArray: true,
+	    unicodeArrayThreshold: 0.8,
+	    wrapUnicodeArrayCalls: true
+	});
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var estraverse = __webpack_require__(7);
+	var AppendState_1 = __webpack_require__(8);
+	var NodeType_1 = __webpack_require__(9);
+	var CatchClauseObfuscator_1 = __webpack_require__(12);
+	var ConsoleOutputDisableExpressionNode_1 = __webpack_require__(15);
+	var DebugProtectionNodesGroup_1 = __webpack_require__(17);
+	var FunctionDeclarationObfuscator_1 = __webpack_require__(22);
+	var FunctionObfuscator_1 = __webpack_require__(23);
+	var LiteralObfuscator_1 = __webpack_require__(24);
+	var MemberExpressionObfuscator_1 = __webpack_require__(25);
+	var MethodDefinitionObfuscator_1 = __webpack_require__(26);
+	var NodeUtils_1 = __webpack_require__(14);
+	var ObjectExpressionObfuscator_1 = __webpack_require__(27);
+	var SelfDefendingNodesGroup_1 = __webpack_require__(28);
+	var UnicodeArrayNodesGroup_1 = __webpack_require__(31);
+	var VariableDeclarationObfuscator_1 = __webpack_require__(36);
+
+	var Obfuscator = function () {
+	    function Obfuscator() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, Obfuscator);
+
+	        this.nodes = new Map();
+	        this.nodeObfuscators = new Map([[NodeType_1.NodeType.ArrowFunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.ClassDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator]], [NodeType_1.NodeType.CatchClause, [CatchClauseObfuscator_1.CatchClauseObfuscator]], [NodeType_1.NodeType.FunctionDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator, FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.FunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.MemberExpression, [MemberExpressionObfuscator_1.MemberExpressionObfuscator]], [NodeType_1.NodeType.MethodDefinition, [MethodDefinitionObfuscator_1.MethodDefinitionObfuscator]], [NodeType_1.NodeType.ObjectExpression, [ObjectExpressionObfuscator_1.ObjectExpressionObfuscator]], [NodeType_1.NodeType.VariableDeclaration, [VariableDeclarationObfuscator_1.VariableDeclarationObfuscator]], [NodeType_1.NodeType.Literal, [LiteralObfuscator_1.LiteralObfuscator]]]);
+	        this.options = options;
+	    }
+
+	    _createClass(Obfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(node) {
+	            this.setNewNodes();
+	            NodeUtils_1.NodeUtils.parentize(node);
+	            this.beforeObfuscation(node);
+	            this.obfuscate(node);
+	            this.afterObfuscation(node);
+	            return node;
+	        }
+	    }, {
+	        key: 'setNode',
+	        value: function setNode(nodeName, node) {
+	            this.nodes.set(nodeName, node);
+	        }
+	    }, {
+	        key: 'setNodesGroup',
+	        value: function setNodesGroup(nodesGroup) {
+	            var _this = this;
+
+	            var nodes = nodesGroup.getNodes();
+	            nodes.forEach(function (node, key) {
+	                _this.nodes.set(key, node);
+	            });
+	        }
+	    }, {
+	        key: 'afterObfuscation',
+	        value: function afterObfuscation(astTree) {
+	            this.nodes.forEach(function (node) {
+	                if (node.getAppendState() === AppendState_1.AppendState.AfterObfuscation) {
+	                    node.appendNode(astTree);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'beforeObfuscation',
+	        value: function beforeObfuscation(astTree) {
+	            this.nodes.forEach(function (node) {
+	                if (node.getAppendState() === AppendState_1.AppendState.BeforeObfuscation) {
+	                    node.appendNode(astTree);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'initializeNodeObfuscators',
+	        value: function initializeNodeObfuscators(node, parentNode) {
+	            var _this2 = this;
+
+	            if (!this.nodeObfuscators.has(node.type)) {
+	                return;
+	            }
+	            this.nodeObfuscators.get(node.type).forEach(function (obfuscator) {
+	                new obfuscator(_this2.nodes, _this2.options).obfuscateNode(node, parentNode);
+	            });
+	        }
+	    }, {
+	        key: 'obfuscate',
+	        value: function obfuscate(node) {
+	            var _this3 = this;
+
+	            estraverse.replace(node, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.initializeNodeObfuscators(node, parentNode);
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'setNewNodes',
+	        value: function setNewNodes() {
+	            if (this.options['selfDefending']) {
+	                this.setNodesGroup(new SelfDefendingNodesGroup_1.SelfDefendingNodesGroup(this.options));
+	            }
+	            if (this.options['disableConsoleOutput']) {
+	                this.setNode('consoleOutputDisableExpressionNode', new ConsoleOutputDisableExpressionNode_1.ConsoleOutputDisableExpressionNode());
+	            }
+	            if (this.options['debugProtection']) {
+	                this.setNodesGroup(new DebugProtectionNodesGroup_1.DebugProtectionNodesGroup(this.options));
+	            }
+	            if (this.options['unicodeArray']) {
+	                this.setNodesGroup(new UnicodeArrayNodesGroup_1.UnicodeArrayNodesGroup(this.options));
+	            }
+	        }
+	    }]);
+
+	    return Obfuscator;
+	}();
+
+	exports.Obfuscator = Obfuscator;
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	module.exports = require("estraverse");
+
+/***/ },
+/* 8 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	(function (AppendState) {
+	    AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation";
+	    AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation";
+	})(exports.AppendState || (exports.AppendState = {}));
+	var AppendState = exports.AppendState;
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var Utils_1 = __webpack_require__(10);
+	exports.NodeType = Utils_1.Utils.strEnumify({
+	    ArrayExpression: 'ArrayExpression',
+	    ArrowFunctionExpression: 'ArrowFunctionExpression',
+	    AssignmentExpression: 'AssignmentExpression',
+	    BinaryExpression: 'BinaryExpression',
+	    BlockStatement: 'BlockStatement',
+	    CallExpression: 'CallExpression',
+	    CatchClause: 'CatchClause',
+	    ClassDeclaration: 'ClassDeclaration',
+	    ExpressionStatement: 'ExpressionStatement',
+	    FunctionDeclaration: 'FunctionDeclaration',
+	    FunctionExpression: 'FunctionExpression',
+	    Identifier: 'Identifier',
+	    IfStatement: 'IfStatement',
+	    Literal: 'Literal',
+	    LogicalExpression: 'LogicalExpression',
+	    MemberExpression: 'MemberExpression',
+	    MethodDefinition: 'MethodDefinition',
+	    ObjectExpression: 'ObjectExpression',
+	    Program: 'Program',
+	    Property: 'Property',
+	    ReturnStatement: 'ReturnStatement',
+	    TryStatement: 'TryStatement',
+	    UnaryExpression: 'UnaryExpression',
+	    UpdateExpression: 'UpdateExpression',
+	    VariableDeclaration: 'VariableDeclaration',
+	    VariableDeclarator: 'VariableDeclarator',
+	    WhileStatement: 'WhileStatement'
+	});
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var JSFuck_1 = __webpack_require__(11);
+
+	var Utils = function () {
+	    function Utils() {
+	        _classCallCheck(this, Utils);
+	    }
+
+	    _createClass(Utils, null, [{
+	        key: 'arrayContains',
+	        value: function arrayContains(array, searchElement) {
+	            return array.indexOf(searchElement) >= 0;
+	        }
+	    }, {
+	        key: 'arrayRotate',
+	        value: function arrayRotate(array, times) {
+	            var reverse = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2];
+
+	            if (times < 0) {
+	                return;
+	            }
+	            var newArray = array,
+	                temp = void 0;
+	            while (times--) {
+	                if (!reverse) {
+	                    temp = newArray.pop();
+	                    newArray.unshift(temp);
+	                } else {
+	                    temp = newArray.shift();
+	                    newArray.push(temp);
+	                }
+	            }
+	            return newArray;
+	        }
+	    }, {
+	        key: 'btoa',
+	        value: function btoa(string) {
+	            return new Buffer(encodeURI(string)).toString('base64');
+	        }
+	    }, {
+	        key: 'decToHex',
+	        value: function decToHex(dec) {
+	            var decToHexSliceValue = -6,
+	                exponent = 6,
+	                radix = 16;
+	            return (dec + Math.pow(radix, exponent)).toString(radix).substr(decToHexSliceValue).replace(Utils.hexRepetitiveZerosRegExp, '');
+	        }
+	    }, {
+	        key: 'getRandomInteger',
+	        value: function getRandomInteger(min, max) {
+	            return Math.round(Math.floor(Math.random() * (max - min + 1)) + min);
+	        }
+	    }, {
+	        key: 'getRandomVariableName',
+	        value: function getRandomVariableName() {
+	            var length = arguments.length <= 0 || arguments[0] === undefined ? 6 : arguments[0];
+
+	            var rangeMinInteger = 10000,
+	                rangeMaxInteger = 99999999,
+	                prefix = '_0x';
+	            return '' + prefix + Utils.decToHex(Utils.getRandomInteger(rangeMinInteger, rangeMaxInteger)).substr(0, length);
+	        }
+	    }, {
+	        key: 'isInteger',
+	        value: function isInteger(number) {
+	            return number % 1 === 0;
+	        }
+	    }, {
+	        key: 'strEnumify',
+	        value: function strEnumify(obj) {
+	            return obj;
+	        }
+	    }, {
+	        key: 'stringToJSFuck',
+	        value: function stringToJSFuck(string) {
+	            return Array.from(string).map(function (character) {
+	                return JSFuck_1.JSFuck[character] || character;
+	            }).join(' + ');
+	        }
+	    }, {
+	        key: 'stringToUnicode',
+	        value: function stringToUnicode(string) {
+	            var radix = 16;
+	            var prefix = void 0,
+	                regexp = new RegExp('[\x00-\x7F]'),
+	                template = void 0;
+	            return '\'' + string.replace(/[\s\S]/g, function (escape) {
+	                if (regexp.test(escape)) {
+	                    prefix = '\\x';
+	                    template = '0'.repeat(2);
+	                } else {
+	                    prefix = '\\u';
+	                    template = '0'.repeat(4);
+	                }
+	                return '' + prefix + (template + escape.charCodeAt(0).toString(radix)).slice(-template.length);
+	            }) + '\'';
+	        }
+	    }]);
+
+	    return Utils;
+	}();
+
+	Utils.hexRepetitiveZerosRegExp = new RegExp('^(0{2,})+(?!$)', '');
+	exports.Utils = Utils;
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.JSFuck = {
+	    Window: '[]["filter"]["constructor"]("return this")()',
+	    False: '![]',
+	    True: '!![]',
+	    a: '(false+"")[1]',
+	    b: '([]["entries"]()+"")[2]',
+	    c: '([]["fill"]+"")[3]',
+	    d: '(undefined+"")[2]',
+	    e: '(true+"")[3]',
+	    f: '(false+"")[0]',
+	    g: '(false+[0]+String)[20]',
+	    h: '(+(101))["to"+String["name"]](21)[1]',
+	    i: '([false]+undefined)[10]',
+	    j: '([]["entries"]()+"")[3]',
+	    k: '(+(20))["to"+String["name"]](21)',
+	    l: '(false+"")[2]',
+	    m: '(Number+"")[11]',
+	    n: '(undefined+"")[1]',
+	    o: '(true+[]["fill"])[10]',
+	    p: '(+(211))["to"+String["name"]](31)[1]',
+	    q: '(+(212))["to"+String["name"]](31)[1]',
+	    r: '(true+"")[1]',
+	    s: '(false+"")[3]',
+	    t: '(true+"")[0]',
+	    u: '(undefined+"")[0]',
+	    v: '(+(31))["to"+String["name"]](32)',
+	    w: '(+(32))["to"+String["name"]](33)',
+	    x: '(+(101))["to"+String["name"]](34)[1]',
+	    y: '(NaN+[Infinity])[10]',
+	    z: '(+(35))["to"+String["name"]](36)',
+	    A: '(+[]+Array)[10]',
+	    B: '(+[]+Boolean)[10]',
+	    C: 'Function("return escape")()(("")["italics"]())[2]',
+	    D: 'Function("return escape")()([]["fill"])["slice"]("-1")',
+	    E: '(RegExp+"")[12]',
+	    F: '(+[]+Function)[10]',
+	    G: '(false+Function("return Date")()())[30]',
+	    H: '\'H\'',
+	    I: '(Infinity+"")[0]',
+	    J: '\'J\'',
+	    K: '\'K\'',
+	    L: '\'L\'',
+	    M: '(true+Function("return Date")()())[30]',
+	    N: '(NaN+"")[0]',
+	    O: '(NaN+Function("return{}")())[11]',
+	    P: '\'P\'',
+	    Q: '\'Q\'',
+	    R: '(+[]+RegExp)[10]',
+	    S: '(+[]+String)[10]',
+	    T: '(NaN+Function("return Date")()())[30]',
+	    U: '(NaN+Function("return{}")()["to"+String["name"]]["call"]())[11]',
+	    V: '\'V\'',
+	    W: '\'W\'',
+	    X: '\'X\'',
+	    Y: '\'Y\'',
+	    Z: '\'Z\''
+	};
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var CatchClauseObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(CatchClauseObfuscator, _NodeObfuscator_1$Nod);
+
+	    function CatchClauseObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, CatchClauseObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(CatchClauseObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.catchClauseParam = new Map();
+	        return _this;
+	    }
+
+	    _createClass(CatchClauseObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(catchClauseNode) {
+	            this.replaceCatchClauseParam(catchClauseNode);
+	            this.replaceCatchClauseParamInBlock(catchClauseNode);
+	        }
+	    }, {
+	        key: 'replaceCatchClauseParam',
+	        value: function replaceCatchClauseParam(catchClauseNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(catchClauseNode.param, {
+	                leave: function leave(node, parentNode) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                        _this2.catchClauseParam.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                        node.name = _this2.catchClauseParam.get(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'replaceCatchClauseParamInBlock',
+	        value: function replaceCatchClauseParamInBlock(catchClauseNode) {
+	            var _this3 = this;
+
+	            estraverse.replace(catchClauseNode.body, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.catchClauseParam);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return CatchClauseObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.CatchClauseObfuscator = CatchClauseObfuscator;
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var JSFuck_1 = __webpack_require__(11);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var NodeObfuscator = function () {
+	    function NodeObfuscator(nodes) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, NodeObfuscator);
+
+	        this.nodes = nodes;
+	        this.options = options;
+	    }
+
+	    _createClass(NodeObfuscator, [{
+	        key: "isReservedName",
+	        value: function isReservedName(name) {
+	            return this.options['reservedNames'].some(function (reservedName) {
+	                return new RegExp(reservedName, 'g').test(name);
+	            });
+	        }
+	    }, {
+	        key: "replaceNodeIdentifierByNewValue",
+	        value: function replaceNodeIdentifierByNewValue(node, parentNode, namesMap) {
+	            if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) {
+	                var parentNodeIsAPropertyNode = NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === node,
+	                    parentNodeIsAMemberExpressionNode = NodeUtils_1.NodeUtils.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node;
+	                if (parentNodeIsAPropertyNode || parentNodeIsAMemberExpressionNode) {
+	                    return;
+	                }
+	                node.name = namesMap.get(node.name);
+	            }
+	        }
+	    }, {
+	        key: "replaceLiteralBooleanByJSFuck",
+	        value: function replaceLiteralBooleanByJSFuck(nodeValue) {
+	            return nodeValue ? JSFuck_1.JSFuck.True : JSFuck_1.JSFuck.False;
+	        }
+	    }, {
+	        key: "replaceLiteralNumberByHexadecimalValue",
+	        value: function replaceLiteralNumberByHexadecimalValue(nodeValue) {
+	            var prefix = '0x';
+	            if (!Utils_1.Utils.isInteger(nodeValue)) {
+	                return String(nodeValue);
+	            }
+	            return "" + prefix + Utils_1.Utils.decToHex(nodeValue);
+	        }
+	    }, {
+	        key: "replaceLiteralValueByUnicodeValue",
+	        value: function replaceLiteralValueByUnicodeValue(nodeValue) {
+	            var value = nodeValue,
+	                replaceByUnicodeArrayFlag = Math.random() <= this.options['unicodeArrayThreshold'];
+	            if (this.options['encodeUnicodeLiterals'] && replaceByUnicodeArrayFlag) {
+	                value = Utils_1.Utils.btoa(value);
+	            }
+	            value = Utils_1.Utils.stringToUnicode(value);
+	            if (!this.options['unicodeArray'] || !replaceByUnicodeArrayFlag) {
+	                return value;
+	            }
+	            return this.replaceLiteralValueByUnicodeArrayCall(value);
+	        }
+	    }, {
+	        key: "replaceLiteralValueByUnicodeArrayCall",
+	        value: function replaceLiteralValueByUnicodeArrayCall(value) {
+	            var unicodeArrayNode = this.nodes.get('unicodeArrayNode'),
+	                unicodeArray = unicodeArrayNode.getNodeData(),
+	                sameIndex = unicodeArray.indexOf(value),
+	                index = void 0,
+	                hexadecimalIndex = void 0;
+	            if (sameIndex >= 0) {
+	                index = sameIndex;
+	            } else {
+	                index = unicodeArray.length;
+	                unicodeArrayNode.updateNodeData(value);
+	            }
+	            hexadecimalIndex = this.replaceLiteralNumberByHexadecimalValue(index);
+	            if (this.options['wrapUnicodeArrayCalls']) {
+	                return this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier() + "('" + hexadecimalIndex + "')";
+	            }
+	            return unicodeArrayNode.getNodeIdentifier() + "[" + hexadecimalIndex + "]";
+	        }
+	    }]);
+
+	    return NodeObfuscator;
+	}();
+
+	exports.NodeObfuscator = NodeObfuscator;
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var Utils_1 = __webpack_require__(10);
+
+	var NodeUtils = function () {
+	    function NodeUtils() {
+	        _classCallCheck(this, NodeUtils);
+	    }
+
+	    _createClass(NodeUtils, null, [{
+	        key: "addXVerbatimPropertyToLiterals",
+	        value: function addXVerbatimPropertyToLiterals(node) {
+	            estraverse.replace(node, {
+	                enter: function enter(node, parentNode) {
+	                    if (NodeUtils.isLiteralNode(node)) {
+	                        node['x-verbatim-property'] = node.raw;
+	                    }
+	                }
+	            });
+	        }
+	    }, {
+	        key: "appendNode",
+	        value: function appendNode(blockScopeBody, node) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.push(node);
+	        }
+	    }, {
+	        key: "getBlockScopeNodeByIndex",
+	        value: function getBlockScopeNodeByIndex(node) {
+	            var index = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+
+	            if (NodeUtils.isNodeHasBlockScope(node) && node.body[index]) {
+	                return node.body[index];
+	            }
+	            return node;
+	        }
+	    }, {
+	        key: "getBlockScopeOfNode",
+	        value: function getBlockScopeOfNode(node) {
+	            var depth = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+
+	            if (!node.parentNode) {
+	                throw new ReferenceError('`parentNode` property of given node is `undefined`');
+	            }
+	            if (node.parentNode.type === NodeType_1.NodeType.Program) {
+	                return node.parentNode;
+	            }
+	            if (!Utils_1.Utils.arrayContains(NodeUtils.scopeNodes, node.parentNode.type)) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode, depth);
+	            }
+	            if (depth > 0) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode, --depth);
+	            }
+	            if (node.type !== NodeType_1.NodeType.BlockStatement) {
+	                return NodeUtils.getBlockScopeOfNode(node.parentNode);
+	            }
+	            return node;
+	        }
+	    }, {
+	        key: "getProgramNode",
+	        value: function getProgramNode(bodyNode) {
+	            return {
+	                'type': NodeType_1.NodeType.Program,
+	                'body': bodyNode
+	            };
+	        }
+	    }, {
+	        key: "insertNodeAtIndex",
+	        value: function insertNodeAtIndex(blockScopeBody, node, index) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.splice(index, 0, node);
+	        }
+	    }, {
+	        key: "isBlockStatementNode",
+	        value: function isBlockStatementNode(node) {
+	            return node.type === NodeType_1.NodeType.BlockStatement;
+	        }
+	    }, {
+	        key: "isIdentifierNode",
+	        value: function isIdentifierNode(node) {
+	            return node.type === NodeType_1.NodeType.Identifier;
+	        }
+	    }, {
+	        key: "isLiteralNode",
+	        value: function isLiteralNode(node) {
+	            return node.type === NodeType_1.NodeType.Literal;
+	        }
+	    }, {
+	        key: "isMemberExpressionNode",
+	        value: function isMemberExpressionNode(node) {
+	            return node.type === NodeType_1.NodeType.MemberExpression;
+	        }
+	    }, {
+	        key: "isNodeHasBlockScope",
+	        value: function isNodeHasBlockScope(node) {
+	            return node.hasOwnProperty('body');
+	        }
+	    }, {
+	        key: "isProgramNode",
+	        value: function isProgramNode(node) {
+	            return node.type === NodeType_1.NodeType.Program;
+	        }
+	    }, {
+	        key: "isPropertyNode",
+	        value: function isPropertyNode(node) {
+	            return node.type === NodeType_1.NodeType.Property;
+	        }
+	    }, {
+	        key: "isVariableDeclaratorNode",
+	        value: function isVariableDeclaratorNode(node) {
+	            return node.type === NodeType_1.NodeType.VariableDeclarator;
+	        }
+	    }, {
+	        key: "parentize",
+	        value: function parentize(node) {
+	            var isRootNode = true;
+	            estraverse.replace(node, {
+	                enter: function enter(node, parentNode) {
+	                    Object.defineProperty(node, 'parentNode', {
+	                        configurable: true,
+	                        enumerable: true,
+	                        value: isRootNode ? NodeUtils.getProgramNode([node]) : parentNode || node,
+	                        writable: true
+	                    });
+	                    isRootNode = false;
+	                }
+	            });
+	        }
+	    }, {
+	        key: "prependNode",
+	        value: function prependNode(blockScopeBody, node) {
+	            if (!NodeUtils.validateNode(node)) {
+	                return;
+	            }
+	            blockScopeBody.unshift(node);
+	        }
+	    }, {
+	        key: "validateNode",
+	        value: function validateNode(node) {
+	            return !!node;
+	        }
+	    }]);
+
+	    return NodeUtils;
+	}();
+
+	NodeUtils.scopeNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression, NodeType_1.NodeType.MethodDefinition];
+	exports.NodeUtils = NodeUtils;
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var ConsoleOutputDisableExpressionNode = function (_Node_1$Node) {
+	    _inherits(ConsoleOutputDisableExpressionNode, _Node_1$Node);
+
+	    function ConsoleOutputDisableExpressionNode() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, ConsoleOutputDisableExpressionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ConsoleOutputDisableExpressionNode).call(this, options));
+
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(ConsoleOutputDisableExpressionNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                (function () {\n                    var _ = \'(\u0004\u0006\u0003\u0005[]\' + \'["filter"]["\u0007tructor"]\' + \'("return this")()\' + \'.\' + \'\u0003;\u0006\u0002\u0005\u0004};\' + \'_\u0003.log\u0001.in\' + \'fo\u0001.\' + \'war\' + \'n\u0001.er\' + \'r\' + \'or\u0001})();\' + \'\u0001\u0005_\u0002;\' + \'_\u0003\u0002function\' + \'\u0003\u0007ole\u0004\u0002 ()\' + \'{\u0005 = \u0006var \' + \'_\u0007cons\', \n                        Y, \n                        $;\n                    \n                    for (Y in $ = "\u0007\u0006\u0005\u0004\u0003\u0002\u0001") {\n                      var arr = _.split($[Y]);\n                      _ = arr.join(arr.pop());\n                    }\n                    \n                    []["filter"]["constructor"](_)();\n                })()\n            '));
+	        }
+	    }]);
+
+	    return ConsoleOutputDisableExpressionNode;
+	}(Node_1.Node);
+
+	exports.ConsoleOutputDisableExpressionNode = ConsoleOutputDisableExpressionNode;
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var AppendState_1 = __webpack_require__(8);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var Node = function () {
+	    function Node() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, Node);
+
+	        this.appendState = AppendState_1.AppendState.BeforeObfuscation;
+	        this.options = options;
+	    }
+
+	    _createClass(Node, [{
+	        key: "getAppendState",
+	        value: function getAppendState() {
+	            return this.appendState;
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            NodeUtils_1.NodeUtils.parentize(this.node);
+	            return this.node;
+	        }
+	    }, {
+	        key: "setNode",
+	        value: function setNode(node) {
+	            this.node = node;
+	        }
+	    }, {
+	        key: "updateNode",
+	        value: function updateNode() {
+	            this.node = this.getNodeStructure();
+	        }
+	    }]);
+
+	    return Node;
+	}();
+
+	exports.Node = Node;
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var DebugProtectionFunctionCallNode_1 = __webpack_require__(18);
+	var DebugProtectionFunctionIntervalNode_1 = __webpack_require__(19);
+	var DebugProtectionFunctionNode_1 = __webpack_require__(20);
+	var NodesGroup_1 = __webpack_require__(21);
+	var Utils_1 = __webpack_require__(10);
+
+	var DebugProtectionNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(DebugProtectionNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function DebugProtectionNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, DebugProtectionNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionNodesGroup).call(this, options));
+
+	        _this.debugProtectionFunctionIdentifier = Utils_1.Utils.getRandomVariableName();
+	        _this.nodes.set('debugProtectionFunctionNode', new DebugProtectionFunctionNode_1.DebugProtectionFunctionNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        _this.nodes.set('debugProtectionFunctionCallNode', new DebugProtectionFunctionCallNode_1.DebugProtectionFunctionCallNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        if (_this.options['debugProtectionInterval']) {
+	            _this.nodes.set('debugProtectionFunctionIntervalNode', new DebugProtectionFunctionIntervalNode_1.DebugProtectionFunctionIntervalNode(_this.debugProtectionFunctionIdentifier, _this.options));
+	        }
+	        return _this;
+	    }
+
+	    return DebugProtectionNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.DebugProtectionNodesGroup = DebugProtectionNodesGroup;
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var DebugProtectionFunctionCallNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionCallNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionCallNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionCallNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionCallNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionCallNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.ExpressionStatement,
+	                'expression': {
+	                    'type': NodeType_1.NodeType.CallExpression,
+	                    'callee': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': this.debugProtectionFunctionName
+	                    },
+	                    'arguments': []
+	                }
+	            };
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionCallNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionCallNode = DebugProtectionFunctionCallNode;
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var DebugProtectionFunctionIntervalNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionIntervalNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionIntervalNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionIntervalNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionIntervalNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionIntervalNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.appendNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.ExpressionStatement,
+	                'expression': {
+	                    'type': NodeType_1.NodeType.CallExpression,
+	                    'callee': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': 'setInterval'
+	                    },
+	                    'arguments': [{
+	                        'type': NodeType_1.NodeType.FunctionExpression,
+	                        'id': null,
+	                        'params': [],
+	                        'defaults': [],
+	                        'body': {
+	                            'type': NodeType_1.NodeType.BlockStatement,
+	                            'body': [{
+	                                'type': NodeType_1.NodeType.ExpressionStatement,
+	                                'expression': {
+	                                    'type': NodeType_1.NodeType.CallExpression,
+	                                    'callee': {
+	                                        'type': NodeType_1.NodeType.Identifier,
+	                                        'name': this.debugProtectionFunctionName
+	                                    },
+	                                    'arguments': []
+	                                }
+	                            }]
+	                        },
+	                        'generator': false,
+	                        'expression': false
+	                    }, {
+	                        'type': NodeType_1.NodeType.Literal,
+	                        'value': 4000,
+	                        'raw': '4000'
+	                    }]
+	                }
+	            };
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionIntervalNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionIntervalNode = DebugProtectionFunctionIntervalNode;
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var DebugProtectionFunctionNode = function (_Node_1$Node) {
+	    _inherits(DebugProtectionFunctionNode, _Node_1$Node);
+
+	    function DebugProtectionFunctionNode(debugProtectionFunctionName) {
+	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+	        _classCallCheck(this, DebugProtectionFunctionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DebugProtectionFunctionNode).call(this, options));
+
+	        _this.debugProtectionFunctionName = debugProtectionFunctionName;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(DebugProtectionFunctionNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            var programBodyLength = blockScopeNode.body.length,
+	                randomIndex = Utils_1.Utils.getRandomInteger(0, programBodyLength);
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
+	        }
+	    }, {
+	        key: 'getNodeIdentifier',
+	        value: function getNodeIdentifier() {
+	            return this.debugProtectionFunctionName;
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(esprima.parse('\n                var ' + this.debugProtectionFunctionName + ' = function () {\n                    function debuggerProtection (counter) {\n                        if ((\'\' + counter / counter)[\'length\'] !== 1 || counter % 20 === 0) {\n                            (function () {}.constructor(\'debugger\')());\n                        } else {\n                            [].filter.constructor(' + Utils_1.Utils.stringToJSFuck('debugger') + ')();\n                        }\n                        \n                        debuggerProtection(++counter);\n                    }\n                    \n                    try {\n                        debuggerProtection(0);\n                    } catch (y) {}\n                };\n            '));
+	        }
+	    }]);
+
+	    return DebugProtectionFunctionNode;
+	}(Node_1.Node);
+
+	exports.DebugProtectionFunctionNode = DebugProtectionFunctionNode;
+
+/***/ },
+/* 21 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var NodesGroup = function () {
+	    function NodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, NodesGroup);
+
+	        this.nodes = new Map();
+	        this.options = options;
+	    }
+
+	    _createClass(NodesGroup, [{
+	        key: "getNodes",
+	        value: function getNodes() {
+	            return this.nodes;
+	        }
+	    }]);
+
+	    return NodesGroup;
+	}();
+
+	exports.NodesGroup = NodesGroup;
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var FunctionDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(FunctionDeclarationObfuscator, _NodeObfuscator_1$Nod);
+
+	    function FunctionDeclarationObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, FunctionDeclarationObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.functionName = new Map();
+	        return _this;
+	    }
+
+	    _createClass(FunctionDeclarationObfuscator, [{
+	        key: "obfuscateNode",
+	        value: function obfuscateNode(functionDeclarationNode, parentNode) {
+	            if (parentNode.type === NodeType_1.NodeType.Program) {
+	                return;
+	            }
+	            this.replaceFunctionName(functionDeclarationNode);
+	            this.replaceFunctionCalls(functionDeclarationNode);
+	        }
+	    }, {
+	        key: "replaceFunctionName",
+	        value: function replaceFunctionName(functionDeclarationNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(functionDeclarationNode.id, {
+	                leave: function leave(node) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                        _this2.functionName.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                        node.name = _this2.functionName.get(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }, {
+	        key: "replaceFunctionCalls",
+	        value: function replaceFunctionCalls(functionDeclarationNode) {
+	            var _this3 = this;
+
+	            var scopeNode = NodeUtils_1.NodeUtils.getBlockScopeOfNode(functionDeclarationNode);
+	            estraverse.replace(scopeNode, {
+	                enter: function enter(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionName);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return FunctionDeclarationObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.FunctionDeclarationObfuscator = FunctionDeclarationObfuscator;
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var FunctionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(FunctionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function FunctionObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, FunctionObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(FunctionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.functionParams = new Map();
+	        return _this;
+	    }
+
+	    _createClass(FunctionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(functionNode) {
+	            this.replaceFunctionParams(functionNode);
+	            this.replaceFunctionParamsInBody(functionNode);
+	        }
+	    }, {
+	        key: 'replaceFunctionParams',
+	        value: function replaceFunctionParams(functionNode) {
+	            var _this2 = this;
+
+	            functionNode.params.forEach(function (paramsNode) {
+	                estraverse.replace(paramsNode, {
+	                    leave: function leave(node) {
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                            _this2.functionParams.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                            node.name = _this2.functionParams.get(node.name);
+	                            return;
+	                        }
+	                        return estraverse.VisitorOption.Skip;
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: 'replaceFunctionParamsInBody',
+	        value: function replaceFunctionParamsInBody(functionNode) {
+	            var _this3 = this;
+
+	            estraverse.replace(functionNode.body, {
+	                leave: function leave(node, parentNode) {
+	                    _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.functionParams);
+	                }
+	            });
+	        }
+	    }]);
+
+	    return FunctionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.FunctionObfuscator = FunctionObfuscator;
+
+/***/ },
+/* 24 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var LiteralObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(LiteralObfuscator, _NodeObfuscator_1$Nod);
+
+	    function LiteralObfuscator() {
+	        _classCallCheck(this, LiteralObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(LiteralObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(LiteralObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(literalNode, parentNode) {
+	            if (NodeUtils_1.NodeUtils.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+	                return;
+	            }
+	            if (literalNode['x-verbatim-property']) {
+	                return;
+	            }
+	            var content = void 0;
+	            switch (_typeof(literalNode.value)) {
+	                case 'boolean':
+	                    content = this.replaceLiteralBooleanByJSFuck(literalNode.value);
+	                    break;
+	                case 'number':
+	                    content = this.replaceLiteralNumberByHexadecimalValue(literalNode.value);
+	                    break;
+	                case 'string':
+	                    content = this.replaceLiteralValueByUnicodeValue(literalNode.value);
+	                    break;
+	                default:
+	                    return;
+	            }
+	            literalNode['x-verbatim-property'] = {
+	                content: content,
+	                precedence: escodegen.Precedence.Primary
+	            };
+	        }
+	    }]);
+
+	    return LiteralObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.LiteralObfuscator = LiteralObfuscator;
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+
+	var MemberExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(MemberExpressionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function MemberExpressionObfuscator() {
+	        _classCallCheck(this, MemberExpressionObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(MemberExpressionObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(MemberExpressionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(memberExpressionNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(memberExpressionNode.property, {
+	                leave: function leave(node, parentNode) {
+	                    if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
+	                        _this2.literalNodeController(node);
+	                        return;
+	                    }
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+	                        if (memberExpressionNode.computed) {
+	                            return;
+	                        }
+	                        memberExpressionNode.computed = true;
+	                        _this2.identifierNodeController(node);
+	                    }
+	                }
+	            });
+	        }
+	    }, {
+	        key: 'identifierNodeController',
+	        value: function identifierNodeController(node) {
+	            var nodeValue = node.name,
+	                literalNode = {
+	                raw: '\'' + nodeValue + '\'',
+	                'x-verbatim-property': {
+	                    content: this.replaceLiteralValueByUnicodeValue(nodeValue),
+	                    precedence: escodegen.Precedence.Primary
+	                },
+	                type: NodeType_1.NodeType.Literal,
+	                value: nodeValue
+	            };
+	            delete node.name;
+	            Object.assign(node, literalNode);
+	        }
+	    }, {
+	        key: 'literalNodeController',
+	        value: function literalNodeController(node) {
+	            switch (_typeof(node.value)) {
+	                case 'string':
+	                    if (node['x-verbatim-property']) {
+	                        break;
+	                    }
+	                    node['x-verbatim-property'] = {
+	                        content: this.replaceLiteralValueByUnicodeValue(node.value),
+	                        precedence: escodegen.Precedence.Primary
+	                    };
+	                    break;
+	                default:
+	                    break;
+	            }
+	        }
+	    }]);
+
+	    return MemberExpressionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.MemberExpressionObfuscator = MemberExpressionObfuscator;
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var MethodDefinitionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(MethodDefinitionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function MethodDefinitionObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, MethodDefinitionObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(MethodDefinitionObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.ignoredNames = ['constructor'];
+	        return _this;
+	    }
+
+	    _createClass(MethodDefinitionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(methodDefinitionNode, parentNode) {
+	            this.replaceMethodName(methodDefinitionNode);
+	        }
+	    }, {
+	        key: 'replaceMethodName',
+	        value: function replaceMethodName(methodDefinitionNode) {
+	            var _this2 = this;
+
+	            estraverse.replace(methodDefinitionNode.key, {
+	                leave: function leave(node) {
+	                    if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !Utils_1.Utils.arrayContains(_this2.ignoredNames, node.name) && methodDefinitionNode.computed === false) {
+	                        methodDefinitionNode.computed = true;
+	                        node.name = _this2.replaceLiteralValueByUnicodeValue(node.name);
+	                        return;
+	                    }
+	                    return estraverse.VisitorOption.Skip;
+	                }
+	            });
+	        }
+	    }]);
+
+	    return MethodDefinitionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.MethodDefinitionObfuscator = MethodDefinitionObfuscator;
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var ObjectExpressionObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(ObjectExpressionObfuscator, _NodeObfuscator_1$Nod);
+
+	    function ObjectExpressionObfuscator() {
+	        _classCallCheck(this, ObjectExpressionObfuscator);
+
+	        return _possibleConstructorReturn(this, Object.getPrototypeOf(ObjectExpressionObfuscator).apply(this, arguments));
+	    }
+
+	    _createClass(ObjectExpressionObfuscator, [{
+	        key: 'obfuscateNode',
+	        value: function obfuscateNode(objectExpressionNode) {
+	            var _this2 = this;
+
+	            objectExpressionNode.properties.forEach(function (property) {
+	                estraverse.replace(property.key, {
+	                    leave: function leave(node, parentNode) {
+	                        if (NodeUtils_1.NodeUtils.isLiteralNode(node)) {
+	                            _this2.literalNodeController(node);
+	                            return;
+	                        }
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node)) {
+	                            _this2.identifierNodeController(node);
+	                        }
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: 'literalNodeController',
+	        value: function literalNodeController(node) {
+	            switch (_typeof(node.value)) {
+	                case 'string':
+	                    if (node['x-verbatim-property']) {
+	                        break;
+	                    }
+	                    node['x-verbatim-property'] = {
+	                        content: Utils_1.Utils.stringToUnicode(node.value),
+	                        precedence: escodegen.Precedence.Primary
+	                    };
+	                    break;
+	                default:
+	                    break;
+	            }
+	        }
+	    }, {
+	        key: 'identifierNodeController',
+	        value: function identifierNodeController(node) {
+	            var nodeValue = node.name,
+	                literalNode = {
+	                raw: '\'' + nodeValue + '\'',
+	                'x-verbatim-property': {
+	                    content: Utils_1.Utils.stringToUnicode(nodeValue),
+	                    precedence: escodegen.Precedence.Primary
+	                },
+	                type: NodeType_1.NodeType.Literal,
+	                value: nodeValue
+	            };
+	            delete node.name;
+	            Object.assign(node, literalNode);
+	        }
+	    }]);
+
+	    return ObjectExpressionObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.ObjectExpressionObfuscator = ObjectExpressionObfuscator;
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodesGroup_1 = __webpack_require__(21);
+	var SelfDefendingUnicodeNode_1 = __webpack_require__(29);
+
+	var SelfDefendingNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(SelfDefendingNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function SelfDefendingNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, SelfDefendingNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingNodesGroup).call(this, options));
+
+	        _this.nodes.set('selfDefendingUnicodeNode', new SelfDefendingUnicodeNode_1.SelfDefendingUnicodeNode(_this.options));
+	        return _this;
+	    }
+
+	    return SelfDefendingNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.SelfDefendingNodesGroup = SelfDefendingNodesGroup;
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var SelfDefendingUnicodeNode = function (_Node_1$Node) {
+	    _inherits(SelfDefendingUnicodeNode, _Node_1$Node);
+
+	    function SelfDefendingUnicodeNode() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, SelfDefendingUnicodeNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SelfDefendingUnicodeNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(SelfDefendingUnicodeNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            var programBodyLength = blockScopeNode.body.length,
+	                randomIndex = 0;
+	            if (programBodyLength > 2) {
+	                randomIndex = Utils_1.Utils.getRandomInteger(programBodyLength / 2, programBodyLength - 1);
+	            }
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), randomIndex);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var node = esprima.parse(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {                                \n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";},\n                        func2 = function () {\n                            return 'window';\n                        };\n                \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? Function(" + Utils_1.Utils.stringToUnicode("return/(\\\\[x|u](\\w){2,4})+/") + ")().test(func2.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET));
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return SelfDefendingUnicodeNode;
+	}(Node_1.Node);
+
+	exports.SelfDefendingUnicodeNode = SelfDefendingUnicodeNode;
+
+/***/ },
+/* 30 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	exports.NO_CUSTOM_NODES_PRESET = Object.freeze({
+	    compact: true,
+	    debugProtection: false,
+	    debugProtectionInterval: false,
+	    disableConsoleOutput: false,
+	    encodeUnicodeLiterals: false,
+	    reservedNames: [],
+	    rotateUnicodeArray: false,
+	    selfDefending: false,
+	    unicodeArray: false,
+	    unicodeArrayThreshold: 0,
+	    wrapUnicodeArrayCalls: false
+	});
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var NodesGroup_1 = __webpack_require__(21);
+	var UnicodeArrayCallsWrapper_1 = __webpack_require__(32);
+	var UnicodeArrayDecodeNode_1 = __webpack_require__(33);
+	var UnicodeArrayNode_1 = __webpack_require__(34);
+	var UnicodeArrayRotateFunctionNode_1 = __webpack_require__(35);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayNodesGroup = function (_NodesGroup_1$NodesGr) {
+	    _inherits(UnicodeArrayNodesGroup, _NodesGroup_1$NodesGr);
+
+	    function UnicodeArrayNodesGroup() {
+	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
+
+	        _classCallCheck(this, UnicodeArrayNodesGroup);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNodesGroup).call(this, options));
+
+	        _this.unicodeArrayName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
+	        _this.unicodeArrayTranslatorName = Utils_1.Utils.getRandomVariableName(UnicodeArrayNode_1.UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH);
+	        _this.unicodeArrayRotateValue = _this.options['rotateUnicodeArray'] ? Utils_1.Utils.getRandomInteger(100, 500) : 0;
+	        var unicodeArrayNode = new UnicodeArrayNode_1.UnicodeArrayNode(_this.unicodeArrayName, _this.unicodeArrayRotateValue, _this.options),
+	            unicodeArray = unicodeArrayNode.getNodeData();
+	        _this.nodes.set('unicodeArrayNode', unicodeArrayNode);
+	        if (_this.options['wrapUnicodeArrayCalls']) {
+	            _this.nodes.set('unicodeArrayCallsWrapper', new UnicodeArrayCallsWrapper_1.UnicodeArrayCallsWrapper(_this.unicodeArrayTranslatorName, _this.unicodeArrayName, unicodeArray, _this.options));
+	        }
+	        if (_this.options['encodeUnicodeLiterals']) {
+	            _this.nodes.set('unicodeArrayDecodeNode', new UnicodeArrayDecodeNode_1.UnicodeArrayDecodeNode(_this.unicodeArrayName, unicodeArray, _this.options));
+	        }
+	        if (_this.options['rotateUnicodeArray']) {
+	            _this.nodes.set('unicodeArrayRotateFunctionNode', new UnicodeArrayRotateFunctionNode_1.UnicodeArrayRotateFunctionNode(_this.unicodeArrayName, unicodeArray, _this.unicodeArrayRotateValue, _this.options));
+	        }
+	        return _this;
+	    }
+
+	    return UnicodeArrayNodesGroup;
+	}(NodesGroup_1.NodesGroup);
+
+	exports.UnicodeArrayNodesGroup = UnicodeArrayNodesGroup;
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayCallsWrapper = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayCallsWrapper, _Node_1$Node);
+
+	    function UnicodeArrayCallsWrapper(unicodeArrayCallsWrapperName, unicodeArrayName, unicodeArray) {
+	        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
+
+	        _classCallCheck(this, UnicodeArrayCallsWrapper);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayCallsWrapper).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayCallsWrapperName = unicodeArrayCallsWrapperName;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayCallsWrapper, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: "getNodeIdentifier",
+	        value: function getNodeIdentifier() {
+	            return this.unicodeArrayCallsWrapperName;
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayCallsWrapper.prototype), "getNode", this).call(this);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var keyName = Utils_1.Utils.getRandomVariableName(),
+	                node = void 0;
+	            node = esprima.parse("\n            var " + this.unicodeArrayCallsWrapperName + " = function (" + keyName + ") {\n                return " + this.unicodeArrayName + "[parseInt(" + keyName + ", 0x010)];\n            };\n        ");
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayCallsWrapper;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayCallsWrapper = UnicodeArrayCallsWrapper;
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayDecodeNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayDecodeNode, _Node_1$Node);
+
+	    function UnicodeArrayDecodeNode(unicodeArrayName, unicodeArray) {
+	        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+	        _classCallCheck(this, UnicodeArrayDecodeNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayDecodeNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayDecodeNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: 'getNode',
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayDecodeNode.prototype), 'getNode', this).call(this);
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            var environmentName = Utils_1.Utils.getRandomVariableName(),
+	                forLoopFunctionName = Utils_1.Utils.getRandomVariableName(),
+	                indexVariableName = Utils_1.Utils.getRandomVariableName(),
+	                tempArrayName = Utils_1.Utils.getRandomVariableName();
+	            var code = '',
+	                node = void 0;
+	            if (this.options['selfDefending']) {
+	                code = '\n                var ' + environmentName + ' = function(){return ' + Utils_1.Utils.stringToUnicode('dev') + ';};\n                   \n                Function(' + Utils_1.Utils.stringToUnicode('return/\\w+ *\\(\\) *{\\w+ *[\'|"].+[\'|"];? *}/') + ')()[' + Utils_1.Utils.stringToUnicode('test') + '](' + environmentName + '[' + Utils_1.Utils.stringToUnicode('toString') + ']()) !== ' + JSFuck_1.JSFuck.True + ' && !' + this.unicodeArrayName + '++ ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.True + '){}\')() : Function(' + Utils_1.Utils.stringToUnicode('a') + ', atob(' + Utils_1.Utils.stringToUnicode(Utils_1.Utils.btoa('a.call()')) + '))(' + forLoopFunctionName + ') ? [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')() : [][\'filter\'][\'constructor\'](' + Utils_1.Utils.stringToJSFuck('while') + ' + \'(' + JSFuck_1.JSFuck.False + '){}\')();\n            ';
+	            } else {
+	                code = forLoopFunctionName + '();';
+	            }
+	            node = esprima.parse('\n            (function () {\n                ' + JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate('\n                    (function () {\n                        var object = [][\'filter\'][\'constructor\'](\'return this\')();\n                        var chars = \'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\';\n            \n                        object.atob || (\n                            object.atob = function(input) {\n                                var str = String(input).replace(/=+$/, \'\');\n                                for (\n                                    var bc = 0, bs, buffer, idx = 0, output = \'\';\n                                    buffer = str.charAt(idx++);\n                                    ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n                                        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n                                ) {\n                                    buffer = chars.indexOf(buffer);\n                                }\n                            return output;\n                        });\n                    })();\n                ', NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET) + '\n              \n                var ' + forLoopFunctionName + ' = function () {\n                    var ' + tempArrayName + ' = [];\n                    \n                    for (var ' + indexVariableName + ' in ' + this.unicodeArrayName + ') {\n                        ' + tempArrayName + '[' + Utils_1.Utils.stringToUnicode('push') + '](decodeURI(atob(' + this.unicodeArrayName + '[' + indexVariableName + '])));\n                    }\n                    \n                    ' + this.unicodeArrayName + ' = ' + tempArrayName + ';\n                };\n                \n                ' + code + '\n            })();\n        ');
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayDecodeNode;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayDecodeNode = UnicodeArrayDecodeNode;
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var escodegen = __webpack_require__(4);
+	var AppendState_1 = __webpack_require__(8);
+	var NodeType_1 = __webpack_require__(9);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayNode, _Node_1$Node);
+
+	    function UnicodeArrayNode(unicodeArrayName) {
+	        var unicodeArrayRotateValue = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
+	        var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+	        _classCallCheck(this, UnicodeArrayNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArray = [];
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayNode, [{
+	        key: 'appendNode',
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.prependNode(blockScopeNode.body, this.getNode());
+	        }
+	    }, {
+	        key: 'getNodeIdentifier',
+	        value: function getNodeIdentifier() {
+	            return this.unicodeArrayName;
+	        }
+	    }, {
+	        key: 'getNodeData',
+	        value: function getNodeData() {
+	            return this.unicodeArray;
+	        }
+	    }, {
+	        key: 'getNode',
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            Utils_1.Utils.arrayRotate(this.unicodeArray, this.unicodeArrayRotateValue);
+	            this.updateNode();
+	            return _get(Object.getPrototypeOf(UnicodeArrayNode.prototype), 'getNode', this).call(this);
+	        }
+	    }, {
+	        key: 'updateNodeData',
+	        value: function updateNodeData(data) {
+	            this.unicodeArray.push(data);
+	        }
+	    }, {
+	        key: 'getNodeStructure',
+	        value: function getNodeStructure() {
+	            return {
+	                'type': NodeType_1.NodeType.VariableDeclaration,
+	                'declarations': [{
+	                    'type': NodeType_1.NodeType.VariableDeclarator,
+	                    'id': {
+	                        'type': NodeType_1.NodeType.Identifier,
+	                        'name': this.unicodeArrayName
+	                    },
+	                    'init': {
+	                        'type': NodeType_1.NodeType.ArrayExpression,
+	                        'elements': this.unicodeArray.map(function (value) {
+	                            return {
+	                                'type': NodeType_1.NodeType.Literal,
+	                                'value': value,
+	                                'raw': '\'' + value + '\'',
+	                                'x-verbatim-property': {
+	                                    'content': value,
+	                                    precedence: escodegen.Precedence.Primary
+	                                }
+	                            };
+	                        })
+	                    }
+	                }],
+	                'kind': 'var'
+	            };
+	        }
+	    }]);
+
+	    return UnicodeArrayNode;
+	}(Node_1.Node);
+
+	UnicodeArrayNode.UNICODE_ARRAY_RANDOM_LENGTH = 4;
+	exports.UnicodeArrayNode = UnicodeArrayNode;
+
+/***/ },
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var esprima = __webpack_require__(3);
+	var AppendState_1 = __webpack_require__(8);
+	var JSFuck_1 = __webpack_require__(11);
+	var NoCustomNodesPreset_1 = __webpack_require__(30);
+	var JavaScriptObfuscator_1 = __webpack_require__(2);
+	var Node_1 = __webpack_require__(16);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var UnicodeArrayRotateFunctionNode = function (_Node_1$Node) {
+	    _inherits(UnicodeArrayRotateFunctionNode, _Node_1$Node);
+
+	    function UnicodeArrayRotateFunctionNode(unicodeArrayName, unicodeArray, unicodeArrayRotateValue) {
+	        var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];
+
+	        _classCallCheck(this, UnicodeArrayRotateFunctionNode);
+
+	        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(UnicodeArrayRotateFunctionNode).call(this, options));
+
+	        _this.appendState = AppendState_1.AppendState.AfterObfuscation;
+	        _this.unicodeArrayName = unicodeArrayName;
+	        _this.unicodeArray = unicodeArray;
+	        _this.unicodeArrayRotateValue = unicodeArrayRotateValue;
+	        _this.node = _this.getNodeStructure();
+	        return _this;
+	    }
+
+	    _createClass(UnicodeArrayRotateFunctionNode, [{
+	        key: "appendNode",
+	        value: function appendNode(blockScopeNode) {
+	            NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
+	        }
+	    }, {
+	        key: "getNode",
+	        value: function getNode() {
+	            if (!this.unicodeArray.length) {
+	                return;
+	            }
+	            return _get(Object.getPrototypeOf(UnicodeArrayRotateFunctionNode.prototype), "getNode", this).call(this);
+	        }
+	    }, {
+	        key: "getNodeStructure",
+	        value: function getNodeStructure() {
+	            var arrayName = Utils_1.Utils.getRandomVariableName(),
+	                code = '',
+	                timesName = Utils_1.Utils.getRandomVariableName(),
+	                timesArgumentName = Utils_1.Utils.getRandomVariableName(),
+	                whileFunctionName = Utils_1.Utils.getRandomVariableName(),
+	                node = void 0;
+	            if (this.options['selfDefending']) {
+	                code = JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate("\n                (function () {\n                    var func = function(){return " + Utils_1.Utils.stringToUnicode('dev') + ";};\n                                        \n                    !Function(" + Utils_1.Utils.stringToUnicode("return/\\w+ *\\(\\) *{\\w+ *['|\"].+['|\"];? *}/") + ")().test(func.toString()) ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.True + "){}')() : Function(" + Utils_1.Utils.stringToUnicode('a') + ", " + Utils_1.Utils.stringToUnicode('b') + ", " + Utils_1.Utils.stringToUnicode('a(++b)') + ")(" + whileFunctionName + ", " + timesName + ") ? []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')() : []['filter']['constructor'](" + Utils_1.Utils.stringToJSFuck('while') + " + '(" + JSFuck_1.JSFuck.False + "){}')();\n                })();\n            ", NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET);
+	            } else {
+	                code = whileFunctionName + "(++" + timesName + ")";
+	            }
+	            node = esprima.parse("\n            (function (" + arrayName + ", " + timesName + ") {\n                var " + whileFunctionName + " = function (" + timesArgumentName + ") {\n                    while (--" + timesArgumentName + ") {\n                        " + arrayName + "[" + Utils_1.Utils.stringToUnicode('push') + "](" + arrayName + "[" + Utils_1.Utils.stringToUnicode('shift') + "]());\n                    }\n                };\n                \n                " + code + "\n            })(" + this.unicodeArrayName + ", 0x" + Utils_1.Utils.decToHex(this.unicodeArrayRotateValue) + ");\n        ");
+	            NodeUtils_1.NodeUtils.addXVerbatimPropertyToLiterals(node);
+	            return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node);
+	        }
+	    }]);
+
+	    return UnicodeArrayRotateFunctionNode;
+	}(Node_1.Node);
+
+	exports.UnicodeArrayRotateFunctionNode = UnicodeArrayRotateFunctionNode;
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var estraverse = __webpack_require__(7);
+	var NodeType_1 = __webpack_require__(9);
+	var NodeObfuscator_1 = __webpack_require__(13);
+	var NodeUtils_1 = __webpack_require__(14);
+	var Utils_1 = __webpack_require__(10);
+
+	var VariableDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
+	    _inherits(VariableDeclarationObfuscator, _NodeObfuscator_1$Nod);
+
+	    function VariableDeclarationObfuscator() {
+	        var _Object$getPrototypeO;
+
+	        _classCallCheck(this, VariableDeclarationObfuscator);
+
+	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+	            args[_key] = arguments[_key];
+	        }
+
+	        var _this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(VariableDeclarationObfuscator)).call.apply(_Object$getPrototypeO, [this].concat(args)));
+
+	        _this.variableNames = new Map();
+	        return _this;
+	    }
+
+	    _createClass(VariableDeclarationObfuscator, [{
+	        key: "obfuscateNode",
+	        value: function obfuscateNode(variableDeclarationNode, parentNode) {
+	            if (parentNode.type === NodeType_1.NodeType.Program) {
+	                return;
+	            }
+	            this.replaceVariableName(variableDeclarationNode);
+	            this.replaceVariableCalls(variableDeclarationNode, parentNode);
+	        }
+	    }, {
+	        key: "replaceVariableName",
+	        value: function replaceVariableName(variableDeclarationNode) {
+	            var _this2 = this;
+
+	            variableDeclarationNode.declarations.forEach(function (declarationNode) {
+	                estraverse.replace(declarationNode.id, {
+	                    enter: function enter(node) {
+	                        if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && !_this2.isReservedName(node.name)) {
+	                            _this2.variableNames.set(node.name, Utils_1.Utils.getRandomVariableName());
+	                            node.name = _this2.variableNames.get(node.name);
+	                            return;
+	                        }
+	                        return estraverse.VisitorOption.Skip;
+	                    }
+	                });
+	            });
+	        }
+	    }, {
+	        key: "replaceVariableCalls",
+	        value: function replaceVariableCalls(variableDeclarationNode, variableParentNode) {
+	            var _this3 = this;
+
+	            var scopeNode = void 0;
+	            scopeNode = variableDeclarationNode.kind === 'var' ? NodeUtils_1.NodeUtils.getBlockScopeOfNode(variableDeclarationNode) : variableParentNode;
+	            var isNodeAfterVariableDeclaratorFlag = false;
+	            estraverse.replace(scopeNode, {
+	                enter: function enter(node, parentNode) {
+	                    var functionNodes = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression];
+	                    if (Utils_1.Utils.arrayContains(functionNodes, node.type)) {
+	                        estraverse.replace(node, {
+	                            enter: function enter(node, parentNode) {
+	                                _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
+	                            }
+	                        });
+	                    }
+	                    if (node === variableDeclarationNode) {
+	                        isNodeAfterVariableDeclaratorFlag = true;
+	                    }
+	                    if (isNodeAfterVariableDeclaratorFlag) {
+	                        _this3.replaceNodeIdentifierByNewValue(node, parentNode, _this3.variableNames);
+	                    }
+	                }
+	            });
+	        }
+	    }]);
+
+	    return VariableDeclarationObfuscator;
+	}(NodeObfuscator_1.NodeObfuscator);
+
+	exports.VariableDeclarationObfuscator = VariableDeclarationObfuscator;
+
+/***/ },
+/* 37 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var OptionsNormalizer = function () {
+	    function OptionsNormalizer() {
+	        _classCallCheck(this, OptionsNormalizer);
+	    }
+
+	    _createClass(OptionsNormalizer, null, [{
+	        key: 'normalize',
+	        value: function normalize(options) {
+	            var normalizedOptions = Object.assign({}, options);
+	            normalizedOptions = OptionsNormalizer.unicodeArrayRule(normalizedOptions);
+	            normalizedOptions = OptionsNormalizer.unicodeArrayThresholdRule(normalizedOptions);
+	            normalizedOptions = OptionsNormalizer.selfDefendingRule(normalizedOptions);
+	            return normalizedOptions;
+	        }
+	    }, {
+	        key: 'selfDefendingRule',
+	        value: function selfDefendingRule(options) {
+	            if (options['selfDefending']) {
+	                Object.assign(options, OptionsNormalizer.SELF_DEFENDING_OPTIONS);
+	            }
+	            return options;
+	        }
+	    }, {
+	        key: 'unicodeArrayRule',
+	        value: function unicodeArrayRule(options) {
+	            if (!options['unicodeArray']) {
+	                Object.assign(options, OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS);
+	            }
+	            return options;
+	        }
+	    }, {
+	        key: 'unicodeArrayThresholdRule',
+	        value: function unicodeArrayThresholdRule(options) {
+	            var minValue = 0,
+	                maxValue = 1;
+	            options['unicodeArrayThreshold'] = Math.min(Math.max(options['unicodeArrayThreshold'], minValue), maxValue);
+	            return options;
+	        }
+	    }]);
+
+	    return OptionsNormalizer;
+	}();
+
+	OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS = {
+	    encodeUnicodeLiterals: false,
+	    rotateUnicodeArray: false,
+	    unicodeArray: false,
+	    unicodeArrayThreshold: 0,
+	    wrapUnicodeArrayCalls: false
+	};
+	OptionsNormalizer.SELF_DEFENDING_OPTIONS = {
+	    compact: true,
+	    selfDefending: true
+	};
+	exports.OptionsNormalizer = OptionsNormalizer;
+
+/***/ }
+/******/ ]);

package.json

@@ -20,10 +20,14 @@
   },
   "devDependencies": {
     "babel-cli": "^6.9.0",
+    "babel-loader": "^6.2.4",
     "babel-polyfill": "^6.9.1",
     "babel-preset-es2015": "^6.9.0",
     "lite-server": "^1.3.1",
-    "typings": "^0.8.1"
+    "ts-loader": "^0.8.2",
+    "typings": "^0.8.1",
+    "webpack": "^1.13.1",
+    "webpack-node-externals": "^1.2.0"
   },
   "repository": {
     "type": "git",
@@ -32,9 +36,10 @@
   "scripts": {
     "tsc": "tsc",
     "tsc:w": "tsc -w",
+    "webpack": "node_modules/.bin/webpack",
     "lite": "lite-server",
     "start": "concurrent \"npm run tsc:w\" \"npm run lite\" ",
-    "tests": "node dist/tests/dev-test.js"
+    "tests": "node dist/tests/test-bundle.js"
   },
   "author": {
     "name": "sanex3339"

webpack.config.js

@@ -0,0 +1,26 @@
+var nodeExternals = require('webpack-node-externals'),
+    webpack = require("webpack");
+
+module.exports = {
+    entry: {
+        'index': './index.ts',
+        'tests/test-bundle': './tests/dev-test.ts'
+    },
+    target: 'node',
+    externals: [nodeExternals()],
+    module: {
+        loaders: [
+            { test: /\.ts(x?)$/, loader: 'babel-loader!ts-loader' }
+        ]
+    },
+    resolve: {
+        extensions: ['', '.ts'],
+        modulesDirectories: ['./src', './node_modules']
+    },
+    output: {
+        path: './dist',
+        filename: '[name].js',
+        libraryTarget:  "commonjs2",
+        library: "JavaScriptObfuscator"
+    }
+};