A-A+

使用fetch遇到过的坑

2017年03月11日 JavaScript 暂无评论 阅读 2,918 次

前段时间在项目中用到了这个fetch 来代替Ajax 进行网络请求。也踩了不少的坑,在这边列举出来以及他的解决方法。

1.如何保持每次请求的会话一致?

在用fetch进行网络请求的时候,发现每次请求到服务端的时候,他的sessionId 都是不一样的,后面排查原来是在请求的时候fetch默认是不会带上本地jsessionId,以至于服务端无法接收到,所以会重新创建一个新的session。

解决办法:

 

[javascript] view plain copy

  1. var init = {
  2.     credentials: 'include' // 请求带上cookies,是每次请求保持会话一直
  3.          ...
  4. }

 

2.兼容性,支持IE10+、谷歌、火狐等

由于fetch是一个新技术,有些旧的浏览器对它并不支持,这时候要怎么兼容?

 

解决办法:

引入一个额外的补丁es6-promise.js可以使它很好的支持IE9以上的版本,那IE8呢?IE8 需要改fetch.js源码才能支持

fetch.js 只需改两处:

 

try里面的是源码本身的,catch里面的是小编额外加的。细心的会发现这两处改的是一样的,都是对getOwnPropertyNames进行替换。但是IE8也不支持forEach为啥没有替换    呢? 其实有替换了,只是不再这边体现。我把它写进了Array.prototype里面了,其实fetch.js里面也用到了indexOf,它在IE8下也是不支持,我把它一并的放在Array.prototype

代码如下:

[javascript] view plain copy

  1. Array.prototype.forEach = function(callback, thisArg) {
  2.         var T, k;
  3.         if (this == null) {
  4.             throw new TypeError(" this is null or not defined");
  5.         }
  6.         var O = Object(this);
  7.         var len = O.length >>> 0; // Hack to convert O.length to a UInt32  
  8.         if ({}.toString.call(callback) != "[object Function]") {
  9.             throw new TypeError(callback + " is not a function");
  10.         }
  11.         if (thisArg) {
  12.             T = thisArg;
  13.         }
  14.         k = 0;
  15.         while (k < len) {
  16.             var kValue;
  17.             if (k in O) {
  18.                 kValue = O[k];
  19.                 callback.call(T, kValue, k, O);
  20.             }
  21.             k++;
  22.         }
  23.     };
  24.     if (!Array.prototype.indexOf)
  25.     {
  26.       Array.prototype.indexOf = function(elt /*, from*/)
  27.       {
  28.         var len = this.length >>> 0;
  29.         var from = Number(arguments[1]) || 0;
  30.         from = (from < 0)
  31.              ? Math.ceil(from)
  32.              : Math.floor(from);
  33.         if (from < 0)
  34.           from += len;
  35.         for (; from < len; from++)
  36.         {
  37.           if (from in this &&
  38.               this[from] === elt)
  39.             return from;
  40.         }
  41.         return -1;
  42.       };
  43.     };

 

最后附上修改后的文件以及自己封装的一个网络请求request.js。

request.js:

[javascript] view plain copy

  1. /**
  2.  * 该方法仅支持IE8以上
  3. * 网络请求方法
  4. * url:请求地址
  5. * options = {
  6. *   catchs: 异常处理,控制台抛出的异常是否自己处理:true 是,false 否 由公共方法统一处理优化显示给用户 默认 false
  7. *   credentials: 请求带上cookies,是每次请求保持会话一直
  8. *   method: 请求使用的方法,如 GET、POST
  9. *   headers: 请求的头信息,形式为 Headers 对象或 ByteString。
  10. *   body: 请求的 body 信息:可能是一个 Blob、BufferSource、FormData、URLSearchParams 或者 USVString 对象。注意 GET 或 HEAD 方法的请求不能包含 body 信息。
  11. *   mode: 请求的模式,如 cors、no-cors 或者same-origin。是否允许跨域请求
  12. *   cache:  请求的 cache 模式: default, no-store, reload, no-cache, force-cache, or only-if-cached.
  13. * }
  14. */
  15. var $requst = function (url, options) {
  16.     var myHeaders = {
  17.         'Content-Type''text/html; charset=utf-8'
  18.     };
  19.     var init = {
  20.         credentials: 'include',
  21.         method: (options && options.method) || 'GET',
  22.         headers: (options && options.headers) || myHeaders,
  23.         cache: (options && options.cache) || 'default'
  24.     }
  25.     if (options && options.body) {
  26.         init.body = JSON.stringify(options.body)
  27.     }
  28.     return fetch(url, init)
  29.       .then(function(response) {
  30.           if (response.ok) {
  31.               return _returnContentByType(response);
  32.           } else {
  33.               if (options && options.catchs) {
  34.                   throw new Error(response.statusText);
  35.               } else {
  36.                   var error = new Error(response.statusText);
  37.                   throw new Error('');
  38.               }
  39.           }
  40.       });
  41. };
  42. /**
  43.  * 根据type返回不同格式的response
  44.  */
  45. var _returnContentByType = function (response) {
  46.     var type = response.headers.get('Content-Type').split(";")[0];
  47.     switch (type) {
  48.         case 'text/html':
  49.             return response.text();
  50.             break
  51.         case 'application/json':
  52.             return response.json();
  53.             break
  54.         default:
  55.     }
  56. };

fetch.js:

[javascript] view plain copy

  1. (function() {
  2.   'use strict';
  3.   // if __disableNativeFetch is set to true, the it will always polyfill fetch
  4.   // with Ajax.
  5.   if (!self.__disableNativeFetch && self.fetch) {
  6.     return
  7.   }
  8.   function normalizeName(name) {
  9.     if (typeof name !== 'string') {
  10.       name = String(name)
  11.     }
  12.     if (/[^a-z0-9-#$%&'*+.^_`|~]/i.test(name)) {
  13.       throw new TypeError('Invalid character in header field name')
  14.     }
  15.     return name.toLowerCase()
  16.   }
  17.   function normalizeValue(value) {
  18.     if (typeof value !== 'string') {
  19.       value = String(value)
  20.     }
  21.     return value
  22.   }
  23.   function Headers(headers) {
  24.     this.map = {}
  25.     if (headers instanceof Headers) {
  26.       headers.forEach(function(value, name) {
  27.         this.append(name, value)
  28.       }, this)
  29.     } else if (headers) {
  30.         try{
  31.             Object.getOwnPropertyNames(headers).forEach(function(name) {
  32.                 this.append(name, headers[name])
  33.             }, this)
  34.         }catch(e){
  35.             var a = [];
  36.              for (var i in headers) {
  37.                 if (headers.hasOwnProperty(i)) {
  38.                     a.push(i); // 输出 foo asj
  39.                 }
  40.             };
  41.              a.forEach(function(name) {
  42.                     this.append(name, headers[name])
  43.                 }, this)
  44.         }
  45.     }
  46.   }
  47.   Headers.prototype.append = function(name, value) {
  48.     name = normalizeName(name)
  49.     value = normalizeValue(value)
  50.     var list = this.map[name]
  51.     if (!list) {
  52.       list = []
  53.       this.map[name] = list
  54.     }
  55.     list.push(value)
  56.   }
  57.   Headers.prototype['delete'] = function(name) {
  58.     delete this.map[normalizeName(name)]
  59.   }
  60.   Headers.prototype.get = function(name) {
  61.     var values = this.map[normalizeName(name)]
  62.     return values ? values[0] : null
  63.   }
  64.   Headers.prototype.getAll = function(name) {
  65.     return this.map[normalizeName(name)] || []
  66.   }
  67.   Headers.prototype.has = function(name) {
  68.     return this.map.hasOwnProperty(normalizeName(name))
  69.   }
  70.   Headers.prototype.set = function(name, value) {
  71.     this.map[normalizeName(name)] = [normalizeValue(value)]
  72.   }
  73.   Headers.prototype.forEach = function(callback, thisArg) {
  74.       try{
  75.           Object.getOwnPropertyNames(this.map).forEach(function(name) {
  76.               this.map[name].forEach(function(value) {
  77.                   callback.call(thisArg, value, name, this)
  78.               }, this)
  79.           }, this)
  80.       }catch(e){
  81.          var a = [];
  82.          for (var i in this.map) {
  83.             if (this.map.hasOwnProperty(i)) {
  84.                 a.push(i); // 输出 foo asj
  85.             }
  86.         };
  87.          a.forEach(function(name) {
  88.               this.map[name].forEach(function(value) {
  89.                   callback.call(thisArg, value, name, this)
  90.               }, this)
  91.           }, this)
  92.       }
  93.   }
  94.   function consumed(body) {
  95.     if (body.bodyUsed) {
  96.       return Promise.reject(new TypeError('Already read'))
  97.     }
  98.     body.bodyUsed = true
  99.   }
  100.   function fileReaderReady(reader) {
  101.     return new Promise(function(resolve, reject) {
  102.       reader.onload = function() {
  103.         resolve(reader.result)
  104.       }
  105.       reader.onerror = function() {
  106.         reject(reader.error)
  107.       }
  108.     })
  109.   }
  110.   function readBlobAsArrayBuffer(blob) {
  111.     var reader = new FileReader()
  112.     reader.readAsArrayBuffer(blob)
  113.     return fileReaderReady(reader)
  114.   }
  115.   function readBlobAsText(blob, options) {
  116.     var reader = new FileReader()
  117.     var contentType = options.headers.map['content-type'] ? options.headers.map['content-type'].toString() : ''
  118.     var regex = /charset=[0-9a-zA-Z-_]*;?/
  119.     var _charset = blob.type.match(regex) || contentType.match(regex)
  120.     var args = [blob]
  121.     if(_charset) {
  122.       args.push(_charset[0].replace(/^charset=/, '').replace(/;$/, ''))
  123.     }
  124.     reader.readAsText.apply(reader, args)
  125.     return fileReaderReady(reader)
  126.   }
  127.   var support = {
  128.     blob: 'FileReader' in self && 'Blob' in self && (function() {
  129.       try {
  130.         new Blob();
  131.         return true
  132.       } catch(e) {
  133.         return false
  134.       }
  135.     })(),
  136.     formData: 'FormData' in self,
  137.     arrayBuffer: 'ArrayBuffer' in self
  138.   }
  139.   function Body() {
  140.     this.bodyUsed = false
  141.     this._initBody = function(body, options) {
  142.       this._bodyInit = body
  143.       if (typeof body === 'string') {
  144.         this._bodyText = body
  145.       } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
  146.         this._bodyBlob = body
  147.         this._options = options
  148.       } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
  149.         this._bodyFormData = body
  150.       } else if (!body) {
  151.         this._bodyText = ''
  152.       } else if (support.arrayBuffer && ArrayBuffer.prototype.isPrototypeOf(body)) {
  153.         // Only support ArrayBuffers for POST method.
  154.         // Receiving ArrayBuffers happens via Blobs, instead.
  155.       } else {
  156.         throw new Error('unsupported BodyInit type')
  157.       }
  158.     }
  159.     if (support.blob) {
  160.       this.blob = function() {
  161.         var rejected = consumed(this)
  162.         if (rejected) {
  163.           return rejected
  164.         }
  165.         if (this._bodyBlob) {
  166.           return Promise.resolve(this._bodyBlob)
  167.         } else if (this._bodyFormData) {
  168.           throw new Error('could not read FormData body as blob')
  169.         } else {
  170.           return Promise.resolve(new Blob([this._bodyText]))
  171.         }
  172.       }
  173.       this.arrayBuffer = function() {
  174.         return this.blob().then(readBlobAsArrayBuffer)
  175.       }
  176.       this.text = function() {
  177.         var rejected = consumed(this)
  178.         if (rejected) {
  179.           return rejected
  180.         }
  181.         if (this._bodyBlob) {
  182.           return readBlobAsText(this._bodyBlob, this._options)
  183.         } else if (this._bodyFormData) {
  184.           throw new Error('could not read FormData body as text')
  185.         } else {
  186.           return Promise.resolve(this._bodyText)
  187.         }
  188.       }
  189.     } else {
  190.       this.text = function() {
  191.         var rejected = consumed(this)
  192.         return rejected ? rejected : Promise.resolve(this._bodyText)
  193.       }
  194.     }
  195.     if (support.formData) {
  196.       this.formData = function() {
  197.         return this.text().then(decode)
  198.       }
  199.     }
  200.     this.json = function() {
  201.       return this.text().then(JSON.parse)
  202.     }
  203.     return this
  204.   }
  205.   // HTTP methods whose capitalization should be normalized
  206.   var methods = ['DELETE''GET''HEAD''OPTIONS''POST''PUT']
  207.   function normalizeMethod(method) {
  208.     var upcased = method.toUpperCase()
  209.     return (methods.indexOf(upcased) > -1) ? upcased : method
  210.   }
  211.   function Request(input, options) {
  212.     options = options || {}
  213.     var body = options.body
  214.     if (Request.prototype.isPrototypeOf(input)) {
  215.       if (input.bodyUsed) {
  216.         throw new TypeError('Already read')
  217.       }
  218.       this.url = input.url
  219.       this.credentials = input.credentials
  220.       if (!options.headers) {
  221.         this.headers = new Headers(input.headers)
  222.       }
  223.       this.method = input.method
  224.       this.mode = input.mode
  225.       if (!body) {
  226.         body = input._bodyInit
  227.         input.bodyUsed = true
  228.       }
  229.     } else {
  230.       this.url = input
  231.     }
  232.     this.credentials = options.credentials || this.credentials || 'omit'
  233.     if (options.headers || !this.headers) {
  234.       this.headers = new Headers(options.headers)
  235.     }
  236.     this.method = normalizeMethod(options.method || this.method || 'GET')
  237.     this.mode = options.mode || this.mode || null
  238.     this.referrer = null
  239.     if ((this.method === 'GET' || this.method === 'HEAD') && body) {
  240.       throw new TypeError('Body not allowed for GET or HEAD requests')
  241.     }
  242.     this._initBody(body, options)
  243.   }
  244.   Request.prototype.clone = function() {
  245.     return new Request(this)
  246.   }
  247.   function decode(body) {
  248.     var form = new FormData()
  249.     body.trim().split('&').forEach(function(bytes) {
  250.       if (bytes) {
  251.         var split = bytes.split('=')
  252.         var name = split.shift().replace(/+/g, ' ')
  253.         var value = split.join('=').replace(/+/g, ' ')
  254.         form.append(decodeURIComponent(name), decodeURIComponent(value))
  255.       }
  256.     })
  257.     return form
  258.   }
  259.   function headers(xhr) {
  260.     var head = new Headers()
  261.     var pairs = xhr.getAllResponseHeaders().trim().split('n')
  262.     pairs.forEach(function(header) {
  263.       var split = header.trim().split(':')
  264.       var key = split.shift().trim()
  265.       var value = split.join(':').trim()
  266.       head.append(key, value)
  267.     })
  268.     return head
  269.   }
  270.   Body.call(Request.prototype)
  271.   function Response(bodyInit, options) {
  272.     if (!options) {
  273.       options = {}
  274.     }
  275.     this._initBody(bodyInit, options)
  276.     this.type = 'default'
  277.     this.status = options.status
  278.     this.ok = this.status >= 200 && this.status < 300
  279.     this.statusText = options.statusText
  280.     this.headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers)
  281.     this.url = options.url || ''
  282.   }
  283.   Body.call(Response.prototype)
  284.   Response.prototype.clone = function() {
  285.     return new Response(this._bodyInit, {
  286.       status: this.status,
  287.       statusText: this.statusText,
  288.       headers: new Headers(this.headers),
  289.       url: this.url
  290.     })
  291.   }
  292.   Response.error = function() {
  293.     var response = new Response(null, {status: 0, statusText: ''})
  294.     response.type = 'error'
  295.     return response
  296.   }
  297.   var redirectStatuses = [301, 302, 303, 307, 308]
  298.   Response.redirect = function(url, status) {
  299.     if (redirectStatuses.indexOf(status) === -1) {
  300.       throw new RangeError('Invalid status code')
  301.     }
  302.     return new Response(null, {status: status, headers: {location: url}})
  303.   }
  304.   self.Headers = Headers;
  305.   self.Request = Request;
  306.   self.Response = Response;
  307.   self.fetch = function(input, init) {
  308.     return new Promise(function(resolve, reject) {
  309.       var request
  310.       if (Request.prototype.isPrototypeOf(input) && !init) {
  311.         request = input
  312.       } else {
  313.         request = new Request(input, init)
  314.       }
  315.       var xhr = new XMLHttpRequest()
  316.       function responseURL() {
  317.         if ('responseURL' in xhr) {
  318.           return xhr.responseURL
  319.         }
  320.         // Avoid security warnings on getResponseHeader when not allowed by CORS
  321.         if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
  322.           return xhr.getResponseHeader('X-Request-URL')
  323.         }
  324.         return;
  325.       }
  326.       var __onLoadHandled = false;
  327.       function onload() {
  328.         if (xhr.readyState !== 4) {
  329.           return
  330.         }
  331.         var status = (xhr.status === 1223) ? 204 : xhr.status
  332.         if (status < 100 || status > 599) {
  333.           if (__onLoadHandled) { return; } else { __onLoadHandled = true; }
  334.           reject(new TypeError('Network request failed'))
  335.           return
  336.         }
  337.         var options = {
  338.           status: status,
  339.           statusText: xhr.statusText,
  340.           headers: headers(xhr),
  341.           url: responseURL()
  342.         }
  343.         var body = 'response' in xhr ? xhr.response : xhr.responseText;
  344.         if (__onLoadHandled) { return; } else { __onLoadHandled = true; }
  345.         resolve(new Response(body, options))
  346.       }
  347.       xhr.onreadystatechange = onload;
  348.       xhr.onload = onload;
  349.       xhr.onerror = function() {
  350.         if (__onLoadHandled) { return; } else { __onLoadHandled = true; }
  351.         reject(new TypeError('Network request failed'))
  352.       }
  353.       xhr.open(request.method, request.url, true)
  354.       // `withCredentials` should be setted after calling `.open` in IE10
  355.       // http://stackoverflow.com/a/19667959/1219343
  356.       try {
  357.         if (request.credentials === 'include') {
  358.           if ('withCredentials' in xhr) {
  359.             xhr.withCredentials = true;
  360.           } else {
  361.             console && console.warn && console.warn('withCredentials is not supported, you can ignore this warning');
  362.           }
  363.         }
  364.       } catch (e) {
  365.         console && console.warn && console.warn('set withCredentials error:' + e);
  366.       }
  367.       if ('responseType' in xhr && support.blob) {
  368.         xhr.responseType = 'blob'
  369.       }
  370.       request.headers.forEach(function(value, name) {
  371.         xhr.setRequestHeader(name, value)
  372.       })
  373.       xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
  374.     })
  375.   }
  376.   self.fetch.polyfill = true
  377.   // Support CommonJS
  378.   if (typeof module !== 'undefined' && module.exports) {
  379.     module.exports = self.fetch;
  380.   }
  381. })();

es6-promise.js:

[javascript] view plain copy

  1. /*!
  2.  * @overview es6-promise - a tiny implementation of Promises/A+.
  3.  * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
  4.  * @license   Licensed under MIT license
  5.  *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
  6.  * @version   3.2.2+39aa2571
  7.  */
  8. (function() {
  9.     "use strict";
  10.     function lib$es6$promise$utils$$objectOrFunction(x) {
  11.       return typeof x === 'function' || (typeof x === 'object' && x !== null);
  12.     }
  13.     function lib$es6$promise$utils$$isFunction(x) {
  14.       return typeof x === 'function';
  15.     }
  16.     function lib$es6$promise$utils$$isMaybeThenable(x) {
  17.       return typeof x === 'object' && x !== null;
  18.     }
  19.     var lib$es6$promise$utils$$_isArray;
  20.     if (!Array.isArray) {
  21.       lib$es6$promise$utils$$_isArray = function (x) {
  22.         return Object.prototype.toString.call(x) === '[object Array]';
  23.       };
  24.     } else {
  25.       lib$es6$promise$utils$$_isArray = Array.isArray;
  26.     }
  27.     var lib$es6$promise$utils
    isArray=lib$es6$promise$utils

    _isArray;

  28.     var lib$es6$promise$asap$$len = 0;
  29.     var lib$es6$promise$asap$$vertxNext;
  30.     var lib$es6$promise$asap$$customSchedulerFn;
  31.     var lib$es6$promise$asap$$asap = function asap(callback, arg) {
  32.       lib$es6$promise$asap
    queue[lib$es6$promise$asap

    len] = callback;

  33.       lib$es6$promise$asap
    queue[lib$es6$promise$asap

    len + 1] = arg;

  34.       lib$es6$promise$asap$$len += 2;
  35.       if (lib$es6$promise$asap$$len === 2) {
  36.         // If len is 2, that means that we need to schedule an async flush.
  37.         // If additional callbacks are queued before the queue is flushed, they
  38.         // will be processed by this flush that we are scheduling.
  39.         if (lib$es6$promise$asap$$customSchedulerFn) {
  40.           lib$es6$promise$asap
    customSchedulerFn(lib$es6$promise$asap

    flush);

  41.         } else {
  42.           lib$es6$promise$asap$$scheduleFlush();
  43.         }
  44.       }
  45.     }
  46.     function lib$es6$promise$asap$$setScheduler(scheduleFn) {
  47.       lib$es6$promise$asap$$customSchedulerFn = scheduleFn;
  48.     }
  49.     function lib$es6$promise$asap$$setAsap(asapFn) {
  50.       lib$es6$promise$asap$$asap = asapFn;
  51.     }
  52.     var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;
  53.     var lib$es6$promise$asap
    browserGlobal=lib$es6$promise$asap

    browserWindow || {};

  54.     var lib$es6$promise$asap
    BrowserMutationObserver=lib$es6$promise$asap

    browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;

  55.     var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
  56.     // test for web worker but not in IE10
  57.     var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
  58.       typeof importScripts !== 'undefined' &&
  59.       typeof MessageChannel !== 'undefined';
  60.     // node
  61.     function lib$es6$promise$asap$$useNextTick() {
  62.       // node version 0.10.x displays a deprecation warning when nextTick is used recursively
  63.       // see https://github.com/cujojs/when/issues/410 for details
  64.       return function() {
  65.         process.nextTick(lib$es6$promise$asap$$flush);
  66.       };
  67.     }
  68.     // vertx
  69.     function lib$es6$promise$asap$$useVertxTimer() {
  70.       return function() {
  71.         lib$es6$promise$asap
    vertxNext(lib$es6$promise$asap

    flush);

  72.       };
  73.     }
  74.     function lib$es6$promise$asap$$useMutationObserver() {
  75.       var iterations = 0;
  76.       var observer = new lib$es6$promise$asap
    BrowserMutationObserver(lib$es6$promise$asap

    flush);

  77.       var node = document.createTextNode('');
  78.       observer.observe(node, { characterData: true });
  79.       return function() {
  80.         node.data = (iterations = ++iterations % 2);
  81.       };
  82.     }
  83.     // web worker
  84.     function lib$es6$promise$asap$$useMessageChannel() {
  85.       var channel = new MessageChannel();
  86.       channel.port1.onmessage = lib$es6$promise$asap$$flush;
  87.       return function () {
  88.         channel.port2.postMessage(0);
  89.       };
  90.     }
  91.     function lib$es6$promise$asap$$useSetTimeout() {
  92.       return function() {
  93.         setTimeout(lib$es6$promise$asap$$flush, 1);
  94.       };
  95.     }
  96.     var lib$es6$promise$asap$$queue = new Array(1000);
  97.     function lib$es6$promise$asap$$flush() {
  98.       for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {
  99.         var callback = lib$es6$promise$asap$$queue[i];
  100.         var arg = lib$es6$promise$asap$$queue[i+1];
  101.         callback(arg);
  102.         lib$es6$promise$asap$$queue[i] = undefined;
  103.         lib$es6$promise$asap$$queue[i+1] = undefined;
  104.       }
  105.       lib$es6$promise$asap$$len = 0;
  106.     }
  107.     function lib$es6$promise$asap$$attemptVertx() {
  108.       try {
  109.         var r = require;
  110.         var vertx = r('vertx');
  111.         lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;
  112.         return lib$es6$promise$asap$$useVertxTimer();
  113.       } catch(e) {
  114.         return lib$es6$promise$asap$$useSetTimeout();
  115.       }
  116.     }
  117.     var lib$es6$promise$asap$$scheduleFlush;
  118.     // Decide what async method to use to triggering processing of queued callbacks:
  119.     if (lib$es6$promise$asap$$isNode) {
  120.       lib$es6$promise$asap
    scheduleFlush=lib$es6$promise$asap

    useNextTick();

  121.     } else if (lib$es6$promise$asap$$BrowserMutationObserver) {
  122.       lib$es6$promise$asap
    scheduleFlush=lib$es6$promise$asap

    useMutationObserver();

  123.     } else if (lib$es6$promise$asap$$isWorker) {
  124.       lib$es6$promise$asap
    scheduleFlush=lib$es6$promise$asap

    useMessageChannel();

  125.     } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') {
  126.       lib$es6$promise$asap
    scheduleFlush=lib$es6$promise$asap

    attemptVertx();

  127.     } else {
  128.       lib$es6$promise$asap
    scheduleFlush=lib$es6$promise$asap

    useSetTimeout();

  129.     }
  130.     function lib$es6$promise$then$$then(onFulfillment, onRejection) {
  131.       var parent = this;
  132.       var child = new this.constructor(lib$es6$promise
    internal

    noop);

  133.       if (child[lib$es6$promise
    internal

    PROMISE_ID] === undefined) {

  134.         lib$es6$promise
    internal

    makePromise(child);

  135.       }
  136.       var state = parent._state;
  137.       if (state) {
  138.         var callback = arguments[state - 1];
  139.         lib$es6$promise$asap$$asap(function(){
  140.           lib$es6$promise
    internal

    invokeCallback(state, child, callback, parent._result);

  141.         });
  142.       } else {
  143.         lib$es6$promise
    internal

    subscribe(parent, child, onFulfillment, onRejection);

  144.       }
  145.       return child;
  146.     }
  147.     var lib$es6$promise$then$$default = lib$es6$promise$then$$then;
  148.     function lib$es6$promise$promise$resolve$$resolve(object) {
  149.       /*jshint validthis:true */
  150.       var Constructor = this;
  151.       if (object && typeof object === 'object' && object.constructor === Constructor) {
  152.         return object;
  153.       }
  154.       var promise = new Constructor(lib$es6$promise
    internal

    noop);

  155.       lib$es6$promise
    internal

    resolve(promise, object);

  156.       return promise;
  157.     }
  158.     var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;
  159.     var lib$es6$promise
    internal

    PROMISE_ID = Math.random().toString(36).substring(16);

  160.     function lib$es6$promise
    internal

    noop() {}

  161.     var lib$es6$promise
    internal

    PENDING   = void 0;

  162.     var lib$es6$promise
    internal

    FULFILLED = 1;

  163.     var lib$es6$promise
    internal

    REJECTED  = 2;

  164.     var lib$es6$promise
    internal

    GET_THEN_ERROR = new lib$es6$promise

    internal

    ErrorObject();

  165.     function lib$es6$promise
    internal

    selfFulfillment() {

  166.       return new TypeError("You cannot resolve a promise with itself");
  167.     }
  168.     function lib$es6$promise
    internal

    cannotReturnOwn() {

  169.       return new TypeError('A promises callback cannot return that same promise.');
  170.     }
  171.     function lib$es6$promise
    internal

    getThen(promise) {

  172.       try {
  173.         return promise.then;
  174.       } catch(error) {
  175.         lib$es6$promise
    internal

    GET_THEN_ERROR.error = error;

  176.         return lib$es6$promise
    internal

    GET_THEN_ERROR;

  177.       }
  178.     }
  179.     function lib$es6$promise
    internal

    tryThen(then, value, fulfillmentHandler, rejectionHandler) {

  180.       try {
  181.         then.call(value, fulfillmentHandler, rejectionHandler);
  182.       } catch(e) {
  183.         return e;
  184.       }
  185.     }
  186.     function lib$es6$promise
    internal

    handleForeignThenable(promise, thenable, then) {

  187.        lib$es6$promise$asap$$asap(function(promise) {
  188.         var sealed = false;
  189.         var error = lib$es6$promise
    internal

    tryThen(then, thenable, function(value) {

  190.           if (sealed) { return; }
  191.           sealed = true;
  192.           if (thenable !== value) {
  193.             lib$es6$promise
    internal

    resolve(promise, value);

  194.           } else {
  195.             lib$es6$promise
    internal

    fulfill(promise, value);

  196.           }
  197.         }, function(reason) {
  198.           if (sealed) { return; }
  199.           sealed = true;
  200.           lib$es6$promise
    internal

    reject(promise, reason);

  201.         }, 'Settle: ' + (promise._label || ' unknown promise'));
  202.         if (!sealed && error) {
  203.           sealed = true;
  204.           lib$es6$promise
    internal

    reject(promise, error);

  205.         }
  206.       }, promise);
  207.     }
  208.     function lib$es6$promise
    internal

    handleOwnThenable(promise, thenable) {

  209.       if (thenable._state === lib$es6$promise
    internal

    FULFILLED) {

  210.         lib$es6$promise
    internal

    fulfill(promise, thenable._result);

  211.       } else if (thenable._state === lib$es6$promise
    internal

    REJECTED) {

  212.         lib$es6$promise
    internal

    reject(promise, thenable._result);

  213.       } else {
  214.         lib$es6$promise
    internal

    subscribe(thenable, undefined, function(value) {

  215.           lib$es6$promise
    internal

    resolve(promise, value);

  216.         }, function(reason) {
  217.           lib$es6$promise
    internal

    reject(promise, reason);

  218.         });
  219.       }
  220.     }
  221.     function lib$es6$promise
    internal

    handleMaybeThenable(promise, maybeThenable, then) {

  222.       if (maybeThenable.constructor === promise.constructor &&
  223.           then === lib$es6$promise$then$$default &&
  224.           constructor.resolve === lib$es6$promise$promise$resolve$$default) {
  225.         lib$es6$promise
    internal

    handleOwnThenable(promise, maybeThenable);

  226.       } else {
  227.         if (then === lib$es6$promise
    internal

    GET_THEN_ERROR) {

  228.           lib$es6$promise
    internal

    reject(promise, lib$es6$promise

    internal

    GET_THEN_ERROR.error);

  229.         } else if (then === undefined) {
  230.           lib$es6$promise
    internal

    fulfill(promise, maybeThenable);

  231.         } else if (lib$es6$promise$utils$$isFunction(then)) {
  232.           lib$es6$promise
    internal

    handleForeignThenable(promise, maybeThenable, then);

  233.         } else {
  234.           lib$es6$promise
    internal

    fulfill(promise, maybeThenable);

  235.         }
  236.       }
  237.     }
  238.     function lib$es6$promise
    internal

    resolve(promise, value) {

  239.       if (promise === value) {
  240.         lib$es6$promise
    internal

    reject(promise, lib$es6$promise

    internal

    selfFulfillment());

  241.       } else if (lib$es6$promise$utils$$objectOrFunction(value)) {
  242.         lib$es6$promise
    internal

    handleMaybeThenable(promise, value, lib$es6$promise

    internal

    getThen(value));

  243.       } else {
  244.         lib$es6$promise
    internal

    fulfill(promise, value);

  245.       }
  246.     }
  247.     function lib$es6$promise
    internal

    publishRejection(promise) {

  248.       if (promise._onerror) {
  249.         promise._onerror(promise._result);
  250.       }
  251.       lib$es6$promise
    internal

    publish(promise);

  252.     }
  253.     function lib$es6$promise
    internal

    fulfill(promise, value) {

  254.       if (promise._state !== lib$es6$promise
    internal

    PENDING) { return; }

  255.       promise._result = value;
  256.       promise._state = lib$es6$promise
    internal

    FULFILLED;

  257.       if (promise._subscribers.length !== 0) {
  258.         lib$es6$promise$asap
    asap(lib$es6$promise

    internal$$publish, promise);

  259.       }
  260.     }
  261.     function lib$es6$promise
    internal

    reject(promise, reason) {

  262.       if (promise._state !== lib$es6$promise
    internal

    PENDING) { return; }

  263.       promise._state = lib$es6$promise
    internal

    REJECTED;

  264.       promise._result = reason;
  265.       lib$es6$promise$asap
    asap(lib$es6$promise

    internal$$publishRejection, promise);

  266.     }
  267.     function lib$es6$promise
    internal

    subscribe(parent, child, onFulfillment, onRejection) {

  268.       var subscribers = parent._subscribers;
  269.       var length = subscribers.length;
  270.       parent._onerror = null;
  271.       subscribers[length] = child;
  272.       subscribers[length + lib$es6$promise
    internal

    FULFILLED] = onFulfillment;

  273.       subscribers[length + lib$es6$promise
    internal

    REJECTED]  = onRejection;

  274.       if (length === 0 && parent._state) {
  275.         lib$es6$promise$asap
    asap(lib$es6$promise

    internal$$publish, parent);

  276.       }
  277.     }
  278.     function lib$es6$promise
    internal

    publish(promise) {

  279.       var subscribers = promise._subscribers;
  280.       var settled = promise._state;
  281.       if (subscribers.length === 0) { return; }
  282.       var child, callback, detail = promise._result;
  283.       for (var i = 0; i < subscribers.length; i += 3) {
  284.         child = subscribers[i];
  285.         callback = subscribers[i + settled];
  286.         if (child) {
  287.           lib$es6$promise
    internal

    invokeCallback(settled, child, callback, detail);

  288.         } else {
  289.           callback(detail);
  290.         }
  291.       }
  292.       promise._subscribers.length = 0;
  293.     }
  294.     function lib$es6$promise
    internal

    ErrorObject() {

  295.       this.error = null;
  296.     }
  297.     var lib$es6$promise
    internal

    TRY_CATCH_ERROR = new lib$es6$promise

    internal

    ErrorObject();

  298.     function lib$es6$promise
    internal

    tryCatch(callback, detail) {

  299.       try {
  300.         return callback(detail);
  301.       } catch(e) {
  302.         lib$es6$promise
    internal

    TRY_CATCH_ERROR.error = e;

  303.         return lib$es6$promise
    internal

    TRY_CATCH_ERROR;

  304.       }
  305.     }
  306.     function lib$es6$promise
    internal

    invokeCallback(settled, promise, callback, detail) {

  307.       var hasCallback = lib$es6$promise$utils$$isFunction(callback),
  308.           value, error, succeeded, failed;
  309.       if (hasCallback) {
  310.         value = lib$es6$promise
    internal

    tryCatch(callback, detail);

  311.         if (value === lib$es6$promise
    internal

    TRY_CATCH_ERROR) {

  312.           failed = true;
  313.           error = value.error;
  314.           value = null;
  315.         } else {
  316.           succeeded = true;
  317.         }
  318.         if (promise === value) {
  319.           lib$es6$promise
    internal

    reject(promise, lib$es6$promise

    internal

    cannotReturnOwn());

  320.           return;
  321.         }
  322.       } else {
  323.         value = detail;
  324.         succeeded = true;
  325.       }
  326.       if (promise._state !== lib$es6$promise
    internal

    PENDING) {

  327.         // noop
  328.       } else if (hasCallback && succeeded) {
  329.         lib$es6$promise
    internal

    resolve(promise, value);

  330.       } else if (failed) {
  331.         lib$es6$promise
    internal

    reject(promise, error);

  332.       } else if (settled === lib$es6$promise
    internal

    FULFILLED) {

  333.         lib$es6$promise
    internal

    fulfill(promise, value);

  334.       } else if (settled === lib$es6$promise
    internal

    REJECTED) {

  335.         lib$es6$promise
    internal

    reject(promise, value);

  336.       }
  337.     }
  338.     function lib$es6$promise
    internal

    initializePromise(promise, resolver) {

  339.       try {
  340.         resolver(function resolvePromise(value){
  341.           lib$es6$promise
    internal

    resolve(promise, value);

  342.         }, function rejectPromise(reason) {
  343.           lib$es6$promise
    internal

    reject(promise, reason);

  344.         });
  345.       } catch(e) {
  346.         lib$es6$promise
    internal

    reject(promise, e);

  347.       }
  348.     }
  349.     var lib$es6$promise
    internal

    id = 0;

  350.     function lib$es6$promise
    internal

    nextId() {

  351.       return lib$es6$promise
    internal

    id++;

  352.     }
  353.     function lib$es6$promise
    internal

    makePromise(promise) {

  354.       promise[lib$es6$promise
    internal

    PROMISE_ID] = lib$es6$promise

    internal

    id++;

  355.       promise._state = undefined;
  356.       promise._result = undefined;
  357.       promise._subscribers = [];
  358.     }
  359.     function lib$es6$promise$promise$all$$all(entries) {
  360.       return new lib$es6$promise$enumerator$$default(this, entries).promise;
  361.     }
  362.     var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;
  363.     function lib$es6$promise$promise$race$$race(entries) {
  364.       /*jshint validthis:true */
  365.       var Constructor = this;
  366.       if (!lib$es6$promise$utils$$isArray(entries)) {
  367.         return new Constructor(function(resolve, reject) {
  368.           reject(new TypeError('You must pass an array to race.'));
  369.         });
  370.       } else {
  371.         return new Constructor(function(resolve, reject) {
  372.           var length = entries.length;
  373.           for (var i = 0; i < length; i++) {
  374.             Constructor.resolve(entries[i]).then(resolve, reject);
  375.           }
  376.         });
  377.       }
  378.     }
  379.     var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;
  380.     function lib$es6$promise$promise$reject$$reject(reason) {
  381.       /*jshint validthis:true */
  382.       var Constructor = this;
  383.       var promise = new Constructor(lib$es6$promise
    internal

    noop);

  384.       lib$es6$promise
    internal

    reject(promise, reason);

  385.       return promise;
  386.     }
  387.     var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;
  388.     function lib$es6$promise$promise$$needsResolver() {
  389.       throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
  390.     }
  391.     function lib$es6$promise$promise$$needsNew() {
  392.       throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
  393.     }
  394.     var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;
  395.     /**
  396.       Promise objects represent the eventual result of an asynchronous operation. The
  397.       primary way of interacting with a promise is through its `then` method, which
  398.       registers callbacks to receive either a promise's eventual value or the reason
  399.       why the promise cannot be fulfilled.
  400.       Terminology
  401.       -----------
  402.       - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
  403.       - `thenable` is an object or function that defines a `then` method.
  404.       - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
  405.       - `exception` is a value that is thrown using the throw statement.
  406.       - `reason` is a value that indicates why a promise was rejected.
  407.       - `settled` the final resting state of a promise, fulfilled or rejected.
  408.       A promise can be in one of three states: pending, fulfilled, or rejected.
  409.       Promises that are fulfilled have a fulfillment value and are in the fulfilled
  410.       state.  Promises that are rejected have a rejection reason and are in the
  411.       rejected state.  A fulfillment value is never a thenable.
  412.       Promises can also be said to *resolve* a value.  If this value is also a
  413.       promise, then the original promise's settled state will match the value's
  414.       settled state.  So a promise that *resolves* a promise that rejects will
  415.       itself reject, and a promise that *resolves* a promise that fulfills will
  416.       itself fulfill.
  417.       Basic Usage:
  418.       ------------
  419.       ```js
  420.       var promise = new Promise(function(resolve, reject) {
  421.         // on success
  422.         resolve(value);
  423.         // on failure
  424.         reject(reason);
  425.       });
  426.       promise.then(function(value) {
  427.         // on fulfillment
  428.       }, function(reason) {
  429.         // on rejection
  430.       });
  431.       ```
  432.       Advanced Usage:
  433.       ---------------
  434.       Promises shine when abstracting away asynchronous interactions such as
  435.       `XMLHttpRequest`s.
  436.       ```js
  437.       function getJSON(url) {
  438.         return new Promise(function(resolve, reject){
  439.           var xhr = new XMLHttpRequest();
  440.           xhr.open('GET', url);
  441.           xhr.onreadystatechange = handler;
  442.           xhr.responseType = 'json';
  443.           xhr.setRequestHeader('Accept', 'application/json');
  444.           xhr.send();
  445.           function handler() {
  446.             if (this.readyState === this.DONE) {
  447.               if (this.status === 200) {
  448.                 resolve(this.response);
  449.               } else {
  450.                 reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
  451.               }
  452.             }
  453.           };
  454.         });
  455.       }
  456.       getJSON('/posts.json').then(function(json) {
  457.         // on fulfillment
  458.       }, function(reason) {
  459.         // on rejection
  460.       });
  461.       ```
  462.       Unlike callbacks, promises are great composable primitives.
  463.       ```js
  464.       Promise.all([
  465.         getJSON('/posts'),
  466.         getJSON('/comments')
  467.       ]).then(function(values){
  468.         values[0] // => postsJSON
  469.         values[1] // => commentsJSON
  470.         return values;
  471.       });
  472.       ```
  473.       @class Promise
  474.       @param {function} resolver
  475.       Useful for tooling.
  476.       @constructor
  477.     */
  478.     function lib$es6$promise$promise$$Promise(resolver) {
  479.       this[lib$es6$promise
    internal

    PROMISE_ID] = lib$es6$promise

    internal

    nextId();

  480.       this._result = this._state = undefined;
  481.       this._subscribers = [];
  482.       if (lib$es6$promise
    internal

    noop !== resolver) {

  483.         typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();
  484.         this instanceof lib$es6$promise$promise
    Promise?lib$es6$promise

    internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();

  485.       }
  486.     }
  487.     lib$es6$promise$promise
    Promise.all=lib$es6$promise$promise$all

    default;

  488.     lib$es6$promise$promise
    Promise.race=lib$es6$promise$promise$race

    default;

  489.     lib$es6$promise$promise
    Promise.resolve=lib$es6$promise$promise$resolve

    default;

  490.     lib$es6$promise$promise
    Promise.reject=lib$es6$promise$promise$reject

    default;

  491.     lib$es6$promise$promise
    Promise.setScheduler=lib$es6$promise$asap

    setScheduler;

  492.     lib$es6$promise$promise
    Promise.setAsap=lib$es6$promise$asap

    setAsap;

  493.     lib$es6$promise$promise
    Promise.asap=lib$es6$promise$asap

    asap;

  494.     lib$es6$promise$promise$$Promise.prototype = {
  495.       constructor: lib$es6$promise$promise$$Promise,
  496.     /**
  497.       The primary way of interacting with a promise is through its `then` method,
  498.       which registers callbacks to receive either a promise's eventual value or the
  499.       reason why the promise cannot be fulfilled.
  500.       ```js
  501.       findUser().then(function(user){
  502.         // user is available
  503.       }, function(reason){
  504.         // user is unavailable, and you are given the reason why
  505.       });
  506.       ```
  507.       Chaining
  508.       --------
  509.       The return value of `then` is itself a promise.  This second, 'downstream'
  510.       promise is resolved with the return value of the first promise's fulfillment
  511.       or rejection handler, or rejected if the handler throws an exception.
  512.       ```js
  513.       findUser().then(function (user) {
  514.         return user.name;
  515.       }, function (reason) {
  516.         return 'default name';
  517.       }).then(function (userName) {
  518.         // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
  519.         // will be `'default name'`
  520.       });
  521.       findUser().then(function (user) {
  522.         throw new Error('Found user, but still unhappy');
  523.       }, function (reason) {
  524.         throw new Error('`findUser` rejected and we're unhappy');
  525.       }).then(function (value) {
  526.         // never reached
  527.       }, function (reason) {
  528.         // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
  529.         // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
  530.       });
  531.       ```
  532.       If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
  533.       ```js
  534.       findUser().then(function (user) {
  535.         throw new PedagogicalException('Upstream error');
  536.       }).then(function (value) {
  537.         // never reached
  538.       }).then(function (value) {
  539.         // never reached
  540.       }, function (reason) {
  541.         // The `PedgagocialException` is propagated all the way down to here
  542.       });
  543.       ```
  544.       Assimilation
  545.       ------------
  546.       Sometimes the value you want to propagate to a downstream promise can only be
  547.       retrieved asynchronously. This can be achieved by returning a promise in the
  548.       fulfillment or rejection handler. The downstream promise will then be pending
  549.       until the returned promise is settled. This is called *assimilation*.
  550.       ```js
  551.       findUser().then(function (user) {
  552.         return findCommentsByAuthor(user);
  553.       }).then(function (comments) {
  554.         // The user's comments are now available
  555.       });
  556.       ```
  557.       If the assimliated promise rejects, then the downstream promise will also reject.
  558.       ```js
  559.       findUser().then(function (user) {
  560.         return findCommentsByAuthor(user);
  561.       }).then(function (comments) {
  562.         // If `findCommentsByAuthor` fulfills, we'll have the value here
  563.       }, function (reason) {
  564.         // If `findCommentsByAuthor` rejects, we'll have the reason here
  565.       });
  566.       ```
  567.       Simple Example
  568.       --------------
  569.       Synchronous Example
  570.       ```javascript
  571.       var result;
  572.       try {
  573.         result = findResult();
  574.         // success
  575.       } catch(reason) {
  576.         // failure
  577.       }
  578.       ```
  579.       Errback Example
  580.       ```js
  581.       findResult(function(result, err){
  582.         if (err) {
  583.           // failure
  584.         } else {
  585.           // success
  586.         }
  587.       });
  588.       ```
  589.       Promise Example;
  590.       ```javascript
  591.       findResult().then(function(result){
  592.         // success
  593.       }, function(reason){
  594.         // failure
  595.       });
  596.       ```
  597.       Advanced Example
  598.       --------------
  599.       Synchronous Example
  600.       ```javascript
  601.       var author, books;
  602.       try {
  603.         author = findAuthor();
  604.         books  = findBooksByAuthor(author);
  605.         // success
  606.       } catch(reason) {
  607.         // failure
  608.       }
  609.       ```
  610.       Errback Example
  611.       ```js
  612.       function foundBooks(books) {
  613.       }
  614.       function failure(reason) {
  615.       }
  616.       findAuthor(function(author, err){
  617.         if (err) {
  618.           failure(err);
  619.           // failure
  620.         } else {
  621.           try {
  622.             findBoooksByAuthor(author, function(books, err) {
  623.               if (err) {
  624.                 failure(err);
  625.               } else {
  626.                 try {
  627.                   foundBooks(books);
  628.                 } catch(reason) {
  629.                   failure(reason);
  630.                 }
  631.               }
  632.             });
  633.           } catch(error) {
  634.             failure(err);
  635.           }
  636.           // success
  637.         }
  638.       });
  639.       ```
  640.       Promise Example;
  641.       ```javascript
  642.       findAuthor().
  643.         then(findBooksByAuthor).
  644.         then(function(books){
  645.           // found books
  646.       }).catch(function(reason){
  647.         // something went wrong
  648.       });
  649.       ```
  650.       @method then
  651.       @param {Function} onFulfilled
  652.       @param {Function} onRejected
  653.       Useful for tooling.
  654.       @return {Promise}
  655.     */
  656.       then: lib$es6$promise$then$$default,
  657.     /**
  658.       `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
  659.       as the catch block of a try/catch statement.
  660.       ```js
  661.       function findAuthor(){
  662.         throw new Error('couldn't find that author');
  663.       }
  664.       // synchronous
  665.       try {
  666.         findAuthor();
  667.       } catch(reason) {
  668.         // something went wrong
  669.       }
  670.       // async with promises
  671.       findAuthor().catch(function(reason){
  672.         // something went wrong
  673.       });
  674.       ```
  675.       @method catch
  676.       @param {Function} onRejection
  677.       Useful for tooling.
  678.       @return {Promise}
  679.     */
  680.       'catch'function(onRejection) {
  681.         return this.then(null, onRejection);
  682.       }
  683.     };
  684.     var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;
  685.     function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {
  686.       this._instanceConstructor = Constructor;
  687.       this.promise = new Constructor(lib$es6$promise
    internal

    noop);

  688.       if (!this.promise[lib$es6$promise
    internal

    PROMISE_ID]) {

  689.         lib$es6$promise
    internal

    makePromise(this.promise);

  690.       }
  691.       if (lib$es6$promise$utils$$isArray(input)) {
  692.         this._input     = input;
  693.         this.length     = input.length;
  694.         this._remaining = input.length;
  695.         this._result = new Array(this.length);
  696.         if (this.length === 0) {
  697.           lib$es6$promise
    internal

    fulfill(this.promise, this._result);

  698.         } else {
  699.           this.length = this.length || 0;
  700.           this._enumerate();
  701.           if (this._remaining === 0) {
  702.             lib$es6$promise
    internal

    fulfill(this.promise, this._result);

  703.           }
  704.         }
  705.       } else {
  706.         lib$es6$promise
    internal

    reject(this.promise, lib$es6$promise$enumerator$$validationError());

  707.       }
  708.     }
  709.     function lib$es6$promise$enumerator$$validationError() {
  710.       return new Error('Array Methods must be provided an Array');
  711.     }
  712.     lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {
  713.       var length  = this.length;
  714.       var input   = this._input;
  715.       for (var i = 0; this._state === lib$es6$promise
    internal

    PENDING && i < length; i++) {

  716.         this._eachEntry(input[i], i);
  717.       }
  718.     };
  719.     lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
  720.       var c = this._instanceConstructor;
  721.       var resolve = c.resolve;
  722.       if (resolve === lib$es6$promise$promise$resolve$$default) {
  723.         var then = lib$es6$promise
    internal

    getThen(entry);

  724.         if (then === lib$es6$promise$then$$default &&
  725.             entry._state !== lib$es6$promise
    internal

    PENDING) {

  726.           this._settledAt(entry._state, i, entry._result);
  727.         } else if (typeof then !== 'function') {
  728.           this._remaining--;
  729.           this._result[i] = entry;
  730.         } else if (c === lib$es6$promise$promise$$default) {
  731.           var promise = new c(lib$es6$promise
    internal

    noop);

  732.           lib$es6$promise
    internal

    handleMaybeThenable(promise, entry, then);

  733.           this._willSettleAt(promise, i);
  734.         } else {
  735.           this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);
  736.         }
  737.       } else {
  738.         this._willSettleAt(resolve(entry), i);
  739.       }
  740.     };
  741.     lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
  742.       var promise = this.promise;
  743.       if (promise._state === lib$es6$promise
    internal

    PENDING) {

  744.         this._remaining--;
  745.         if (state === lib$es6$promise
    internal

    REJECTED) {

  746.           lib$es6$promise
    internal

    reject(promise, value);

  747.         } else {
  748.           this._result[i] = value;
  749.         }
  750.       }
  751.       if (this._remaining === 0) {
  752.         lib$es6$promise
    internal

    fulfill(promise, this._result);

  753.       }
  754.     };
  755.     lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
  756.       var enumerator = this;
  757.       lib$es6$promise
    internal

    subscribe(promise, undefined, function(value) {

  758.         enumerator._settledAt(lib$es6$promise
    internal

    FULFILLED, i, value);

  759.       }, function(reason) {
  760.         enumerator._settledAt(lib$es6$promise
    internal

    REJECTED, i, reason);

  761.       });
  762.     };
  763.     function lib$es6$promise$polyfill$$polyfill() {
  764.       var local;
  765.       if (typeof global !== 'undefined') {
  766.           local = global;
  767.       } else if (typeof self !== 'undefined') {
  768.           local = self;
  769.       } else {
  770.           try {
  771.               local = Function('return this')();
  772.           } catch (e) {
  773.               throw new Error('polyfill failed because global object is unavailable in this environment');
  774.           }
  775.       }
  776.       var P = local.Promise;
  777.       if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {
  778.         return;
  779.       }
  780.       local.Promise = lib$es6$promise$promise$$default;
  781.     }
  782.     var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;
  783.     lib$es6$promise$promise$$default.Promise = lib$es6$promise$promise$$default;
  784.     lib$es6$promise$promise$$default.polyfill = lib$es6$promise$polyfill$$default;
  785.     /* global define:true module:true window: true */
  786.     if (typeof define === 'function' && define['amd']) {
  787.       define(function() { return lib$es6$promise$promise$$default; });
  788.     } else if (typeof module !== 'undefined' && module['exports']) {
  789.       module['exports'] = lib$es6$promise$promise$$default;
  790.     } else if (typeof this !== 'undefined') {
  791.       this['Promise'] = lib$es6$promise$promise$$default;
  792.     }
  793.     lib$es6$promise$polyfill$$default();
  794. }).call(this);
http://blog.csdn.net/whbwhb1/article/details/53322451
标签:

给我留言

Copyright © web前端技术开发个人博客 保留所有权利  京ICP备14060653号 Theme  Ality

用户登录