Created
February 5, 2014 20:05
-
-
Save Nek/8831929 to your computer and use it in GitHub Desktop.
transpiled code
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
var wrapGenerator = require('regeneratorify/runtime').wrapGenerator; | |
wrapGenerator.mark(listen); | |
function listen(el, evType) { | |
return wrapGenerator(function listen$($ctx) { | |
while (1) switch ($ctx.next) { | |
case 0: | |
if (!true) { | |
$ctx.next = 5; | |
break; | |
} | |
$ctx.next = 3; | |
return function(cb) { | |
var fire = function(ev) { | |
el.removeEventListener(evType, fire); | |
cb(null, ev); | |
} | |
el.addEventListener(evType, fire); | |
} | |
case 3: | |
$ctx.next = 0; | |
break; | |
case 5: | |
case "end": | |
return $ctx.stop(); | |
} | |
}, this); | |
} | |
var gens = require('gens'); | |
function go(gen) { | |
gens(gen)(function(err) { if (err) throw err; }); | |
} | |
go(wrapGenerator.mark(function() { | |
var clicks; | |
return wrapGenerator(function($ctx) { | |
while (1) switch ($ctx.next) { | |
case 0: | |
clicks = listen(document.getElementById('search'), 'click'); | |
while (true) | |
console.log(clicks.next().value); | |
case 2: | |
case "end": | |
return $ctx.stop(); | |
} | |
}, this); | |
})); | |
},{"gens":44,"regeneratorify/runtime":50}],2:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, Promise$_CreatePromiseArray, PromiseArray) { | |
var SomePromiseArray = require("./some_promise_array.js")(PromiseArray); | |
var ASSERT = require("./assert.js"); | |
function Promise$_Any(promises, useBound, caller) { | |
var ret = Promise$_CreatePromiseArray( | |
promises, | |
SomePromiseArray, | |
caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0 | |
); | |
var promise = ret.promise(); | |
if (promise.isRejected()) { | |
return promise; | |
} | |
ret.setHowMany(1); | |
ret.setUnwrap(); | |
ret.init(); | |
return promise; | |
} | |
Promise.any = function Promise$Any(promises) { | |
return Promise$_Any(promises, false, Promise.any); | |
}; | |
Promise.prototype.any = function Promise$any() { | |
return Promise$_Any(this, true, this.any); | |
}; | |
}; | |
},{"./assert.js":3,"./some_promise_array.js":36}],3:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = (function(){ | |
var AssertionError = (function() { | |
function AssertionError(a) { | |
this.constructor$(a); | |
this.message = a; | |
this.name = "AssertionError"; | |
} | |
AssertionError.prototype = new Error(); | |
AssertionError.prototype.constructor = AssertionError; | |
AssertionError.prototype.constructor$ = Error; | |
return AssertionError; | |
})(); | |
return function assert(boolExpr, message) { | |
if (boolExpr === true) return; | |
var ret = new AssertionError(message); | |
if (Error.captureStackTrace) { | |
Error.captureStackTrace(ret, assert); | |
} | |
if (console && console.error) { | |
console.error(ret.stack + ""); | |
} | |
throw ret; | |
}; | |
})(); | |
},{}],4:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var ASSERT = require("./assert.js"); | |
var schedule = require("./schedule.js"); | |
var Queue = require("./queue.js"); | |
var errorObj = require("./util.js").errorObj; | |
var tryCatch1 = require("./util.js").tryCatch1; | |
function Async() { | |
this._isTickUsed = false; | |
this._length = 0; | |
this._lateBuffer = new Queue(); | |
this._functionBuffer = new Queue(25000 * 3); | |
var self = this; | |
this.consumeFunctionBuffer = function Async$consumeFunctionBuffer() { | |
self._consumeFunctionBuffer(); | |
}; | |
} | |
Async.prototype.haveItemsQueued = function Async$haveItemsQueued() { | |
return this._length > 0; | |
}; | |
Async.prototype.invokeLater = function Async$invokeLater(fn, receiver, arg) { | |
this._lateBuffer.push(fn, receiver, arg); | |
this._queueTick(); | |
}; | |
Async.prototype.invoke = function Async$invoke(fn, receiver, arg) { | |
var functionBuffer = this._functionBuffer; | |
functionBuffer.push(fn, receiver, arg); | |
this._length = functionBuffer.length(); | |
this._queueTick(); | |
}; | |
Async.prototype._consumeFunctionBuffer = | |
function Async$_consumeFunctionBuffer() { | |
var functionBuffer = this._functionBuffer; | |
while(functionBuffer.length() > 0) { | |
var fn = functionBuffer.shift(); | |
var receiver = functionBuffer.shift(); | |
var arg = functionBuffer.shift(); | |
fn.call(receiver, arg); | |
} | |
this._reset(); | |
this._consumeLateBuffer(); | |
}; | |
Async.prototype._consumeLateBuffer = function Async$_consumeLateBuffer() { | |
var buffer = this._lateBuffer; | |
while(buffer.length() > 0) { | |
var fn = buffer.shift(); | |
var receiver = buffer.shift(); | |
var arg = buffer.shift(); | |
var res = tryCatch1(fn, receiver, arg); | |
if (res === errorObj) { | |
this._queueTick(); | |
throw res.e; | |
} | |
} | |
}; | |
Async.prototype._queueTick = function Async$_queue() { | |
if (!this._isTickUsed) { | |
schedule(this.consumeFunctionBuffer); | |
this._isTickUsed = true; | |
} | |
}; | |
Async.prototype._reset = function Async$_reset() { | |
this._isTickUsed = false; | |
this._length = 0; | |
}; | |
module.exports = new Async(); | |
},{"./assert.js":3,"./queue.js":29,"./schedule.js":32,"./util.js":40}],5:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var Promise = require("./promise.js")(); | |
module.exports = Promise; | |
},{"./promise.js":21}],6:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise) { | |
Promise.prototype.call = function Promise$call(propertyName) { | |
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];} | |
return this._then(function(obj) { | |
return obj[propertyName].apply(obj, args); | |
}, | |
void 0, | |
void 0, | |
void 0, | |
void 0, | |
this.call | |
); | |
}; | |
function Promise$getter(obj) { | |
var prop = typeof this === "string" | |
? this | |
: ("" + this); | |
return obj[prop]; | |
} | |
Promise.prototype.get = function Promise$get(propertyName) { | |
return this._then( | |
Promise$getter, | |
void 0, | |
void 0, | |
propertyName, | |
void 0, | |
this.get | |
); | |
}; | |
}; | |
},{}],7:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var errors = require("./errors.js"); | |
var async = require("./async.js"); | |
var ASSERT = require("./assert.js"); | |
var CancellationError = errors.CancellationError; | |
var SYNC_TOKEN = {}; | |
Promise.prototype._cancel = function Promise$_cancel() { | |
if (!this.isCancellable()) return this; | |
var parent; | |
if ((parent = this._cancellationParent) !== void 0) { | |
parent.cancel(SYNC_TOKEN); | |
return; | |
} | |
var err = new CancellationError(); | |
this._attachExtraTrace(err); | |
this._rejectUnchecked(err); | |
}; | |
Promise.prototype.cancel = function Promise$cancel(token) { | |
if (!this.isCancellable()) return this; | |
if (token === SYNC_TOKEN) { | |
this._cancel(); | |
return this; | |
} | |
async.invokeLater(this._cancel, this, void 0); | |
return this; | |
}; | |
Promise.prototype.cancellable = function Promise$cancellable() { | |
if (this._cancellable()) return this; | |
this._setCancellable(); | |
this._cancellationParent = void 0; | |
return this; | |
}; | |
Promise.prototype.uncancellable = function Promise$uncancellable() { | |
var ret = new Promise(INTERNAL); | |
ret._setTrace(this.uncancellable, this); | |
ret._follow(this); | |
ret._unsetCancellable(); | |
if (this._isBound()) ret._setBoundTo(this._boundTo); | |
return ret; | |
}; | |
Promise.prototype.fork = | |
function Promise$fork(didFulfill, didReject, didProgress) { | |
var ret = this._then(didFulfill, didReject, didProgress, | |
void 0, void 0, this.fork); | |
ret._setCancellable(); | |
ret._cancellationParent = void 0; | |
return ret; | |
}; | |
}; | |
},{"./assert.js":3,"./async.js":4,"./errors.js":11}],8:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function() { | |
var ASSERT = require("./assert.js"); | |
var inherits = require("./util.js").inherits; | |
var defineProperty = require("./es5.js").defineProperty; | |
var rignore = new RegExp( | |
"\\b(?:[\\w.]*Promise(?:Array|Spawn)?\\$_\\w+|" + | |
"tryCatch(?:1|2|Apply)|new \\w*PromiseArray|" + | |
"\\w*PromiseArray\\.\\w*PromiseArray|" + | |
"setTimeout|CatchFilter\\$_\\w+|makeNodePromisified|processImmediate|" + | |
"process._tickCallback|nextTick|Async\\$\\w+)\\b" | |
); | |
var rtraceline = null; | |
var formatStack = null; | |
var areNamesMangled = false; | |
function formatNonError(obj) { | |
var str; | |
if (typeof obj === "function") { | |
str = "[function " + | |
(obj.name || "anonymous") + | |
"]"; | |
} | |
else { | |
str = obj.toString(); | |
var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/; | |
if (ruselessToString.test(str)) { | |
try { | |
var newStr = JSON.stringify(obj); | |
str = newStr; | |
} | |
catch(e) { | |
} | |
} | |
if (str.length === 0) { | |
str = "(empty array)"; | |
} | |
} | |
return ("(<" + snip(str) + ">, no stack trace)"); | |
} | |
function snip(str) { | |
var maxChars = 41; | |
if (str.length < maxChars) { | |
return str; | |
} | |
return str.substr(0, maxChars - 3) + "..."; | |
} | |
function CapturedTrace(ignoreUntil, isTopLevel) { | |
if (!areNamesMangled) { | |
} | |
this.captureStackTrace(ignoreUntil, isTopLevel); | |
} | |
inherits(CapturedTrace, Error); | |
CapturedTrace.prototype.captureStackTrace = | |
function CapturedTrace$captureStackTrace(ignoreUntil, isTopLevel) { | |
captureStackTrace(this, ignoreUntil, isTopLevel); | |
}; | |
CapturedTrace.possiblyUnhandledRejection = | |
function CapturedTrace$PossiblyUnhandledRejection(reason) { | |
if (typeof console === "object") { | |
var message; | |
if (typeof reason === "object" || typeof reason === "function") { | |
var stack = reason.stack; | |
message = "Possibly unhandled " + formatStack(stack, reason); | |
} | |
else { | |
message = "Possibly unhandled " + String(reason); | |
} | |
if (typeof console.error === "function" || | |
typeof console.error === "object") { | |
console.error(message); | |
} | |
else if (typeof console.log === "function" || | |
typeof console.error === "object") { | |
console.log(message); | |
} | |
} | |
}; | |
areNamesMangled = CapturedTrace.prototype.captureStackTrace.name !== | |
"CapturedTrace$captureStackTrace"; | |
CapturedTrace.combine = function CapturedTrace$Combine(current, prev) { | |
var curLast = current.length - 1; | |
for (var i = prev.length - 1; i >= 0; --i) { | |
var line = prev[i]; | |
if (current[curLast] === line) { | |
current.pop(); | |
curLast--; | |
} | |
else { | |
break; | |
} | |
} | |
current.push("From previous event:"); | |
var lines = current.concat(prev); | |
var ret = []; | |
for (var i = 0, len = lines.length; i < len; ++i) { | |
if ((rignore.test(lines[i]) || | |
(i > 0 && !rtraceline.test(lines[i])) && | |
lines[i] !== "From previous event:") | |
) { | |
continue; | |
} | |
ret.push(lines[i]); | |
} | |
return ret; | |
}; | |
CapturedTrace.isSupported = function CapturedTrace$IsSupported() { | |
return typeof captureStackTrace === "function"; | |
}; | |
var captureStackTrace = (function stackDetection() { | |
if (typeof Error.stackTraceLimit === "number" && | |
typeof Error.captureStackTrace === "function") { | |
rtraceline = /^\s*at\s*/; | |
formatStack = function(stack, error) { | |
if (typeof stack === "string") return stack; | |
if (error.name !== void 0 && | |
error.message !== void 0) { | |
return error.name + ". " + error.message; | |
} | |
return formatNonError(error); | |
}; | |
var captureStackTrace = Error.captureStackTrace; | |
return function CapturedTrace$_captureStackTrace( | |
receiver, ignoreUntil) { | |
captureStackTrace(receiver, ignoreUntil); | |
}; | |
} | |
var err = new Error(); | |
if (!areNamesMangled && typeof err.stack === "string" && | |
typeof "".startsWith === "function" && | |
(err.stack.startsWith("stackDetection@")) && | |
stackDetection.name === "stackDetection") { | |
defineProperty(Error, "stackTraceLimit", { | |
writable: true, | |
enumerable: false, | |
configurable: false, | |
value: 25 | |
}); | |
rtraceline = /@/; | |
var rline = /[@\n]/; | |
formatStack = function(stack, error) { | |
if (typeof stack === "string") { | |
return (error.name + ". " + error.message + "\n" + stack); | |
} | |
if (error.name !== void 0 && | |
error.message !== void 0) { | |
return error.name + ". " + error.message; | |
} | |
return formatNonError(error); | |
}; | |
return function captureStackTrace(o, fn) { | |
var name = fn.name; | |
var stack = new Error().stack; | |
var split = stack.split(rline); | |
var i, len = split.length; | |
for (i = 0; i < len; i += 2) { | |
if (split[i] === name) { | |
break; | |
} | |
} | |
split = split.slice(i + 2); | |
len = split.length - 2; | |
var ret = ""; | |
for (i = 0; i < len; i += 2) { | |
ret += split[i]; | |
ret += "@"; | |
ret += split[i + 1]; | |
ret += "\n"; | |
} | |
o.stack = ret; | |
}; | |
} | |
else { | |
formatStack = function(stack, error) { | |
if (typeof stack === "string") return stack; | |
if ((typeof error === "object" || | |
typeof error === "function") && | |
error.name !== void 0 && | |
error.message !== void 0) { | |
return error.name + ". " + error.message; | |
} | |
return formatNonError(error); | |
}; | |
return null; | |
} | |
})(); | |
return CapturedTrace; | |
}; | |
},{"./assert.js":3,"./es5.js":13,"./util.js":40}],9:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(NEXT_FILTER) { | |
var util = require("./util.js"); | |
var tryCatch1 = util.tryCatch1; | |
var errorObj = util.errorObj; | |
var keys = require("./es5.js").keys; | |
function CatchFilter(instances, callback, promise) { | |
this._instances = instances; | |
this._callback = callback; | |
this._promise = promise; | |
} | |
function CatchFilter$_safePredicate(predicate, e) { | |
var safeObject = {}; | |
var retfilter = tryCatch1(predicate, safeObject, e); | |
if (retfilter === errorObj) return retfilter; | |
var safeKeys = keys(safeObject); | |
if (safeKeys.length) { | |
errorObj.e = new TypeError( | |
"Catch filter must inherit from Error " | |
+ "or be a simple predicate function"); | |
return errorObj; | |
} | |
return retfilter; | |
} | |
CatchFilter.prototype.doFilter = function CatchFilter$_doFilter(e) { | |
var cb = this._callback; | |
var promise = this._promise; | |
var boundTo = promise._isBound() ? promise._boundTo : void 0; | |
for (var i = 0, len = this._instances.length; i < len; ++i) { | |
var item = this._instances[i]; | |
var itemIsErrorType = item === Error || | |
(item != null && item.prototype instanceof Error); | |
if (itemIsErrorType && e instanceof item) { | |
var ret = tryCatch1(cb, boundTo, e); | |
if (ret === errorObj) { | |
NEXT_FILTER.e = ret.e; | |
return NEXT_FILTER; | |
} | |
return ret; | |
} else if (typeof item === "function" && !itemIsErrorType) { | |
var shouldHandle = CatchFilter$_safePredicate(item, e); | |
if (shouldHandle === errorObj) { | |
this._promise._attachExtraTrace(errorObj.e); | |
e = errorObj.e; | |
break; | |
} else if (shouldHandle) { | |
var ret = tryCatch1(cb, boundTo, e); | |
if (ret === errorObj) { | |
NEXT_FILTER.e = ret.e; | |
return NEXT_FILTER; | |
} | |
return ret; | |
} | |
} | |
} | |
NEXT_FILTER.e = e; | |
return NEXT_FILTER; | |
}; | |
return CatchFilter; | |
}; | |
},{"./es5.js":13,"./util.js":40}],10:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var util = require("./util.js"); | |
var ASSERT = require("./assert.js"); | |
var isPrimitive = util.isPrimitive; | |
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver; | |
module.exports = function(Promise) { | |
var returner = function Promise$_returner() { | |
return this; | |
}; | |
var thrower = function Promise$_thrower() { | |
throw this; | |
}; | |
var wrapper = function Promise$_wrapper(value, action) { | |
if (action === 1) { | |
return function Promise$_thrower() { | |
throw value; | |
}; | |
} | |
else if (action === 2) { | |
return function Promise$_returner() { | |
return value; | |
}; | |
} | |
}; | |
Promise.prototype["return"] = | |
Promise.prototype.thenReturn = | |
function Promise$thenReturn(value) { | |
if (wrapsPrimitiveReceiver && isPrimitive(value)) { | |
return this._then( | |
wrapper(value, 2), | |
void 0, | |
void 0, | |
void 0, | |
void 0, | |
this.thenReturn | |
); | |
} | |
return this._then(returner, void 0, void 0, | |
value, void 0, this.thenReturn); | |
}; | |
Promise.prototype["throw"] = | |
Promise.prototype.thenThrow = | |
function Promise$thenThrow(reason) { | |
if (wrapsPrimitiveReceiver && isPrimitive(reason)) { | |
return this._then( | |
wrapper(reason, 1), | |
void 0, | |
void 0, | |
void 0, | |
void 0, | |
this.thenThrow | |
); | |
} | |
return this._then(thrower, void 0, void 0, | |
reason, void 0, this.thenThrow); | |
}; | |
}; | |
},{"./assert.js":3,"./util.js":40}],11:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var global = require("./global.js"); | |
var Objectfreeze = require("./es5.js").freeze; | |
var util = require("./util.js"); | |
var inherits = util.inherits; | |
var isObject = util.isObject; | |
var notEnumerableProp = util.notEnumerableProp; | |
var Error = global.Error; | |
function isStackAttached(val) { | |
return (val & 1) > 0; | |
} | |
function isHandled(val) { | |
return (val & 2) > 0; | |
} | |
function withStackAttached(val) { | |
return (val | 1); | |
} | |
function withHandledMarked(val) { | |
return (val | 2); | |
} | |
function withHandledUnmarked(val) { | |
return (val & (~2)); | |
} | |
function ensureNotHandled(reason) { | |
var field; | |
if (isObject(reason) && | |
((field = reason["__promiseHandled__"]) !== void 0)) { | |
reason["__promiseHandled__"] = withHandledUnmarked(field); | |
} | |
return reason; | |
} | |
function markAsOriginatingFromRejection(e) { | |
try { | |
notEnumerableProp(e, "isAsync", true); | |
} | |
catch(ignore) {} | |
} | |
function originatesFromRejection(e) { | |
if (e == null) return false; | |
return ((e instanceof RejectionError) || | |
e["isAsync"] === true); | |
} | |
function attachDefaultState(obj) { | |
try { | |
notEnumerableProp(obj, "__promiseHandled__", 0); | |
return true; | |
} | |
catch(e) { | |
return false; | |
} | |
} | |
function isError(obj) { | |
return obj instanceof Error; | |
} | |
function canAttach(obj) { | |
if (isError(obj)) { | |
var handledState = obj["__promiseHandled__"]; | |
if (handledState === void 0) { | |
return attachDefaultState(obj); | |
} | |
return !isStackAttached(handledState); | |
} | |
return false; | |
} | |
function subError(nameProperty, defaultMessage) { | |
function SubError(message) { | |
if (!(this instanceof SubError)) return new SubError(message); | |
this.message = typeof message === "string" ? message : defaultMessage; | |
this.name = nameProperty; | |
if (Error.captureStackTrace) { | |
Error.captureStackTrace(this, this.constructor); | |
} | |
} | |
inherits(SubError, Error); | |
return SubError; | |
} | |
var TypeError = global.TypeError; | |
if (typeof TypeError !== "function") { | |
TypeError = subError("TypeError", "type error"); | |
} | |
var RangeError = global.RangeError; | |
if (typeof RangeError !== "function") { | |
RangeError = subError("RangeError", "range error"); | |
} | |
var CancellationError = subError("CancellationError", "cancellation error"); | |
var TimeoutError = subError("TimeoutError", "timeout error"); | |
function RejectionError(message) { | |
this.name = "RejectionError"; | |
this.message = message; | |
this.cause = message; | |
this.isAsync = true; | |
if (message instanceof Error) { | |
this.message = message.message; | |
this.stack = message.stack; | |
} | |
else if (Error.captureStackTrace) { | |
Error.captureStackTrace(this, this.constructor); | |
} | |
} | |
inherits(RejectionError, Error); | |
var key = "__BluebirdErrorTypes__"; | |
var errorTypes = global[key]; | |
if (!errorTypes) { | |
errorTypes = Objectfreeze({ | |
CancellationError: CancellationError, | |
TimeoutError: TimeoutError, | |
RejectionError: RejectionError | |
}); | |
notEnumerableProp(global, key, errorTypes); | |
} | |
module.exports = { | |
Error: Error, | |
TypeError: TypeError, | |
RangeError: RangeError, | |
CancellationError: errorTypes.CancellationError, | |
RejectionError: errorTypes.RejectionError, | |
TimeoutError: errorTypes.TimeoutError, | |
originatesFromRejection: originatesFromRejection, | |
markAsOriginatingFromRejection: markAsOriginatingFromRejection, | |
attachDefaultState: attachDefaultState, | |
ensureNotHandled: ensureNotHandled, | |
withHandledUnmarked: withHandledUnmarked, | |
withHandledMarked: withHandledMarked, | |
withStackAttached: withStackAttached, | |
isStackAttached: isStackAttached, | |
isHandled: isHandled, | |
canAttach: canAttach | |
}; | |
},{"./es5.js":13,"./global.js":17,"./util.js":40}],12:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise) { | |
var TypeError = require('./errors.js').TypeError; | |
function apiRejection(msg) { | |
var error = new TypeError(msg); | |
var ret = Promise.rejected(error); | |
var parent = ret._peekContext(); | |
if (parent != null) { | |
parent._attachExtraTrace(error); | |
} | |
return ret; | |
} | |
return apiRejection; | |
}; | |
},{"./errors.js":11}],13:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
var isES5 = (function(){ | |
"use strict"; | |
return this === void 0; | |
})(); | |
if (isES5) { | |
module.exports = { | |
freeze: Object.freeze, | |
defineProperty: Object.defineProperty, | |
keys: Object.keys, | |
getPrototypeOf: Object.getPrototypeOf, | |
isArray: Array.isArray, | |
isES5: isES5 | |
}; | |
} | |
else { | |
var has = {}.hasOwnProperty; | |
var str = {}.toString; | |
var proto = {}.constructor.prototype; | |
function ObjectKeys(o) { | |
var ret = []; | |
for (var key in o) { | |
if (has.call(o, key)) { | |
ret.push(key); | |
} | |
} | |
return ret; | |
} | |
function ObjectDefineProperty(o, key, desc) { | |
o[key] = desc.value; | |
return o; | |
} | |
function ObjectFreeze(obj) { | |
return obj; | |
} | |
function ObjectGetPrototypeOf(obj) { | |
try { | |
return Object(obj).constructor.prototype; | |
} | |
catch (e) { | |
return proto; | |
} | |
} | |
function ArrayIsArray(obj) { | |
try { | |
return str.call(obj) === "[object Array]"; | |
} | |
catch(e) { | |
return false; | |
} | |
} | |
module.exports = { | |
isArray: ArrayIsArray, | |
keys: ObjectKeys, | |
defineProperty: ObjectDefineProperty, | |
freeze: ObjectFreeze, | |
getPrototypeOf: ObjectGetPrototypeOf, | |
isES5: isES5 | |
}; | |
} | |
},{}],14:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise) { | |
var ASSERT = require("./assert.js"); | |
var isArray = require("./util.js").isArray; | |
function Promise$_filter(booleans) { | |
var values = this._settledValue; | |
var len = values.length; | |
var ret = new Array(len); | |
var j = 0; | |
for (var i = 0; i < len; ++i) { | |
if (booleans[i]) ret[j++] = values[i]; | |
} | |
ret.length = j; | |
return ret; | |
} | |
var ref = {ref: null}; | |
Promise.filter = function Promise$Filter(promises, fn) { | |
return Promise.map(promises, fn, ref) | |
._then(Promise$_filter, void 0, void 0, | |
ref.ref, void 0, Promise.filter); | |
}; | |
Promise.prototype.filter = function Promise$filter(fn) { | |
return this.map(fn, ref) | |
._then(Promise$_filter, void 0, void 0, | |
ref.ref, void 0, this.filter); | |
}; | |
}; | |
},{"./assert.js":3,"./util.js":40}],15:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
module.exports = function(Promise, NEXT_FILTER) { | |
var util = require("./util.js"); | |
var ensureNotHandled = require("./errors.js").ensureNotHandled; | |
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver; | |
var isPrimitive = util.isPrimitive; | |
var thrower = util.thrower; | |
function returnThis() { | |
return this; | |
} | |
function throwThis() { | |
ensureNotHandled(this); | |
throw this; | |
} | |
function makeReturner(r) { | |
return function Promise$_returner() { | |
return r; | |
}; | |
} | |
function makeThrower(r) { | |
return function Promise$_thrower() { | |
ensureNotHandled(r); | |
throw r; | |
}; | |
} | |
function promisedFinally(ret, reasonOrValue, isFulfilled) { | |
var useConstantFunction = | |
wrapsPrimitiveReceiver && isPrimitive(reasonOrValue); | |
if (isFulfilled) { | |
return ret._then( | |
useConstantFunction | |
? returnThis | |
: makeReturner(reasonOrValue), | |
thrower, void 0, reasonOrValue, void 0, promisedFinally); | |
} | |
else { | |
return ret._then( | |
useConstantFunction | |
? throwThis | |
: makeThrower(reasonOrValue), | |
thrower, void 0, reasonOrValue, void 0, promisedFinally); | |
} | |
} | |
function finallyHandler(reasonOrValue) { | |
var promise = this.promise; | |
var handler = this.handler; | |
var ret = promise._isBound() | |
? handler.call(promise._boundTo) | |
: handler(); | |
if (ret !== void 0) { | |
var maybePromise = Promise._cast(ret, finallyHandler, void 0); | |
if (Promise.is(maybePromise)) { | |
return promisedFinally(maybePromise, reasonOrValue, | |
promise.isFulfilled()); | |
} | |
} | |
if (promise.isRejected()) { | |
ensureNotHandled(reasonOrValue); | |
NEXT_FILTER.e = reasonOrValue; | |
return NEXT_FILTER; | |
} | |
else { | |
return reasonOrValue; | |
} | |
} | |
Promise.prototype.lastly = Promise.prototype["finally"] = | |
function Promise$finally(handler) { | |
if (typeof handler !== "function") return this.then(); | |
var promiseAndHandler = { | |
promise: this, | |
handler: handler | |
}; | |
return this._then(finallyHandler, finallyHandler, void 0, | |
promiseAndHandler, void 0, this.lastly); | |
}; | |
}; | |
},{"./errors.js":11,"./util.js":40}],16:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, apiRejection, INTERNAL) { | |
var PromiseSpawn = require("./promise_spawn.js")(Promise, INTERNAL); | |
var errors = require("./errors.js"); | |
var TypeError = errors.TypeError; | |
Promise.coroutine = function Promise$Coroutine(generatorFunction) { | |
if (typeof generatorFunction !== "function") { | |
throw new TypeError("generatorFunction must be a function"); | |
} | |
var PromiseSpawn$ = PromiseSpawn; | |
return function anonymous() { | |
var generator = generatorFunction.apply(this, arguments); | |
var spawn = new PromiseSpawn$(void 0, void 0, anonymous); | |
spawn._generator = generator; | |
spawn._next(void 0); | |
return spawn.promise(); | |
}; | |
}; | |
Promise.spawn = function Promise$Spawn(generatorFunction) { | |
if (typeof generatorFunction !== "function") { | |
return apiRejection("generatorFunction must be a function"); | |
} | |
var spawn = new PromiseSpawn(generatorFunction, this, Promise.spawn); | |
var ret = spawn.promise(); | |
spawn._run(Promise.spawn); | |
return ret; | |
}; | |
}; | |
},{"./errors.js":11,"./promise_spawn.js":25}],17:[function(require,module,exports){ | |
(function (process,global){/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = (function(){ | |
if (typeof this !== "undefined") { | |
return this; | |
} | |
if (typeof process !== "undefined" && | |
typeof global !== "undefined" && | |
typeof process.execPath === "string") { | |
return global; | |
} | |
if (typeof window !== "undefined" && | |
typeof document !== "undefined" && | |
typeof navigator !== "undefined" && navigator !== null && | |
typeof navigator.appName === "string") { | |
if(window.wrappedJSObject !== undefined){ | |
return window.wrappedJSObject; | |
} | |
return window; | |
} | |
})(); | |
}).call(this,require("/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
},{"/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":41}],18:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function( | |
Promise, Promise$_CreatePromiseArray, PromiseArray, apiRejection) { | |
var ASSERT = require("./assert.js"); | |
function Promise$_mapper(values) { | |
var fn = this; | |
var receiver = void 0; | |
if (typeof fn !== "function") { | |
receiver = fn.receiver; | |
fn = fn.fn; | |
} | |
var shouldDefer = false; | |
var ret = new Array(values.length); | |
if (receiver === void 0) { | |
for (var i = 0, len = values.length; i < len; ++i) { | |
var value = fn(values[i], i, len); | |
if (!shouldDefer) { | |
var maybePromise = Promise._cast(value, | |
Promise$_mapper, void 0); | |
if (maybePromise instanceof Promise) { | |
if (maybePromise.isFulfilled()) { | |
ret[i] = maybePromise._settledValue; | |
continue; | |
} | |
else { | |
shouldDefer = true; | |
} | |
value = maybePromise; | |
} | |
} | |
ret[i] = value; | |
} | |
} | |
else { | |
for (var i = 0, len = values.length; i < len; ++i) { | |
var value = fn.call(receiver, values[i], i, len); | |
if (!shouldDefer) { | |
var maybePromise = Promise._cast(value, | |
Promise$_mapper, void 0); | |
if (maybePromise instanceof Promise) { | |
if (maybePromise.isFulfilled()) { | |
ret[i] = maybePromise._settledValue; | |
continue; | |
} | |
else { | |
shouldDefer = true; | |
} | |
value = maybePromise; | |
} | |
} | |
ret[i] = value; | |
} | |
} | |
return shouldDefer | |
? Promise$_CreatePromiseArray(ret, PromiseArray, | |
Promise$_mapper, void 0).promise() | |
: ret; | |
} | |
function Promise$_Map(promises, fn, useBound, caller, ref) { | |
if (typeof fn !== "function") { | |
return apiRejection("fn must be a function"); | |
} | |
if (useBound === true && promises._isBound()) { | |
fn = { | |
fn: fn, | |
receiver: promises._boundTo | |
}; | |
} | |
var ret = Promise$_CreatePromiseArray( | |
promises, | |
PromiseArray, | |
caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0 | |
).promise(); | |
if (ref !== void 0) { | |
ref.ref = ret; | |
} | |
return ret._then( | |
Promise$_mapper, | |
void 0, | |
void 0, | |
fn, | |
void 0, | |
caller | |
); | |
} | |
Promise.prototype.map = function Promise$map(fn, ref) { | |
return Promise$_Map(this, fn, true, this.map, ref); | |
}; | |
Promise.map = function Promise$Map(promises, fn, ref) { | |
return Promise$_Map(promises, fn, false, Promise.map, ref); | |
}; | |
}; | |
},{"./assert.js":3}],19:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise) { | |
var util = require("./util.js"); | |
var async = require("./async.js"); | |
var ASSERT = require("./assert.js"); | |
var tryCatch2 = util.tryCatch2; | |
var tryCatch1 = util.tryCatch1; | |
var errorObj = util.errorObj; | |
function thrower(r) { | |
throw r; | |
} | |
function Promise$_successAdapter(val, receiver) { | |
var nodeback = this; | |
var ret = tryCatch2(nodeback, receiver, null, val); | |
if (ret === errorObj) { | |
async.invokeLater(thrower, void 0, ret.e); | |
} | |
} | |
function Promise$_errorAdapter(reason, receiver) { | |
var nodeback = this; | |
var ret = tryCatch1(nodeback, receiver, reason); | |
if (ret === errorObj) { | |
async.invokeLater(thrower, void 0, ret.e); | |
} | |
} | |
Promise.prototype.nodeify = function Promise$nodeify(nodeback) { | |
if (typeof nodeback == "function") { | |
this._then( | |
Promise$_successAdapter, | |
Promise$_errorAdapter, | |
void 0, | |
nodeback, | |
this._isBound() ? this._boundTo : null, | |
this.nodeify | |
); | |
} | |
return this; | |
}; | |
}; | |
},{"./assert.js":3,"./async.js":4,"./util.js":40}],20:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, isPromiseArrayProxy) { | |
var ASSERT = require("./assert.js"); | |
var util = require("./util.js"); | |
var async = require("./async.js"); | |
var tryCatch1 = util.tryCatch1; | |
var errorObj = util.errorObj; | |
Promise.prototype.progressed = function Promise$progressed(handler) { | |
return this._then(void 0, void 0, handler, | |
void 0, void 0, this.progressed); | |
}; | |
Promise.prototype._progress = function Promise$_progress(progressValue) { | |
if (this._isFollowingOrFulfilledOrRejected()) return; | |
this._progressUnchecked(progressValue); | |
}; | |
Promise.prototype._progressHandlerAt = | |
function Promise$_progressHandlerAt(index) { | |
if (index === 0) return this._progressHandler0; | |
return this[index + 2 - 5]; | |
}; | |
Promise.prototype._doProgressWith = | |
function Promise$_doProgressWith(progression) { | |
var progressValue = progression.value; | |
var handler = progression.handler; | |
var promise = progression.promise; | |
var receiver = progression.receiver; | |
this._pushContext(); | |
var ret = tryCatch1(handler, receiver, progressValue); | |
this._popContext(); | |
if (ret === errorObj) { | |
if (ret.e != null && | |
ret.e.name === "StopProgressPropagation") { | |
ret.e["__promiseHandled__"] = 2; | |
} | |
else { | |
promise._attachExtraTrace(ret.e); | |
promise._progress(ret.e); | |
} | |
} | |
else if (Promise.is(ret)) { | |
ret._then(promise._progress, null, null, promise, void 0, | |
this._progress); | |
} | |
else { | |
promise._progress(ret); | |
} | |
}; | |
Promise.prototype._progressUnchecked = | |
function Promise$_progressUnchecked(progressValue) { | |
if (!this.isPending()) return; | |
var len = this._length(); | |
for (var i = 0; i < len; i += 5) { | |
var handler = this._progressHandlerAt(i); | |
var promise = this._promiseAt(i); | |
if (!Promise.is(promise)) { | |
var receiver = this._receiverAt(i); | |
if (typeof handler === "function") { | |
handler.call(receiver, progressValue, promise); | |
} | |
else if (Promise.is(receiver) && receiver._isProxied()) { | |
receiver._progressUnchecked(progressValue); | |
} | |
else if (isPromiseArrayProxy(receiver, promise)) { | |
receiver._promiseProgressed(progressValue, promise); | |
} | |
continue; | |
} | |
if (typeof handler === "function") { | |
async.invoke(this._doProgressWith, this, { | |
handler: handler, | |
promise: promise, | |
receiver: this._receiverAt(i), | |
value: progressValue | |
}); | |
} | |
else { | |
async.invoke(promise._progress, promise, progressValue); | |
} | |
} | |
}; | |
}; | |
},{"./assert.js":3,"./async.js":4,"./util.js":40}],21:[function(require,module,exports){ | |
(function (process){/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function() { | |
var global = require("./global.js"); | |
var ASSERT = require("./assert.js"); | |
var util = require("./util.js"); | |
var async = require("./async.js"); | |
var errors = require("./errors.js"); | |
var INTERNAL = function(){}; | |
var APPLY = {}; | |
var NEXT_FILTER = {e: null}; | |
var PromiseArray = require("./promise_array.js")(Promise, INTERNAL); | |
var CapturedTrace = require("./captured_trace.js")(); | |
var CatchFilter = require("./catch_filter.js")(NEXT_FILTER); | |
var PromiseResolver = require("./promise_resolver.js"); | |
var isArray = util.isArray; | |
var notEnumerableProp = util.notEnumerableProp; | |
var isObject = util.isObject; | |
var ensurePropertyExpansion = util.ensurePropertyExpansion; | |
var errorObj = util.errorObj; | |
var tryCatch1 = util.tryCatch1; | |
var tryCatch2 = util.tryCatch2; | |
var tryCatchApply = util.tryCatchApply; | |
var RangeError = errors.RangeError; | |
var TypeError = errors.TypeError; | |
var CancellationError = errors.CancellationError; | |
var TimeoutError = errors.TimeoutError; | |
var RejectionError = errors.RejectionError; | |
var originatesFromRejection = errors.originatesFromRejection; | |
var markAsOriginatingFromRejection = errors.markAsOriginatingFromRejection; | |
var ensureNotHandled = errors.ensureNotHandled; | |
var withHandledMarked = errors.withHandledMarked; | |
var withStackAttached = errors.withStackAttached; | |
var isStackAttached = errors.isStackAttached; | |
var isHandled = errors.isHandled; | |
var canAttach = errors.canAttach; | |
var thrower = util.thrower; | |
var apiRejection = require("./errors_api_rejection")(Promise); | |
var makeSelfResolutionError = function Promise$_makeSelfResolutionError() { | |
return new TypeError("circular promise resolution chain"); | |
}; | |
function isPromise(obj) { | |
if (obj === void 0) return false; | |
return obj instanceof Promise; | |
} | |
function isPromiseArrayProxy(receiver, promiseSlotValue) { | |
if (receiver instanceof PromiseArray) { | |
return promiseSlotValue >= 0; | |
} | |
return false; | |
} | |
function Promise(resolver) { | |
if (typeof resolver !== "function") { | |
throw new TypeError("the promise constructor requires a resolver function"); | |
} | |
if (this.constructor !== Promise) { | |
throw new TypeError("the promise constructor cannot be invoked directly"); | |
} | |
this._bitField = 0; | |
this._fulfillmentHandler0 = void 0; | |
this._rejectionHandler0 = void 0; | |
this._promise0 = void 0; | |
this._receiver0 = void 0; | |
this._settledValue = void 0; | |
this._boundTo = void 0; | |
if (resolver !== INTERNAL) this._resolveFromResolver(resolver); | |
} | |
Promise.prototype.bind = function Promise$bind(thisArg) { | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(this.bind, this); | |
ret._follow(this); | |
ret._setBoundTo(thisArg); | |
if (this._cancellable()) { | |
ret._setCancellable(); | |
ret._cancellationParent = this; | |
} | |
return ret; | |
}; | |
Promise.prototype.toString = function Promise$toString() { | |
return "[object Promise]"; | |
}; | |
Promise.prototype.caught = Promise.prototype["catch"] = | |
function Promise$catch(fn) { | |
var len = arguments.length; | |
if (len > 1) { | |
var catchInstances = new Array(len - 1), | |
j = 0, i; | |
for (i = 0; i < len - 1; ++i) { | |
var item = arguments[i]; | |
if (typeof item === "function") { | |
catchInstances[j++] = item; | |
} | |
else { | |
var catchFilterTypeError = | |
new TypeError( | |
"A catch filter must be an error constructor " | |
+ "or a filter function"); | |
this._attachExtraTrace(catchFilterTypeError); | |
async.invoke(this._reject, this, catchFilterTypeError); | |
return; | |
} | |
} | |
catchInstances.length = j; | |
fn = arguments[i]; | |
this._resetTrace(this.caught); | |
var catchFilter = new CatchFilter(catchInstances, fn, this); | |
return this._then(void 0, catchFilter.doFilter, void 0, | |
catchFilter, void 0, this.caught); | |
} | |
return this._then(void 0, fn, void 0, void 0, void 0, this.caught); | |
}; | |
Promise.prototype.then = | |
function Promise$then(didFulfill, didReject, didProgress) { | |
return this._then(didFulfill, didReject, didProgress, | |
void 0, void 0, this.then); | |
}; | |
Promise.prototype.done = | |
function Promise$done(didFulfill, didReject, didProgress) { | |
var promise = this._then(didFulfill, didReject, didProgress, | |
void 0, void 0, this.done); | |
promise._setIsFinal(); | |
}; | |
Promise.prototype.spread = function Promise$spread(didFulfill, didReject) { | |
return this._then(didFulfill, didReject, void 0, | |
APPLY, void 0, this.spread); | |
}; | |
Promise.prototype.isFulfilled = function Promise$isFulfilled() { | |
return (this._bitField & 268435456) > 0; | |
}; | |
Promise.prototype.isRejected = function Promise$isRejected() { | |
return (this._bitField & 134217728) > 0; | |
}; | |
Promise.prototype.isPending = function Promise$isPending() { | |
return !this.isResolved(); | |
}; | |
Promise.prototype.isResolved = function Promise$isResolved() { | |
return (this._bitField & 402653184) > 0; | |
}; | |
Promise.prototype.isCancellable = function Promise$isCancellable() { | |
return !this.isResolved() && | |
this._cancellable(); | |
}; | |
Promise.prototype.toJSON = function Promise$toJSON() { | |
var ret = { | |
isFulfilled: false, | |
isRejected: false, | |
fulfillmentValue: void 0, | |
rejectionReason: void 0 | |
}; | |
if (this.isFulfilled()) { | |
ret.fulfillmentValue = this._settledValue; | |
ret.isFulfilled = true; | |
} | |
else if (this.isRejected()) { | |
ret.rejectionReason = this._settledValue; | |
ret.isRejected = true; | |
} | |
return ret; | |
}; | |
Promise.prototype.all = function Promise$all() { | |
return Promise$_all(this, true, this.all); | |
}; | |
Promise.is = isPromise; | |
function Promise$_all(promises, useBound, caller) { | |
return Promise$_CreatePromiseArray( | |
promises, | |
PromiseArray, | |
caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0 | |
).promise(); | |
} | |
Promise.all = function Promise$All(promises) { | |
return Promise$_all(promises, false, Promise.all); | |
}; | |
Promise.join = function Promise$Join() { | |
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];} | |
return Promise$_CreatePromiseArray( | |
args, PromiseArray, Promise.join, void 0).promise(); | |
}; | |
Promise.resolve = Promise.fulfilled = | |
function Promise$Resolve(value, caller) { | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(typeof caller === "function" | |
? caller | |
: Promise.resolve, void 0); | |
if (ret._tryFollow(value)) { | |
return ret; | |
} | |
ret._cleanValues(); | |
ret._setFulfilled(); | |
ret._settledValue = value; | |
return ret; | |
}; | |
Promise.reject = Promise.rejected = function Promise$Reject(reason) { | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(Promise.reject, void 0); | |
markAsOriginatingFromRejection(reason); | |
ret._cleanValues(); | |
ret._setRejected(); | |
ret._settledValue = reason; | |
return ret; | |
}; | |
Promise.prototype.error = function Promise$_error(fn) { | |
return this.caught(originatesFromRejection, fn); | |
}; | |
Promise.prototype._resolveFromSyncValue = | |
function Promise$_resolveFromSyncValue(value, caller) { | |
if (value === errorObj) { | |
this._cleanValues(); | |
this._setRejected(); | |
this._settledValue = value.e; | |
} | |
else { | |
var maybePromise = Promise._cast(value, caller, void 0); | |
if (maybePromise instanceof Promise) { | |
this._follow(maybePromise); | |
} | |
else { | |
this._cleanValues(); | |
this._setFulfilled(); | |
this._settledValue = value; | |
} | |
} | |
}; | |
Promise.method = function Promise$_Method(fn) { | |
if (typeof fn !== "function") { | |
throw new TypeError("fn must be a function"); | |
} | |
return function Promise$_method() { | |
var value; | |
switch(arguments.length) { | |
case 0: value = tryCatch1(fn, this, void 0); break; | |
case 1: value = tryCatch1(fn, this, arguments[0]); break; | |
case 2: value = tryCatch2(fn, this, arguments[0], arguments[1]); break; | |
default: | |
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];} | |
value = tryCatchApply(fn, args, this); break; | |
} | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(Promise$_method, void 0); | |
ret._resolveFromSyncValue(value, Promise$_method); | |
return ret; | |
}; | |
}; | |
Promise.attempt = Promise["try"] = function Promise$_Try(fn, args, ctx) { | |
if (typeof fn !== "function") { | |
return apiRejection("fn must be a function"); | |
} | |
var value = isArray(args) | |
? tryCatchApply(fn, args, ctx) | |
: tryCatch1(fn, ctx, args); | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(Promise.attempt, void 0); | |
ret._resolveFromSyncValue(value, Promise.attempt); | |
return ret; | |
}; | |
Promise.defer = Promise.pending = function Promise$Defer(caller) { | |
var promise = new Promise(INTERNAL); | |
if (debugging) promise._setTrace(typeof caller === "function" | |
? caller : Promise.defer, void 0); | |
return new PromiseResolver(promise); | |
}; | |
Promise.bind = function Promise$Bind(thisArg) { | |
var ret = new Promise(INTERNAL); | |
if (debugging) ret._setTrace(Promise.bind, void 0); | |
ret._setFulfilled(); | |
ret._setBoundTo(thisArg); | |
return ret; | |
}; | |
Promise.cast = function Promise$_Cast(obj, caller) { | |
if (typeof caller !== "function") { | |
caller = Promise.cast; | |
} | |
var ret = Promise._cast(obj, caller, void 0); | |
if (!(ret instanceof Promise)) { | |
return Promise.resolve(ret, caller); | |
} | |
return ret; | |
}; | |
Promise.onPossiblyUnhandledRejection = | |
function Promise$OnPossiblyUnhandledRejection(fn) { | |
if (typeof fn === "function") { | |
CapturedTrace.possiblyUnhandledRejection = fn; | |
} | |
else { | |
CapturedTrace.possiblyUnhandledRejection = void 0; | |
} | |
}; | |
var debugging = false || !!( | |
typeof process !== "undefined" && | |
typeof process.execPath === "string" && | |
typeof process.env === "object" && | |
(process.env["BLUEBIRD_DEBUG"] || | |
process.env["NODE_ENV"] === "development") | |
); | |
Promise.longStackTraces = function Promise$LongStackTraces() { | |
if (async.haveItemsQueued() && | |
debugging === false | |
) { | |
throw new Error("cannot enable long stack traces after promises have been created"); | |
} | |
debugging = CapturedTrace.isSupported(); | |
}; | |
Promise.hasLongStackTraces = function Promise$HasLongStackTraces() { | |
return debugging && CapturedTrace.isSupported(); | |
}; | |
Promise.prototype._setProxyHandlers = | |
function Promise$_setProxyHandlers(receiver, promiseSlotValue) { | |
var index = this._length(); | |
if (index >= 4194303 - 5) { | |
index = 0; | |
this._setLength(0); | |
} | |
if (index === 0) { | |
this._promise0 = promiseSlotValue; | |
this._receiver0 = receiver; | |
} | |
else { | |
var i = index - 5; | |
this[i + 3] = promiseSlotValue; | |
this[i + 4] = receiver; | |
this[i + 0] = | |
this[i + 1] = | |
this[i + 2] = void 0; | |
} | |
this._setLength(index + 5); | |
}; | |
Promise.prototype._proxyPromiseArray = | |
function Promise$_proxyPromiseArray(promiseArray, index) { | |
this._setProxyHandlers(promiseArray, index); | |
}; | |
Promise.prototype._proxyPromise = function Promise$_proxyPromise(promise) { | |
promise._setProxied(); | |
this._setProxyHandlers(promise, -1); | |
}; | |
Promise.prototype._then = | |
function Promise$_then( | |
didFulfill, | |
didReject, | |
didProgress, | |
receiver, | |
internalData, | |
caller | |
) { | |
var haveInternalData = internalData !== void 0; | |
var ret = haveInternalData ? internalData : new Promise(INTERNAL); | |
if (debugging && !haveInternalData) { | |
var haveSameContext = this._peekContext() === this._traceParent; | |
ret._traceParent = haveSameContext ? this._traceParent : this; | |
ret._setTrace(typeof caller === "function" | |
? caller | |
: this._then, this); | |
} | |
if (!haveInternalData && this._isBound()) { | |
ret._setBoundTo(this._boundTo); | |
} | |
var callbackIndex = | |
this._addCallbacks(didFulfill, didReject, didProgress, ret, receiver); | |
if (!haveInternalData && this._cancellable()) { | |
ret._setCancellable(); | |
ret._cancellationParent = this; | |
} | |
if (this.isResolved()) { | |
async.invoke(this._queueSettleAt, this, callbackIndex); | |
} | |
return ret; | |
}; | |
Promise.prototype._length = function Promise$_length() { | |
return this._bitField & 4194303; | |
}; | |
Promise.prototype._isFollowingOrFulfilledOrRejected = | |
function Promise$_isFollowingOrFulfilledOrRejected() { | |
return (this._bitField & 939524096) > 0; | |
}; | |
Promise.prototype._isFollowing = function Promise$_isFollowing() { | |
return (this._bitField & 536870912) === 536870912; | |
}; | |
Promise.prototype._setLength = function Promise$_setLength(len) { | |
this._bitField = (this._bitField & -4194304) | | |
(len & 4194303); | |
}; | |
Promise.prototype._cancellable = function Promise$_cancellable() { | |
return (this._bitField & 67108864) > 0; | |
}; | |
Promise.prototype._setFulfilled = function Promise$_setFulfilled() { | |
this._bitField = this._bitField | 268435456; | |
}; | |
Promise.prototype._setRejected = function Promise$_setRejected() { | |
this._bitField = this._bitField | 134217728; | |
}; | |
Promise.prototype._setFollowing = function Promise$_setFollowing() { | |
this._bitField = this._bitField | 536870912; | |
}; | |
Promise.prototype._setIsFinal = function Promise$_setIsFinal() { | |
this._bitField = this._bitField | 33554432; | |
}; | |
Promise.prototype._isFinal = function Promise$_isFinal() { | |
return (this._bitField & 33554432) > 0; | |
}; | |
Promise.prototype._setCancellable = function Promise$_setCancellable() { | |
this._bitField = this._bitField | 67108864; | |
}; | |
Promise.prototype._unsetCancellable = function Promise$_unsetCancellable() { | |
this._bitField = this._bitField & (~67108864); | |
}; | |
Promise.prototype._receiverAt = function Promise$_receiverAt(index) { | |
var ret; | |
if (index === 0) { | |
ret = this._receiver0; | |
} | |
else { | |
ret = this[index + 4 - 5]; | |
} | |
if (this._isBound() && ret === void 0) { | |
return this._boundTo; | |
} | |
return ret; | |
}; | |
Promise.prototype._promiseAt = function Promise$_promiseAt(index) { | |
if (index === 0) return this._promise0; | |
return this[index + 3 - 5]; | |
}; | |
Promise.prototype._fulfillmentHandlerAt = | |
function Promise$_fulfillmentHandlerAt(index) { | |
if (index === 0) return this._fulfillmentHandler0; | |
return this[index + 0 - 5]; | |
}; | |
Promise.prototype._rejectionHandlerAt = | |
function Promise$_rejectionHandlerAt(index) { | |
if (index === 0) return this._rejectionHandler0; | |
return this[index + 1 - 5]; | |
}; | |
Promise.prototype._unsetAt = function Promise$_unsetAt(index) { | |
if (index === 0) { | |
this._fulfillmentHandler0 = | |
this._rejectionHandler0 = | |
this._progressHandler0 = | |
this._promise0 = | |
this._receiver0 = void 0; | |
} | |
else { | |
this[index - 5 + 0] = | |
this[index - 5 + 1] = | |
this[index - 5 + 2] = | |
this[index - 5 + 3] = | |
this[index - 5 + 4] = void 0; | |
} | |
}; | |
Promise.prototype._resolveFromResolver = | |
function Promise$_resolveFromResolver(resolver) { | |
var promise = this; | |
var localDebugging = debugging; | |
if (localDebugging) { | |
this._setTrace(this._resolveFromResolver, void 0); | |
this._pushContext(); | |
} | |
function Promise$_resolver(val) { | |
if (promise._tryFollow(val)) { | |
return; | |
} | |
promise._fulfill(val); | |
} | |
function Promise$_rejecter(val) { | |
promise._attachExtraTrace(val); | |
markAsOriginatingFromRejection(val); | |
promise._reject(val); | |
} | |
var r = tryCatch2(resolver, void 0, Promise$_resolver, Promise$_rejecter); | |
if (localDebugging) this._popContext(); | |
if (r !== void 0 && r === errorObj) { | |
promise._reject(r.e); | |
} | |
}; | |
Promise.prototype._addCallbacks = function Promise$_addCallbacks( | |
fulfill, | |
reject, | |
progress, | |
promise, | |
receiver | |
) { | |
var index = this._length(); | |
if (index >= 4194303 - 5) { | |
index = 0; | |
this._setLength(0); | |
} | |
if (index === 0) { | |
this._promise0 = promise; | |
if (receiver !== void 0) this._receiver0 = receiver; | |
if (typeof fulfill === "function") this._fulfillmentHandler0 = fulfill; | |
if (typeof reject === "function") this._rejectionHandler0 = reject; | |
if (typeof progress === "function") this._progressHandler0 = progress; | |
} | |
else { | |
var i = index - 5; | |
this[i + 3] = promise; | |
this[i + 4] = receiver; | |
this[i + 0] = typeof fulfill === "function" | |
? fulfill : void 0; | |
this[i + 1] = typeof reject === "function" | |
? reject : void 0; | |
this[i + 2] = typeof progress === "function" | |
? progress : void 0; | |
} | |
this._setLength(index + 5); | |
return index; | |
}; | |
Promise.prototype._setBoundTo = function Promise$_setBoundTo(obj) { | |
if (obj !== void 0) { | |
this._bitField = this._bitField | 8388608; | |
this._boundTo = obj; | |
} | |
else { | |
this._bitField = this._bitField & (~8388608); | |
} | |
}; | |
Promise.prototype._isBound = function Promise$_isBound() { | |
return (this._bitField & 8388608) === 8388608; | |
}; | |
Promise.prototype._spreadSlowCase = | |
function Promise$_spreadSlowCase(targetFn, promise, values, boundTo) { | |
var promiseForAll = | |
Promise$_CreatePromiseArray | |
(values, PromiseArray, this._spreadSlowCase, boundTo) | |
.promise() | |
._then(function() { | |
return targetFn.apply(boundTo, arguments); | |
}, void 0, void 0, APPLY, void 0, this._spreadSlowCase); | |
promise._follow(promiseForAll); | |
}; | |
Promise.prototype._markHandled = function Promise$_markHandled(value) { | |
if( typeof value === "object" && | |
value !== null) { | |
var handledState = value["__promiseHandled__"]; | |
if (handledState === void 0) { | |
notEnumerableProp(value, "__promiseHandled__", 2); | |
} | |
else { | |
value["__promiseHandled__"] = | |
withHandledMarked(handledState); | |
} | |
} | |
}; | |
Promise.prototype._callSpread = | |
function Promise$_callSpread(handler, promise, value, localDebugging) { | |
var boundTo = this._isBound() ? this._boundTo : void 0; | |
if (isArray(value)) { | |
var caller = this._settlePromiseFromHandler; | |
for (var i = 0, len = value.length; i < len; ++i) { | |
if (isPromise(Promise._cast(value[i], caller, void 0))) { | |
this._spreadSlowCase(handler, promise, value, boundTo); | |
return; | |
} | |
} | |
} | |
if (localDebugging) promise._pushContext(); | |
return tryCatchApply(handler, value, boundTo); | |
}; | |
Promise.prototype._callHandler = | |
function Promise$_callHandler( | |
handler, receiver, promise, value, localDebugging) { | |
var x; | |
if (receiver === APPLY && !this.isRejected()) { | |
x = this._callSpread(handler, promise, value, localDebugging); | |
} | |
else { | |
if (localDebugging) promise._pushContext(); | |
x = tryCatch1(handler, receiver, value); | |
} | |
if (localDebugging) promise._popContext(); | |
return x; | |
}; | |
Promise.prototype._settlePromiseFromHandler = | |
function Promise$_settlePromiseFromHandler( | |
handler, receiver, value, promise | |
) { | |
if (!isPromise(promise)) { | |
handler.call(receiver, value, promise); | |
return; | |
} | |
if (this.isRejected()) this._markHandled(value); | |
var localDebugging = debugging; | |
var x = this._callHandler(handler, receiver, | |
promise, value, localDebugging); | |
if (promise._isFollowing()) return; | |
if (x === errorObj || x === promise || x === NEXT_FILTER) { | |
var err = x === promise | |
? makeSelfResolutionError() | |
: ensureNotHandled(x.e); | |
if (x !== NEXT_FILTER) promise._attachExtraTrace(err); | |
promise._rejectUnchecked(err); | |
} | |
else { | |
var castValue = Promise._cast(x, | |
localDebugging ? this._settlePromiseFromHandler : void 0, | |
promise); | |
if (isPromise(castValue)) { | |
promise._follow(castValue); | |
if (castValue._cancellable()) { | |
promise._cancellationParent = castValue; | |
promise._setCancellable(); | |
} | |
} | |
else { | |
promise._fulfillUnchecked(x); | |
} | |
} | |
}; | |
Promise.prototype._follow = | |
function Promise$_follow(promise) { | |
this._setFollowing(); | |
if (promise.isPending()) { | |
if (promise._cancellable() ) { | |
this._cancellationParent = promise; | |
this._setCancellable(); | |
} | |
promise._proxyPromise(this); | |
} | |
else if (promise.isFulfilled()) { | |
this._fulfillUnchecked(promise._settledValue); | |
} | |
else { | |
this._rejectUnchecked(promise._settledValue); | |
} | |
if (debugging && | |
promise._traceParent == null) { | |
promise._traceParent = this; | |
} | |
}; | |
Promise.prototype._tryFollow = | |
function Promise$_tryFollow(value) { | |
if (this._isFollowingOrFulfilledOrRejected() || | |
value === this) { | |
return false; | |
} | |
var maybePromise = Promise._cast(value, this._tryFollow, void 0); | |
if (!isPromise(maybePromise)) { | |
return false; | |
} | |
this._follow(maybePromise); | |
return true; | |
}; | |
Promise.prototype._resetTrace = function Promise$_resetTrace(caller) { | |
if (debugging) { | |
var context = this._peekContext(); | |
var isTopLevel = context === void 0; | |
this._trace = new CapturedTrace( | |
typeof caller === "function" | |
? caller | |
: this._resetTrace, | |
isTopLevel | |
); | |
} | |
}; | |
Promise.prototype._setTrace = function Promise$_setTrace(caller, parent) { | |
if (debugging) { | |
var context = this._peekContext(); | |
this._traceParent = context; | |
var isTopLevel = context === void 0; | |
if (parent !== void 0 && | |
parent._traceParent === context) { | |
this._trace = parent._trace; | |
} | |
else { | |
this._trace = new CapturedTrace( | |
typeof caller === "function" | |
? caller | |
: this._setTrace, | |
isTopLevel | |
); | |
} | |
} | |
return this; | |
}; | |
Promise.prototype._attachExtraTrace = | |
function Promise$_attachExtraTrace(error) { | |
if (debugging && | |
canAttach(error)) { | |
var promise = this; | |
var stack = error.stack; | |
stack = typeof stack === "string" | |
? stack.split("\n") : []; | |
var headerLineCount = 1; | |
while(promise != null && | |
promise._trace != null) { | |
stack = CapturedTrace.combine( | |
stack, | |
promise._trace.stack.split("\n") | |
); | |
promise = promise._traceParent; | |
} | |
var max = Error.stackTraceLimit + headerLineCount; | |
var len = stack.length; | |
if (len > max) { | |
stack.length = max; | |
} | |
if (stack.length <= headerLineCount) { | |
error.stack = "(No stack trace)"; | |
} | |
else { | |
error.stack = stack.join("\n"); | |
} | |
error["__promiseHandled__"] = | |
withStackAttached(error["__promiseHandled__"]); | |
} | |
}; | |
Promise.prototype._notifyUnhandledRejection = | |
function Promise$_notifyUnhandledRejection(reason) { | |
if (!isHandled(reason["__promiseHandled__"])) { | |
reason["__promiseHandled__"] = | |
withHandledMarked(reason["__promiseHandled__"]); | |
CapturedTrace.possiblyUnhandledRejection(reason, this); | |
} | |
}; | |
Promise.prototype._unhandledRejection = | |
function Promise$_unhandledRejection(reason) { | |
if (!isHandled(reason["__promiseHandled__"])) { | |
async.invokeLater(this._notifyUnhandledRejection, this, reason); | |
} | |
}; | |
Promise.prototype._cleanValues = function Promise$_cleanValues() { | |
if (this._cancellable()) { | |
this._cancellationParent = void 0; | |
} | |
}; | |
Promise.prototype._fulfill = function Promise$_fulfill(value) { | |
if (this._isFollowingOrFulfilledOrRejected()) return; | |
this._fulfillUnchecked(value); | |
}; | |
Promise.prototype._reject = function Promise$_reject(reason) { | |
if (this._isFollowingOrFulfilledOrRejected()) return; | |
this._rejectUnchecked(reason); | |
}; | |
Promise.prototype._settlePromiseAt = function Promise$_settlePromiseAt(index) { | |
var handler = this.isFulfilled() | |
? this._fulfillmentHandlerAt(index) | |
: this._rejectionHandlerAt(index); | |
var value = this._settledValue; | |
var receiver = this._receiverAt(index); | |
var promise = this._promiseAt(index); | |
if (typeof handler === "function") { | |
this._settlePromiseFromHandler(handler, receiver, value, promise); | |
} | |
else { | |
var done = false; | |
var isFulfilled = this.isFulfilled(); | |
if (receiver !== void 0) { | |
if (receiver instanceof Promise && | |
receiver._isProxied()) { | |
receiver._unsetProxied(); | |
if (isFulfilled) receiver._fulfillUnchecked(value); | |
else receiver._rejectUnchecked(value); | |
done = true; | |
} | |
else if (isPromiseArrayProxy(receiver, promise)) { | |
if (isFulfilled) receiver._promiseFulfilled(value, promise); | |
else receiver._promiseRejected(value, promise); | |
done = true; | |
} | |
} | |
if (!done) { | |
if (isFulfilled) promise._fulfill(value); | |
else promise._reject(value); | |
} | |
} | |
if (index >= 256) { | |
this._queueGC(); | |
} | |
}; | |
Promise.prototype._isProxied = function Promise$_isProxied() { | |
return (this._bitField & 4194304) === 4194304; | |
}; | |
Promise.prototype._setProxied = function Promise$_setProxied() { | |
this._bitField = this._bitField | 4194304; | |
}; | |
Promise.prototype._unsetProxied = function Promise$_unsetProxied() { | |
this._bitField = this._bitField & (~4194304); | |
}; | |
Promise.prototype._isGcQueued = function Promise$_isGcQueued() { | |
return (this._bitField & -1073741824) === -1073741824; | |
}; | |
Promise.prototype._setGcQueued = function Promise$_setGcQueued() { | |
this._bitField = this._bitField | -1073741824; | |
}; | |
Promise.prototype._unsetGcQueued = function Promise$_unsetGcQueued() { | |
this._bitField = this._bitField & (~-1073741824); | |
}; | |
Promise.prototype._queueGC = function Promise$_queueGC() { | |
if (this._isGcQueued()) return; | |
this._setGcQueued(); | |
async.invokeLater(this._gc, this, void 0); | |
}; | |
Promise.prototype._gc = function Promise$gc() { | |
var len = this._length(); | |
this._unsetAt(0); | |
for (var i = 0; i < len; i++) { | |
delete this[i]; | |
} | |
this._setLength(0); | |
this._unsetGcQueued(); | |
}; | |
Promise.prototype._queueSettleAt = function Promise$_queueSettleAt(index) { | |
async.invoke(this._settlePromiseAt, this, index); | |
}; | |
Promise.prototype._fulfillUnchecked = | |
function Promise$_fulfillUnchecked(value) { | |
if (!this.isPending()) return; | |
if (value === this) { | |
var err = makeSelfResolutionError(); | |
this._attachExtraTrace(err); | |
return this._rejectUnchecked(err); | |
} | |
this._cleanValues(); | |
this._setFulfilled(); | |
this._settledValue = value; | |
var len = this._length(); | |
if (len > 0) { | |
async.invoke(this._fulfillPromises, this, len); | |
} | |
}; | |
Promise.prototype._fulfillPromises = function Promise$_fulfillPromises(len) { | |
len = this._length(); | |
for (var i = 0; i < len; i+= 5) { | |
this._settlePromiseAt(i); | |
} | |
}; | |
Promise.prototype._rejectUnchecked = | |
function Promise$_rejectUnchecked(reason) { | |
if (!this.isPending()) return; | |
if (reason === this) { | |
var err = makeSelfResolutionError(); | |
this._attachExtraTrace(err); | |
return this._rejectUnchecked(err); | |
} | |
this._cleanValues(); | |
this._setRejected(); | |
this._settledValue = reason; | |
if (this._isFinal()) { | |
async.invokeLater(thrower, void 0, reason); | |
return; | |
} | |
var len = this._length(); | |
if (len > 0) { | |
async.invoke(this._rejectPromises, this, len); | |
} | |
else { | |
this._ensurePossibleRejectionHandled(reason); | |
} | |
}; | |
Promise.prototype._rejectPromises = function Promise$_rejectPromises(len) { | |
len = this._length(); | |
var rejectionWasHandled = false; | |
for (var i = 0; i < len; i+= 5) { | |
var handler = this._rejectionHandlerAt(i); | |
if (!rejectionWasHandled) { | |
if(typeof handler === "function") rejectionWasHandled = true; | |
else { | |
var promise = this._promiseAt(i); | |
if (isPromise(promise) && promise._length() > 0) { | |
rejectionWasHandled = true; | |
} | |
else { | |
var receiver = this._receiverAt(i); | |
if (isPromise(receiver) && receiver._length() > 0 || | |
isPromiseArrayProxy(receiver, promise)) { | |
rejectionWasHandled = true; | |
} | |
} | |
} | |
} | |
this._settlePromiseAt(i); | |
} | |
if (!rejectionWasHandled) { | |
this._ensurePossibleRejectionHandled(this._settledValue); | |
} | |
}; | |
Promise.prototype._ensurePossibleRejectionHandled = | |
function Promise$_ensurePossibleRejectionHandled(reason) { | |
if (CapturedTrace.possiblyUnhandledRejection !== void 0) { | |
if (isObject(reason)) { | |
var handledState = reason["__promiseHandled__"]; | |
var newReason = reason; | |
if (handledState === void 0) { | |
newReason = ensurePropertyExpansion(reason, | |
"__promiseHandled__", 0); | |
handledState = 0; | |
} | |
else if (isHandled(handledState)) { | |
return; | |
} | |
if (!isStackAttached(handledState)) { | |
this._attachExtraTrace(newReason); | |
} | |
async.invoke(this._unhandledRejection, this, newReason); | |
} | |
} | |
}; | |
var contextStack = []; | |
Promise.prototype._peekContext = function Promise$_peekContext() { | |
var lastIndex = contextStack.length - 1; | |
if (lastIndex >= 0) { | |
return contextStack[lastIndex]; | |
} | |
return void 0; | |
}; | |
Promise.prototype._pushContext = function Promise$_pushContext() { | |
if (!debugging) return; | |
contextStack.push(this); | |
}; | |
Promise.prototype._popContext = function Promise$_popContext() { | |
if (!debugging) return; | |
contextStack.pop(); | |
}; | |
function Promise$_CreatePromiseArray( | |
promises, PromiseArrayConstructor, caller, boundTo) { | |
var list = null; | |
if (isArray(promises)) { | |
list = promises; | |
} | |
else { | |
list = Promise._cast(promises, caller, void 0); | |
if (list !== promises) { | |
list._setBoundTo(boundTo); | |
} | |
else if (!isPromise(list)) { | |
list = null; | |
} | |
} | |
if (list !== null) { | |
return new PromiseArrayConstructor( | |
list, | |
typeof caller === "function" | |
? caller | |
: Promise$_CreatePromiseArray, | |
boundTo | |
); | |
} | |
return { | |
promise: function() {return apiRejection("expecting an array, a promise or a thenable");} | |
}; | |
} | |
var old = global.Promise; | |
Promise.noConflict = function() { | |
if (global.Promise === Promise) { | |
global.Promise = old; | |
} | |
return Promise; | |
}; | |
if (!CapturedTrace.isSupported()) { | |
Promise.longStackTraces = function(){}; | |
debugging = false; | |
} | |
Promise._makeSelfResolutionError = makeSelfResolutionError; | |
require("./finally.js")(Promise, NEXT_FILTER); | |
require("./direct_resolve.js")(Promise); | |
require("./thenables.js")(Promise, INTERNAL); | |
Promise.RangeError = RangeError; | |
Promise.CancellationError = CancellationError; | |
Promise.TimeoutError = TimeoutError; | |
Promise.TypeError = TypeError; | |
Promise.RejectionError = RejectionError; | |
require('./timers.js')(Promise,INTERNAL); | |
require('./synchronous_inspection.js')(Promise); | |
require('./any.js')(Promise,Promise$_CreatePromiseArray,PromiseArray); | |
require('./race.js')(Promise,INTERNAL); | |
require('./call_get.js')(Promise); | |
require('./filter.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection); | |
require('./generators.js')(Promise,apiRejection,INTERNAL); | |
require('./map.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection); | |
require('./nodeify.js')(Promise); | |
require('./promisify.js')(Promise,INTERNAL); | |
require('./props.js')(Promise,PromiseArray); | |
require('./reduce.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection,INTERNAL); | |
require('./settle.js')(Promise,Promise$_CreatePromiseArray,PromiseArray); | |
require('./some.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection); | |
require('./progress.js')(Promise,isPromiseArrayProxy); | |
require('./cancel.js')(Promise,INTERNAL); | |
Promise.prototype = Promise.prototype; | |
return Promise; | |
}; | |
}).call(this,require("/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js")) | |
},{"./any.js":2,"./assert.js":3,"./async.js":4,"./call_get.js":6,"./cancel.js":7,"./captured_trace.js":8,"./catch_filter.js":9,"./direct_resolve.js":10,"./errors.js":11,"./errors_api_rejection":12,"./filter.js":14,"./finally.js":15,"./generators.js":16,"./global.js":17,"./map.js":18,"./nodeify.js":19,"./progress.js":20,"./promise_array.js":22,"./promise_resolver.js":24,"./promisify.js":26,"./props.js":28,"./race.js":30,"./reduce.js":31,"./settle.js":33,"./some.js":35,"./synchronous_inspection.js":37,"./thenables.js":38,"./timers.js":39,"./util.js":40,"/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":41}],22:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var ASSERT = require("./assert.js"); | |
var ensureNotHandled = require("./errors.js").ensureNotHandled; | |
var util = require("./util.js"); | |
var async = require("./async.js"); | |
var hasOwn = {}.hasOwnProperty; | |
var isArray = util.isArray; | |
function toResolutionValue(val) { | |
switch(val) { | |
case -1: return void 0; | |
case -2: return []; | |
case -3: return {}; | |
} | |
} | |
function PromiseArray(values, caller, boundTo) { | |
var promise = this._promise = new Promise(INTERNAL); | |
var parent = void 0; | |
if (Promise.is(values)) { | |
parent = values; | |
if (values._cancellable()) { | |
promise._setCancellable(); | |
promise._cancellationParent = values; | |
} | |
if (values._isBound()) { | |
promise._setBoundTo(boundTo); | |
} | |
} | |
promise._setTrace(caller, parent); | |
this._values = values; | |
this._length = 0; | |
this._totalResolved = 0; | |
this._init(void 0, -2); | |
} | |
PromiseArray.PropertiesPromiseArray = function() {}; | |
PromiseArray.prototype.length = function PromiseArray$length() { | |
return this._length; | |
}; | |
PromiseArray.prototype.promise = function PromiseArray$promise() { | |
return this._promise; | |
}; | |
PromiseArray.prototype._init = | |
function PromiseArray$_init(_, resolveValueIfEmpty) { | |
var values = this._values; | |
if (Promise.is(values)) { | |
if (values.isFulfilled()) { | |
values = values._settledValue; | |
if (!isArray(values)) { | |
var err = new Promise.TypeError("expecting an array, a promise or a thenable"); | |
this.__hardReject__(err); | |
return; | |
} | |
this._values = values; | |
} | |
else if (values.isPending()) { | |
values._then( | |
this._init, | |
this._reject, | |
void 0, | |
this, | |
resolveValueIfEmpty, | |
this.constructor | |
); | |
return; | |
} | |
else { | |
this._reject(values._settledValue); | |
return; | |
} | |
} | |
if (values.length === 0) { | |
this._resolve(toResolutionValue(resolveValueIfEmpty)); | |
return; | |
} | |
var len = values.length; | |
var newLen = len; | |
var newValues; | |
if (this instanceof PromiseArray.PropertiesPromiseArray) { | |
newValues = this._values; | |
} | |
else { | |
newValues = new Array(len); | |
} | |
var isDirectScanNeeded = false; | |
for (var i = 0; i < len; ++i) { | |
var promise = values[i]; | |
if (promise === void 0 && !hasOwn.call(values, i)) { | |
newLen--; | |
continue; | |
} | |
var maybePromise = Promise._cast(promise, void 0, void 0); | |
if (maybePromise instanceof Promise && | |
maybePromise.isPending()) { | |
maybePromise._proxyPromiseArray(this, i); | |
} | |
else { | |
isDirectScanNeeded = true; | |
} | |
newValues[i] = maybePromise; | |
} | |
if (newLen === 0) { | |
if (resolveValueIfEmpty === -2) { | |
this._resolve(newValues); | |
} | |
else { | |
this._resolve(toResolutionValue(resolveValueIfEmpty)); | |
} | |
return; | |
} | |
this._values = newValues; | |
this._length = newLen; | |
if (isDirectScanNeeded) { | |
var scanMethod = newLen === len | |
? this._scanDirectValues | |
: this._scanDirectValuesHoled; | |
async.invoke(scanMethod, this, len); | |
} | |
}; | |
PromiseArray.prototype._settlePromiseAt = | |
function PromiseArray$_settlePromiseAt(index) { | |
var value = this._values[index]; | |
if (!Promise.is(value)) { | |
this._promiseFulfilled(value, index); | |
} | |
else if (value.isFulfilled()) { | |
this._promiseFulfilled(value._settledValue, index); | |
} | |
else if (value.isRejected()) { | |
this._promiseRejected(value._settledValue, index); | |
} | |
}; | |
PromiseArray.prototype._scanDirectValuesHoled = | |
function PromiseArray$_scanDirectValuesHoled(len) { | |
for (var i = 0; i < len; ++i) { | |
if (this._isResolved()) { | |
break; | |
} | |
if (hasOwn.call(this._values, i)) { | |
this._settlePromiseAt(i); | |
} | |
} | |
}; | |
PromiseArray.prototype._scanDirectValues = | |
function PromiseArray$_scanDirectValues(len) { | |
for (var i = 0; i < len; ++i) { | |
if (this._isResolved()) { | |
break; | |
} | |
this._settlePromiseAt(i); | |
} | |
}; | |
PromiseArray.prototype._isResolved = function PromiseArray$_isResolved() { | |
return this._values === null; | |
}; | |
PromiseArray.prototype._resolve = function PromiseArray$_resolve(value) { | |
this._values = null; | |
this._promise._fulfill(value); | |
}; | |
PromiseArray.prototype.__hardReject__ = | |
PromiseArray.prototype._reject = function PromiseArray$_reject(reason) { | |
ensureNotHandled(reason); | |
this._values = null; | |
this._promise._attachExtraTrace(reason); | |
this._promise._reject(reason); | |
}; | |
PromiseArray.prototype._promiseProgressed = | |
function PromiseArray$_promiseProgressed(progressValue, index) { | |
if (this._isResolved()) return; | |
this._promise._progress({ | |
index: index, | |
value: progressValue | |
}); | |
}; | |
PromiseArray.prototype._promiseFulfilled = | |
function PromiseArray$_promiseFulfilled(value, index) { | |
if (this._isResolved()) return; | |
this._values[index] = value; | |
var totalResolved = ++this._totalResolved; | |
if (totalResolved >= this._length) { | |
this._resolve(this._values); | |
} | |
}; | |
PromiseArray.prototype._promiseRejected = | |
function PromiseArray$_promiseRejected(reason, index) { | |
if (this._isResolved()) return; | |
this._totalResolved++; | |
this._reject(reason); | |
}; | |
return PromiseArray; | |
}; | |
},{"./assert.js":3,"./async.js":4,"./errors.js":11,"./util.js":40}],23:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var TypeError = require("./errors.js").TypeError; | |
function PromiseInspection(promise) { | |
if (promise !== void 0) { | |
this._bitField = promise._bitField; | |
this._settledValue = promise.isResolved() | |
? promise._settledValue | |
: void 0; | |
} | |
else { | |
this._bitField = 0; | |
this._settledValue = void 0; | |
} | |
} | |
PromiseInspection.prototype.isFulfilled = | |
function PromiseInspection$isFulfilled() { | |
return (this._bitField & 268435456) > 0; | |
}; | |
PromiseInspection.prototype.isRejected = | |
function PromiseInspection$isRejected() { | |
return (this._bitField & 134217728) > 0; | |
}; | |
PromiseInspection.prototype.isPending = function PromiseInspection$isPending() { | |
return (this._bitField & 402653184) === 0; | |
}; | |
PromiseInspection.prototype.value = function PromiseInspection$value() { | |
if (!this.isFulfilled()) { | |
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise"); | |
} | |
return this._settledValue; | |
}; | |
PromiseInspection.prototype.error = function PromiseInspection$error() { | |
if (!this.isRejected()) { | |
throw new TypeError("cannot get rejection reason of a non-rejected promise"); | |
} | |
return this._settledValue; | |
}; | |
module.exports = PromiseInspection; | |
},{"./errors.js":11}],24:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var util = require("./util.js"); | |
var maybeWrapAsError = util.maybeWrapAsError; | |
var errors = require("./errors.js"); | |
var TimeoutError = errors.TimeoutError; | |
var RejectionError = errors.RejectionError; | |
var async = require("./async.js"); | |
var haveGetters = util.haveGetters; | |
var es5 = require("./es5.js"); | |
function isUntypedError(obj) { | |
return obj instanceof Error && | |
es5.getPrototypeOf(obj) === Error.prototype; | |
} | |
function wrapAsRejectionError(obj) { | |
var ret; | |
if (isUntypedError(obj)) { | |
ret = new RejectionError(obj); | |
} | |
else { | |
ret = obj; | |
} | |
errors.markAsOriginatingFromRejection(ret); | |
return ret; | |
} | |
function nodebackForPromise(promise) { | |
function PromiseResolver$_callback(err, value) { | |
if (err) { | |
var wrapped = wrapAsRejectionError(maybeWrapAsError(err)); | |
promise._attachExtraTrace(wrapped); | |
promise._reject(wrapped); | |
} | |
else { | |
if (arguments.length > 2) { | |
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];} | |
promise._fulfill(args); | |
} | |
else { | |
promise._fulfill(value); | |
} | |
} | |
} | |
return PromiseResolver$_callback; | |
} | |
var PromiseResolver; | |
if (!haveGetters) { | |
PromiseResolver = function PromiseResolver(promise) { | |
this.promise = promise; | |
this.asCallback = nodebackForPromise(promise); | |
this.callback = this.asCallback; | |
}; | |
} | |
else { | |
PromiseResolver = function PromiseResolver(promise) { | |
this.promise = promise; | |
}; | |
} | |
if (haveGetters) { | |
var prop = { | |
get: function() { | |
return nodebackForPromise(this.promise); | |
} | |
}; | |
es5.defineProperty(PromiseResolver.prototype, "asCallback", prop); | |
es5.defineProperty(PromiseResolver.prototype, "callback", prop); | |
} | |
PromiseResolver._nodebackForPromise = nodebackForPromise; | |
PromiseResolver.prototype.toString = function PromiseResolver$toString() { | |
return "[object PromiseResolver]"; | |
}; | |
PromiseResolver.prototype.resolve = | |
PromiseResolver.prototype.fulfill = function PromiseResolver$resolve(value) { | |
var promise = this.promise; | |
if (promise._tryFollow(value)) { | |
return; | |
} | |
async.invoke(promise._fulfill, promise, value); | |
}; | |
PromiseResolver.prototype.reject = function PromiseResolver$reject(reason) { | |
var promise = this.promise; | |
errors.markAsOriginatingFromRejection(reason); | |
promise._attachExtraTrace(reason); | |
async.invoke(promise._reject, promise, reason); | |
}; | |
PromiseResolver.prototype.progress = | |
function PromiseResolver$progress(value) { | |
async.invoke(this.promise._progress, this.promise, value); | |
}; | |
PromiseResolver.prototype.cancel = function PromiseResolver$cancel() { | |
async.invoke(this.promise.cancel, this.promise, void 0); | |
}; | |
PromiseResolver.prototype.timeout = function PromiseResolver$timeout() { | |
this.reject(new TimeoutError("timeout")); | |
}; | |
PromiseResolver.prototype.isResolved = function PromiseResolver$isResolved() { | |
return this.promise.isResolved(); | |
}; | |
PromiseResolver.prototype.toJSON = function PromiseResolver$toJSON() { | |
return this.promise.toJSON(); | |
}; | |
module.exports = PromiseResolver; | |
},{"./async.js":4,"./errors.js":11,"./es5.js":13,"./util.js":40}],25:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var errors = require("./errors.js"); | |
var TypeError = errors.TypeError; | |
var ensureNotHandled = errors.ensureNotHandled; | |
var util = require("./util.js"); | |
var isArray = util.isArray; | |
var errorObj = util.errorObj; | |
var tryCatch1 = util.tryCatch1; | |
function PromiseSpawn(generatorFunction, receiver, caller) { | |
var promise = this._promise = new Promise(INTERNAL); | |
promise._setTrace(caller, void 0); | |
this._generatorFunction = generatorFunction; | |
this._receiver = receiver; | |
this._generator = void 0; | |
} | |
PromiseSpawn.prototype.promise = function PromiseSpawn$promise() { | |
return this._promise; | |
}; | |
PromiseSpawn.prototype._run = function PromiseSpawn$_run() { | |
this._generator = this._generatorFunction.call(this._receiver); | |
this._receiver = | |
this._generatorFunction = void 0; | |
this._next(void 0); | |
}; | |
PromiseSpawn.prototype._continue = function PromiseSpawn$_continue(result) { | |
if (result === errorObj) { | |
this._generator = void 0; | |
this._promise._attachExtraTrace(result.e); | |
this._promise._reject(result.e); | |
return; | |
} | |
var value = result.value; | |
if (result.done === true) { | |
this._generator = void 0; | |
if (!this._promise._tryFollow(value)) { | |
this._promise._fulfill(value); | |
} | |
} | |
else { | |
var maybePromise = Promise._cast(value, PromiseSpawn$_continue, void 0); | |
if (!(maybePromise instanceof Promise)) { | |
if (isArray(maybePromise)) { | |
maybePromise = Promise.all(maybePromise); | |
} | |
else { | |
this._throw(new TypeError( | |
"A value was yielded that could not be treated as a promise" | |
)); | |
return; | |
} | |
} | |
maybePromise._then( | |
this._next, | |
this._throw, | |
void 0, | |
this, | |
null, | |
void 0 | |
); | |
} | |
}; | |
PromiseSpawn.prototype._throw = function PromiseSpawn$_throw(reason) { | |
ensureNotHandled(reason); | |
this._promise._attachExtraTrace(reason); | |
this._continue( | |
tryCatch1(this._generator["throw"], this._generator, reason) | |
); | |
}; | |
PromiseSpawn.prototype._next = function PromiseSpawn$_next(value) { | |
this._continue( | |
tryCatch1(this._generator.next, this._generator, value) | |
); | |
}; | |
return PromiseSpawn; | |
}; | |
},{"./errors.js":11,"./util.js":40}],26:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var THIS = {}; | |
var util = require("./util.js"); | |
var es5 = require("./es5.js"); | |
var nodebackForPromise = require("./promise_resolver.js") | |
._nodebackForPromise; | |
var withAppended = util.withAppended; | |
var maybeWrapAsError = util.maybeWrapAsError; | |
var canEvaluate = util.canEvaluate; | |
var notEnumerableProp = util.notEnumerableProp; | |
var deprecated = util.deprecated; | |
var ASSERT = require("./assert.js"); | |
var roriginal = new RegExp("__beforePromisified__" + "$"); | |
var hasProp = {}.hasOwnProperty; | |
function isPromisified(fn) { | |
return fn.__isPromisified__ === true; | |
} | |
var inheritedMethods = (function() { | |
if (es5.isES5) { | |
var create = Object.create; | |
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; | |
return function(cur) { | |
var original = cur; | |
var ret = []; | |
var visitedKeys = create(null); | |
while (cur !== null) { | |
var keys = es5.keys(cur); | |
for (var i = 0, len = keys.length; i < len; ++i) { | |
var key = keys[i]; | |
if (visitedKeys[key] || | |
roriginal.test(key) || | |
hasProp.call(original, key + "__beforePromisified__") | |
) { | |
continue; | |
} | |
visitedKeys[key] = true; | |
var desc = getOwnPropertyDescriptor(cur, key); | |
if (desc != null && | |
typeof desc.value === "function" && | |
!isPromisified(desc.value)) { | |
ret.push(key, desc.value); | |
} | |
} | |
cur = es5.getPrototypeOf(cur); | |
} | |
return ret; | |
}; | |
} | |
else { | |
return function(obj) { | |
var ret = []; | |
/*jshint forin:false */ | |
for (var key in obj) { | |
if (roriginal.test(key) || | |
hasProp.call(obj, key + "__beforePromisified__")) { | |
continue; | |
} | |
var fn = obj[key]; | |
if (typeof fn === "function" && | |
!isPromisified(fn)) { | |
ret.push(key, fn); | |
} | |
} | |
return ret; | |
}; | |
} | |
})(); | |
function makeNodePromisifiedEval(callback, receiver, originalName) { | |
function getCall(count) { | |
var args = new Array(count); | |
for (var i = 0, len = args.length; i < len; ++i) { | |
args[i] = "a" + (i+1); | |
} | |
var comma = count > 0 ? "," : ""; | |
if (typeof callback === "string" && | |
receiver === THIS) { | |
return "this['" + callback + "']("+args.join(",") + | |
comma +" fn);"+ | |
"break;"; | |
} | |
return (receiver === void 0 | |
? "callback("+args.join(",")+ comma +" fn);" | |
: "callback.call("+(receiver === THIS | |
? "this" | |
: "receiver")+", "+args.join(",") + comma + " fn);") + | |
"break;"; | |
} | |
function getArgs() { | |
return "var args = new Array(len + 1);" + | |
"var i = 0;" + | |
"for (var i = 0; i < len; ++i) { " + | |
" args[i] = arguments[i];" + | |
"}" + | |
"args[i] = fn;"; | |
} | |
var callbackName = (typeof originalName === "string" ? | |
originalName + "Async" : | |
"promisified"); | |
return new Function("Promise", "callback", "receiver", | |
"withAppended", "maybeWrapAsError", "nodebackForPromise", | |
"INTERNAL", | |
"var ret = function " + callbackName + | |
"(a1, a2, a3, a4, a5) {\"use strict\";" + | |
"var len = arguments.length;" + | |
"var promise = new Promise(INTERNAL);"+ | |
"promise._setTrace(" + callbackName + ", void 0);" + | |
"var fn = nodebackForPromise(promise);"+ | |
"try{" + | |
"switch(len) {" + | |
"case 1:" + getCall(1) + | |
"case 2:" + getCall(2) + | |
"case 3:" + getCall(3) + | |
"case 0:" + getCall(0) + | |
"case 4:" + getCall(4) + | |
"case 5:" + getCall(5) + | |
"default: " + getArgs() + (typeof callback === "string" | |
? "this['" + callback + "'].apply(" | |
: "callback.apply(" | |
) + | |
(receiver === THIS ? "this" : "receiver") + | |
", args); break;" + | |
"}" + | |
"}" + | |
"catch(e){ " + | |
"var wrapped = maybeWrapAsError(e);" + | |
"promise._attachExtraTrace(wrapped);" + | |
"promise._reject(wrapped);" + | |
"}" + | |
"return promise;" + | |
"" + | |
"}; ret.__isPromisified__ = true; return ret;" | |
)(Promise, callback, receiver, withAppended, | |
maybeWrapAsError, nodebackForPromise, INTERNAL); | |
} | |
function makeNodePromisifiedClosure(callback, receiver) { | |
function promisified() { | |
var _receiver = receiver; | |
if (receiver === THIS) _receiver = this; | |
if (typeof callback === "string") { | |
callback = _receiver[callback]; | |
} | |
var promise = new Promise(INTERNAL); | |
promise._setTrace(promisified, void 0); | |
var fn = nodebackForPromise(promise); | |
try { | |
callback.apply(_receiver, withAppended(arguments, fn)); | |
} | |
catch(e) { | |
var wrapped = maybeWrapAsError(e); | |
promise._attachExtraTrace(wrapped); | |
promise._reject(wrapped); | |
} | |
return promise; | |
} | |
promisified.__isPromisified__ = true; | |
return promisified; | |
} | |
var makeNodePromisified = canEvaluate | |
? makeNodePromisifiedEval | |
: makeNodePromisifiedClosure; | |
function f(){} | |
function _promisify(callback, receiver, isAll) { | |
if (isAll) { | |
var methods = inheritedMethods(callback); | |
for (var i = 0, len = methods.length; i < len; i+= 2) { | |
var key = methods[i]; | |
var fn = methods[i+1]; | |
var originalKey = key + "__beforePromisified__"; | |
var promisifiedKey = key + "Async"; | |
notEnumerableProp(callback, originalKey, fn); | |
callback[promisifiedKey] = | |
makeNodePromisified(originalKey, THIS, key); | |
} | |
if (methods.length > 16) f.prototype = callback; | |
return callback; | |
} | |
else { | |
return makeNodePromisified(callback, receiver, void 0); | |
} | |
} | |
Promise.promisify = function Promise$Promisify(fn, receiver) { | |
if (typeof fn === "object" && fn !== null) { | |
deprecated("Promise.promisify for promisifying entire objects is deprecated. Use Promise.promisifyAll instead."); | |
return _promisify(fn, receiver, true); | |
} | |
if (typeof fn !== "function") { | |
throw new TypeError("fn must be a function"); | |
} | |
if (isPromisified(fn)) { | |
return fn; | |
} | |
return _promisify( | |
fn, | |
arguments.length < 2 ? THIS : receiver, | |
false); | |
}; | |
Promise.promisifyAll = function Promise$PromisifyAll(target) { | |
if (typeof target !== "function" && typeof target !== "object") { | |
throw new TypeError("the target of promisifyAll must be an object or a function"); | |
} | |
return _promisify(target, void 0, true); | |
}; | |
}; | |
},{"./assert.js":3,"./es5.js":13,"./promise_resolver.js":24,"./util.js":40}],27:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, PromiseArray) { | |
var ASSERT = require("./assert.js"); | |
var util = require("./util.js"); | |
var inherits = util.inherits; | |
var es5 = require("./es5.js"); | |
function PropertiesPromiseArray(obj, caller, boundTo) { | |
var keys = es5.keys(obj); | |
var values = new Array(keys.length); | |
for (var i = 0, len = values.length; i < len; ++i) { | |
values[i] = obj[keys[i]]; | |
} | |
this.constructor$(values, caller, boundTo); | |
if (!this._isResolved()) { | |
for (var i = 0, len = keys.length; i < len; ++i) { | |
values.push(keys[i]); | |
} | |
} | |
} | |
inherits(PropertiesPromiseArray, PromiseArray); | |
PropertiesPromiseArray.prototype._init = | |
function PropertiesPromiseArray$_init() { | |
this._init$(void 0, -3) ; | |
}; | |
PropertiesPromiseArray.prototype._promiseFulfilled = | |
function PropertiesPromiseArray$_promiseFulfilled(value, index) { | |
if (this._isResolved()) return; | |
this._values[index] = value; | |
var totalResolved = ++this._totalResolved; | |
if (totalResolved >= this._length) { | |
var val = {}; | |
var keyOffset = this.length(); | |
for (var i = 0, len = this.length(); i < len; ++i) { | |
val[this._values[i + keyOffset]] = this._values[i]; | |
} | |
this._resolve(val); | |
} | |
}; | |
PropertiesPromiseArray.prototype._promiseProgressed = | |
function PropertiesPromiseArray$_promiseProgressed(value, index) { | |
if (this._isResolved()) return; | |
this._promise._progress({ | |
key: this._values[index + this.length()], | |
value: value | |
}); | |
}; | |
PromiseArray.PropertiesPromiseArray = PropertiesPromiseArray; | |
return PropertiesPromiseArray; | |
}; | |
},{"./assert.js":3,"./es5.js":13,"./util.js":40}],28:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, PromiseArray) { | |
var PropertiesPromiseArray = require("./properties_promise_array.js")( | |
Promise, PromiseArray); | |
var util = require("./util.js"); | |
var apiRejection = require("./errors_api_rejection")(Promise); | |
var isObject = util.isObject; | |
function Promise$_Props(promises, useBound, caller) { | |
var ret; | |
var castValue = Promise._cast(promises, caller, void 0); | |
if (!isObject(castValue)) { | |
return apiRejection("cannot await properties of a non-object"); | |
} | |
else if (Promise.is(castValue)) { | |
ret = castValue._then(Promise.props, void 0, void 0, | |
void 0, void 0, caller); | |
} | |
else { | |
ret = new PropertiesPromiseArray( | |
castValue, | |
caller, | |
useBound === true && castValue._isBound() | |
? castValue._boundTo | |
: void 0 | |
).promise(); | |
useBound = false; | |
} | |
if (useBound === true && castValue._isBound()) { | |
ret._setBoundTo(castValue._boundTo); | |
} | |
return ret; | |
} | |
Promise.prototype.props = function Promise$props() { | |
return Promise$_Props(this, true, this.props); | |
}; | |
Promise.props = function Promise$Props(promises) { | |
return Promise$_Props(promises, false, Promise.props); | |
}; | |
}; | |
},{"./errors_api_rejection":12,"./properties_promise_array.js":27,"./util.js":40}],29:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var ASSERT = require("./assert.js"); | |
function arrayCopy(src, srcIndex, dst, dstIndex, len) { | |
for (var j = 0; j < len; ++j) { | |
dst[j + dstIndex] = src[j + srcIndex]; | |
} | |
} | |
function pow2AtLeast(n) { | |
n = n >>> 0; | |
n = n - 1; | |
n = n | (n >> 1); | |
n = n | (n >> 2); | |
n = n | (n >> 4); | |
n = n | (n >> 8); | |
n = n | (n >> 16); | |
return n + 1; | |
} | |
function getCapacity(capacity) { | |
if (typeof capacity !== "number") return 16; | |
return pow2AtLeast( | |
Math.min( | |
Math.max(16, capacity), 1073741824) | |
); | |
} | |
function Queue(capacity) { | |
this._capacity = getCapacity(capacity); | |
this._length = 0; | |
this._front = 0; | |
this._makeCapacity(); | |
} | |
Queue.prototype._willBeOverCapacity = | |
function Queue$_willBeOverCapacity(size) { | |
return this._capacity < size; | |
}; | |
Queue.prototype._pushOne = function Queue$_pushOne(arg) { | |
var length = this.length(); | |
this._checkCapacity(length + 1); | |
var i = (this._front + length) & (this._capacity - 1); | |
this[i] = arg; | |
this._length = length + 1; | |
}; | |
Queue.prototype.push = function Queue$push(fn, receiver, arg) { | |
var length = this.length() + 3; | |
if (this._willBeOverCapacity(length)) { | |
this._pushOne(fn); | |
this._pushOne(receiver); | |
this._pushOne(arg); | |
return; | |
} | |
var j = this._front + length - 3; | |
this._checkCapacity(length); | |
var wrapMask = this._capacity - 1; | |
this[(j + 0) & wrapMask] = fn; | |
this[(j + 1) & wrapMask] = receiver; | |
this[(j + 2) & wrapMask] = arg; | |
this._length = length; | |
}; | |
Queue.prototype.shift = function Queue$shift() { | |
var front = this._front, | |
ret = this[front]; | |
this[front] = void 0; | |
this._front = (front + 1) & (this._capacity - 1); | |
this._length--; | |
return ret; | |
}; | |
Queue.prototype.length = function Queue$length() { | |
return this._length; | |
}; | |
Queue.prototype._makeCapacity = function Queue$_makeCapacity() { | |
var len = this._capacity; | |
for (var i = 0; i < len; ++i) { | |
this[i] = void 0; | |
} | |
}; | |
Queue.prototype._checkCapacity = function Queue$_checkCapacity(size) { | |
if (this._capacity < size) { | |
this._resizeTo(this._capacity << 3); | |
} | |
}; | |
Queue.prototype._resizeTo = function Queue$_resizeTo(capacity) { | |
var oldFront = this._front; | |
var oldCapacity = this._capacity; | |
var oldQueue = new Array(oldCapacity); | |
var length = this.length(); | |
arrayCopy(this, 0, oldQueue, 0, oldCapacity); | |
this._capacity = capacity; | |
this._makeCapacity(); | |
this._front = 0; | |
if (oldFront + length <= oldCapacity) { | |
arrayCopy(oldQueue, oldFront, this, 0, length); | |
} | |
else { var lengthBeforeWrapping = | |
length - ((oldFront + length) & (oldCapacity - 1)); | |
arrayCopy(oldQueue, oldFront, this, 0, lengthBeforeWrapping); | |
arrayCopy(oldQueue, 0, this, lengthBeforeWrapping, | |
length - lengthBeforeWrapping); | |
} | |
}; | |
module.exports = Queue; | |
},{"./assert.js":3}],30:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var apiRejection = require("./errors_api_rejection.js")(Promise); | |
var isArray = require("./util.js").isArray; | |
var raceLater = function Promise$_raceLater(promise) { | |
return promise.then(function Promise$_lateRacer(array) { | |
return Promise$_Race(array, Promise$_lateRacer, promise); | |
}); | |
}; | |
var hasOwn = {}.hasOwnProperty; | |
function Promise$_Race(promises, caller, parent) { | |
var maybePromise = Promise._cast(promises, caller, void 0); | |
if (Promise.is(maybePromise)) { | |
return raceLater(maybePromise); | |
} | |
else if (!isArray(promises)) { | |
return apiRejection("expecting an array, a promise or a thenable"); | |
} | |
var ret = new Promise(INTERNAL); | |
ret._setTrace(caller, parent); | |
if (parent !== void 0) { | |
if (parent._isBound()) { | |
ret._setBoundTo(parent._boundTo); | |
} | |
if (parent._cancellable()) { | |
ret._setCancellable(); | |
ret._cancellationParent = parent; | |
} | |
} | |
var fulfill = ret._fulfill; | |
var reject = ret._reject; | |
for (var i = 0, len = promises.length; i < len; ++i) { | |
var val = promises[i]; | |
if (val === void 0 && !(hasOwn.call(promises, i))) { | |
continue; | |
} | |
Promise.cast(val)._then( | |
fulfill, | |
reject, | |
void 0, | |
ret, | |
null, | |
caller | |
); | |
} | |
return ret; | |
} | |
Promise.race = function Promise$Race(promises) { | |
return Promise$_Race(promises, Promise.race, void 0); | |
}; | |
Promise.prototype.race = function Promise$race() { | |
return Promise$_Race(this, this.race, void 0); | |
}; | |
}; | |
},{"./errors_api_rejection.js":12,"./util.js":40}],31:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function( | |
Promise, Promise$_CreatePromiseArray, | |
PromiseArray, apiRejection, INTERNAL) { | |
var ASSERT = require("./assert.js"); | |
function Reduction(callback, index, accum, items, receiver) { | |
this.promise = new Promise(INTERNAL); | |
this.index = index; | |
this.length = items.length; | |
this.items = items; | |
this.callback = callback; | |
this.receiver = receiver; | |
this.accum = accum; | |
} | |
Reduction.prototype.reject = function Reduction$reject(e) { | |
this.promise._reject(e); | |
}; | |
Reduction.prototype.fulfill = function Reduction$fulfill(value, index) { | |
this.accum = value; | |
this.index = index + 1; | |
this.iterate(); | |
}; | |
Reduction.prototype.iterate = function Reduction$iterate() { | |
var i = this.index; | |
var len = this.length; | |
var items = this.items; | |
var result = this.accum; | |
var receiver = this.receiver; | |
var callback = this.callback; | |
var iterate = this.iterate; | |
for(; i < len; ++i) { | |
result = Promise._cast( | |
callback.call( | |
receiver, | |
result, | |
items[i], | |
i, | |
len | |
), | |
iterate, | |
void 0 | |
); | |
if (result instanceof Promise) { | |
result._then( | |
this.fulfill, this.reject, void 0, this, i, iterate); | |
return; | |
} | |
} | |
this.promise._fulfill(result); | |
}; | |
function Promise$_reducer(fulfilleds, initialValue) { | |
var fn = this; | |
var receiver = void 0; | |
if (typeof fn !== "function") { | |
receiver = fn.receiver; | |
fn = fn.fn; | |
} | |
var len = fulfilleds.length; | |
var accum = void 0; | |
var startIndex = 0; | |
if (initialValue !== void 0) { | |
accum = initialValue; | |
startIndex = 0; | |
} | |
else { | |
startIndex = 1; | |
if (len > 0) accum = fulfilleds[0]; | |
} | |
var i = startIndex; | |
if (i >= len) { | |
return accum; | |
} | |
var reduction = new Reduction(fn, i, accum, fulfilleds, receiver); | |
reduction.iterate(); | |
return reduction.promise; | |
} | |
function Promise$_unpackReducer(fulfilleds) { | |
var fn = this.fn; | |
var initialValue = this.initialValue; | |
return Promise$_reducer.call(fn, fulfilleds, initialValue); | |
} | |
function Promise$_slowReduce( | |
promises, fn, initialValue, useBound, caller) { | |
return initialValue._then(function callee(initialValue) { | |
return Promise$_Reduce( | |
promises, fn, initialValue, useBound, callee); | |
}, void 0, void 0, void 0, void 0, caller); | |
} | |
function Promise$_Reduce(promises, fn, initialValue, useBound, caller) { | |
if (typeof fn !== "function") { | |
return apiRejection("fn must be a function"); | |
} | |
if (useBound === true && promises._isBound()) { | |
fn = { | |
fn: fn, | |
receiver: promises._boundTo | |
}; | |
} | |
if (initialValue !== void 0) { | |
if (Promise.is(initialValue)) { | |
if (initialValue.isFulfilled()) { | |
initialValue = initialValue._settledValue; | |
} | |
else { | |
return Promise$_slowReduce(promises, | |
fn, initialValue, useBound, caller); | |
} | |
} | |
return Promise$_CreatePromiseArray(promises, PromiseArray, caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0) | |
.promise() | |
._then(Promise$_unpackReducer, void 0, void 0, { | |
fn: fn, | |
initialValue: initialValue | |
}, void 0, Promise.reduce); | |
} | |
return Promise$_CreatePromiseArray(promises, PromiseArray, caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0).promise() | |
._then(Promise$_reducer, void 0, void 0, fn, void 0, caller); | |
} | |
Promise.reduce = function Promise$Reduce(promises, fn, initialValue) { | |
return Promise$_Reduce(promises, fn, | |
initialValue, false, Promise.reduce); | |
}; | |
Promise.prototype.reduce = function Promise$reduce(fn, initialValue) { | |
return Promise$_Reduce(this, fn, initialValue, | |
true, this.reduce); | |
}; | |
}; | |
},{"./assert.js":3}],32:[function(require,module,exports){ | |
(function (process){/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var global = require("./global.js"); | |
var ASSERT = require("./assert.js"); | |
var schedule; | |
if (typeof process !== "undefined" && process !== null && | |
typeof process.cwd === "function" && | |
typeof process.nextTick === "function") { | |
schedule = process.nextTick; | |
} | |
else if ((typeof MutationObserver === "function" || | |
typeof WebkitMutationObserver === "function" || | |
typeof WebKitMutationObserver === "function") && | |
typeof document !== "undefined" && | |
typeof document.createElement === "function") { | |
schedule = (function(){ | |
var MutationObserver = global.MutationObserver || | |
global.WebkitMutationObserver || | |
global.WebKitMutationObserver; | |
var div = document.createElement("div"); | |
var queuedFn = void 0; | |
var observer = new MutationObserver( | |
function Promise$_Scheduler() { | |
var fn = queuedFn; | |
queuedFn = void 0; | |
fn(); | |
} | |
); | |
observer.observe(div, { | |
attributes: true | |
}); | |
return function Promise$_Scheduler(fn) { | |
queuedFn = fn; | |
div.setAttribute("class", "foo"); | |
}; | |
})(); | |
} | |
else if (typeof global.postMessage === "function" && | |
typeof global.importScripts !== "function" && | |
typeof global.addEventListener === "function" && | |
typeof global.removeEventListener === "function") { | |
var MESSAGE_KEY = "bluebird_message_key_" + Math.random(); | |
schedule = (function(){ | |
var queuedFn = void 0; | |
function Promise$_Scheduler(e) { | |
if (e.source === global && | |
e.data === MESSAGE_KEY) { | |
var fn = queuedFn; | |
queuedFn = void 0; | |
fn(); | |
} | |
} | |
global.addEventListener("message", Promise$_Scheduler, false); | |
return function Promise$_Scheduler(fn) { | |
queuedFn = fn; | |
global.postMessage( | |
MESSAGE_KEY, "*" | |
); | |
}; | |
})(); | |
} | |
else if (typeof MessageChannel === "function") { | |
schedule = (function(){ | |
var queuedFn = void 0; | |
var channel = new MessageChannel(); | |
channel.port1.onmessage = function Promise$_Scheduler() { | |
var fn = queuedFn; | |
queuedFn = void 0; | |
fn(); | |
}; | |
return function Promise$_Scheduler(fn) { | |
queuedFn = fn; | |
channel.port2.postMessage(null); | |
}; | |
})(); | |
} | |
else if (global.setTimeout) { | |
schedule = function Promise$_Scheduler(fn) { | |
setTimeout(fn, 4); | |
}; | |
} | |
else { | |
schedule = function Promise$_Scheduler(fn) { | |
fn(); | |
}; | |
} | |
module.exports = schedule; | |
}).call(this,require("/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js")) | |
},{"./assert.js":3,"./global.js":17,"/Users/Nek/Projects/regenerator-async/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":41}],33:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = | |
function(Promise, Promise$_CreatePromiseArray, PromiseArray) { | |
var SettledPromiseArray = require("./settled_promise_array.js")( | |
Promise, PromiseArray); | |
function Promise$_Settle(promises, useBound, caller) { | |
return Promise$_CreatePromiseArray( | |
promises, | |
SettledPromiseArray, | |
caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0 | |
).promise(); | |
} | |
Promise.settle = function Promise$Settle(promises) { | |
return Promise$_Settle(promises, false, Promise.settle); | |
}; | |
Promise.prototype.settle = function Promise$settle() { | |
return Promise$_Settle(this, true, this.settle); | |
}; | |
}; | |
},{"./settled_promise_array.js":34}],34:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, PromiseArray) { | |
var ASSERT = require("./assert.js"); | |
var PromiseInspection = require("./promise_inspection.js"); | |
var util = require("./util.js"); | |
var inherits = util.inherits; | |
function SettledPromiseArray(values, caller, boundTo) { | |
this.constructor$(values, caller, boundTo); | |
} | |
inherits(SettledPromiseArray, PromiseArray); | |
SettledPromiseArray.prototype._promiseResolved = | |
function SettledPromiseArray$_promiseResolved(index, inspection) { | |
this._values[index] = inspection; | |
var totalResolved = ++this._totalResolved; | |
if (totalResolved >= this._length) { | |
this._resolve(this._values); | |
} | |
}; | |
SettledPromiseArray.prototype._promiseFulfilled = | |
function SettledPromiseArray$_promiseFulfilled(value, index) { | |
if (this._isResolved()) return; | |
var ret = new PromiseInspection(); | |
ret._bitField = 268435456; | |
ret._settledValue = value; | |
this._promiseResolved(index, ret); | |
}; | |
SettledPromiseArray.prototype._promiseRejected = | |
function SettledPromiseArray$_promiseRejected(reason, index) { | |
if (this._isResolved()) return; | |
var ret = new PromiseInspection(); | |
ret._bitField = 134217728; | |
ret._settledValue = reason; | |
this._promiseResolved(index, ret); | |
}; | |
return SettledPromiseArray; | |
}; | |
},{"./assert.js":3,"./promise_inspection.js":23,"./util.js":40}],35:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = | |
function(Promise, Promise$_CreatePromiseArray, PromiseArray, apiRejection) { | |
var SomePromiseArray = require("./some_promise_array.js")(PromiseArray); | |
var ASSERT = require("./assert.js"); | |
function Promise$_Some(promises, howMany, useBound, caller) { | |
if ((howMany | 0) !== howMany || howMany < 0) { | |
return apiRejection("expecting a positive integer"); | |
} | |
var ret = Promise$_CreatePromiseArray( | |
promises, | |
SomePromiseArray, | |
caller, | |
useBound === true && promises._isBound() | |
? promises._boundTo | |
: void 0 | |
); | |
var promise = ret.promise(); | |
if (promise.isRejected()) { | |
return promise; | |
} | |
ret.setHowMany(howMany); | |
ret.init(); | |
return promise; | |
} | |
Promise.some = function Promise$Some(promises, howMany) { | |
return Promise$_Some(promises, howMany, false, Promise.some); | |
}; | |
Promise.prototype.some = function Promise$some(count) { | |
return Promise$_Some(this, count, true, this.some); | |
}; | |
}; | |
},{"./assert.js":3,"./some_promise_array.js":36}],36:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function (PromiseArray) { | |
var util = require("./util.js"); | |
var RangeError = require("./errors.js").RangeError; | |
var inherits = util.inherits; | |
var isArray = util.isArray; | |
function SomePromiseArray(values, caller, boundTo) { | |
this.constructor$(values, caller, boundTo); | |
this._howMany = 0; | |
this._unwrap = false; | |
this._initialized = false; | |
} | |
inherits(SomePromiseArray, PromiseArray); | |
SomePromiseArray.prototype._init = function SomePromiseArray$_init() { | |
if (!this._initialized) { | |
return; | |
} | |
if (this._howMany === 0) { | |
this._resolve([]); | |
return; | |
} | |
this._init$(void 0, -2); | |
var isArrayResolved = isArray(this._values); | |
this._holes = isArrayResolved ? this._values.length - this.length() : 0; | |
if (!this._isResolved() && | |
isArrayResolved && | |
this._howMany > this._canPossiblyFulfill()) { | |
var message = "(Promise.some) input array contains less than " + | |
this._howMany + " promises"; | |
this._reject(new RangeError(message)); | |
} | |
}; | |
SomePromiseArray.prototype.init = function SomePromiseArray$init() { | |
this._initialized = true; | |
this._init(); | |
}; | |
SomePromiseArray.prototype.setUnwrap = function SomePromiseArray$setUnwrap() { | |
this._unwrap = true; | |
}; | |
SomePromiseArray.prototype.howMany = function SomePromiseArray$howMany() { | |
return this._howMany; | |
}; | |
SomePromiseArray.prototype.setHowMany = | |
function SomePromiseArray$setHowMany(count) { | |
if (this._isResolved()) return; | |
this._howMany = count; | |
}; | |
SomePromiseArray.prototype._promiseFulfilled = | |
function SomePromiseArray$_promiseFulfilled(value) { | |
if (this._isResolved()) return; | |
this._addFulfilled(value); | |
if (this._fulfilled() === this.howMany()) { | |
this._values.length = this.howMany(); | |
if (this.howMany() === 1 && this._unwrap) { | |
this._resolve(this._values[0]); | |
} | |
else { | |
this._resolve(this._values); | |
} | |
} | |
}; | |
SomePromiseArray.prototype._promiseRejected = | |
function SomePromiseArray$_promiseRejected(reason) { | |
if (this._isResolved()) return; | |
this._addRejected(reason); | |
if (this.howMany() > this._canPossiblyFulfill()) { | |
if (this._values.length === this.length()) { | |
this._reject([]); | |
} | |
else { | |
this._reject(this._values.slice(this.length() + this._holes)); | |
} | |
} | |
}; | |
SomePromiseArray.prototype._fulfilled = function SomePromiseArray$_fulfilled() { | |
return this._totalResolved; | |
}; | |
SomePromiseArray.prototype._rejected = function SomePromiseArray$_rejected() { | |
return this._values.length - this.length() - this._holes; | |
}; | |
SomePromiseArray.prototype._addRejected = | |
function SomePromiseArray$_addRejected(reason) { | |
this._values.push(reason); | |
}; | |
SomePromiseArray.prototype._addFulfilled = | |
function SomePromiseArray$_addFulfilled(value) { | |
this._values[this._totalResolved++] = value; | |
}; | |
SomePromiseArray.prototype._canPossiblyFulfill = | |
function SomePromiseArray$_canPossiblyFulfill() { | |
return this.length() - this._rejected(); | |
}; | |
return SomePromiseArray; | |
}; | |
},{"./errors.js":11,"./util.js":40}],37:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise) { | |
var PromiseInspection = require("./promise_inspection.js"); | |
Promise.prototype.inspect = function Promise$inspect() { | |
return new PromiseInspection(this); | |
}; | |
}; | |
},{"./promise_inspection.js":23}],38:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
module.exports = function(Promise, INTERNAL) { | |
var ASSERT = require("./assert.js"); | |
var util = require("./util.js"); | |
var errorObj = util.errorObj; | |
var isObject = util.isObject; | |
function getThen(obj) { | |
try { | |
return obj.then; | |
} | |
catch(e) { | |
errorObj.e = e; | |
return errorObj; | |
} | |
} | |
function Promise$_Cast(obj, caller, originalPromise) { | |
if (isObject(obj)) { | |
if (obj instanceof Promise) { | |
return obj; | |
} | |
else if (isAnyBluebirdPromise(obj)) { | |
var ret = new Promise(INTERNAL); | |
ret._setTrace(caller, void 0); | |
obj._then( | |
ret._fulfillUnchecked, | |
ret._rejectUnchecked, | |
ret._progressUnchecked, | |
ret, | |
null, | |
void 0 | |
); | |
ret._setFollowing(); | |
return ret; | |
} | |
var then = getThen(obj); | |
if (then === errorObj) { | |
caller = typeof caller === "function" ? caller : Promise$_Cast; | |
if (originalPromise !== void 0) { | |
originalPromise._attachExtraTrace(then.e); | |
} | |
return Promise.reject(then.e, caller); | |
} | |
else if (typeof then === "function") { | |
caller = typeof caller === "function" ? caller : Promise$_Cast; | |
return Promise$_doThenable(obj, then, caller, originalPromise); | |
} | |
} | |
return obj; | |
} | |
var hasProp = {}.hasOwnProperty; | |
function isAnyBluebirdPromise(obj) { | |
return hasProp.call(obj, "_promise0"); | |
} | |
function Promise$_doThenable(x, then, caller, originalPromise) { | |
var resolver = Promise.defer(caller); | |
var called = false; | |
try { | |
then.call( | |
x, | |
Promise$_resolveFromThenable, | |
Promise$_rejectFromThenable, | |
Promise$_progressFromThenable | |
); | |
} | |
catch(e) { | |
if (!called) { | |
called = true; | |
if (originalPromise !== void 0) { | |
originalPromise._attachExtraTrace(e); | |
} | |
resolver.promise._reject(e); | |
} | |
} | |
return resolver.promise; | |
function Promise$_resolveFromThenable(y) { | |
if (called) return; | |
called = true; | |
if (x === y) { | |
var e = Promise._makeSelfResolutionError(); | |
if (originalPromise !== void 0) { | |
originalPromise._attachExtraTrace(e); | |
} | |
resolver.promise._reject(e); | |
return; | |
} | |
resolver.resolve(y); | |
} | |
function Promise$_rejectFromThenable(r) { | |
if (called) return; | |
called = true; | |
if (originalPromise !== void 0) { | |
originalPromise._attachExtraTrace(r); | |
} | |
resolver.promise._attachExtraTrace(r); | |
resolver.promise._reject(r); | |
} | |
function Promise$_progressFromThenable(v) { | |
if (called) return; | |
var promise = resolver.promise; | |
if (typeof promise._progress === "function") { | |
promise._progress(v); | |
} | |
} | |
} | |
Promise._cast = Promise$_Cast; | |
}; | |
},{"./assert.js":3,"./util.js":40}],39:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var global = require("./global.js"); | |
var setTimeout = function(fn, time) { | |
var $_len = arguments.length;var args = new Array($_len - 2); for(var $_i = 2; $_i < $_len; ++$_i) {args[$_i - 2] = arguments[$_i];} | |
global.setTimeout(function() { | |
fn.apply(void 0, args); | |
}, time); | |
}; | |
var pass = {}; | |
global.setTimeout( function(_) { | |
if(_ === pass) { | |
setTimeout = global.setTimeout; | |
} | |
}, 1, pass); | |
module.exports = function(Promise, INTERNAL) { | |
var util = require("./util.js"); | |
var ASSERT = require("./assert.js"); | |
var errors = require("./errors.js"); | |
var apiRejection = require("./errors_api_rejection")(Promise); | |
var TimeoutError = Promise.TimeoutError; | |
var afterTimeout = function Promise$_afterTimeout(promise, message, ms) { | |
if (!promise.isPending()) return; | |
if (typeof message !== "string") { | |
message = "operation timed out after" + " " + ms + " ms" | |
} | |
var err = new TimeoutError(message); | |
errors.markAsOriginatingFromRejection(err); | |
promise._attachExtraTrace(err); | |
promise._rejectUnchecked(err); | |
}; | |
var afterDelay = function Promise$_afterDelay(value, promise) { | |
promise._fulfill(value); | |
}; | |
Promise.delay = function Promise$Delay(value, ms, caller) { | |
if (ms === void 0) { | |
ms = value; | |
value = void 0; | |
} | |
ms = +ms; | |
if (typeof caller !== "function") { | |
caller = Promise.delay; | |
} | |
var maybePromise = Promise._cast(value, caller, void 0); | |
var promise = new Promise(INTERNAL); | |
if (Promise.is(maybePromise)) { | |
if (maybePromise._isBound()) { | |
promise._setBoundTo(maybePromise._boundTo); | |
} | |
if (maybePromise._cancellable()) { | |
promise._setCancellable(); | |
promise._cancellationParent = maybePromise; | |
} | |
promise._setTrace(caller, maybePromise); | |
promise._follow(maybePromise); | |
return promise.then(function(value) { | |
return Promise.delay(value, ms); | |
}); | |
} | |
else { | |
promise._setTrace(caller, void 0); | |
setTimeout(afterDelay, ms, value, promise); | |
} | |
return promise; | |
}; | |
Promise.prototype.delay = function Promise$delay(ms) { | |
return Promise.delay(this, ms, this.delay); | |
}; | |
Promise.prototype.timeout = function Promise$timeout(ms, message) { | |
ms = +ms; | |
var ret = new Promise(INTERNAL); | |
ret._setTrace(this.timeout, this); | |
if (this._isBound()) ret._setBoundTo(this._boundTo); | |
if (this._cancellable()) { | |
ret._setCancellable(); | |
ret._cancellationParent = this; | |
} | |
ret._follow(this); | |
setTimeout(afterTimeout, ms, ret, message, ms); | |
return ret; | |
}; | |
}; | |
},{"./assert.js":3,"./errors.js":11,"./errors_api_rejection":12,"./global.js":17,"./util.js":40}],40:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2014 Petka Antonov | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions:</p> | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
* | |
*/ | |
"use strict"; | |
var global = require("./global.js"); | |
var ASSERT = require("./assert.js"); | |
var es5 = require("./es5.js"); | |
var haveGetters = (function(){ | |
try { | |
var o = {}; | |
es5.defineProperty(o, "f", { | |
get: function () { | |
return 3; | |
} | |
}); | |
return o.f === 3; | |
} | |
catch (e) { | |
return false; | |
} | |
})(); | |
var ensurePropertyExpansion = function(obj, prop, value) { | |
try { | |
notEnumerableProp(obj, prop, value); | |
return obj; | |
} | |
catch (e) { | |
var ret = {}; | |
var keys = es5.keys(obj); | |
for (var i = 0, len = keys.length; i < len; ++i) { | |
try { | |
var key = keys[i]; | |
ret[key] = obj[key]; | |
} | |
catch (err) { | |
ret[key] = err; | |
} | |
} | |
notEnumerableProp(ret, prop, value); | |
return ret; | |
} | |
}; | |
var canEvaluate = (function() { | |
if (typeof window !== "undefined" && window !== null && | |
typeof window.document !== "undefined" && | |
typeof navigator !== "undefined" && navigator !== null && | |
typeof navigator.appName === "string" && | |
window === global) { | |
return false; | |
} | |
return true; | |
})(); | |
function deprecated(msg) { | |
if (typeof console !== "undefined" && console !== null && | |
typeof console.warn === "function") { | |
console.warn("Bluebird: " + msg); | |
} | |
} | |
var errorObj = {e: {}}; | |
function tryCatch1(fn, receiver, arg) { | |
try { | |
return fn.call(receiver, arg); | |
} | |
catch (e) { | |
errorObj.e = e; | |
return errorObj; | |
} | |
} | |
function tryCatch2(fn, receiver, arg, arg2) { | |
try { | |
return fn.call(receiver, arg, arg2); | |
} | |
catch (e) { | |
errorObj.e = e; | |
return errorObj; | |
} | |
} | |
function tryCatchApply(fn, args, receiver) { | |
try { | |
return fn.apply(receiver, args); | |
} | |
catch (e) { | |
errorObj.e = e; | |
return errorObj; | |
} | |
} | |
var inherits = function(Child, Parent) { | |
var hasProp = {}.hasOwnProperty; | |
function T() { | |
this.constructor = Child; | |
this.constructor$ = Parent; | |
for (var propertyName in Parent.prototype) { | |
if (hasProp.call(Parent.prototype, propertyName) && | |
propertyName.charAt(propertyName.length-1) !== "$" | |
) { | |
this[propertyName + "$"] = Parent.prototype[propertyName]; | |
} | |
} | |
} | |
T.prototype = Parent.prototype; | |
Child.prototype = new T(); | |
return Child.prototype; | |
}; | |
function asString(val) { | |
return typeof val === "string" ? val : ("" + val); | |
} | |
function isPrimitive(val) { | |
return val == null || val === true || val === false || | |
typeof val === "string" || typeof val === "number"; | |
} | |
function isObject(value) { | |
return !isPrimitive(value); | |
} | |
function maybeWrapAsError(maybeError) { | |
if (!isPrimitive(maybeError)) return maybeError; | |
return new Error(asString(maybeError)); | |
} | |
function withAppended(target, appendee) { | |
var len = target.length; | |
var ret = new Array(len + 1); | |
var i; | |
for (i = 0; i < len; ++i) { | |
ret[i] = target[i]; | |
} | |
ret[i] = appendee; | |
return ret; | |
} | |
function notEnumerableProp(obj, name, value) { | |
var descriptor = { | |
value: value, | |
configurable: true, | |
enumerable: false, | |
writable: true | |
}; | |
es5.defineProperty(obj, name, descriptor); | |
return obj; | |
} | |
var wrapsPrimitiveReceiver = (function() { | |
return this !== "string"; | |
}).call("string"); | |
function thrower(r) { | |
throw r; | |
} | |
var ret = { | |
thrower: thrower, | |
isArray: es5.isArray, | |
haveGetters: haveGetters, | |
notEnumerableProp: notEnumerableProp, | |
isPrimitive: isPrimitive, | |
isObject: isObject, | |
ensurePropertyExpansion: ensurePropertyExpansion, | |
canEvaluate: canEvaluate, | |
deprecated: deprecated, | |
errorObj: errorObj, | |
tryCatch1: tryCatch1, | |
tryCatch2: tryCatch2, | |
tryCatchApply: tryCatchApply, | |
inherits: inherits, | |
withAppended: withAppended, | |
asString: asString, | |
maybeWrapAsError: maybeWrapAsError, | |
wrapsPrimitiveReceiver: wrapsPrimitiveReceiver | |
}; | |
module.exports = ret; | |
},{"./assert.js":3,"./es5.js":13,"./global.js":17}],41:[function(require,module,exports){ | |
// shim for using process in browser | |
var process = module.exports = {}; | |
process.nextTick = (function () { | |
var canSetImmediate = typeof window !== 'undefined' | |
&& window.setImmediate; | |
var canPost = typeof window !== 'undefined' | |
&& window.postMessage && window.addEventListener | |
; | |
if (canSetImmediate) { | |
return function (f) { return window.setImmediate(f) }; | |
} | |
if (canPost) { | |
var queue = []; | |
window.addEventListener('message', function (ev) { | |
var source = ev.source; | |
if ((source === window || source === null) && ev.data === 'process-tick') { | |
ev.stopPropagation(); | |
if (queue.length > 0) { | |
var fn = queue.shift(); | |
fn(); | |
} | |
} | |
}, true); | |
return function nextTick(fn) { | |
queue.push(fn); | |
window.postMessage('process-tick', '*'); | |
}; | |
} | |
return function nextTick(fn) { | |
setTimeout(fn, 0); | |
}; | |
})(); | |
process.title = 'browser'; | |
process.browser = true; | |
process.env = {}; | |
process.argv = []; | |
process.binding = function (name) { | |
throw new Error('process.binding is not supported'); | |
} | |
// TODO(shtylman) | |
process.cwd = function () { return '/' }; | |
process.chdir = function (dir) { | |
throw new Error('process.chdir is not supported'); | |
}; | |
},{}],42:[function(require,module,exports){ | |
var parallel = require("continuable-para") | |
var Promise = require("bluebird") | |
var both = require("./both.js") | |
var async = require("./index.js") | |
var Asynchrony = module.exports = { | |
parallel: function (value, next) { | |
if (value.length === 0) { | |
parallel([])(next) | |
} else if (typeof value[0] === "function") { | |
parallel(value)(next) | |
} else if (value[0] && typeof value[0].then === "function") { | |
Asynchrony.execute(Promise.all(value), next) | |
} | |
}, | |
both: function (value, next) { | |
var async = value.both | |
if (typeof async === "function") { | |
both(async)(next) | |
} else if (async && typeof async.then === "function") { | |
var p = async.then(function (result) { | |
return [null, result] | |
}, function (error) { | |
return [error] | |
}) | |
Asynchrony.execute(p, next) | |
} | |
}, | |
execute: function (value, next) { | |
if (typeof value === "function") { | |
value(next) | |
} else if (value && typeof value.then === "function") { | |
value.then(function (result) { | |
next(null, result) | |
}, function (error) { | |
next(error) | |
}) | |
} | |
}, | |
is: function (value) { | |
return typeof value === "function" || // thunk / continuable | |
value && typeof value.then === "function" // promise | |
}, | |
to: function (generator) { | |
return function (cb) { | |
async(generator)(cb) | |
} | |
} | |
} | |
},{"./both.js":43,"./index.js":44,"bluebird":5,"continuable-para":45}],43:[function(require,module,exports){ | |
// both := (Continuable) => Continuable<[Error, Any]> | |
module.exports = both | |
function both(source) { | |
return function continuable(callback) { | |
source(function (err, value) { | |
callback(null, [err || null, value]) | |
}) | |
} | |
} | |
},{}],44:[function(require,module,exports){ | |
var toString = Object.prototype.toString | |
module.exports = async | |
var Asynchrony = require("./asynchrony") | |
function async(generator) { | |
return function async() { | |
var args = [].slice.call(arguments) | |
var callback = args.pop() | |
var iterator = isGenerator(generator) ? | |
generator : generator.apply(this, args) | |
next(null, null) | |
function next(err, value) { | |
if (err) { | |
return callback(err) | |
} | |
var res = iterator.next(value) | |
if (!res.done) { | |
return runValue(res.value, next) | |
} | |
return isError(res.value) ? callback(res.value) : | |
callback(null, res.value) | |
} | |
} | |
} | |
function runValue(value, next) { | |
if (!value) { | |
return | |
} else if (Asynchrony.is(value)) { | |
Asynchrony.execute(value, next) | |
} else if (Array.isArray(value) && Asynchrony.is(value[0])) { | |
Asynchrony.parallel(value, next) | |
} else if (Array.isArray(value) && isGenerator(value[0])) { | |
Asynchrony.parallel(value.map(Asynchrony.to), next) | |
} else if (value.both) { | |
if (isGenerator(value.both)) { | |
value.both = Asynchrony.to(value.both) | |
} | |
Asynchrony.both(value, next) | |
} else if (isError(value)) { | |
next(value) | |
} else { | |
throw new Error("yielded strange value. Cannot be run " + | |
JSON.stringify(value)) | |
} | |
} | |
function isError(err) { | |
return toString.call(err) === "[object Error]" | |
} | |
function isGenerator(obj) { | |
return obj && (toString.call(obj) === "[object Generator]" || | |
// this fallback is here for polyfill runtimes, like facebook/regenerator | |
(obj.constructor && 'Generator' == obj.constructor.name)) | |
} | |
},{"./asynchrony":42}],45:[function(require,module,exports){ | |
var list = require('continuable-list') | |
var hash = require('continuable-hash') | |
module.exports = function (obj) { | |
if(Array.isArray(obj)) | |
return list(obj) | |
else if('object' === typeof obj) | |
return hash(obj) | |
else | |
return list([].slice.call(arguments)) | |
} | |
},{"continuable-hash":46,"continuable-list":48}],46:[function(require,module,exports){ | |
var maybeCallback = require("continuable/maybe-callback") | |
module.exports = maybeCallback(hash) | |
// hash := (tasks:Object<String, Continuable<T>>) | |
// => Continuable<Object<String, T>> | |
function hash(tasks) { | |
return function continuable(callback) { | |
var keys = Object.keys(tasks) | |
var count = 0 | |
var result = {} | |
if (keys.length === 0) { | |
return callback(null, result) | |
} | |
keys.forEach(function (key) { | |
tasks[key](function (err, value) { | |
if (err && result) { | |
result = null | |
callback(err) | |
} else if (!err && result) { | |
result[key] = value | |
if (++count === keys.length) { | |
callback(null, result) | |
} | |
} | |
}) | |
}) | |
} | |
} | |
},{"continuable/maybe-callback":47}],47:[function(require,module,exports){ | |
var slice = Array.prototype.slice | |
/* Given a function that takes n arguments and returns a continuable | |
return a function that takes n arguments and maybe a n+1th argument | |
which is a callback or takes n arguments and returns a continuable | |
This basically means that you can do this: | |
```js | |
var readFile = maybeCallback(function (uri) { | |
return function (cb) { fs.readFile(uri, cb) } | |
}) | |
readFile("./foo")(cb) | |
readFile("./foo", cb) | |
``` | |
Be warned this breaks if the last argument is a function | |
*/ | |
module.exports = maybeCallback | |
// maybeCallback := (fn: (Any, ...) => Continuable<T>) => | |
// (Any, ..., Callback<T>?) => Continuable<T> | |
function maybeCallback(fn) { | |
return function maybeContinuable() { | |
var args = slice.call(arguments) | |
var callback = args[args.length - 1] | |
if (typeof callback === "function") { | |
args.pop() | |
} | |
var continuable = fn.apply(null, args) | |
if (typeof callback === "function") { | |
continuable(callback) | |
} else { | |
return continuable | |
} | |
} | |
} | |
},{}],48:[function(require,module,exports){ | |
var maybeCallback = require("continuable/maybe-callback") | |
module.exports = maybeCallback(list) | |
// list := (tasks:Array<Continuable<T>>) | |
// => Continuable<Array<T>> | |
function list(tasks) { | |
return function continuable(callback) { | |
var result = [] | |
var count = 0 | |
if (tasks.length === 0) { | |
return callback(null, result) | |
} | |
tasks.forEach(function invokeSource(source, index) { | |
source(function continuation(err, value) { | |
if (err && result) { | |
result = null | |
callback(err) | |
} else if (!err && result) { | |
result[index] = value | |
if (++count === tasks.length) { | |
callback(null, result) | |
} | |
} | |
}) | |
}) | |
} | |
} | |
},{"continuable/maybe-callback":49}],49:[function(require,module,exports){ | |
module.exports=require(47) | |
},{}],50:[function(require,module,exports){ | |
/** | |
* Copyright (c) 2013, Facebook, Inc. | |
* All rights reserved. | |
* | |
* This source code is licensed under the BSD-style license found in the | |
* LICENSE file in the root directory of this source tree. An additional grant | |
* of patent rights can be found in the PATENTS file in the same directory. | |
*/ | |
(function( | |
// Reliable reference to the global object (i.e. window in browsers). | |
global, | |
// Dummy constructor that we use as the .constructor property for | |
// functions that return Generator objects. | |
GeneratorFunction | |
) { | |
var hasOwn = Object.prototype.hasOwnProperty; | |
if (global.wrapGenerator) { | |
return; | |
} | |
function wrapGenerator(innerFn, self) { | |
return new Generator(innerFn, self || null); | |
} | |
global.wrapGenerator = wrapGenerator; | |
if (typeof exports !== "undefined") { | |
exports.wrapGenerator = wrapGenerator; | |
} | |
var GenStateSuspendedStart = "suspendedStart"; | |
var GenStateSuspendedYield = "suspendedYield"; | |
var GenStateExecuting = "executing"; | |
var GenStateCompleted = "completed"; | |
// Returning this object from the innerFn has the same effect as | |
// breaking out of the dispatch switch statement. | |
var ContinueSentinel = {}; | |
wrapGenerator.mark = function(genFun) { | |
genFun.constructor = GeneratorFunction; | |
return genFun; | |
}; | |
// Ensure isGeneratorFunction works when Function#name not supported. | |
if (GeneratorFunction.name !== "GeneratorFunction") { | |
GeneratorFunction.name = "GeneratorFunction"; | |
} | |
wrapGenerator.isGeneratorFunction = function(genFun) { | |
var ctor = genFun && genFun.constructor; | |
return ctor ? GeneratorFunction.name === ctor.name : false; | |
}; | |
function Generator(innerFn, self) { | |
var generator = this; | |
var context = new Context(); | |
var state = GenStateSuspendedStart; | |
function invoke() { | |
state = GenStateExecuting; | |
do { | |
var value = innerFn.call(self, context); | |
} while (value === ContinueSentinel); | |
// If an exception is thrown from innerFn, we leave state === | |
// GenStateExecuting and loop back for another invocation. | |
state = context.done | |
? GenStateCompleted | |
: GenStateSuspendedYield; | |
return { value: value, done: context.done }; | |
} | |
function assertCanInvoke() { | |
if (state === GenStateExecuting) { | |
throw new Error("Generator is already running"); | |
} | |
if (state === GenStateCompleted) { | |
throw new Error("Generator has already finished"); | |
} | |
} | |
function handleDelegate(method, arg) { | |
var delegate = context.delegate; | |
if (delegate) { | |
try { | |
var info = delegate.generator[method](arg); | |
} catch (uncaught) { | |
context.delegate = null; | |
return generator.throw(uncaught); | |
} | |
if (info) { | |
if (info.done) { | |
context[delegate.resultName] = info.value; | |
context.next = delegate.nextLoc; | |
} else { | |
return info; | |
} | |
} | |
context.delegate = null; | |
} | |
} | |
generator.next = function(value) { | |
assertCanInvoke(); | |
var delegateInfo = handleDelegate("next", value); | |
if (delegateInfo) { | |
return delegateInfo; | |
} | |
if (state === GenStateSuspendedYield) { | |
context.sent = value; | |
} | |
while (true) try { | |
return invoke(); | |
} catch (exception) { | |
context.dispatchException(exception); | |
} | |
}; | |
generator.throw = function(exception) { | |
assertCanInvoke(); | |
var delegateInfo = handleDelegate("throw", exception); | |
if (delegateInfo) { | |
return delegateInfo; | |
} | |
if (state === GenStateSuspendedStart) { | |
state = GenStateCompleted; | |
throw exception; | |
} | |
while (true) { | |
context.dispatchException(exception); | |
try { | |
return invoke(); | |
} catch (thrown) { | |
exception = thrown; | |
} | |
} | |
}; | |
} | |
Generator.prototype.toString = function() { | |
return "[object Generator]"; | |
}; | |
function Context() { | |
this.reset(); | |
} | |
Context.prototype = { | |
constructor: Context, | |
reset: function() { | |
this.next = 0; | |
this.sent = void 0; | |
this.tryStack = []; | |
this.done = false; | |
this.delegate = null; | |
// Pre-initialize at least 20 temporary variables to enable hidden | |
// class optimizations for simple generators. | |
for (var tempIndex = 0, tempName; | |
hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20; | |
++tempIndex) { | |
this[tempName] = null; | |
} | |
}, | |
stop: function() { | |
this.done = true; | |
if (hasOwn.call(this, "thrown")) { | |
var thrown = this.thrown; | |
delete this.thrown; | |
throw thrown; | |
} | |
return this.rval; | |
}, | |
keys: function(object) { | |
return Object.keys(object).reverse(); | |
}, | |
pushTry: function(catchLoc, finallyLoc, finallyTempVar) { | |
if (finallyLoc) { | |
this.tryStack.push({ | |
finallyLoc: finallyLoc, | |
finallyTempVar: finallyTempVar | |
}); | |
} | |
if (catchLoc) { | |
this.tryStack.push({ | |
catchLoc: catchLoc | |
}); | |
} | |
}, | |
popCatch: function(catchLoc) { | |
var lastIndex = this.tryStack.length - 1; | |
var entry = this.tryStack[lastIndex]; | |
if (entry && entry.catchLoc === catchLoc) { | |
this.tryStack.length = lastIndex; | |
} | |
}, | |
popFinally: function(finallyLoc) { | |
var lastIndex = this.tryStack.length - 1; | |
var entry = this.tryStack[lastIndex]; | |
if (!entry || !hasOwn.call(entry, "finallyLoc")) { | |
entry = this.tryStack[--lastIndex]; | |
} | |
if (entry && entry.finallyLoc === finallyLoc) { | |
this.tryStack.length = lastIndex; | |
} | |
}, | |
dispatchException: function(exception) { | |
var finallyEntries = []; | |
var dispatched = false; | |
if (this.done) { | |
throw exception; | |
} | |
// Dispatch the exception to the "end" location by default. | |
this.thrown = exception; | |
this.next = "end"; | |
for (var i = this.tryStack.length - 1; i >= 0; --i) { | |
var entry = this.tryStack[i]; | |
if (entry.catchLoc) { | |
this.next = entry.catchLoc; | |
dispatched = true; | |
break; | |
} else if (entry.finallyLoc) { | |
finallyEntries.push(entry); | |
dispatched = true; | |
} | |
} | |
while ((entry = finallyEntries.pop())) { | |
this[entry.finallyTempVar] = this.next; | |
this.next = entry.finallyLoc; | |
} | |
}, | |
delegateYield: function(generator, resultName, nextLoc) { | |
var info = generator.next(this.sent); | |
if (info.done) { | |
this.delegate = null; | |
this[resultName] = info.value; | |
this.next = nextLoc; | |
return ContinueSentinel; | |
} | |
this.delegate = { | |
generator: generator, | |
resultName: resultName, | |
nextLoc: nextLoc | |
}; | |
return info.value; | |
} | |
}; | |
}).apply(this, Function("return [this, function GeneratorFunction(){}]")()); | |
},{}]},{},[1]) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment