{"version":3,"sources":["webpack:///./node_modules/nodent-runtime/thenableFactory.js","webpack:///./node_modules/nodent-runtime/runtime.js","webpack:///./node_modules/nodent-runtime/zousan.js"],"names":["module","exports","isThenable","obj","Object","then","resolution","p","r","how","x","reject","TypeError","y","e","resolve","ex","_unchained","v","thenChain","res","rej","this","Chained","chain","_resolver","value","Thenable","resolver","prototype","processIncludes","includes","input","src","toString","t","args","match","re","m","mx","exec","push","reverse","forEach","slice","index","substr","length","replace","Function","$asyncbind","zousan","thenable","self","catcher","boundThen","apply","arguments","defineProperty","enumerable","configurable","writable","trampoline","s","u","b","q","undefined","pop","call","LazyThenable","EagerThenable","EagerThenableFactory","$asyncspawn","promiseProvider","genF","gen","step","fn","arg","next","done","throw","tick","process","nextTick","setImmediate","f","setTimeout","soon","fq","fqStart","bufferSize","callQueue","splice","Zousan","func","me","STATE_FULFILLED","c","yret","err","STATE_REJECTED","reason","n","state","first","ra","rr","l","clients","onF","onR","client","a","val","z","version"],"mappings":"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","file":"js/chunk-vendors~d1a61510.3018392f.js","sourcesContent":["module.exports = function() {\n    function isThenable(obj) {\n        return obj && (obj instanceof Object) && typeof obj.then===\"function\";\n    }\n\n    function resolution(p,r,how) {\n        try {\n            /* 2.2.7.1 */\n            var x = how ? how(r):r ;\n\n            if (p===x) /* 2.3.1 */\n                return p.reject(new TypeError(\"Promise resolution loop\")) ;\n\n            if (isThenable(x)) {\n                /* 2.3.3 */\n                x.then(function(y){\n                    resolution(p,y);\n                },function(e){\n                    p.reject(e)\n                }) ;\n            } else {\n                p.resolve(x) ;\n            }\n        } catch (ex) {\n            /* 2.2.7.2 */\n            p.reject(ex) ;\n        }\n    }\n\n    function _unchained(v){}\n    function thenChain(res,rej){\n        this.resolve = res;\n        this.reject = rej;\n    }\n\n    function Chained() {};\n    Chained.prototype = {\n        resolve:_unchained,\n        reject:_unchained,\n        then:thenChain\n    };\n    \n    function then(res,rej){\n        var chain = new Chained() ;\n        try {\n            this._resolver(function(value) {\n                return isThenable(value) ? value.then(res,rej) : resolution(chain,value,res);\n            },function(ex) {\n                resolution(chain,ex,rej) ;\n            }) ;\n        } catch (ex) {\n            resolution(chain,ex,rej);\n        }\n        return chain ;\n    }\n\n    function Thenable(resolver) {\n        this._resolver = resolver ;\n        this.then = then ;\n    };\n\n    Thenable.resolve = function(v){\n        return Thenable.isThenable(v) ? v : {then:function(resolve){return resolve(v)}};\n    };\n\n    Thenable.isThenable = isThenable ;\n\n    return Thenable ;\n} ;\n","\"use strict\";\n/*\n * $asyncbind has multiple uses, depending on the parameter list. It is in Function.prototype, so 'this' is always a function\n *\n * 1) If called with a single argument (this), it is used when defining an async function to ensure when\n *      it is invoked, the correct 'this' is present, just like \"bind\". For legacy reasons, 'this' is given\n *      a memeber 'then' which refers to itself.\n * 2) If called with a second parameter (\"catcher\") and catcher!==true it is being used to invoke an async\n *      function where the second parameter is the error callback (for sync exceptions and to be passed to\n *      nested async calls)\n * 3) If called with the second parameter===true, it is the same use as (1), but the function is wrapped\n *      in an 'Promise' as well bound to 'this'.\n *      It is the same as calling 'new Promise(this)', where 'this' is the function being bound/wrapped\n * 4) If called with the second parameter===0, it is the same use as (1), but the function is wrapped\n *      in a 'LazyThenable', which executes lazily and can resolve synchronously.\n *      It is the same as calling 'new LazyThenable(this)' (if such a type were exposed), where 'this' is\n *      the function being bound/wrapped\n */\n\nfunction processIncludes(includes,input) {\n    var src = input.toString() ;\n    var t = \"return \"+src ;\n    var args = src.match(/.*\\(([^)]*)\\)/)[1] ;\n    var re = /['\"]!!!([^'\"]*)['\"]/g ;\n    var m = [] ;\n    while (1) {\n        var mx = re.exec(t) ;\n        if (mx)\n            m.push(mx) ;\n        else break ;\n    }\n    m.reverse().forEach(function(e){\n        t = t.slice(0,e.index)+includes[e[1]]+t.substr(e.index+e[0].length) ;\n    }) ;\n    t = t.replace(/\\/\\*[^*]*\\*\\//g,' ').replace(/\\s+/g,' ') ;\n    return new Function(args,t)() ;\n}\n\nvar $asyncbind = processIncludes({\n    zousan:require('./zousan').toString(),\n    thenable:require('./thenableFactory').toString()\n},\nfunction $asyncbind(self,catcher) {\n    \"use strict\";\n    if (!Function.prototype.$asyncbind) {\n        Object.defineProperty(Function.prototype,\"$asyncbind\",{value:$asyncbind,enumerable:false,configurable:true,writable:true}) ;\n    }\n\n    if (!$asyncbind.trampoline) {\n      $asyncbind.trampoline = function trampoline(t,x,s,e,u){\n        return function b(q) {\n                while (q) {\n                    if (q.then) {\n                        q = q.then(b, e) ;\n                        return u?undefined:q;\n                    }\n                    try {\n                        if (q.pop) {\n                            if (q.length)\n                              return q.pop() ? x.call(t) : q;\n                            q = s;\n                         } else\n                            q = q.call(t)\n                    } catch (r) {\n                        return e(r);\n                    }\n                }\n            }\n        };\n    }\n    if (!$asyncbind.LazyThenable) {\n        $asyncbind.LazyThenable = '!!!thenable'();\n        $asyncbind.EagerThenable = $asyncbind.Thenable = ($asyncbind.EagerThenableFactory = '!!!zousan')();\n    }\n\n    function boundThen() {\n        return resolver.apply(self,arguments);\n    }\n\n    var resolver = this;\n    switch (catcher) {\n    case true:\n        return new ($asyncbind.Thenable)(boundThen);\n    case 0:\n        return new ($asyncbind.LazyThenable)(boundThen);\n    case undefined:\n        /* For runtime compatibility with Nodent v2.x, provide a thenable */\n        boundThen.then = boundThen ;\n        return boundThen ;\n    default:\n        return function(){\n            try {\n                return resolver.apply(self,arguments);\n            } catch(ex) {\n                return catcher(ex);\n            }\n        }\n    }\n\n}) ;\n\nfunction $asyncspawn(promiseProvider,self) {\n    if (!Function.prototype.$asyncspawn) {\n        Object.defineProperty(Function.prototype,\"$asyncspawn\",{value:$asyncspawn,enumerable:false,configurable:true,writable:true}) ;\n    }\n    if (!(this instanceof Function)) return ;\n\n    var genF = this ;\n    return new promiseProvider(function enough(resolve, reject) {\n        var gen = genF.call(self, resolve, reject);\n        function step(fn,arg) {\n            var next;\n            try {\n                next = fn.call(gen,arg);\n                if(next.done) {\n                    if (next.value !== resolve) {\n                        if (next.value && next.value===next.value.then)\n                            return next.value(resolve,reject) ;\n                        resolve && resolve(next.value);\n                        resolve = null ;\n                    }\n                    return;\n                }\n\n                if (next.value.then) {\n                    next.value.then(function(v) {\n                        step(gen.next,v);\n                    }, function(e) {\n                        step(gen.throw,e);\n                    });\n                } else {\n                    step(gen.next,next.value);\n                }\n            } catch(e) {\n                reject && reject(e);\n                reject = null ;\n                return;\n            }\n        }\n        step(gen.next);\n    });\n}\n\n// Initialize async bindings\n$asyncbind() ;\n$asyncspawn() ;\n\n// Export async bindings\nmodule.exports = {\n    $asyncbind:$asyncbind,\n    $asyncspawn:$asyncspawn\n};\n","/* This code is based on:\nzousan - A Lightning Fast, Yet Very Small Promise A+ Compliant Implementation\nhttps://github.com/bluejava/zousan\nAuthor: Glenn Crownover <glenn@bluejava.com> (http://www.bluejava.com)\nVersion 2.3.3\nLicense: MIT */\n\"use strict\";\nmodule.exports = function(tick){\n    tick = tick || (typeof process===\"object\" && process.nextTick) || (typeof setImmediate===\"function\" && setImmediate) || function(f){setTimeout(f,0)};\n    var soon = (function () {\n        var fq = [], fqStart = 0, bufferSize = 1024;\n        function callQueue() {\n            while (fq.length - fqStart) {\n                try { fq[fqStart]() } catch(ex) { /* console.error(ex) */ }\n                fq[fqStart++] = undefined;\n                if (fqStart === bufferSize) {\n                    fq.splice(0, bufferSize);\n                    fqStart = 0;\n                }\n            }\n        }\n\n        return function (fn) {\n            fq.push(fn);\n            if (fq.length - fqStart === 1)\n                tick(callQueue);\n        };\n    })();\n\n    function Zousan(func) {\n        if (func) {\n            var me = this;\n            func(function (arg) {\n                me.resolve(arg);\n            }, function (arg) {\n                me.reject(arg);\n            });\n        }\n    }\n\n    Zousan.prototype = {\n        resolve: function (value) {\n            if (this.state !== undefined)\n                return;\n            if (value === this)\n                return this.reject(new TypeError(\"Attempt to resolve promise with self\"));\n            var me = this;\n            if (value && (typeof value === \"function\" || typeof value === \"object\")) {\n                try {\n                    var first = 0;\n                    var then = value.then;\n                    if (typeof then === \"function\") {\n                        then.call(value, function (ra) {\n                            if (!first++) {\n                                me.resolve(ra);\n                            }\n                        }, function (rr) {\n                            if (!first++) {\n                                me.reject(rr);\n                            }\n                        });\n                        return;\n                    }\n                } catch (e) {\n                    if (!first)\n                        this.reject(e);\n                    return;\n                }\n            }\n            this.state = STATE_FULFILLED;\n            this.v = value;\n            if (me.c)\n                soon(function () {\n                    for (var n = 0, l = me.c.length;n < l; n++)\n                        STATE_FULFILLED(me.c[n], value);\n                });\n        },\n        reject: function (reason) {\n            if (this.state !== undefined)\n                return;\n            this.state = STATE_REJECTED;\n            this.v = reason;\n            var clients = this.c;\n            if (clients)\n                soon(function () {\n                    for (var n = 0, l = clients.length;n < l; n++)\n                        STATE_REJECTED(clients[n], reason);\n                });\n        },\n        then: function (onF, onR) {\n            var p = new Zousan();\n            var client = {\n                y: onF,\n                n: onR,\n                p: p\n            };\n            if (this.state === undefined) {\n                if (this.c)\n                    this.c.push(client);\n                else\n                    this.c = [client];\n            } else {\n                var s = this.state, a = this.v;\n                soon(function () {\n                    s(client, a);\n                });\n            }\n            return p;\n        }\n    };\n\n    function STATE_FULFILLED(c, arg) {\n        if (typeof c.y === \"function\") {\n            try {\n                var yret = c.y.call(undefined, arg);\n                c.p.resolve(yret);\n            } catch (err) {\n                c.p.reject(err);\n            }\n        } else\n            c.p.resolve(arg);\n    }\n\n    function STATE_REJECTED(c, reason) {\n        if (typeof c.n === \"function\") {\n            try {\n                var yret = c.n.call(undefined, reason);\n                c.p.resolve(yret);\n            } catch (err) {\n                c.p.reject(err);\n            }\n        } else\n            c.p.reject(reason);\n    }\n\n    Zousan.resolve = function (val) {\n        if (val && (val instanceof Zousan))\n            return val ;\n        var z = new Zousan();\n        z.resolve(val);\n        return z;\n    };\n    Zousan.reject = function (err) {\n        if (err && (err instanceof Zousan))\n            return err ;\n        var z = new Zousan();\n        z.reject(err);\n        return z;\n    };\n\n    Zousan.version = \"2.3.3-nodent\" ;\n    return Zousan ;\n};\n"],"sourceRoot":""}