js-confuser 1.7.3 → 2.0.0-alpha.0

package/dist/transforms/minify.js

@@ -1,491 +1,486 @@
 "use strict";
 
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-var _transform = _interopRequireDefault(require("./transform"));
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _order = require("../order");
-var _gen = require("../util/gen");
-var _insert = require("../util/insert");
-var _compare = require("../util/compare");
-var _traverse = require("../traverse");
-var _assert = require("assert");
-var _scope = require("../util/scope");
-var _template = _interopRequireDefault(require("../templates/template"));
-var _globals = require("../templates/globals");
-var _identifiers = require("../util/identifiers");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var _astUtils = require("../utils/ast-utils");
+var _constants = require("../constants");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var identifierMap = new Map();
+identifierMap.set("undefined", function () {
+  return t.unaryExpression("void", t.numericLiteral(0));
+});
+identifierMap.set("Infinity", function () {
+  return t.binaryExpression("/", t.numericLiteral(1), t.numericLiteral(0));
+});
+
 /**
- * Basic transformations to reduce code size.
+ * Minify removes unnecessary code and shortens the length for file size.
  *
- * Examples:
- * - `if(a) { b() }` **->** `a && b()`
- * - `if(a){b()}else{c()}` **->** `a?b():c()`
- * - `x['y']` **->** `x.y`
+ * - Dead code elimination
+ * - Variable grouping
+ * - Constant folding
+ * - Shorten literals: True to !0, False to !1, Infinity to 1/0, Undefined to void 0
+ * - Remove unused variables, functions
  */
-class Minify extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.Minify);
-    /**
-     * A helper function that is introduced preserve function semantics
-     */
-    _defineProperty(this, "arrowFunctionName", void 0);
-  }
-  match(object, parents) {
-    return object.hasOwnProperty("type");
-  }
-  transform(object, parents) {
-    if ((0, _scope.isLexicalScope)(object)) {
-      return () => {
-        var body = object.type == "SwitchCase" ? object.consequent : (0, _insert.getBlockBody)(object);
-        var earlyReturn = body.length;
-        var fnDecs = [];
-        body.forEach((stmt, i) => {
-          if (stmt.type === "ReturnStatement" || stmt.type === "BreakStatement" || stmt.type === "ContinueStatement" || stmt.type === "ThrowStatement") {
-            if (earlyReturn > i + 1) {
-              earlyReturn = i + 1;
-            }
-          }
-          if (stmt.type == "FunctionDeclaration") {
-            fnDecs.push([stmt, i]);
-          }
-        });
-        if (earlyReturn < body.length) {
-          body.length = earlyReturn;
-          body.push(...fnDecs.filter(x => x[1] >= earlyReturn).map(x => x[0]));
-        }
-
-        // Now combine ExpressionStatements
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.Minify);
+  return {
+    visitor: {
+      Program: function Program(path) {
+        path.scope.crawl();
+      },
+      // var a; var b; -> var a,b;
+      VariableDeclaration: {
+        exit: function exit(path) {
+          if (typeof path.key !== "number") return;
+          var kind = path.node.kind;
 
-        if (body.length > 1) {
-          var exprs = [];
-          var startIndex = -1;
-          var sequences = [];
-          body.forEach((stmt, i) => {
-            if (stmt.type == "ExpressionStatement" && !stmt.directive) {
-              exprs.push(stmt.expression);
-              if (startIndex == -1) {
-                startIndex = i;
+          // get declaration after this
+          var nextDeclaration = path.getSibling(path.key + 1);
+          if (nextDeclaration.isVariableDeclaration({
+            kind: kind
+          })) {
+            var _nextDeclaration$node;
+            // Add bindings back
+            var addBindingsToScope = function addBindingsToScope(scope) {
+              for (var name in bindings) {
+                var binding = bindings[name];
+                if (binding) {
+                  binding.path = newBindingIdentifierPaths[name];
+                  scope.bindings[name] = binding;
+                }
               }
-            } else {
-              if (exprs.length) {
-                sequences.push({
-                  exprs: exprs,
-                  index: startIndex
-                });
+            };
+            var declarations = path.get("declarations");
+
+            // Preserve bindings!
+            // This is important for dead code elimination
+            var bindings = Object.create(null);
+            var _iterator = _createForOfIteratorHelper(declarations),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var declaration = _step.value;
+                for (var _i = 0, _Object$values = Object.values(declaration.getBindingIdentifierPaths()); _i < _Object$values.length; _i++) {
+                  var idPath = _Object$values[_i];
+                  bindings[idPath.node.name] = idPath.scope.getBinding(idPath.node.name);
+                }
               }
-              exprs = [];
-              startIndex = -1;
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
             }
-          });
-          if (exprs.length) {
-            sequences.push({
-              exprs: exprs,
-              index: startIndex
-            });
-          }
-          sequences.reverse().forEach(seq => {
-            (0, _assert.ok)(seq.index != -1);
-            body.splice(seq.index, seq.exprs.length, (0, _gen.ExpressionStatement)(seq.exprs.length == 1 ? seq.exprs[0] : (0, _gen.SequenceExpression)(seq.exprs)));
-          });
-        }
+            (_nextDeclaration$node = nextDeclaration.node.declarations).unshift.apply(_nextDeclaration$node, _toConsumableArray(declarations.map(function (x) {
+              return x.node;
+            })));
+            var newBindingIdentifierPaths = nextDeclaration.getBindingIdentifierPaths();
 
-        // Unnecessary return
-        if (parents[0] && (0, _insert.isVarContext)(parents[0]) && body.length && body[body.length - 1]) {
-          var last = body[body.length - 1];
-          if (last.type == "ReturnStatement") {
-            var isUndefined = last.argument == null;
-            if (isUndefined) {
-              body.pop();
+            // path.remove() unfortunately removes the bindings
+            // We must perverse the entire binding object (referencePaths, constantViolations, etc)
+            // and re-add them to the new scope
+            path.remove();
+            if (kind === "var") {
+              addBindingsToScope((0, _astUtils.getParentFunctionOrProgram)(path).scope);
             }
+            addBindingsToScope(path.scope);
           }
         }
-
-        // Variable declaration grouping
-        // var a = 1;
-        // var b = 1;
-        // var c = 1;
-        //
-        // var a=1,b=1,c=1;
-        var lastDec = null;
-        var remove = [];
-        body.forEach((x, i) => {
-          if (x.type === "VariableDeclaration") {
-            if (!lastDec || lastDec.kind !== x.kind || !lastDec.declarations.length) {
-              lastDec = x;
-            } else {
-              lastDec.declarations.push(...(0, _insert.clone)(x.declarations));
-              remove.unshift(i);
-            }
+      },
+      // true -> !0, false -> !1
+      BooleanLiteral: {
+        exit: function exit(path) {
+          if (path.node.value) {
+            path.replaceWith(t.unaryExpression("!", t.numericLiteral(0)));
           } else {
-            lastDec = null;
+            path.replaceWith(t.unaryExpression("!", t.numericLiteral(1)));
           }
-        });
-        remove.forEach(x => {
-          body.splice(x, 1);
-        });
-      };
-    }
-
-    /**
-     * ES6 and higher only
-     * - `function(){}` -> `()=>{}`
-     * - `function abc(){}` -> `var abc = ()=>{}`
-     */
-    if (!this.options.es5 && (object.type == "FunctionExpression" || object.type == "FunctionDeclaration")) {
-      return () => {
-        // Don't touch `{get key(){...}}`
-        var propIndex = parents.findIndex(x => x.type == "Property" || x.type == "MethodDefinition");
-        if (propIndex !== -1) {
-          if (parents[propIndex].value === (parents[propIndex - 1] || object)) {
-            if (parents[propIndex].kind !== "init" || parents[propIndex].method) {
-              return;
-            }
+        }
+      },
+      // !"" -> !1
+      UnaryExpression: {
+        exit: function exit(path) {
+          if (path.node.operator === "!") {
+            var argument = path.get("argument");
+            if (argument.isNumericLiteral()) return;
+            var value = argument.evaluateTruthy();
+            var parent = (0, _astUtils.getParentFunctionOrProgram)(path);
+            if (parent && parent.node[_constants.UNSAFE]) return;
+            if (value === undefined) return;
+            path.replaceWith(t.unaryExpression("!", t.numericLiteral(value ? 1 : 0)));
           }
         }
-        if (object.type === "FunctionDeclaration") {
-          var body = parents[0];
-          if (!Array.isArray(body)) {
-            return;
+      },
+      // a["key"] -> a.key
+      MemberExpression: {
+        exit: function exit(path) {
+          if (!path.node.computed) return;
+          var property = path.get("property");
+          if (!property.isStringLiteral()) return;
+          var key = property.node.value;
+          if (!t.isValidIdentifier(key)) return;
+          path.node.computed = false;
+          path.node.property = t.identifier(key);
+        }
+      },
+      // {["key"]: 1} -> {key: 1}
+      // {"key": 1} -> {key: 1}
+      ObjectProperty: {
+        exit: function exit(path) {
+          var key = path.get("key");
+          if (path.node.computed && key.isStringLiteral()) {
+            path.node.computed = false;
           }
-          var index = body.indexOf(object);
-          if (index == -1) {
-            return;
+          if (!path.node.computed && key.isStringLiteral() && t.isValidIdentifier(key.node.value)) {
+            if (identifierMap.has(key.node.value)) {
+              path.node.computed = true;
+              key.replaceWith(identifierMap.get(key.node.value)());
+            } else {
+              key.replaceWith(t.identifier(key.node.value));
+            }
           }
-          var before = body.slice(0, index);
-          (0, _assert.ok)(!before.includes(object));
-          var beforeTypes = new Set(before.map(x => x.type));
-          beforeTypes.delete("FunctionDeclaration");
-          if (beforeTypes.size > 0) {
-            return;
+        }
+      },
+      // (a); -> a;
+      SequenceExpression: {
+        exit: function exit(path) {
+          if (path.node.expressions.length === 1) {
+            path.replaceWith(path.node.expressions[0]);
           }
-
-          // Test Variant #25: Don't break redefined function declaration
-          if (object.id && body.find(x => x.type === "FunctionDeclaration" && x !== object && x.id && x.id.name === object.id.name)) {
-            return;
+        }
+      },
+      // ; -> ()
+      EmptyStatement: {
+        exit: function exit(path) {
+          path.remove();
+        }
+      },
+      // console; -> ();
+      ExpressionStatement: {
+        exit: function exit(path) {
+          if (path.get("expression").isIdentifier()) {
+            var _path$parentPath, _path$parentPath2;
+            // Preserve last expression of program for RGF
+            if ((_path$parentPath = path.parentPath) !== null && _path$parentPath !== void 0 && _path$parentPath.isProgram() && ((_path$parentPath2 = path.parentPath) === null || _path$parentPath2 === void 0 ? void 0 : _path$parentPath2.get("body").at(-1)) === path) return;
+            path.remove();
           }
         }
-        var canTransform = true;
-        (0, _traverse.walk)(object.body, [], ($object, $parents) => {
-          if ($object.type == "ThisExpression") {
-            canTransform = false;
-          } else if ($object.type == "Identifier") {
-            if ($object.name == "arguments") {
-              canTransform = false;
+      },
+      // undefined -> void 0
+      // Infinity -> 1/0
+      Identifier: {
+        exit: function exit(path) {
+          if (path.isReferencedIdentifier()) {
+            if (identifierMap.has(path.node.name)) {
+              (0, _astUtils.ensureComputedExpression)(path);
+              path.replaceWith(identifierMap.get(path.node.name)());
             }
-            if ($object.name == "this") {
-              this.error(new Error("Use ThisExpression instead"));
+          }
+        }
+      },
+      // true ? a : b -> a
+      ConditionalExpression: {
+        exit: function exit(path) {
+          var testValue = path.get("test").evaluateTruthy();
+          if (testValue === undefined) return;
+          path.replaceWith(testValue ? path.node.consequent : path.node.alternate);
+        }
+      },
+      // Remove unused functions
+      FunctionDeclaration: {
+        exit: function exit(path) {
+          var id = path.get("id");
+          if (id.isIdentifier() && !id.node.name.startsWith(_constants.placeholderVariablePrefix)) {
+            var binding = path.scope.getBinding(id.node.name);
+            if (binding && binding.constantViolations.length === 0 && binding.referencePaths.length === 0 && !binding.referenced) {
+              path.remove();
             }
           }
-        });
-        if (canTransform) {
-          if (!this.arrowFunctionName) {
-            this.arrowFunctionName = this.getPlaceholder();
-            (0, _insert.append)(parents[parents.length - 1] || object, new _template.default(`
-            function ${this.arrowFunctionName}(arrowFn, functionLength = 0){
-              var functionObject = function(){ return arrowFn(...arguments) };
+        }
+      },
+      // var x=undefined -> var x
+      // Remove unused variables
+      // Simple destructuring
+      VariableDeclarator: {
+        exit: function exit(path) {
+          if ((0, _astUtils.isUndefined)(path.get("init"))) {
+            path.node.init = null;
+          }
+          var id = path.get("id");
+          var init = path.get("init");
 
-              ${this.options.preserveFunctionLength ? `return {ObjectDefineProperty}(functionObject, "length", {
-                  "value": functionLength,
-                  "configurable": true
-                });` : `return functionObject`}
-           
+          // Simple array/object destructuring
+          if (id.isArrayPattern() && init.isArrayExpression()) {
+            var elements = id.get("elements");
+            var initElements = init.get("elements");
+            if (elements.length === 1 && initElements.length === 1) {
+              id.replaceWith(elements[0]);
+              init.replaceWith(initElements[0]);
             }
-            `).single({
-              ObjectDefineProperty: this.options.preserveFunctionLength ? this.createInitVariable(_globals.ObjectDefineProperty, parents) : undefined
-            }));
           }
-          const wrap = object => {
-            var args = [(0, _insert.clone)(object)];
-            var fnLength = (0, _insert.computeFunctionLength)(object.params);
-            if (this.options.preserveFunctionLength && fnLength != 0) {
-              args.push((0, _gen.Literal)(fnLength));
-            }
-            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), args);
-          };
-          if (object.type == "FunctionExpression") {
-            object.type = "ArrowFunctionExpression";
-            this.replace(object, wrap((0, _insert.clone)(object)));
-          } else {
-            var arrow = {
-              ...(0, _insert.clone)(object),
-              type: "ArrowFunctionExpression"
-            };
-            this.replace(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(object.id.name, wrap(arrow))));
-            var x = this.transform(arrow, []);
-            if (typeof x === "function") {
-              x();
+          if (id.isObjectPattern() && init.isObjectExpression()) {
+            var properties = id.get("properties");
+            var initProperties = init.get("properties");
+            if (properties.length === 1 && initProperties.length === 1) {
+              var firstProperty = properties[0];
+              var firstInitProperty = initProperties[0];
+              if (firstProperty.isObjectProperty() && firstInitProperty.isObjectProperty()) {
+                var firstKey = firstProperty.get("key");
+                var firstInitKey = firstInitProperty.get("key");
+                if (firstKey.isIdentifier() && firstInitKey.isIdentifier() && firstKey.node.name === firstInitKey.node.name) {
+                  id.replaceWith(firstProperty.node.value);
+                  init.replaceWith(firstInitProperty.node.value);
+                }
+              }
             }
           }
-        }
-      };
-    }
 
-    /**
-     * ()=>{ expr } -> ()=>expr
-     */
-    if (object.type == "ArrowFunctionExpression" && object.body.type == "BlockStatement") {
-      return () => {
-        var body = (0, _insert.getBlockBody)(object.body);
-        var stmt1 = body[0];
-        if (body.length == 1 && stmt1.type == "ReturnStatement") {
-          // x=>{a: 1} // Invalid syntax
-          if (stmt1.argument && stmt1.argument.type != "ObjectExpression") {
-            object.body = stmt1.argument;
-            object.expression = true;
-          }
-        } else {
-          // ()=>{exprStmt;exprStmt;} -> ()=>(expr, expr, expr, undefined)
-          var exprs = body.filter(x => x.type == "ExpressionStatement");
-          if (exprs.length == body.length) {
-            var array = [];
-            function flatten(expr) {
-              if (expr.type == "SequenceExpression") {
-                expr.expressions.forEach(flatten);
-              } else if (expr.type == "ExpressionStatement") {
-                flatten(expr.expression);
-              } else {
-                array.push(expr);
+          // Remove unused variables
+          // Can only remove if it's pure
+          if (id.isIdentifier()) {
+            // Do not remove variables in unsafe functions
+            var fn = (0, _astUtils.getParentFunctionOrProgram)(path);
+            if (fn.node[_constants.UNSAFE]) return;
+            var binding = path.scope.getBinding(id.node.name);
+            if (binding && binding.constantViolations.length === 0 && binding.referencePaths.length === 0) {
+              if (!init.node || init.isPure()) {
+                path.remove();
+              } else if (path.parentPath.isVariableDeclaration() && path.parentPath.node.declarations.length === 1) {
+                path.parentPath.replaceWith(t.expressionStatement(init.node));
               }
             }
-            body.forEach(flatten);
-            object.body = (0, _gen.SequenceExpression)([...(0, _insert.clone)(array), (0, _gen.UnaryExpression)("void", (0, _gen.Literal)(0))]);
           }
         }
-      };
-    }
-
-    // (a()) -> a()
-    if (object.type == "SequenceExpression") {
-      return () => {
-        if (object.expressions.length == 1) {
-          this.replace(object, (0, _insert.clone)(object.expressions[0]));
-        }
-      };
-    }
-
-    // a += -1 -> a -= 1
-    if (object.type == "AssignmentExpression") {
-      return () => {
-        if (object.operator == "+=" && object.right.type == "UnaryExpression" && object.right.operator == "-") {
-          object.operator = "-=";
-          object.right = object.right.argument;
-        } else if (
-        // a -= -1 -> a += 1
-        object.operator == "-=" && object.right.type == "UnaryExpression" && object.right.operator == "-") {
-          object.operator = "+=";
-          object.right = object.right.argument;
-        }
-      };
-    }
-
-    // a + -b -> a - b
-    if (object.type == "BinaryExpression") {
-      return () => {
-        if (object.operator == "+" && object.right.type == "UnaryExpression" && object.right.operator == "-") {
-          object.operator = "-";
-          object.right = object.right.argument;
-        } else if (
-        // a - -1 -> a + 1
-        object.operator == "-" && object.right.type == "UnaryExpression" && object.right.operator == "-") {
-          object.operator = "+";
-          object.right = object.right.argument;
-        }
-      };
-    }
-    if (object.type == "ForStatement" || object.type == "ForInStatement" || object.type == "ForOfStatement" || object.type == "WhileStatement") {
-      if (object.body.type == "BlockStatement") {
-        return () => {
-          if (object.body.body.length === 1) {
-            object.body = object.body.body[0];
+      },
+      // return undefined->return
+      ReturnStatement: {
+        exit: function exit(path) {
+          if ((0, _astUtils.isUndefined)(path.get("argument"))) {
+            path.node.argument = null;
           }
-        };
-      }
-    }
-
-    // Last switch case does not need break
-    if (object.type == "SwitchStatement") {
-      var last = object.cases[object.cases.length - 1];
-      if (last) {
-        var lastStatement = last.consequent[last.consequent.length - 1];
-        if (lastStatement && lastStatement.type == "BreakStatement" && lastStatement.label == null) {
-          last.consequent.pop();
         }
-      } else {
-        if (object.cases.length == 0 && (object.discriminant.type == "Literal" || object.discriminant.type == "Identifier")) {
-          if (parents[0].type == "LabeledStatement" && Array.isArray(parents[1])) {
-            return () => {
-              parents[1].splice(parents[1].indexOf(parents[0]), 1);
-            };
-          } else if (Array.isArray(parents[0])) {
-            return () => {
-              parents[0].splice(parents[0].indexOf(object), 1);
-            };
+      },
+      // while(true) {a();} -> while(true) a();
+      // for(;;) {a();} -> for(;;) a();
+      // with(a) {a();} -> with(a) a();
+      "While|For|WithStatement": {
+        exit: function exit(_path) {
+          var path = _path;
+          var body = path.get("body");
+          if (body.isBlock() && body.node.body.length === 1) {
+            body.replaceWith(body.node.body[0]);
           }
         }
-      }
-    }
-
-    // if ( x ) { y() } -> x && y()
-    // Todo Make this shit readable
-    if (object.type == "IfStatement") {
-      if (object.consequent.type != "BlockStatement") {
-        this.replace(object.consequent, (0, _gen.BlockStatement)([(0, _insert.clone)(object.consequent)]));
-      }
-      if (object.alternate && object.alternate.type != "BlockStatement") {
-        this.replace(object.alternate, (0, _gen.BlockStatement)([(0, _insert.clone)(object.alternate)]));
-      }
-      var body = (0, _insert.getBlockBody)(object.consequent);
-
-      // Check for hard-coded if statements
-      if (object.test.type == "Literal") {
-        if (object.test.value || object.test.regex) {
-          // Why would anyone test just a regex literal
-          object.alternate = null;
-        } else {
-          object.consequent = (0, _gen.BlockStatement)([]);
-        }
-      }
-      return () => {
-        // if ( a ) { } else {b()} -> if ( !a ) b();
-        if (body.length == 0 && object.alternate) {
-          object.test = (0, _gen.UnaryExpression)("!", (0, _insert.clone)(object.test));
-          if (object.alternate.type == "BlockStatement" && object.alternate.body.length == 1) {
-            object.alternate = (0, _insert.clone)(object.alternate.body[0]);
+      },
+      // if(a) a(); -> a && a();
+      // if(a) { return b; } -> if(a) return b;
+      // if(a) { a(); } else { b(); } -> a ? a() : b();
+      // if(a) { return b; } else { return c; } -> return a ? b : c;
+      IfStatement: {
+        exit: function exit(path) {
+          // BlockStatement to single statement
+          var consequent = path.get("consequent");
+          var alternate = path.get("alternate");
+          var isMoveable = function isMoveable(node) {
+            if (t.isDeclaration(node)) return false;
+            return true;
+          };
+          var testValue = path.get("test").evaluateTruthy();
+          var parent = (0, _astUtils.getParentFunctionOrProgram)(path);
+          if (parent && parent.node[_constants.UNSAFE]) {
+            testValue = undefined;
           }
-          object.consequent = object.alternate;
-          object.alternate = null;
-        }
-        if (object.consequent && object.consequent.body && object.consequent.body.length == 1 && object.alternate && object.alternate.body.length == 1) {
-          var stmt1 = (0, _insert.clone)(object.consequent.body[0]);
-          var stmt2 = (0, _insert.clone)(object.alternate.body[0]);
-
-          // if (a) {return b;} else {return c;} -> return a ? b : c;
-          if (stmt1.type == "ReturnStatement" && stmt2.type == "ReturnStatement") {
-            this.replace(object, (0, _gen.ReturnStatement)((0, _gen.ConditionalExpression)((0, _insert.clone)(object.test), stmt1.argument || (0, _gen.Identifier)("undefined"), stmt2.argument || (0, _gen.Identifier)("undefined"))));
+          if (typeof testValue !== "undefined") {
+            if (!alternate.node && consequent.isBlock() && consequent.node.body.length === 1 && isMoveable(consequent.node.body[0])) {
+              consequent.replaceWith(consequent.node.body[0]);
+            }
+            if (alternate.node && alternate.isBlock() && alternate.node.body.length === 1 && isMoveable(alternate.node.body[0])) {
+              alternate.replaceWith(alternate.node.body[0]);
+            }
           }
+          if (testValue === false) {
+            // if(false){} -> ()
+            if (!alternate.node) {
+              path.remove();
+              return;
 
-          // if (a) {b = 0} else {b = 1} -> b = a ? 0 : 1;
-          if (stmt1.type == "ExpressionStatement" && stmt2.type == "ExpressionStatement") {
-            var e1 = stmt1.expression;
-            var e2 = stmt2.expression;
-            if (e1.type == "AssignmentExpression" && e2.type == "AssignmentExpression") {
-              if (e1.operator === e2.operator && (0, _compare.isEquivalent)(e1.left, e2.left)) {
-                this.replace(object, (0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)(e1.operator, e1.left, (0, _gen.ConditionalExpression)((0, _insert.clone)(object.test), e1.right, e2.right))));
+              // if(false){a()}else{b()} -> b()
+            } else {
+              path.replaceWith(alternate.node);
+              return;
+            }
+
+            // if(true){a()} -> {a()}
+          } else if (testValue === true) {
+            path.replaceWith(consequent.node);
+            return;
+          }
+          function getResult(path) {
+            if (!path.node) return null;
+            if (path.isReturnStatement()) {
+              return {
+                returnPath: path,
+                expressions: []
+              };
+            }
+            if (path.isExpressionStatement()) {
+              return {
+                returnPath: null,
+                expressions: [path.get("expression").node]
+              };
+            }
+            if (path.isBlockStatement()) {
+              var expressions = [];
+              var _iterator2 = _createForOfIteratorHelper(path.get("body")),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var statement = _step2.value;
+                  if (statement.isReturnStatement()) {
+                    return {
+                      returnPath: statement,
+                      expressions: expressions
+                    };
+                  } else if (statement.isExpressionStatement()) {
+                    expressions.push(statement.get("expression").node);
+                  } else {
+                    return null;
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
               }
+              return {
+                returnPath: null,
+                expressions: expressions
+              };
             }
+            return null;
           }
-        }
-      };
-    }
+          var consequentReturn = getResult(consequent);
+          var alternateReturn = getResult(alternate);
+          if (consequentReturn && alternateReturn) {
+            if (consequentReturn.returnPath && alternateReturn.returnPath) {
+              var createReturnArgument = function createReturnArgument(resultInfo) {
+                return t.sequenceExpression([].concat(_toConsumableArray(resultInfo.expressions), [resultInfo.returnPath.node.argument || t.identifier("undefined")]));
+              };
+              path.replaceWith(t.returnStatement(t.conditionalExpression(path.node.test, createReturnArgument(consequentReturn), createReturnArgument(alternateReturn))));
+            } else if (!consequentReturn.returnPath && !alternateReturn.returnPath) {
+              var joinExpressions = function joinExpressions(expressions) {
+                // condition?():() is invalid syntax
+                // Just use 0 as a placeholder
+                if (expressions.length === 0) return t.numericLiteral(0);
 
-    // x["abc"] -> x.abc
-    if (object.type == "MemberExpression") {
-      var {
-        object: obj,
-        property
-      } = object;
-      if (property.type == "Literal" && (0, _compare.isValidIdentifier)(property.value)) {
-        object.computed = false;
-        object.property.type = "Identifier";
-        object.property.name = (0, _insert.clone)(object.property.value);
-
-        // obj.name &&
-        //   this.log(
-        //     obj.name +
-        //       "['" +
-        //       object.property.name +
-        //       "'] -> " +
-        //       obj.name +
-        //       "." +
-        //       object.property.name
-        //   );
-      }
-    }
-    if (object.type == "CallExpression") {
-      if (object.callee.type == "MemberExpression") {
-        var key = object.callee.computed ? object.callee.property.value : object.callee.property.name;
-        if (key == "toString" && object.arguments.length == 0) {
-          this.replace(object, (0, _gen.BinaryExpression)("+", (0, _gen.Literal)(""), (0, _insert.clone)(object.callee.object)));
-        }
-      }
-    }
-
-    // { "x": 1 } -> {x: 1}
-    if (object.type === "Property" || object.type === "MethodDefinition") {
-      if (object.key.type == "SequenceExpression" && object.key.expressions.length == 1) {
-        object.key = object.key.expressions[0];
-        object.computed = true;
-      }
-      if (object.key.type == "Literal" && typeof object.key.value === "string" && (0, _compare.isValidIdentifier)(object.key.value)) {
-        object.key.type = "Identifier";
-        object.key.name = object.key.value;
-        object.computed = false;
-      }
-    }
-    if (object.type == "VariableDeclarator") {
-      // undefined is not necessary
-      if (object.init && object.init.type == "Identifier") {
-        if (object.init.name == "undefined") {
-          object.init = null;
-        }
-      }
-      if (object.id.type == "ObjectPattern" && object.init && object.init.type == "ObjectExpression") {
-        if (object.id.properties.length === 1 && object.init.properties.length === 1) {
-          var key1 = object.id.properties[0].computed ? object.id.properties[0].key.value : object.id.properties[0].key.name;
-          var key2 = object.init.properties[0].computed ? object.init.properties[0].key.value : object.init.properties[0].key.name;
-
-          // console.log(key1, key2);
-
-          if (key1 && key2 && key1 === key2) {
-            object.id = object.id.properties[0].value;
-            object.init = object.init.properties[0].value;
+                // No need for sequence expression if there's only one expression
+                if (expressions.length === 1) return expressions[0];
+                return t.sequenceExpression(expressions);
+              };
+              path.replaceWith(t.conditionalExpression(path.node.test, joinExpressions(consequentReturn.expressions), joinExpressions(alternateReturn.expressions)));
+            }
           }
         }
-      }
-
-      // check for redundant patterns
-      if (object.id.type == "ArrayPattern" && object.init && typeof object.init === "object" && object.init.type == "ArrayExpression") {
-        if (object.id.elements.length == 1 && object.init.elements.length == 1) {
-          object.id = object.id.elements[0];
-          object.init = object.init.elements[0];
-        }
-      }
-    }
-    if (object.type == "Literal") {
-      return () => {
-        switch (typeof object.value) {
-          case "boolean":
-            this.replaceIdentifierOrLiteral(object, (0, _gen.UnaryExpression)("!", (0, _gen.Literal)(object.value ? 0 : 1)), parents);
-            break;
-        }
-      };
-    }
-    if (object.type == "Identifier") {
-      return () => {
-        var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-        if (info.spec.isDefined || info.spec.isModified) return;
-        if (object.name == "undefined" && !(0, _insert.isForInitialize)(object, parents)) {
-          this.replaceIdentifierOrLiteral(object, (0, _gen.UnaryExpression)("void", (0, _gen.Literal)(0)), parents);
-        } else if (object.name == "Infinity") {
-          this.replaceIdentifierOrLiteral(object, (0, _gen.BinaryExpression)("/", (0, _gen.Literal)(1), (0, _gen.Literal)(0)), parents);
+      },
+      // Remove unreachable code
+      // Code after a return/throw/break/continue is unreachable
+      // Remove implied returns
+      // Remove code after if all branches are unreachable
+      "Block|SwitchCase": {
+        enter: function enter(path) {
+          if (path.isProgram()) {
+            path.scope.crawl();
+          }
+        },
+        exit: function exit(path) {
+          var statementList = path.isBlock() ? path.get("body") : path.get("consequent");
+          var impliedReturn;
+          function isUnreachable(statementList) {
+            var topLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+            var unreachableState = false;
+            var _iterator3 = _createForOfIteratorHelper(statementList),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var statement = _step3.value;
+                if (unreachableState) {
+                  statement.remove();
+                  continue;
+                }
+                if (statement.isIfStatement()) {
+                  var consequent = statement.get("consequent");
+                  var alternate = statement.get("alternate");
+                  if ([consequent, alternate].every(function (x) {
+                    return x.node && x.isBlockStatement() && isUnreachable(x.get("body"));
+                  })) {
+                    unreachableState = true;
+                    if (!topLevel) {
+                      return true;
+                    } else {
+                      continue;
+                    }
+                  }
+                }
+                if (statement.isSwitchStatement()) {
+                  // Can only remove switch statements if all cases are unreachable
+                  // And all paths are exhausted
+                  var cases = statement.get("cases");
+                  var hasDefaultCase = cases.some(function (x) {
+                    return !x.node.test;
+                  });
+                  if (hasDefaultCase && cases.every(function (x) {
+                    return isUnreachable(x.get("consequent"));
+                  })) {
+                    unreachableState = true;
+                    if (!topLevel) {
+                      return true;
+                    } else {
+                      continue;
+                    }
+                  }
+                }
+                if (statement.isReturnStatement() || statement.isThrowStatement() || statement.isBreakStatement() || statement.isContinueStatement()) {
+                  unreachableState = true;
+                  if (!topLevel) {
+                    return true;
+                  }
+                }
+                if (topLevel) {
+                  if (statement == statementList.at(-1) && statement.isReturnStatement() && !statement.node.argument) {
+                    impliedReturn = statement;
+                  }
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            return false;
+          }
+          isUnreachable(statementList, true);
+          if (impliedReturn) {
+            var functionParent = path.getFunctionParent();
+            if (functionParent && t.isBlockStatement(functionParent.node.body) && functionParent.node.body === path.node) {
+              impliedReturn.remove();
+            }
+          }
         }
-      };
-    }
-    if (object.type == "UnaryExpression" && object.operator == "!") {
-      if (object.argument.type == "Literal" && !object.argument.regex) {
-        this.replace(object, (0, _gen.Literal)(!object.argument.value));
-      }
-    }
-    if (object.type == "ConditionalExpression") {
-      if (object.test.type == "Literal" && !object.test.regex) {
-        this.replace(object, object.test.value ? object.consequent : object.alternate);
       }
     }
-  }
-}
-exports.default = Minify;
+  };
+};