BVB Source Codes

mobile-chrome-apps Show q.js Source code

Return Download mobile-chrome-apps: download q.js Source code - Download mobile-chrome-apps Source code - Type:.js
  1. // vim:ts=4:sts=4:sw=4:
  2. /*!
  3.  *
  4.  * Copyright 2009-2012 Kris Kowal under the terms of the MIT
  5.  * license found at http://github.com/kriskowal/q/raw/master/LICENSE
  6.  *
  7.  * With parts by Tyler Close
  8.  * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
  9.  * at http://www.opensource.org/licenses/mit-license.html
  10.  * Forked at ref_send.js version: 2009-05-11
  11.  *
  12.  * With parts by Mark Miller
  13.  * Copyright (C) 2011 Google Inc.
  14.  *
  15.  * Licensed under the Apache License, Version 2.0 (the "License");
  16.  * you may not use this file except in compliance with the License.
  17.  * You may obtain a copy of the License at
  18.  *
  19.  * http://www.apache.org/licenses/LICENSE-2.0
  20.  *
  21.  * Unless required by applicable law or agreed to in writing, software
  22.  * distributed under the License is distributed on an "AS IS" BASIS,
  23.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24.  * See the License for the specific language governing permissions and
  25.  * limitations under the License.
  26.  *
  27.  */
  28.  
  29. (function (definition) {
  30.     // Turn off strict mode for this function so we can assign to global.Q
  31.     /* jshint strict: false */
  32.  
  33.     // This file will function properly as a <script> tag, or a module
  34.     // using CommonJS and NodeJS or RequireJS module formats.  In
  35.     // Common/Node/RequireJS, the module exports the Q API and when
  36.     // executed as a simple <script>, it creates a Q global instead.
  37.  
  38.     // Montage Require
  39.     if (typeof bootstrap === "function") {
  40.         bootstrap("promise", definition);
  41.  
  42.     // CommonJS
  43.     } else if (typeof exports === "object") {
  44.         module.exports = definition();
  45.  
  46.     // RequireJS
  47.     } else if (typeof define === "function" && define.amd) {
  48.         define(definition);
  49.  
  50.     // SES (Secure EcmaScript)
  51.     } else if (typeof ses !== "undefined") {
  52.         if (!ses.ok()) {
  53.             return;
  54.         } else {
  55.             ses.makeQ = definition;
  56.         }
  57.  
  58.     // <script>
  59.     } else {
  60.         Q = definition();
  61.     }
  62.  
  63. })(function () {
  64. "use strict";
  65.  
  66. var hasStacks = false;
  67. try {
  68.     throw new Error();
  69. } catch (e) {
  70.     hasStacks = !!e.stack;
  71. }
  72.  
  73. // All code after this point will be filtered from stack traces reported
  74. // by Q.
  75. var qStartingLine = captureLine();
  76. var qFileName;
  77.  
  78. // shims
  79.  
  80. // used for fallback in "allResolved"
  81. var noop = function () {};
  82.  
  83. // Use the fastest possible means to execute a task in a future turn
  84. // of the event loop.
  85. var nextTick =(function () {
  86.     // linked list of tasks (single, with head node)
  87.     var head = {task: void 0, next: null};
  88.     var tail = head;
  89.     var flushing = false;
  90.     var requestTick = void 0;
  91.     var isNodeJS = false;
  92.  
  93.     function flush() {
  94.         /* jshint loopfunc: true */
  95.  
  96.         while (head.next) {
  97.             head = head.next;
  98.             var task = head.task;
  99.             head.task = void 0;
  100.             var domain = head.domain;
  101.  
  102.             if (domain) {
  103.                 head.domain = void 0;
  104.                 domain.enter();
  105.             }
  106.  
  107.             try {
  108.                 task();
  109.  
  110.             } catch (e) {
  111.                 if (isNodeJS) {
  112.                     // In node, uncaught exceptions are considered fatal errors.
  113.                     // Re-throw them synchronously to interrupt flushing!
  114.  
  115.                     // Ensure continuation if the uncaught exception is suppressed
  116.                     // listening "uncaughtException" events (as domains does).
  117.                     // Continue in next event to avoid tick recursion.
  118.                     if (domain) {
  119.                         domain.exit();
  120.                     }
  121.                     setTimeout(flush, 0);
  122.                     if (domain) {
  123.                         domain.enter();
  124.                     }
  125.  
  126.                     throw e;
  127.  
  128.                 } else {
  129.                     // In browsers, uncaught exceptions are not fatal.
  130.                     // Re-throw them asynchronously to avoid slow-downs.
  131.                     setTimeout(function() {
  132.                        throw e;
  133.                     }, 0);
  134.                 }
  135.             }
  136.  
  137.             if (domain) {
  138.                 domain.exit();
  139.             }
  140.         }
  141.  
  142.         flushing = false;
  143.     }
  144.  
  145.     nextTick = function (task) {
  146.         tail = tail.next = {
  147.             task: task,
  148.             domain: isNodeJS && process.domain,
  149.             next: null
  150.         };
  151.  
  152.         if (!flushing) {
  153.             flushing = true;
  154.             requestTick();
  155.         }
  156.     };
  157.  
  158.     if (typeof process !== "undefined" && process.nextTick) {
  159.         // Node.js before 0.9. Note that some fake-Node environments, like the
  160.         // Mocha test runner, introduce a `process` global without a `nextTick`.
  161.         isNodeJS = true;
  162.  
  163.         requestTick = function () {
  164.             process.nextTick(flush);
  165.         };
  166.  
  167.     } else if (typeof setImmediate === "function") {
  168.         // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
  169.         if (typeof window !== "undefined") {
  170.             requestTick = setImmediate.bind(window, flush);
  171.         } else {
  172.             requestTick = function () {
  173.                 setImmediate(flush);
  174.             };
  175.         }
  176.  
  177.     } else if (typeof MessageChannel !== "undefined") {
  178.         // modern browsers
  179.         // http://www.nonblocking.io/2011/06/windownexttick.html
  180.         var channel = new MessageChannel();
  181.         // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
  182.         // working message ports the first time a page loads.
  183.         channel.port1.onmessage = function () {
  184.             requestTick = requestPortTick;
  185.             channel.port1.onmessage = flush;
  186.             flush();
  187.         };
  188.         var requestPortTick = function () {
  189.             // Opera requires us to provide a message payload, regardless of
  190.             // whether we use it.
  191.             channel.port2.postMessage(0);
  192.         };
  193.         requestTick = function () {
  194.             setTimeout(flush, 0);
  195.             requestPortTick();
  196.         };
  197.  
  198.     } else {
  199.         // old browsers
  200.         requestTick = function () {
  201.             setTimeout(flush, 0);
  202.         };
  203.     }
  204.  
  205.     return nextTick;
  206. })();
  207.  
  208. // Attempt to make generics safe in the face of downstream
  209. // modifications.
  210. // There is no situation where this is necessary.
  211. // If you need a security guarantee, these primordials need to be
  212. // deeply frozen anyway, and if you don鈥檛 need a security guarantee,
  213. // this is just plain paranoid.
  214. // However, this **might** have the nice side-effect of reducing the size of
  215. // the minified code by reducing x.call() to merely x()
  216. // See Mark Miller鈥檚 explanation of what this does.
  217. // http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
  218. var call = Function.call;
  219. function uncurryThis(f) {
  220.     return function () {
  221.         return call.apply(f, arguments);
  222.     };
  223. }
  224. // This is equivalent, but slower:
  225. // uncurryThis = Function_bind.bind(Function_bind.call);
  226. // http://jsperf.com/uncurrythis
  227.  
  228. var array_slice = uncurryThis(Array.prototype.slice);
  229.  
  230. var array_reduce = uncurryThis(
  231.     Array.prototype.reduce || function (callback, basis) {
  232.         var index = 0,
  233.             length = this.length;
  234.         // concerning the initial value, if one is not provided
  235.         if (arguments.length === 1) {
  236.             // seek to the first value in the array, accounting
  237.             // for the possibility that is is a sparse array
  238.             do {
  239.                 if (index in this) {
  240.                     basis = this[index++];
  241.                     break;
  242.                 }
  243.                 if (++index >= length) {
  244.                     throw new TypeError();
  245.                 }
  246.             } while (1);
  247.         }
  248.         // reduce
  249.         for (; index < length; index++) {
  250.             // account for the possibility that the array is sparse
  251.             if (index in this) {
  252.                 basis = callback(basis, this[index], index);
  253.             }
  254.         }
  255.         return basis;
  256.     }
  257. );
  258.  
  259. var array_indexOf = uncurryThis(
  260.     Array.prototype.indexOf || function (value) {
  261.         // not a very good shim, but good enough for our one use of it
  262.         for (var i = 0; i < this.length; i++) {
  263.             if (this[i] === value) {
  264.                 return i;
  265.             }
  266.         }
  267.         return -1;
  268.     }
  269. );
  270.  
  271. var array_map = uncurryThis(
  272.     Array.prototype.map || function (callback, thisp) {
  273.         var self = this;
  274.         var collect = [];
  275.         array_reduce(self, function (undefined, value, index) {
  276.             collect.push(callback.call(thisp, value, index, self));
  277.         }, void 0);
  278.         return collect;
  279.     }
  280. );
  281.  
  282. var object_create = Object.create || function (prototype) {
  283.     function Type() { }
  284.     Type.prototype = prototype;
  285.     return new Type();
  286. };
  287.  
  288. var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
  289.  
  290. var object_keys = Object.keys || function (object) {
  291.     var keys = [];
  292.     for (var key in object) {
  293.         if (object_hasOwnProperty(object, key)) {
  294.             keys.push(key);
  295.         }
  296.     }
  297.     return keys;
  298. };
  299.  
  300. var object_toString = uncurryThis(Object.prototype.toString);
  301.  
  302. function isObject(value) {
  303.     return value === Object(value);
  304. }
  305.  
  306. // generator related shims
  307.  
  308. // FIXME: Remove this function once ES6 generators are in SpiderMonkey.
  309. function isStopIteration(exception) {
  310.     return (
  311.         object_toString(exception) === "[object StopIteration]" ||
  312.         exception instanceof QReturnValue
  313.     );
  314. }
  315.  
  316. // FIXME: Remove this helper and Q.return once ES6 generators are in
  317. // SpiderMonkey.
  318. var QReturnValue;
  319. if (typeof ReturnValue !== "undefined") {
  320.     QReturnValue = ReturnValue;
  321. } else {
  322.     QReturnValue = function (value) {
  323.         this.value = value;
  324.     };
  325. }
  326.  
  327. // long stack traces
  328.  
  329. var STACK_JUMP_SEPARATOR = "From previous event:";
  330.  
  331. function makeStackTraceLong(error, promise) {
  332.     // If possible, transform the error stack trace by removing Node and Q
  333.     // cruft, then concatenating with the stack trace of `promise`. See #57.
  334.     if (hasStacks &&
  335.         promise.stack &&
  336.         typeof error === "object" &&
  337.         error !== null &&
  338.         error.stack &&
  339.         error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
  340.     ) {
  341.         var stacks = [];
  342.         for (var p = promise; !!p; p = p.source) {
  343.             if (p.stack) {
  344.                 stacks.unshift(p.stack);
  345.             }
  346.         }
  347.         stacks.unshift(error.stack);
  348.  
  349.         var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
  350.         error.stack = filterStackString(concatedStacks);
  351.     }
  352. }
  353.  
  354. function filterStackString(stackString) {
  355.     var lines = stackString.split("\n");
  356.     var desiredLines = [];
  357.     for (var i = 0; i < lines.length; ++i) {
  358.         var line = lines[i];
  359.  
  360.         if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
  361.             desiredLines.push(line);
  362.         }
  363.     }
  364.     return desiredLines.join("\n");
  365. }
  366.  
  367. function isNodeFrame(stackLine) {
  368.     return stackLine.indexOf("(module.js:") !== -1 ||
  369.            stackLine.indexOf("(node.js:") !== -1;
  370. }
  371.  
  372. function getFileNameAndLineNumber(stackLine) {
  373.     // Named functions: "at functionName (filename:lineNumber:columnNumber)"
  374.     // In IE10 function name can have spaces ("Anonymous function") O_o
  375.     var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
  376.     if (attempt1) {
  377.         return [attempt1[1], Number(attempt1[2])];
  378.     }
  379.  
  380.     // Anonymous functions: "at filename:lineNumber:columnNumber"
  381.     var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
  382.     if (attempt2) {
  383.         return [attempt2[1], Number(attempt2[2])];
  384.     }
  385.  
  386.     // Firefox style: "function@filename:lineNumber or @filename:lineNumber"
  387.     var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
  388.     if (attempt3) {
  389.         return [attempt3[1], Number(attempt3[2])];
  390.     }
  391. }
  392.  
  393. function isInternalFrame(stackLine) {
  394.     var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
  395.  
  396.     if (!fileNameAndLineNumber) {
  397.         return false;
  398.     }
  399.  
  400.     var fileName = fileNameAndLineNumber[0];
  401.     var lineNumber = fileNameAndLineNumber[1];
  402.  
  403.     return fileName === qFileName &&
  404.         lineNumber >= qStartingLine &&
  405.         lineNumber <= qEndingLine;
  406. }
  407.  
  408. // discover own file name and line number range for filtering stack
  409. // traces
  410. function captureLine() {
  411.     if (!hasStacks) {
  412.         return;
  413.     }
  414.  
  415.     try {
  416.         throw new Error();
  417.     } catch (e) {
  418.         var lines = e.stack.split("\n");
  419.         var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
  420.         var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
  421.         if (!fileNameAndLineNumber) {
  422.             return;
  423.         }
  424.  
  425.         qFileName = fileNameAndLineNumber[0];
  426.         return fileNameAndLineNumber[1];
  427.     }
  428. }
  429.  
  430. function deprecate(callback, name, alternative) {
  431.     return function () {
  432.         if (typeof console !== "undefined" &&
  433.             typeof console.warn === "function") {
  434.             console.warn(name + " is deprecated, use " + alternative +
  435.                          " instead.", new Error("").stack);
  436.         }
  437.         return callback.apply(callback, arguments);
  438.     };
  439. }
  440.  
  441. // end of shims
  442. // beginning of real work
  443.  
  444. /**
  445.  * Constructs a promise for an immediate reference, passes promises through, or
  446.  * coerces promises from different systems.
  447.  * @param value immediate reference or promise
  448.  */
  449. function Q(value) {
  450.     // If the object is already a Promise, return it directly.  This enables
  451.     // the resolve function to both be used to created references from objects,
  452.     // but to tolerably coerce non-promises to promises.
  453.     if (isPromise(value)) {
  454.         return value;
  455.     }
  456.  
  457.     // assimilate thenables
  458.     if (isPromiseAlike(value)) {
  459.         return coerce(value);
  460.     } else {
  461.         return fulfill(value);
  462.     }
  463. }
  464. Q.resolve = Q;
  465.  
  466. /**
  467.  * Performs a task in a future turn of the event loop.
  468.  * @param {Function} task
  469.  */
  470. Q.nextTick = nextTick;
  471.  
  472. /**
  473.  * Controls whether or not long stack traces will be on
  474.  */
  475. Q.longStackSupport = false;
  476.  
  477. /**
  478.  * Constructs a {promise, resolve, reject} object.
  479.  *
  480.  * `resolve` is a callback to invoke with a more resolved value for the
  481.  * promise. To fulfill the promise, invoke `resolve` with any value that is
  482.  * not a thenable. To reject the promise, invoke `resolve` with a rejected
  483.  * thenable, or invoke `reject` with the reason directly. To resolve the
  484.  * promise to another thenable, thus putting it in the same state, invoke
  485.  * `resolve` with that other thenable.
  486.  */
  487. Q.defer = defer;
  488. function defer() {
  489.     // if "messages" is an "Array", that indicates that the promise has not yet
  490.     // been resolved.  If it is "undefined", it has been resolved.  Each
  491.     // element of the messages array is itself an array of complete arguments to
  492.     // forward to the resolved promise.  We coerce the resolution value to a
  493.     // promise using the `resolve` function because it handles both fully
  494.     // non-thenable values and other thenables gracefully.
  495.     var messages = [], progressListeners = [], resolvedPromise;
  496.  
  497.     var deferred = object_create(defer.prototype);
  498.     var promise = object_create(Promise.prototype);
  499.  
  500.     promise.promiseDispatch = function (resolve, op, operands) {
  501.         var args = array_slice(arguments);
  502.         if (messages) {
  503.             messages.push(args);
  504.             if (op === "when" && operands[1]) { // progress operand
  505.                 progressListeners.push(operands[1]);
  506.             }
  507.         } else {
  508.             nextTick(function () {
  509.                 resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
  510.             });
  511.         }
  512.     };
  513.  
  514.     // XXX deprecated
  515.     promise.valueOf = function () {
  516.         if (messages) {
  517.             return promise;
  518.         }
  519.         var nearerValue = nearer(resolvedPromise);
  520.         if (isPromise(nearerValue)) {
  521.             resolvedPromise = nearerValue; // shorten chain
  522.         }
  523.         return nearerValue;
  524.     };
  525.  
  526.     promise.inspect = function () {
  527.         if (!resolvedPromise) {
  528.             return { state: "pending" };
  529.         }
  530.         return resolvedPromise.inspect();
  531.     };
  532.  
  533.     if (Q.longStackSupport && hasStacks) {
  534.         try {
  535.             throw new Error();
  536.         } catch (e) {
  537.             // NOTE: don't try to use `Error.captureStackTrace` or transfer the
  538.             // accessor around; that causes memory leaks as per GH-111. Just
  539.             // reify the stack trace as a string ASAP.
  540.             //
  541.             // At the same time, cut off the first line; it's always just
  542.             // "[object Promise]\n", as per the `toString`.
  543.             promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
  544.         }
  545.     }
  546.  
  547.     // NOTE: we do the checks for `resolvedPromise` in each method, instead of
  548.     // consolidating them into `become`, since otherwise we'd create new
  549.     // promises with the lines `become(whatever(value))`. See e.g. GH-252.
  550.  
  551.     function become(newPromise) {
  552.         resolvedPromise = newPromise;
  553.         promise.source = newPromise;
  554.  
  555.         array_reduce(messages, function (undefined, message) {
  556.             nextTick(function () {
  557.                 newPromise.promiseDispatch.apply(newPromise, message);
  558.             });
  559.         }, void 0);
  560.  
  561.         messages = void 0;
  562.         progressListeners = void 0;
  563.     }
  564.  
  565.     deferred.promise = promise;
  566.     deferred.resolve = function (value) {
  567.         if (resolvedPromise) {
  568.             return;
  569.         }
  570.  
  571.         become(Q(value));
  572.     };
  573.  
  574.     deferred.fulfill = function (value) {
  575.         if (resolvedPromise) {
  576.             return;
  577.         }
  578.  
  579.         become(fulfill(value));
  580.     };
  581.     deferred.reject = function (reason) {
  582.         if (resolvedPromise) {
  583.             return;
  584.         }
  585.  
  586.         become(reject(reason));
  587.     };
  588.     deferred.notify = function (progress) {
  589.         if (resolvedPromise) {
  590.             return;
  591.         }
  592.  
  593.         array_reduce(progressListeners, function (undefined, progressListener) {
  594.             nextTick(function () {
  595.                 progressListener(progress);
  596.             });
  597.         }, void 0);
  598.     };
  599.  
  600.     return deferred;
  601. }
  602.  
  603. /**
  604.  * Creates a Node-style callback that will resolve or reject the deferred
  605.  * promise.
  606.  * @returns a nodeback
  607.  */
  608. defer.prototype.makeNodeResolver = function () {
  609.     var self = this;
  610.     return function (error, value) {
  611.         if (error) {
  612.             self.reject(error);
  613.         } else if (arguments.length > 2) {
  614.             self.resolve(array_slice(arguments, 1));
  615.         } else {
  616.             self.resolve(value);
  617.         }
  618.     };
  619. };
  620.  
  621. /**
  622.  * @param resolver {Function} a function that returns nothing and accepts
  623.  * the resolve, reject, and notify functions for a deferred.
  624.  * @returns a promise that may be resolved with the given resolve and reject
  625.  * functions, or rejected by a thrown exception in resolver
  626.  */
  627. Q.Promise = promise; // ES6
  628. Q.promise = promise;
  629. function promise(resolver) {
  630.     if (typeof resolver !== "function") {
  631.         throw new TypeError("resolver must be a function.");
  632.     }
  633.     var deferred = defer();
  634.     try {
  635.         resolver(deferred.resolve, deferred.reject, deferred.notify);
  636.     } catch (reason) {
  637.         deferred.reject(reason);
  638.     }
  639.     return deferred.promise;
  640. }
  641.  
  642. promise.race = race; // ES6
  643. promise.all = all; // ES6
  644. promise.reject = reject; // ES6
  645. promise.resolve = Q; // ES6
  646.  
  647. // XXX experimental.  This method is a way to denote that a local value is
  648. // serializable and should be immediately dispatched to a remote upon request,
  649. // instead of passing a reference.
  650. Q.passByCopy = function (object) {
  651.     //freeze(object);
  652.     //passByCopies.set(object, true);
  653.     return object;
  654. };
  655.  
  656. Promise.prototype.passByCopy = function () {
  657.     //freeze(object);
  658.     //passByCopies.set(object, true);
  659.     return this;
  660. };
  661.  
  662. /**
  663.  * If two promises eventually fulfill to the same value, promises that value,
  664.  * but otherwise rejects.
  665.  * @param x {Any*}
  666.  * @param y {Any*}
  667.  * @returns {Any*} a promise for x and y if they are the same, but a rejection
  668.  * otherwise.
  669.  *
  670.  */
  671. Q.join = function (x, y) {
  672.     return Q(x).join(y);
  673. };
  674.  
  675. Promise.prototype.join = function (that) {
  676.     return Q([this, that]).spread(function (x, y) {
  677.         if (x === y) {
  678.             // TODO: "===" should be Object.is or equiv
  679.             return x;
  680.         } else {
  681.             throw new Error("Can't join: not the same: " + x + " " + y);
  682.         }
  683.     });
  684. };
  685.  
  686. /**
  687.  * Returns a promise for the first of an array of promises to become fulfilled.
  688.  * @param answers {Array[Any*]} promises to race
  689.  * @returns {Any*} the first promise to be fulfilled
  690.  */
  691. Q.race = race;
  692. function race(answerPs) {
  693.     return promise(function(resolve, reject) {
  694.         // Switch to this once we can assume at least ES5
  695.         // answerPs.forEach(function(answerP) {
  696.         //     Q(answerP).then(resolve, reject);
  697.         // });
  698.         // Use this in the meantime
  699.         for (var i = 0, len = answerPs.length; i < len; i++) {
  700.             Q(answerPs[i]).then(resolve, reject);
  701.         }
  702.     });
  703. }
  704.  
  705. Promise.prototype.race = function () {
  706.     return this.then(Q.race);
  707. };
  708.  
  709. /**
  710.  * Constructs a Promise with a promise descriptor object and optional fallback
  711.  * function.  The descriptor contains methods like when(rejected), get(name),
  712.  * set(name, value), post(name, args), and delete(name), which all
  713.  * return either a value, a promise for a value, or a rejection.  The fallback
  714.  * accepts the operation name, a resolver, and any further arguments that would
  715.  * have been forwarded to the appropriate method above had a method been
  716.  * provided with the proper name.  The API makes no guarantees about the nature
  717.  * of the returned object, apart from that it is usable whereever promises are
  718.  * bought and sold.
  719.  */
  720. Q.makePromise = Promise;
  721. function Promise(descriptor, fallback, inspect) {
  722.     if (fallback === void 0) {
  723.         fallback = function (op) {
  724.             return reject(new Error(
  725.                 "Promise does not support operation: " + op
  726.             ));
  727.         };
  728.     }
  729.     if (inspect === void 0) {
  730.         inspect = function () {
  731.             return {state: "unknown"};
  732.         };
  733.     }
  734.  
  735.     var promise = object_create(Promise.prototype);
  736.  
  737.     promise.promiseDispatch = function (resolve, op, args) {
  738.         var result;
  739.         try {
  740.             if (descriptor[op]) {
  741.                 result = descriptor[op].apply(promise, args);
  742.             } else {
  743.                 result = fallback.call(promise, op, args);
  744.             }
  745.         } catch (exception) {
  746.             result = reject(exception);
  747.         }
  748.         if (resolve) {
  749.             resolve(result);
  750.         }
  751.     };
  752.  
  753.     promise.inspect = inspect;
  754.  
  755.     // XXX deprecated `valueOf` and `exception` support
  756.     if (inspect) {
  757.         var inspected = inspect();
  758.         if (inspected.state === "rejected") {
  759.             promise.exception = inspected.reason;
  760.         }
  761.  
  762.         promise.valueOf = function () {
  763.             var inspected = inspect();
  764.             if (inspected.state === "pending" ||
  765.                 inspected.state === "rejected") {
  766.                 return promise;
  767.             }
  768.             return inspected.value;
  769.         };
  770.     }
  771.  
  772.     return promise;
  773. }
  774.  
  775. Promise.prototype.toString = function () {
  776.     return "[object Promise]";
  777. };
  778.  
  779. Promise.prototype.then = function (fulfilled, rejected, progressed) {
  780.     var self = this;
  781.     var deferred = defer();
  782.     var done = false;   // ensure the untrusted promise makes at most a
  783.                         // single call to one of the callbacks
  784.  
  785.     function _fulfilled(value) {
  786.         try {
  787.             return typeof fulfilled === "function" ? fulfilled(value) : value;
  788.         } catch (exception) {
  789.             return reject(exception);
  790.         }
  791.     }
  792.  
  793.     function _rejected(exception) {
  794.         if (typeof rejected === "function") {
  795.             makeStackTraceLong(exception, self);
  796.             try {
  797.                 return rejected(exception);
  798.             } catch (newException) {
  799.                 return reject(newException);
  800.             }
  801.         }
  802.         return reject(exception);
  803.     }
  804.  
  805.     function _progressed(value) {
  806.         return typeof progressed === "function" ? progressed(value) : value;
  807.     }
  808.  
  809.     nextTick(function () {
  810.         self.promiseDispatch(function (value) {
  811.             if (done) {
  812.                 return;
  813.             }
  814.             done = true;
  815.  
  816.             deferred.resolve(_fulfilled(value));
  817.         }, "when", [function (exception) {
  818.             if (done) {
  819.                 return;
  820.             }
  821.             done = true;
  822.  
  823.             deferred.resolve(_rejected(exception));
  824.         }]);
  825.     });
  826.  
  827.     // Progress propagator need to be attached in the current tick.
  828.     self.promiseDispatch(void 0, "when", [void 0, function (value) {
  829.         var newValue;
  830.         var threw = false;
  831.         try {
  832.             newValue = _progressed(value);
  833.         } catch (e) {
  834.             threw = true;
  835.             if (Q.onerror) {
  836.                 Q.onerror(e);
  837.             } else {
  838.                 throw e;
  839.             }
  840.         }
  841.  
  842.         if (!threw) {
  843.             deferred.notify(newValue);
  844.         }
  845.     }]);
  846.  
  847.     return deferred.promise;
  848. };
  849.  
  850. /**
  851.  * Registers an observer on a promise.
  852.  *
  853.  * Guarantees:
  854.  *
  855.  * 1. that fulfilled and rejected will be called only once.
  856.  * 2. that either the fulfilled callback or the rejected callback will be
  857.  *    called, but not both.
  858.  * 3. that fulfilled and rejected will not be called in this turn.
  859.  *
  860.  * @param value      promise or immediate reference to observe
  861.  * @param fulfilled  function to be called with the fulfilled value
  862.  * @param rejected   function to be called with the rejection exception
  863.  * @param progressed function to be called on any progress notifications
  864.  * @return promise for the return value from the invoked callback
  865.  */
  866. Q.when = when;
  867. function when(value, fulfilled, rejected, progressed) {
  868.     return Q(value).then(fulfilled, rejected, progressed);
  869. }
  870.  
  871. Promise.prototype.thenResolve = function (value) {
  872.     return this.then(function () { return value; });
  873. };
  874.  
  875. Q.thenResolve = function (promise, value) {
  876.     return Q(promise).thenResolve(value);
  877. };
  878.  
  879. Promise.prototype.thenReject = function (reason) {
  880.     return this.then(function () { throw reason; });
  881. };
  882.  
  883. Q.thenReject = function (promise, reason) {
  884.     return Q(promise).thenReject(reason);
  885. };
  886.  
  887. /**
  888.  * If an object is not a promise, it is as "near" as possible.
  889.  * If a promise is rejected, it is as "near" as possible too.
  890.  * If it鈥檚 a fulfilled promise, the fulfillment value is nearer.
  891.  * If it鈥檚 a deferred promise and the deferred has been resolved, the
  892.  * resolution is "nearer".
  893.  * @param object
  894.  * @returns most resolved (nearest) form of the object
  895.  */
  896.  
  897. // XXX should we re-do this?
  898. Q.nearer = nearer;
  899. function nearer(value) {
  900.     if (isPromise(value)) {
  901.         var inspected = value.inspect();
  902.         if (inspected.state === "fulfilled") {
  903.             return inspected.value;
  904.         }
  905.     }
  906.     return value;
  907. }
  908.  
  909. /**
  910.  * @returns whether the given object is a promise.
  911.  * Otherwise it is a fulfilled value.
  912.  */
  913. Q.isPromise = isPromise;
  914. function isPromise(object) {
  915.     return isObject(object) &&
  916.         typeof object.promiseDispatch === "function" &&
  917.         typeof object.inspect === "function";
  918. }
  919.  
  920. Q.isPromiseAlike = isPromiseAlike;
  921. function isPromiseAlike(object) {
  922.     return isObject(object) && typeof object.then === "function";
  923. }
  924.  
  925. /**
  926.  * @returns whether the given object is a pending promise, meaning not
  927.  * fulfilled or rejected.
  928.  */
  929. Q.isPending = isPending;
  930. function isPending(object) {
  931.     return isPromise(object) && object.inspect().state === "pending";
  932. }
  933.  
  934. Promise.prototype.isPending = function () {
  935.     return this.inspect().state === "pending";
  936. };
  937.  
  938. /**
  939.  * @returns whether the given object is a value or fulfilled
  940.  * promise.
  941.  */
  942. Q.isFulfilled = isFulfilled;
  943. function isFulfilled(object) {
  944.     return !isPromise(object) || object.inspect().state === "fulfilled";
  945. }
  946.  
  947. Promise.prototype.isFulfilled = function () {
  948.     return this.inspect().state === "fulfilled";
  949. };
  950.  
  951. /**
  952.  * @returns whether the given object is a rejected promise.
  953.  */
  954. Q.isRejected = isRejected;
  955. function isRejected(object) {
  956.     return isPromise(object) && object.inspect().state === "rejected";
  957. }
  958.  
  959. Promise.prototype.isRejected = function () {
  960.     return this.inspect().state === "rejected";
  961. };
  962.  
  963. //// BEGIN UNHANDLED REJECTION TRACKING
  964.  
  965. // This promise library consumes exceptions thrown in handlers so they can be
  966. // handled by a subsequent promise.  The exceptions get added to this array when
  967. // they are created, and removed when they are handled.  Note that in ES6 or
  968. // shimmed environments, this would naturally be a `Set`.
  969. var unhandledReasons = [];
  970. var unhandledRejections = [];
  971. var trackUnhandledRejections = true;
  972.  
  973. function resetUnhandledRejections() {
  974.     unhandledReasons.length = 0;
  975.     unhandledRejections.length = 0;
  976.  
  977.     if (!trackUnhandledRejections) {
  978.         trackUnhandledRejections = true;
  979.     }
  980. }
  981.  
  982. function trackRejection(promise, reason) {
  983.     if (!trackUnhandledRejections) {
  984.         return;
  985.     }
  986.  
  987.     unhandledRejections.push(promise);
  988.     if (reason && typeof reason.stack !== "undefined") {
  989.         unhandledReasons.push(reason.stack);
  990.     } else {
  991.         unhandledReasons.push("(no stack) " + reason);
  992.     }
  993. }
  994.  
  995. function untrackRejection(promise) {
  996.     if (!trackUnhandledRejections) {
  997.         return;
  998.     }
  999.  
  1000.     var at = array_indexOf(unhandledRejections, promise);
  1001.     if (at !== -1) {
  1002.         unhandledRejections.splice(at, 1);
  1003.         unhandledReasons.splice(at, 1);
  1004.     }
  1005. }
  1006.  
  1007. Q.resetUnhandledRejections = resetUnhandledRejections;
  1008.  
  1009. Q.getUnhandledReasons = function () {
  1010.     // Make a copy so that consumers can't interfere with our internal state.
  1011.     return unhandledReasons.slice();
  1012. };
  1013.  
  1014. Q.stopUnhandledRejectionTracking = function () {
  1015.     resetUnhandledRejections();
  1016.     trackUnhandledRejections = false;
  1017. };
  1018.  
  1019. resetUnhandledRejections();
  1020.  
  1021. //// END UNHANDLED REJECTION TRACKING
  1022.  
  1023. /**
  1024.  * Constructs a rejected promise.
  1025.  * @param reason value describing the failure
  1026.  */
  1027. Q.reject = reject;
  1028. function reject(reason) {
  1029.     var rejection = Promise({
  1030.         "when": function (rejected) {
  1031.             // note that the error has been handled
  1032.             if (rejected) {
  1033.                 untrackRejection(this);
  1034.             }
  1035.             return rejected ? rejected(reason) : this;
  1036.         }
  1037.     }, function fallback() {
  1038.         return this;
  1039.     }, function inspect() {
  1040.         return { state: "rejected", reason: reason };
  1041.     });
  1042.  
  1043.     // Note that the reason has not been handled.
  1044.     trackRejection(rejection, reason);
  1045.  
  1046.     return rejection;
  1047. }
  1048.  
  1049. /**
  1050.  * Constructs a fulfilled promise for an immediate reference.
  1051.  * @param value immediate reference
  1052.  */
  1053. Q.fulfill = fulfill;
  1054. function fulfill(value) {
  1055.     return Promise({
  1056.         "when": function () {
  1057.             return value;
  1058.         },
  1059.         "get": function (name) {
  1060.             return value[name];
  1061.         },
  1062.         "set": function (name, rhs) {
  1063.             value[name] = rhs;
  1064.         },
  1065.         "delete": function (name) {
  1066.             delete value[name];
  1067.         },
  1068.         "post": function (name, args) {
  1069.             // Mark Miller proposes that post with no name should apply a
  1070.             // promised function.
  1071.             if (name === null || name === void 0) {
  1072.                 return value.apply(void 0, args);
  1073.             } else {
  1074.                 return value[name].apply(value, args);
  1075.             }
  1076.         },
  1077.         "apply": function (thisp, args) {
  1078.             return value.apply(thisp, args);
  1079.         },
  1080.         "keys": function () {
  1081.             return object_keys(value);
  1082.         }
  1083.     }, void 0, function inspect() {
  1084.         return { state: "fulfilled", value: value };
  1085.     });
  1086. }
  1087.  
  1088. /**
  1089.  * Converts thenables to Q promises.
  1090.  * @param promise thenable promise
  1091.  * @returns a Q promise
  1092.  */
  1093. function coerce(promise) {
  1094.     var deferred = defer();
  1095.     nextTick(function () {
  1096.         try {
  1097.             promise.then(deferred.resolve, deferred.reject, deferred.notify);
  1098.         } catch (exception) {
  1099.             deferred.reject(exception);
  1100.         }
  1101.     });
  1102.     return deferred.promise;
  1103. }
  1104.  
  1105. /**
  1106.  * Annotates an object such that it will never be
  1107.  * transferred away from this process over any promise
  1108.  * communication channel.
  1109.  * @param object
  1110.  * @returns promise a wrapping of that object that
  1111.  * additionally responds to the "isDef" message
  1112.  * without a rejection.
  1113.  */
  1114. Q.master = master;
  1115. function master(object) {
  1116.     return Promise({
  1117.         "isDef": function () {}
  1118.     }, function fallback(op, args) {
  1119.         return dispatch(object, op, args);
  1120.     }, function () {
  1121.         return Q(object).inspect();
  1122.     });
  1123. }
  1124.  
  1125. /**
  1126.  * Spreads the values of a promised array of arguments into the
  1127.  * fulfillment callback.
  1128.  * @param fulfilled callback that receives variadic arguments from the
  1129.  * promised array
  1130.  * @param rejected callback that receives the exception if the promise
  1131.  * is rejected.
  1132.  * @returns a promise for the return value or thrown exception of
  1133.  * either callback.
  1134.  */
  1135. Q.spread = spread;
  1136. function spread(value, fulfilled, rejected) {
  1137.     return Q(value).spread(fulfilled, rejected);
  1138. }
  1139.  
  1140. Promise.prototype.spread = function (fulfilled, rejected) {
  1141.     return this.all().then(function (array) {
  1142.         return fulfilled.apply(void 0, array);
  1143.     }, rejected);
  1144. };
  1145.  
  1146. /**
  1147.  * The async function is a decorator for generator functions, turning
  1148.  * them into asynchronous generators.  Although generators are only part
  1149.  * of the newest ECMAScript 6 drafts, this code does not cause syntax
  1150.  * errors in older engines.  This code should continue to work and will
  1151.  * in fact improve over time as the language improves.
  1152.  *
  1153.  * ES6 generators are currently part of V8 version 3.19 with the
  1154.  * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
  1155.  * for longer, but under an older Python-inspired form.  This function
  1156.  * works on both kinds of generators.
  1157.  *
  1158.  * Decorates a generator function such that:
  1159.  *  - it may yield promises
  1160.  *  - execution will continue when that promise is fulfilled
  1161.  *  - the value of the yield expression will be the fulfilled value
  1162.  *  - it returns a promise for the return value (when the generator
  1163.  *    stops iterating)
  1164.  *  - the decorated function returns a promise for the return value
  1165.  *    of the generator or the first rejected promise among those
  1166.  *    yielded.
  1167.  *  - if an error is thrown in the generator, it propagates through
  1168.  *    every following yield until it is caught, or until it escapes
  1169.  *    the generator function altogether, and is translated into a
  1170.  *    rejection for the promise returned by the decorated generator.
  1171.  */
  1172. Q.async = async;
  1173. function async(makeGenerator) {
  1174.     return function () {
  1175.         // when verb is "send", arg is a value
  1176.         // when verb is "throw", arg is an exception
  1177.         function continuer(verb, arg) {
  1178.             var result;
  1179.  
  1180.             // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
  1181.             // engine that has a deployed base of browsers that support generators.
  1182.             // However, SM's generators use the Python-inspired semantics of
  1183.             // outdated ES6 drafts.  We would like to support ES6, but we'd also
  1184.             // like to make it possible to use generators in deployed browsers, so
  1185.             // we also support Python-style generators.  At some point we can remove
  1186.             // this block.
  1187.  
  1188.             if (typeof StopIteration === "undefined") {
  1189.                 // ES6 Generators
  1190.                 try {
  1191.                     result = generator[verb](arg);
  1192.                 } catch (exception) {
  1193.                     return reject(exception);
  1194.                 }
  1195.                 if (result.done) {
  1196.                     return Q(result.value);
  1197.                 } else {
  1198.                     return when(result.value, callback, errback);
  1199.                 }
  1200.             } else {
  1201.                 // SpiderMonkey Generators
  1202.                 // FIXME: Remove this case when SM does ES6 generators.
  1203.                 try {
  1204.                     result = generator[verb](arg);
  1205.                 } catch (exception) {
  1206.                     if (isStopIteration(exception)) {
  1207.                         return Q(exception.value);
  1208.                     } else {
  1209.                         return reject(exception);
  1210.                     }
  1211.                 }
  1212.                 return when(result, callback, errback);
  1213.             }
  1214.         }
  1215.         var generator = makeGenerator.apply(this, arguments);
  1216.         var callback = continuer.bind(continuer, "next");
  1217.         var errback = continuer.bind(continuer, "throw");
  1218.         return callback();
  1219.     };
  1220. }
  1221.  
  1222. /**
  1223.  * The spawn function is a small wrapper around async that immediately
  1224.  * calls the generator and also ends the promise chain, so that any
  1225.  * unhandled errors are thrown instead of forwarded to the error
  1226.  * handler. This is useful because it's extremely common to run
  1227.  * generators at the top-level to work with libraries.
  1228.  */
  1229. Q.spawn = spawn;
  1230. function spawn(makeGenerator) {
  1231.     Q.done(Q.async(makeGenerator)());
  1232. }
  1233.  
  1234. // FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
  1235. /**
  1236.  * Throws a ReturnValue exception to stop an asynchronous generator.
  1237.  *
  1238.  * This interface is a stop-gap measure to support generator return
  1239.  * values in older Firefox/SpiderMonkey.  In browsers that support ES6
  1240.  * generators like Chromium 29, just use "return" in your generator
  1241.  * functions.
  1242.  *
  1243.  * @param value the return value for the surrounding generator
  1244.  * @throws ReturnValue exception with the value.
  1245.  * @example
  1246.  * // ES6 style
  1247.  * Q.async(function* () {
  1248.  *      var foo = yield getFooPromise();
  1249.  *      var bar = yield getBarPromise();
  1250.  *      return foo + bar;
  1251.  * })
  1252.  * // Older SpiderMonkey style
  1253.  * Q.async(function () {
  1254.  *      var foo = yield getFooPromise();
  1255.  *      var bar = yield getBarPromise();
  1256.  *      Q.return(foo + bar);
  1257.  * })
  1258.  */
  1259. Q["return"] = _return;
  1260. function _return(value) {
  1261.     throw new QReturnValue(value);
  1262. }
  1263.  
  1264. /**
  1265.  * The promised function decorator ensures that any promise arguments
  1266.  * are settled and passed as values (`this` is also settled and passed
  1267.  * as a value).  It will also ensure that the result of a function is
  1268.  * always a promise.
  1269.  *
  1270.  * @example
  1271.  * var add = Q.promised(function (a, b) {
  1272.  *     return a + b;
  1273.  * });
  1274.  * add(Q(a), Q(B));
  1275.  *
  1276.  * @param {function} callback The function to decorate
  1277.  * @returns {function} a function that has been decorated.
  1278.  */
  1279. Q.promised = promised;
  1280. function promised(callback) {
  1281.     return function () {
  1282.         return spread([this, all(arguments)], function (self, args) {
  1283.             return callback.apply(self, args);
  1284.         });
  1285.     };
  1286. }
  1287.  
  1288. /**
  1289.  * sends a message to a value in a future turn
  1290.  * @param object* the recipient
  1291.  * @param op the name of the message operation, e.g., "when",
  1292.  * @param args further arguments to be forwarded to the operation
  1293.  * @returns result {Promise} a promise for the result of the operation
  1294.  */
  1295. Q.dispatch = dispatch;
  1296. function dispatch(object, op, args) {
  1297.     return Q(object).dispatch(op, args);
  1298. }
  1299.  
  1300. Promise.prototype.dispatch = function (op, args) {
  1301.     var self = this;
  1302.     var deferred = defer();
  1303.     nextTick(function () {
  1304.         self.promiseDispatch(deferred.resolve, op, args);
  1305.     });
  1306.     return deferred.promise;
  1307. };
  1308.  
  1309. /**
  1310.  * Gets the value of a property in a future turn.
  1311.  * @param object    promise or immediate reference for target object
  1312.  * @param name      name of property to get
  1313.  * @return promise for the property value
  1314.  */
  1315. Q.get = function (object, key) {
  1316.     return Q(object).dispatch("get", [key]);
  1317. };
  1318.  
  1319. Promise.prototype.get = function (key) {
  1320.     return this.dispatch("get", [key]);
  1321. };
  1322.  
  1323. /**
  1324.  * Sets the value of a property in a future turn.
  1325.  * @param object    promise or immediate reference for object object
  1326.  * @param name      name of property to set
  1327.  * @param value     new value of property
  1328.  * @return promise for the return value
  1329.  */
  1330. Q.set = function (object, key, value) {
  1331.     return Q(object).dispatch("set", [key, value]);
  1332. };
  1333.  
  1334. Promise.prototype.set = function (key, value) {
  1335.     return this.dispatch("set", [key, value]);
  1336. };
  1337.  
  1338. /**
  1339.  * Deletes a property in a future turn.
  1340.  * @param object    promise or immediate reference for target object
  1341.  * @param name      name of property to delete
  1342.  * @return promise for the return value
  1343.  */
  1344. Q.del = // XXX legacy
  1345. Q["delete"] = function (object, key) {
  1346.     return Q(object).dispatch("delete", [key]);
  1347. };
  1348.  
  1349. Promise.prototype.del = // XXX legacy
  1350. Promise.prototype["delete"] = function (key) {
  1351.     return this.dispatch("delete", [key]);
  1352. };
  1353.  
  1354. /**
  1355.  * Invokes a method in a future turn.
  1356.  * @param object    promise or immediate reference for target object
  1357.  * @param name      name of method to invoke
  1358.  * @param value     a value to post, typically an array of
  1359.  *                  invocation arguments for promises that
  1360.  *                  are ultimately backed with `resolve` values,
  1361.  *                  as opposed to those backed with URLs
  1362.  *                  wherein the posted value can be any
  1363.  *                  JSON serializable object.
  1364.  * @return promise for the return value
  1365.  */
  1366. // bound locally because it is used by other methods
  1367. Q.mapply = // XXX As proposed by "Redsandro"
  1368. Q.post = function (object, name, args) {
  1369.     return Q(object).dispatch("post", [name, args]);
  1370. };
  1371.  
  1372. Promise.prototype.mapply = // XXX As proposed by "Redsandro"
  1373. Promise.prototype.post = function (name, args) {
  1374.     return this.dispatch("post", [name, args]);
  1375. };
  1376.  
  1377. /**
  1378.  * Invokes a method in a future turn.
  1379.  * @param object    promise or immediate reference for target object
  1380.  * @param name      name of method to invoke
  1381.  * @param ...args   array of invocation arguments
  1382.  * @return promise for the return value
  1383.  */
  1384. Q.send = // XXX Mark Miller's proposed parlance
  1385. Q.mcall = // XXX As proposed by "Redsandro"
  1386. Q.invoke = function (object, name /*...args*/) {
  1387.     return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
  1388. };
  1389.  
  1390. Promise.prototype.send = // XXX Mark Miller's proposed parlance
  1391. Promise.prototype.mcall = // XXX As proposed by "Redsandro"
  1392. Promise.prototype.invoke = function (name /*...args*/) {
  1393.     return this.dispatch("post", [name, array_slice(arguments, 1)]);
  1394. };
  1395.  
  1396. /**
  1397.  * Applies the promised function in a future turn.
  1398.  * @param object    promise or immediate reference for target function
  1399.  * @param args      array of application arguments
  1400.  */
  1401. Q.fapply = function (object, args) {
  1402.     return Q(object).dispatch("apply", [void 0, args]);
  1403. };
  1404.  
  1405. Promise.prototype.fapply = function (args) {
  1406.     return this.dispatch("apply", [void 0, args]);
  1407. };
  1408.  
  1409. /**
  1410.  * Calls the promised function in a future turn.
  1411.  * @param object    promise or immediate reference for target function
  1412.  * @param ...args   array of application arguments
  1413.  */
  1414. Q["try"] =
  1415. Q.fcall = function (object /* ...args*/) {
  1416.     return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
  1417. };
  1418.  
  1419. Promise.prototype.fcall = function (/*...args*/) {
  1420.     return this.dispatch("apply", [void 0, array_slice(arguments)]);
  1421. };
  1422.  
  1423. /**
  1424.  * Binds the promised function, transforming return values into a fulfilled
  1425.  * promise and thrown errors into a rejected one.
  1426.  * @param object    promise or immediate reference for target function
  1427.  * @param ...args   array of application arguments
  1428.  */
  1429. Q.fbind = function (object /*...args*/) {
  1430.     var promise = Q(object);
  1431.     var args = array_slice(arguments, 1);
  1432.     return function fbound() {
  1433.         return promise.dispatch("apply", [
  1434.             this,
  1435.             args.concat(array_slice(arguments))
  1436.         ]);
  1437.     };
  1438. };
  1439. Promise.prototype.fbind = function (/*...args*/) {
  1440.     var promise = this;
  1441.     var args = array_slice(arguments);
  1442.     return function fbound() {
  1443.         return promise.dispatch("apply", [
  1444.             this,
  1445.             args.concat(array_slice(arguments))
  1446.         ]);
  1447.     };
  1448. };
  1449.  
  1450. /**
  1451.  * Requests the names of the owned properties of a promised
  1452.  * object in a future turn.
  1453.  * @param object    promise or immediate reference for target object
  1454.  * @return promise for the keys of the eventually settled object
  1455.  */
  1456. Q.keys = function (object) {
  1457.     return Q(object).dispatch("keys", []);
  1458. };
  1459.  
  1460. Promise.prototype.keys = function () {
  1461.     return this.dispatch("keys", []);
  1462. };
  1463.  
  1464. /**
  1465.  * Turns an array of promises into a promise for an array.  If any of
  1466.  * the promises gets rejected, the whole array is rejected immediately.
  1467.  * @param {Array*} an array (or promise for an array) of values (or
  1468.  * promises for values)
  1469.  * @returns a promise for an array of the corresponding values
  1470.  */
  1471. // By Mark Miller
  1472. // http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
  1473. Q.all = all;
  1474. function all(promises) {
  1475.     return when(promises, function (promises) {
  1476.         var countDown = 0;
  1477.         var deferred = defer();
  1478.         array_reduce(promises, function (undefined, promise, index) {
  1479.             var snapshot;
  1480.             if (
  1481.                 isPromise(promise) &&
  1482.                 (snapshot = promise.inspect()).state === "fulfilled"
  1483.             ) {
  1484.                 promises[index] = snapshot.value;
  1485.             } else {
  1486.                 ++countDown;
  1487.                 when(
  1488.                     promise,
  1489.                     function (value) {
  1490.                         promises[index] = value;
  1491.                         if (--countDown === 0) {
  1492.                             deferred.resolve(promises);
  1493.                         }
  1494.                     },
  1495.                     deferred.reject,
  1496.                     function (progress) {
  1497.                         deferred.notify({ index: index, value: progress });
  1498.                     }
  1499.                 );
  1500.             }
  1501.         }, void 0);
  1502.         if (countDown === 0) {
  1503.             deferred.resolve(promises);
  1504.         }
  1505.         return deferred.promise;
  1506.     });
  1507. }
  1508.  
  1509. Promise.prototype.all = function () {
  1510.     return all(this);
  1511. };
  1512.  
  1513. /**
  1514.  * Waits for all promises to be settled, either fulfilled or
  1515.  * rejected.  This is distinct from `all` since that would stop
  1516.  * waiting at the first rejection.  The promise returned by
  1517.  * `allResolved` will never be rejected.
  1518.  * @param promises a promise for an array (or an array) of promises
  1519.  * (or values)
  1520.  * @return a promise for an array of promises
  1521.  */
  1522. Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
  1523. function allResolved(promises) {
  1524.     return when(promises, function (promises) {
  1525.         promises = array_map(promises, Q);
  1526.         return when(all(array_map(promises, function (promise) {
  1527.             return when(promise, noop, noop);
  1528.         })), function () {
  1529.             return promises;
  1530.         });
  1531.     });
  1532. }
  1533.  
  1534. Promise.prototype.allResolved = function () {
  1535.     return allResolved(this);
  1536. };
  1537.  
  1538. /**
  1539.  * @see Promise#allSettled
  1540.  */
  1541. Q.allSettled = allSettled;
  1542. function allSettled(promises) {
  1543.     return Q(promises).allSettled();
  1544. }
  1545.  
  1546. /**
  1547.  * Turns an array of promises into a promise for an array of their states (as
  1548.  * returned by `inspect`) when they have all settled.
  1549.  * @param {Array[Any*]} values an array (or promise for an array) of values (or
  1550.  * promises for values)
  1551.  * @returns {Array[State]} an array of states for the respective values.
  1552.  */
  1553. Promise.prototype.allSettled = function () {
  1554.     return this.then(function (promises) {
  1555.         return all(array_map(promises, function (promise) {
  1556.             promise = Q(promise);
  1557.             function regardless() {
  1558.                 return promise.inspect();
  1559.             }
  1560.             return promise.then(regardless, regardless);
  1561.         }));
  1562.     });
  1563. };
  1564.  
  1565. /**
  1566.  * Captures the failure of a promise, giving an oportunity to recover
  1567.  * with a callback.  If the given promise is fulfilled, the returned
  1568.  * promise is fulfilled.
  1569.  * @param {Any*} promise for something
  1570.  * @param {Function} callback to fulfill the returned promise if the
  1571.  * given promise is rejected
  1572.  * @returns a promise for the return value of the callback
  1573.  */
  1574. Q.fail = // XXX legacy
  1575. Q["catch"] = function (object, rejected) {
  1576.     return Q(object).then(void 0, rejected);
  1577. };
  1578.  
  1579. Promise.prototype.fail = // XXX legacy
  1580. Promise.prototype["catch"] = function (rejected) {
  1581.     return this.then(void 0, rejected);
  1582. };
  1583.  
  1584. /**
  1585.  * Attaches a listener that can respond to progress notifications from a
  1586.  * promise's originating deferred. This listener receives the exact arguments
  1587.  * passed to ``deferred.notify``.
  1588.  * @param {Any*} promise for something
  1589.  * @param {Function} callback to receive any progress notifications
  1590.  * @returns the given promise, unchanged
  1591.  */
  1592. Q.progress = progress;
  1593. function progress(object, progressed) {
  1594.     return Q(object).then(void 0, void 0, progressed);
  1595. }
  1596.  
  1597. Promise.prototype.progress = function (progressed) {
  1598.     return this.then(void 0, void 0, progressed);
  1599. };
  1600.  
  1601. /**
  1602.  * Provides an opportunity to observe the settling of a promise,
  1603.  * regardless of whether the promise is fulfilled or rejected.  Forwards
  1604.  * the resolution to the returned promise when the callback is done.
  1605.  * The callback can return a promise to defer completion.
  1606.  * @param {Any*} promise
  1607.  * @param {Function} callback to observe the resolution of the given
  1608.  * promise, takes no arguments.
  1609.  * @returns a promise for the resolution of the given promise when
  1610.  * ``fin`` is done.
  1611.  */
  1612. Q.fin = // XXX legacy
  1613. Q["finally"] = function (object, callback) {
  1614.     return Q(object)["finally"](callback);
  1615. };
  1616.  
  1617. Promise.prototype.fin = // XXX legacy
  1618. Promise.prototype["finally"] = function (callback) {
  1619.     callback = Q(callback);
  1620.     return this.then(function (value) {
  1621.         return callback.fcall().then(function () {
  1622.             return value;
  1623.         });
  1624.     }, function (reason) {
  1625.         // TODO attempt to recycle the rejection with "this".
  1626.         return callback.fcall().then(function () {
  1627.             throw reason;
  1628.         });
  1629.     });
  1630. };
  1631.  
  1632. /**
  1633.  * Terminates a chain of promises, forcing rejections to be
  1634.  * thrown as exceptions.
  1635.  * @param {Any*} promise at the end of a chain of promises
  1636.  * @returns nothing
  1637.  */
  1638. Q.done = function (object, fulfilled, rejected, progress) {
  1639.     return Q(object).done(fulfilled, rejected, progress);
  1640. };
  1641.  
  1642. Promise.prototype.done = function (fulfilled, rejected, progress) {
  1643.     var onUnhandledError = function (error) {
  1644.         // forward to a future turn so that ``when``
  1645.         // does not catch it and turn it into a rejection.
  1646.         nextTick(function () {
  1647.             makeStackTraceLong(error, promise);
  1648.             if (Q.onerror) {
  1649.                 Q.onerror(error);
  1650.             } else {
  1651.                 throw error;
  1652.             }
  1653.         });
  1654.     };
  1655.  
  1656.     // Avoid unnecessary `nextTick`ing via an unnecessary `when`.
  1657.     var promise = fulfilled || rejected || progress ?
  1658.         this.then(fulfilled, rejected, progress) :
  1659.         this;
  1660.  
  1661.     if (typeof process === "object" && process && process.domain) {
  1662.         onUnhandledError = process.domain.bind(onUnhandledError);
  1663.     }
  1664.  
  1665.     promise.then(void 0, onUnhandledError);
  1666. };
  1667.  
  1668. /**
  1669.  * Causes a promise to be rejected if it does not get fulfilled before
  1670.  * some milliseconds time out.
  1671.  * @param {Any*} promise
  1672.  * @param {Number} milliseconds timeout
  1673.  * @param {Any*} custom error message or Error object (optional)
  1674.  * @returns a promise for the resolution of the given promise if it is
  1675.  * fulfilled before the timeout, otherwise rejected.
  1676.  */
  1677. Q.timeout = function (object, ms, error) {
  1678.     return Q(object).timeout(ms, error);
  1679. };
  1680.  
  1681. Promise.prototype.timeout = function (ms, error) {
  1682.     var deferred = defer();
  1683.     var timeoutId = setTimeout(function () {
  1684.         if (!error || "string" === typeof error) {
  1685.             error = new Error(error || "Timed out after " + ms + " ms");
  1686.             error.code = "ETIMEDOUT";
  1687.         }
  1688.         deferred.reject(error);
  1689.     }, ms);
  1690.  
  1691.     this.then(function (value) {
  1692.         clearTimeout(timeoutId);
  1693.         deferred.resolve(value);
  1694.     }, function (exception) {
  1695.         clearTimeout(timeoutId);
  1696.         deferred.reject(exception);
  1697.     }, deferred.notify);
  1698.  
  1699.     return deferred.promise;
  1700. };
  1701.  
  1702. /**
  1703.  * Returns a promise for the given value (or promised value), some
  1704.  * milliseconds after it resolved. Passes rejections immediately.
  1705.  * @param {Any*} promise
  1706.  * @param {Number} milliseconds
  1707.  * @returns a promise for the resolution of the given promise after milliseconds
  1708.  * time has elapsed since the resolution of the given promise.
  1709.  * If the given promise rejects, that is passed immediately.
  1710.  */
  1711. Q.delay = function (object, timeout) {
  1712.     if (timeout === void 0) {
  1713.         timeout = object;
  1714.         object = void 0;
  1715.     }
  1716.     return Q(object).delay(timeout);
  1717. };
  1718.  
  1719. Promise.prototype.delay = function (timeout) {
  1720.     return this.then(function (value) {
  1721.         var deferred = defer();
  1722.         setTimeout(function () {
  1723.             deferred.resolve(value);
  1724.         }, timeout);
  1725.         return deferred.promise;
  1726.     });
  1727. };
  1728.  
  1729. /**
  1730.  * Passes a continuation to a Node function, which is called with the given
  1731.  * arguments provided as an array, and returns a promise.
  1732.  *
  1733.  *      Q.nfapply(FS.readFile, [__filename])
  1734.  *      .then(function (content) {
  1735.  *      })
  1736.  *
  1737.  */
  1738. Q.nfapply = function (callback, args) {
  1739.     return Q(callback).nfapply(args);
  1740. };
  1741.  
  1742. Promise.prototype.nfapply = function (args) {
  1743.     var deferred = defer();
  1744.     var nodeArgs = array_slice(args);
  1745.     nodeArgs.push(deferred.makeNodeResolver());
  1746.     this.fapply(nodeArgs).fail(deferred.reject);
  1747.     return deferred.promise;
  1748. };
  1749.  
  1750. /**
  1751.  * Passes a continuation to a Node function, which is called with the given
  1752.  * arguments provided individually, and returns a promise.
  1753.  * @example
  1754.  * Q.nfcall(FS.readFile, __filename)
  1755.  * .then(function (content) {
  1756.  * })
  1757.  *
  1758.  */
  1759. Q.nfcall = function (callback /*...args*/) {
  1760.     var args = array_slice(arguments, 1);
  1761.     return Q(callback).nfapply(args);
  1762. };
  1763.  
  1764. Promise.prototype.nfcall = function (/*...args*/) {
  1765.     var nodeArgs = array_slice(arguments);
  1766.     var deferred = defer();
  1767.     nodeArgs.push(deferred.makeNodeResolver());
  1768.     this.fapply(nodeArgs).fail(deferred.reject);
  1769.     return deferred.promise;
  1770. };
  1771.  
  1772. /**
  1773.  * Wraps a NodeJS continuation passing function and returns an equivalent
  1774.  * version that returns a promise.
  1775.  * @example
  1776.  * Q.nfbind(FS.readFile, __filename)("utf-8")
  1777.  * .then(console.log)
  1778.  * .done()
  1779.  */
  1780. Q.nfbind =
  1781. Q.denodeify = function (callback /*...args*/) {
  1782.     var baseArgs = array_slice(arguments, 1);
  1783.     return function () {
  1784.         var nodeArgs = baseArgs.concat(array_slice(arguments));
  1785.         var deferred = defer();
  1786.         nodeArgs.push(deferred.makeNodeResolver());
  1787.         Q(callback).fapply(nodeArgs).fail(deferred.reject);
  1788.         return deferred.promise;
  1789.     };
  1790. };
  1791.  
  1792. Promise.prototype.nfbind =
  1793. Promise.prototype.denodeify = function (/*...args*/) {
  1794.     var args = array_slice(arguments);
  1795.     args.unshift(this);
  1796.     return Q.denodeify.apply(void 0, args);
  1797. };
  1798.  
  1799. Q.nbind = function (callback, thisp /*...args*/) {
  1800.     var baseArgs = array_slice(arguments, 2);
  1801.     return function () {
  1802.         var nodeArgs = baseArgs.concat(array_slice(arguments));
  1803.         var deferred = defer();
  1804.         nodeArgs.push(deferred.makeNodeResolver());
  1805.         function bound() {
  1806.             return callback.apply(thisp, arguments);
  1807.         }
  1808.         Q(bound).fapply(nodeArgs).fail(deferred.reject);
  1809.         return deferred.promise;
  1810.     };
  1811. };
  1812.  
  1813. Promise.prototype.nbind = function (/*thisp, ...args*/) {
  1814.     var args = array_slice(arguments, 0);
  1815.     args.unshift(this);
  1816.     return Q.nbind.apply(void 0, args);
  1817. };
  1818.  
  1819. /**
  1820.  * Calls a method of a Node-style object that accepts a Node-style
  1821.  * callback with a given array of arguments, plus a provided callback.
  1822.  * @param object an object that has the named method
  1823.  * @param {String} name name of the method of object
  1824.  * @param {Array} args arguments to pass to the method; the callback
  1825.  * will be provided by Q and appended to these arguments.
  1826.  * @returns a promise for the value or error
  1827.  */
  1828. Q.nmapply = // XXX As proposed by "Redsandro"
  1829. Q.npost = function (object, name, args) {
  1830.     return Q(object).npost(name, args);
  1831. };
  1832.  
  1833. Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
  1834. Promise.prototype.npost = function (name, args) {
  1835.     var nodeArgs = array_slice(args || []);
  1836.     var deferred = defer();
  1837.     nodeArgs.push(deferred.makeNodeResolver());
  1838.     this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
  1839.     return deferred.promise;
  1840. };
  1841.  
  1842. /**
  1843.  * Calls a method of a Node-style object that accepts a Node-style
  1844.  * callback, forwarding the given variadic arguments, plus a provided
  1845.  * callback argument.
  1846.  * @param object an object that has the named method
  1847.  * @param {String} name name of the method of object
  1848.  * @param ...args arguments to pass to the method; the callback will
  1849.  * be provided by Q and appended to these arguments.
  1850.  * @returns a promise for the value or error
  1851.  */
  1852. Q.nsend = // XXX Based on Mark Miller's proposed "send"
  1853. Q.nmcall = // XXX Based on "Redsandro's" proposal
  1854. Q.ninvoke = function (object, name /*...args*/) {
  1855.     var nodeArgs = array_slice(arguments, 2);
  1856.     var deferred = defer();
  1857.     nodeArgs.push(deferred.makeNodeResolver());
  1858.     Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
  1859.     return deferred.promise;
  1860. };
  1861.  
  1862. Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
  1863. Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
  1864. Promise.prototype.ninvoke = function (name /*...args*/) {
  1865.     var nodeArgs = array_slice(arguments, 1);
  1866.     var deferred = defer();
  1867.     nodeArgs.push(deferred.makeNodeResolver());
  1868.     this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
  1869.     return deferred.promise;
  1870. };
  1871.  
  1872. /**
  1873.  * If a function would like to support both Node continuation-passing-style and
  1874.  * promise-returning-style, it can end its internal promise chain with
  1875.  * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
  1876.  * elects to use a nodeback, the result will be sent there.  If they do not
  1877.  * pass a nodeback, they will receive the result promise.
  1878.  * @param object a result (or a promise for a result)
  1879.  * @param {Function} nodeback a Node.js-style callback
  1880.  * @returns either the promise or nothing
  1881.  */
  1882. Q.nodeify = nodeify;
  1883. function nodeify(object, nodeback) {
  1884.     return Q(object).nodeify(nodeback);
  1885. }
  1886.  
  1887. Promise.prototype.nodeify = function (nodeback) {
  1888.     if (nodeback) {
  1889.         this.then(function (value) {
  1890.             nextTick(function () {
  1891.                 nodeback(null, value);
  1892.             });
  1893.         }, function (error) {
  1894.             nextTick(function () {
  1895.                 nodeback(error);
  1896.             });
  1897.         });
  1898.     } else {
  1899.         return this;
  1900.     }
  1901. };
  1902.  
  1903. // All code before this point will be filtered from stack traces.
  1904. var qEndingLine = captureLine();
  1905.  
  1906. return Q;
  1907.  
  1908. });
  1909.  
downloadq.js Source code - Download mobile-chrome-apps Source code
Related Source Codes/Software:
pycrumbs - Bits and bytes of Python from the Internet 2017-02-20
drupal - Verbatim mirror of the git.drupal.org repository f... 2017-02-20
elasticsearch-head - A web front end for an elastic search cluster 2017-02-19
launchrocket - A Mac PrefPane to manage all your Homebrew-install... 2017-02-19
jquery-boilerplate - A jump-start for jQuery plugins development ... 2017-02-19
ricochet - Anonymous peer-to-peer instant messaging ... 2017-02-20
octokit.rb - Ruby toolkit for the GitHub API ... 2017-02-20
sticky-headers-recyclerview - [UNMAINTAINED] Sticky Headers decorator for Androi... 2017-02-20
shuttle - A simple SSH shortcut menu for macOS ... 2017-02-20
postgres - Mirror of the official PostgreSQL GIT repository. ... 2017-02-20
sharingbuttons.io - Quickly generate social sharing buttons with a tin... 2017-04-12
angular-schema-form - Generate forms from a JSON schema, with AngularJS!... 2017-04-12
sisyphus - Gmail-like client-side drafts and bit more. Plugin... 2017-04-12
git-recall - Handy tool to easily recall what you've done 2017-04-12
devise_invitable - An invitation strategy for devise 2017-04-12
redux-ecosystem-links - A categorized list of Redux-related addons, librar... 2017-04-12
code - Douban CODE http://douban-c... 2017-04-12
PullZoomView - An Android custom ListView and ScrollView with pul... 2017-04-12
scrollability - Imitates iOS native scrolling in JavaScript. http:... 2017-04-12
pyxley - Python helpers for building dashboards using Flask... 2017-04-12

 Back to top