{"version":3,"sources":["webpack:///./node_modules/nodent-runtime/thenableFactory.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/nodent-runtime/runtime.js","webpack:///./node_modules/nodent-runtime/zousan.js","webpack:///./node_modules/path-browserify/index.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","nextTick","fn","setTimeout","platform","arch","execPath","title","pid","browser","env","argv","binding","name","Error","path","cwd","chdir","dir","__webpack_require__","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","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","arg","next","done","throw","process","tick","setImmediate","f","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","normalizeArray","parts","allowAboveRoot","up","i","last","unshift","splitPathRe","splitPath","filename","filter","xs","resolvedPath","resolvedAbsolute","charAt","split","join","normalize","isAbsolute","trailingSlash","paths","Array","relative","from","to","trim","arr","start","end","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","result","root","basename","ext","extname","str","len"],"mappings":"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","file":"js/chunk-vendors~b58f7129.b676d5db.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","exports.nextTick = function nextTick(fn) {\n\tsetTimeout(fn, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\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","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar splitPath = function(filename) {\n  return splitPathRe.exec(filename).slice(1);\n};\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nexports.basename = function(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nexports.extname = function(path) {\n  return splitPath(path)[3];\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n"],"sourceRoot":""}