az6161311 / test Goto Github PK

View Code? Open in Web Editor NEW

1.0 1.0 0.0 0 B

test's People

Stargazers

Watchers

test's Issues

Orderby

    public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string sort, string sortFieldName)
    {
        var param = Expression.Parameter(typeof(T), "p");
        var prop = Expression.Property(param, sortFieldName);
        var exp = Expression.Lambda(prop, param);
        string method = (sort.ToLower() == "asc" || sort.IsNull()) ? "OrderBy" : "OrderByDescending";
        Type[] types = new Type[] { source.ElementType, exp.Body.Type };
        var mce = Expression.Call(typeof(Queryable), method, types, source.Expression, exp);
        return source.Provider.CreateQuery<T>(mce);
    }

bluebird.js

/* @preserve

The MIT License (MIT)
Copyright (c) 2013-2017 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:
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.

/
/*

bluebird build version 3.5.0
Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
*/
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof dereq=="function"&&dereq;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof dereq=="function"&&dereq;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise) {
var SomePromiseArray = Promise._SomePromiseArray;
function any(promises) {
var ret = new SomePromiseArray(promises);
var promise = ret.promise();
ret.setHowMany(1);
ret.setUnwrap();
ret.init();
return promise;
}

Promise.any = function (promises) {
return any(promises);
};

Promise.prototype.any = function () {
return any(this);
};

};

},{}],2:[function(dereq,module,exports){
"use strict";
var firstLineError;
try {throw new Error(); } catch (e) {firstLineError = e;}
var schedule = dereq("./schedule");
var Queue = dereq("./queue");
var util = dereq("./util");

function Async() {
this._customScheduler = false;
this._isTickUsed = false;
this._lateQueue = new Queue(16);
this._normalQueue = new Queue(16);
this._haveDrainedQueues = false;
this._trampolineEnabled = true;
var self = this;
this.drainQueues = function () {
self._drainQueues();
};
this._schedule = schedule;
}

Async.prototype.setScheduler = function(fn) {
var prev = this._schedule;
this._schedule = fn;
this._customScheduler = true;
return prev;
};

Async.prototype.hasCustomScheduler = function() {
return this._customScheduler;
};

Async.prototype.enableTrampoline = function() {
this._trampolineEnabled = true;
};

Async.prototype.disableTrampolineIfNecessary = function() {
if (util.hasDevTools) {
this._trampolineEnabled = false;
}
};

Async.prototype.haveItemsQueued = function () {
return this._isTickUsed || this._haveDrainedQueues;
};

Async.prototype.fatalError = function(e, isNode) {
if (isNode) {
process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
"\n");
process.exit(2);
} else {
this.throwLater(e);
}
};

Async.prototype.throwLater = function(fn, arg) {
if (arguments.length === 1) {
arg = fn;
fn = function () { throw arg; };
}
if (typeof setTimeout !== "undefined") {
setTimeout(function() {
fn(arg);
}, 0);
} else try {
this._schedule(function() {
fn(arg);
});
} catch (e) {
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
}
};

function AsyncInvokeLater(fn, receiver, arg) {
this._lateQueue.push(fn, receiver, arg);
this._queueTick();
}

function AsyncInvoke(fn, receiver, arg) {
this._normalQueue.push(fn, receiver, arg);
this._queueTick();
}

function AsyncSettlePromises(promise) {
this._normalQueue._pushOne(promise);
this._queueTick();
}

if (!util.hasDevTools) {
Async.prototype.invokeLater = AsyncInvokeLater;
Async.prototype.invoke = AsyncInvoke;
Async.prototype.settlePromises = AsyncSettlePromises;
} else {
Async.prototype.invokeLater = function (fn, receiver, arg) {
if (this._trampolineEnabled) {
AsyncInvokeLater.call(this, fn, receiver, arg);
} else {
this._schedule(function() {
setTimeout(function() {
fn.call(receiver, arg);
}, 100);
});
}
};

Async.prototype.invoke = function (fn, receiver, arg) {
    if (this._trampolineEnabled) {
        AsyncInvoke.call(this, fn, receiver, arg);
    } else {
        this._schedule(function() {
            fn.call(receiver, arg);
        });
    }
};

Async.prototype.settlePromises = function(promise) {
    if (this._trampolineEnabled) {
        AsyncSettlePromises.call(this, promise);
    } else {
        this._schedule(function() {
            promise._settlePromises();
        });
    }
};

}

Async.prototype._drainQueue = function(queue) {
while (queue.length() > 0) {
var fn = queue.shift();
if (typeof fn !== "function") {
fn._settlePromises();
continue;
}
var receiver = queue.shift();
var arg = queue.shift();
fn.call(receiver, arg);
}
};

Async.prototype._drainQueues = function () {
this._drainQueue(this._normalQueue);
this._reset();
this._haveDrainedQueues = true;
this._drainQueue(this._lateQueue);
};

Async.prototype._queueTick = function () {
if (!this._isTickUsed) {
this._isTickUsed = true;
this._schedule(this.drainQueues);
}
};

Async.prototype._reset = function () {
this._isTickUsed = false;
};

module.exports = Async;
module.exports.firstLineError = firstLineError;

},{"./queue":26,"./schedule":29,"./util":36}],3:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
var calledBind = false;
var rejectThis = function(_, e) {
this._reject(e);
};

var targetRejected = function(e, context) {
context.promiseRejectionQueued = true;
context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
};

var bindingResolved = function(thisArg, context) {
if (((this._bitField & 50397184) === 0)) {
this._resolveCallback(context.target);
}
};

var bindingRejected = function(e, context) {
if (!context.promiseRejectionQueued) this._reject(e);
};

Promise.prototype.bind = function (thisArg) {
if (!calledBind) {
calledBind = true;
Promise.prototype._propagateFrom = debug.propagateFromFunction();
Promise.prototype._boundValue = debug.boundValueFunction();
}
var maybePromise = tryConvertToPromise(thisArg);
var ret = new Promise(INTERNAL);
ret._propagateFrom(this, 1);
var target = this._target();
ret._setBoundTo(maybePromise);
if (maybePromise instanceof Promise) {
var context = {
promiseRejectionQueued: false,
promise: ret,
target: target,
bindingPromise: maybePromise
};
target._then(INTERNAL, targetRejected, undefined, ret, context);
maybePromise._then(
bindingResolved, bindingRejected, undefined, ret, context);
ret._setOnCancel(maybePromise);
} else {
ret._resolveCallback(target);
}
return ret;
};

Promise.prototype._setBoundTo = function (obj) {
if (obj !== undefined) {
this._bitField = this._bitField | 2097152;
this._boundTo = obj;
} else {
this._bitField = this._bitField & (~2097152);
}
};

Promise.prototype._isBound = function () {
return (this._bitField & 2097152) === 2097152;
};

Promise.bind = function (thisArg, value) {
return Promise.resolve(value).bind(thisArg);
};
};

},{}],4:[function(dereq,module,exports){
"use strict";
var old;
if (typeof Promise !== "undefined") old = Promise;
function noConflict() {
try { if (Promise === bluebird) Promise = old; }
catch (e) {}
return bluebird;
}
var bluebird = dereq("./promise")();
bluebird.noConflict = noConflict;
module.exports = bluebird;

},{"./promise":22}],5:[function(dereq,module,exports){
"use strict";
var cr = Object.create;
if (cr) {
var callerCache = cr(null);
var getterCache = cr(null);
callerCache[" size"] = getterCache[" size"] = 0;
}

module.exports = function(Promise) {
var util = dereq("./util");
var canEvaluate = util.canEvaluate;
var isIdentifier = util.isIdentifier;

var getMethodCaller;
var getGetter;
if (!true) {
var makeMethodCaller = function (methodName) {
return new Function("ensureMethod", " \n
return function(obj) { \n
'use strict' \n
var len = this.length; \n
ensureMethod(obj, 'methodName'); \n
switch(len) { \n
case 1: return obj.methodName(this[0]); \n
case 2: return obj.methodName(this[0], this[1]); \n
case 3: return obj.methodName(this[0], this[1], this[2]); \n
case 0: return obj.methodName(); \n
default: \n
return obj.methodName.apply(obj, this); \n
} \n
}; \n
".replace(/methodName/g, methodName))(ensureMethod);
};

var makeGetter = function (propertyName) {
return new Function("obj", " \n
'use strict'; \n
return obj.propertyName; \n
".replace("propertyName", propertyName));
};

getMethodCaller = function(name) {
return getCompiled(name, makeMethodCaller, callerCache);
};

getGetter = function(name) {
return getCompiled(name, makeGetter, getterCache);
};
}

function ensureMethod(obj, methodName) {
var fn;
if (obj != null) fn = obj[methodName];
if (typeof fn !== "function") {
var message = "Object " + util.classString(obj) + " has no method '" +
util.toString(methodName) + "'";
throw new Promise.TypeError(message);
}
return fn;
}

},{"./util":36}],6:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, PromiseArray, apiRejection, debug) {
var util = dereq("./util");
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
var async = Promise._async;

Promise.prototype["break"] = Promise.prototype.cancel = function() {
if (!debug.cancellation()) return this._warn("cancellation is disabled");

var promise = this;
var child = promise;
while (promise._isCancellable()) {
    if (!promise._cancelBy(child)) {
        if (child._isFollowing()) {
            child._followee().cancel();
        } else {
            child._cancelBranched();
        }
        break;
    }

    var parent = promise._cancellationParent;
    if (parent == null || !parent._isCancellable()) {
        if (promise._isFollowing()) {
            promise._followee().cancel();
        } else {
            promise._cancelBranched();
        }
        break;
    } else {
        if (promise._isFollowing()) promise._followee().cancel();
        promise._setWillBeCancelled();
        child = promise;
        promise = parent;
    }
}

};

Promise.prototype._branchHasCancelled = function() {
this._branchesRemainingToCancel--;
};

Promise.prototype._enoughBranchesHaveCancelled = function() {
return this._branchesRemainingToCancel === undefined ||
this._branchesRemainingToCancel <= 0;
};

Promise.prototype._cancelBy = function(canceller) {
if (canceller === this) {
this._branchesRemainingToCancel = 0;
this._invokeOnCancel();
return true;
} else {
this._branchHasCancelled();
if (this._enoughBranchesHaveCancelled()) {
this._invokeOnCancel();
return true;
}
}
return false;
};

Promise.prototype._cancelBranched = function() {
if (this._enoughBranchesHaveCancelled()) {
this._cancel();
}
};

Promise.prototype._cancel = function() {
if (!this._isCancellable()) return;
this._setCancelled();
async.invoke(this._cancelPromises, this, undefined);
};

Promise.prototype._cancelPromises = function() {
if (this._length() > 0) this._settlePromises();
};

Promise.prototype._unsetOnCancel = function() {
this._onCancelField = undefined;
};

Promise.prototype._isCancellable = function() {
return this.isPending() && !this._isCancelled();
};

Promise.prototype.isCancellable = function() {
return this.isPending() && !this.isCancelled();
};

Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
if (util.isArray(onCancelCallback)) {
for (var i = 0; i < onCancelCallback.length; ++i) {
this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
}
} else if (onCancelCallback !== undefined) {
if (typeof onCancelCallback === "function") {
if (!internalOnly) {
var e = tryCatch(onCancelCallback).call(this._boundValue());
if (e === errorObj) {
this._attachExtraTrace(e.e);
async.throwLater(e.e);
}
}
} else {
onCancelCallback._resultCancelled(this);
}
}
};

Promise.prototype._invokeOnCancel = function() {
var onCancelCallback = this._onCancel();
this._unsetOnCancel();
async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
};

Promise.prototype._invokeInternalOnCancel = function() {
if (this._isCancellable()) {
this._doInvokeOnCancel(this._onCancel(), true);
this._unsetOnCancel();
}
};

Promise.prototype._resultCancelled = function() {
this.cancel();
};

};

},{"./util":36}],7:[function(dereq,module,exports){
"use strict";
module.exports = function(NEXT_FILTER) {
var util = dereq("./util");
var getKeys = dereq("./es5").keys;
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;

function catchFilter(instances, cb, promise) {
return function(e) {
var boundTo = promise._boundValue();
predicateLoop: for (var i = 0; i < instances.length; ++i) {
var item = instances[i];

        if (item === Error ||
            (item != null && item.prototype instanceof Error)) {
            if (e instanceof item) {
                return tryCatch(cb).call(boundTo, e);
            }
        } else if (typeof item === "function") {
            var matchesPredicate = tryCatch(item).call(boundTo, e);
            if (matchesPredicate === errorObj) {
                return matchesPredicate;
            } else if (matchesPredicate) {
                return tryCatch(cb).call(boundTo, e);
            }
        } else if (util.isObject(e)) {
            var keys = getKeys(item);
            for (var j = 0; j < keys.length; ++j) {
                var key = keys[j];
                if (item[key] != e[key]) {
                    continue predicateLoop;
                }
            }
            return tryCatch(cb).call(boundTo, e);
        }
    }
    return NEXT_FILTER;
};

}

return catchFilter;
};

},{"./es5":13,"./util":36}],8:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise) {
var longStackTraces = false;
var contextStack = [];

Promise.prototype._promiseCreated = function() {};
Promise.prototype._pushContext = function() {};
Promise.prototype._popContext = function() {return null;};
Promise._peekContext = Promise.prototype._peekContext = function() {};

Context.prototype._popContext = function () {
if (this._trace !== undefined) {
var trace = contextStack.pop();
var ret = trace._promiseCreated;
trace._promiseCreated = null;
return ret;
}
return null;
};

function createContext() {
if (longStackTraces) return new Context();
}

},{}],9:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, Context) {
var getDomain = Promise._getDomain;
var async = Promise._async;
var Warning = dereq("./errors").Warning;
var util = dereq("./util");
var canAttachTrace = util.canAttachTrace;
var unhandledRejectionHandled;
var possiblyUnhandledRejection;
var bluebirdFramePattern =
/[\/]bluebird[\/]js\//;
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 &&
(true ||
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();
};

function generatePromiseLifecycleEventObject(name, promise) {
return {promise: promise};
}

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 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 bindingPropagateFrom(parent, flags) {
if ((flags & 2) !== 0 && parent._isBound()) {
this._setBoundTo(parent._boundTo);
}
}
var propagateFromFunction = bindingPropagateFrom;

function longStackTracesCaptureStackTrace() {
this._trace = new CapturedTrace(this._peekContext());
}

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);
}

if (!activeFireEvent("warning", warning)) {
    formatAndLogError(warning, "", true);
}

}

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 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)
};
}

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";
}

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 = /^\sat\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
};
};

},{"./errors":12,"./util":36}],10:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise) {
function returner() {
return this.value;
}
function thrower() {
throw this.reason;
}

Promise.prototype["return"] =
Promise.prototype.thenReturn = function (value) {
if (value instanceof Promise) value.suppressUnhandledRejections();
return this._then(
returner, undefined, undefined, {value: value}, undefined);
};

Promise.prototype["throw"] =
Promise.prototype.thenThrow = function (reason) {
return this._then(
thrower, undefined, undefined, {reason: reason}, undefined);
};

Promise.prototype.catchThrow = function (reason) {
if (arguments.length <= 1) {
return this._then(
undefined, thrower, undefined, {reason: reason}, undefined);
} else {
var _reason = arguments[1];
var handler = function() {throw _reason;};
return this.caught(reason, handler);
}
};

Promise.prototype.catchReturn = function (value) {
if (arguments.length <= 1) {
if (value instanceof Promise) value.suppressUnhandledRejections();
return this._then(
undefined, returner, undefined, {value: value}, undefined);
} else {
var _value = arguments[1];
if (_value instanceof Promise) _value.suppressUnhandledRejections();
var handler = function() {return _value;};
return this.caught(value, handler);
}
};
};

},{}],11:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL) {
var PromiseReduce = Promise.reduce;
var PromiseAll = Promise.all;

function promiseAllThis() {
return PromiseAll(this);
}

function PromiseMapSeries(promises, fn) {
return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
}

Promise.prototype.each = function (fn) {
return PromiseReduce(this, fn, INTERNAL, 0)
._then(promiseAllThis, undefined, undefined, this, undefined);
};

Promise.prototype.mapSeries = function (fn) {
return PromiseReduce(this, fn, INTERNAL, INTERNAL);
};

Promise.each = function (promises, fn) {
return PromiseReduce(promises, fn, INTERNAL, 0)
._then(promiseAllThis, undefined, undefined, promises, undefined);
};

Promise.mapSeries = PromiseMapSeries;
};

},{}],12:[function(dereq,module,exports){
"use strict";
var es5 = dereq("./es5");
var Objectfreeze = es5.freeze;
var util = dereq("./util");
var inherits = util.inherits;
var notEnumerableProp = util.notEnumerableProp;

var _TypeError, _RangeError;
var Warning = subError("Warning", "warning");
var CancellationError = subError("CancellationError", "cancellation error");
var TimeoutError = subError("TimeoutError", "timeout error");
var AggregateError = subError("AggregateError", "aggregate error");
try {
_TypeError = TypeError;
_RangeError = RangeError;
} catch(e) {
_TypeError = subError("TypeError", "type error");
_RangeError = subError("RangeError", "range error");
}

var methods = ("join pop push shift unshift slice filter forEach some " +
"every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");

for (var i = 0; i < methods.length; ++i) {
if (typeof Array.prototype[methods[i]] === "function") {
AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
}
}

es5.defineProperty(AggregateError.prototype, "length", {
value: 0,
configurable: false,
writable: true,
enumerable: true
});
AggregateError.prototype["isOperational"] = true;
var level = 0;
AggregateError.prototype.toString = function() {
var indent = Array(level * 4 + 1).join(" ");
var ret = "\n" + indent + "AggregateError of:" + "\n";
level++;
indent = Array(level * 4 + 1).join(" ");
for (var i = 0; i < this.length; ++i) {
var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
var lines = str.split("\n");
for (var j = 0; j < lines.length; ++j) {
lines[j] = indent + lines[j];
}
str = lines.join("\n");
ret += str + "\n";
}
level--;
return ret;
};

function OperationalError(message) {
if (!(this instanceof OperationalError))
return new OperationalError(message);
notEnumerableProp(this, "name", "OperationalError");
notEnumerableProp(this, "message", message);
this.cause = message;
this["isOperational"] = true;

if (message instanceof Error) {
    notEnumerableProp(this, "message", message.message);
    notEnumerableProp(this, "stack", message.stack);
} else if (Error.captureStackTrace) {
    Error.captureStackTrace(this, this.constructor);
}

}
inherits(OperationalError, Error);

module.exports = {
Error: Error,
TypeError: _TypeError,
RangeError: _RangeError,
CancellationError: errorTypes.CancellationError,
OperationalError: errorTypes.OperationalError,
TimeoutError: errorTypes.TimeoutError,
AggregateError: errorTypes.AggregateError,
Warning: Warning
};

},{"./es5":13,"./util":36}],13:[function(dereq,module,exports){
var isES5 = (function(){
"use strict";
return this === undefined;
})();

if (isES5) {
module.exports = {
freeze: Object.freeze,
defineProperty: Object.defineProperty,
getDescriptor: Object.getOwnPropertyDescriptor,
keys: Object.keys,
names: Object.getOwnPropertyNames,
getPrototypeOf: Object.getPrototypeOf,
isArray: Array.isArray,
isES5: isES5,
propertyIsWritable: function(obj, prop) {
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
return !!(!descriptor || descriptor.writable || descriptor.set);
}
};
} else {
var has = {}.hasOwnProperty;
var str = {}.toString;
var proto = {}.constructor.prototype;

var ObjectKeys = function (o) {
    var ret = [];
    for (var key in o) {
        if (has.call(o, key)) {
            ret.push(key);
        }
    }
    return ret;
};

var ObjectGetDescriptor = function(o, key) {
    return {value: o[key]};
};

var ObjectDefineProperty = function (o, key, desc) {
    o[key] = desc.value;
    return o;
};

var ObjectFreeze = function (obj) {
    return obj;
};

var ObjectGetPrototypeOf = function (obj) {
    try {
        return Object(obj).constructor.prototype;
    }
    catch (e) {
        return proto;
    }
};

var ArrayIsArray = function (obj) {
    try {
        return str.call(obj) === "[object Array]";
    }
    catch(e) {
        return false;
    }
};

module.exports = {
    isArray: ArrayIsArray,
    keys: ObjectKeys,
    names: ObjectKeys,
    defineProperty: ObjectDefineProperty,
    getDescriptor: ObjectGetDescriptor,
    freeze: ObjectFreeze,
    getPrototypeOf: ObjectGetPrototypeOf,
    isES5: isES5,
    propertyIsWritable: function() {
        return true;
    }
};

}

},{}],14:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL) {
var PromiseMap = Promise.map;

Promise.prototype.filter = function (fn, options) {
return PromiseMap(this, fn, options, INTERNAL);
};

Promise.filter = function (promises, fn, options) {
return PromiseMap(promises, fn, options, INTERNAL);
};
};

},{}],15:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {
var util = dereq("./util");
var CancellationError = Promise.CancellationError;
var errorObj = util.errorObj;
var catchFilter = dereq("./catch_filter")(NEXT_FILTER);

function PassThroughHandlerContext(promise, type, handler) {
this.promise = promise;
this.type = type;
this.handler = handler;
this.called = false;
this.cancelPromise = null;
}

PassThroughHandlerContext.prototype.isFinallyHandler = function() {
return this.type === 0;
};

function FinallyHandlerCancelReaction(finallyHandler) {
this.finallyHandler = finallyHandler;
}

FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
checkCancel(this.finallyHandler);
};

function succeed() {
return finallyHandler.call(this, this.promise._target()._settledValue());
}
function fail(reason) {
if (checkCancel(this, reason)) return;
errorObj.e = reason;
return errorObj;
}
function finallyHandler(reasonOrValue) {
var promise = this.promise;
var handler = this.handler;

if (!this.called) {
    this.called = true;
    var ret = this.isFinallyHandler()
        ? handler.call(promise._boundValue())
        : handler.call(promise._boundValue(), reasonOrValue);
    if (ret === NEXT_FILTER) {
        return ret;
    } else if (ret !== undefined) {
        promise._setReturnedNonUndefined();
        var maybePromise = tryConvertToPromise(ret, promise);
        if (maybePromise instanceof Promise) {
            if (this.cancelPromise != null) {
                if (maybePromise._isCancelled()) {
                    var reason =
                        new CancellationError("late cancellation observer");
                    promise._attachExtraTrace(reason);
                    errorObj.e = reason;
                    return errorObj;
                } else if (maybePromise.isPending()) {
                    maybePromise._attachCancellationCallback(
                        new FinallyHandlerCancelReaction(this));
                }
            }
            return maybePromise._then(
                succeed, fail, undefined, this, undefined);
        }
    }
}

if (promise.isRejected()) {
    checkCancel(this);
    errorObj.e = reasonOrValue;
    return errorObj;
} else {
    checkCancel(this);
    return reasonOrValue;
}

}

Promise.prototype._passThrough = function(handler, type, success, fail) {
if (typeof handler !== "function") return this.then();
return this._then(success,
fail,
undefined,
new PassThroughHandlerContext(this, type, handler),
undefined);
};

Promise.prototype.lastly =
Promise.prototype["finally"] = function (handler) {
return this._passThrough(handler,
0,
finallyHandler,
finallyHandler);
};

Promise.prototype.tap = function (handler) {
return this._passThrough(handler, 1, finallyHandler);
};

Promise.prototype.tapCatch = function (handlerOrPredicate) {
var len = arguments.length;
if(len === 1) {
return this._passThrough(handlerOrPredicate,
1,
undefined,
finallyHandler);
} else {
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 Promise.reject(new TypeError(
"tapCatch statement predicate: "
+ "expecting an object but got " + util.classString(item)
));
}
}
catchInstances.length = j;
var handler = arguments[i];
return this._passThrough(catchFilter(catchInstances, handler, this),
1,
undefined,
finallyHandler);
}

};

return PassThroughHandlerContext;
};

},{"./catch_filter":7,"./util":36}],16:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise,
apiRejection,
INTERNAL,
tryConvertToPromise,
Proxyable,
debug) {
var errors = dereq("./errors");
var TypeError = errors.TypeError;
var util = dereq("./util");
var errorObj = util.errorObj;
var tryCatch = util.tryCatch;
var yieldHandlers = [];

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;
};
};

},{"./errors":12,"./util":36}],17:[function(dereq,module,exports){
"use strict";
module.exports =
function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async,
getDomain) {
var util = dereq("./util");
var canEvaluate = util.canEvaluate;
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
var reject;

if (!true) {
if (canEvaluate) {
var thenCallback = function(i) {
return new Function("value", "holder", " \n
'use strict'; \n
holder.pIndex = value; \n
holder.checkFulfillment(this); \n
".replace(/Index/g, i));
};

var promiseSetter = function(i) {
    return new Function("promise", "holder", "                           \n\
        'use strict';                                                    \n\
        holder.pIndex = promise;                                         \n\
        ".replace(/Index/g, i));
};

var generateHolderClass = function(total) {
    var props = new Array(total);
    for (var i = 0; i < props.length; ++i) {
        props[i] = "this.p" + (i+1);
    }
    var assignment = props.join(" = ") + " = null;";
    var cancellationCode= "var promise;\n" + props.map(function(prop) {
        return "                                                         \n\
            promise = " + prop + ";                                      \n\
            if (promise instanceof Promise) {                            \n\
                promise.cancel();                                        \n\
            }                                                            \n\
        ";
    }).join("\n");
    var passedArguments = props.join(", ");
    var name = "Holder$" + total;


    var code = "return function(tryCatch, errorObj, Promise, async) {    \n\
        'use strict';                                                    \n\
        function [TheName](fn) {                                         \n\
            [TheProperties]                                              \n\
            this.fn = fn;                                                \n\
            this.asyncNeeded = true;                                     \n\
            this.now = 0;                                                \n\
        }                                                                \n\
                                                                         \n\
        [TheName].prototype._callFunction = function(promise) {          \n\
            promise._pushContext();                                      \n\
            var ret = tryCatch(this.fn)([ThePassedArguments]);           \n\
            promise._popContext();                                       \n\
            if (ret === errorObj) {                                      \n\
                promise._rejectCallback(ret.e, false);                   \n\
            } else {                                                     \n\
                promise._resolveCallback(ret);                           \n\
            }                                                            \n\
        };                                                               \n\
                                                                         \n\
        [TheName].prototype.checkFulfillment = function(promise) {       \n\
            var now = ++this.now;                                        \n\
            if (now === [TheTotal]) {                                    \n\
                if (this.asyncNeeded) {                                  \n\
                    async.invoke(this._callFunction, this, promise);     \n\
                } else {                                                 \n\
                    this._callFunction(promise);                         \n\
                }                                                        \n\
                                                                         \n\
            }                                                            \n\
        };                                                               \n\
                                                                         \n\
        [TheName].prototype._resultCancelled = function() {              \n\
            [CancellationCode]                                           \n\
        };                                                               \n\
                                                                         \n\
        return [TheName];                                                \n\
    }(tryCatch, errorObj, Promise, async);                               \n\
    ";

    code = code.replace(/\[TheName\]/g, name)
        .replace(/\[TheTotal\]/g, total)
        .replace(/\[ThePassedArguments\]/g, passedArguments)
        .replace(/\[TheProperties\]/g, assignment)
        .replace(/\[CancellationCode\]/g, cancellationCode);

    return new Function("tryCatch", "errorObj", "Promise", "async", code)
                       (tryCatch, errorObj, Promise, async);
};

var holderClasses = [];
var thenCallbacks = [];
var promiseSetters = [];

for (var i = 0; i < 8; ++i) {
    holderClasses.push(generateHolderClass(i + 1));
    thenCallbacks.push(thenCallback(i + 1));
    promiseSetters.push(promiseSetter(i + 1));
}

reject = function (reason) {
    this._reject(reason);
};

}}

Promise.join = function () {
var last = arguments.length - 1;
var fn;
if (last > 0 && typeof arguments[last] === "function") {
fn = arguments[last];
if (!true) {
if (last <= 8 && canEvaluate) {
var ret = new Promise(INTERNAL);
ret._captureStackTrace();
var HolderClass = holderClasses[last - 1];
var holder = new HolderClass(fn);
var callbacks = thenCallbacks;

            for (var i = 0; i < last; ++i) {
                var maybePromise = tryConvertToPromise(arguments[i], ret);
                if (maybePromise instanceof Promise) {
                    maybePromise = maybePromise._target();
                    var bitField = maybePromise._bitField;
                    ;
                    if (((bitField & 50397184) === 0)) {
                        maybePromise._then(callbacks[i], reject,
                                           undefined, ret, holder);
                        promiseSetters[i](maybePromise, holder);
                        holder.asyncNeeded = false;
                    } else if (((bitField & 33554432) !== 0)) {
                        callbacks[i].call(ret,
                                          maybePromise._value(), holder);
                    } else if (((bitField & 16777216) !== 0)) {
                        ret._reject(maybePromise._reason());
                    } else {
                        ret._cancel();
                    }
                } else {
                    callbacks[i].call(ret, maybePromise, holder);
                }
            }

            if (!ret._isFateSealed()) {
                if (holder.asyncNeeded) {
                    var domain = getDomain();
                    if (domain !== null) {
                        holder.fn = util.domainBind(domain, holder.fn);
                    }
                }
                ret._setAsyncGuaranteed();
                ret._setOnCancel(holder);
            }
            return ret;
        }
    }
}
var args = [].slice.call(arguments);;
if (fn) args.pop();
var ret = new PromiseArray(args).promise();
return fn !== undefined ? ret.spread(fn) : ret;

};

},{"./util":36}],18:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise,
PromiseArray,
apiRejection,
tryConvertToPromise,
INTERNAL,
debug) {
var getDomain = Promise._getDomain;
var util = dereq("./util");
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
var async = Promise._async;

function MappingPromiseArray(promises, fn, limit, _filter) {
this.constructor$(promises);
this._promise._captureStackTrace();
var domain = getDomain();
this._callback = domain === null ? fn : util.domainBind(domain, fn);
this._preservedValues = _filter === INTERNAL
? new Array(this.length())
: null;
this._limit = limit;
this._inFlight = 0;
this._queue = [];
async.invoke(this._asyncInit, this, undefined);
}
util.inherits(MappingPromiseArray, PromiseArray);

MappingPromiseArray.prototype._asyncInit = function() {
this._init$(undefined, -2);
};

MappingPromiseArray.prototype._init = function () {};

MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
var values = this._values;
var length = this.length();
var preservedValues = this._preservedValues;
var limit = this._limit;

if (index < 0) {
    index = (index * -1) - 1;
    values[index] = value;
    if (limit >= 1) {
        this._inFlight--;
        this._drainQueue();
        if (this._isResolved()) return true;
    }
} else {
    if (limit >= 1 && this._inFlight >= limit) {
        values[index] = value;
        this._queue.push(index);
        return false;
    }
    if (preservedValues !== null) preservedValues[index] = value;

    var promise = this._promise;
    var callback = this._callback;
    var receiver = promise._boundValue();
    promise._pushContext();
    var ret = tryCatch(callback).call(receiver, value, index, length);
    var promiseCreated = promise._popContext();
    debug.checkForgottenReturns(
        ret,
        promiseCreated,
        preservedValues !== null ? "Promise.filter" : "Promise.map",
        promise
    );
    if (ret === errorObj) {
        this._reject(ret.e);
        return true;
    }

    var maybePromise = tryConvertToPromise(ret, this._promise);
    if (maybePromise instanceof Promise) {
        maybePromise = maybePromise._target();
        var bitField = maybePromise._bitField;
        ;
        if (((bitField & 50397184) === 0)) {
            if (limit >= 1) this._inFlight++;
            values[index] = maybePromise;
            maybePromise._proxy(this, (index + 1) * -1);
            return false;
        } else if (((bitField & 33554432) !== 0)) {
            ret = maybePromise._value();
        } else if (((bitField & 16777216) !== 0)) {
            this._reject(maybePromise._reason());
            return true;
        } else {
            this._cancel();
            return true;
        }
    }
    values[index] = ret;
}
var totalResolved = ++this._totalResolved;
if (totalResolved >= length) {
    if (preservedValues !== null) {
        this._filter(values, preservedValues);
    } else {
        this._resolve(values);
    }
    return true;
}
return false;

};

MappingPromiseArray.prototype._drainQueue = function () {
var queue = this._queue;
var limit = this._limit;
var values = this._values;
while (queue.length > 0 && this._inFlight < limit) {
if (this._isResolved()) return;
var index = queue.pop();
this._promiseFulfilled(values[index], index);
}
};

MappingPromiseArray.prototype._filter = function (booleans, values) {
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;
this._resolve(ret);
};

MappingPromiseArray.prototype.preservedValues = function () {
return this._preservedValues;
};

function map(promises, fn, options, _filter) {
if (typeof fn !== "function") {
return apiRejection("expecting a function but got " + util.classString(fn));
}

var limit = 0;
if (options !== undefined) {
    if (typeof options === "object" && options !== null) {
        if (typeof options.concurrency !== "number") {
            return Promise.reject(
                new TypeError("'concurrency' must be a number but it is " +
                                util.classString(options.concurrency)));
        }
        limit = options.concurrency;
    } else {
        return Promise.reject(new TypeError(
                        "options argument must be an object but it is " +
                         util.classString(options)));
    }
}
limit = typeof limit === "number" &&
    isFinite(limit) && limit >= 1 ? limit : 0;
return new MappingPromiseArray(promises, fn, limit, _filter).promise();

}

Promise.prototype.map = function (fn, options) {
return map(this, fn, options, null);
};

Promise.map = function (promises, fn, options, _filter) {
return map(promises, fn, options, _filter);
};

};

},{"./util":36}],19:[function(dereq,module,exports){
"use strict";
module.exports =
function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
var util = dereq("./util");
var tryCatch = util.tryCatch;

Promise.method = function (fn) {
if (typeof fn !== "function") {
throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
}
return function () {
var ret = new Promise(INTERNAL);
ret._captureStackTrace();
ret._pushContext();
var value = tryCatch(fn).apply(this, arguments);
var promiseCreated = ret._popContext();
debug.checkForgottenReturns(
value, promiseCreated, "Promise.method", ret);
ret._resolveFromSyncValue(value);
return ret;
};
};

Promise.attempt = Promise["try"] = function (fn) {
if (typeof fn !== "function") {
return apiRejection("expecting a function but got " + util.classString(fn));
}
var ret = new Promise(INTERNAL);
ret._captureStackTrace();
ret._pushContext();
var value;
if (arguments.length > 1) {
debug.deprecated("calling Promise.try with more than 1 argument");
var arg = arguments[1];
var ctx = arguments[2];
value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
: tryCatch(fn).call(ctx, arg);
} else {
value = tryCatch(fn)();
}
var promiseCreated = ret._popContext();
debug.checkForgottenReturns(
value, promiseCreated, "Promise.try", ret);
ret._resolveFromSyncValue(value);
return ret;
};

Promise.prototype._resolveFromSyncValue = function (value) {
if (value === util.errorObj) {
this._rejectCallback(value.e, false);
} else {
this._resolveCallback(value, true);
}
};
};

},{"./util":36}],20:[function(dereq,module,exports){
"use strict";
var util = dereq("./util");
var maybeWrapAsError = util.maybeWrapAsError;
var errors = dereq("./errors");
var OperationalError = errors.OperationalError;
var es5 = dereq("./es5");

function isUntypedError(obj) {
return obj instanceof Error &&
es5.getPrototypeOf(obj) === Error.prototype;
}

module.exports = nodebackForPromise;

},{"./errors":12,"./es5":13,"./util":36}],21:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise) {
var util = dereq("./util");
var async = Promise._async;
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;

function spreadAdapter(val, nodeback) {
var promise = this;
if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
var ret =
tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
if (ret === errorObj) {
async.throwLater(ret.e);
}
}

Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,
options) {
if (typeof nodeback == "function") {
var adapter = successAdapter;
if (options !== undefined && Object(options).spread) {
adapter = spreadAdapter;
}
this._then(
adapter,
errorAdapter,
undefined,
this,
nodeback
);
}
return this;
};
};

},{"./util":36}],22:[function(dereq,module,exports){
"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 = dereq("./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 = dereq("./es5");
var Async = dereq("./async");
var async = new Async();
es5.defineProperty(Promise, "_async", {value: async});
var errors = dereq("./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 = dereq("./thenables")(Promise, INTERNAL);
var PromiseArray =
dereq("./promise_array")(Promise, INTERNAL,
tryConvertToPromise, apiRejection, Proxyable);
var Context = dereq("./context")(Promise);
/jshint unused:false/
var createContext = Context.create;
var debug = dereq("./debuggability")(Promise, Context);
var CapturedTrace = debug.CapturedTrace;
var PassThroughHandlerContext =
dereq("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
var catchFilter = dereq("./catch_filter")(NEXT_FILTER);
var nodebackForPromise = dereq("./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);

dereq("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
debug);
dereq("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
dereq("./cancel")(Promise, PromiseArray, apiRejection, debug);
dereq("./direct_resolve")(Promise);
dereq("./synchronous_inspection")(Promise);
dereq("./join")(
Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);
Promise.Promise = Promise;
Promise.version = "3.5.0";
dereq('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
dereq('./call_get.js')(Promise);
dereq('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);
dereq('./timers.js')(Promise, INTERNAL, debug);
dereq('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);
dereq('./nodeify.js')(Promise);
dereq('./promisify.js')(Promise, INTERNAL);
dereq('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
dereq('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
dereq('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
dereq('./settle.js')(Promise, PromiseArray, debug);
dereq('./some.js')(Promise, PromiseArray, apiRejection);
dereq('./filter.js')(Promise, INTERNAL);
dereq('./each.js')(Promise, INTERNAL);
dereq('./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;

};

},{"./any.js":1,"./async":2,"./bind":3,"./call_get.js":5,"./cancel":6,"./catch_filter":7,"./context":8,"./debuggability":9,"./direct_resolve":10,"./each.js":11,"./errors":12,"./es5":13,"./filter.js":14,"./finally":15,"./generators.js":16,"./join":17,"./map.js":18,"./method":19,"./nodeback":20,"./nodeify.js":21,"./promise_array":23,"./promisify.js":24,"./props.js":25,"./race.js":27,"./reduce.js":28,"./settle.js":30,"./some.js":31,"./synchronous_inspection":32,"./thenables":33,"./timers.js":34,"./using.js":35,"./util":36}],23:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL, tryConvertToPromise,
apiRejection, Proxyable) {
var util = dereq("./util");
var isArray = util.isArray;

function toResolutionValue(val) {
switch(val) {
case -2: return [];
case -3: return {};
case -6: return new Map();
}
}

function PromiseArray(values) {
var promise = this._promise = new Promise(INTERNAL);
if (values instanceof Promise) {
promise._propagateFrom(values, 3);
}
promise._setOnCancel(this);
this._values = values;
this._length = 0;
this._totalResolved = 0;
this._init(undefined, -2);
}
util.inherits(PromiseArray, Proxyable);

PromiseArray.prototype.length = function () {
return this._length;
};

PromiseArray.prototype.promise = function () {
return this._promise;
};

PromiseArray.prototype.init = function init(, resolveValueIfEmpty) {
var values = tryConvertToPromise(this._values, this._promise);
if (values instanceof Promise) {
values = values._target();
var bitField = values._bitField;
;
this._values = values;

    if (((bitField & 50397184) === 0)) {
        this._promise._setAsyncGuaranteed();
        return values._then(
            init,
            this._reject,
            undefined,
            this,
            resolveValueIfEmpty
       );
    } else if (((bitField & 33554432) !== 0)) {
        values = values._value();
    } else if (((bitField & 16777216) !== 0)) {
        return this._reject(values._reason());
    } else {
        return this._cancel();
    }
}
values = util.asArray(values);
if (values === null) {
    var err = apiRejection(
        "expecting an array or an iterable object but got " + util.classString(values)).reason();
    this._promise._rejectCallback(err, false);
    return;
}

if (values.length === 0) {
    if (resolveValueIfEmpty === -5) {
        this._resolveEmptyArray();
    }
    else {
        this._resolve(toResolutionValue(resolveValueIfEmpty));
    }
    return;
}
this._iterate(values);

};

PromiseArray.prototype._iterate = function(values) {
var len = this.getActualLength(values.length);
this._length = len;
this._values = this.shouldCopyValues() ? new Array(len) : this._values;
var result = this._promise;
var isResolved = false;
var bitField = null;
for (var i = 0; i < len; ++i) {
var maybePromise = tryConvertToPromise(values[i], result);

    if (maybePromise instanceof Promise) {
        maybePromise = maybePromise._target();
        bitField = maybePromise._bitField;
    } else {
        bitField = null;
    }

    if (isResolved) {
        if (bitField !== null) {
            maybePromise.suppressUnhandledRejections();
        }
    } else if (bitField !== null) {
        if (((bitField & 50397184) === 0)) {
            maybePromise._proxy(this, i);
            this._values[i] = maybePromise;
        } else if (((bitField & 33554432) !== 0)) {
            isResolved = this._promiseFulfilled(maybePromise._value(), i);
        } else if (((bitField & 16777216) !== 0)) {
            isResolved = this._promiseRejected(maybePromise._reason(), i);
        } else {
            isResolved = this._promiseCancelled(i);
        }
    } else {
        isResolved = this._promiseFulfilled(maybePromise, i);
    }
}
if (!isResolved) result._setAsyncGuaranteed();

};

PromiseArray.prototype._isResolved = function () {
return this._values === null;
};

PromiseArray.prototype._resolve = function (value) {
this._values = null;
this._promise._fulfill(value);
};

PromiseArray.prototype._cancel = function() {
if (this._isResolved() || !this._promise._isCancellable()) return;
this._values = null;
this._promise._cancel();
};

PromiseArray.prototype._reject = function (reason) {
this._values = null;
this._promise._rejectCallback(reason, false);
};

PromiseArray.prototype._promiseFulfilled = function (value, index) {
this._values[index] = value;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
this._resolve(this._values);
return true;
}
return false;
};

PromiseArray.prototype._promiseCancelled = function() {
this._cancel();
return true;
};

PromiseArray.prototype._promiseRejected = function (reason) {
this._totalResolved++;
this._reject(reason);
return true;
};

PromiseArray.prototype._resultCancelled = function() {
if (this._isResolved()) return;
var values = this._values;
this._cancel();
if (values instanceof Promise) {
values.cancel();
} else {
for (var i = 0; i < values.length; ++i) {
if (values[i] instanceof Promise) {
values[i].cancel();
}
}
}
};

PromiseArray.prototype.shouldCopyValues = function () {
return true;
};

PromiseArray.prototype.getActualLength = function (len) {
return len;
};

return PromiseArray;
};

},{"./util":36}],24:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL) {
var THIS = {};
var util = dereq("./util");
var nodebackForPromise = dereq("./nodeback");
var withAppended = util.withAppended;
var maybeWrapAsError = util.maybeWrapAsError;
var canEvaluate = util.canEvaluate;
var TypeError = dereq("./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));
}
}
}
}
}

var escapeIdentRegex = function(str) {
return str.replace(/([$])/, "\$");
};

var makeNodePromisifiedEval;
if (!true) {
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);

};
}

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);

};
};

},{"./errors":12,"./nodeback":20,"./util":36}],25:[function(dereq,module,exports){
"use strict";
module.exports = function(
Promise, PromiseArray, tryConvertToPromise, apiRejection) {
var util = dereq("./util");
var isObject = util.isObject;
var es5 = dereq("./es5");
var Es6Map;
if (typeof Map === "function") Es6Map = Map;

var mapToEntries = (function() {
var index = 0;
var size = 0;

function extractEntry(value, key) {
    this[index] = value;
    this[index + size] = key;
    index++;
}

return function mapToEntries(map) {
    size = map.size;
    index = 0;
    var ret = new Array(map.size * 2);
    map.forEach(extractEntry, ret);
    return ret;
};

})();

var entriesToMap = function(entries) {
var ret = new Es6Map();
var length = entries.length / 2 | 0;
for (var i = 0; i < length; ++i) {
var key = entries[length + i];
var value = entries[i];
ret.set(key, value);
}
return ret;
};

PropertiesPromiseArray.prototype._init = function () {};

PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
this._values[index] = value;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
var val;
if (this._isMap) {
val = entriesToMap(this._values);
} else {
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);
return true;
}
return false;
};

PropertiesPromiseArray.prototype.shouldCopyValues = function () {
return false;
};

PropertiesPromiseArray.prototype.getActualLength = function (len) {
return len >> 1;
};

function props(promises) {
var ret;
var castValue = tryConvertToPromise(promises);

if (!isObject(castValue)) {
    return apiRejection("cannot await properties of a non-object\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
} else if (castValue instanceof Promise) {
    ret = castValue._then(
        Promise.props, undefined, undefined, undefined, undefined);
} else {
    ret = new PropertiesPromiseArray(castValue).promise();
}

if (castValue instanceof Promise) {
    ret._propagateFrom(castValue, 2);
}
return ret;

}

Promise.prototype.props = function () {
return props(this);
};

Promise.props = function (promises) {
return props(promises);
};
};

},{"./es5":13,"./util":36}],26:[function(dereq,module,exports){
"use strict";
function arrayMove(src, srcIndex, dst, dstIndex, len) {
for (var j = 0; j < len; ++j) {
dst[j + dstIndex] = src[j + srcIndex];
src[j + srcIndex] = void 0;
}
}

function Queue(capacity) {
this._capacity = capacity;
this._length = 0;
this._front = 0;
}

Queue.prototype._willBeOverCapacity = function (size) {
return this._capacity < size;
};

Queue.prototype._pushOne = function (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 (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 () {
var front = this._front,
ret = this[front];

this[front] = undefined;
this._front = (front + 1) & (this._capacity - 1);
this._length--;
return ret;

};

Queue.prototype.length = function () {
return this._length;
};

Queue.prototype._checkCapacity = function (size) {
if (this._capacity < size) {
this._resizeTo(this._capacity << 1);
}
};

Queue.prototype._resizeTo = function (capacity) {
var oldCapacity = this._capacity;
this._capacity = capacity;
var front = this._front;
var length = this._length;
var moveItemsCount = (front + length) & (oldCapacity - 1);
arrayMove(this, 0, this, oldCapacity, moveItemsCount);
};

module.exports = Queue;

},{}],27:[function(dereq,module,exports){
"use strict";
module.exports = function(
Promise, INTERNAL, tryConvertToPromise, apiRejection) {
var util = dereq("./util");

var raceLater = function (promise) {
return promise.then(function(array) {
return race(array, promise);
});
};

function race(promises, parent) {
var maybePromise = tryConvertToPromise(promises);

if (maybePromise instanceof Promise) {
    return raceLater(maybePromise);
} else {
    promises = util.asArray(promises);
    if (promises === null)
        return apiRejection("expecting an array or an iterable object but got " + util.classString(promises));
}

var ret = new Promise(INTERNAL);
if (parent !== undefined) {
    ret._propagateFrom(parent, 3);
}
var fulfill = ret._fulfill;
var reject = ret._reject;
for (var i = 0, len = promises.length; i < len; ++i) {
    var val = promises[i];

    if (val === undefined && !(i in promises)) {
        continue;
    }

    Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
}
return ret;

}

Promise.race = function (promises) {
return race(promises, undefined);
};

Promise.prototype.race = function () {
return race(this, undefined);
};

};

},{"./util":36}],28:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise,
PromiseArray,
apiRejection,
tryConvertToPromise,
INTERNAL,
debug) {
var getDomain = Promise._getDomain;
var util = dereq("./util");
var tryCatch = util.tryCatch;

ReductionPromiseArray.prototype._gotAccum = function(accum) {
if (this._eachValues !== undefined &&
this._eachValues !== null &&
accum !== INTERNAL) {
this._eachValues.push(accum);
}
};

ReductionPromiseArray.prototype._eachComplete = function(value) {
if (this._eachValues !== null) {
this._eachValues.push(value);
}
return this._eachValues;
};

ReductionPromiseArray.prototype._init = function() {};

ReductionPromiseArray.prototype._resolveEmptyArray = function() {
this._resolve(this._eachValues !== undefined ? this._eachValues
: this._initialValue);
};

ReductionPromiseArray.prototype.shouldCopyValues = function () {
return false;
};

ReductionPromiseArray.prototype._resolve = function(value) {
this._promise._resolveCallback(value);
this._values = null;
};

ReductionPromiseArray.prototype._resultCancelled = function(sender) {
if (sender === this._initialValue) return this._cancel();
if (this._isResolved()) return;
this._resultCancelled$();
if (this._currentCancellable instanceof Promise) {
this._currentCancellable.cancel();
}
if (this._initialValue instanceof Promise) {
this._initialValue.cancel();
}
};

ReductionPromiseArray.prototype._iterate = function (values) {
this._values = values;
var value;
var i;
var length = values.length;
if (this._initialValue !== undefined) {
value = this._initialValue;
i = 0;
} else {
value = Promise.resolve(values[0]);
i = 1;
}

this._currentCancellable = value;

if (!value.isRejected()) {
    for (; i < length; ++i) {
        var ctx = {
            accum: null,
            value: values[i],
            index: i,
            length: length,
            array: this
        };
        value = value._then(gotAccum, undefined, undefined, ctx, undefined);
    }
}

if (this._eachValues !== undefined) {
    value = value
        ._then(this._eachComplete, undefined, undefined, this, undefined);
}
value._then(completed, completed, undefined, value, this);

};

Promise.prototype.reduce = function (fn, initialValue) {
return reduce(this, fn, initialValue, null);
};

Promise.reduce = function (promises, fn, initialValue, _each) {
return reduce(promises, fn, initialValue, _each);
};

function completed(valueOrReason, array) {
if (this.isFulfilled()) {
array._resolve(valueOrReason);
} else {
array._reject(valueOrReason);
}
}

function reduce(promises, fn, initialValue, _each) {
if (typeof fn !== "function") {
return apiRejection("expecting a function but got " + util.classString(fn));
}
var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
return array.promise();
}

},{"./util":36}],29:[function(dereq,module,exports){
"use strict";
var util = dereq("./util");
var schedule;
var noAsyncScheduler = function() {
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
};
var NativePromise = util.getNativePromise();
if (util.isNode && typeof MutationObserver === "undefined") {
var GlobalSetImmediate = global.setImmediate;
var ProcessNextTick = process.nextTick;
schedule = util.isRecentNode
? function(fn) { GlobalSetImmediate.call(global, fn); }
: function(fn) { ProcessNextTick.call(process, fn); };
} else if (typeof NativePromise === "function" &&
typeof NativePromise.resolve === "function") {
var nativePromise = NativePromise.resolve();
schedule = function(fn) {
nativePromise.then(fn);
};
} else if ((typeof MutationObserver !== "undefined") &&
!(typeof window !== "undefined" &&
window.navigator &&
(window.navigator.standalone || window.cordova))) {
schedule = (function() {
var div = document.createElement("div");
var opts = {attributes: true};
var toggleScheduled = false;
var div2 = document.createElement("div");
var o2 = new MutationObserver(function() {
div.classList.toggle("foo");
toggleScheduled = false;
});
o2.observe(div2, opts);

    var scheduleToggle = function() {
        if (toggleScheduled) return;
        toggleScheduled = true;
        div2.classList.toggle("foo");
    };

    return function schedule(fn) {
        var o = new MutationObserver(function() {
            o.disconnect();
            fn();
        });
        o.observe(div, opts);
        scheduleToggle();
    };
})();

} else if (typeof setImmediate !== "undefined") {
schedule = function (fn) {
setImmediate(fn);
};
} else if (typeof setTimeout !== "undefined") {
schedule = function (fn) {
setTimeout(fn, 0);
};
} else {
schedule = noAsyncScheduler;
}
module.exports = schedule;

},{"./util":36}],30:[function(dereq,module,exports){
"use strict";
module.exports =
function(Promise, PromiseArray, debug) {
var PromiseInspection = Promise.PromiseInspection;
var util = dereq("./util");

function SettledPromiseArray(values) {
this.constructor$(values);
}
util.inherits(SettledPromiseArray, PromiseArray);

SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
this._values[index] = inspection;
var totalResolved = ++this._totalResolved;
if (totalResolved >= this._length) {
this._resolve(this._values);
return true;
}
return false;
};

SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
var ret = new PromiseInspection();
ret._bitField = 33554432;
ret._settledValueField = value;
return this._promiseResolved(index, ret);
};
SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
var ret = new PromiseInspection();
ret._bitField = 16777216;
ret._settledValueField = reason;
return this._promiseResolved(index, ret);
};

Promise.settle = function (promises) {
debug.deprecated(".settle()", ".reflect()");
return new SettledPromiseArray(promises).promise();
};

Promise.prototype.settle = function () {
return Promise.settle(this);
};
};

},{"./util":36}],31:[function(dereq,module,exports){
"use strict";
module.exports =
function(Promise, PromiseArray, apiRejection) {
var util = dereq("./util");
var RangeError = dereq("./errors").RangeError;
var AggregateError = dereq("./errors").AggregateError;
var isArray = util.isArray;
var CANCELLATION = {};

function SomePromiseArray(values) {
this.constructor$(values);
this._howMany = 0;
this._unwrap = false;
this._initialized = false;
}
util.inherits(SomePromiseArray, PromiseArray);

SomePromiseArray.prototype._init = function () {
if (!this._initialized) {
return;
}
if (this._howMany === 0) {
this._resolve([]);
return;
}
this._init$(undefined, -5);
var isArrayResolved = isArray(this._values);
if (!this._isResolved() &&
isArrayResolved &&
this._howMany > this._canPossiblyFulfill()) {
this._reject(this._getRangeError(this.length()));
}
};

SomePromiseArray.prototype.init = function () {
this._initialized = true;
this._init();
};

SomePromiseArray.prototype.setUnwrap = function () {
this._unwrap = true;
};

SomePromiseArray.prototype.howMany = function () {
return this._howMany;
};

SomePromiseArray.prototype.setHowMany = function (count) {
this._howMany = count;
};

SomePromiseArray.prototype._promiseFulfilled = function (value) {
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);
}
return true;
}
return false;

};
SomePromiseArray.prototype._promiseRejected = function (reason) {
this._addRejected(reason);
return this._checkOutcome();
};

SomePromiseArray.prototype._promiseCancelled = function () {
if (this._values instanceof Promise || this._values == null) {
return this._cancel();
}
this._addRejected(CANCELLATION);
return this._checkOutcome();
};

SomePromiseArray.prototype._checkOutcome = function() {
if (this.howMany() > this._canPossiblyFulfill()) {
var e = new AggregateError();
for (var i = this.length(); i < this._values.length; ++i) {
if (this._values[i] !== CANCELLATION) {
e.push(this._values[i]);
}
}
if (e.length > 0) {
this._reject(e);
} else {
this._cancel();
}
return true;
}
return false;
};

SomePromiseArray.prototype._fulfilled = function () {
return this._totalResolved;
};

SomePromiseArray.prototype._rejected = function () {
return this._values.length - this.length();
};

SomePromiseArray.prototype._addRejected = function (reason) {
this._values.push(reason);
};

SomePromiseArray.prototype._addFulfilled = function (value) {
this._values[this._totalResolved++] = value;
};

SomePromiseArray.prototype._canPossiblyFulfill = function () {
return this.length() - this._rejected();
};

SomePromiseArray.prototype._getRangeError = function (count) {
var message = "Input array must contain at least " +
this._howMany + " items but contains only " + count + " items";
return new RangeError(message);
};

SomePromiseArray.prototype._resolveEmptyArray = function () {
this._reject(this._getRangeError(0));
};

function some(promises, howMany) {
if ((howMany | 0) !== howMany || howMany < 0) {
return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/MqrFmX\u000a");
}
var ret = new SomePromiseArray(promises);
var promise = ret.promise();
ret.setHowMany(howMany);
ret.init();
return promise;
}

Promise.some = function (promises, howMany) {
return some(promises, howMany);
};

Promise.prototype.some = function (howMany) {
return some(this, howMany);
};

Promise._SomePromiseArray = SomePromiseArray;
};

},{"./errors":12,"./util":36}],32:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise) {
function PromiseInspection(promise) {
if (promise !== undefined) {
promise = promise._target();
this._bitField = promise._bitField;
this._settledValueField = promise._isFateSealed()
? promise._settledValue() : undefined;
}
else {
this._bitField = 0;
this._settledValueField = undefined;
}
}

PromiseInspection.prototype._settledValue = function() {
return this._settledValueField;
};

var value = PromiseInspection.prototype.value = function () {
if (!this.isFulfilled()) {
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
}
return this._settledValue();
};

var reason = PromiseInspection.prototype.error =
PromiseInspection.prototype.reason = function () {
if (!this.isRejected()) {
throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
}
return this._settledValue();
};

var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
return (this._bitField & 33554432) !== 0;
};

var isRejected = PromiseInspection.prototype.isRejected = function () {
return (this._bitField & 16777216) !== 0;
};

var isPending = PromiseInspection.prototype.isPending = function () {
return (this._bitField & 50397184) === 0;
};

var isResolved = PromiseInspection.prototype.isResolved = function () {
return (this._bitField & 50331648) !== 0;
};

PromiseInspection.prototype.isCancelled = function() {
return (this._bitField & 8454144) !== 0;
};

Promise.prototype.__isCancelled = function() {
return (this._bitField & 65536) === 65536;
};

Promise.prototype._isCancelled = function() {
return this._target().__isCancelled();
};

Promise.prototype.isCancelled = function() {
return (this._target()._bitField & 8454144) !== 0;
};

Promise.prototype.isPending = function() {
return isPending.call(this._target());
};

Promise.prototype.isRejected = function() {
return isRejected.call(this._target());
};

Promise.prototype.isFulfilled = function() {
return isFulfilled.call(this._target());
};

Promise.prototype.isResolved = function() {
return isResolved.call(this._target());
};

Promise.prototype.value = function() {
return value.call(this._target());
};

Promise.prototype.reason = function() {
var target = this._target();
target._unsetRejectionIsUnhandled();
return reason.call(target);
};

Promise.prototype._value = function() {
return this._settledValue();
};

Promise.prototype._reason = function() {
this._unsetRejectionIsUnhandled();
return this._settledValue();
};

Promise.PromiseInspection = PromiseInspection;
};

},{}],33:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL) {
var util = dereq("./util");
var errorObj = util.errorObj;
var isObject = util.isObject;

function doGetThen(obj) {
return obj.then;
}

function getThen(obj) {
try {
return doGetThen(obj);
} catch (e) {
errorObj.e = e;
return errorObj;
}
}

var hasProp = {}.hasOwnProperty;
function isAnyBluebirdPromise(obj) {
try {
return hasProp.call(obj, "_promise0");
} catch (e) {
return false;
}
}

function doThenable(x, then, context) {
var promise = new Promise(INTERNAL);
var ret = promise;
if (context) context._pushContext();
promise._captureStackTrace();
if (context) context._popContext();
var synchronous = true;
var result = util.tryCatch(then).call(x, resolve, reject);
synchronous = false;

if (promise && result === errorObj) {
    promise._rejectCallback(result.e, true, true);
    promise = null;
}

function resolve(value) {
    if (!promise) return;
    promise._resolveCallback(value);
    promise = null;
}

function reject(reason) {
    if (!promise) return;
    promise._rejectCallback(reason, synchronous, true);
    promise = null;
}
return ret;

}

return tryConvertToPromise;
};

},{"./util":36}],34:[function(dereq,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL, debug) {
var util = dereq("./util");
var TimeoutError = Promise.TimeoutError;

function HandleWrapper(handle) {
this.handle = handle;
}

HandleWrapper.prototype._resultCancelled = function() {
clearTimeout(this.handle);
};

Promise.prototype.delay = function (ms) {
return delay(ms, this);
};

if (parent != null) {
    parent.cancel();
}

};

function successClear(value) {
clearTimeout(this.handle);
return value;
}

function failureClear(reason) {
clearTimeout(this.handle);
throw reason;
}

Promise.prototype.timeout = function (ms, message) {
ms = +ms;
var ret, parent;

var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {
    if (ret.isPending()) {
        afterTimeout(ret, message, parent);
    }
}, ms));

if (debug.cancellation()) {
    parent = this.then();
    ret = parent._then(successClear, failureClear,
                        undefined, handleWrapper, undefined);
    ret._setOnCancel(handleWrapper);
} else {
    ret = this._then(successClear, failureClear,
                        undefined, handleWrapper, undefined);
}

return ret;

};

},{"./util":36}],35:[function(dereq,module,exports){
"use strict";
module.exports = function (Promise, apiRejection, tryConvertToPromise,
createContext, INTERNAL, debug) {
var util = dereq("./util");
var TypeError = dereq("./errors").TypeError;
var inherits = dereq("./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();
};

};

},{"./errors":12,"./util":36}],36:[function(dereq,module,exports){
"use strict";
var es5 = dereq("./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;

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");
}

function classString(obj) {
return {}.toString.call(obj);
}

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 = vSymbol.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;

},{"./es5":13}]},{},[4])(4)
}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; }

App.config

[Supporting different data and serialization formats in WCF.zip](https://github.com/az6161311/Test/files/2324585/Supporting.different.data.and.serialization.formats.in.WCF.zip)

AutomationBuild.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BuildDtoClass
{
public class AutomationBuild
{
private string path { get; set; }
private string contextName { get; set; }
private string connectionName { get; set; }
private string namespaceName { get; set; }
private string description { get; set; }
public AutomationBuild()
{
path = System.Configuration.ConfigurationManager.AppSettings["AutomationPath"];
contextName = System.Configuration.ConfigurationManager.AppSettings["AutomationContextName"];
connectionName = System.Configuration.ConfigurationManager.AppSettings["AutomationConnectionName"];
namespaceName = System.Configuration.ConfigurationManager.AppSettings["AutomationNamespaceName"];
description = System.Configuration.ConfigurationManager.AppSettings["AutomationDescription"];
if (!string.IsNullOrEmpty(description))
{
description = description.Replace("CurrentDateTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
}
}
public void DataBulid()
{
BulidModel();
BulidMap();
BulidContext();
BulidDto();
}
private void BulidContext()
{
var contextContent = new StringBuilder();
var blankContent = " ";
var mapContext = new StringBuilder();
var tableNames = SqlHelper.ExecuteDataTable("select name from sysobjects where xtype = 'U' ").ToList();
var notKeyTableNames = GetNotKeyTableNames();
foreach (var tableName in tableNames)
{
if (!notKeyTableNames.Any(a => a.ToLower() == tableName.Name.ToLower()))
{
contextContent.AppendLine(blankContent + string.Format("public virtual DbSet<{0}> {0} {{ get; set; }}", tableName.Name));
mapContext.AppendLine(blankContent + string.Format("modelBuilder.Configurations.Add(new {0}Map());", tableName.Name));
}

        }
        var outContextContent = string.Format(@"{0}

namespace {1}
{{
using Model;
using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;

public partial class {2} : DbContext
{{
    public TaxRiskDBContext()
        : base(""name = {3}"")
    {{
    }}


    static {2}()
    {{
        Database.SetInitializer<{2}>(null);
    }}
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {{
    {4}
    }}

{5}
}}
}}
", description, namespaceName, contextName, connectionName, mapContext.ToString(), contextContent.ToString());

        var outFilePath = Path.Combine(path, contextName + ".cs");
        if (File.Exists(outFilePath))
        {
            File.Delete(outFilePath);
        }
        File.AppendAllText(outFilePath, outContextContent);
    }

    private void BulidModel()
    {
        var outPath = path;

        outPath = Path.Combine(outPath, "Model");
        if (!System.IO.Directory.Exists(outPath))
        {
            Directory.CreateDirectory(outPath);
        }
        var tableNames = SqlHelper.ExecuteDataTable("select name from sysobjects where xtype = 'U' ").ToList<DataTableName>();
        var notKeyTableNames = GetNotKeyTableNames();
        foreach (var item in tableNames)
        {

            if (!notKeyTableNames.Any(a => a.ToLower() == item.Name.ToLower()))
            {
                #region sql
                var sql = @"SELECT
CASE
    WHEN col.colorder = 1 THEN obj.name
    ELSE ''
END AS 表名

,col.colorder AS 序号
,col.name AS 列名
,ISNULL(ep.[value], '') AS 列说明
, t.name AS 数据类型
,col.length AS 长度
,ISNULL(COLUMNPROPERTY(col.id, col.name, 'Scale'), 0) AS 小数位数
, CASE
WHEN COLUMNPROPERTY(col.id, col.name, 'IsIdentity') = 1 THEN '√'
ELSE ''
END AS 标识
,CASE
WHEN EXISTS(SELECT
1
FROM dbo.sysindexes si
INNER JOIN dbo.sysindexkeys sik
ON si.id = sik.id
AND si.indid = sik.indid
INNER JOIN dbo.syscolumns sc
ON sc.id = sik.id
AND sc.colid = sik.colid
INNER JOIN dbo.sysobjects so
ON so.name = si.name
AND so.xtype = 'PK'
WHERE sc.id = col.id
AND sc.colid = col.colid) THEN '√'
ELSE ''
END AS 主键
,CASE
WHEN col.isnullable = 1 THEN '√'
ELSE ''
END AS 允许空
,ISNULL(comm.text, '') AS 默认值
FROM dbo.syscolumns col
LEFT JOIN dbo.systypes t
ON col.xtype = t.xusertype
INNER JOIN dbo.sysobjects obj
ON col.id = obj.id
AND obj.xtype = 'U'
AND obj.status >= 0
LEFT JOIN dbo.syscomments comm
ON col.cdefault = comm.id
LEFT JOIN sys.extended_properties ep
ON col.id = ep.major_id
AND col.colid = ep.minor_id
AND ep.name = 'MS_Description'
LEFT JOIN sys.extended_properties epTwo
ON obj.id = epTwo.major_id
AND epTwo.minor_id = 0
AND epTwo.name = 'MS_Description'
WHERE obj.name = '" + item.Name + @"'--表名
ORDER BY col.colorder; ";
#endregion

                StringBuilder outModel = new StringBuilder();
                var tableInfos = SqlHelper.ExecuteDataTable(sql).ToList<TableInfo>();
                var outContent = new StringBuilder();
                outModel.AppendLine(@"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
");
outModel.AppendLine(description);
outModel.AppendLine(string.Format("namespace {0}.Model", namespaceName));
outModel.AppendLine("{");
outModel.AppendLine(" public partial class " + item.Name + "");
outModel.AppendLine(" {");
foreach (var tableInfo in tableInfos)
{
var typeString = SqlTypeHelper.SqlTypeStringToCsharpTypeString(tableInfo.数据类型);
if (!string.IsNullOrEmpty(tableInfo.允许空))
{
if (typeString.ToLower() != "string")
typeString += "?";
}
outContent.AppendFormat(@" public {0} {1} {{ get; set; }}", typeString, tableInfo.列名);
outContent.AppendLine();
}
outContent.AppendLine();
outModel.AppendLine(outContent.ToString());
outModel.AppendLine(" }");
outModel.AppendLine("}");

                var outFilePath = Path.Combine(outPath, item.Name + ".cs");
                if (File.Exists(outFilePath))
                {
                    File.Delete(outFilePath);
                }
                System.IO.File.AppendAllText(outFilePath, outModel.ToString());
            }
        }
    }
    private void BulidMap()
    {
        var outPath = path;

        outPath = Path.Combine(outPath, "Map");
        if (!System.IO.Directory.Exists(outPath))
        {
            Directory.CreateDirectory(outPath);
        }
        var tableNames = SqlHelper.ExecuteDataTable("select name from sysobjects where xtype = 'U' ").ToList<DataTableName>();
        var notKeyTableNames = GetNotKeyTableNames();
        foreach (var item in tableNames)
        {
            if (!notKeyTableNames.Any(a => a.ToLower() == item.Name.ToLower()))
            {
                #region sql
                var sql = @"SELECT
CASE
    WHEN col.colorder = 1 THEN obj.name
    ELSE ''
END AS 表名

                StringBuilder outMap = new StringBuilder();
                var tableInfos = SqlHelper.ExecuteDataTable(sql).ToList<TableInfo>();
                var outContent = new StringBuilder();
                outMap.AppendLine("using System.ComponentModel.DataAnnotations.Schema;");
                outMap.AppendLine("using System.Data.Entity.ModelConfiguration;");
                outMap.AppendLine(description);
                outMap.AppendLine("namespace Huawei.TaxRisk.Model");
                outMap.AppendLine("{");
                outMap.AppendLine("    public partial class " + item.Name + "Map : EntityTypeConfiguration<" + item.Name + ">");
                outMap.AppendLine("    {");
                outMap.AppendLine("        public " + item.Name + "Map()");
                outMap.AppendLine("        {");
                var outColumnName = new StringBuilder();
                foreach (var tableInfo in tableInfos)
                {
                    #region Properties
                    if (!string.IsNullOrEmpty(tableInfo.主键))
                    {
                        outContent.AppendLine("            this.HasKey(t => t." + tableInfo.列名 + ");");
                    }
                    else
                    {
                        outContent.Append("            this.Property(t => t." + tableInfo.列名 + ")");
                        if (tableInfo.数据类型 == "nvarchar" || tableInfo.数据类型 == "varchar")
                        {
                            #region 是否为必填 
                            if (string.IsNullOrEmpty(tableInfo.允许空))
                            {
                                outContent.Append(".IsRequired()");
                            }
                            #endregion

                            #region 最大长度
                            if (tableInfo.长度 != -1)
                            {
                                outContent.Append(".HasMaxLength(" + tableInfo.长度 / 2 + ")");
                            }
                            #endregion
                            outContent.AppendLine(";");
                        }
                        else if (tableInfo.数据类型 == "decimal")
                        {
                            outContent.AppendLine(".HasPrecision(" + (tableInfo.长度 * 2) + "," + tableInfo.小数位数 + ");");
                        }
                        else
                        {
                            outContent.AppendLine(";");
                        }
                    }

                    #region 字段映射
                    outColumnName.AppendLine("            this.Property(t => t." + tableInfo.列名 + ").HasColumnName(\"" + tableInfo.列名 + "\");");
                    #endregion
                    #endregion
                }
                outContent.AppendLine();
                outContent.AppendLine("            this.ToTable(\"" + item.Name + "\");");
                outContent.AppendLine("            " + outColumnName.ToString() + "");
                outMap.AppendLine(outContent.ToString());
                outMap.AppendLine("        }");
                outMap.AppendLine("    }");
                outMap.AppendLine("}");

                var outFilePath = Path.Combine(outPath, item.Name + "Map.cs");
                if (File.Exists(outFilePath))
                {
                    File.Delete(outFilePath);
                }
                System.IO.File.AppendAllText(outFilePath, outMap.ToString());
            }
        }
    }
    private void BulidDto()
    {

        var outPath = path;

        outPath = Path.Combine(outPath, "Dto");
        if (!System.IO.Directory.Exists(outPath))
        {
            Directory.CreateDirectory(outPath);
        }
        var tableNames = SqlHelper.ExecuteDataTable("select name from sysobjects where xtype = 'U' ").ToList<DataTableName>();
        var notKeyTableNames = GetNotKeyTableNames();
        foreach (var item in tableNames)
        {
            if (!notKeyTableNames.Any(a => a.ToLower() == item.Name.ToLower()))
            {
                #region sql
                var sql = @"SELECT
CASE
    WHEN col.colorder = 1 THEN obj.name
    ELSE ''
END AS 表名

                StringBuilder outDto = new StringBuilder();
                var tableInfos = SqlHelper.ExecuteDataTable(sql).ToList<TableInfo>();
                var outContent = new StringBuilder();
                outDto.AppendLine(@"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Huawei.TaxRisk.Model;
");
outDto.AppendLine(description);
outDto.AppendLine(@"namespace Huawei.TaxRisk.Dto");
outDto.AppendLine("{");
outDto.AppendLine(" [DataContract]");
outDto.AppendLine(" public partial class " + item.Name + "Dto");
outDto.AppendLine(" {");
var StructureStr = new StringBuilder();
foreach (var tableInfo in tableInfos)
{
var typeString = SqlTypeHelper.SqlTypeStringToCsharpTypeString(tableInfo.数据类型);
if (!string.IsNullOrEmpty(tableInfo.允许空))
{
if (typeString.ToLower() != "string")
typeString += "?";
}
outContent.AppendFormat(@" [DataMember]
public {0} {1} {{ get; set; }}", typeString, tableInfo.列名);
outContent.AppendLine();
StructureStr.AppendLine(" this." + tableInfo.列名 + " = input." + tableInfo.列名 + ";");
}
outContent.AppendLine();

                outDto.AppendLine("        public " + item.Name + "Dto()");
                outDto.AppendLine("        {");
                outDto.AppendLine("        }");
                outDto.AppendLine("        public " + item.Name + "Dto(" + item.Name + " input)");
                outDto.AppendLine("        {");
                outDto.AppendLine(StructureStr.ToString());
                outDto.AppendLine("        }");
                outDto.AppendLine(outContent.ToString());
                outDto.AppendLine("    }");
                outDto.AppendLine("}");

                var outFilePath = Path.Combine(outPath, item.Name + "Dto.cs");
                if (File.Exists(outFilePath))
                {
                    File.Delete(outFilePath);
                }
                System.IO.File.AppendAllText(outFilePath, outDto.ToString());
            }
        }
    }

    private List<string> GetNotKeyTableNames()
    {
        var sql = @"

SELECT name FROM sys.tables
EXCEPT
SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS
WHERE CONSTRAINT_TYPE = 'PRIMARY KEY'";

        var tableNames = SqlHelper.ExecuteDataTable(sql).ToList<DataTableName>();
        if (tableNames != null)
            return tableNames.Select(s => s.Name).ToList();
        else
        {
            return new List<string>();
        }
    }
}

}

polyfill.min.js?features=es6

/* Disable minification (remove .min from URL path) for more info */

TableListHelper.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace BulidDtoClass
{
public static class TableListHelper
{

    /// <summary>  
    /// 转化一个DataTable  
    /// </summary>  
    /// <typeparam name="T"></typeparam>  
    /// <param name="list"></param>  
    /// <returns></returns>  
    public static DataTable ToDataTable<T>(this IEnumerable<T> list)
    {
        //创建属性的集合  
        List<PropertyInfo> pList = new List<PropertyInfo>();
        //获得反射的入口  
        Type type = typeof(T);
        DataTable dt = new DataTable();
        //把所有的public属性加入到集合 并添加DataTable的列  
        Array.ForEach<PropertyInfo>(type.GetProperties(), p => { pList.Add(p); dt.Columns.Add(p.Name, p.PropertyType); });
        foreach (var item in list)
        {
            //创建一个DataRow实例  
            DataRow row = dt.NewRow();
            //给row 赋值  
            pList.ForEach(p => row[p.Name] = p.GetValue(item, null));
            //加入到DataTable  
            dt.Rows.Add(row);
        }
        return dt;
    }


    /// <summary>  
    /// DataTable 转换为List 集合  
    /// </summary>  
    /// <typeparam name="TResult">类型</typeparam>  
    /// <param name="dt">DataTable</param>  
    /// <returns></returns>  
    public static List<T> ToList<T>(this DataTable dt) where T : class, new()
    {
        //创建一个属性的列表  
        List<PropertyInfo> prlist = new List<PropertyInfo>();
        //获取TResult的类型实例  反射的入口  

        Type t = typeof(T);

        //获得TResult 的所有的Public 属性 并找出TResult属性和DataTable的列名称相同的属性(PropertyInfo) 并加入到属性列表   
        Array.ForEach<PropertyInfo>(t.GetProperties(), p => { if (dt.Columns.IndexOf(p.Name) != -1) prlist.Add(p); });

        //创建返回的集合  

        List<T> oblist = new List<T>();

        foreach (DataRow row in dt.Rows)
        {
            //创建TResult的实例  
            T ob = new T();
            //找到对应的数据  并赋值  
            prlist.ForEach(p => { if (row[p.Name] != DBNull.Value) p.SetValue(ob, row[p.Name], null); });
            //放入到返回的集合中.  
            oblist.Add(ob);
        }
        return oblist;
    }


    /// <summary>  
    /// 将集合类转换成DataTable  
    /// </summary>  
    /// <param name="list">集合</param>  
    /// <returns></returns>  
    public static DataTable ToDataTableTow(IList list)
    {
        DataTable result = new DataTable();
        if (list.Count > 0)
        {
            PropertyInfo[] propertys = list[0].GetType().GetProperties();

            foreach (PropertyInfo pi in propertys)
            {
                result.Columns.Add(pi.Name, pi.PropertyType);
            }
            for (int i = 0; i < list.Count; i++)
            {
                ArrayList tempList = new ArrayList();
                foreach (PropertyInfo pi in propertys)
                {
                    object obj = pi.GetValue(list[i], null);
                    tempList.Add(obj);
                }
                object[] array = tempList.ToArray();
                result.LoadDataRow(array, true);
            }
        }
        return result;
    }


    /// <summary>  
    /// 将泛型集合类转换成DataTable  
    /// </summary>  
    /// <typeparam name="T">集合项类型</typeparam>  
    /// <param name="list">集合</param>  
    /// <param name="propertyName">需要返回的列的列名</param>  
    /// <returns>数据集(表)</returns>  
    public static DataTable ToDataTable<T>(IList<T> list, params string[] propertyName)
    {
        List<string> propertyNameList = new List<string>();
        if (propertyName != null)
            propertyNameList.AddRange(propertyName);
        DataTable result = new DataTable();
        if (list.Count > 0)
        {
            PropertyInfo[] propertys = list[0].GetType().GetProperties();
            foreach (PropertyInfo pi in propertys)
            {
                if (propertyNameList.Count == 0)
                {
                    result.Columns.Add(pi.Name, pi.PropertyType);
                }
                else
                {
                    if (propertyNameList.Contains(pi.Name))
                        result.Columns.Add(pi.Name, pi.PropertyType);
                }
            }

            for (int i = 0; i < list.Count; i++)
            {
                ArrayList tempList = new ArrayList();
                foreach (PropertyInfo pi in propertys)
                {
                    if (propertyNameList.Count == 0)
                    {
                        object obj = pi.GetValue(list[i], null);
                        tempList.Add(obj);
                    }
                    else
                    {
                        if (propertyNameList.Contains(pi.Name))
                        {
                            object obj = pi.GetValue(list[i], null);
                            tempList.Add(obj);
                        }
                    }
                }
                object[] array = tempList.ToArray();
                result.LoadDataRow(array, true);
            }
        }
        return result;
    }

}

}

ClassGeneratHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using System.Configuration;

namespace BulidDtoClass
{
///

/// ** 描述：实体生成类
///

public class ClassGeneratHelper
{
///

/// 根据匿名类获取实体类的字符串
///

/// 匿名对象
/// 生成的类名
///
public static string DynamicToClass(object entity, string className)
{
StringBuilder reval = new StringBuilder();
StringBuilder propertiesValue = new StringBuilder();
var propertiesObj = entity.GetType().GetProperties();
string replaceGuid = Guid.NewGuid().ToString();
string nullable = string.Empty;
foreach (var r in propertiesObj)
{

            var type = r.PropertyType;
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                type = type.GetGenericArguments()[0];
                nullable = "?";
            }
            if (!type.Namespace.Contains("System.Collections.Generic"))
            {
                propertiesValue.AppendLine();
                string typeName = ChangeType(type);
                propertiesValue.AppendFormat("public {0}{3} {1} {2}", typeName, r.Name, "{get;set;}", nullable);
                propertiesValue.AppendLine();
            }
        }

        reval.AppendFormat(@"
             public class {0}{{
                    {1}
             }}
        ", className, propertiesValue);


        return reval.ToString();
    }


    /// <summary>
    /// 根据DataTable获取实体类的字符串
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="className"></param>
    /// <returns></returns>
    public static string DataTableToClass(DataTable dt, string className)
    {
        StringBuilder reval = new StringBuilder();
        StringBuilder propertiesValue = new StringBuilder();
        string replaceGuid = Guid.NewGuid().ToString();
        foreach (DataColumn r in dt.Columns)
        {
            propertiesValue.AppendLine();
            string typeName = ChangeType(r.DataType);
            propertiesValue.AppendLine("        " + ConfigurationManager.AppSettings["PropertyFeature"]);
            propertiesValue.AppendFormat("        public {0} {1} {2}", typeName, r.ColumnName, "{get;set;}");
            propertiesValue.AppendLine();
        }
        var classFeature = ConfigurationManager.AppSettings["ClassFeature"];
        reval.AppendFormat(@"
{0}
public class {1}
{{
{2}
}}
        ", classFeature, className, propertiesValue);


        return reval.ToString();
    }

    /// <summary>
    ///  根据SQL语句获取实体类的字符串
    /// </summary>
    /// <param name="sql">SQL语句</param>
    /// <param name="className">生成的类名</param>
    /// <param name="server">服务名</param>
    /// <param name="database">数据库名称</param>
    /// <param name="uid">账号</param>
    /// <param name="pwd">密码</param>
    /// <returns></returns>
    public static string SqlToClass(string sql, string className, string server, string database, string uid, string pwd)
    {
        using (SqlConnection conn = new SqlConnection(string.Format("server={0};uid={2};pwd={3};database={1}", server, database, uid, pwd)))
        {
            SqlCommand command = new SqlCommand();
            command.Connection = conn;
            command.CommandText = sql;
            DataTable dt = new DataTable();
            SqlDataAdapter sad = new SqlDataAdapter(command);
            sad.Fill(dt);
            var reval = DataTableToClass(dt, className);
            return reval;
        }
    }
    /// <summary>
    ///  根据SQL语句获取实体类的字符串
    /// </summary>
    /// <param name="sql">SQL语句</param>
    /// <param name="className">生成的类名</param>
    /// <param name="connName">webconfig的connectionStrings name</param>
    /// <returns></returns>
    public static string SqlToClass(string sql, string className, string connName)
    {
        string connstr = System.Configuration.ConfigurationManager.ConnectionStrings[connName].ToString();
        if (connstr.Contains("metadata"))//ef
            connstr = Regex.Match(connstr, @"connection string\=""(.+)""").Groups[1].Value;
        using (SqlConnection conn = new SqlConnection(connstr))
        {
            SqlCommand command = new SqlCommand();
            command.Connection = conn;
            command.CommandText = sql;
            DataTable dt = new DataTable();
            SqlDataAdapter sad = new SqlDataAdapter(command);
            sad.Fill(dt);
            var reval = DataTableToClass(dt, className);
            return reval;
        }
    }
    /// <summary>
    /// 匹配类型
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private static string ChangeType(Type type)
    {
        string typeName = type.Name;
        switch (typeName)
        {
            case "Int32": typeName = "int"; break;
            case "String": typeName = "string"; break;
        }
        return typeName;
    }
}

}

Program.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BulidDtoClass
{
class Program
{
static void Main(string[] args)
{
var namespaceName = ConfigurationManager.AppSettings["namespaceName"] ?? "BulidDto_" + DateTime.Now.ToString("yyyyMMdd");

        var usingList = ConfigurationManager.AppSettings["UsingList"];
        var outPath = ConfigurationManager.AppSettings["OutPath"];
        var tableNames = SqlHelper.ExecuteDataTable("select name from sysobjects where xtype = 'U' ").ToList<DataTableName>();
        foreach (var tableName in tableNames)
        {
            var outClass = @"using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
";
outClass += usingList;
outClass += @"
namespace " + namespaceName;
outClass += @"
{";
var tableData = SqlHelper.ExecuteDataTable("select * from " + tableName.Name);
var classCode = ClassGeneratHelper.DataTableToClass(tableData, tableName.Name + "Dto");
outClass += classCode;
outClass += @"
}";
System.IO.File.AppendAllText(Path.Combine(outPath, tableName.Name + "Dto.cs"), outClass);
}
}
}

public class DataTableName
{
    public string Name { get; set; }
}

}

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.