{"version":3,"sources":["jsdelivr-header.js","/npm/micropromise@0.4.10/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,CCGC,SAAS,GACN,aAEA,IAAI,EAAO,QAAQ,aAEnB,IAAK,EAAO,MAAO,CAAE,MAAM,GAAI,IAAK,EAAO,MAAO,CAAE,MAAM,GAAG,CAAE,CAE/D,IAAI,EAAQ,MAAM,UAAU,MACxB,EAAU,MAAM,QAcpB,SAAS,EAAQ,GACpB,IAAI,EAAO,KAGJ,GAAG,GAAkB,iBAAN,EAAe,CAC1B,IAAI,IAAI,KAAK,EAAQ,UAC/B,EAAE,GAAK,EAAQ,UAAU,GAGtB,OAFA,EAAE,SAAW,CAAC,OAAO,IAEd,CACJ,CAGA,KAAK,gBAAgB,GACjB,OAAO,IAAI,EAAQ,GAE9B,KAAK,SAAW,CAAC,OAAQ,IAGF,mBAAN,GACb,GAAK,WACR,IAAI,EAAM,EAAK,QAAQ,KAAK,GACxB,EAAM,EAAK,OAAO,KAAK,GAC3B,EAAE,EAAI,EACH,GAED,CAkrBA,SAAS,EAAS,GAOd,IANP,IAII,EAAG,EAAG,EAAG,EAJT,EAAI,EAAS,OACb,EAAI,EAAS,OACb,EAAI,EAAS,OACb,EAAI,EAAS,QAGH,EAAI,EAAE,SAIT,GAHP,EAAI,EAAE,GAGiB,mBAFhB,EAAI,EAAE,IAGF,IACI,EAAI,EAAE,EAAE,GACtB,EAAE,QAAQ,EAAE,EACF,CAAE,MAAM,GAClB,EAAE,OAAO,EACC,MAEd,EAAE,SAAS,OAAS,EACpB,EAAE,SAAS,OAAS,EACpB,EAAE,SAAS,QAAU,EAErB,EAAK,EAAS,CAAC,EAAE,UAGf,CAnsBA,EAAQ,SAAW,SAAS,GAC/B,IAAI,EAEJ,GAAG,IAAmB,iBAAN,GAA+B,mBAAN,GACrC,IAAM,EAAO,EAAE,IAAM,CAAE,MAAO,GAAK,OAAO,CAAO,CAGrD,MAAwB,mBAAT,CACZ,EAiBA,EAAQ,KAAO,SAAS,EAAM,GAC1B,IAAI,EAAI,IAAI,EAEnB,IAAI,EAAO,MAAM,MAAM,oBAEhB,OAAO,WACH,IAEV,EAFc,EAAM,EAAM,UAAU,YACpC,EAAO,EAAM,KAAK,WAIR,GAAiB,mBAAP,EAyBV,MAAM,MAAM,iBAxBtB,IAEI,MADA,EAAM,EAAG,MAAM,EAAK,cACA,GAAO,EAC9B,EAAK,WAAW,GAEb,UAAY,EAAM,UAErB,EAAO,IAAI,EAEX,IACI,EAAM,EAAM,MAAM,EAAK,EAC3B,CAAE,MAAO,GAEL,YADA,EAAE,OAAO,EAEb,CAEA,EAAM,OAAO,KAAS,EAAM,EAAM,CAC/B,CAEA,EAAE,QAAQ,EAEd,CAAE,MAAM,GACJ,EAAE,OAAO,EACb,CAGU,OAAO,CACX,CACJ,EAqBA,EAAQ,MAAQ,WACZ,IAAI,EAAO,EAAM,KAAK,WAClB,EAAI,EAAK,QACT,EAAI,IAAI,EAcZ,MAZgB,mBAAN,GACN,GAGJ,WACI,IACV,EAAE,QAAQ,EAAE,MAAM,EAAE,GACjB,CAAE,MAAM,GACX,EAAE,OAAO,EACN,CACG,GATiB,GAWV,CACX,EAoBA,EAAQ,MAAQ,SAAS,EAAK,GACjC,IAAuB,EAAnB,EAAI,IAAI,EAEZ,GAAkB,mBAAR,EACN,MAAM,IAAI,UAAU,0BAUjB,OARP,EAAmB,mBAAP,EAAoB,EAAK,SAAU,EAAI,GAC/C,GAAS,EAEN,EAAK,EAAE,OAAO,GACD,IAAR,EAAW,EAAE,SAAS,GACzB,EAAE,QAAQ,EACnB,EAEc,WACV,IAAI,EAAO,EAAM,KAAK,WAmBtB,OAjBA,EAAK,KAAK,GAEV,GAAK,WACR,IAAI,EAEJ,IACI,EAAM,EAAK,MAAM,KAAK,EAC1B,CAAE,MAAM,GACJ,EAAG,EACP,MAEU,IAAP,GAAqB,IACjB,aAAe,MAAO,EAAG,GACvB,OAAG,EAAU,GAEnB,IAEO,CACX,CACG,EAOA,EAAQ,UAAU,UAAY,WACjC,OAAQ,KAAK,SAAS,MACnB,EAOA,EAAQ,UAAU,YAAc,WACnC,OA/NY,IA+NL,KAAK,SAAS,MAClB,EAOA,EAAQ,UAAU,WAAa,WAClC,OAvOY,IAuOL,KAAK,SAAS,MAClB,EAOA,EAAQ,UAAU,YAAc,WACnC,QAAS,KAAK,SAAS,MACpB,EAOA,EAAQ,UAAU,QAAU,WAC/B,OAAO,KAAK,cAAgB,KAAK,SAAS,YAAS,CAChD,EAOA,EAAQ,UAAU,OAAS,WAC9B,OAAO,KAAK,aAAe,KAAK,SAAS,YAAS,CAC/C,EA6CA,EAAQ,UAAU,KAAO,SAAS,EAAE,EAAE,GAClC,IAAI,EAAI,IAAI,EAAW,EAAO,KAAK,SAMnC,OAJP,EAAK,OAAO,EAAK,OAAO,QAAU,CAAC,EAAE,EAAE,EAAE,GAEtC,EAAK,QAAQ,EAAK,EAAS,CAAC,IAEjB,CACX,EAmBA,EAAQ,UAAU,OAAS,SAAS,EAAE,EAAE,GAMpC,OAAO,KAAK,MALZ,SAAW,EAAE,GAET,OADI,EAAQ,KAAI,EAAI,CAAC,IACd,EAAE,MAAM,EAAE,EAAE,OAAO,GAC9B,GAEmB,EAAE,EACzB,EAmCA,EAAQ,UAAU,KAAO,SAAS,EAAE,EAAE,GAClC,IAAI,EAAO,KAAU,KAAK,KAAK,GAE/B,SAAoB,GAChB,GAAK,WACf,GAAgB,mBAAN,EAAkB,EAAE,QACX,GAA2B,mBAAjB,EAAK,QAChB,EAAK,QAAQ,OACV,IAAuB,aAApB,EAAQ,QAEX,MAAM,EADT,EAAQ,QAAQ,EACN,CAClB,GACJ,GAX4C,EAYhD,EAQA,EAAQ,UAAU,IAAM,SAAS,GAEpC,KAAK,KAAK,GAAS,SAAS,GAKxB,GAJK,aAAa,QACrB,EAAI,IAAI,MAAM,IAGY,mBAAb,EACL,MAAM,EADwB,EAAS,EAEhD,GACG,EAuBA,EAAQ,UAAU,MAAQ,SAAS,GACtC,KAAK,UAAK,EAAU,EACjB,EA6BA,EAAQ,UAAU,QAAU,SAAS,EAAM,GAC9C,IAAI,EAAO,KAAK,SAST,OAPH,EAAK,SACL,EAAK,OA/cG,EAgdR,EAAK,OAAS,EACd,EAAK,QAAU,EACf,EAAK,EAAS,CAAC,KAGL,IACX,EAmBA,EAAQ,UAAU,OAAS,SAAS,EAAO,GAC9C,IAAI,EAAO,KAAK,SAUT,YARY,IAAhB,EAAK,SACJ,EAAK,OA5eG,EA6eR,EAAK,OAAS,EACd,EAAK,QAAU,EAEf,EAAK,EAAS,CAAC,EAhfP,EAgfqB,EAAO,KAG1B,IACX,EAoBA,EAAQ,UAAU,QAAU,SAAS,EAAE,GACnC,IAAI,EAAM,EAAI,EAAG,EAAO,KAAK,SAAU,EAAI,KAE3C,IAAI,EAAK,OAAO,CAGZ,GAFG,IAAM,GAAG,EAAE,OAAO,IAAI,UAAU,mCAEhC,IAAmB,iBAAN,GAA+B,mBAAN,GACrC,IAAM,EAAO,EAAE,IAAM,CAAE,MAAM,GAAI,EAAE,OAAO,EAAI,CAGlD,GAAmB,mBAAT,EACpB,EAAE,QAAQ,EAAE,QACK,IAAI,EACP,IACI,EAAK,MAAM,EAAE,CAAC,SAAS,GACf,IACA,EAAE,QAAQ,EAAE,GACZ,EAAI,EAEZ,EAAE,SAAS,GACH,IACA,EAAE,OAAO,GACT,EAAI,EAEZ,GACJ,CAAE,MAAM,GACA,IACrB,EAAE,OAAO,GACT,EAAI,EAES,CAER,CAEA,OAAO,IACX,EAqBA,EAAQ,UAAU,SAAW,WAGhC,IAFO,IAAI,EAAQ,EAAQ,KAAK,SAAS,OAEjC,EAAI,EAAG,EAAI,EAAM,OAAQ,EAAI,EAAG,IACQ,mBAA1B,EAAS,EAAM,GAAG,KACzB,EAAO,MAAM,KAAK,UAE9B,EAqBA,EAAQ,UAAU,QAAU,SAAS,EAAK,GACtC,IAAI,EAAI,KAAM,EAAO,KAAK,SAoB1B,OAlBY,OAAT,GACI,EAAK,UAClB,EAAK,aAAa,EAAK,UAEb,EAAK,SAAW,MACT,EAAK,WACZ,EAAK,SAAW,EAAK,YAGzB,WACI,IAAI,EAAI,IAAI,WAAW,oBACvB,IAAI,EAAK,OACL,GAAmB,mBAAT,EAAqB,EAAK,OAC/B,IAAwB,mBAAd,EAAE,QACZ,MAAM,EAD8B,EAAE,QAAQ,EACvC,CAEpB,GAV8C,IAYvC,IACX,EA0BA,EAAQ,UAAU,SAAW,SAAS,GAClC,OAAO,KAAK,MAAK,SAAS,EAAM,GAC5B,OAAO,OAAS,EAAU,EAAM,EACpC,IAAE,SAAS,EAAO,GACrB,IAAI,EAAQ,EAEZ,KAAK,aAAiB,OACzB,GAAqB,iBAAX,EAEN,IAAI,IAAI,KADR,EAAQ,IAAI,MAAM,KAAK,UAAU,IACpB,EAChB,EAAM,GAAK,EAAO,QAEf,EAAQ,IAAI,MAAM,GAIZ,OAAO,EAAS,EAAM,EAC1B,IAAE,SAAS,GACP,OAAO,EAAS,EAAE,EACtB,GACJ,EAuBA,EAAQ,UAAU,KAAO,SAAS,GAC9B,IACI,EAAI,GACJ,GAAI,IAAI,GAAU,QAFd,MAEyB,MAAK,SAAS,GAAG,EAAE,GAAK,CAAE,IAQlE,SAAS,EAAK,GACV,EAAE,OAAO,EACb,CAEO,SAAS,EAAQ,GAKb,OAJA,EAAE,GAAG,MAAK,SAAS,GACf,EAAE,EAAE,GAAK,CACb,IAAG,MAAM,GAEF,WAAW,OAAO,EAAE,EAAG,CAClC,CAhBG,UAAU,OAAS,IAClB,EAAI,EAAM,KAAK,YAGf,EAAQ,KAAI,EAAI,CAAC,IAcrB,IAAI,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,IACzB,EAAI,EAAE,KAAK,EAAQ,IAGvB,OAAO,EAAE,MAAK,WAAW,OAAO,CAAE,GACtC,EAgCG,QAAU,OAAO,QAAS,OAAO,QAAU,EACrB,mBAAV,QAAwB,OAAO,IAAK,OAAO,GACrD,EAAK,QAAU,CACxB,CAlwBA,CAkwBE","file":"/npm/micropromise@0.4.10/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/micropromise@0.4.10/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*global require, global, window */\n\n/**\n * @provides A+ v1.1 compliant promises.\n * @module Promise\n * @name microPromise\n * @main Promise\n */\n\n(function(root){\n    \"use strict\";\n\n    var task = require('microtask'); // nextTick shim\n\n    try {root = window;} catch(e){ try {root = global;} catch(f){} }\n\n    var slice = Array.prototype.slice,\n        isArray = Array.isArray;\n\n    var PENDING   = 0,   \n\tFULFILLED = 1, \n\tREJECTED  = 2;  \n    \n    /**\n     * Promise constructor\n     * \n     * @param {Object} [mixin] - Mixin promise into object\n     * @param {Function} [resolver] - Resolver function(resolve,reject) \n     * @return {Object} Promise\n     * @api public\n     */\n    function Promise(o){\n\tvar self = this;\n\t\n        // object mixin\n        if(o && typeof o === 'object'){\n            for(var k in Promise.prototype)\n\t\to[k] = Promise.prototype[k];\n\t    o._promise = {_chain:[]};\n\n\t    return o;\n        }\n\t\n\t// create new instance\n        if(!(this instanceof Promise))\n            return new Promise(o);\n\n\tthis._promise = {_chain: []};\n\n        // use resolver callback\n        if(typeof o === 'function') {\n\t    task(function(){\n\t\tvar res = self.resolve.bind(self),\n\t\t    rej = self.reject.bind(self);\n\t\to(res,rej);\n\t    });\n        }\n    }\n\n    \n    /**\n     * Helper for identifying a promise-like objects or functions\n     * \n     * @param {Object} p - Object or Function to test\n     * @return {Boolean} - Returns true if thenable or else false\n     */\n    Promise.thenable = function(p){\n\tvar then;\n\t\n\tif(p && (typeof p === 'object' || typeof p === 'function')){\n\t    try { then = p.then; } catch (e) { return false; };\n\t}\n\t\n\treturn (typeof then === 'function');\n    };\n\n    \n    /**\n     * Wrap a promise around function or constructor\n     *\n     * Example: wrap an Array\n     *      p = Promise.wrap(Array);\n     *      \n     *      var r = c(1,2,3); // => calls Array constructor and returns fulfilled promise\n     *      r.valueOf(); // => [1,2,3]; \n     * @param {Function} class - class to wrap\n     * @param {Object} [instance] - optional instance\n     * @return {Function} function to wrap\n     * @throw {Error} on not wrappable\n     * @api public\n     */\n    Promise.wrap = function(Klass,inst){\n        var p = new Promise();\n\n\tif(!Klass) throw Error(\"Nothing to wrap!\");\n\t\n        return function(){\n            var KC =  Klass.prototype.constructor,\n\t\targs = slice.call(arguments),\n\t\tret;\n\t    \n\t    \n            if(typeof KC === 'function'){\n\t\ttry {\n\t\t    ret = KC.apply(inst,args);\n\t\t    if(!(ret instanceof Klass)){\n\t\t\tKC = function(){};\n\t\t\t\n\t\t\tKC.prototype = Klass.prototype;\n\n\t\t\tinst = new KC();\n\t\t\t\n\t\t\ttry {\n\t\t\t    ret = Klass.apply(inst,args);\n\t\t\t} catch (e){\n\t\t\t    p.reject(e);\n\t\t\t    return;\n\t\t\t}\n\t\t\t\n\t\t\tret = Object(ret) === ret ? ret : inst;\n\t\t    }\n\t\t    \n\t\t    p.resolve(ret);\n\t\t    \n\t\t} catch(err){\n\t\t    p.reject(err);\n\t\t}\n\t    } else throw Error(\"not wrappable\");\n\n            return p;\n        };\n    };\n\n    \n    /**\n     * Deferres a task and returns a pending promise fulfilled with the return value from task.\n     * The task may also return a promise itself which to wait on.\n     *\n     * Example: Make readFileSync async\n     *      fs = require('fs');\n     *      var asyncReadFile = Promise().defer(fs.readFileSync,'./index.js','utf-8');\n     *      asyncReadFile.then(function(data){\n     *          console.log(data)\n     *      },function(error){\n     *          console.log(\"Read error:\", error);\n     *      });\n     *\n     * @param {Function} - task to defer\n     * @param {...} [args] - optional list of arguments\n     * @return {Object} - returns a pending promise\n     * @api public\n     */\n    Promise.defer = function(){\n        var args = slice.call(arguments),\n            f = args.shift(),\n            p = new Promise();\n\n        if(typeof f === 'function'){\n            task(enclose,args);\n        }\n\n        function enclose(){\n            try {\n\t\tp.resolve(f.apply(p,args));\n\t    } catch(err) {\n\t\tp.reject(err);\n\t    }\n        }\n\n        return p;\n    };\n\n    \n    /**\n     * Make function asyncronous and fulfill/reject promise on execution.\n     *\n     * Example: make readFile async\n     *      fs = require('fs');\n     *      var asyncReadFile = Promise.async(fs.readFile);\n     *      asyncReadFile('package.json','utf8').then(function(data){\n     *          console.log(data);\n     *      },function(error){\n     *          console.log(\"Read error:\", error);\n     *      });\n     *\n     * @param {Function} function - function to make async\n     * @param {Function} [callback] - optional callback to call\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.async = function(func,cb){\n\tvar p = new Promise(), called;\n\n\tif(typeof func !=='function')\n\t    throw new TypeError(\"func is not a function\");\n\t\n\tcb = typeof cb === 'function' ? cb : function (err,ret){\n\t    called = true;\n\t    \n\t    if(err) p.reject(err);\n\t    else if(err === 0) p.progress(ret);\n\t    else p.fulfill(ret);\n\t};\n\t\n        return function(){\n\t    var args = slice.call(arguments);\n\n\t    args.push(cb);\n\n\t    task(function(){\n\t\tvar ret;\n\t\t\n\t\ttry {\n\t\t    ret = func.apply(null,args);\n\t\t} catch(err) {\n\t\t    cb(err);\n\t\t}\n\t\t\n\t\tif(ret !==undefined && !called) {\n\t\t    if(ret instanceof Error) cb(ret);\n\t\t    else cb(undefined,ret);\n\t\t}\n\t    });\n\t    \n\t    return p;\n\t};\n    };\n    \n    /**\n     * Check if promise is pending\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */\n    Promise.prototype.isPending = function(){\n\treturn !this._promise._state;\n    };\n\n    /**\n     * Check if promise is fulfilled\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */\n    Promise.prototype.isFulfilled = function(){\n\treturn this._promise._state === FULFILLED;\n    };\n\n    /**\n     * Check if promise is rejeced\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */ \n    Promise.prototype.isRejected = function(){\n\treturn this._promise._state === REJECTED;\n    };\n\n    /**\n     * Check if promise has resolved\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */ \n    Promise.prototype.hasResolved = function(){\n\treturn !!this._promise._state;\n    };\n\n    /**\n     * Get value if promise has been fulfilled\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */\n    Promise.prototype.valueOf = function(){\n\treturn this.isFulfilled() ? this._promise._value : undefined;\n    };\n\n    /**\n     * Get reason if promise has rejected\n     * \n     * @return {Boolean} - Returns true if pending or else false\n     */\n    Promise.prototype.reason = function(){\n\treturn this.isRejected() ? this._promise._value : undefined;\n    };\n    \n    /**\n     * Attaches callback,errback,notify handlers and returns a promise\n     *\n     * Example: catch fulfillment or rejection\n     *      var p = Promise();\n     *      p.then(function(value){\n     *          console.log(\"received:\", value);\n     *      },function(error){\n     *          console.log(\"failed with:\", error);\n     *      });\n     *      p.fulfill('hello world!'); // => 'received: hello world!'\n     *\n     * Example: chainable then clauses\n     *      p.then(function(v){\n     *          console.log('v is:', v);\n     *          if(v > 10) throw new RangeError('to large!');\n     *          return v*2;\n     *      }).then(function(v){\n     *          // gets v*2 from above\n     *          console.log('v is:', v)\n     *      },function(e){\n     *          console.log('error2:', e);\n     *      });\n     *      p.fulfill(142); // => v is: 142, error2: [RangeError:'to large']\n     *\n     * Example: undefined callbacks are ignored\n     *      p.then(function(v){\n     *          if(v < 0) throw v;\n     *          return v;\n     *      }).then(undefined,function(e){\n     *          e = -e;\n     *          return e;\n     *      }).then(function(value){\n     *          console.log('we got:', value);\n     *      });\n     *      p.fulfill(-5); // => we got: 5\n     *\n     * @param {Function} onFulfill callback\n     * @param {Function} onReject errback\n     * @param {Function} onNotify callback\n     * @return {Object} a decendant promise\n     * @api public\n     */\n    Promise.prototype.then = function(f,r,n){\n        var p = new Promise(), self = this._promise;\n\t\n\tself._chain[self._chain.length] = [p,f,r,n];\n\n\tif(self._state) task(traverse,[self]);\n\n        return p;\n    };\n\n    \n    /**\n     * Like `then` but spreads array into multiple arguments\n     *\n     * Example: Multiple fulfillment values\n     *      p = Promise();\n     *      p.fulfill([1,2,3])\n     *      p.spread(function(a,b,c){\n     *          console.log(a,b,c); // => '1 2 3'\n     *      });\n     *\n     * @param {Function} onFulfill callback\n     * @param {Function} onReject errback\n     * @param {Function} onNotify callback\n     * @return {Object} a decendant promise\n     * @api public\n     */\n    Promise.prototype.spread = function(f,r,n){\n        function s(v,a){\n            if(!isArray(v)) v = [v];\n            return f.apply(f,v.concat(a));\n        }\n\n        return this.then(s,r,n);\n    };\n\n    \n    /**\n     * Terminates chain of promises, calls onerror or throws on unhandled Errors\n     *\n     * Example: capture error with done\n     *      p.then(function(v){\n     *          console.log('v is:', v);\n     *          if(v > 10) throw new RangeError('to large!');\n     *          return v*2;\n     *      }).done(function(v){\n     *          // gets v*2 from above\n     *          console.log('v is:', v)\n     *      });\n     *\n     *      p.fulfill(142); // => v is: 142, throws [RangeError:'to large']\n     *\n     * Example: define onerror handler defined on promise\n     *      p.onerror = function(error){ console.log(\"Sorry:\",error) };\n     *      p.then(function(v){\n     *          console.log('v is:', v);\n     *          if(v > 10) throw new RangeError('to large!');\n     *          return v*2;\n     *      }).done(function(v){\n     *          // gets v*2 from above\n     *          console.log('v is:', v)\n     *      });\n     *      p.fulfill(142); // => v is: 142, \"Sorry: [RangeError:'to large']\"\n     *\n     * @param {Function} onFulfill callback\n     * @param {Function} onReject errback\n     * @param {Function} onNotify callback\n     * @api public\n     */\n    Promise.prototype.done = function(f,r,n){\t\n        var self = this, p = this.then(f,catchError,n);\n\n        function catchError(e){\n            task(function(){\n\t\tif(typeof r === 'function') r(e);\n                else if(typeof self.onerror === 'function'){\n                    self.onerror(e);\n                } else if(Promise.onerror === 'function'){\n                    Promise.onerror(e);\n                } else throw e;\n            });\n        }\n    };\n\n    /** \n     * Terminates chain, invokes a callback or throws Error on error \n     *\n     * @param {Function} callback - Callback with value or Error object on error.\n     * @api public\n     */\n    Promise.prototype.end = function(callback){\n\t\n\tthis.then(callback,function(e){\n\t    if(!(e instanceof Error)){\n\t\te = new Error(e);\n\t    }\n\t    \n\t    if(typeof callback === 'function') callback(e);\n\t    else throw e;\n\t});\n    };\n\n\n    /**\n     * Catches errors, terminates promise chain and calls errBack handler.\n     *\n     *\n     * Example: Catch error\n     *      p = Promise();\n     *      p.then(function(v){\n     *          console.log(\"someone said:\", v);  //-> \"Hello there\"\n     *          return \"boom!\";\n     *        })\n     *       .then(function(v){ if(v === 'boom!') throw \"something bad happened!\";})\n     *       .catch(function(e){\n     *          console.log(\"error:\",e);\n     *       });\n     *      p.resolve(\"Hello there\");\n     *\n     * @param {Function} onError callback\n     * @return undefined \n     * @api public\n     */\n    Promise.prototype.catch = function(errBack){\n\tthis.done(undefined,errBack);\n    };\n    /**\n     * Fulfills a promise with a `value`\n     *\n     *\n     *  Example: fulfillment\n     *      p = Promise();\n     *      p.fulfill(123);\n     *\n     *  Example: multiple fulfillment values in array\n     *      p = Promise();\n     *      p.fulfill([1,2,3]);\n     *      p.resolved; // => [1,2,3]\n     *\n     *  Example: Pass through opaque arguments (experimental)\n     *      p = Promise();\n     *      p.fulfill(\"hello\",\"world\");\n     *      p.then(function(x,o){\n     *          console.log(x,o[0]); // => \"hello world\"\n     *          o.push(\"!\");\n     *          return \"bye bye\";\n     *      }).then(function(x,o){\n     *          console.log(x,o.join('')); // => \"bye bye world!\"\n     *      })\n     *\n     * @param {Object} value\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.fulfill = function(value,opaque){\n\tvar self = this._promise;\n\t\n\tif(!self._state) {\n\t    self._state = FULFILLED;\n\t    self._value = value;\n\t    self._opaque = opaque;\n\t    task(traverse,[self]);\n\t}\n\t\n        return this;\n    };\n\n\n    /**\n     * Rejects promise with a `reason`\n     *\n     *  Example:\n     *      p = Promise();\n     *      p.then(function(ok){\n     *         console.log(\"ok:\",ok);\n     *      }, function(error){\n     *         console.log(\"error:\",error);\n     *      });\n     *      p.reject('some error'); // outputs => 'error: some error'\n     *\n     * @param {Object} reason\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.reject = function(reason,opaque){\n\tvar self = this._promise;\n\t\n\tif(self._state === undefined){\n\t    self._state = REJECTED;\n\t    self._value = reason;\n\t    self._opaque = opaque;\n\t    \n\t    task(traverse,[self,REJECTED,reason,opaque]);\n\t}\n\t\n        return this;\n    };\n\n    /**\n     * Resolves a promise and performs unwrapping if necessary  \n     *\n     *\n     *  Example: resolve a literal\n     *      p = Promise();\n     *      p.resolve(123); // fulfills promise to 123\n     *\n     *  Example: resolve value from pending promise\n     *      p1 = Promise();\n     *      p2 = Promise();\n     *      p1.resolve(p2);\n     *      p2.fulfill(123) // => p1 fulfills to 123\n     *\n     * @param {Object} value - Promise or literal\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.resolve = function(x,o){\n        var then, z = 0, self = this._promise, p = this;\n\n        if(!self._state){\n            if(x === p) p.reject(new TypeError(\"Promise cannot resolve itself!\"));\n\n            if(x && (typeof x === 'object' || typeof x === 'function')){\n                try { then = x.then; } catch(e){ p.reject(e); }\n            }\n\n            if(typeof then !== 'function'){\n\t\tp.fulfill(x,o);\n            } else if(!z){\n                try {\n                    then.apply(x,[function(y){\n                        if(!z) {\n                            p.resolve(y,o);\n                            z = 1;\n                        }\n                    },function(r){\n                        if(!z) {\n                            p.reject(r);\n                            z = 1;\n                        }\n                    }]);\n                } catch(e) {\n                    if(!z) {\n\t\t\tp.reject(e);\n\t\t\tz = 1;\n                    }\n                }\n            }\n        }\n\n        return this;\n    };\n\n\n    /**\n     * Notifies attached handlers\n     *\n     *  Example:\n     *      p = Promise();\n     *      p.then(function(ok){\n     *         console.log(\"ok:\",ok);\n     *      }, function(error){\n     *         console.log(\"error:\",error);\n     *      }, function(notify){\n     *         console.log(notify);\n     *      });\n     *      p.progress(\"almost done\"); // optputs => 'almost done'\n     *      p.reject('some error'); // outputs => 'error: some error'\n     *\n     * @param {Object} arguments\n     * @api public\n     */\n    Promise.prototype.progress = function(){\n        var notify, chain = this._promise._chain;\n\n\tfor(var i = 0, l = chain.length; i < l; i++){\n            if(typeof (notify = chain[i][2]) === 'function')\n                notify.apply(this,arguments);\n        }\n    };\n\n    /**\n     * Timeout a pending promise and invoke callback function on timeout.\n     * Without a callback it throws a RangeError('exceeded timeout').\n     *\n     * Example: timeout & abort()\n     *      var p = Promise();\n     *      p.timeout(5000);\n     *      // ... after 5 secs ... => Aborted: |RangeError: 'exceeded timeout']\n     *\n     * Example: cancel timeout\n     *      p.timeout(5000);\n     *      p.timeout(null); // timeout cancelled\n     *\n     * @param {Number} time - timeout value in ms or null to clear timeout\n     * @param {Function} callback - optional timeout function callback\n     * @throw {RangeError} If timeout exceeded \n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.timeout = function(msec,func){\n        var p = this, self = this._promise;\n\n        if(msec === null) {\n            if(self._timeout)\n\t\troot.clearTimeout(self._timeout);\n\t    \n            self._timeout = null;\n        } else if(!self._timeout){\n            self._timeout = root.setTimeout(onTimeout,msec);\n        }\n\n        function onTimeout(){\n            var e = new RangeError(\"exceeded timeout\");\n            if(!self._state) {\n                if(typeof func === 'function') func(p);\n                else if(typeof p.onerror === 'function') p.onerror(e);\n                else throw e;\n            }\n        }\n\n        return this;\n    };\n\n    /**\n     * Resolves promise to a nodejs styled callback function(err,ret) \n     * and passes the callbacks return value down the chain.\n     *\n     * Example:\n     *      function cb(err,ret){\n     *        if(err) console.log(\"error(%s):\",err,ret);\n     *        else console.log(\"success:\", ret);\n     *\n     *        return \"nice\";\n     *      }\n     *\n     *      p = Promise();\n     *      p.callback(cb)\n     *       .then(function(cbret){ \n     *         console.log(\"callback says:\", cbret); //-> callback says: nice \n     *      });\n     *\n     *      p.fulfill(\"ok\"); //-> success: ok\n     *\n     * @param {Function} callback - Callback function\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.callback = function(callback){\n        return this.then(function(value,opaque){\n            return callback(undefined,value,opaque);\n        },function(reason,opaque){\n\t    var error = reason;\n\t    \n\t    if(!(error instanceof Error)){\n\t\tif(typeof reason === 'object'){\n\t\t    error = new Error(JSON.stringify(reason));\n\t\t    for(var k in reason)\n\t\t\terror[k] = reason[k];\n\t\t} else {\n\t\t    error = new Error(reason);\n\t\t}\n\t    }\n\n            return callback(error,opaque);\n        },function(progress){\n            return callback(0,progress);\n        });\n    };\n    \n    /**\n     * Joins promises and collects results into an array.\n     * If any of the promises are rejected the chain is also rejected.\n     *\n     * Example: join with two promises\n     *      a = Promise();\n     *      b = Promise();\n     *      c = Promise();\n     *      a.join([b,c]).spread(function(a,b,c){\n     *          console.log(a,b,c);\n     *      },function(err){\n     *          console.log('error=',err);\n     *      });\n     *      b.fulfill('world');\n     *      a.fulfill('hello');\n     *      c.fulfill('!'); // => 'hello world !''\n     *\n     * @param {Array} promises\n     * @return {Object} promise\n     * @api public\n     */\n    Promise.prototype.join = function(j){\n        var p = this,\n            y = [],\n            u = new Promise().resolve(p).then(function(v){y[0] = v;});\n\n        if(arguments.length > 1) {\n            j = slice.call(arguments);\n        }\n\n        if(!isArray(j)) j = [j];\n\n\tfunction stop(error){\n\t    u.reject(error);\n\t}\n\t\n        function collect(i){\n            j[i].then(function(v){\n                y[i+1] = v;\n            }).catch(stop);\n\n            return function(){return j[i];};\n        }\n\n        for(var i = 0; i < j.length; i++){\n            u = u.then(collect(i));\n        }\n\n        return u.then(function(){return y;});\n    };\n\n    // Resolver function, yields a promised value to handlers\n    function traverse(_promise){\n\tvar c = _promise._chain,\n\t    s = _promise._state,\n\t    v = _promise._value,\n\t    o = _promise._opaque,\n\t    t, p, h, r;\n\t\n        while((t = c.shift())){\n\t    p = t[0];\n            h = t[s];\n\n            if(typeof h === 'function') {\n                try {\n                    r = h(v,o);\n\t\t    p.resolve(r,o);\n                } catch(e) {\n\t\t    p.reject(e);\n                }\n            } else {\n\t\tp._promise._state = s;\n\t\tp._promise._value = v;\n\t\tp._promise._opaque = o;\n\t\t\n\t\ttask(traverse,[p._promise]);\n            }\n        }\n    }\n\n    /* expose this module */\n    if(module && module.exports) module.exports = Promise;\n    else if(typeof define ==='function' && define.amd) define(Promise);\n    else root.Promise = Promise;\n}(this));\n"]}