core-js 0.9.14 → 0.9.18

package/modules/es6.promise.js

@@ -13,6 +13,7 @@ var $        = require('./$')
   , PROMISE  = 'Promise'
   , global   = $.g
   , process  = global.process
+  , isNode   = cof(process) == 'process'
   , asap     = process && process.nextTick || require('./$.task').set
   , P        = global[PROMISE]
   , isFunction     = $.isFunction
@@ -42,6 +43,14 @@ var useNative = function(){
     if(!(P2.resolve(5).then(function(){}) instanceof P2)){
       works = false;
     }
+    // actual V8 bug, https://code.google.com/p/v8/issues/detail?id=4162
+    if(works && $.DESC){
+      var thenableThenGotten = false;
+      P.resolve($.setDesc({}, 'then', {
+        get: function(){ thenableThenGotten = true; }
+      }));
+      works = thenableThenGotten;
+    }
   } catch(e){ works = false; }
   return works;
 }();
@@ -66,7 +75,8 @@ function isThenable(it){
 }
 function notify(record){
   var chain = record.c;
-  if(chain.length)asap(function(){
+  // strange IE + webpack dev server bug - use .call(global)
+  if(chain.length)asap.call(global, function(){
     var value = record.v
       , ok    = record.s == 1
       , i     = 0;
@@ -112,11 +122,12 @@ function $reject(value){
   record.s = 2;
   record.a = record.c.slice();
   setTimeout(function(){
-    asap(function(){
+    // strange IE + webpack dev server bug - use .call(global)
+    asap.call(global, function(){
       if(isUnhandled(promise = record.p)){
-        if(cof(process) == 'process'){
+        if(isNode){
           process.emit('unhandledRejection', value, promise);
-        } else if(global.console && isFunction(console.error)){
+        } else if(global.console && console.error){
           console.error('Unhandled promise rejection', value);
         }
       }
@@ -127,21 +138,28 @@ function $reject(value){
 }
 function $resolve(value){
   var record = this
-    , then, wrapper;
+    , then;
   if(record.d)return;
   record.d = true;
   record = record.r || record; // unwrap
   try {
     if(then = isThenable(value)){
-      wrapper = {r: record, d: false}; // wrap
-      then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+      // strange IE + webpack dev server bug - use .call(global)
+      asap.call(global, function(){
+        var wrapper = {r: record, d: false}; // wrap
+        try {
+          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+        } catch(e){
+          $reject.call(wrapper, e);
+        }
+      });
     } else {
       record.v = value;
       record.s = 1;
       notify(record);
     }
-  } catch(err){
-    $reject.call(wrapper || {r: record, d: false}, err); // wrap
+  } catch(e){
+    $reject.call({r: record, d: false}, e); // wrap
   }
 }
 

package/modules/es6.weak-map.js

@@ -27,7 +27,7 @@ var $WeakMap = require('./$.collection')('WeakMap', function(get){
 }, weak, true, true);
 
 // IE11 WeakMap frozen keys fix
-if($.FW && new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
+if(new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
   $.each.call(['delete', 'has', 'get', 'set'], function(key){
     var proto  = $WeakMap.prototype
       , method = proto[key];

package/modules/es7.observable.js

@@ -0,0 +1,158 @@
+// Based on https://github.com/zenparsing/es-observable/blob/master/src/Observable.js
+var $              = require('./$')
+  , $def           = require('./$.def')
+  , $redef         = require('./$.redef')
+  , $mix           = require('./$.mix')
+  , asap           = require('./$.task').set
+  , assert         = require('./$.assert')
+  , OBSERVER       = require('./$.wks')('observer')
+  , isFunction     = $.isFunction
+  , assertObject   = assert.obj
+  , assertFunction = assert.fn;
+
+// === Abstract Operations ===
+function cancelSubscription(observer){
+  var subscription = observer._subscription;
+  if(!subscription)return;
+  // Drop the reference to the subscription so that we don't unsubscribe
+  // more than once
+  observer._subscription = undefined;
+  try {
+    // Call the unsubscribe function
+    subscription.unsubscribe();
+  } finally {
+    // Drop the reference to the inner observer so that no more notifications
+    // will be sent
+    observer._observer = undefined;
+  }
+}
+
+function closeSubscription(observer){
+  observer._observer = undefined;
+  cancelSubscription(observer);
+}
+
+function hasUnsubscribe(x){
+  return $.isObject(x) && isFunction(x.unsubscribe);
+}
+
+function SubscriptionObserver(observer){
+  this._observer = observer;
+  this._subscription = undefined;
+}
+$mix(SubscriptionObserver.prototype, {
+  next: function(value){
+    var observer = this._observer
+      , result;
+    // If the stream if closed, then return a "done" result
+    if(!observer)return { value: undefined, done: true };
+    try {
+      // Send the next value to the sink
+      result = observer.next(value);
+    } catch (e) {
+      // If the observer throws, then close the stream and rethrow the error
+      closeSubscription(this);
+      throw e;
+    }
+    // Cleanup if sink is closed
+    if(result && result.done)closeSubscription(this);
+    return result;
+  },
+  'throw': function(value){
+    var observer = this._observer;
+    // If the stream is closed, throw the error to the caller
+    if(!observer)throw value;
+    this._observer = undefined;
+    try {
+      // If the sink does not support "throw", then throw the error to the caller
+      if(!('throw' in observer))throw value;
+      return observer['throw'](value);
+    } finally {
+      cancelSubscription(this);
+    }
+  },
+  'return': function(value){
+    var observer = this._observer;
+    // If the stream is closed, then return a done result
+    if (!observer)return {value: value, done: true};
+    this._observer = undefined;
+    try {
+      // If the sink does not support "return", then return a done result
+      if (!('return' in observer))return {value: value, done: true};
+      return observer['return'](value);
+    } finally {
+      cancelSubscription(this);
+    }
+  }
+});
+
+function Observable(subscriber){
+  // The stream subscriber must be a function
+  this._subscriber = assertFunction(subscriber);
+}
+$mix(Observable.prototype, {
+  subscribe: function(observer){
+    // The sink must be an object
+    assertObject(observer);
+    var unsubscribed = false
+      , that = this
+      , subscription;
+    asap.call(global, function(){
+      if(!unsubscribed)subscription = that[OBSERVER](observer);
+    });
+    return {
+      unsubscribe: function(){
+        if(unsubscribed)return;
+        unsubscribed = true;
+        if(subscription)subscription.unsubscribe();
+      }
+    };
+  },
+  forEach: function(fn, thisArg){
+    var that = this;
+    return new ($.core.Promise || $.g.Promise)(function(resolve, reject){
+      assertFunction(fn);
+      that.subscribe({
+        next: function(value){ fn.call(thisArg, value); },
+        'throw': function(value){ reject(value); },
+        'return': function(){ resolve(undefined); }
+      });
+    });
+  }
+});
+$redef(Observable.prototype, OBSERVER, function(observer){
+  // The sink must be an object
+  // Wrap the observer in order to maintain observation invariants
+  observer = new SubscriptionObserver(assertObject(observer));
+  var subscription;
+  try {
+    // Call the subscriber function
+    subscription = this._subscriber.call(undefined, observer);
+    if(!hasUnsubscribe(subscription)){
+      var unsubscribe = isFunction(subscription)
+        ? subscription
+        : function(){ observer['return'](); };
+      subscription = {unsubscribe: unsubscribe};
+    }
+  } catch(e){
+    // If an error occurs during startup, then attempt to send the error
+    // to the observer
+    observer['throw'](e);
+  }
+  observer._subscription = subscription;
+  // If the stream is already finished, then perform cleanup
+  if(!observer._observer)cancelSubscription(observer);
+  // Return the subscription object
+  return subscription;
+});
+$redef(Observable, 'from', function(x){
+  if(assertObject(x)._subscriber && x.constructor === this)return x;
+  var subscribeFunction = assertFunction(x[OBSERVER]);
+  return new this(function(sink){
+    subscribeFunction.call(x, sink);
+  });
+});
+
+
+$def($def.G + $def.F, {Observable: Observable});
+$def($def.S, 'Symbol', {observer: OBSERVER});

package/modules/es7.regexp.escape.js

@@ -1,5 +1,5 @@
-// https://gist.github.com/kangax/9698100
+// https://github.com/benjamingr/RexExp.escape
 var $def = require('./$.def');
 $def($def.S, 'RegExp', {
-  escape: require('./$.replacer')(/([\\\-[\]{}()*+?.,^$|])/g, '\\$1', true)
-});
+  escape: require('./$.replacer')(/[\\^$*+?.()|[\]{}]/g, '\\$&', true)
+});

package/modules/library/modules/$.collection.js

@@ -0,0 +1,49 @@
+'use strict';
+var $     = require('./$')
+  , $def  = require('./$.def')
+  , $iter = require('./$.iter')
+  , BUGGY = $iter.BUGGY
+  , forOf = require('./$.for-of')
+  , assertInstance = require('./$.assert').inst
+  , INTERNAL = require('./$.uid').safe('internal');
+
+module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
+  var Base  = $.g[NAME]
+    , C     = Base
+    , ADDER = IS_MAP ? 'set' : 'add'
+    , proto = C && C.prototype
+    , O     = {};
+  if(!$.DESC || !$.isFunction(C) || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){
+    // create collection constructor
+    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+    require('./$.mix')(C.prototype, methods);
+  } else {
+    C = wrapper(function(target, iterable){
+      assertInstance(target, C, NAME);
+      target[INTERNAL] = new Base;
+      if(iterable != undefined)forOf(iterable, IS_MAP, target[ADDER], target);
+    });
+    $.each.call('add,clear,delete,forEach,get,has,set,keys,values,entries'.split(','),function(KEY){
+      var chain = KEY == 'add' || KEY == 'set';
+      if(KEY in proto)$.hide(C.prototype, KEY, function(a, b){
+        var result = this[INTERNAL][KEY](a === 0 ? 0 : a, b);
+        return chain ? this : result;
+      });
+    });
+    if('size' in proto)$.setDesc(C.prototype, 'size', {
+      get: function(){
+        return this[INTERNAL].size;
+      }
+    });
+  }
+
+  require('./$.cof').set(C, NAME);
+
+  O[NAME] = C;
+  $def($def.G + $def.W + $def.F, O);
+  require('./$.species')(C);
+
+  if(!IS_WEAK)common.setIter(C, NAME, IS_MAP);
+
+  return C;
+};

package/modules/library/modules/$.unscope.js

@@ -0,0 +1 @@
+module.exports = function(){ /* empty */ };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "core-js",
   "description": "Standard library",
-  "version": "0.9.14",
+  "version": "0.9.18",
   "repository": {
     "type": "git",
     "url": "https://github.com/zloirock/core-js.git"
@@ -21,12 +21,12 @@
     "karma": "0.12.x",
     "karma-qunit": "0.1.x",
     "karma-chrome-launcher": "0.1.x",
-    "karma-ie-launcher": "0.1.x",
+    "karma-ie-launcher": "0.2.x",
     "karma-firefox-launcher": "0.1.x",
     "karma-opera-launcher": "0.1.x",
     "karma-phantomjs-launcher": "0.2.x",
     "promises-aplus-tests": "2.1.x",
-    "eslint": "^0.22.1"
+    "eslint": "0.23.x"
   },
   "scripts": {
     "grunt": "grunt",