babel-source 5.6.5 → 5.6.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2MyMDM2NmZiNjMxYzM3MDE4Yzc4ZDE1ZTY0M2M5ZTA5ZDI5Nzc4Mw==
+    OTk5MzQzMGY1NTAwZjE0ODc3MjAyZmVkNjc4NDI1ZDVlNjlhNWIzYg==
   data.tar.gz: !binary |-
-    OWY1OTI1Y2RmOThkMTliYjlhYjk5MWQ2MDU0NmRmNWZjMmZlYzRkYQ==
+    OWFiYTI3MWEwOGY5NGEyYTQ3YzFjNTQwNmI1NGU4ZjdjYmJmYmE3OA==
 SHA512:
   metadata.gz: !binary |-
-    MjlhZjFkYjJjNDY0NTgyMDdlM2IxODg1YWNjZTQxODUyMDMyNDhlMGQ2MzY2
-    ODRhYmMxMTczYTNmZGRjOGFkMDE5YWIwZmM3YjllYjQ1NGMzYzU4NmQ0NmEy
-    OTM5ZDczNDFmM2FlODljMmE5Nzg0OGY3NGFhYjhhODEyNGQyNmE=
+    ODljOWQxNWIxMzI2Y2VlNWU5NDc3NDMxNmFhZWQ2OTYzNTU4MGJjNzNmNGQ1
+    YWViZDcxMWEzY2VkZmM5ZGEyNjRhMWIwOWYyNjk1ODMxM2QxNTkxOTA5NGEy
+    NWEyZGY5ZDQxYTc3YzJmNGYxMmZjNTg0ODIyYjgyZWY4YzQ1YjY=
   data.tar.gz: !binary |-
-    ZmIwZGZhMjQyZmIyZWIxNGFlZDUwMzdmM2FjM2NkZjI2ZWNlMGVjNjUyNTNk
-    YzIyMDU5NzcxZTQxMmQ5MmVmZWMzZTAxNmNiNDAyNDk5ZTAxZmQ2ZTkzZTJj
-    MTMxNzcyOWRkZGE3NjJkOTljNmVhYjAzOGE0ZjdlM2RjNmVlZDA=
+    MGZlZTRhZDllYWM4MWE3MTc2NjVjZjI0NjIyNGFkNTRiMjIyMjNhMGU4NWQ4
+    YjI3ZTJmMjNhMjQ2NDI4MWY3ZWQ2Y2ZiMDkyYmRkNDc3Y2U2ZmU4MzY1ZWRj
+    MTY2NWM5ODdkNGYzZjE2MTE1MWZlNTMyY2RlMzY1YjQ3OWMxNTI=

data/lib/babel.js

@@ -25,6 +25,7 @@ _acornJsxInject2["default"](acorn);
 },{"./plugins/flow":2,"./src/index":5,"acorn-jsx/inject":177}],2:[function(require,module,exports){
 "use strict";
 
+Error.stackTraceLimit = Infinity;
 var acorn = require("../src/index");
 
 var pp = acorn.Parser.prototype;
@@ -68,8 +69,11 @@ pp.flow_parseDeclareFunction = function (node) {
   typeNode.rest = tmp.rest;
   this.expect(tt.parenR);
 
+  var oldInType = this.inType;
+  this.inType = true;
   this.expect(tt.colon);
   typeNode.returnType = this.flow_parseType();
+  this.inType = oldInType;
 
   typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
   id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
@@ -379,12 +383,6 @@ pp.flow_parseGenericType = function (start, id) {
   return this.finishNode(node, "GenericTypeAnnotation");
 };
 
-pp.flow_parseVoidType = function () {
-  var node = this.startNode();
-  this.expect(tt._void);
-  return this.finishNode(node, "VoidTypeAnnotation");
-};
-
 pp.flow_parseTypeofType = function () {
   var node = this.startNode();
   this.expect(tt._typeof);
@@ -438,6 +436,9 @@ pp.flow_identToTypeAnnotation = function (start, node, id) {
     case "any":
       return this.finishNode(node, "AnyTypeAnnotation");
 
+    case "void":
+      return this.finishNode(node, "VoidTypeAnnotation");
+
     case "bool":
     case "boolean":
       return this.finishNode(node, "BooleanTypeAnnotation");
@@ -544,14 +545,8 @@ pp.flow_parsePrimaryType = function () {
       return this.finishNode(node, "StringLiteralTypeAnnotation");
 
     default:
-      if (this.type.keyword) {
-        switch (this.type.keyword) {
-          case "void":
-            return this.flow_parseVoidType();
-
-          case "typeof":
-            return this.flow_parseTypeofType();
-        }
+      if (this.type.keyword === "typeof") {
+        return this.flow_parseTypeofType();
       }
   }
 
@@ -714,6 +709,18 @@ acorn.plugins.flow = function (instance) {
     };
   });
 
+  // don't consider `void` to be a keyword as then it'll use the void token type
+  // and set startExpr
+  instance.extend("isKeyword", function (inner) {
+    return function (name) {
+      if (this.inType && name === "void") {
+        return false;
+      } else {
+        return inner.call(this, name);
+      }
+    };
+  });
+
   instance.extend("readToken", function (inner) {
     return function (code) {
       if (this.inType && (code === 62 || code === 60)) {
@@ -1995,7 +2002,7 @@ var _state = require("./state");
 
 var pp = _state.Parser.prototype;
 
-var STATE_KEYS = ["lastTokStartLoc", "lastTokEndLoc", "lastTokStart", "lastTokEnd", "lineStart", "startLoc", "curLine", "endLoc", "start", "pos", "end", "type", "value", "exprAllowed", "potentialArrowAt", "currLine", "input"];
+var STATE_KEYS = ["lastTokStartLoc", "lastTokEndLoc", "lastTokStart", "lastTokEnd", "lineStart", "startLoc", "curLine", "endLoc", "start", "pos", "end", "type", "value", "exprAllowed", "potentialArrowAt", "currLine", "input", "inType", "inFunction", "inGenerator", "labels"];
 
 pp.getState = function () {
   var state = {};
@@ -2004,6 +2011,7 @@ pp.getState = function () {
     state[key] = this[key];
   }
   state.context = this.context.slice();
+  state.labels = this.labels.slice();
   return state;
 };
 
@@ -2520,11 +2528,11 @@ var _whitespace = require("./whitespace");
 
 function Parser(options, input, startPos) {
   this.options = options;
-  this.loadPlugins(this.options.plugins);
   this.sourceFile = this.options.sourceFile || null;
   this.isKeyword = _identifier.keywords[this.options.ecmaVersion >= 6 ? 6 : 5];
   this.isReservedWord = _identifier.reservedWords[this.options.ecmaVersion];
   this.input = input;
+  this.loadPlugins(this.options.plugins);
 
   // Set up token state
 
@@ -4370,7 +4378,7 @@ kw("case", beforeExpr);
 kw("catch");
 kw("continue");
 kw("debugger");
-kw("default");
+kw("default", beforeExpr);
 kw("do", { isLoop: true });
 kw("else", beforeExpr);
 kw("finally");
@@ -4771,9 +4779,10 @@ var Buffer = (function () {
     this.space();
   };
 
-  Buffer.prototype.space = function space() {
-    if (this.format.compact) return;
-    if (this.buf && !this.isLast(" ") && !this.isLast("\n")) {
+  Buffer.prototype.space = function space(force) {
+    if (!force && this.format.compact) return;
+
+    if (force || this.buf && !this.isLast(" ") && !this.isLast("\n")) {
       this.push(" ");
     }
   };
@@ -4873,7 +4882,13 @@ var Buffer = (function () {
   };
 
   Buffer.prototype.endsWith = function endsWith(str) {
-    return this.buf.slice(-str.length) === str;
+    var buf = arguments[1] === undefined ? this.buf : arguments[1];
+
+    if (str.length === 1) {
+      return buf[buf.length - 1] === str;
+    } else {
+      return buf.slice(-str.length) === str;
+    }
   };
 
   Buffer.prototype.isLast = function isLast(cha) {
@@ -5070,19 +5085,19 @@ var _types = require("../../types");
 var t = _interopRequireWildcard(_types);
 
 function UnaryExpression(node, print) {
-  var hasSpace = /[a-z]$/.test(node.operator);
+  var needsSpace = /[a-z]$/.test(node.operator);
   var arg = node.argument;
 
   if (t.isUpdateExpression(arg) || t.isUnaryExpression(arg)) {
-    hasSpace = true;
+    needsSpace = true;
   }
 
   if (t.isUnaryExpression(arg) && arg.operator === "!") {
-    hasSpace = false;
+    needsSpace = false;
   }
 
   this.push(node.operator);
-  if (hasSpace) this.push(" ");
+  if (needsSpace) this.push(" ");
   print.plain(node.argument);
 }
 
@@ -5151,16 +5166,13 @@ function CallExpression(node, print) {
 
   this.push("(");
 
-  var separator = ",";
-
-  var isPrettyCall = node._prettyCall && !this.format.retainLines;
+  var isPrettyCall = node._prettyCall && !this.format.retainLines && !this.format.compact;
 
+  var separator;
   if (isPrettyCall) {
-    separator += "\n";
+    separator = ",\n";
     this.newline();
     this.indent();
-  } else {
-    separator += " ";
   }
 
   print.list(node.arguments, { separator: separator });
@@ -5212,9 +5224,20 @@ function AssignmentPattern(node, print) {
 function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
   print.plain(node.left);
-  this.push(" ");
+
+  var spaces = node.operator === "in" || node.operator === "instanceof";
+  this.space(spaces);
+
   this.push(node.operator);
-  this.push(" ");
+
+  if (!spaces) {
+    // space is mandatory to avoid outputting <!--
+    // http://javascript.spec.whatwg.org/#comment-syntax
+    spaces = node.operator === "<" && t.isUnaryExpression(node.right, { prefix: true, operator: "!" }) && t.isUnaryExpression(node.right.argument, { prefix: true, operator: "--" });
+  }
+
+  this.space(spaces);
+
   print.plain(node.right);
 }
 
@@ -5687,7 +5710,7 @@ function _method(node, print) {
   }
 
   this._params(value, print);
-  this.push(" ");
+  this.space();
   print.plain(value.body);
 }
 
@@ -6107,16 +6130,29 @@ function VariableDeclaration(node, print, parent) {
     }
   }
 
-  var sep = ",";
+  //
+  // use a pretty separator when we aren't in compact mode, have initializers and don't have retainLines on
+  // this will format declarations like:
+  //
+  //   var foo = "bar", bar = "foo";
+  //
+  // into
+  //
+  //   var foo = "bar",
+  //       bar = "foo";
+  //
+
+  var sep;
   if (!this.format.compact && !this.format.concise && hasInits && !this.format.retainLines) {
-    sep += "\n" + _repeating2["default"](" ", node.kind.length + 1);
-  } else {
-    sep += " ";
+    sep = ",\n" + _repeating2["default"](" ", node.kind.length + 1);
   }
 
+  //
+
   print.list(node.declarations, { separator: sep });
 
   if (t.isFor(parent)) {
+    // don't give semicolons to these nodes since they'll be inserted in the parent generator
     if (parent.left === node || parent.init === node) return;
   }
 
@@ -6269,7 +6305,7 @@ function ArrayExpression(node, print) {
       // both (all) of the holes.
       this.push(",");
     } else {
-      if (i > 0) this.push(" ");
+      if (i > 0) this.space();
       print.plain(elem);
       if (i < len - 1) this.push(",");
     }
@@ -7153,7 +7189,11 @@ var NodePrinter = (function () {
   NodePrinter.prototype.list = function list(items) {
     var opts = arguments[1] === undefined ? {} : arguments[1];
 
-    if (opts.separator == null) opts.separator = ", ";
+    if (opts.separator == null) {
+      opts.separator = ",";
+      if (!this.generator.format.compact) opts.separator += " ";
+    }
+
     return this.join(items, opts);
   };
 
@@ -18522,6 +18562,7 @@ function unshiftContext(context) {
  */
 
 function setup(parentPath, container, listKey, key) {
+  this.inList = !!listKey;
   this.listKey = listKey;
   this.parentKey = listKey || key;
   this.container = container;
@@ -19059,6 +19100,7 @@ var NodePath = (function () {
     this.context = null;
     this.container = null;
     this.listKey = null;
+    this.inList = false;
     this.parentKey = null;
     this.key = null;
     this.node = null;
@@ -28681,143 +28723,145 @@ exports["default"] = function (_ref) {
     return node;
   }
 
-  return new Plugin("dead-code-elimination", {
-    metadata: {
-      group: "builtin-pre",
-      experimental: true
-    },
+  var visitor = {
+    ReferencedIdentifier: function ReferencedIdentifier(node, parent, scope) {
+      var binding = scope.getBinding(node.name);
+      if (!binding || binding.references > 1 || !binding.constant) return;
+      if (binding.kind === "param" || binding.kind === "module") return;
 
-    visitor: {
-      ReferencedIdentifier: function ReferencedIdentifier(node, parent, scope) {
-        var binding = scope.getBinding(node.name);
-        if (!binding || binding.references > 1 || !binding.constant) return;
-        if (binding.kind === "param" || binding.kind === "module") return;
-
-        var replacement = binding.path.node;
-        if (t.isVariableDeclarator(replacement)) {
-          replacement = replacement.init;
-        }
-        if (!replacement) return;
+      var replacement = binding.path.node;
+      if (t.isVariableDeclarator(replacement)) {
+        replacement = replacement.init;
+      }
+      if (!replacement) return;
 
-        // ensure it's a "pure" type
-        if (!scope.isPure(replacement, true)) return;
+      // ensure it's a "pure" type
+      if (!scope.isPure(replacement, true)) return;
 
-        if (t.isClass(replacement) || t.isFunction(replacement)) {
-          // don't change this if it's in a different scope, this can be bad
-          // for performance since it may be inside a loop or deeply nested in
-          // hot code
-          if (binding.path.scope.parent !== scope) return;
-        }
+      if (t.isClass(replacement) || t.isFunction(replacement)) {
+        // don't change this if it's in a different scope, this can be bad
+        // for performance since it may be inside a loop or deeply nested in
+        // hot code
+        if (binding.path.scope.parent !== scope) return;
+      }
 
-        if (this.findParent(function (path) {
-          return path.node === replacement;
-        })) {
-          return;
-        }
+      if (this.findParent(function (path) {
+        return path.node === replacement;
+      })) {
+        return;
+      }
 
-        t.toExpression(replacement);
-        scope.removeBinding(node.name);
-        binding.path.dangerouslyRemove();
-        return replacement;
-      },
+      t.toExpression(replacement);
+      scope.removeBinding(node.name);
+      binding.path.dangerouslyRemove();
+      return replacement;
+    },
 
-      "ClassDeclaration|FunctionDeclaration": function ClassDeclarationFunctionDeclaration(node, parent, scope) {
-        var binding = scope.getBinding(node.id.name);
-        if (binding && !binding.referenced) {
-          this.dangerouslyRemove();
-        }
-      },
+    "ClassDeclaration|FunctionDeclaration": function ClassDeclarationFunctionDeclaration(node, parent, scope) {
+      var binding = scope.getBinding(node.id.name);
+      if (binding && !binding.referenced) {
+        this.dangerouslyRemove();
+      }
+    },
 
-      VariableDeclarator: function VariableDeclarator(node, parent, scope) {
-        if (!t.isIdentifier(node.id) || !scope.isPure(node.init, true)) return;
-        visitor["ClassDeclaration|FunctionDeclaration"].apply(this, arguments);
-      },
+    VariableDeclarator: function VariableDeclarator(node, parent, scope) {
+      if (!t.isIdentifier(node.id) || !scope.isPure(node.init, true)) return;
+      visitor["ClassDeclaration|FunctionDeclaration"].apply(this, arguments);
+    },
 
-      ConditionalExpression: function ConditionalExpression(node) {
-        var evaluateTest = this.get("test").evaluateTruthy();
-        if (evaluateTest === true) {
-          return node.consequent;
-        } else if (evaluateTest === false) {
-          return node.alternate;
-        }
-      },
+    ConditionalExpression: function ConditionalExpression(node) {
+      var evaluateTest = this.get("test").evaluateTruthy();
+      if (evaluateTest === true) {
+        return node.consequent;
+      } else if (evaluateTest === false) {
+        return node.alternate;
+      }
+    },
 
-      BlockStatement: function BlockStatement() {
-        var paths = this.get("body");
+    BlockStatement: function BlockStatement() {
+      var paths = this.get("body");
 
-        var purge = false;
+      var purge = false;
 
-        for (var i = 0; i < paths.length; i++) {
-          var path = paths[i];
+      for (var i = 0; i < paths.length; i++) {
+        var path = paths[i];
 
-          if (!purge && path.isCompletionStatement()) {
-            purge = true;
-            continue;
-          }
+        if (!purge && path.isCompletionStatement()) {
+          purge = true;
+          continue;
+        }
 
-          if (purge && !path.isFunctionDeclaration()) {
-            path.dangerouslyRemove();
-          }
+        if (purge && !path.isFunctionDeclaration()) {
+          path.dangerouslyRemove();
         }
-      },
+      }
+    },
 
-      IfStatement: {
-        exit: function exit(node) {
-          var consequent = node.consequent;
-          var alternate = node.alternate;
-          var test = node.test;
+    IfStatement: {
+      exit: function exit(node) {
+        var consequent = node.consequent;
+        var alternate = node.alternate;
+        var test = node.test;
 
-          var evaluateTest = this.get("test").evaluateTruthy();
+        var evaluateTest = this.get("test").evaluateTruthy();
 
-          // we can check if a test will be truthy 100% and if so then we can inline
-          // the consequent and completely ignore the alternate
-          //
-          //   if (true) { foo; } -> { foo; }
-          //   if ("foo") { foo; } -> { foo; }
-          //
+        // we can check if a test will be truthy 100% and if so then we can inline
+        // the consequent and completely ignore the alternate
+        //
+        //   if (true) { foo; } -> { foo; }
+        //   if ("foo") { foo; } -> { foo; }
+        //
 
-          if (evaluateTest === true) {
-            return toStatements(consequent);
-          }
+        if (evaluateTest === true) {
+          return toStatements(consequent);
+        }
 
-          // we can check if a test will be falsy 100% and if so we can inline the
-          // alternate if there is one and completely remove the consequent
-          //
-          //   if ("") { bar; } else { foo; } -> { foo; }
-          //   if ("") { bar; } ->
-          //
+        // we can check if a test will be falsy 100% and if so we can inline the
+        // alternate if there is one and completely remove the consequent
+        //
+        //   if ("") { bar; } else { foo; } -> { foo; }
+        //   if ("") { bar; } ->
+        //
 
-          if (evaluateTest === false) {
-            if (alternate) {
-              return toStatements(alternate);
-            } else {
-              return this.dangerouslyRemove();
-            }
+        if (evaluateTest === false) {
+          if (alternate) {
+            return toStatements(alternate);
+          } else {
+            return this.dangerouslyRemove();
           }
+        }
 
-          // remove alternate blocks that are empty
-          //
-          //   if (foo) { foo; } else {} -> if (foo) { foo; }
-          //
+        // remove alternate blocks that are empty
+        //
+        //   if (foo) { foo; } else {} -> if (foo) { foo; }
+        //
 
-          if (t.isBlockStatement(alternate) && !alternate.body.length) {
-            alternate = node.alternate = null;
-          }
+        if (t.isBlockStatement(alternate) && !alternate.body.length) {
+          alternate = node.alternate = null;
+        }
 
-          // if the consequent block is empty turn alternate blocks into a consequent
-          // and flip the test
-          //
-          //   if (foo) {} else { bar; } -> if (!foo) { bar; }
-          //
+        // if the consequent block is empty turn alternate blocks into a consequent
+        // and flip the test
+        //
+        //   if (foo) {} else { bar; } -> if (!foo) { bar; }
+        //
 
-          if (t.isBlockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {
-            node.consequent = node.alternate;
-            node.alternate = null;
-            node.test = t.unaryExpression("!", test, true);
-          }
+        if (t.isBlockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {
+          node.consequent = node.alternate;
+          node.alternate = null;
+          node.test = t.unaryExpression("!", test, true);
         }
       }
     }
+  };
+
+  return new Plugin("dead-code-elimination", {
+    metadata: {
+      group: "builtin-pre",
+      experimental: true
+    },
+
+    visitor: visitor
   });
 };
 
@@ -53551,12 +53595,17 @@ var defaults = {
     // If you want esprima not to throw exceptions when it encounters
     // non-fatal errors, keep this option true.
     tolerant: true,
-    
+
     // If you want to override the quotes used in string literals, specify
-    // either "single", "double", or "auto" here ("auto" will select the one 
+    // either "single", "double", or "auto" here ("auto" will select the one
     // which results in the shorter literal)
     // Otherwise, the input marks will be preserved
     quote: null,
+
+    // If you want to print trailing commas in object literals,
+    // array expressions, functions calls and function definitions pass true
+    // for this option.
+    trailingComma: false,
 }, hasOwn = defaults.hasOwnProperty;
 
 // Copy options and fill in default values.
@@ -53582,6 +53631,7 @@ exports.normalize = function(options) {
         range: get("range"),
         tolerant: get("tolerant"),
         quote: get("quote"),
+        trailingComma: get("trailingComma"),
     };
 };
 
@@ -54684,7 +54734,6 @@ function genericPrintNoParens(path, options, print) {
         fields.forEach(function(field) {
             path.map(function(childPath) {
                 var i = childPath.getName();
-                var prop = childPath.getValue();
                 var lines = print(childPath);
 
                 if (!oneLine) {
@@ -54706,6 +54755,8 @@ function genericPrintNoParens(path, options, print) {
                     allowBreak = !multiLine;
                 } else if (len !== 1 && isTypeAnnotation) {
                     parts.push(separator);
+                } else if (options.trailingComma) {
+                    parts.push(separator);
                 }
             }, field);
         });
@@ -54740,8 +54791,12 @@ function genericPrintNoParens(path, options, print) {
     case "ArrayExpression":
     case "ArrayPattern":
         var elems = n.elements,
-            len = elems.length,
-            parts = ["["];
+            len = elems.length;
+
+        var printed = path.map(print, "elements");
+        var joined = fromString(", ").join(printed);
+        var oneLine = joined.getLineLength(1) <= options.wrapColumn;
+        var parts = [oneLine ? "[" : "[\n"];
 
         path.each(function(elemPath) {
             var i = elemPath.getName();
@@ -54754,11 +54809,18 @@ function genericPrintNoParens(path, options, print) {
                 // both (all) of the holes.
                 parts.push(",");
             } else {
-                if (i > 0)
-                    parts.push(" ");
-                parts.push(print(elemPath));
-                if (i < len - 1)
+                var lines = printed[i];
+                if (oneLine) {
+                    if (i > 0)
+                        parts.push(" ");
+                } else {
+                    lines = lines.indent(options.tabWidth);
+                }
+                parts.push(lines);
+                if (i < len - 1 || (!oneLine && options.trailingComma))
                     parts.push(",");
+                if (!oneLine)
+                    parts.push("\n");
             }
         }, "elements");
 
@@ -55654,7 +55716,11 @@ function printArgumentsList(path, options, print) {
     var joined = fromString(", ").join(printed);
     if (joined.getLineLength(1) > options.wrapColumn) {
         joined = fromString(",\n").join(printed);
-        return concat(["(\n", joined.indent(options.tabWidth), "\n)"]);
+        return concat([
+            "(\n",
+            joined.indent(options.tabWidth),
+            options.trailingComma ? ",\n)" : "\n)"
+        ]);
     }
 
     return concat(["(", joined, ")"]);
@@ -55684,6 +55750,9 @@ function printFunctionParams(path, options, print) {
     if (joined.length > 1 ||
         joined.getLineLength(1) > options.wrapColumn) {
         joined = fromString(",\n").join(printed);
+        if (options.trailingComma && !fun.rest) {
+            joined = concat([joined, ",\n"]);
+        }
         return concat(["\n", joined.indent(options.tabWidth)]);
     }
 
@@ -62923,7 +62992,7 @@ module.exports = function (str) {
 module.exports={
   "name": "babel-core",
   "description": "A compiler for writing next generation JavaScript",
-  "version": "5.6.5",
+  "version": "5.6.6",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "license": "MIT",
@@ -62953,7 +63022,7 @@ module.exports={
     "acorn-jsx": "^1.0.0",
     "ast-types": "~0.7.0",
     "babel-plugin-constant-folding": "^1.0.1",
-    "babel-plugin-dead-code-elimination": "^1.0.1",
+    "babel-plugin-dead-code-elimination": "^1.0.2",
     "babel-plugin-eval": "^1.0.1",
     "babel-plugin-inline-environment-variables": "^1.0.1",
     "babel-plugin-jscript": "^1.0.1",

data/lib/babel/source.rb

@@ -1,7 +1,7 @@
 module Babel
   module Source
-    VERSION = "5.6.5"
-    DATE = Time.at(1435150074)
+    VERSION = "5.6.6"
+    DATE = Time.at(1435184864)
     PATH = File.expand_path("../..", __FILE__)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babel-source
 version: !ruby/object:Gem::Version
-  version: 5.6.5
+  version: 5.6.6
 platform: ruby
 authors:
 - Sebastian McKenzie