/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/debuggability.js |
@@ -0,0 +1,916 @@ |
"use strict"; |
module.exports = function(Promise, Context) { |
var getDomain = Promise._getDomain; |
var async = Promise._async; |
var Warning = require("./errors").Warning; |
var util = require("./util"); |
var canAttachTrace = util.canAttachTrace; |
var unhandledRejectionHandled; |
var possiblyUnhandledRejection; |
var bluebirdFramePattern = |
/[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/; |
var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/; |
var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/; |
var stackFramePattern = null; |
var formatStack = null; |
var indentStackFrames = false; |
var printWarning; |
var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 && |
(false || |
util.env("BLUEBIRD_DEBUG") || |
util.env("NODE_ENV") === "development")); |
|
var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 && |
(debugging || util.env("BLUEBIRD_WARNINGS"))); |
|
var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 && |
(debugging || util.env("BLUEBIRD_LONG_STACK_TRACES"))); |
|
var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 && |
(warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN")); |
|
Promise.prototype.suppressUnhandledRejections = function() { |
var target = this._target(); |
target._bitField = ((target._bitField & (~1048576)) | |
524288); |
}; |
|
Promise.prototype._ensurePossibleRejectionHandled = function () { |
if ((this._bitField & 524288) !== 0) return; |
this._setRejectionIsUnhandled(); |
async.invokeLater(this._notifyUnhandledRejection, this, undefined); |
}; |
|
Promise.prototype._notifyUnhandledRejectionIsHandled = function () { |
fireRejectionEvent("rejectionHandled", |
unhandledRejectionHandled, undefined, this); |
}; |
|
Promise.prototype._setReturnedNonUndefined = function() { |
this._bitField = this._bitField | 268435456; |
}; |
|
Promise.prototype._returnedNonUndefined = function() { |
return (this._bitField & 268435456) !== 0; |
}; |
|
Promise.prototype._notifyUnhandledRejection = function () { |
if (this._isRejectionUnhandled()) { |
var reason = this._settledValue(); |
this._setUnhandledRejectionIsNotified(); |
fireRejectionEvent("unhandledRejection", |
possiblyUnhandledRejection, reason, this); |
} |
}; |
|
Promise.prototype._setUnhandledRejectionIsNotified = function () { |
this._bitField = this._bitField | 262144; |
}; |
|
Promise.prototype._unsetUnhandledRejectionIsNotified = function () { |
this._bitField = this._bitField & (~262144); |
}; |
|
Promise.prototype._isUnhandledRejectionNotified = function () { |
return (this._bitField & 262144) > 0; |
}; |
|
Promise.prototype._setRejectionIsUnhandled = function () { |
this._bitField = this._bitField | 1048576; |
}; |
|
Promise.prototype._unsetRejectionIsUnhandled = function () { |
this._bitField = this._bitField & (~1048576); |
if (this._isUnhandledRejectionNotified()) { |
this._unsetUnhandledRejectionIsNotified(); |
this._notifyUnhandledRejectionIsHandled(); |
} |
}; |
|
Promise.prototype._isRejectionUnhandled = function () { |
return (this._bitField & 1048576) > 0; |
}; |
|
Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) { |
return warn(message, shouldUseOwnTrace, promise || this); |
}; |
|
Promise.onPossiblyUnhandledRejection = function (fn) { |
var domain = getDomain(); |
possiblyUnhandledRejection = |
typeof fn === "function" ? (domain === null ? |
fn : util.domainBind(domain, fn)) |
: undefined; |
}; |
|
Promise.onUnhandledRejectionHandled = function (fn) { |
var domain = getDomain(); |
unhandledRejectionHandled = |
typeof fn === "function" ? (domain === null ? |
fn : util.domainBind(domain, fn)) |
: undefined; |
}; |
|
var disableLongStackTraces = function() {}; |
Promise.longStackTraces = function () { |
if (async.haveItemsQueued() && !config.longStackTraces) { |
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
if (!config.longStackTraces && longStackTracesIsSupported()) { |
var Promise_captureStackTrace = Promise.prototype._captureStackTrace; |
var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace; |
config.longStackTraces = true; |
disableLongStackTraces = function() { |
if (async.haveItemsQueued() && !config.longStackTraces) { |
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
Promise.prototype._captureStackTrace = Promise_captureStackTrace; |
Promise.prototype._attachExtraTrace = Promise_attachExtraTrace; |
Context.deactivateLongStackTraces(); |
async.enableTrampoline(); |
config.longStackTraces = false; |
}; |
Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace; |
Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace; |
Context.activateLongStackTraces(); |
async.disableTrampolineIfNecessary(); |
} |
}; |
|
Promise.hasLongStackTraces = function () { |
return config.longStackTraces && longStackTracesIsSupported(); |
}; |
|
var fireDomEvent = (function() { |
try { |
if (typeof CustomEvent === "function") { |
var event = new CustomEvent("CustomEvent"); |
util.global.dispatchEvent(event); |
return function(name, event) { |
var domEvent = new CustomEvent(name.toLowerCase(), { |
detail: event, |
cancelable: true |
}); |
return !util.global.dispatchEvent(domEvent); |
}; |
} else if (typeof Event === "function") { |
var event = new Event("CustomEvent"); |
util.global.dispatchEvent(event); |
return function(name, event) { |
var domEvent = new Event(name.toLowerCase(), { |
cancelable: true |
}); |
domEvent.detail = event; |
return !util.global.dispatchEvent(domEvent); |
}; |
} else { |
var event = document.createEvent("CustomEvent"); |
event.initCustomEvent("testingtheevent", false, true, {}); |
util.global.dispatchEvent(event); |
return function(name, event) { |
var domEvent = document.createEvent("CustomEvent"); |
domEvent.initCustomEvent(name.toLowerCase(), false, true, |
event); |
return !util.global.dispatchEvent(domEvent); |
}; |
} |
} catch (e) {} |
return function() { |
return false; |
}; |
})(); |
|
var fireGlobalEvent = (function() { |
if (util.isNode) { |
return function() { |
return process.emit.apply(process, arguments); |
}; |
} else { |
if (!util.global) { |
return function() { |
return false; |
}; |
} |
return function(name) { |
var methodName = "on" + name.toLowerCase(); |
var method = util.global[methodName]; |
if (!method) return false; |
method.apply(util.global, [].slice.call(arguments, 1)); |
return true; |
}; |
} |
})(); |
|
function generatePromiseLifecycleEventObject(name, promise) { |
return {promise: promise}; |
} |
|
var eventToObjectGenerator = { |
promiseCreated: generatePromiseLifecycleEventObject, |
promiseFulfilled: generatePromiseLifecycleEventObject, |
promiseRejected: generatePromiseLifecycleEventObject, |
promiseResolved: generatePromiseLifecycleEventObject, |
promiseCancelled: generatePromiseLifecycleEventObject, |
promiseChained: function(name, promise, child) { |
return {promise: promise, child: child}; |
}, |
warning: function(name, warning) { |
return {warning: warning}; |
}, |
unhandledRejection: function (name, reason, promise) { |
return {reason: reason, promise: promise}; |
}, |
rejectionHandled: generatePromiseLifecycleEventObject |
}; |
|
var activeFireEvent = function (name) { |
var globalEventFired = false; |
try { |
globalEventFired = fireGlobalEvent.apply(null, arguments); |
} catch (e) { |
async.throwLater(e); |
globalEventFired = true; |
} |
|
var domEventFired = false; |
try { |
domEventFired = fireDomEvent(name, |
eventToObjectGenerator[name].apply(null, arguments)); |
} catch (e) { |
async.throwLater(e); |
domEventFired = true; |
} |
|
return domEventFired || globalEventFired; |
}; |
|
Promise.config = function(opts) { |
opts = Object(opts); |
if ("longStackTraces" in opts) { |
if (opts.longStackTraces) { |
Promise.longStackTraces(); |
} else if (!opts.longStackTraces && Promise.hasLongStackTraces()) { |
disableLongStackTraces(); |
} |
} |
if ("warnings" in opts) { |
var warningsOption = opts.warnings; |
config.warnings = !!warningsOption; |
wForgottenReturn = config.warnings; |
|
if (util.isObject(warningsOption)) { |
if ("wForgottenReturn" in warningsOption) { |
wForgottenReturn = !!warningsOption.wForgottenReturn; |
} |
} |
} |
if ("cancellation" in opts && opts.cancellation && !config.cancellation) { |
if (async.haveItemsQueued()) { |
throw new Error( |
"cannot enable cancellation after promises are in use"); |
} |
Promise.prototype._clearCancellationData = |
cancellationClearCancellationData; |
Promise.prototype._propagateFrom = cancellationPropagateFrom; |
Promise.prototype._onCancel = cancellationOnCancel; |
Promise.prototype._setOnCancel = cancellationSetOnCancel; |
Promise.prototype._attachCancellationCallback = |
cancellationAttachCancellationCallback; |
Promise.prototype._execute = cancellationExecute; |
propagateFromFunction = cancellationPropagateFrom; |
config.cancellation = true; |
} |
if ("monitoring" in opts) { |
if (opts.monitoring && !config.monitoring) { |
config.monitoring = true; |
Promise.prototype._fireEvent = activeFireEvent; |
} else if (!opts.monitoring && config.monitoring) { |
config.monitoring = false; |
Promise.prototype._fireEvent = defaultFireEvent; |
} |
} |
return Promise; |
}; |
|
function defaultFireEvent() { return false; } |
|
Promise.prototype._fireEvent = defaultFireEvent; |
Promise.prototype._execute = function(executor, resolve, reject) { |
try { |
executor(resolve, reject); |
} catch (e) { |
return e; |
} |
}; |
Promise.prototype._onCancel = function () {}; |
Promise.prototype._setOnCancel = function (handler) { ; }; |
Promise.prototype._attachCancellationCallback = function(onCancel) { |
; |
}; |
Promise.prototype._captureStackTrace = function () {}; |
Promise.prototype._attachExtraTrace = function () {}; |
Promise.prototype._clearCancellationData = function() {}; |
Promise.prototype._propagateFrom = function (parent, flags) { |
; |
; |
}; |
|
function cancellationExecute(executor, resolve, reject) { |
var promise = this; |
try { |
executor(resolve, reject, function(onCancel) { |
if (typeof onCancel !== "function") { |
throw new TypeError("onCancel must be a function, got: " + |
util.toString(onCancel)); |
} |
promise._attachCancellationCallback(onCancel); |
}); |
} catch (e) { |
return e; |
} |
} |
|
function cancellationAttachCancellationCallback(onCancel) { |
if (!this._isCancellable()) return this; |
|
var previousOnCancel = this._onCancel(); |
if (previousOnCancel !== undefined) { |
if (util.isArray(previousOnCancel)) { |
previousOnCancel.push(onCancel); |
} else { |
this._setOnCancel([previousOnCancel, onCancel]); |
} |
} else { |
this._setOnCancel(onCancel); |
} |
} |
|
function cancellationOnCancel() { |
return this._onCancelField; |
} |
|
function cancellationSetOnCancel(onCancel) { |
this._onCancelField = onCancel; |
} |
|
function cancellationClearCancellationData() { |
this._cancellationParent = undefined; |
this._onCancelField = undefined; |
} |
|
function cancellationPropagateFrom(parent, flags) { |
if ((flags & 1) !== 0) { |
this._cancellationParent = parent; |
var branchesRemainingToCancel = parent._branchesRemainingToCancel; |
if (branchesRemainingToCancel === undefined) { |
branchesRemainingToCancel = 0; |
} |
parent._branchesRemainingToCancel = branchesRemainingToCancel + 1; |
} |
if ((flags & 2) !== 0 && parent._isBound()) { |
this._setBoundTo(parent._boundTo); |
} |
} |
|
function bindingPropagateFrom(parent, flags) { |
if ((flags & 2) !== 0 && parent._isBound()) { |
this._setBoundTo(parent._boundTo); |
} |
} |
var propagateFromFunction = bindingPropagateFrom; |
|
function boundValueFunction() { |
var ret = this._boundTo; |
if (ret !== undefined) { |
if (ret instanceof Promise) { |
if (ret.isFulfilled()) { |
return ret.value(); |
} else { |
return undefined; |
} |
} |
} |
return ret; |
} |
|
function longStackTracesCaptureStackTrace() { |
this._trace = new CapturedTrace(this._peekContext()); |
} |
|
function longStackTracesAttachExtraTrace(error, ignoreSelf) { |
if (canAttachTrace(error)) { |
var trace = this._trace; |
if (trace !== undefined) { |
if (ignoreSelf) trace = trace._parent; |
} |
if (trace !== undefined) { |
trace.attachExtraTrace(error); |
} else if (!error.__stackCleaned__) { |
var parsed = parseStackAndMessage(error); |
util.notEnumerableProp(error, "stack", |
parsed.message + "\n" + parsed.stack.join("\n")); |
util.notEnumerableProp(error, "__stackCleaned__", true); |
} |
} |
} |
|
function checkForgottenReturns(returnValue, promiseCreated, name, promise, |
parent) { |
if (returnValue === undefined && promiseCreated !== null && |
wForgottenReturn) { |
if (parent !== undefined && parent._returnedNonUndefined()) return; |
if ((promise._bitField & 65535) === 0) return; |
|
if (name) name = name + " "; |
var handlerLine = ""; |
var creatorLine = ""; |
if (promiseCreated._trace) { |
var traceLines = promiseCreated._trace.stack.split("\n"); |
var stack = cleanStack(traceLines); |
for (var i = stack.length - 1; i >= 0; --i) { |
var line = stack[i]; |
if (!nodeFramePattern.test(line)) { |
var lineMatches = line.match(parseLinePattern); |
if (lineMatches) { |
handlerLine = "at " + lineMatches[1] + |
":" + lineMatches[2] + ":" + lineMatches[3] + " "; |
} |
break; |
} |
} |
|
if (stack.length > 0) { |
var firstUserLine = stack[0]; |
for (var i = 0; i < traceLines.length; ++i) { |
|
if (traceLines[i] === firstUserLine) { |
if (i > 0) { |
creatorLine = "\n" + traceLines[i - 1]; |
} |
break; |
} |
} |
|
} |
} |
var msg = "a promise was created in a " + name + |
"handler " + handlerLine + "but was not returned from it, " + |
"see http://goo.gl/rRqMUw" + |
creatorLine; |
promise._warn(msg, true, promiseCreated); |
} |
} |
|
function deprecated(name, replacement) { |
var message = name + |
" is deprecated and will be removed in a future version."; |
if (replacement) message += " Use " + replacement + " instead."; |
return warn(message); |
} |
|
function warn(message, shouldUseOwnTrace, promise) { |
if (!config.warnings) return; |
var warning = new Warning(message); |
var ctx; |
if (shouldUseOwnTrace) { |
promise._attachExtraTrace(warning); |
} else if (config.longStackTraces && (ctx = Promise._peekContext())) { |
ctx.attachExtraTrace(warning); |
} else { |
var parsed = parseStackAndMessage(warning); |
warning.stack = parsed.message + "\n" + parsed.stack.join("\n"); |
} |
|
if (!activeFireEvent("warning", warning)) { |
formatAndLogError(warning, "", true); |
} |
} |
|
function reconstructStack(message, stacks) { |
for (var i = 0; i < stacks.length - 1; ++i) { |
stacks[i].push("From previous event:"); |
stacks[i] = stacks[i].join("\n"); |
} |
if (i < stacks.length) { |
stacks[i] = stacks[i].join("\n"); |
} |
return message + "\n" + stacks.join("\n"); |
} |
|
function removeDuplicateOrEmptyJumps(stacks) { |
for (var i = 0; i < stacks.length; ++i) { |
if (stacks[i].length === 0 || |
((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) { |
stacks.splice(i, 1); |
i--; |
} |
} |
} |
|
function removeCommonRoots(stacks) { |
var current = stacks[0]; |
for (var i = 1; i < stacks.length; ++i) { |
var prev = stacks[i]; |
var currentLastIndex = current.length - 1; |
var currentLastLine = current[currentLastIndex]; |
var commonRootMeetPoint = -1; |
|
for (var j = prev.length - 1; j >= 0; --j) { |
if (prev[j] === currentLastLine) { |
commonRootMeetPoint = j; |
break; |
} |
} |
|
for (var j = commonRootMeetPoint; j >= 0; --j) { |
var line = prev[j]; |
if (current[currentLastIndex] === line) { |
current.pop(); |
currentLastIndex--; |
} else { |
break; |
} |
} |
current = prev; |
} |
} |
|
function cleanStack(stack) { |
var ret = []; |
for (var i = 0; i < stack.length; ++i) { |
var line = stack[i]; |
var isTraceLine = " (No stack trace)" === line || |
stackFramePattern.test(line); |
var isInternalFrame = isTraceLine && shouldIgnore(line); |
if (isTraceLine && !isInternalFrame) { |
if (indentStackFrames && line.charAt(0) !== " ") { |
line = " " + line; |
} |
ret.push(line); |
} |
} |
return ret; |
} |
|
function stackFramesAsArray(error) { |
var stack = error.stack.replace(/\s+$/g, "").split("\n"); |
for (var i = 0; i < stack.length; ++i) { |
var line = stack[i]; |
if (" (No stack trace)" === line || stackFramePattern.test(line)) { |
break; |
} |
} |
if (i > 0 && error.name != "SyntaxError") { |
stack = stack.slice(i); |
} |
return stack; |
} |
|
function parseStackAndMessage(error) { |
var stack = error.stack; |
var message = error.toString(); |
stack = typeof stack === "string" && stack.length > 0 |
? stackFramesAsArray(error) : [" (No stack trace)"]; |
return { |
message: message, |
stack: error.name == "SyntaxError" ? stack : cleanStack(stack) |
}; |
} |
|
function formatAndLogError(error, title, isSoft) { |
if (typeof console !== "undefined") { |
var message; |
if (util.isObject(error)) { |
var stack = error.stack; |
message = title + formatStack(stack, error); |
} else { |
message = title + String(error); |
} |
if (typeof printWarning === "function") { |
printWarning(message, isSoft); |
} else if (typeof console.log === "function" || |
typeof console.log === "object") { |
console.log(message); |
} |
} |
} |
|
function fireRejectionEvent(name, localHandler, reason, promise) { |
var localEventFired = false; |
try { |
if (typeof localHandler === "function") { |
localEventFired = true; |
if (name === "rejectionHandled") { |
localHandler(promise); |
} else { |
localHandler(reason, promise); |
} |
} |
} catch (e) { |
async.throwLater(e); |
} |
|
if (name === "unhandledRejection") { |
if (!activeFireEvent(name, reason, promise) && !localEventFired) { |
formatAndLogError(reason, "Unhandled rejection "); |
} |
} else { |
activeFireEvent(name, promise); |
} |
} |
|
function formatNonError(obj) { |
var str; |
if (typeof obj === "function") { |
str = "[function " + |
(obj.name || "anonymous") + |
"]"; |
} else { |
str = obj && typeof obj.toString === "function" |
? obj.toString() : util.toString(obj); |
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 longStackTracesIsSupported() { |
return typeof captureStackTrace === "function"; |
} |
|
var shouldIgnore = function() { return false; }; |
var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/; |
function parseLineInfo(line) { |
var matches = line.match(parseLineInfoRegex); |
if (matches) { |
return { |
fileName: matches[1], |
line: parseInt(matches[2], 10) |
}; |
} |
} |
|
function setBounds(firstLineError, lastLineError) { |
if (!longStackTracesIsSupported()) return; |
var firstStackLines = firstLineError.stack.split("\n"); |
var lastStackLines = lastLineError.stack.split("\n"); |
var firstIndex = -1; |
var lastIndex = -1; |
var firstFileName; |
var lastFileName; |
for (var i = 0; i < firstStackLines.length; ++i) { |
var result = parseLineInfo(firstStackLines[i]); |
if (result) { |
firstFileName = result.fileName; |
firstIndex = result.line; |
break; |
} |
} |
for (var i = 0; i < lastStackLines.length; ++i) { |
var result = parseLineInfo(lastStackLines[i]); |
if (result) { |
lastFileName = result.fileName; |
lastIndex = result.line; |
break; |
} |
} |
if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName || |
firstFileName !== lastFileName || firstIndex >= lastIndex) { |
return; |
} |
|
shouldIgnore = function(line) { |
if (bluebirdFramePattern.test(line)) return true; |
var info = parseLineInfo(line); |
if (info) { |
if (info.fileName === firstFileName && |
(firstIndex <= info.line && info.line <= lastIndex)) { |
return true; |
} |
} |
return false; |
}; |
} |
|
function CapturedTrace(parent) { |
this._parent = parent; |
this._promisesCreated = 0; |
var length = this._length = 1 + (parent === undefined ? 0 : parent._length); |
captureStackTrace(this, CapturedTrace); |
if (length > 32) this.uncycle(); |
} |
util.inherits(CapturedTrace, Error); |
Context.CapturedTrace = CapturedTrace; |
|
CapturedTrace.prototype.uncycle = function() { |
var length = this._length; |
if (length < 2) return; |
var nodes = []; |
var stackToIndex = {}; |
|
for (var i = 0, node = this; node !== undefined; ++i) { |
nodes.push(node); |
node = node._parent; |
} |
length = this._length = i; |
for (var i = length - 1; i >= 0; --i) { |
var stack = nodes[i].stack; |
if (stackToIndex[stack] === undefined) { |
stackToIndex[stack] = i; |
} |
} |
for (var i = 0; i < length; ++i) { |
var currentStack = nodes[i].stack; |
var index = stackToIndex[currentStack]; |
if (index !== undefined && index !== i) { |
if (index > 0) { |
nodes[index - 1]._parent = undefined; |
nodes[index - 1]._length = 1; |
} |
nodes[i]._parent = undefined; |
nodes[i]._length = 1; |
var cycleEdgeNode = i > 0 ? nodes[i - 1] : this; |
|
if (index < length - 1) { |
cycleEdgeNode._parent = nodes[index + 1]; |
cycleEdgeNode._parent.uncycle(); |
cycleEdgeNode._length = |
cycleEdgeNode._parent._length + 1; |
} else { |
cycleEdgeNode._parent = undefined; |
cycleEdgeNode._length = 1; |
} |
var currentChildLength = cycleEdgeNode._length + 1; |
for (var j = i - 2; j >= 0; --j) { |
nodes[j]._length = currentChildLength; |
currentChildLength++; |
} |
return; |
} |
} |
}; |
|
CapturedTrace.prototype.attachExtraTrace = function(error) { |
if (error.__stackCleaned__) return; |
this.uncycle(); |
var parsed = parseStackAndMessage(error); |
var message = parsed.message; |
var stacks = [parsed.stack]; |
|
var trace = this; |
while (trace !== undefined) { |
stacks.push(cleanStack(trace.stack.split("\n"))); |
trace = trace._parent; |
} |
removeCommonRoots(stacks); |
removeDuplicateOrEmptyJumps(stacks); |
util.notEnumerableProp(error, "stack", reconstructStack(message, stacks)); |
util.notEnumerableProp(error, "__stackCleaned__", true); |
}; |
|
var captureStackTrace = (function stackDetection() { |
var v8stackFramePattern = /^\s*at\s*/; |
var v8stackFormatter = function(stack, error) { |
if (typeof stack === "string") return stack; |
|
if (error.name !== undefined && |
error.message !== undefined) { |
return error.toString(); |
} |
return formatNonError(error); |
}; |
|
if (typeof Error.stackTraceLimit === "number" && |
typeof Error.captureStackTrace === "function") { |
Error.stackTraceLimit += 6; |
stackFramePattern = v8stackFramePattern; |
formatStack = v8stackFormatter; |
var captureStackTrace = Error.captureStackTrace; |
|
shouldIgnore = function(line) { |
return bluebirdFramePattern.test(line); |
}; |
return function(receiver, ignoreUntil) { |
Error.stackTraceLimit += 6; |
captureStackTrace(receiver, ignoreUntil); |
Error.stackTraceLimit -= 6; |
}; |
} |
var err = new Error(); |
|
if (typeof err.stack === "string" && |
err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) { |
stackFramePattern = /@/; |
formatStack = v8stackFormatter; |
indentStackFrames = true; |
return function captureStackTrace(o) { |
o.stack = new Error().stack; |
}; |
} |
|
var hasStackAfterThrow; |
try { throw new Error(); } |
catch(e) { |
hasStackAfterThrow = ("stack" in e); |
} |
if (!("stack" in err) && hasStackAfterThrow && |
typeof Error.stackTraceLimit === "number") { |
stackFramePattern = v8stackFramePattern; |
formatStack = v8stackFormatter; |
return function captureStackTrace(o) { |
Error.stackTraceLimit += 6; |
try { throw new Error(); } |
catch(e) { o.stack = e.stack; } |
Error.stackTraceLimit -= 6; |
}; |
} |
|
formatStack = function(stack, error) { |
if (typeof stack === "string") return stack; |
|
if ((typeof error === "object" || |
typeof error === "function") && |
error.name !== undefined && |
error.message !== undefined) { |
return error.toString(); |
} |
return formatNonError(error); |
}; |
|
return null; |
|
})([]); |
|
if (typeof console !== "undefined" && typeof console.warn !== "undefined") { |
printWarning = function (message) { |
console.warn(message); |
}; |
if (util.isNode && process.stderr.isTTY) { |
printWarning = function(message, isSoft) { |
var color = isSoft ? "\u001b[33m" : "\u001b[31m"; |
console.warn(color + message + "\u001b[0m\n"); |
}; |
} else if (!util.isNode && typeof (new Error().stack) === "string") { |
printWarning = function(message, isSoft) { |
console.warn("%c" + message, |
isSoft ? "color: darkorange" : "color: red"); |
}; |
} |
} |
|
var config = { |
warnings: warnings, |
longStackTraces: false, |
cancellation: false, |
monitoring: false |
}; |
|
if (longStackTraces) Promise.longStackTraces(); |
|
return { |
longStackTraces: function() { |
return config.longStackTraces; |
}, |
warnings: function() { |
return config.warnings; |
}, |
cancellation: function() { |
return config.cancellation; |
}, |
monitoring: function() { |
return config.monitoring; |
}, |
propagateFromFunction: function() { |
return propagateFromFunction; |
}, |
boundValueFunction: function() { |
return boundValueFunction; |
}, |
checkForgottenReturns: checkForgottenReturns, |
setBounds: setBounds, |
warn: warn, |
deprecated: deprecated, |
CapturedTrace: CapturedTrace, |
fireDomEvent: fireDomEvent, |
fireGlobalEvent: fireGlobalEvent |
}; |
}; |
/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/generators.js |
@@ -0,0 +1,223 @@ |
"use strict"; |
module.exports = function(Promise, |
apiRejection, |
INTERNAL, |
tryConvertToPromise, |
Proxyable, |
debug) { |
var errors = require("./errors"); |
var TypeError = errors.TypeError; |
var util = require("./util"); |
var errorObj = util.errorObj; |
var tryCatch = util.tryCatch; |
var yieldHandlers = []; |
|
function promiseFromYieldHandler(value, yieldHandlers, traceParent) { |
for (var i = 0; i < yieldHandlers.length; ++i) { |
traceParent._pushContext(); |
var result = tryCatch(yieldHandlers[i])(value); |
traceParent._popContext(); |
if (result === errorObj) { |
traceParent._pushContext(); |
var ret = Promise.reject(errorObj.e); |
traceParent._popContext(); |
return ret; |
} |
var maybePromise = tryConvertToPromise(result, traceParent); |
if (maybePromise instanceof Promise) return maybePromise; |
} |
return null; |
} |
|
function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) { |
if (debug.cancellation()) { |
var internal = new Promise(INTERNAL); |
var _finallyPromise = this._finallyPromise = new Promise(INTERNAL); |
this._promise = internal.lastly(function() { |
return _finallyPromise; |
}); |
internal._captureStackTrace(); |
internal._setOnCancel(this); |
} else { |
var promise = this._promise = new Promise(INTERNAL); |
promise._captureStackTrace(); |
} |
this._stack = stack; |
this._generatorFunction = generatorFunction; |
this._receiver = receiver; |
this._generator = undefined; |
this._yieldHandlers = typeof yieldHandler === "function" |
? [yieldHandler].concat(yieldHandlers) |
: yieldHandlers; |
this._yieldedPromise = null; |
this._cancellationPhase = false; |
} |
util.inherits(PromiseSpawn, Proxyable); |
|
PromiseSpawn.prototype._isResolved = function() { |
return this._promise === null; |
}; |
|
PromiseSpawn.prototype._cleanup = function() { |
this._promise = this._generator = null; |
if (debug.cancellation() && this._finallyPromise !== null) { |
this._finallyPromise._fulfill(); |
this._finallyPromise = null; |
} |
}; |
|
PromiseSpawn.prototype._promiseCancelled = function() { |
if (this._isResolved()) return; |
var implementsReturn = typeof this._generator["return"] !== "undefined"; |
|
var result; |
if (!implementsReturn) { |
var reason = new Promise.CancellationError( |
"generator .return() sentinel"); |
Promise.coroutine.returnSentinel = reason; |
this._promise._attachExtraTrace(reason); |
this._promise._pushContext(); |
result = tryCatch(this._generator["throw"]).call(this._generator, |
reason); |
this._promise._popContext(); |
} else { |
this._promise._pushContext(); |
result = tryCatch(this._generator["return"]).call(this._generator, |
undefined); |
this._promise._popContext(); |
} |
this._cancellationPhase = true; |
this._yieldedPromise = null; |
this._continue(result); |
}; |
|
PromiseSpawn.prototype._promiseFulfilled = function(value) { |
this._yieldedPromise = null; |
this._promise._pushContext(); |
var result = tryCatch(this._generator.next).call(this._generator, value); |
this._promise._popContext(); |
this._continue(result); |
}; |
|
PromiseSpawn.prototype._promiseRejected = function(reason) { |
this._yieldedPromise = null; |
this._promise._attachExtraTrace(reason); |
this._promise._pushContext(); |
var result = tryCatch(this._generator["throw"]) |
.call(this._generator, reason); |
this._promise._popContext(); |
this._continue(result); |
}; |
|
PromiseSpawn.prototype._resultCancelled = function() { |
if (this._yieldedPromise instanceof Promise) { |
var promise = this._yieldedPromise; |
this._yieldedPromise = null; |
promise.cancel(); |
} |
}; |
|
PromiseSpawn.prototype.promise = function () { |
return this._promise; |
}; |
|
PromiseSpawn.prototype._run = function () { |
this._generator = this._generatorFunction.call(this._receiver); |
this._receiver = |
this._generatorFunction = undefined; |
this._promiseFulfilled(undefined); |
}; |
|
PromiseSpawn.prototype._continue = function (result) { |
var promise = this._promise; |
if (result === errorObj) { |
this._cleanup(); |
if (this._cancellationPhase) { |
return promise.cancel(); |
} else { |
return promise._rejectCallback(result.e, false); |
} |
} |
|
var value = result.value; |
if (result.done === true) { |
this._cleanup(); |
if (this._cancellationPhase) { |
return promise.cancel(); |
} else { |
return promise._resolveCallback(value); |
} |
} else { |
var maybePromise = tryConvertToPromise(value, this._promise); |
if (!(maybePromise instanceof Promise)) { |
maybePromise = |
promiseFromYieldHandler(maybePromise, |
this._yieldHandlers, |
this._promise); |
if (maybePromise === null) { |
this._promiseRejected( |
new TypeError( |
"A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", String(value)) + |
"From coroutine:\u000a" + |
this._stack.split("\n").slice(1, -7).join("\n") |
) |
); |
return; |
} |
} |
maybePromise = maybePromise._target(); |
var bitField = maybePromise._bitField; |
; |
if (((bitField & 50397184) === 0)) { |
this._yieldedPromise = maybePromise; |
maybePromise._proxy(this, null); |
} else if (((bitField & 33554432) !== 0)) { |
Promise._async.invoke( |
this._promiseFulfilled, this, maybePromise._value() |
); |
} else if (((bitField & 16777216) !== 0)) { |
Promise._async.invoke( |
this._promiseRejected, this, maybePromise._reason() |
); |
} else { |
this._promiseCancelled(); |
} |
} |
}; |
|
Promise.coroutine = function (generatorFunction, options) { |
if (typeof generatorFunction !== "function") { |
throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
var yieldHandler = Object(options).yieldHandler; |
var PromiseSpawn$ = PromiseSpawn; |
var stack = new Error().stack; |
return function () { |
var generator = generatorFunction.apply(this, arguments); |
var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler, |
stack); |
var ret = spawn.promise(); |
spawn._generator = generator; |
spawn._promiseFulfilled(undefined); |
return ret; |
}; |
}; |
|
Promise.coroutine.addYieldHandler = function(fn) { |
if (typeof fn !== "function") { |
throw new TypeError("expecting a function but got " + util.classString(fn)); |
} |
yieldHandlers.push(fn); |
}; |
|
Promise.spawn = function (generatorFunction) { |
debug.deprecated("Promise.spawn()", "Promise.coroutine()"); |
if (typeof generatorFunction !== "function") { |
return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
var spawn = new PromiseSpawn(generatorFunction, this); |
var ret = spawn.promise(); |
spawn._run(Promise.spawn); |
return ret; |
}; |
}; |
/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/promise.js |
@@ -0,0 +1,775 @@ |
"use strict"; |
module.exports = function() { |
var makeSelfResolutionError = function () { |
return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
}; |
var reflectHandler = function() { |
return new Promise.PromiseInspection(this._target()); |
}; |
var apiRejection = function(msg) { |
return Promise.reject(new TypeError(msg)); |
}; |
function Proxyable() {} |
var UNDEFINED_BINDING = {}; |
var util = require("./util"); |
|
var getDomain; |
if (util.isNode) { |
getDomain = function() { |
var ret = process.domain; |
if (ret === undefined) ret = null; |
return ret; |
}; |
} else { |
getDomain = function() { |
return null; |
}; |
} |
util.notEnumerableProp(Promise, "_getDomain", getDomain); |
|
var es5 = require("./es5"); |
var Async = require("./async"); |
var async = new Async(); |
es5.defineProperty(Promise, "_async", {value: async}); |
var errors = require("./errors"); |
var TypeError = Promise.TypeError = errors.TypeError; |
Promise.RangeError = errors.RangeError; |
var CancellationError = Promise.CancellationError = errors.CancellationError; |
Promise.TimeoutError = errors.TimeoutError; |
Promise.OperationalError = errors.OperationalError; |
Promise.RejectionError = errors.OperationalError; |
Promise.AggregateError = errors.AggregateError; |
var INTERNAL = function(){}; |
var APPLY = {}; |
var NEXT_FILTER = {}; |
var tryConvertToPromise = require("./thenables")(Promise, INTERNAL); |
var PromiseArray = |
require("./promise_array")(Promise, INTERNAL, |
tryConvertToPromise, apiRejection, Proxyable); |
var Context = require("./context")(Promise); |
/*jshint unused:false*/ |
var createContext = Context.create; |
var debug = require("./debuggability")(Promise, Context); |
var CapturedTrace = debug.CapturedTrace; |
var PassThroughHandlerContext = |
require("./finally")(Promise, tryConvertToPromise, NEXT_FILTER); |
var catchFilter = require("./catch_filter")(NEXT_FILTER); |
var nodebackForPromise = require("./nodeback"); |
var errorObj = util.errorObj; |
var tryCatch = util.tryCatch; |
function check(self, executor) { |
if (self == null || self.constructor !== Promise) { |
throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
if (typeof executor !== "function") { |
throw new TypeError("expecting a function but got " + util.classString(executor)); |
} |
|
} |
|
function Promise(executor) { |
if (executor !== INTERNAL) { |
check(this, executor); |
} |
this._bitField = 0; |
this._fulfillmentHandler0 = undefined; |
this._rejectionHandler0 = undefined; |
this._promise0 = undefined; |
this._receiver0 = undefined; |
this._resolveFromExecutor(executor); |
this._promiseCreated(); |
this._fireEvent("promiseCreated", this); |
} |
|
Promise.prototype.toString = function () { |
return "[object Promise]"; |
}; |
|
Promise.prototype.caught = Promise.prototype["catch"] = function (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 (util.isObject(item)) { |
catchInstances[j++] = item; |
} else { |
return apiRejection("Catch statement predicate: " + |
"expecting an object but got " + util.classString(item)); |
} |
} |
catchInstances.length = j; |
fn = arguments[i]; |
return this.then(undefined, catchFilter(catchInstances, fn, this)); |
} |
return this.then(undefined, fn); |
}; |
|
Promise.prototype.reflect = function () { |
return this._then(reflectHandler, |
reflectHandler, undefined, this, undefined); |
}; |
|
Promise.prototype.then = function (didFulfill, didReject) { |
if (debug.warnings() && arguments.length > 0 && |
typeof didFulfill !== "function" && |
typeof didReject !== "function") { |
var msg = ".then() only accepts functions but was passed: " + |
util.classString(didFulfill); |
if (arguments.length > 1) { |
msg += ", " + util.classString(didReject); |
} |
this._warn(msg); |
} |
return this._then(didFulfill, didReject, undefined, undefined, undefined); |
}; |
|
Promise.prototype.done = function (didFulfill, didReject) { |
var promise = |
this._then(didFulfill, didReject, undefined, undefined, undefined); |
promise._setIsFinal(); |
}; |
|
Promise.prototype.spread = function (fn) { |
if (typeof fn !== "function") { |
return apiRejection("expecting a function but got " + util.classString(fn)); |
} |
return this.all()._then(fn, undefined, undefined, APPLY, undefined); |
}; |
|
Promise.prototype.toJSON = function () { |
var ret = { |
isFulfilled: false, |
isRejected: false, |
fulfillmentValue: undefined, |
rejectionReason: undefined |
}; |
if (this.isFulfilled()) { |
ret.fulfillmentValue = this.value(); |
ret.isFulfilled = true; |
} else if (this.isRejected()) { |
ret.rejectionReason = this.reason(); |
ret.isRejected = true; |
} |
return ret; |
}; |
|
Promise.prototype.all = function () { |
if (arguments.length > 0) { |
this._warn(".all() was passed arguments but it does not take any"); |
} |
return new PromiseArray(this).promise(); |
}; |
|
Promise.prototype.error = function (fn) { |
return this.caught(util.originatesFromRejection, fn); |
}; |
|
Promise.getNewLibraryCopy = module.exports; |
|
Promise.is = function (val) { |
return val instanceof Promise; |
}; |
|
Promise.fromNode = Promise.fromCallback = function(fn) { |
var ret = new Promise(INTERNAL); |
ret._captureStackTrace(); |
var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs |
: false; |
var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs)); |
if (result === errorObj) { |
ret._rejectCallback(result.e, true); |
} |
if (!ret._isFateSealed()) ret._setAsyncGuaranteed(); |
return ret; |
}; |
|
Promise.all = function (promises) { |
return new PromiseArray(promises).promise(); |
}; |
|
Promise.cast = function (obj) { |
var ret = tryConvertToPromise(obj); |
if (!(ret instanceof Promise)) { |
ret = new Promise(INTERNAL); |
ret._captureStackTrace(); |
ret._setFulfilled(); |
ret._rejectionHandler0 = obj; |
} |
return ret; |
}; |
|
Promise.resolve = Promise.fulfilled = Promise.cast; |
|
Promise.reject = Promise.rejected = function (reason) { |
var ret = new Promise(INTERNAL); |
ret._captureStackTrace(); |
ret._rejectCallback(reason, true); |
return ret; |
}; |
|
Promise.setScheduler = function(fn) { |
if (typeof fn !== "function") { |
throw new TypeError("expecting a function but got " + util.classString(fn)); |
} |
return async.setScheduler(fn); |
}; |
|
Promise.prototype._then = function ( |
didFulfill, |
didReject, |
_, receiver, |
internalData |
) { |
var haveInternalData = internalData !== undefined; |
var promise = haveInternalData ? internalData : new Promise(INTERNAL); |
var target = this._target(); |
var bitField = target._bitField; |
|
if (!haveInternalData) { |
promise._propagateFrom(this, 3); |
promise._captureStackTrace(); |
if (receiver === undefined && |
((this._bitField & 2097152) !== 0)) { |
if (!((bitField & 50397184) === 0)) { |
receiver = this._boundValue(); |
} else { |
receiver = target === this ? undefined : this._boundTo; |
} |
} |
this._fireEvent("promiseChained", this, promise); |
} |
|
var domain = getDomain(); |
if (!((bitField & 50397184) === 0)) { |
var handler, value, settler = target._settlePromiseCtx; |
if (((bitField & 33554432) !== 0)) { |
value = target._rejectionHandler0; |
handler = didFulfill; |
} else if (((bitField & 16777216) !== 0)) { |
value = target._fulfillmentHandler0; |
handler = didReject; |
target._unsetRejectionIsUnhandled(); |
} else { |
settler = target._settlePromiseLateCancellationObserver; |
value = new CancellationError("late cancellation observer"); |
target._attachExtraTrace(value); |
handler = didReject; |
} |
|
async.invoke(settler, target, { |
handler: domain === null ? handler |
: (typeof handler === "function" && |
util.domainBind(domain, handler)), |
promise: promise, |
receiver: receiver, |
value: value |
}); |
} else { |
target._addCallbacks(didFulfill, didReject, promise, receiver, domain); |
} |
|
return promise; |
}; |
|
Promise.prototype._length = function () { |
return this._bitField & 65535; |
}; |
|
Promise.prototype._isFateSealed = function () { |
return (this._bitField & 117506048) !== 0; |
}; |
|
Promise.prototype._isFollowing = function () { |
return (this._bitField & 67108864) === 67108864; |
}; |
|
Promise.prototype._setLength = function (len) { |
this._bitField = (this._bitField & -65536) | |
(len & 65535); |
}; |
|
Promise.prototype._setFulfilled = function () { |
this._bitField = this._bitField | 33554432; |
this._fireEvent("promiseFulfilled", this); |
}; |
|
Promise.prototype._setRejected = function () { |
this._bitField = this._bitField | 16777216; |
this._fireEvent("promiseRejected", this); |
}; |
|
Promise.prototype._setFollowing = function () { |
this._bitField = this._bitField | 67108864; |
this._fireEvent("promiseResolved", this); |
}; |
|
Promise.prototype._setIsFinal = function () { |
this._bitField = this._bitField | 4194304; |
}; |
|
Promise.prototype._isFinal = function () { |
return (this._bitField & 4194304) > 0; |
}; |
|
Promise.prototype._unsetCancelled = function() { |
this._bitField = this._bitField & (~65536); |
}; |
|
Promise.prototype._setCancelled = function() { |
this._bitField = this._bitField | 65536; |
this._fireEvent("promiseCancelled", this); |
}; |
|
Promise.prototype._setWillBeCancelled = function() { |
this._bitField = this._bitField | 8388608; |
}; |
|
Promise.prototype._setAsyncGuaranteed = function() { |
if (async.hasCustomScheduler()) return; |
this._bitField = this._bitField | 134217728; |
}; |
|
Promise.prototype._receiverAt = function (index) { |
var ret = index === 0 ? this._receiver0 : this[ |
index * 4 - 4 + 3]; |
if (ret === UNDEFINED_BINDING) { |
return undefined; |
} else if (ret === undefined && this._isBound()) { |
return this._boundValue(); |
} |
return ret; |
}; |
|
Promise.prototype._promiseAt = function (index) { |
return this[ |
index * 4 - 4 + 2]; |
}; |
|
Promise.prototype._fulfillmentHandlerAt = function (index) { |
return this[ |
index * 4 - 4 + 0]; |
}; |
|
Promise.prototype._rejectionHandlerAt = function (index) { |
return this[ |
index * 4 - 4 + 1]; |
}; |
|
Promise.prototype._boundValue = function() {}; |
|
Promise.prototype._migrateCallback0 = function (follower) { |
var bitField = follower._bitField; |
var fulfill = follower._fulfillmentHandler0; |
var reject = follower._rejectionHandler0; |
var promise = follower._promise0; |
var receiver = follower._receiverAt(0); |
if (receiver === undefined) receiver = UNDEFINED_BINDING; |
this._addCallbacks(fulfill, reject, promise, receiver, null); |
}; |
|
Promise.prototype._migrateCallbackAt = function (follower, index) { |
var fulfill = follower._fulfillmentHandlerAt(index); |
var reject = follower._rejectionHandlerAt(index); |
var promise = follower._promiseAt(index); |
var receiver = follower._receiverAt(index); |
if (receiver === undefined) receiver = UNDEFINED_BINDING; |
this._addCallbacks(fulfill, reject, promise, receiver, null); |
}; |
|
Promise.prototype._addCallbacks = function ( |
fulfill, |
reject, |
promise, |
receiver, |
domain |
) { |
var index = this._length(); |
|
if (index >= 65535 - 4) { |
index = 0; |
this._setLength(0); |
} |
|
if (index === 0) { |
this._promise0 = promise; |
this._receiver0 = receiver; |
if (typeof fulfill === "function") { |
this._fulfillmentHandler0 = |
domain === null ? fulfill : util.domainBind(domain, fulfill); |
} |
if (typeof reject === "function") { |
this._rejectionHandler0 = |
domain === null ? reject : util.domainBind(domain, reject); |
} |
} else { |
var base = index * 4 - 4; |
this[base + 2] = promise; |
this[base + 3] = receiver; |
if (typeof fulfill === "function") { |
this[base + 0] = |
domain === null ? fulfill : util.domainBind(domain, fulfill); |
} |
if (typeof reject === "function") { |
this[base + 1] = |
domain === null ? reject : util.domainBind(domain, reject); |
} |
} |
this._setLength(index + 1); |
return index; |
}; |
|
Promise.prototype._proxy = function (proxyable, arg) { |
this._addCallbacks(undefined, undefined, arg, proxyable, null); |
}; |
|
Promise.prototype._resolveCallback = function(value, shouldBind) { |
if (((this._bitField & 117506048) !== 0)) return; |
if (value === this) |
return this._rejectCallback(makeSelfResolutionError(), false); |
var maybePromise = tryConvertToPromise(value, this); |
if (!(maybePromise instanceof Promise)) return this._fulfill(value); |
|
if (shouldBind) this._propagateFrom(maybePromise, 2); |
|
var promise = maybePromise._target(); |
|
if (promise === this) { |
this._reject(makeSelfResolutionError()); |
return; |
} |
|
var bitField = promise._bitField; |
if (((bitField & 50397184) === 0)) { |
var len = this._length(); |
if (len > 0) promise._migrateCallback0(this); |
for (var i = 1; i < len; ++i) { |
promise._migrateCallbackAt(this, i); |
} |
this._setFollowing(); |
this._setLength(0); |
this._setFollowee(promise); |
} else if (((bitField & 33554432) !== 0)) { |
this._fulfill(promise._value()); |
} else if (((bitField & 16777216) !== 0)) { |
this._reject(promise._reason()); |
} else { |
var reason = new CancellationError("late cancellation observer"); |
promise._attachExtraTrace(reason); |
this._reject(reason); |
} |
}; |
|
Promise.prototype._rejectCallback = |
function(reason, synchronous, ignoreNonErrorWarnings) { |
var trace = util.ensureErrorObject(reason); |
var hasStack = trace === reason; |
if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) { |
var message = "a promise was rejected with a non-error: " + |
util.classString(reason); |
this._warn(message, true); |
} |
this._attachExtraTrace(trace, synchronous ? hasStack : false); |
this._reject(reason); |
}; |
|
Promise.prototype._resolveFromExecutor = function (executor) { |
if (executor === INTERNAL) return; |
var promise = this; |
this._captureStackTrace(); |
this._pushContext(); |
var synchronous = true; |
var r = this._execute(executor, function(value) { |
promise._resolveCallback(value); |
}, function (reason) { |
promise._rejectCallback(reason, synchronous); |
}); |
synchronous = false; |
this._popContext(); |
|
if (r !== undefined) { |
promise._rejectCallback(r, true); |
} |
}; |
|
Promise.prototype._settlePromiseFromHandler = function ( |
handler, receiver, value, promise |
) { |
var bitField = promise._bitField; |
if (((bitField & 65536) !== 0)) return; |
promise._pushContext(); |
var x; |
if (receiver === APPLY) { |
if (!value || typeof value.length !== "number") { |
x = errorObj; |
x.e = new TypeError("cannot .spread() a non-array: " + |
util.classString(value)); |
} else { |
x = tryCatch(handler).apply(this._boundValue(), value); |
} |
} else { |
x = tryCatch(handler).call(receiver, value); |
} |
var promiseCreated = promise._popContext(); |
bitField = promise._bitField; |
if (((bitField & 65536) !== 0)) return; |
|
if (x === NEXT_FILTER) { |
promise._reject(value); |
} else if (x === errorObj) { |
promise._rejectCallback(x.e, false); |
} else { |
debug.checkForgottenReturns(x, promiseCreated, "", promise, this); |
promise._resolveCallback(x); |
} |
}; |
|
Promise.prototype._target = function() { |
var ret = this; |
while (ret._isFollowing()) ret = ret._followee(); |
return ret; |
}; |
|
Promise.prototype._followee = function() { |
return this._rejectionHandler0; |
}; |
|
Promise.prototype._setFollowee = function(promise) { |
this._rejectionHandler0 = promise; |
}; |
|
Promise.prototype._settlePromise = function(promise, handler, receiver, value) { |
var isPromise = promise instanceof Promise; |
var bitField = this._bitField; |
var asyncGuaranteed = ((bitField & 134217728) !== 0); |
if (((bitField & 65536) !== 0)) { |
if (isPromise) promise._invokeInternalOnCancel(); |
|
if (receiver instanceof PassThroughHandlerContext && |
receiver.isFinallyHandler()) { |
receiver.cancelPromise = promise; |
if (tryCatch(handler).call(receiver, value) === errorObj) { |
promise._reject(errorObj.e); |
} |
} else if (handler === reflectHandler) { |
promise._fulfill(reflectHandler.call(receiver)); |
} else if (receiver instanceof Proxyable) { |
receiver._promiseCancelled(promise); |
} else if (isPromise || promise instanceof PromiseArray) { |
promise._cancel(); |
} else { |
receiver.cancel(); |
} |
} else if (typeof handler === "function") { |
if (!isPromise) { |
handler.call(receiver, value, promise); |
} else { |
if (asyncGuaranteed) promise._setAsyncGuaranteed(); |
this._settlePromiseFromHandler(handler, receiver, value, promise); |
} |
} else if (receiver instanceof Proxyable) { |
if (!receiver._isResolved()) { |
if (((bitField & 33554432) !== 0)) { |
receiver._promiseFulfilled(value, promise); |
} else { |
receiver._promiseRejected(value, promise); |
} |
} |
} else if (isPromise) { |
if (asyncGuaranteed) promise._setAsyncGuaranteed(); |
if (((bitField & 33554432) !== 0)) { |
promise._fulfill(value); |
} else { |
promise._reject(value); |
} |
} |
}; |
|
Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) { |
var handler = ctx.handler; |
var promise = ctx.promise; |
var receiver = ctx.receiver; |
var value = ctx.value; |
if (typeof handler === "function") { |
if (!(promise instanceof Promise)) { |
handler.call(receiver, value, promise); |
} else { |
this._settlePromiseFromHandler(handler, receiver, value, promise); |
} |
} else if (promise instanceof Promise) { |
promise._reject(value); |
} |
}; |
|
Promise.prototype._settlePromiseCtx = function(ctx) { |
this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value); |
}; |
|
Promise.prototype._settlePromise0 = function(handler, value, bitField) { |
var promise = this._promise0; |
var receiver = this._receiverAt(0); |
this._promise0 = undefined; |
this._receiver0 = undefined; |
this._settlePromise(promise, handler, receiver, value); |
}; |
|
Promise.prototype._clearCallbackDataAtIndex = function(index) { |
var base = index * 4 - 4; |
this[base + 2] = |
this[base + 3] = |
this[base + 0] = |
this[base + 1] = undefined; |
}; |
|
Promise.prototype._fulfill = function (value) { |
var bitField = this._bitField; |
if (((bitField & 117506048) >>> 16)) return; |
if (value === this) { |
var err = makeSelfResolutionError(); |
this._attachExtraTrace(err); |
return this._reject(err); |
} |
this._setFulfilled(); |
this._rejectionHandler0 = value; |
|
if ((bitField & 65535) > 0) { |
if (((bitField & 134217728) !== 0)) { |
this._settlePromises(); |
} else { |
async.settlePromises(this); |
} |
} |
}; |
|
Promise.prototype._reject = function (reason) { |
var bitField = this._bitField; |
if (((bitField & 117506048) >>> 16)) return; |
this._setRejected(); |
this._fulfillmentHandler0 = reason; |
|
if (this._isFinal()) { |
return async.fatalError(reason, util.isNode); |
} |
|
if ((bitField & 65535) > 0) { |
async.settlePromises(this); |
} else { |
this._ensurePossibleRejectionHandled(); |
} |
}; |
|
Promise.prototype._fulfillPromises = function (len, value) { |
for (var i = 1; i < len; i++) { |
var handler = this._fulfillmentHandlerAt(i); |
var promise = this._promiseAt(i); |
var receiver = this._receiverAt(i); |
this._clearCallbackDataAtIndex(i); |
this._settlePromise(promise, handler, receiver, value); |
} |
}; |
|
Promise.prototype._rejectPromises = function (len, reason) { |
for (var i = 1; i < len; i++) { |
var handler = this._rejectionHandlerAt(i); |
var promise = this._promiseAt(i); |
var receiver = this._receiverAt(i); |
this._clearCallbackDataAtIndex(i); |
this._settlePromise(promise, handler, receiver, reason); |
} |
}; |
|
Promise.prototype._settlePromises = function () { |
var bitField = this._bitField; |
var len = (bitField & 65535); |
|
if (len > 0) { |
if (((bitField & 16842752) !== 0)) { |
var reason = this._fulfillmentHandler0; |
this._settlePromise0(this._rejectionHandler0, reason, bitField); |
this._rejectPromises(len, reason); |
} else { |
var value = this._rejectionHandler0; |
this._settlePromise0(this._fulfillmentHandler0, value, bitField); |
this._fulfillPromises(len, value); |
} |
this._setLength(0); |
} |
this._clearCancellationData(); |
}; |
|
Promise.prototype._settledValue = function() { |
var bitField = this._bitField; |
if (((bitField & 33554432) !== 0)) { |
return this._rejectionHandler0; |
} else if (((bitField & 16777216) !== 0)) { |
return this._fulfillmentHandler0; |
} |
}; |
|
function deferResolve(v) {this.promise._resolveCallback(v);} |
function deferReject(v) {this.promise._rejectCallback(v, false);} |
|
Promise.defer = Promise.pending = function() { |
debug.deprecated("Promise.defer", "new Promise"); |
var promise = new Promise(INTERNAL); |
return { |
promise: promise, |
resolve: deferResolve, |
reject: deferReject |
}; |
}; |
|
util.notEnumerableProp(Promise, |
"_makeSelfResolutionError", |
makeSelfResolutionError); |
|
require("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection, |
debug); |
require("./bind")(Promise, INTERNAL, tryConvertToPromise, debug); |
require("./cancel")(Promise, PromiseArray, apiRejection, debug); |
require("./direct_resolve")(Promise); |
require("./synchronous_inspection")(Promise); |
require("./join")( |
Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain); |
Promise.Promise = Promise; |
Promise.version = "3.5.0"; |
require('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); |
require('./call_get.js')(Promise); |
require('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); |
require('./timers.js')(Promise, INTERNAL, debug); |
require('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); |
require('./nodeify.js')(Promise); |
require('./promisify.js')(Promise, INTERNAL); |
require('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); |
require('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); |
require('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); |
require('./settle.js')(Promise, PromiseArray, debug); |
require('./some.js')(Promise, PromiseArray, apiRejection); |
require('./filter.js')(Promise, INTERNAL); |
require('./each.js')(Promise, INTERNAL); |
require('./any.js')(Promise); |
|
util.toFastProperties(Promise); |
util.toFastProperties(Promise.prototype); |
function fillTypes(value) { |
var p = new Promise(INTERNAL); |
p._fulfillmentHandler0 = value; |
p._rejectionHandler0 = value; |
p._promise0 = value; |
p._receiver0 = value; |
} |
// Complete slack tracking, opt out of field-type tracking and |
// stabilize map |
fillTypes({a: 1}); |
fillTypes({b: 2}); |
fillTypes({c: 3}); |
fillTypes(1); |
fillTypes(function(){}); |
fillTypes(undefined); |
fillTypes(false); |
fillTypes(new Promise(INTERNAL)); |
debug.setBounds(Async.firstLineError, util.lastLineError); |
return Promise; |
|
}; |
/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/promisify.js |
@@ -0,0 +1,314 @@ |
"use strict"; |
module.exports = function(Promise, INTERNAL) { |
var THIS = {}; |
var util = require("./util"); |
var nodebackForPromise = require("./nodeback"); |
var withAppended = util.withAppended; |
var maybeWrapAsError = util.maybeWrapAsError; |
var canEvaluate = util.canEvaluate; |
var TypeError = require("./errors").TypeError; |
var defaultSuffix = "Async"; |
var defaultPromisified = {__isPromisified__: true}; |
var noCopyProps = [ |
"arity", "length", |
"name", |
"arguments", |
"caller", |
"callee", |
"prototype", |
"__isPromisified__" |
]; |
var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$"); |
|
var defaultFilter = function(name) { |
return util.isIdentifier(name) && |
name.charAt(0) !== "_" && |
name !== "constructor"; |
}; |
|
function propsFilter(key) { |
return !noCopyPropsPattern.test(key); |
} |
|
function isPromisified(fn) { |
try { |
return fn.__isPromisified__ === true; |
} |
catch (e) { |
return false; |
} |
} |
|
function hasPromisified(obj, key, suffix) { |
var val = util.getDataPropertyOrDefault(obj, key + suffix, |
defaultPromisified); |
return val ? isPromisified(val) : false; |
} |
function checkValid(ret, suffix, suffixRegexp) { |
for (var i = 0; i < ret.length; i += 2) { |
var key = ret[i]; |
if (suffixRegexp.test(key)) { |
var keyWithoutAsyncSuffix = key.replace(suffixRegexp, ""); |
for (var j = 0; j < ret.length; j += 2) { |
if (ret[j] === keyWithoutAsyncSuffix) { |
throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/MqrFmX\u000a" |
.replace("%s", suffix)); |
} |
} |
} |
} |
} |
|
function promisifiableMethods(obj, suffix, suffixRegexp, filter) { |
var keys = util.inheritedDataKeys(obj); |
var ret = []; |
for (var i = 0; i < keys.length; ++i) { |
var key = keys[i]; |
var value = obj[key]; |
var passesDefaultFilter = filter === defaultFilter |
? true : defaultFilter(key, value, obj); |
if (typeof value === "function" && |
!isPromisified(value) && |
!hasPromisified(obj, key, suffix) && |
filter(key, value, obj, passesDefaultFilter)) { |
ret.push(key, value); |
} |
} |
checkValid(ret, suffix, suffixRegexp); |
return ret; |
} |
|
var escapeIdentRegex = function(str) { |
return str.replace(/([$])/, "\\$"); |
}; |
|
var makeNodePromisifiedEval; |
if (!false) { |
var switchCaseArgumentOrder = function(likelyArgumentCount) { |
var ret = [likelyArgumentCount]; |
var min = Math.max(0, likelyArgumentCount - 1 - 3); |
for(var i = likelyArgumentCount - 1; i >= min; --i) { |
ret.push(i); |
} |
for(var i = likelyArgumentCount + 1; i <= 3; ++i) { |
ret.push(i); |
} |
return ret; |
}; |
|
var argumentSequence = function(argumentCount) { |
return util.filledRange(argumentCount, "_arg", ""); |
}; |
|
var parameterDeclaration = function(parameterCount) { |
return util.filledRange( |
Math.max(parameterCount, 3), "_arg", ""); |
}; |
|
var parameterCount = function(fn) { |
if (typeof fn.length === "number") { |
return Math.max(Math.min(fn.length, 1023 + 1), 0); |
} |
return 0; |
}; |
|
makeNodePromisifiedEval = |
function(callback, receiver, originalName, fn, _, multiArgs) { |
var newParameterCount = Math.max(0, parameterCount(fn) - 1); |
var argumentOrder = switchCaseArgumentOrder(newParameterCount); |
var shouldProxyThis = typeof callback === "string" || receiver === THIS; |
|
function generateCallForArgumentCount(count) { |
var args = argumentSequence(count).join(", "); |
var comma = count > 0 ? ", " : ""; |
var ret; |
if (shouldProxyThis) { |
ret = "ret = callback.call(this, {{args}}, nodeback); break;\n"; |
} else { |
ret = receiver === undefined |
? "ret = callback({{args}}, nodeback); break;\n" |
: "ret = callback.call(receiver, {{args}}, nodeback); break;\n"; |
} |
return ret.replace("{{args}}", args).replace(", ", comma); |
} |
|
function generateArgumentSwitchCase() { |
var ret = ""; |
for (var i = 0; i < argumentOrder.length; ++i) { |
ret += "case " + argumentOrder[i] +":" + |
generateCallForArgumentCount(argumentOrder[i]); |
} |
|
ret += " \n\ |
default: \n\ |
var args = new Array(len + 1); \n\ |
var i = 0; \n\ |
for (var i = 0; i < len; ++i) { \n\ |
args[i] = arguments[i]; \n\ |
} \n\ |
args[i] = nodeback; \n\ |
[CodeForCall] \n\ |
break; \n\ |
".replace("[CodeForCall]", (shouldProxyThis |
? "ret = callback.apply(this, args);\n" |
: "ret = callback.apply(receiver, args);\n")); |
return ret; |
} |
|
var getFunctionCode = typeof callback === "string" |
? ("this != null ? this['"+callback+"'] : fn") |
: "fn"; |
var body = "'use strict'; \n\ |
var ret = function (Parameters) { \n\ |
'use strict'; \n\ |
var len = arguments.length; \n\ |
var promise = new Promise(INTERNAL); \n\ |
promise._captureStackTrace(); \n\ |
var nodeback = nodebackForPromise(promise, " + multiArgs + "); \n\ |
var ret; \n\ |
var callback = tryCatch([GetFunctionCode]); \n\ |
switch(len) { \n\ |
[CodeForSwitchCase] \n\ |
} \n\ |
if (ret === errorObj) { \n\ |
promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\ |
} \n\ |
if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); \n\ |
return promise; \n\ |
}; \n\ |
notEnumerableProp(ret, '__isPromisified__', true); \n\ |
return ret; \n\ |
".replace("[CodeForSwitchCase]", generateArgumentSwitchCase()) |
.replace("[GetFunctionCode]", getFunctionCode); |
body = body.replace("Parameters", parameterDeclaration(newParameterCount)); |
return new Function("Promise", |
"fn", |
"receiver", |
"withAppended", |
"maybeWrapAsError", |
"nodebackForPromise", |
"tryCatch", |
"errorObj", |
"notEnumerableProp", |
"INTERNAL", |
body)( |
Promise, |
fn, |
receiver, |
withAppended, |
maybeWrapAsError, |
nodebackForPromise, |
util.tryCatch, |
util.errorObj, |
util.notEnumerableProp, |
INTERNAL); |
}; |
} |
|
function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) { |
var defaultThis = (function() {return this;})(); |
var method = callback; |
if (typeof method === "string") { |
callback = fn; |
} |
function promisified() { |
var _receiver = receiver; |
if (receiver === THIS) _receiver = this; |
var promise = new Promise(INTERNAL); |
promise._captureStackTrace(); |
var cb = typeof method === "string" && this !== defaultThis |
? this[method] : callback; |
var fn = nodebackForPromise(promise, multiArgs); |
try { |
cb.apply(_receiver, withAppended(arguments, fn)); |
} catch(e) { |
promise._rejectCallback(maybeWrapAsError(e), true, true); |
} |
if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); |
return promise; |
} |
util.notEnumerableProp(promisified, "__isPromisified__", true); |
return promisified; |
} |
|
var makeNodePromisified = canEvaluate |
? makeNodePromisifiedEval |
: makeNodePromisifiedClosure; |
|
function promisifyAll(obj, suffix, filter, promisifier, multiArgs) { |
var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$"); |
var methods = |
promisifiableMethods(obj, suffix, suffixRegexp, filter); |
|
for (var i = 0, len = methods.length; i < len; i+= 2) { |
var key = methods[i]; |
var fn = methods[i+1]; |
var promisifiedKey = key + suffix; |
if (promisifier === makeNodePromisified) { |
obj[promisifiedKey] = |
makeNodePromisified(key, THIS, key, fn, suffix, multiArgs); |
} else { |
var promisified = promisifier(fn, function() { |
return makeNodePromisified(key, THIS, key, |
fn, suffix, multiArgs); |
}); |
util.notEnumerableProp(promisified, "__isPromisified__", true); |
obj[promisifiedKey] = promisified; |
} |
} |
util.toFastProperties(obj); |
return obj; |
} |
|
function promisify(callback, receiver, multiArgs) { |
return makeNodePromisified(callback, receiver, undefined, |
callback, null, multiArgs); |
} |
|
Promise.promisify = function (fn, options) { |
if (typeof fn !== "function") { |
throw new TypeError("expecting a function but got " + util.classString(fn)); |
} |
if (isPromisified(fn)) { |
return fn; |
} |
options = Object(options); |
var receiver = options.context === undefined ? THIS : options.context; |
var multiArgs = !!options.multiArgs; |
var ret = promisify(fn, receiver, multiArgs); |
util.copyDescriptors(fn, ret, propsFilter); |
return ret; |
}; |
|
Promise.promisifyAll = function (target, options) { |
if (typeof target !== "function" && typeof target !== "object") { |
throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
options = Object(options); |
var multiArgs = !!options.multiArgs; |
var suffix = options.suffix; |
if (typeof suffix !== "string") suffix = defaultSuffix; |
var filter = options.filter; |
if (typeof filter !== "function") filter = defaultFilter; |
var promisifier = options.promisifier; |
if (typeof promisifier !== "function") promisifier = makeNodePromisified; |
|
if (!util.isIdentifier(suffix)) { |
throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
} |
|
var keys = util.inheritedDataKeys(target); |
for (var i = 0; i < keys.length; ++i) { |
var value = target[keys[i]]; |
if (keys[i] !== "constructor" && |
util.isClass(value)) { |
promisifyAll(value.prototype, suffix, filter, promisifier, |
multiArgs); |
promisifyAll(value, suffix, filter, promisifier, multiArgs); |
} |
} |
|
return promisifyAll(target, suffix, filter, promisifier, multiArgs); |
}; |
}; |
|
/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/using.js |
@@ -0,0 +1,226 @@ |
"use strict"; |
module.exports = function (Promise, apiRejection, tryConvertToPromise, |
createContext, INTERNAL, debug) { |
var util = require("./util"); |
var TypeError = require("./errors").TypeError; |
var inherits = require("./util").inherits; |
var errorObj = util.errorObj; |
var tryCatch = util.tryCatch; |
var NULL = {}; |
|
function thrower(e) { |
setTimeout(function(){throw e;}, 0); |
} |
|
function castPreservingDisposable(thenable) { |
var maybePromise = tryConvertToPromise(thenable); |
if (maybePromise !== thenable && |
typeof thenable._isDisposable === "function" && |
typeof thenable._getDisposer === "function" && |
thenable._isDisposable()) { |
maybePromise._setDisposable(thenable._getDisposer()); |
} |
return maybePromise; |
} |
function dispose(resources, inspection) { |
var i = 0; |
var len = resources.length; |
var ret = new Promise(INTERNAL); |
function iterator() { |
if (i >= len) return ret._fulfill(); |
var maybePromise = castPreservingDisposable(resources[i++]); |
if (maybePromise instanceof Promise && |
maybePromise._isDisposable()) { |
try { |
maybePromise = tryConvertToPromise( |
maybePromise._getDisposer().tryDispose(inspection), |
resources.promise); |
} catch (e) { |
return thrower(e); |
} |
if (maybePromise instanceof Promise) { |
return maybePromise._then(iterator, thrower, |
null, null, null); |
} |
} |
iterator(); |
} |
iterator(); |
return ret; |
} |
|
function Disposer(data, promise, context) { |
this._data = data; |
this._promise = promise; |
this._context = context; |
} |
|
Disposer.prototype.data = function () { |
return this._data; |
}; |
|
Disposer.prototype.promise = function () { |
return this._promise; |
}; |
|
Disposer.prototype.resource = function () { |
if (this.promise().isFulfilled()) { |
return this.promise().value(); |
} |
return NULL; |
}; |
|
Disposer.prototype.tryDispose = function(inspection) { |
var resource = this.resource(); |
var context = this._context; |
if (context !== undefined) context._pushContext(); |
var ret = resource !== NULL |
? this.doDispose(resource, inspection) : null; |
if (context !== undefined) context._popContext(); |
this._promise._unsetDisposable(); |
this._data = null; |
return ret; |
}; |
|
Disposer.isDisposer = function (d) { |
return (d != null && |
typeof d.resource === "function" && |
typeof d.tryDispose === "function"); |
}; |
|
function FunctionDisposer(fn, promise, context) { |
this.constructor$(fn, promise, context); |
} |
inherits(FunctionDisposer, Disposer); |
|
FunctionDisposer.prototype.doDispose = function (resource, inspection) { |
var fn = this.data(); |
return fn.call(resource, resource, inspection); |
}; |
|
function maybeUnwrapDisposer(value) { |
if (Disposer.isDisposer(value)) { |
this.resources[this.index]._setDisposable(value); |
return value.promise(); |
} |
return value; |
} |
|
function ResourceList(length) { |
this.length = length; |
this.promise = null; |
this[length-1] = null; |
} |
|
ResourceList.prototype._resultCancelled = function() { |
var len = this.length; |
for (var i = 0; i < len; ++i) { |
var item = this[i]; |
if (item instanceof Promise) { |
item.cancel(); |
} |
} |
}; |
|
Promise.using = function () { |
var len = arguments.length; |
if (len < 2) return apiRejection( |
"you must pass at least 2 arguments to Promise.using"); |
var fn = arguments[len - 1]; |
if (typeof fn !== "function") { |
return apiRejection("expecting a function but got " + util.classString(fn)); |
} |
var input; |
var spreadArgs = true; |
if (len === 2 && Array.isArray(arguments[0])) { |
input = arguments[0]; |
len = input.length; |
spreadArgs = false; |
} else { |
input = arguments; |
len--; |
} |
var resources = new ResourceList(len); |
for (var i = 0; i < len; ++i) { |
var resource = input[i]; |
if (Disposer.isDisposer(resource)) { |
var disposer = resource; |
resource = resource.promise(); |
resource._setDisposable(disposer); |
} else { |
var maybePromise = tryConvertToPromise(resource); |
if (maybePromise instanceof Promise) { |
resource = |
maybePromise._then(maybeUnwrapDisposer, null, null, { |
resources: resources, |
index: i |
}, undefined); |
} |
} |
resources[i] = resource; |
} |
|
var reflectedResources = new Array(resources.length); |
for (var i = 0; i < reflectedResources.length; ++i) { |
reflectedResources[i] = Promise.resolve(resources[i]).reflect(); |
} |
|
var resultPromise = Promise.all(reflectedResources) |
.then(function(inspections) { |
for (var i = 0; i < inspections.length; ++i) { |
var inspection = inspections[i]; |
if (inspection.isRejected()) { |
errorObj.e = inspection.error(); |
return errorObj; |
} else if (!inspection.isFulfilled()) { |
resultPromise.cancel(); |
return; |
} |
inspections[i] = inspection.value(); |
} |
promise._pushContext(); |
|
fn = tryCatch(fn); |
var ret = spreadArgs |
? fn.apply(undefined, inspections) : fn(inspections); |
var promiseCreated = promise._popContext(); |
debug.checkForgottenReturns( |
ret, promiseCreated, "Promise.using", promise); |
return ret; |
}); |
|
var promise = resultPromise.lastly(function() { |
var inspection = new Promise.PromiseInspection(resultPromise); |
return dispose(resources, inspection); |
}); |
resources.promise = promise; |
promise._setOnCancel(resources); |
return promise; |
}; |
|
Promise.prototype._setDisposable = function (disposer) { |
this._bitField = this._bitField | 131072; |
this._disposer = disposer; |
}; |
|
Promise.prototype._isDisposable = function () { |
return (this._bitField & 131072) > 0; |
}; |
|
Promise.prototype._getDisposer = function () { |
return this._disposer; |
}; |
|
Promise.prototype._unsetDisposable = function () { |
this._bitField = this._bitField & (~131072); |
this._disposer = undefined; |
}; |
|
Promise.prototype.disposer = function (fn) { |
if (typeof fn === "function") { |
return new FunctionDisposer(fn, this, createContext()); |
} |
throw new TypeError(); |
}; |
|
}; |
/script-kiddie/002_script_kiddie/script-kiddie/node_modules/bluebird/js/release/util.js |
@@ -0,0 +1,379 @@ |
"use strict"; |
var es5 = require("./es5"); |
var canEvaluate = typeof navigator == "undefined"; |
|
var errorObj = {e: {}}; |
var tryCatchTarget; |
var globalObject = typeof self !== "undefined" ? self : |
typeof window !== "undefined" ? window : |
typeof global !== "undefined" ? global : |
this !== undefined ? this : null; |
|
function tryCatcher() { |
try { |
var target = tryCatchTarget; |
tryCatchTarget = null; |
return target.apply(this, arguments); |
} catch (e) { |
errorObj.e = e; |
return errorObj; |
} |
} |
function tryCatch(fn) { |
tryCatchTarget = fn; |
return tryCatcher; |
} |
|
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 isPrimitive(val) { |
return val == null || val === true || val === false || |
typeof val === "string" || typeof val === "number"; |
|
} |
|
function isObject(value) { |
return typeof value === "function" || |
typeof value === "object" && value !== null; |
} |
|
function maybeWrapAsError(maybeError) { |
if (!isPrimitive(maybeError)) return maybeError; |
|
return new Error(safeToString(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 getDataPropertyOrDefault(obj, key, defaultValue) { |
if (es5.isES5) { |
var desc = Object.getOwnPropertyDescriptor(obj, key); |
|
if (desc != null) { |
return desc.get == null && desc.set == null |
? desc.value |
: defaultValue; |
} |
} else { |
return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined; |
} |
} |
|
function notEnumerableProp(obj, name, value) { |
if (isPrimitive(obj)) return obj; |
var descriptor = { |
value: value, |
configurable: true, |
enumerable: false, |
writable: true |
}; |
es5.defineProperty(obj, name, descriptor); |
return obj; |
} |
|
function thrower(r) { |
throw r; |
} |
|
var inheritedDataKeys = (function() { |
var excludedPrototypes = [ |
Array.prototype, |
Object.prototype, |
Function.prototype |
]; |
|
var isExcludedProto = function(val) { |
for (var i = 0; i < excludedPrototypes.length; ++i) { |
if (excludedPrototypes[i] === val) { |
return true; |
} |
} |
return false; |
}; |
|
if (es5.isES5) { |
var getKeys = Object.getOwnPropertyNames; |
return function(obj) { |
var ret = []; |
var visitedKeys = Object.create(null); |
while (obj != null && !isExcludedProto(obj)) { |
var keys; |
try { |
keys = getKeys(obj); |
} catch (e) { |
return ret; |
} |
for (var i = 0; i < keys.length; ++i) { |
var key = keys[i]; |
if (visitedKeys[key]) continue; |
visitedKeys[key] = true; |
var desc = Object.getOwnPropertyDescriptor(obj, key); |
if (desc != null && desc.get == null && desc.set == null) { |
ret.push(key); |
} |
} |
obj = es5.getPrototypeOf(obj); |
} |
return ret; |
}; |
} else { |
var hasProp = {}.hasOwnProperty; |
return function(obj) { |
if (isExcludedProto(obj)) return []; |
var ret = []; |
|
/*jshint forin:false */ |
enumeration: for (var key in obj) { |
if (hasProp.call(obj, key)) { |
ret.push(key); |
} else { |
for (var i = 0; i < excludedPrototypes.length; ++i) { |
if (hasProp.call(excludedPrototypes[i], key)) { |
continue enumeration; |
} |
} |
ret.push(key); |
} |
} |
return ret; |
}; |
} |
|
})(); |
|
var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/; |
function isClass(fn) { |
try { |
if (typeof fn === "function") { |
var keys = es5.names(fn.prototype); |
|
var hasMethods = es5.isES5 && keys.length > 1; |
var hasMethodsOtherThanConstructor = keys.length > 0 && |
!(keys.length === 1 && keys[0] === "constructor"); |
var hasThisAssignmentAndStaticMethods = |
thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0; |
|
if (hasMethods || hasMethodsOtherThanConstructor || |
hasThisAssignmentAndStaticMethods) { |
return true; |
} |
} |
return false; |
} catch (e) { |
return false; |
} |
} |
|
function toFastProperties(obj) { |
/*jshint -W027,-W055,-W031*/ |
function FakeConstructor() {} |
FakeConstructor.prototype = obj; |
var l = 8; |
while (l--) new FakeConstructor(); |
return obj; |
eval(obj); |
} |
|
var rident = /^[a-z$_][a-z$_0-9]*$/i; |
function isIdentifier(str) { |
return rident.test(str); |
} |
|
function filledRange(count, prefix, suffix) { |
var ret = new Array(count); |
for(var i = 0; i < count; ++i) { |
ret[i] = prefix + i + suffix; |
} |
return ret; |
} |
|
function safeToString(obj) { |
try { |
return obj + ""; |
} catch (e) { |
return "[no string representation]"; |
} |
} |
|
function isError(obj) { |
return obj !== null && |
typeof obj === "object" && |
typeof obj.message === "string" && |
typeof obj.name === "string"; |
} |
|
function markAsOriginatingFromRejection(e) { |
try { |
notEnumerableProp(e, "isOperational", true); |
} |
catch(ignore) {} |
} |
|
function originatesFromRejection(e) { |
if (e == null) return false; |
return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) || |
e["isOperational"] === true); |
} |
|
function canAttachTrace(obj) { |
return isError(obj) && es5.propertyIsWritable(obj, "stack"); |
} |
|
var ensureErrorObject = (function() { |
if (!("stack" in new Error())) { |
return function(value) { |
if (canAttachTrace(value)) return value; |
try {throw new Error(safeToString(value));} |
catch(err) {return err;} |
}; |
} else { |
return function(value) { |
if (canAttachTrace(value)) return value; |
return new Error(safeToString(value)); |
}; |
} |
})(); |
|
function classString(obj) { |
return {}.toString.call(obj); |
} |
|
function copyDescriptors(from, to, filter) { |
var keys = es5.names(from); |
for (var i = 0; i < keys.length; ++i) { |
var key = keys[i]; |
if (filter(key)) { |
try { |
es5.defineProperty(to, key, es5.getDescriptor(from, key)); |
} catch (ignore) {} |
} |
} |
} |
|
var asArray = function(v) { |
if (es5.isArray(v)) { |
return v; |
} |
return null; |
}; |
|
if (typeof Symbol !== "undefined" && Symbol.iterator) { |
var ArrayFrom = typeof Array.from === "function" ? function(v) { |
return Array.from(v); |
} : function(v) { |
var ret = []; |
var it = v[Symbol.iterator](); |
var itResult; |
while (!((itResult = it.next()).done)) { |
ret.push(itResult.value); |
} |
return ret; |
}; |
|
asArray = function(v) { |
if (es5.isArray(v)) { |
return v; |
} else if (v != null && typeof v[Symbol.iterator] === "function") { |
return ArrayFrom(v); |
} |
return null; |
}; |
} |
|
var isNode = typeof process !== "undefined" && |
classString(process).toLowerCase() === "[object process]"; |
|
var hasEnvVariables = typeof process !== "undefined" && |
typeof process.env !== "undefined"; |
|
function env(key) { |
return hasEnvVariables ? process.env[key] : undefined; |
} |
|
function getNativePromise() { |
if (typeof Promise === "function") { |
try { |
var promise = new Promise(function(){}); |
if ({}.toString.call(promise) === "[object Promise]") { |
return Promise; |
} |
} catch (e) {} |
} |
} |
|
function domainBind(self, cb) { |
return self.bind(cb); |
} |
|
var ret = { |
isClass: isClass, |
isIdentifier: isIdentifier, |
inheritedDataKeys: inheritedDataKeys, |
getDataPropertyOrDefault: getDataPropertyOrDefault, |
thrower: thrower, |
isArray: es5.isArray, |
asArray: asArray, |
notEnumerableProp: notEnumerableProp, |
isPrimitive: isPrimitive, |
isObject: isObject, |
isError: isError, |
canEvaluate: canEvaluate, |
errorObj: errorObj, |
tryCatch: tryCatch, |
inherits: inherits, |
withAppended: withAppended, |
maybeWrapAsError: maybeWrapAsError, |
toFastProperties: toFastProperties, |
filledRange: filledRange, |
toString: safeToString, |
canAttachTrace: canAttachTrace, |
ensureErrorObject: ensureErrorObject, |
originatesFromRejection: originatesFromRejection, |
markAsOriginatingFromRejection: markAsOriginatingFromRejection, |
classString: classString, |
copyDescriptors: copyDescriptors, |
hasDevTools: typeof chrome !== "undefined" && chrome && |
typeof chrome.loadTimes === "function", |
isNode: isNode, |
hasEnvVariables: hasEnvVariables, |
env: env, |
global: globalObject, |
getNativePromise: getNativePromise, |
domainBind: domainBind |
}; |
ret.isRecentNode = ret.isNode && (function() { |
var version = process.versions.node.split(".").map(Number); |
return (version[0] === 0 && version[1] > 10) || (version[0] > 0); |
})(); |
|
if (ret.isNode) ret.toFastProperties(process); |
|
try {throw new Error(); } catch (e) {ret.lastLineError = e;} |
module.exports = ret; |