babel-source 4.4.5 → 4.4.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MWVkNDM4MjE4M2IzZDZkNDIwYTllYzQxNTFkZWEyNmU1NzFjYzMyOQ==
+    MGZlYmM4ODgyNzhlYzYyYzdhZDE0MWQwYWNlZDQ0OWJiZGQzMmExMQ==
   data.tar.gz: !binary |-
-    YjQ2ODc1MjA1N2FjNzc2OWIwZDQ5ZWExZWZiMGE1ZTM5YmQzODMxOA==
+    YTM5ZjRjOTA4ZjNlYWY1MDk3OTQ1ZjVkZTUxMjNjZTdlNzE0MDA5OQ==
 SHA512:
   metadata.gz: !binary |-
-    ODUwNjlhZWNlYzJiM2FmOGQ4NjY1MTk4MTdkYjRjNWFhZDc0MGIyMDk2MjYx
-    NWM2ZWE4NDQ4Y2NmMGY5ZTIyNGY3MTNkODYwMTJiMWIyOGY3NTBiYjE0MTU3
-    ZDExOGIxMTM2ZjBhNjEyNDBlMGYyZjA4OGE5YTNlYWVlMjBjZTc=
+    ODNkOTUwZjM0MGM1MzAzOWNiYmM5NjE3MTI3Mjg2MTI0M2NhMGU2NjIxOTgz
+    MmViNDkxMWU5YjU4M2MwN2JiNmQxZDVlODZhYmI3ODU1YjU1YWM4YjAxMDAz
+    NmY4MjZmMGJkZjVmMDE2MjA5ZjY0NDAzMDNmZTdmNjBjZmE1NmM=
   data.tar.gz: !binary |-
-    NjJjYjZlZTRjMTc5ZWQ0NjVmNmY2M2M0M2E5OTk0Y2U2YWQ4ZmNkMzQ3Zjc2
-    Y2NiZmM4OTEzZDUxNGE0ZWFiNjQ1ZDI4ZmJkZDRjMzBmNGY2NzgxN2U5ZDM3
-    MGFjNmViY2U5YTMzYmU1ZjIwMThhMGFmOWVmOTg4ZTY1YWRmNWU=
+    NWJmZTdmYmFkNGRkOTNmNjQ2NGMxODUxNjAyMDc5ZWIyZjM5MWFkMTlmN2E5
+    YWFkYTcyNDc2OWVkNDY1NDY2NDEyMDFjNTU1NWE5ZTU3NTEyZTJkZjgxNzZh
+    NWY2NzEyMTI3MDhhNWFkNjI5MTIyNzFiZGZhOTI3NjhmNGU3ZjI=

data/lib/babel.js

@@ -3164,16 +3164,19 @@ module.exports = function (exports, opts) {
   };
 
   exports.JSXAttribute = {
-    exit: function (node) {
-      var value = node.value || t.literal(true);
-
+    enter: function (node) {
+      var value = node.value;
       if (t.isLiteral(value) && isString(value.value)) {
         value.value = value.value.replace(/\n\s+/g, " ");
       }
+    },
 
+    exit: function (node) {
+      var value = node.value || t.literal(true);
       return t.inherits(t.property("init", node.name, value), node);
     }
   };
+
   exports.JSXOpeningElement = {
     exit: function (node, parent, scope, file) {
       var tagExpr = node.name;
@@ -5881,6 +5884,7 @@ function ClassTransformer(node, file, scope, isStatement) {
 ClassTransformer.prototype.run = function () {
   var superName = this.superName;
   var className = this.className;
+  var classBody = this.node.body.body;
   var file      = this.file;
 
   //
@@ -5893,13 +5897,21 @@ ClassTransformer.prototype.run = function () {
       className
     ]))
   ]);
-  var constructor;
 
+  var constructor;
   if (this.node.id) {
     constructor = t.functionDeclaration(className, [], constructorBody);
     body.push(constructor);
   } else {
-    constructor = t.functionExpression(null, [], constructorBody);
+    var constructorName = null;
+    // when a class has no parent and there is only a constructor or no body
+    // then the constructor is not wrapped in a closure and needs to be named
+    var containsOnlyConstructor = classBody.length === 1 && classBody[0].key.name === "constructor";
+    if (!this.hasSuper && (classBody.length === 0 || containsOnlyConstructor)) {
+      constructorName = className;
+    }
+
+    constructor = t.functionExpression(constructorName, [], constructorBody);
     body.push(t.variableDeclaration("var", [
       t.variableDeclarator(className, constructor)
     ]));
@@ -6718,7 +6730,7 @@ var loose = function (node, parent, scope, file) {
   var left = node.left;
   var declar, id;
 
-  if (t.isIdentifier(left) || t.isPattern(left)) {
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
     // for (i of test), for ({ i } of test)
     id = left;
   } else if (t.isVariableDeclaration(left)) {
@@ -6779,7 +6791,7 @@ var spec = function (node, parent, scope, file) {
   var stepKey   = scope.generateUidIdentifier("step");
   var stepValue = t.memberExpression(stepKey, t.identifier("value"));
 
-  if (t.isIdentifier(left) || t.isPattern(left)) {
+  if (t.isIdentifier(left) || t.isPattern(left) || t.isMemberExpression(left)) {
     // for (i of test), for ({ i } of test)
     declar = t.expressionStatement(t.assignmentExpression("=", left, stepValue));
   } else if (t.isVariableDeclaration(left)) {
@@ -8116,6 +8128,9 @@ module.exports = {
   "validation.react":                      require("./validation/react"),
   "spec.blockScopedFunctions":             require("./spec/block-scoped-functions"),
 
+  // needs to be before `_aliasFunction`
+  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
+
   "playground.malletOperator":             require("./playground/mallet-operator"),
   "playground.methodBinding":              require("./playground/method-binding"),
   "playground.memoizationOperator":        require("./playground/memoization-operator"),
@@ -8131,9 +8146,6 @@ module.exports = {
   // needs to be before `_aliasFunction`
   "es7.comprehensions":                    require("./es7/comprehensions"),
 
-  // needs to be before `_aliasFunction`
-  "es6.arrowFunctions":                    require("./es6/arrow-functions"),
-
   "es6.classes":                           require("./es6/classes"),
 
   asyncToGenerator:                        require("./other/async-to-generator"),
@@ -8671,10 +8683,17 @@ var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
 exports.Program = function (node, parent, scope, file) {
   var id = "React.createElement";
 
-  var comment = file.ast.comments[0];
-  if (comment) {
+  for (var i = 0; i < file.ast.comments.length; i++) {
+    var comment = file.ast.comments[i];
     var matches = JSX_ANNOTATION_REGEX.exec(comment.value);
-    if (matches) id = matches[1];
+    if (matches) {
+      id = matches[1];
+      if (id === "React.DOM") {
+        throw file.errorWithNode(comment, "The @jsx React.DOM pragma has been deprecated as of React 0.12");
+      } else {
+        break;
+      }
+    }
   }
 
   file.set("jsxIdentifier", id.split(".").map(t.identifier).reduce(function (object, property) {
@@ -10273,7 +10292,6 @@ module.exports={
   "AssignmentPattern": ["Pattern"],
 
   "Property":   ["UserWhitespacable"],
-  "JSXElement": ["UserWhitespacable", "Expression"],
 
   "ArrayExpression":           ["Expression"],
   "AssignmentExpression":      ["Expression"],
@@ -10299,7 +10317,7 @@ module.exports={
 
   "JSXAttribute":           ["JSX"],
   "JSXClosingElement":      ["JSX"],
-  "JSXElement":             ["JSX"],
+  "JSXElement":             ["JSX", "Expression"],
   "JSXEmptyExpression":     ["JSX"],
   "JSXExpressionContainer": ["JSX"],
   "JSXIdentifier":          ["JSX"],
@@ -25225,6 +25243,7 @@ function hasOwnProperty(obj, prop) {
 
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
 },{"./support/isBuffer":160,"_process":145,"inherits":142}],162:[function(require,module,exports){
+(function (process){
 'use strict';
 var escapeStringRegexp = require('escape-string-regexp');
 var ansiStyles = require('ansi-styles');
@@ -25232,13 +25251,23 @@ var stripAnsi = require('strip-ansi');
 var hasAnsi = require('has-ansi');
 var supportsColor = require('supports-color');
 var defineProps = Object.defineProperties;
-var chalk = module.exports;
+
+function Chalk(options) {
+	// detect mode if not set manually
+	this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled;
+}
+
+// use bright blue on Windows as the normal blue color is illegible
+if (process.platform === 'win32') {
+	ansiStyles.blue.open = '\u001b[94m';
+}
 
 function build(_styles) {
 	var builder = function builder() {
 		return applyStyle.apply(builder, arguments);
 	};
 	builder._styles = _styles;
+	builder.enabled = this.enabled;
 	// __proto__ is used because we must return a function, but there is
 	// no way to create a function with a different prototype.
 	builder.__proto__ = proto;
@@ -25248,14 +25277,12 @@ function build(_styles) {
 var styles = (function () {
 	var ret = {};
 
-	ansiStyles.grey = ansiStyles.gray;
-
 	Object.keys(ansiStyles).forEach(function (key) {
 		ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
 
 		ret[key] = {
 			get: function () {
-				return build(this._styles.concat(key));
+				return build.call(this, this._styles.concat(key));
 			}
 		};
 	});
@@ -25277,14 +25304,15 @@ function applyStyle() {
 		}
 	}
 
-	if (!chalk.enabled || !str) {
+	if (!this.enabled || !str) {
 		return str;
 	}
 
-	/*jshint validthis: true*/
+	/*jshint validthis: true */
 	var nestedStyles = this._styles;
 
-	for (var i = 0; i < nestedStyles.length; i++) {
+	var i = nestedStyles.length;
+	while (i--) {
 		var code = ansiStyles[nestedStyles[i]];
 		// Replace any instances already present with a re-opening code
 		// otherwise only the part of the string until said closing code
@@ -25301,7 +25329,7 @@ function init() {
 	Object.keys(styles).forEach(function (name) {
 		ret[name] = {
 			get: function () {
-				return build([name]);
+				return build.call(this, [name]);
 			}
 		};
 	});
@@ -25309,58 +25337,71 @@ function init() {
 	return ret;
 }
 
-defineProps(chalk, init());
-
-chalk.styles = ansiStyles;
-chalk.hasColor = hasAnsi;
-chalk.stripColor = stripAnsi;
-chalk.supportsColor = supportsColor;
+defineProps(Chalk.prototype, init());
 
-// detect mode if not set manually
-if (chalk.enabled === undefined) {
-	chalk.enabled = chalk.supportsColor;
-}
+module.exports = new Chalk();
+module.exports.styles = ansiStyles;
+module.exports.hasColor = hasAnsi;
+module.exports.stripColor = stripAnsi;
+module.exports.supportsColor = supportsColor;
 
-},{"ansi-styles":163,"escape-string-regexp":164,"has-ansi":165,"strip-ansi":167,"supports-color":169}],163:[function(require,module,exports){
+}).call(this,require('_process'))
+},{"_process":145,"ansi-styles":163,"escape-string-regexp":164,"has-ansi":165,"strip-ansi":167,"supports-color":169}],163:[function(require,module,exports){
 'use strict';
-var styles = module.exports;
-
-var codes = {
-	reset: [0, 0],
-
-	bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
-	dim: [2, 22],
-	italic: [3, 23],
-	underline: [4, 24],
-	inverse: [7, 27],
-	hidden: [8, 28],
-	strikethrough: [9, 29],
-
-	black: [30, 39],
-	red: [31, 39],
-	green: [32, 39],
-	yellow: [33, 39],
-	blue: [34, 39],
-	magenta: [35, 39],
-	cyan: [36, 39],
-	white: [37, 39],
-	gray: [90, 39],
-
-	bgBlack: [40, 49],
-	bgRed: [41, 49],
-	bgGreen: [42, 49],
-	bgYellow: [43, 49],
-	bgBlue: [44, 49],
-	bgMagenta: [45, 49],
-	bgCyan: [46, 49],
-	bgWhite: [47, 49]
-};
-
-Object.keys(codes).forEach(function (key) {
-	var val = codes[key];
-	var style = styles[key] = {};
-	style.open = '\u001b[' + val[0] + 'm';
-	style.close = '\u001b[' + val[1] + 'm';
+
+var styles = module.exports = {
+	modifiers: {
+		reset: [0, 0],
+		bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	colors: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		gray: [90, 39]
+	},
+	bgColors: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49]
+	}
+};
+
+// fix humans
+styles.colors.grey = styles.colors.gray;
+
+Object.keys(styles).forEach(function (groupName) {
+	var group = styles[groupName];
+
+	Object.keys(group).forEach(function (styleName) {
+		var style = group[styleName];
+
+		styles[styleName] = group[styleName] = {
+			open: '\u001b[' + style[0] + 'm',
+			close: '\u001b[' + style[1] + 'm'
+		};
+	});
+
+	Object.defineProperty(styles, groupName, {
+		value: group,
+		enumerable: false
+	});
 });
 
 },{}],164:[function(require,module,exports){
@@ -25385,7 +25426,7 @@ module.exports = re.test.bind(re);
 },{"ansi-regex":166}],166:[function(require,module,exports){
 'use strict';
 module.exports = function () {
-	return /\u001b\[(?:[0-9]{1,3}(?:;[0-9]{1,3})*)?[m|K]/g;
+	return /(?:(?:\u001b\[)|\u009b)(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m])|\u001b[A-M]/g;
 };
 
 },{}],167:[function(require,module,exports){
@@ -25401,12 +25442,23 @@ arguments[4][166][0].apply(exports,arguments)
 },{"dup":166}],169:[function(require,module,exports){
 (function (process){
 'use strict';
+var argv = process.argv;
+
 module.exports = (function () {
-	if (process.argv.indexOf('--no-color') !== -1) {
+	if ('FORCE_COLOR' in process.env) {
+		return true;
+	}
+
+	if (argv.indexOf('--no-color') !== -1 ||
+		argv.indexOf('--no-colors') !== -1 ||
+		argv.indexOf('--color=false') !== -1) {
 		return false;
 	}
 
-	if (process.argv.indexOf('--color') !== -1) {
+	if (argv.indexOf('--color') !== -1 ||
+		argv.indexOf('--colors') !== -1 ||
+		argv.indexOf('--color=true') !== -1 ||
+		argv.indexOf('--color=always') !== -1) {
 		return true;
 	}
 
@@ -25414,6 +25466,10 @@ module.exports = (function () {
 		return false;
 	}
 
+	if ('UPSTART_JOB' in process.env) {
+		return false;
+	}
+
 	if (process.platform === 'win32') {
 		return true;
 	}
@@ -25436,7 +25492,7 @@ module.exports = (function () {
 }).call(this,require('_process'))
 },{"_process":145}],170:[function(require,module,exports){
 /**
- * Core.js 0.5.4
+ * Core.js 0.6.1
  * https://github.com/zloirock/core-js
  * License: http://rock.mit-license.org
  * © 2015 Denis Pushkarev
@@ -25502,16 +25558,12 @@ var OBJECT          = 'Object'
   , html            = document && document.documentElement
   , navigator       = global.navigator
   , define          = global.define
+  , console         = global.console || {}
   , ArrayProto      = Array[PROTOTYPE]
   , ObjectProto     = Object[PROTOTYPE]
   , FunctionProto   = Function[PROTOTYPE]
   , Infinity        = 1 / 0
-  , DOT             = '.'
-  // Methods from https://github.com/DeveloperToolsWG/console-object/blob/master/api.md
-  , CONSOLE_METHODS = 'assert,clear,count,debug,dir,dirxml,error,exception,' +
-      'group,groupCollapsed,groupEnd,info,isIndependentlyComposed,log,' +
-      'markTimeline,profile,profileEnd,table,time,timeEnd,timeline,' +
-      'timelineEnd,timeStamp,trace,warn';
+  , DOT             = '.';
 
 // http://jsperf.com/core-js-isobject
 function isObject(it){
@@ -25599,12 +25651,6 @@ function invoke(fn, args, that){
                       : fn.call(that, args[0], args[1], args[2], args[3], args[4]);
   } return              fn.apply(that, args);
 }
-function construct(target, argumentsList /*, newTarget*/){
-  var proto    = assertFunction(arguments.length < 3 ? target : arguments[2])[PROTOTYPE]
-    , instance = create(isObject(proto) ? proto : ObjectProto)
-    , result   = apply.call(target, instance, argumentsList);
-  return isObject(result) ? result : instance;
-}
 
 // Object:
 var create           = Object.create
@@ -25846,32 +25892,97 @@ function assignHidden(target, src){
 
 var SYMBOL_UNSCOPABLES = getWellKnownSymbol('unscopables')
   , ArrayUnscopables   = ArrayProto[SYMBOL_UNSCOPABLES] || {}
-  , SYMBOL_SPECIES     = getWellKnownSymbol('species');
+  , SYMBOL_TAG         = getWellKnownSymbol(TO_STRING_TAG)
+  , SYMBOL_SPECIES     = getWellKnownSymbol('species')
+  , SYMBOL_ITERATOR;
 function setSpecies(C){
-  if(framework || !isNative(C))defineProperty(C, SYMBOL_SPECIES, {
+  if(DESC && (framework || !isNative(C)))defineProperty(C, SYMBOL_SPECIES, {
     configurable: true,
     get: returnThis
   });
+}
+
+/******************************************************************************
+ * Module : common.export                                                     *
+ ******************************************************************************/
+
+var NODE = cof(process) == PROCESS
+  , core = {}
+  , path = framework ? global : core
+  , old  = global.core
+  , exportGlobal
+  // type bitmap
+  , FORCED = 1
+  , GLOBAL = 2
+  , STATIC = 4
+  , PROTO  = 8
+  , BIND   = 16
+  , WRAP   = 32;
+function $define(type, name, source){
+  var key, own, out, exp
+    , isGlobal = type & GLOBAL
+    , target   = isGlobal ? global : (type & STATIC)
+        ? global[name] : (global[name] || ObjectProto)[PROTOTYPE]
+    , exports  = isGlobal ? core : core[name] || (core[name] = {});
+  if(isGlobal)source = name;
+  for(key in source){
+    // there is a similar native
+    own = !(type & FORCED) && target && key in target
+      && (!isFunction(target[key]) || isNative(target[key]));
+    // export native or passed
+    out = (own ? target : source)[key];
+    // prevent global pollution for namespaces
+    if(!framework && isGlobal && !isFunction(target[key]))exp = source[key];
+    // bind timers to global for call from export context
+    else if(type & BIND && own)exp = ctx(out, global);
+    // wrap global constructors for prevent change them in library
+    else if(type & WRAP && !framework && target[key] == out){
+      exp = function(param){
+        return this instanceof out ? new out(param) : out(param);
+      }
+      exp[PROTOTYPE] = out[PROTOTYPE];
+    } else exp = type & PROTO && isFunction(out) ? ctx(call, out) : out;
+    // extend global
+    if(framework && target && !own){
+      if(isGlobal)target[key] = out;
+      else delete target[key] && hidden(target, key, out);
+    }
+    // export
+    if(exports[key] != out)hidden(exports, key, exp);
+  }
 }
-
-// Iterators
-var SYMBOL_ITERATOR = getWellKnownSymbol(ITERATOR)
-  , SYMBOL_TAG      = getWellKnownSymbol(TO_STRING_TAG)
-  , SUPPORT_FF_ITER = FF_ITERATOR in ArrayProto
-  , ITER  = safeSymbol('iter')
+// CommonJS export
+if(typeof module != 'undefined' && module.exports)module.exports = core;
+// RequireJS export
+else if(isFunction(define) && define.amd)define(function(){return core});
+// Export to global object
+else exportGlobal = true;
+if(exportGlobal || framework){
+  core.noConflict = function(){
+    global.core = old;
+    return core;
+  }
+  global.core = core;
+}
+
+/******************************************************************************
+ * Module : common.iterators                                                  *
+ ******************************************************************************/
+
+SYMBOL_ITERATOR = getWellKnownSymbol(ITERATOR);
+var ITER  = safeSymbol('iter')
   , KEY   = 1
   , VALUE = 2
   , Iterators = {}
   , IteratorPrototype = {}
-  , NATIVE_ITERATORS = SYMBOL_ITERATOR in ArrayProto
-    // Safari define byggy iterators w/o `next`
+    // Safari has byggy iterators w/o `next`
   , BUGGY_ITERATORS = 'keys' in ArrayProto && !('next' in [].keys());
 // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
 setIterator(IteratorPrototype, returnThis);
 function setIterator(O, value){
   hidden(O, SYMBOL_ITERATOR, value);
   // Add iterator for FF iterator protocol
-  SUPPORT_FF_ITER && hidden(O, FF_ITERATOR, value);
+  FF_ITERATOR in ArrayProto && hidden(O, FF_ITERATOR, value);
 }
 function createIterator(Constructor, NAME, next, proto){
   Constructor[PROTOTYPE] = create(proto || IteratorPrototype, {next: descriptor(1, next)});
@@ -25934,72 +26045,38 @@ function getIterator(it){
 function stepCall(fn, value, entries){
   return entries ? invoke(fn, value) : fn(value);
 }
-function forOf(iterable, entries, fn, that){
-  var iterator = getIterator(iterable)
-    , f        = ctx(fn, that, entries ? 2 : 1)
-    , step;
-  while(!(step = iterator.next()).done)if(stepCall(f, step.value, entries) === false)return;
+function checkDangerIterClosing(fn){
+  var danger = true;
+  var O = {
+    next: function(){ throw 1 },
+    'return': function(){ danger = false }
+  };
+  O[SYMBOL_ITERATOR] = returnThis;
+  try {
+    fn(O);
+  } catch(e){}
+  return danger;
 }
-
-// core
-var NODE = cof(process) == PROCESS
-  , core = {}
-  , path = framework ? global : core
-  , old  = global.core
-  , exportGlobal
-  // type bitmap
-  , FORCED = 1
-  , GLOBAL = 2
-  , STATIC = 4
-  , PROTO  = 8
-  , BIND   = 16
-  , WRAP   = 32
-  , SIMPLE = 64;
-function $define(type, name, source){
-  var key, own, out, exp
-    , isGlobal = type & GLOBAL
-    , target   = isGlobal ? global : (type & STATIC)
-        ? global[name] : (global[name] || ObjectProto)[PROTOTYPE]
-    , exports  = isGlobal ? core : core[name] || (core[name] = {});
-  if(isGlobal)source = name;
-  for(key in source){
-    // there is a similar native
-    own = !(type & FORCED) && target && key in target
-      && (!isFunction(target[key]) || isNative(target[key]));
-    // export native or passed
-    out = (own ? target : source)[key];
-    // prevent global pollution for namespaces
-    if(!framework && isGlobal && !isFunction(target[key]))exp = source[key];
-    // bind timers to global for call from export context
-    else if(type & BIND && own)exp = ctx(out, global);
-    // wrap global constructors for prevent change them in library
-    else if(type & WRAP && !framework && target[key] == out){
-      exp = function(param){
-        return this instanceof out ? new out(param) : out(param);
-      }
-      exp[PROTOTYPE] = out[PROTOTYPE];
-    } else exp = type & PROTO && isFunction(out) ? ctx(call, out) : out;
-    // extend global
-    if(framework && target && !own){
-      if(isGlobal || type & SIMPLE)target[key] = out;
-      else delete target[key] && hidden(target, key, out);
-    }
-    // export
-    if(exports[key] != out)hidden(exports, key, exp);
-  }
+function closeIterator(iterator){
+  var ret = iterator['return'];
+  if(ret !== undefined)ret.call(iterator);
 }
-// CommonJS export
-if(typeof module != 'undefined' && module.exports)module.exports = core;
-// RequireJS export
-else if(isFunction(define) && define.amd)define(function(){return core});
-// Export to global object
-else exportGlobal = true;
-if(exportGlobal || framework){
-  core.noConflict = function(){
-    global.core = old;
-    return core;
+function safeIterClose(exec, iterator){
+  try {
+    exec(iterator);
+  } catch(e){
+    closeIterator(iterator);
+    throw e;
   }
-  global.core = core;
+}
+function forOf(iterable, entries, fn, that){
+  safeIterClose(function(iterator){
+    var f = ctx(fn, that, entries ? 2 : 1)
+      , step;
+    while(!(step = iterator.next()).done)if(stepCall(f, step.value, entries) === false){
+      return closeIterator(iterator);
+    }
+  }, getIterator(iterable));
 }
 
 /******************************************************************************
@@ -26037,7 +26114,7 @@ if(exportGlobal || framework){
         : SymbolRegistry[key] = Symbol(key);
     },
     // 19.4.2.4 Symbol.iterator
-    iterator: SYMBOL_ITERATOR,
+    iterator: SYMBOL_ITERATOR || getWellKnownSymbol(ITERATOR),
     // 19.4.2.5 Symbol.keyFor(sym)
     keyFor: part.call(keyOf, SymbolRegistry),
     // 19.4.2.10 Symbol.species
@@ -26081,13 +26158,18 @@ if(exportGlobal || framework){
       return result;
     }
   });
+  
+  // 20.2.1.9 Math[@@toStringTag]
+  setToStringTag(Math, MATH, true);
+  // 24.3.3 JSON[@@toStringTag]
+  setToStringTag(global.JSON, 'JSON', true);
 }(safeSymbol('tag'), {}, {}, true);
 
 /******************************************************************************
- * Module : es6.object                                                        *
+ * Module : es6.object.statics                                                *
  ******************************************************************************/
 
-!function(tmp){
+!function(){
   var objectStatic = {
     // 19.1.3.1 Object.assign(target, source)
     assign: assign,
@@ -26112,20 +26194,7 @@ if(exportGlobal || framework){
     }
   }();
   $define(STATIC, OBJECT, objectStatic);
-  
-  if(framework){
-    // 19.1.3.6 Object.prototype.toString()
-    tmp[SYMBOL_TAG] = DOT;
-    if(cof(tmp) != DOT)hidden(ObjectProto, TO_STRING, function(){
-      return '[object ' + classof(this) + ']';
-    });
-  }
-  
-  // 20.2.1.9 Math[@@toStringTag]
-  setToStringTag(Math, MATH, true);
-  // 24.3.3 JSON[@@toStringTag]
-  setToStringTag(global.JSON, 'JSON', true);
-}({});
+}();
 
 /******************************************************************************
  * Module : es6.object.statics-accept-primitives                              *
@@ -26168,7 +26237,7 @@ if(exportGlobal || framework){
 }();
 
 /******************************************************************************
- * Module : es6.number                                                        *
+ * Module : es6.number.statics                                                *
  ******************************************************************************/
 
 !function(isInteger){
@@ -26388,11 +26457,11 @@ if(exportGlobal || framework){
 }(String.fromCharCode);
 
 /******************************************************************************
- * Module : es6.array                                                         *
+ * Module : es6.array.statics                                                 *
  ******************************************************************************/
 
 !function(){
-  $define(STATIC, ARRAY, {
+  $define(STATIC + FORCED * checkDangerIterClosing(Array.from), ARRAY, {
     // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
     from: function(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
       var O       = Object(assertDefined(arrayLike))
@@ -26400,15 +26469,26 @@ if(exportGlobal || framework){
         , mapping = mapfn !== undefined
         , f       = mapping ? ctx(mapfn, arguments[2], 2) : undefined
         , index   = 0
-        , length, result, iter, step;
-      if(isIterable(O))for(iter = getIterator(O), result = new (generic(this, Array)); !(step = iter.next()).done; index++){
-        result[index] = mapping ? f(step.value, index) : step.value;
-      } else for(result = new (generic(this, Array))(length = toLength(O.length)); length > index; index++){
-        result[index] = mapping ? f(O[index], index) : O[index];
+        , length, result, step;
+      if(isIterable(O)){
+        result = new (generic(this, Array));
+        safeIterClose(function(iterator){
+          for(; !(step = iterator.next()).done; index++){
+            result[index] = mapping ? f(step.value, index) : step.value;
+          }
+        }, getIterator(O));
+      } else {
+        result = new (generic(this, Array))(length = toLength(O.length));
+        for(; length > index; index++){
+          result[index] = mapping ? f(O[index], index) : O[index];
+        }
       }
       result.length = index;
       return result;
-    },
+    }
+  });
+  
+  $define(STATIC, ARRAY, {
     // 22.1.2.3 Array.of( ...items)
     of: function(/* ...args */){
       var index  = 0
@@ -26420,6 +26500,14 @@ if(exportGlobal || framework){
     }
   });
   
+  setSpecies(Array);
+}();
+
+/******************************************************************************
+ * Module : es6.array.prototype                                               *
+ ******************************************************************************/
+
+!function(){
   $define(PROTO, ARRAY, {
     // 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
     copyWithin: function(target /* = 0 */, start /* = 0, end = @length */){
@@ -26465,9 +26553,7 @@ if(exportGlobal || framework){
       ArrayUnscopables[it] = true;
     });
     SYMBOL_UNSCOPABLES in ArrayProto || hidden(ArrayProto, SYMBOL_UNSCOPABLES, ArrayUnscopables);
-  }  
-  
-  setSpecies(Array);
+  }
 }();
 
 /******************************************************************************
@@ -26597,30 +26683,55 @@ $define(GLOBAL + BIND, {
 !function(Promise, test){
   isFunction(Promise) && isFunction(Promise.resolve)
   && Promise.resolve(test = new Promise(function(){})) == test
-  || function(asap, DEF){
-    function isThenable(o){
+  || function(asap, RECORD){
+    function isThenable(it){
       var then;
-      if(isObject(o))then = o.then;
+      if(isObject(it))then = it.then;
       return isFunction(then) ? then : false;
     }
-    function notify(def){
-      var chain = def.chain;
-      chain.length && asap(function(){
-        var msg = def.msg
-          , ok  = def.state == 1
-          , i   = 0;
-        while(chain.length > i)!function(react){
+    function handledRejectionOrHasOnRejected(promise){
+      var record = promise[RECORD]
+        , chain  = record.c
+        , i      = 0
+        , react;
+      if(record.h)return true;
+      while(chain.length > i){
+        react = chain[i++];
+        if(react.fail || handledRejectionOrHasOnRejected(react.P))return true;
+      }
+    }
+    function notify(record, reject){
+      var chain = record.c;
+      if(reject || chain.length)asap(function(){
+        var promise = record.p
+          , value   = record.v
+          , ok      = record.s == 1
+          , i       = 0;
+        if(reject && !handledRejectionOrHasOnRejected(promise)){
+          setTimeout(function(){
+            if(!handledRejectionOrHasOnRejected(promise)){
+              if(NODE){
+                if(!process.emit('unhandledRejection', value, promise)){
+                  // default node.js behavior
+                }
+              } else if(isFunction(console.error)){
+                console.error('Unhandled promise rejection', value);
+              }
+            }
+          }, 1e3);
+        } else while(chain.length > i)!function(react){
           var cb = ok ? react.ok : react.fail
             , ret, then;
           try {
             if(cb){
-              ret = cb === true ? msg : cb(msg);
+              if(!ok)record.h = true;
+              ret = cb === true ? value : cb(value);
               if(ret === react.P){
                 react.rej(TypeError(PROMISE + '-chain cycle'));
               } else if(then = isThenable(ret)){
                 then.call(ret, react.res, react.rej);
               } else react.res(ret);
-            } else react.rej(msg);
+            } else react.rej(value);
           } catch(err){
             react.rej(err);
           }
@@ -26628,33 +26739,33 @@ $define(GLOBAL + BIND, {
         chain.length = 0;
       });
     }
-    function resolve(msg){
-      var def = this
+    function resolve(value){
+      var record = this
         , then, wrapper;
-      if(def.done)return;
-      def.done = true;
-      def = def.def || def; // unwrap
+      if(record.d)return;
+      record.d = true;
+      record = record.r || record; // unwrap
       try {
-        if(then = isThenable(msg)){
-          wrapper = {def: def, done: false}; // wrap
-          then.call(msg, ctx(resolve, wrapper, 1), ctx(reject, wrapper, 1));
+        if(then = isThenable(value)){
+          wrapper = {r: record, d: false}; // wrap
+          then.call(value, ctx(resolve, wrapper, 1), ctx(reject, wrapper, 1));
         } else {
-          def.msg = msg;
-          def.state = 1;
-          notify(def);
+          record.v = value;
+          record.s = 1;
+          notify(record);
         }
       } catch(err){
-        reject.call(wrapper || {def: def, done: false}, err); // wrap
+        reject.call(wrapper || {r: record, d: false}, err); // wrap
       }
     }
-    function reject(msg){
-      var def = this;
-      if(def.done)return;
-      def.done = true;
-      def = def.def || def; // unwrap
-      def.msg = msg;
-      def.state = 2;
-      notify(def);
+    function reject(value){
+      var record = this;
+      if(record.d)return;
+      record.d = true;
+      record = record.r || record; // unwrap
+      record.v = value;
+      record.s = 2;
+      notify(record, true);
     }
     function getConstructor(C){
       var S = assertObject(C)[SYMBOL_SPECIES];
@@ -26664,12 +26775,19 @@ $define(GLOBAL + BIND, {
     Promise = function(executor){
       assertFunction(executor);
       assertInstance(this, Promise, PROMISE);
-      var def = {chain: [], state: 0, done: false, msg: undefined};
-      hidden(this, DEF, def);
+      var record = {
+        p: this,      // promise
+        c: [],        // chain
+        s: 0,         // state
+        d: false,     // done
+        v: undefined, // value
+        h: false      // handled rejection
+      };
+      hidden(this, RECORD, record);
       try {
-        executor(ctx(resolve, def, 1), ctx(reject, def, 1));
+        executor(ctx(resolve, record, 1), ctx(reject, record, 1));
       } catch(err){
-        reject.call(def, err);
+        reject.call(record, err);
       }
     }
     assignHidden(Promise[PROTOTYPE], {
@@ -26682,9 +26800,9 @@ $define(GLOBAL + BIND, {
         } , P = react.P = new (S != undefined ? S : Promise)(function(resolve, reject){
           react.res = assertFunction(resolve);
           react.rej = assertFunction(reject);
-        }), def = this[DEF];
-        def.chain.push(react);
-        def.state && notify(def);
+        }), record = this[RECORD];
+        record.c.push(react);
+        record.s && notify(record);
         return P;
       },
       // 25.4.5.1 Promise.prototype.catch(onRejected)
@@ -26727,13 +26845,13 @@ $define(GLOBAL + BIND, {
       },
       // 25.4.4.6 Promise.resolve(x)
       resolve: function(x){
-        return isObject(x) && DEF in x && getPrototypeOf(x) === this[PROTOTYPE]
+        return isObject(x) && RECORD in x && getPrototypeOf(x) === this[PROTOTYPE]
           ? x : new (getConstructor(this))(function(resolve, reject){
             resolve(x);
           });
       }
     });
-  }(nextTick || setImmediate, safeSymbol('def'));
+  }(nextTick || setImmediate, safeSymbol('record'));
   setToStringTag(Promise, PROMISE);
   setSpecies(Promise);
   $define(GLOBAL + FORCED * !isNative(Promise), {Promise: Promise});
@@ -26788,7 +26906,7 @@ $define(GLOBAL + BIND, {
             initFromIterable(that, iterable);
           };
       assignHidden(assignHidden(C[PROTOTYPE], methods), commonMethods);
-      isWeak || defineProperty(C[PROTOTYPE], 'size', {get: function(){
+      isWeak || !DESC || defineProperty(C[PROTOTYPE], 'size', {get: function(){
         return assertDefined(this[SIZE]);
       }});
     } else {
@@ -26797,7 +26915,7 @@ $define(GLOBAL + BIND, {
         , chain  = inst[ADDER](isWeak ? {} : -0, 1)
         , buggyZero;
       // wrap to init collections from iterable
-      if(!NATIVE_ITERATORS || !C.length){
+      if(checkDangerIterClosing(function(O){ new C(O) })){
         C = function(iterable){
           assertInstance(this, C, NAME);
           return initFromIterable(new Native, iterable);
@@ -27097,7 +27215,12 @@ $define(GLOBAL + BIND, {
     // 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
     apply: ctx(call, apply, 3),
     // 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
-    construct: construct,
+    construct: function(target, argumentsList /*, newTarget*/){
+      var proto    = assertFunction(arguments.length < 3 ? target : arguments[2])[PROTOTYPE]
+        , instance = create(isObject(proto) ? proto : ObjectProto)
+        , result   = apply.call(target, instance, argumentsList);
+      return isObject(result) ? result : instance;
+    },
     // 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
     defineProperty: wrap(defineProperty),
     // 26.1.4 Reflect.deleteProperty(target, propertyKey)
@@ -27171,8 +27294,17 @@ $define(GLOBAL + BIND, {
     }
   }
   $define(STATIC, OBJECT, {
+    // https://gist.github.com/WebReflection/9353781
+    getOwnPropertyDescriptors: function(object){
+      var O      = toObject(object)
+        , result = {};
+      forEach.call(ownKeys(O), function(key){
+        defineProperty(result, key, descriptor(0, getOwnDescriptor(O, key)));
+      });
+      return result;
+    },
     // https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-04/apr-9.md#51-objectentries-objectvalues
-    values: createObjectToArray(false),
+    values:  createObjectToArray(false),
     entries: createObjectToArray(true)
   });
   $define(STATIC, REGEXP, {
@@ -27220,10 +27352,9 @@ $define(GLOBAL + BIND, {
     var dict = create(null);
     if(iterable != undefined){
       if(isIterable(iterable)){
-        for(var iter = getIterator(iterable), step, value; !(step = iter.next()).done;){
-          value = step.value;
-          dict[value[0]] = value[1];
-        }
+        forOf(iterable, true, function(key, value){
+          dict[key] = value;
+        });
       } else assign(dict, iterable);
     }
     return dict;
@@ -27679,8 +27810,12 @@ $define(GLOBAL + FORCED, {global: global});
  * Module : core.log                                                          *
  ******************************************************************************/
 
-!function(log, console, enabled){
-  forEach.call(array(CONSOLE_METHODS), function(key){
+!function(log, enabled){
+  // Methods from https://github.com/DeveloperToolsWG/console-object/blob/master/api.md
+  forEach.call(array('assert,clear,count,debug,dir,dirxml,error,exception,' +
+      'group,groupCollapsed,groupEnd,info,isIndependentlyComposed,log,' +
+      'markTimeline,profile,profileEnd,table,time,timeEnd,timeline,' +
+      'timelineEnd,timeStamp,trace,warn'), function(key){
     log[key] = function(){
       if(enabled && key in console)return apply.call(console[key], console, arguments);
     };
@@ -27693,7 +27828,7 @@ $define(GLOBAL + FORCED, {global: global});
       enabled = false;
     }
   })});
-}({}, global.console || {}, true);
+}({}, true);
 }(typeof self != 'undefined' && self.Math === Math ? self : Function('return this')(), false);
 },{}],171:[function(require,module,exports){
 
@@ -37639,27 +37774,33 @@ function through (write, end, opts) {
       }
     },
 
-    _findFinallyEntry: function(finallyLoc) {
+    abrupt: function(type, arg) {
       for (var i = this.tryEntries.length - 1; i >= 0; --i) {
         var entry = this.tryEntries[i];
         if (entry.tryLoc <= this.prev &&
-            hasOwn.call(entry, "finallyLoc") && (
-              entry.finallyLoc === finallyLoc ||
-              this.prev < entry.finallyLoc)) {
-          return entry;
+            hasOwn.call(entry, "finallyLoc") &&
+            this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
         }
       }
-    },
 
-    abrupt: function(type, arg) {
-      var entry = this._findFinallyEntry();
-      var record = entry ? entry.completion : {};
+      if (finallyEntry &&
+          (type === "break" ||
+           type === "continue") &&
+          finallyEntry.tryLoc <= arg &&
+          arg < finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
 
+      var record = finallyEntry ? finallyEntry.completion : {};
       record.type = type;
       record.arg = arg;
 
-      if (entry) {
-        this.next = entry.finallyLoc;
+      if (finallyEntry) {
+        this.next = finallyEntry.finallyLoc;
       } else {
         this.complete(record);
       }
@@ -37686,8 +37827,12 @@ function through (write, end, opts) {
     },
 
     finish: function(finallyLoc) {
-      var entry = this._findFinallyEntry(finallyLoc);
-      return this.complete(entry.completion, entry.afterLoc);
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) {
+          return this.complete(entry.completion, entry.afterLoc);
+        }
+      }
     },
 
     "catch": function(tryLoc) {
@@ -43271,7 +43416,7 @@ module.exports = function (str) {
 module.exports={
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "4.4.5",
+  "version": "4.4.6",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
@@ -43308,10 +43453,10 @@ module.exports={
   "dependencies": {
     "acorn-babel": "0.11.1-34",
     "ast-types": "~0.6.1",
-    "chalk": "^0.5.1",
+    "chalk": "^1.0.0",
     "chokidar": "^0.12.6",
     "commander": "^2.6.0",
-    "core-js": "^0.5.4",
+    "core-js": "^0.6.1",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
     "estraverse": "^1.9.1",
@@ -43326,7 +43471,7 @@ module.exports={
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator-babel": "0.8.10-2",
+    "regenerator-babel": "0.8.13-1",
     "regexpu": "^1.1.1",
     "repeating": "^1.1.2",
     "shebang-regex": "^1.0.0",