├── CONTRIBUTING.md
├── LICENSE.md
├── README.md
├── bower.json
├── package.json
├── test
    ├── bluebird.js
    ├── index.html
    ├── jquery-1.11.1.js
    ├── jquery-1.4.3.js
    ├── q.js
    ├── qunit-1.14.0.css
    ├── qunit-1.14.0.js
    ├── when.js
    └── zepto.js
├── velocity.js
├── velocity.ui.js
└── velocity.ui.min.js


/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | **Contributing**
 2 | 
 3 | - Make sure you're using the latest version of Velocity before reporting a bug.
 4 | 
 5 | - Unless you're reporting an obvious bug that can be immediately recreated by anyone, please **create a demo** with the minimum amount of code necessary to reproduce your bug. You can use this template, which already has Velocity and its UI pack included: http://jsfiddle.net/65xCP/4/.
 6 | 
 7 | - ~~For a variety of reasons, I rarely merge pull requests. There is no need to make one; just explain your issue and I will take care of it. Thank you so much!~~ Having forked the project, we are happy to consider pull requests, however please note that part of the reason the original authors did not accept pull requests was because the source on github is not the original source (https://github.com/julianshapiro/velocity/issues/632) so this is worth bearing in mind if considering making changes.
 8 | 
 9 | - Please skim the FAQ before asking questions: https://github.com/julianshapiro/velocity/issues/47.
10 | 
11 | - @ydaniv provides moderation support for Velocity's GitHub issues.
12 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2014 Julian Shapiro
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ##Velocity 1.2.3
 2 | 
 3 | **Note**
 4 | This is the Vector fork of Velocity, created to incoprporate a bugfix from the community since it's useful for the Vector project.
 5 | 
 6 | **Docs**  
 7 | [VelocityJS.org](http://VelocityJS.org)
 8 | 
 9 | **News**  
10 | You can order the Velocity book on [Amazon](http://amazon.com/Web-Animation-using-JavaScript-Develop/dp/0134096665)!
11 | 
12 | WhatsApp, Tumblr, Windows, Samsung, Uber, and thousands of other companies rely on Velocity. Visit [Libscore.com](http://libscore.com/#$.Velocity) to see which sites use Velocity on their homepage.
13 | 
14 | **React Plugin**  
15 | Announcement: https://fabric.io/blog/introducing-the-velocityreact-library  
16 | Repo: https://github.com/twitter-fabric/velocity-react  
17 | NPM: https://www.npmjs.com/package/velocity-react
18 | 
19 | **Quickstart**  
20 | Velocity (CDN):
21 | `<script src="//cdn.jsdelivr.net/velocity/1.2.3/velocity.min.js"></script>`  
22 | Velocity UI pack (CDN):
23 | `<script src="//cdn.jsdelivr.net/velocity/1.2.3/velocity.ui.min.js"></script>`  
24 | Package managers:
25 | `npm install velocity-animate` / 
26 | `bower install velocity`
27 | 
28 | **Questions or Problems?**  
29 | Ask on [StackOverflow](http://stackoverflow.com/tags/velocity.js) (make sure you add the ```velocity.js``` and ```javascript``` tags).
30 | 
31 | ###**Updates**
32 | 
33 | - **1.2.0**: [Custom tweens](http://VelocityJS.org/#progress). [Custom easings](http://VelocityJS.org/#easing). ["Finish" command](http://VelocityJS.org/#finish). See [commit log](https://github.com/julianshapiro/velocity/commit/2a28e3812c6fe9262244ed3b6d41d12ae9a107c6) for more.
34 | - **1.0.0**: File name changed to `velocity.js`. Read [VelocityJS.org/#dependencies](http://VelocityJS.org/#dependencies).
35 | - **0.1.0**: `stop` now stops animations *immediately* (instead of only clearing the remainder of the animation queue). No other backwards-incompatible changes were made.
36 | 
37 | ###**Learn**
38 | 
39 | - **Motion design**: [smashingmagazine.com/2014/06/18/faster-ui-animations-with-velocity-js](http://smashingmagazine.com/2014/06/18/faster-ui-animations-with-velocity-js)
40 | - **Animating without jQuery**: [smashingmagazine.com/2014/09/04/animating-without-jquery](http://www.smashingmagazine.com/2014/09/04/animating-without-jquery/)
41 | - **Performance comparisons**: [davidwalsh.name/css-js-animation](http://davidwalsh.name/css-js-animation)
42 | - **Workflow**: [css-tricks.com/improving-ui-animation-workflow-velocity-js](http://css-tricks.com/improving-ui-animation-workflow-velocity-js)
43 | 
44 | ###**Comparisons**
45 | 
46 | - **CSS transitions** are meant for simple interface flourishes.
47 | - **jQuery's $.animate()** is slow and poorly-equipped for motion design.
48 | - **Velocity** is a fast, feature-rich standalone alternative to jQuery's $.animate().
49 | 
50 | ====
51 | 
52 | [MIT License](LICENSE.md). © Julian Shapiro (http://twitter.com/shapiro).
53 | [Stripe](https://stripe.com/blog/stripe-open-source-retreat) sponsors Velocity's development. [BrowserStack](http://www.browserstack.com/) provides testing services.
54 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "velocity",
 3 |   "version": "1.2.3",
 4 |   "homepage": "http://velocityjs.org",
 5 |   "authors": [
 6 |     { "name" : "Julian Shapiro",
 7 |       "homepage" : "http://julian.com/"
 8 |     }
 9 |   ],
10 |   "description": "Accelerated JavaScript animation.",
11 |   "main": [ "./velocity.js", "./velocity.ui.js"],
12 |   "keywords": [
13 |     "animation",
14 |     "jquery",
15 |     "animate",
16 |     "lightweight",
17 |     "smooth",
18 |     "ui",
19 |     "velocity.js",
20 |     "velocityjs",
21 |     "javascript"
22 |   ],
23 |   "license": "MIT",
24 |   "ignore": [
25 |     "*.json",
26 |     "!/bower.json",
27 |     "LICENSE",
28 |     "*.md"
29 |   ],
30 |   "dependencies": {
31 |     "jquery": "*"
32 |   },
33 |   "repository" :
34 |   {
35 |     "type" : "git",
36 |     "url" : "http://github.com/julianshapiro/velocity.git"
37 |   }
38 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "velocity-vector",
 3 |   "version": "1.2.3",
 4 |   "description": "Accelerated JavaScript animation.",
 5 |   "keywords": [
 6 |     "velocity",
 7 |     "animation",
 8 |     "jquery",
 9 |     "animate",
10 |     "ui",
11 |     "velocity.js",
12 |     "velocityjs",
13 |     "javascript"
14 |   ],
15 |   "homepage": "http://velocityjs.org",
16 |   "bugs": {
17 |     "url": "http://github.com/julianshapiro/velocity/issues"
18 |   },
19 |   "license": "MIT",
20 |   "authors": [
21 |     {
22 |       "name": "Julian Shapiro",
23 |       "url": "http://julian.com/"
24 |     }
25 |   ],
26 |   "main": "velocity.js",
27 |   "repository": "julianshapiro/velocity",
28 |   "files": [
29 |     "velocity.js",
30 |     "velocity.min.js",
31 |     "velocity.ui.js",
32 |     "velocity.ui.min.js"
33 |   ],
34 |   "dependencies": {
35 |     "jquery": ">= 1.4.3"
36 |   },
37 |   "devDependencies": {
38 |     "grunt": "^0.4.4",
39 |     "grunt-contrib-concat": "~0.4.0",
40 |     "grunt-contrib-jshint": "~0.6.3",
41 |     "grunt-contrib-nodeunit": "~0.2.0",
42 |     "grunt-contrib-requirejs": "~0.4.4",
43 |     "grunt-contrib-uglify": "~0.2.2"
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/test/q.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’t 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’s 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’s a fulfilled promise, the fulfillment value is nearer.
 891 |  * If it’s 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 | 


--------------------------------------------------------------------------------
/test/qunit-1.14.0.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * QUnit 1.14.0
  3 |  * http://qunitjs.com/
  4 |  *
  5 |  * Copyright 2013 jQuery Foundation and other contributors
  6 |  * Released under the MIT license
  7 |  * http://jquery.org/license
  8 |  *
  9 |  * Date: 2014-01-31T16:40Z
 10 |  */
 11 | 
 12 | /** Font Family and Sizes */
 13 | 
 14 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 15 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 16 | }
 17 | 
 18 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 19 | #qunit-tests { font-size: smaller; }
 20 | 
 21 | 
 22 | /** Resets */
 23 | 
 24 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 25 | 	margin: 0;
 26 | 	padding: 0;
 27 | }
 28 | 
 29 | 
 30 | /** Header */
 31 | 
 32 | #qunit-header {
 33 | 	padding: 0.5em 0 0.5em 1em;
 34 | 
 35 | 	color: #8699A4;
 36 | 	background-color: #0D3349;
 37 | 
 38 | 	font-size: 1.5em;
 39 | 	line-height: 1em;
 40 | 	font-weight: 400;
 41 | 
 42 | 	border-radius: 5px 5px 0 0;
 43 | }
 44 | 
 45 | #qunit-header a {
 46 | 	text-decoration: none;
 47 | 	color: #C2CCD1;
 48 | }
 49 | 
 50 | #qunit-header a:hover,
 51 | #qunit-header a:focus {
 52 | 	color: #FFF;
 53 | }
 54 | 
 55 | #qunit-testrunner-toolbar label {
 56 | 	display: inline-block;
 57 | 	padding: 0 0.5em 0 0.1em;
 58 | }
 59 | 
 60 | #qunit-banner {
 61 | 	height: 5px;
 62 | }
 63 | 
 64 | #qunit-testrunner-toolbar {
 65 | 	padding: 0.5em 0 0.5em 2em;
 66 | 	color: #5E740B;
 67 | 	background-color: #EEE;
 68 | 	overflow: hidden;
 69 | }
 70 | 
 71 | #qunit-userAgent {
 72 | 	padding: 0.5em 0 0.5em 2.5em;
 73 | 	background-color: #2B81AF;
 74 | 	color: #FFF;
 75 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 76 | }
 77 | 
 78 | #qunit-modulefilter-container {
 79 | 	float: right;
 80 | }
 81 | 
 82 | /** Tests: Pass/Fail */
 83 | 
 84 | #qunit-tests {
 85 | 	list-style-position: inside;
 86 | }
 87 | 
 88 | #qunit-tests li {
 89 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 90 | 	border-bottom: 1px solid #FFF;
 91 | 	list-style-position: inside;
 92 | }
 93 | 
 94 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 95 | 	display: none;
 96 | }
 97 | 
 98 | #qunit-tests li strong {
 99 | 	cursor: pointer;
100 | }
101 | 
102 | #qunit-tests li a {
103 | 	padding: 0.5em;
104 | 	color: #C2CCD1;
105 | 	text-decoration: none;
106 | }
107 | #qunit-tests li a:hover,
108 | #qunit-tests li a:focus {
109 | 	color: #000;
110 | }
111 | 
112 | #qunit-tests li .runtime {
113 | 	float: right;
114 | 	font-size: smaller;
115 | }
116 | 
117 | .qunit-assert-list {
118 | 	margin-top: 0.5em;
119 | 	padding: 0.5em;
120 | 
121 | 	background-color: #FFF;
122 | 
123 | 	border-radius: 5px;
124 | }
125 | 
126 | .qunit-collapsed {
127 | 	display: none;
128 | }
129 | 
130 | #qunit-tests table {
131 | 	border-collapse: collapse;
132 | 	margin-top: 0.2em;
133 | }
134 | 
135 | #qunit-tests th {
136 | 	text-align: right;
137 | 	vertical-align: top;
138 | 	padding: 0 0.5em 0 0;
139 | }
140 | 
141 | #qunit-tests td {
142 | 	vertical-align: top;
143 | }
144 | 
145 | #qunit-tests pre {
146 | 	margin: 0;
147 | 	white-space: pre-wrap;
148 | 	word-wrap: break-word;
149 | }
150 | 
151 | #qunit-tests del {
152 | 	background-color: #E0F2BE;
153 | 	color: #374E0C;
154 | 	text-decoration: none;
155 | }
156 | 
157 | #qunit-tests ins {
158 | 	background-color: #FFCACA;
159 | 	color: #500;
160 | 	text-decoration: none;
161 | }
162 | 
163 | /*** Test Counts */
164 | 
165 | #qunit-tests b.counts                       { color: #000; }
166 | #qunit-tests b.passed                       { color: #5E740B; }
167 | #qunit-tests b.failed                       { color: #710909; }
168 | 
169 | #qunit-tests li li {
170 | 	padding: 5px;
171 | 	background-color: #FFF;
172 | 	border-bottom: none;
173 | 	list-style-position: inside;
174 | }
175 | 
176 | /*** Passing Styles */
177 | 
178 | #qunit-tests li li.pass {
179 | 	color: #3C510C;
180 | 	background-color: #FFF;
181 | 	border-left: 10px solid #C6E746;
182 | }
183 | 
184 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
185 | #qunit-tests .pass .test-name               { color: #366097; }
186 | 
187 | #qunit-tests .pass .test-actual,
188 | #qunit-tests .pass .test-expected           { color: #999; }
189 | 
190 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
191 | 
192 | /*** Failing Styles */
193 | 
194 | #qunit-tests li li.fail {
195 | 	color: #710909;
196 | 	background-color: #FFF;
197 | 	border-left: 10px solid #EE5757;
198 | 	white-space: pre;
199 | }
200 | 
201 | #qunit-tests > li:last-child {
202 | 	border-radius: 0 0 5px 5px;
203 | }
204 | 
205 | #qunit-tests .fail                          { color: #000; background-color: #EE5757; }
206 | #qunit-tests .fail .test-name,
207 | #qunit-tests .fail .module-name             { color: #000; }
208 | 
209 | #qunit-tests .fail .test-actual             { color: #EE5757; }
210 | #qunit-tests .fail .test-expected           { color: #008000; }
211 | 
212 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
213 | 
214 | 
215 | /** Result */
216 | 
217 | #qunit-testresult {
218 | 	padding: 0.5em 0.5em 0.5em 2.5em;
219 | 
220 | 	color: #2B81AF;
221 | 	background-color: #D2E0E6;
222 | 
223 | 	border-bottom: 1px solid #FFF;
224 | }
225 | #qunit-testresult .module-name {
226 | 	font-weight: 700;
227 | }
228 | 
229 | /** Fixture */
230 | 
231 | #qunit-stage {
232 | 	position: absolute;
233 | 	top: -10000px;
234 | 	left: -10000px;
235 | 	width: 1000px;
236 | 	height: 1000px;
237 | }
238 | 


--------------------------------------------------------------------------------
/test/when.js:
--------------------------------------------------------------------------------
   1 | !function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.Promise=e():"undefined"!=typeof global?global.Promise=e():"undefined"!=typeof self&&(self.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 require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
   3 | /** @author Brian Cavalier */
   4 | /** @author John Hann */
   5 | 
   6 | /**
   7 |  * ES6 global Promise shim
   8 |  */
   9 | var unhandledRejections = require('../lib/decorators/unhandledRejection');
  10 | var PromiseConstructor = module.exports = unhandledRejections(require('../lib/Promise'));
  11 | 
  12 | var g = typeof global !== 'undefined' && global
  13 | 	|| typeof self !== 'undefined' && self;
  14 | 
  15 | if(typeof g !== 'undefined' && typeof g.Promise === 'undefined') {
  16 | 	g['Promise'] = PromiseConstructor;
  17 | }
  18 | 
  19 | },{"../lib/Promise":2,"../lib/decorators/unhandledRejection":6}],2:[function(require,module,exports){
  20 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
  21 | /** @author Brian Cavalier */
  22 | /** @author John Hann */
  23 | 
  24 | (function(define) { 'use strict';
  25 | define(function (require) {
  26 | 
  27 | 	var makePromise = require('./makePromise');
  28 | 	var Scheduler = require('./Scheduler');
  29 | 	var async = require('./async');
  30 | 
  31 | 	return makePromise({
  32 | 		scheduler: new Scheduler(async)
  33 | 	});
  34 | 
  35 | });
  36 | })(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory(require); });
  37 | 
  38 | },{"./Scheduler":4,"./async":5,"./makePromise":7}],3:[function(require,module,exports){
  39 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
  40 | /** @author Brian Cavalier */
  41 | /** @author John Hann */
  42 | 
  43 | (function(define) { 'use strict';
  44 | define(function() {
  45 | 	/**
  46 | 	 * Circular queue
  47 | 	 * @param {number} capacityPow2 power of 2 to which this queue's capacity
  48 | 	 *  will be set initially. eg when capacityPow2 == 3, queue capacity
  49 | 	 *  will be 8.
  50 | 	 * @constructor
  51 | 	 */
  52 | 	function Queue(capacityPow2) {
  53 | 		this.head = this.tail = this.length = 0;
  54 | 		this.buffer = new Array(1 << capacityPow2);
  55 | 	}
  56 | 
  57 | 	Queue.prototype.push = function(x) {
  58 | 		if(this.length === this.buffer.length) {
  59 | 			this._ensureCapacity(this.length * 2);
  60 | 		}
  61 | 
  62 | 		this.buffer[this.tail] = x;
  63 | 		this.tail = (this.tail + 1) & (this.buffer.length - 1);
  64 | 		++this.length;
  65 | 		return this.length;
  66 | 	};
  67 | 
  68 | 	Queue.prototype.shift = function() {
  69 | 		var x = this.buffer[this.head];
  70 | 		this.buffer[this.head] = void 0;
  71 | 		this.head = (this.head + 1) & (this.buffer.length - 1);
  72 | 		--this.length;
  73 | 		return x;
  74 | 	};
  75 | 
  76 | 	Queue.prototype._ensureCapacity = function(capacity) {
  77 | 		var head = this.head;
  78 | 		var buffer = this.buffer;
  79 | 		var newBuffer = new Array(capacity);
  80 | 		var i = 0;
  81 | 		var len;
  82 | 
  83 | 		if(head === 0) {
  84 | 			len = this.length;
  85 | 			for(; i<len; ++i) {
  86 | 				newBuffer[i] = buffer[i];
  87 | 			}
  88 | 		} else {
  89 | 			capacity = buffer.length;
  90 | 			len = this.tail;
  91 | 			for(; head<capacity; ++i, ++head) {
  92 | 				newBuffer[i] = buffer[head];
  93 | 			}
  94 | 
  95 | 			for(head=0; head<len; ++i, ++head) {
  96 | 				newBuffer[i] = buffer[head];
  97 | 			}
  98 | 		}
  99 | 
 100 | 		this.buffer = newBuffer;
 101 | 		this.head = 0;
 102 | 		this.tail = this.length;
 103 | 	};
 104 | 
 105 | 	return Queue;
 106 | 
 107 | });
 108 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
 109 | 
 110 | },{}],4:[function(require,module,exports){
 111 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
 112 | /** @author Brian Cavalier */
 113 | /** @author John Hann */
 114 | 
 115 | (function(define) { 'use strict';
 116 | define(function(require) {
 117 | 
 118 | 	var Queue = require('./Queue');
 119 | 
 120 | 	// Credit to Twisol (https://github.com/Twisol) for suggesting
 121 | 	// this type of extensible queue + trampoline approach for next-tick conflation.
 122 | 
 123 | 	/**
 124 | 	 * Async task scheduler
 125 | 	 * @param {function} async function to schedule a single async function
 126 | 	 * @constructor
 127 | 	 */
 128 | 	function Scheduler(async) {
 129 | 		this._async = async;
 130 | 		this._queue = new Queue(15);
 131 | 		this._afterQueue = new Queue(5);
 132 | 		this._running = false;
 133 | 
 134 | 		var self = this;
 135 | 		this.drain = function() {
 136 | 			self._drain();
 137 | 		};
 138 | 	}
 139 | 
 140 | 	/**
 141 | 	 * Enqueue a task
 142 | 	 * @param {{ run:function }} task
 143 | 	 */
 144 | 	Scheduler.prototype.enqueue = function(task) {
 145 | 		this._add(this._queue, task);
 146 | 	};
 147 | 
 148 | 	/**
 149 | 	 * Enqueue a task to run after the main task queue
 150 | 	 * @param {{ run:function }} task
 151 | 	 */
 152 | 	Scheduler.prototype.afterQueue = function(task) {
 153 | 		this._add(this._afterQueue, task);
 154 | 	};
 155 | 
 156 | 	/**
 157 | 	 * Drain the handler queue entirely, and then the after queue
 158 | 	 */
 159 | 	Scheduler.prototype._drain = function() {
 160 | 		runQueue(this._queue);
 161 | 		this._running = false;
 162 | 		runQueue(this._afterQueue);
 163 | 	};
 164 | 
 165 | 	/**
 166 | 	 * Add a task to the q, and schedule drain if not already scheduled
 167 | 	 * @param {Queue} queue
 168 | 	 * @param {{run:function}} task
 169 | 	 * @private
 170 | 	 */
 171 | 	Scheduler.prototype._add = function(queue, task) {
 172 | 		queue.push(task);
 173 | 		if(!this._running) {
 174 | 			this._running = true;
 175 | 			this._async(this.drain);
 176 | 		}
 177 | 	};
 178 | 
 179 | 	/**
 180 | 	 * Run all the tasks in the q
 181 | 	 * @param queue
 182 | 	 */
 183 | 	function runQueue(queue) {
 184 | 		while(queue.length > 0) {
 185 | 			queue.shift().run();
 186 | 		}
 187 | 	}
 188 | 
 189 | 	return Scheduler;
 190 | 
 191 | });
 192 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
 193 | 
 194 | },{"./Queue":3}],5:[function(require,module,exports){
 195 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
 196 | /** @author Brian Cavalier */
 197 | /** @author John Hann */
 198 | 
 199 | (function(define) { 'use strict';
 200 | define(function(require) {
 201 | 
 202 | 	// Sniff "best" async scheduling option
 203 | 	// Prefer process.nextTick or MutationObserver, then check for
 204 | 	// vertx and finally fall back to setTimeout
 205 | 
 206 | 	/*jshint maxcomplexity:6*/
 207 | 	/*global process,document,setTimeout,MutationObserver,WebKitMutationObserver*/
 208 | 	var nextTick, MutationObs;
 209 | 
 210 | 	if (typeof process !== 'undefined' && process !== null &&
 211 | 		typeof process.nextTick === 'function') {
 212 | 		nextTick = function(f) {
 213 | 			process.nextTick(f);
 214 | 		};
 215 | 
 216 | 	} else if (MutationObs =
 217 | 		(typeof MutationObserver === 'function' && MutationObserver) ||
 218 | 		(typeof WebKitMutationObserver === 'function' && WebKitMutationObserver)) {
 219 | 		nextTick = (function (document, MutationObserver) {
 220 | 			var scheduled;
 221 | 			var el = document.createElement('div');
 222 | 			var o = new MutationObserver(run);
 223 | 			o.observe(el, { attributes: true });
 224 | 
 225 | 			function run() {
 226 | 				var f = scheduled;
 227 | 				scheduled = void 0;
 228 | 				f();
 229 | 			}
 230 | 
 231 | 			return function (f) {
 232 | 				scheduled = f;
 233 | 				el.setAttribute('class', 'x');
 234 | 			};
 235 | 		}(document, MutationObs));
 236 | 
 237 | 	} else {
 238 | 		nextTick = (function(cjsRequire) {
 239 | 			try {
 240 | 				// vert.x 1.x || 2.x
 241 | 				return cjsRequire('vertx').runOnLoop || cjsRequire('vertx').runOnContext;
 242 | 			} catch (ignore) {}
 243 | 
 244 | 			// capture setTimeout to avoid being caught by fake timers
 245 | 			// used in time based tests
 246 | 			var capturedSetTimeout = setTimeout;
 247 | 			return function (t) {
 248 | 				capturedSetTimeout(t, 0);
 249 | 			};
 250 | 		}(require));
 251 | 	}
 252 | 
 253 | 	return nextTick;
 254 | });
 255 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
 256 | 
 257 | },{}],6:[function(require,module,exports){
 258 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
 259 | /** @author Brian Cavalier */
 260 | /** @author John Hann */
 261 | 
 262 | (function(define) { 'use strict';
 263 | define(function(require) {
 264 | 
 265 | 	var timer = require('../timer');
 266 | 
 267 | 	return function unhandledRejection(Promise) {
 268 | 		var logError = noop;
 269 | 		var logInfo = noop;
 270 | 
 271 | 		if(typeof console !== 'undefined') {
 272 | 			logError = typeof console.error !== 'undefined'
 273 | 				? function (e) { console.error(e); }
 274 | 				: function (e) { console.log(e); };
 275 | 
 276 | 			logInfo = typeof console.info !== 'undefined'
 277 | 				? function (e) { console.info(e); }
 278 | 				: function (e) { console.log(e); };
 279 | 		}
 280 | 
 281 | 		Promise.onPotentiallyUnhandledRejection = function(rejection) {
 282 | 			enqueue(report, rejection);
 283 | 		};
 284 | 
 285 | 		Promise.onPotentiallyUnhandledRejectionHandled = function(rejection) {
 286 | 			enqueue(unreport, rejection);
 287 | 		};
 288 | 
 289 | 		Promise.onFatalRejection = function(rejection) {
 290 | 			enqueue(throwit, rejection.value);
 291 | 		};
 292 | 
 293 | 		var tasks = [];
 294 | 		var reported = [];
 295 | 		var running = false;
 296 | 
 297 | 		function report(r) {
 298 | 			if(!r.handled) {
 299 | 				reported.push(r);
 300 | 				logError('Potentially unhandled rejection [' + r.id + '] ' + formatError(r.value));
 301 | 			}
 302 | 		}
 303 | 
 304 | 		function unreport(r) {
 305 | 			var i = reported.indexOf(r);
 306 | 			if(i >= 0) {
 307 | 				reported.splice(i, 1);
 308 | 				logInfo('Handled previous rejection [' + r.id + '] ' + formatObject(r.value));
 309 | 			}
 310 | 		}
 311 | 
 312 | 		function enqueue(f, x) {
 313 | 			tasks.push(f, x);
 314 | 			if(!running) {
 315 | 				running = true;
 316 | 				running = timer.set(flush, 0);
 317 | 			}
 318 | 		}
 319 | 
 320 | 		function flush() {
 321 | 			running = false;
 322 | 			while(tasks.length > 0) {
 323 | 				tasks.shift()(tasks.shift());
 324 | 			}
 325 | 		}
 326 | 
 327 | 		return Promise;
 328 | 	};
 329 | 
 330 | 	function formatError(e) {
 331 | 		var s = typeof e === 'object' && e.stack ? e.stack : formatObject(e);
 332 | 		return e instanceof Error ? s : s + ' (WARNING: non-Error used)';
 333 | 	}
 334 | 
 335 | 	function formatObject(o) {
 336 | 		var s = String(o);
 337 | 		if(s === '[object Object]' && typeof JSON !== 'undefined') {
 338 | 			s = tryStringify(o, s);
 339 | 		}
 340 | 		return s;
 341 | 	}
 342 | 
 343 | 	function tryStringify(e, defaultValue) {
 344 | 		try {
 345 | 			return JSON.stringify(e);
 346 | 		} catch(e) {
 347 | 			// Ignore. Cannot JSON.stringify e, stick with String(e)
 348 | 			return defaultValue;
 349 | 		}
 350 | 	}
 351 | 
 352 | 	function throwit(e) {
 353 | 		throw e;
 354 | 	}
 355 | 
 356 | 	function noop() {}
 357 | 
 358 | });
 359 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
 360 | 
 361 | },{"../timer":8}],7:[function(require,module,exports){
 362 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
 363 | /** @author Brian Cavalier */
 364 | /** @author John Hann */
 365 | 
 366 | (function(define) { 'use strict';
 367 | define(function() {
 368 | 
 369 | 	return function makePromise(environment) {
 370 | 
 371 | 		var tasks = environment.scheduler;
 372 | 
 373 | 		var objectCreate = Object.create ||
 374 | 			function(proto) {
 375 | 				function Child() {}
 376 | 				Child.prototype = proto;
 377 | 				return new Child();
 378 | 			};
 379 | 
 380 | 		/**
 381 | 		 * Create a promise whose fate is determined by resolver
 382 | 		 * @constructor
 383 | 		 * @returns {Promise} promise
 384 | 		 * @name Promise
 385 | 		 */
 386 | 		function Promise(resolver, handler) {
 387 | 			this._handler = resolver === Handler ? handler : init(resolver);
 388 | 		}
 389 | 
 390 | 		/**
 391 | 		 * Run the supplied resolver
 392 | 		 * @param resolver
 393 | 		 * @returns {Pending}
 394 | 		 */
 395 | 		function init(resolver) {
 396 | 			var handler = new Pending();
 397 | 
 398 | 			try {
 399 | 				resolver(promiseResolve, promiseReject, promiseNotify);
 400 | 			} catch (e) {
 401 | 				promiseReject(e);
 402 | 			}
 403 | 
 404 | 			return handler;
 405 | 
 406 | 			/**
 407 | 			 * Transition from pre-resolution state to post-resolution state, notifying
 408 | 			 * all listeners of the ultimate fulfillment or rejection
 409 | 			 * @param {*} x resolution value
 410 | 			 */
 411 | 			function promiseResolve (x) {
 412 | 				handler.resolve(x);
 413 | 			}
 414 | 			/**
 415 | 			 * Reject this promise with reason, which will be used verbatim
 416 | 			 * @param {Error|*} reason rejection reason, strongly suggested
 417 | 			 *   to be an Error type
 418 | 			 */
 419 | 			function promiseReject (reason) {
 420 | 				handler.reject(reason);
 421 | 			}
 422 | 
 423 | 			/**
 424 | 			 * Issue a progress event, notifying all progress listeners
 425 | 			 * @param {*} x progress event payload to pass to all listeners
 426 | 			 */
 427 | 			function promiseNotify (x) {
 428 | 				handler.notify(x);
 429 | 			}
 430 | 		}
 431 | 
 432 | 		// Creation
 433 | 
 434 | 		Promise.resolve = resolve;
 435 | 		Promise.reject = reject;
 436 | 		Promise.never = never;
 437 | 
 438 | 		Promise._defer = defer;
 439 | 		Promise._handler = getHandler;
 440 | 
 441 | 		/**
 442 | 		 * Returns a trusted promise. If x is already a trusted promise, it is
 443 | 		 * returned, otherwise returns a new trusted Promise which follows x.
 444 | 		 * @param  {*} x
 445 | 		 * @return {Promise} promise
 446 | 		 */
 447 | 		function resolve(x) {
 448 | 			return isPromise(x) ? x
 449 | 				: new Promise(Handler, new Async(getHandler(x)));
 450 | 		}
 451 | 
 452 | 		/**
 453 | 		 * Return a reject promise with x as its reason (x is used verbatim)
 454 | 		 * @param {*} x
 455 | 		 * @returns {Promise} rejected promise
 456 | 		 */
 457 | 		function reject(x) {
 458 | 			return new Promise(Handler, new Async(new Rejected(x)));
 459 | 		}
 460 | 
 461 | 		/**
 462 | 		 * Return a promise that remains pending forever
 463 | 		 * @returns {Promise} forever-pending promise.
 464 | 		 */
 465 | 		function never() {
 466 | 			return foreverPendingPromise; // Should be frozen
 467 | 		}
 468 | 
 469 | 		/**
 470 | 		 * Creates an internal {promise, resolver} pair
 471 | 		 * @private
 472 | 		 * @returns {Promise}
 473 | 		 */
 474 | 		function defer() {
 475 | 			return new Promise(Handler, new Pending());
 476 | 		}
 477 | 
 478 | 		// Transformation and flow control
 479 | 
 480 | 		/**
 481 | 		 * Transform this promise's fulfillment value, returning a new Promise
 482 | 		 * for the transformed result.  If the promise cannot be fulfilled, onRejected
 483 | 		 * is called with the reason.  onProgress *may* be called with updates toward
 484 | 		 * this promise's fulfillment.
 485 | 		 * @param {function=} onFulfilled fulfillment handler
 486 | 		 * @param {function=} onRejected rejection handler
 487 | 		 * @deprecated @param {function=} onProgress progress handler
 488 | 		 * @return {Promise} new promise
 489 | 		 */
 490 | 		Promise.prototype.then = function(onFulfilled, onRejected) {
 491 | 			var parent = this._handler;
 492 | 
 493 | 			if (typeof onFulfilled !== 'function' && parent.join().state() > 0) {
 494 | 				// Short circuit: value will not change, simply share handler
 495 | 				return new Promise(Handler, parent);
 496 | 			}
 497 | 
 498 | 			var p = this._beget();
 499 | 			var child = p._handler;
 500 | 
 501 | 			parent.chain(child, parent.receiver, onFulfilled, onRejected,
 502 | 					arguments.length > 2 ? arguments[2] : void 0);
 503 | 
 504 | 			return p;
 505 | 		};
 506 | 
 507 | 		/**
 508 | 		 * If this promise cannot be fulfilled due to an error, call onRejected to
 509 | 		 * handle the error. Shortcut for .then(undefined, onRejected)
 510 | 		 * @param {function?} onRejected
 511 | 		 * @return {Promise}
 512 | 		 */
 513 | 		Promise.prototype['catch'] = function(onRejected) {
 514 | 			return this.then(void 0, onRejected);
 515 | 		};
 516 | 
 517 | 		/**
 518 | 		 * Private function to bind a thisArg for this promise's handlers
 519 | 		 * @private
 520 | 		 * @param {object} thisArg `this` value for all handlers attached to
 521 | 		 *  the returned promise.
 522 | 		 * @returns {Promise}
 523 | 		 */
 524 | 		Promise.prototype._bindContext = function(thisArg) {
 525 | 			return new Promise(Handler, new Bound(this._handler, thisArg));
 526 | 		};
 527 | 
 528 | 		/**
 529 | 		 * Creates a new, pending promise of the same type as this promise
 530 | 		 * @private
 531 | 		 * @returns {Promise}
 532 | 		 */
 533 | 		Promise.prototype._beget = function() {
 534 | 			var parent = this._handler;
 535 | 			var child = new Pending(parent.receiver, parent.join().context);
 536 | 			return new this.constructor(Handler, child);
 537 | 		};
 538 | 
 539 | 		// Array combinators
 540 | 
 541 | 		Promise.all = all;
 542 | 		Promise.race = race;
 543 | 
 544 | 		/**
 545 | 		 * Return a promise that will fulfill when all promises in the
 546 | 		 * input array have fulfilled, or will reject when one of the
 547 | 		 * promises rejects.
 548 | 		 * @param {array} promises array of promises
 549 | 		 * @returns {Promise} promise for array of fulfillment values
 550 | 		 */
 551 | 		function all(promises) {
 552 | 			/*jshint maxcomplexity:8*/
 553 | 			var resolver = new Pending();
 554 | 			var pending = promises.length >>> 0;
 555 | 			var results = new Array(pending);
 556 | 
 557 | 			var i, h, x, s;
 558 | 			for (i = 0; i < promises.length; ++i) {
 559 | 				x = promises[i];
 560 | 
 561 | 				if (x === void 0 && !(i in promises)) {
 562 | 					--pending;
 563 | 					continue;
 564 | 				}
 565 | 
 566 | 				if (maybeThenable(x)) {
 567 | 					h = isPromise(x)
 568 | 						? x._handler.join()
 569 | 						: getHandlerUntrusted(x);
 570 | 
 571 | 					s = h.state();
 572 | 					if (s === 0) {
 573 | 						h.fold(settleAt, i, results, resolver);
 574 | 					} else if (s > 0) {
 575 | 						results[i] = h.value;
 576 | 						--pending;
 577 | 					} else {
 578 | 						resolver.become(h);
 579 | 						break;
 580 | 					}
 581 | 
 582 | 				} else {
 583 | 					results[i] = x;
 584 | 					--pending;
 585 | 				}
 586 | 			}
 587 | 
 588 | 			if(pending === 0) {
 589 | 				resolver.become(new Fulfilled(results));
 590 | 			}
 591 | 
 592 | 			return new Promise(Handler, resolver);
 593 | 
 594 | 			function settleAt(i, x, resolver) {
 595 | 				/*jshint validthis:true*/
 596 | 				this[i] = x;
 597 | 				if(--pending === 0) {
 598 | 					resolver.become(new Fulfilled(this));
 599 | 				}
 600 | 			}
 601 | 		}
 602 | 
 603 | 		/**
 604 | 		 * Fulfill-reject competitive race. Return a promise that will settle
 605 | 		 * to the same state as the earliest input promise to settle.
 606 | 		 *
 607 | 		 * WARNING: The ES6 Promise spec requires that race()ing an empty array
 608 | 		 * must return a promise that is pending forever.  This implementation
 609 | 		 * returns a singleton forever-pending promise, the same singleton that is
 610 | 		 * returned by Promise.never(), thus can be checked with ===
 611 | 		 *
 612 | 		 * @param {array} promises array of promises to race
 613 | 		 * @returns {Promise} if input is non-empty, a promise that will settle
 614 | 		 * to the same outcome as the earliest input promise to settle. if empty
 615 | 		 * is empty, returns a promise that will never settle.
 616 | 		 */
 617 | 		function race(promises) {
 618 | 			// Sigh, race([]) is untestable unless we return *something*
 619 | 			// that is recognizable without calling .then() on it.
 620 | 			if(Object(promises) === promises && promises.length === 0) {
 621 | 				return never();
 622 | 			}
 623 | 
 624 | 			var h = new Pending();
 625 | 			var i, x;
 626 | 			for(i=0; i<promises.length; ++i) {
 627 | 				x = promises[i];
 628 | 				if (x !== void 0 && i in promises) {
 629 | 					getHandler(x).visit(h, h.resolve, h.reject);
 630 | 				}
 631 | 			}
 632 | 			return new Promise(Handler, h);
 633 | 		}
 634 | 
 635 | 		// Promise internals
 636 | 		// Below this, everything is @private
 637 | 
 638 | 		/**
 639 | 		 * Get an appropriate handler for x, without checking for cycles
 640 | 		 * @param {*} x
 641 | 		 * @returns {object} handler
 642 | 		 */
 643 | 		function getHandler(x) {
 644 | 			if(isPromise(x)) {
 645 | 				return x._handler.join();
 646 | 			}
 647 | 			return maybeThenable(x) ? getHandlerUntrusted(x) : new Fulfilled(x);
 648 | 		}
 649 | 
 650 | 		/**
 651 | 		 * Get a handler for potentially untrusted thenable x
 652 | 		 * @param {*} x
 653 | 		 * @returns {object} handler
 654 | 		 */
 655 | 		function getHandlerUntrusted(x) {
 656 | 			try {
 657 | 				var untrustedThen = x.then;
 658 | 				return typeof untrustedThen === 'function'
 659 | 					? new Thenable(untrustedThen, x)
 660 | 					: new Fulfilled(x);
 661 | 			} catch(e) {
 662 | 				return new Rejected(e);
 663 | 			}
 664 | 		}
 665 | 
 666 | 		/**
 667 | 		 * Handler for a promise that is pending forever
 668 | 		 * @constructor
 669 | 		 */
 670 | 		function Handler() {}
 671 | 
 672 | 		Handler.prototype.when
 673 | 			= Handler.prototype.become
 674 | 			= Handler.prototype.notify
 675 | 			= Handler.prototype.fail
 676 | 			= Handler.prototype._unreport
 677 | 			= Handler.prototype._report
 678 | 			= noop;
 679 | 
 680 | 		Handler.prototype.inspect = toPendingState;
 681 | 
 682 | 		Handler.prototype._state = 0;
 683 | 
 684 | 		Handler.prototype.state = function() {
 685 | 			return this._state;
 686 | 		};
 687 | 
 688 | 		/**
 689 | 		 * Recursively collapse handler chain to find the handler
 690 | 		 * nearest to the fully resolved value.
 691 | 		 * @returns {object} handler nearest the fully resolved value
 692 | 		 */
 693 | 		Handler.prototype.join = function() {
 694 | 			var h = this;
 695 | 			while(h.handler !== void 0) {
 696 | 				h = h.handler;
 697 | 			}
 698 | 			return h;
 699 | 		};
 700 | 
 701 | 		Handler.prototype.chain = function(to, receiver, fulfilled, rejected, progress) {
 702 | 			this.when({
 703 | 				resolver: to,
 704 | 				receiver: receiver,
 705 | 				fulfilled: fulfilled,
 706 | 				rejected: rejected,
 707 | 				progress: progress
 708 | 			});
 709 | 		};
 710 | 
 711 | 		Handler.prototype.visit = function(receiver, fulfilled, rejected, progress) {
 712 | 			this.chain(failIfRejected, receiver, fulfilled, rejected, progress);
 713 | 		};
 714 | 
 715 | 		Handler.prototype.fold = function(f, z, c, to) {
 716 | 			this.visit(to, function(x) {
 717 | 				f.call(c, z, x, this);
 718 | 			}, to.reject, to.notify);
 719 | 		};
 720 | 
 721 | 		/**
 722 | 		 * Handler that invokes fail() on any handler it becomes
 723 | 		 * @constructor
 724 | 		 */
 725 | 		function FailIfRejected() {}
 726 | 
 727 | 		inherit(Handler, FailIfRejected);
 728 | 
 729 | 		FailIfRejected.prototype.become = function(h) {
 730 | 			h.fail();
 731 | 		};
 732 | 
 733 | 		var failIfRejected = new FailIfRejected();
 734 | 
 735 | 		/**
 736 | 		 * Handler that manages a queue of consumers waiting on a pending promise
 737 | 		 * @constructor
 738 | 		 */
 739 | 		function Pending(receiver, inheritedContext) {
 740 | 			Promise.createContext(this, inheritedContext);
 741 | 
 742 | 			this.consumers = void 0;
 743 | 			this.receiver = receiver;
 744 | 			this.handler = void 0;
 745 | 			this.resolved = false;
 746 | 		}
 747 | 
 748 | 		inherit(Handler, Pending);
 749 | 
 750 | 		Pending.prototype._state = 0;
 751 | 
 752 | 		Pending.prototype.inspect = function() {
 753 | 			return this.resolved ? this.join().inspect() : toPendingState();
 754 | 		};
 755 | 
 756 | 		Pending.prototype.resolve = function(x) {
 757 | 			this.become(getHandler(x));
 758 | 		};
 759 | 
 760 | 		Pending.prototype.reject = function(x) {
 761 | 			if(this.resolved) {
 762 | 				return;
 763 | 			}
 764 | 
 765 | 			this.become(new Rejected(x));
 766 | 		};
 767 | 
 768 | 		Pending.prototype.join = function() {
 769 | 			if (!this.resolved) {
 770 | 				return this;
 771 | 			}
 772 | 
 773 | 			var h = this;
 774 | 
 775 | 			while (h.handler !== void 0) {
 776 | 				h = h.handler;
 777 | 				if (h === this) {
 778 | 					return this.handler = cycle();
 779 | 				}
 780 | 			}
 781 | 
 782 | 			return h;
 783 | 		};
 784 | 
 785 | 		Pending.prototype.run = function() {
 786 | 			var q = this.consumers;
 787 | 			var handler = this.join();
 788 | 			this.consumers = void 0;
 789 | 
 790 | 			for (var i = 0; i < q.length; ++i) {
 791 | 				handler.when(q[i]);
 792 | 			}
 793 | 		};
 794 | 
 795 | 		Pending.prototype.become = function(handler) {
 796 | 			if(this.resolved) {
 797 | 				return;
 798 | 			}
 799 | 
 800 | 			this.resolved = true;
 801 | 			this.handler = handler;
 802 | 			if(this.consumers !== void 0) {
 803 | 				tasks.enqueue(this);
 804 | 			}
 805 | 
 806 | 			if(this.context !== void 0) {
 807 | 				handler._report(this.context);
 808 | 			}
 809 | 		};
 810 | 
 811 | 		Pending.prototype.when = function(continuation) {
 812 | 			if(this.resolved) {
 813 | 				tasks.enqueue(new ContinuationTask(continuation, this.handler));
 814 | 			} else {
 815 | 				if(this.consumers === void 0) {
 816 | 					this.consumers = [continuation];
 817 | 				} else {
 818 | 					this.consumers.push(continuation);
 819 | 				}
 820 | 			}
 821 | 		};
 822 | 
 823 | 		Pending.prototype.notify = function(x) {
 824 | 			if(!this.resolved) {
 825 | 				tasks.enqueue(new ProgressTask(x, this));
 826 | 			}
 827 | 		};
 828 | 
 829 | 		Pending.prototype.fail = function(context) {
 830 | 			var c = typeof context === 'undefined' ? this.context : context;
 831 | 			this.resolved && this.handler.join().fail(c);
 832 | 		};
 833 | 
 834 | 		Pending.prototype._report = function(context) {
 835 | 			this.resolved && this.handler.join()._report(context);
 836 | 		};
 837 | 
 838 | 		Pending.prototype._unreport = function() {
 839 | 			this.resolved && this.handler.join()._unreport();
 840 | 		};
 841 | 
 842 | 		/**
 843 | 		 * Abstract base for handler that delegates to another handler
 844 | 		 * @param {object} handler
 845 | 		 * @constructor
 846 | 		 */
 847 | 		function Delegating(handler) {
 848 | 			this.handler = handler;
 849 | 		}
 850 | 
 851 | 		inherit(Handler, Delegating);
 852 | 
 853 | 		Delegating.prototype.inspect = function() {
 854 | 			return this.join().inspect();
 855 | 		};
 856 | 
 857 | 		Delegating.prototype._report = function(context) {
 858 | 			this.join()._report(context);
 859 | 		};
 860 | 
 861 | 		Delegating.prototype._unreport = function() {
 862 | 			this.join()._unreport();
 863 | 		};
 864 | 
 865 | 		/**
 866 | 		 * Wrap another handler and force it into a future stack
 867 | 		 * @param {object} handler
 868 | 		 * @constructor
 869 | 		 */
 870 | 		function Async(handler) {
 871 | 			Delegating.call(this, handler);
 872 | 		}
 873 | 
 874 | 		inherit(Delegating, Async);
 875 | 
 876 | 		Async.prototype.when = function(continuation) {
 877 | 			tasks.enqueue(new ContinuationTask(continuation, this));
 878 | 		};
 879 | 
 880 | 		/**
 881 | 		 * Handler that follows another handler, injecting a receiver
 882 | 		 * @param {object} handler another handler to follow
 883 | 		 * @param {object=undefined} receiver
 884 | 		 * @constructor
 885 | 		 */
 886 | 		function Bound(handler, receiver) {
 887 | 			Delegating.call(this, handler);
 888 | 			this.receiver = receiver;
 889 | 		}
 890 | 
 891 | 		inherit(Delegating, Bound);
 892 | 
 893 | 		Bound.prototype.when = function(continuation) {
 894 | 			// Because handlers are allowed to be shared among promises,
 895 | 			// each of which possibly having a different receiver, we have
 896 | 			// to insert our own receiver into the chain if it has been set
 897 | 			// so that callbacks (f, r, u) will be called using our receiver
 898 | 			if(this.receiver !== void 0) {
 899 | 				continuation.receiver = this.receiver;
 900 | 			}
 901 | 			this.join().when(continuation);
 902 | 		};
 903 | 
 904 | 		/**
 905 | 		 * Handler that wraps an untrusted thenable and assimilates it in a future stack
 906 | 		 * @param {function} then
 907 | 		 * @param {{then: function}} thenable
 908 | 		 * @constructor
 909 | 		 */
 910 | 		function Thenable(then, thenable) {
 911 | 			Pending.call(this);
 912 | 			tasks.enqueue(new AssimilateTask(then, thenable, this));
 913 | 		}
 914 | 
 915 | 		inherit(Pending, Thenable);
 916 | 
 917 | 		/**
 918 | 		 * Handler for a fulfilled promise
 919 | 		 * @param {*} x fulfillment value
 920 | 		 * @constructor
 921 | 		 */
 922 | 		function Fulfilled(x) {
 923 | 			Promise.createContext(this);
 924 | 			this.value = x;
 925 | 		}
 926 | 
 927 | 		inherit(Handler, Fulfilled);
 928 | 
 929 | 		Fulfilled.prototype._state = 1;
 930 | 
 931 | 		Fulfilled.prototype.inspect = function() {
 932 | 			return { state: 'fulfilled', value: this.value };
 933 | 		};
 934 | 
 935 | 		Fulfilled.prototype.fold = function(f, z, c, to) {
 936 | 			runContinuation3(f, z, this, c, to);
 937 | 		};
 938 | 
 939 | 		Fulfilled.prototype.when = function(cont) {
 940 | 			runContinuation1(cont.fulfilled, this, cont.receiver, cont.resolver);
 941 | 		};
 942 | 
 943 | 		var errorId = 0;
 944 | 
 945 | 		/**
 946 | 		 * Handler for a rejected promise
 947 | 		 * @param {*} x rejection reason
 948 | 		 * @constructor
 949 | 		 */
 950 | 		function Rejected(x) {
 951 | 			Promise.createContext(this);
 952 | 
 953 | 			this.id = ++errorId;
 954 | 			this.value = x;
 955 | 			this.handled = false;
 956 | 			this.reported = false;
 957 | 
 958 | 			this._report();
 959 | 		}
 960 | 
 961 | 		inherit(Handler, Rejected);
 962 | 
 963 | 		Rejected.prototype._state = -1;
 964 | 
 965 | 		Rejected.prototype.inspect = function() {
 966 | 			return { state: 'rejected', reason: this.value };
 967 | 		};
 968 | 
 969 | 		Rejected.prototype.fold = function(f, z, c, to) {
 970 | 			this._unreport();
 971 | 			to.become(this);
 972 | 		};
 973 | 
 974 | 		Rejected.prototype.when = function(cont) {
 975 | 			this._unreport();
 976 | 			runContinuation1(cont.rejected, this, cont.receiver, cont.resolver);
 977 | 		};
 978 | 
 979 | 		Rejected.prototype._report = function(context) {
 980 | 			tasks.afterQueue(new ReportTask(this, context));
 981 | 		};
 982 | 
 983 | 		Rejected.prototype._unreport = function() {
 984 | 			this.handled = true;
 985 | 			tasks.afterQueue(new UnreportTask(this));
 986 | 		};
 987 | 
 988 | 		Rejected.prototype.fail = function(context) {
 989 | 			Promise.onFatalRejection(this, context === void 0 ? this.context : context);
 990 | 		};
 991 | 
 992 | 		function ReportTask(rejection, context) {
 993 | 			this.rejection = rejection;
 994 | 			this.context = context;
 995 | 		}
 996 | 
 997 | 		ReportTask.prototype.run = function() {
 998 | 			if(!this.rejection.handled) {
 999 | 				this.rejection.reported = true;
1000 | 				Promise.onPotentiallyUnhandledRejection(this.rejection, this.context);
1001 | 			}
1002 | 		};
1003 | 
1004 | 		function UnreportTask(rejection) {
1005 | 			this.rejection = rejection;
1006 | 		}
1007 | 
1008 | 		UnreportTask.prototype.run = function() {
1009 | 			if(this.rejection.reported) {
1010 | 				Promise.onPotentiallyUnhandledRejectionHandled(this.rejection);
1011 | 			}
1012 | 		};
1013 | 
1014 | 		// Unhandled rejection hooks
1015 | 		// By default, everything is a noop
1016 | 
1017 | 		// TODO: Better names: "annotate"?
1018 | 		Promise.createContext
1019 | 			= Promise.enterContext
1020 | 			= Promise.exitContext
1021 | 			= Promise.onPotentiallyUnhandledRejection
1022 | 			= Promise.onPotentiallyUnhandledRejectionHandled
1023 | 			= Promise.onFatalRejection
1024 | 			= noop;
1025 | 
1026 | 		// Errors and singletons
1027 | 
1028 | 		var foreverPendingHandler = new Handler();
1029 | 		var foreverPendingPromise = new Promise(Handler, foreverPendingHandler);
1030 | 
1031 | 		function cycle() {
1032 | 			return new Rejected(new TypeError('Promise cycle'));
1033 | 		}
1034 | 
1035 | 		// Snapshot states
1036 | 
1037 | 		/**
1038 | 		 * Creates a pending state snapshot
1039 | 		 * @returns {{state:'pending'}}
1040 | 		 */
1041 | 		function toPendingState() {
1042 | 			return { state: 'pending' };
1043 | 		}
1044 | 
1045 | 		// Task runners
1046 | 
1047 | 		/**
1048 | 		 * Run a single consumer
1049 | 		 * @constructor
1050 | 		 */
1051 | 		function ContinuationTask(continuation, handler) {
1052 | 			this.continuation = continuation;
1053 | 			this.handler = handler;
1054 | 		}
1055 | 
1056 | 		ContinuationTask.prototype.run = function() {
1057 | 			this.handler.join().when(this.continuation);
1058 | 		};
1059 | 
1060 | 		/**
1061 | 		 * Run a queue of progress handlers
1062 | 		 * @constructor
1063 | 		 */
1064 | 		function ProgressTask(value, handler) {
1065 | 			this.handler = handler;
1066 | 			this.value = value;
1067 | 		}
1068 | 
1069 | 		ProgressTask.prototype.run = function() {
1070 | 			var q = this.handler.consumers;
1071 | 			if(q === void 0) {
1072 | 				return;
1073 | 			}
1074 | 
1075 | 			for (var c, i = 0; i < q.length; ++i) {
1076 | 				c = q[i];
1077 | 				runNotify(c.progress, this.value, this.handler, c.receiver, c.resolver);
1078 | 			}
1079 | 		};
1080 | 
1081 | 		/**
1082 | 		 * Assimilate a thenable, sending it's value to resolver
1083 | 		 * @param {function} then
1084 | 		 * @param {object|function} thenable
1085 | 		 * @param {object} resolver
1086 | 		 * @constructor
1087 | 		 */
1088 | 		function AssimilateTask(then, thenable, resolver) {
1089 | 			this._then = then;
1090 | 			this.thenable = thenable;
1091 | 			this.resolver = resolver;
1092 | 		}
1093 | 
1094 | 		AssimilateTask.prototype.run = function() {
1095 | 			var h = this.resolver;
1096 | 			tryAssimilate(this._then, this.thenable, _resolve, _reject, _notify);
1097 | 
1098 | 			function _resolve(x) { h.resolve(x); }
1099 | 			function _reject(x)  { h.reject(x); }
1100 | 			function _notify(x)  { h.notify(x); }
1101 | 		};
1102 | 
1103 | 		function tryAssimilate(then, thenable, resolve, reject, notify) {
1104 | 			try {
1105 | 				then.call(thenable, resolve, reject, notify);
1106 | 			} catch (e) {
1107 | 				reject(e);
1108 | 			}
1109 | 		}
1110 | 
1111 | 		// Other helpers
1112 | 
1113 | 		/**
1114 | 		 * @param {*} x
1115 | 		 * @returns {boolean} true iff x is a trusted Promise
1116 | 		 */
1117 | 		function isPromise(x) {
1118 | 			return x instanceof Promise;
1119 | 		}
1120 | 
1121 | 		/**
1122 | 		 * Test just enough to rule out primitives, in order to take faster
1123 | 		 * paths in some code
1124 | 		 * @param {*} x
1125 | 		 * @returns {boolean} false iff x is guaranteed *not* to be a thenable
1126 | 		 */
1127 | 		function maybeThenable(x) {
1128 | 			return (typeof x === 'object' || typeof x === 'function') && x !== null;
1129 | 		}
1130 | 
1131 | 		function runContinuation1(f, h, receiver, next) {
1132 | 			if(typeof f !== 'function') {
1133 | 				return next.become(h);
1134 | 			}
1135 | 
1136 | 			Promise.enterContext(h);
1137 | 			tryCatchReject(f, h.value, receiver, next);
1138 | 			Promise.exitContext();
1139 | 		}
1140 | 
1141 | 		function runContinuation3(f, x, h, receiver, next) {
1142 | 			if(typeof f !== 'function') {
1143 | 				return next.become(h);
1144 | 			}
1145 | 
1146 | 			Promise.enterContext(h);
1147 | 			tryCatchReject3(f, x, h.value, receiver, next);
1148 | 			Promise.exitContext();
1149 | 		}
1150 | 
1151 | 		function runNotify(f, x, h, receiver, next) {
1152 | 			if(typeof f !== 'function') {
1153 | 				return next.notify(x);
1154 | 			}
1155 | 
1156 | 			Promise.enterContext(h);
1157 | 			tryCatchReturn(f, x, receiver, next);
1158 | 			Promise.exitContext();
1159 | 		}
1160 | 
1161 | 		/**
1162 | 		 * Return f.call(thisArg, x), or if it throws return a rejected promise for
1163 | 		 * the thrown exception
1164 | 		 */
1165 | 		function tryCatchReject(f, x, thisArg, next) {
1166 | 			try {
1167 | 				next.become(getHandler(f.call(thisArg, x)));
1168 | 			} catch(e) {
1169 | 				next.become(new Rejected(e));
1170 | 			}
1171 | 		}
1172 | 
1173 | 		/**
1174 | 		 * Same as above, but includes the extra argument parameter.
1175 | 		 */
1176 | 		function tryCatchReject3(f, x, y, thisArg, next) {
1177 | 			try {
1178 | 				f.call(thisArg, x, y, next);
1179 | 			} catch(e) {
1180 | 				next.become(new Rejected(e));
1181 | 			}
1182 | 		}
1183 | 
1184 | 		/**
1185 | 		 * Return f.call(thisArg, x), or if it throws, *return* the exception
1186 | 		 */
1187 | 		function tryCatchReturn(f, x, thisArg, next) {
1188 | 			try {
1189 | 				next.notify(f.call(thisArg, x));
1190 | 			} catch(e) {
1191 | 				next.notify(e);
1192 | 			}
1193 | 		}
1194 | 
1195 | 		function inherit(Parent, Child) {
1196 | 			Child.prototype = objectCreate(Parent.prototype);
1197 | 			Child.prototype.constructor = Child;
1198 | 		}
1199 | 
1200 | 		function noop() {}
1201 | 
1202 | 		return Promise;
1203 | 	};
1204 | });
1205 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(); }));
1206 | 
1207 | },{}],8:[function(require,module,exports){
1208 | /** @license MIT License (c) copyright 2010-2014 original author or authors */
1209 | /** @author Brian Cavalier */
1210 | /** @author John Hann */
1211 | 
1212 | (function(define) { 'use strict';
1213 | define(function(require) {
1214 | 	/*global setTimeout,clearTimeout*/
1215 | 	var cjsRequire, vertx, setTimer, clearTimer;
1216 | 
1217 | 	cjsRequire = require;
1218 | 
1219 | 	try {
1220 | 		vertx = cjsRequire('vertx');
1221 | 		setTimer = function (f, ms) { return vertx.setTimer(ms, f); };
1222 | 		clearTimer = vertx.cancelTimer;
1223 | 	} catch (e) {
1224 | 		setTimer = function(f, ms) { return setTimeout(f, ms); };
1225 | 		clearTimer = function(t) { return clearTimeout(t); };
1226 | 	}
1227 | 
1228 | 	return {
1229 | 		set: setTimer,
1230 | 		clear: clearTimer
1231 | 	};
1232 | 
1233 | });
1234 | }(typeof define === 'function' && define.amd ? define : function(factory) { module.exports = factory(require); }));
1235 | 
1236 | },{}]},{},[1])
1237 | (1)
1238 | });
1239 | ;


--------------------------------------------------------------------------------
/test/zepto.js:
--------------------------------------------------------------------------------
   1 | //     Zepto.js
   2 | //     (c) 2010-2014 Thomas Fuchs
   3 | //     Zepto.js may be freely distributed under the MIT license.
   4 | 
   5 | var Zepto = (function() {
   6 |   var undefined, key, $, classList, emptyArray = [], slice = emptyArray.slice, filter = emptyArray.filter,
   7 |     document = window.document,
   8 |     elementDisplay = {}, classCache = {},
   9 |     cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 },
  10 |     fragmentRE = /^\s*<(\w+|!)[^>]*>/,
  11 |     singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
  12 |     tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
  13 |     rootNodeRE = /^(?:body|html)$/i,
  14 |     capitalRE = /([A-Z])/g,
  15 | 
  16 |     // special attributes that should be get/set via method calls
  17 |     methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'],
  18 | 
  19 |     adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ],
  20 |     table = document.createElement('table'),
  21 |     tableRow = document.createElement('tr'),
  22 |     containers = {
  23 |       'tr': document.createElement('tbody'),
  24 |       'tbody': table, 'thead': table, 'tfoot': table,
  25 |       'td': tableRow, 'th': tableRow,
  26 |       '*': document.createElement('div')
  27 |     },
  28 |     readyRE = /complete|loaded|interactive/,
  29 |     simpleSelectorRE = /^[\w-]*$/,
  30 |     class2type = {},
  31 |     toString = class2type.toString,
  32 |     zepto = {},
  33 |     camelize, uniq,
  34 |     tempParent = document.createElement('div'),
  35 |     propMap = {
  36 |       'tabindex': 'tabIndex',
  37 |       'readonly': 'readOnly',
  38 |       'for': 'htmlFor',
  39 |       'class': 'className',
  40 |       'maxlength': 'maxLength',
  41 |       'cellspacing': 'cellSpacing',
  42 |       'cellpadding': 'cellPadding',
  43 |       'rowspan': 'rowSpan',
  44 |       'colspan': 'colSpan',
  45 |       'usemap': 'useMap',
  46 |       'frameborder': 'frameBorder',
  47 |       'contenteditable': 'contentEditable'
  48 |     },
  49 |     isArray = Array.isArray ||
  50 |       function(object){ return object instanceof Array }
  51 | 
  52 |   zepto.matches = function(element, selector) {
  53 |     if (!selector || !element || element.nodeType !== 1) return false
  54 |     var matchesSelector = element.webkitMatchesSelector || element.mozMatchesSelector ||
  55 |                           element.oMatchesSelector || element.matchesSelector
  56 |     if (matchesSelector) return matchesSelector.call(element, selector)
  57 |     // fall back to performing a selector:
  58 |     var match, parent = element.parentNode, temp = !parent
  59 |     if (temp) (parent = tempParent).appendChild(element)
  60 |     match = ~zepto.qsa(parent, selector).indexOf(element)
  61 |     temp && tempParent.removeChild(element)
  62 |     return match
  63 |   }
  64 | 
  65 |   function type(obj) {
  66 |     return obj == null ? String(obj) :
  67 |       class2type[toString.call(obj)] || "object"
  68 |   }
  69 | 
  70 |   function isFunction(value) { return type(value) == "function" }
  71 |   function isWindow(obj)     { return obj != null && obj == obj.window }
  72 |   function isDocument(obj)   { return obj != null && obj.nodeType == obj.DOCUMENT_NODE }
  73 |   function isObject(obj)     { return type(obj) == "object" }
  74 |   function isPlainObject(obj) {
  75 |     return isObject(obj) && !isWindow(obj) && Object.getPrototypeOf(obj) == Object.prototype
  76 |   }
  77 |   function likeArray(obj) { return typeof obj.length == 'number' }
  78 | 
  79 |   function compact(array) { return filter.call(array, function(item){ return item != null }) }
  80 |   function flatten(array) { return array.length > 0 ? $.fn.concat.apply([], array) : array }
  81 |   camelize = function(str){ return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) }
  82 |   function dasherize(str) {
  83 |     return str.replace(/::/g, '/')
  84 |            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
  85 |            .replace(/([a-z\d])([A-Z])/g, '$1_$2')
  86 |            .replace(/_/g, '-')
  87 |            .toLowerCase()
  88 |   }
  89 |   uniq = function(array){ return filter.call(array, function(item, idx){ return array.indexOf(item) == idx }) }
  90 | 
  91 |   function classRE(name) {
  92 |     return name in classCache ?
  93 |       classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)'))
  94 |   }
  95 | 
  96 |   function maybeAddPx(name, value) {
  97 |     return (typeof value == "number" && !cssNumber[dasherize(name)]) ? value + "px" : value
  98 |   }
  99 | 
 100 |   function defaultDisplay(nodeName) {
 101 |     var element, display
 102 |     if (!elementDisplay[nodeName]) {
 103 |       element = document.createElement(nodeName)
 104 |       document.body.appendChild(element)
 105 |       display = getComputedStyle(element, '').getPropertyValue("display")
 106 |       element.parentNode.removeChild(element)
 107 |       display == "none" && (display = "block")
 108 |       elementDisplay[nodeName] = display
 109 |     }
 110 |     return elementDisplay[nodeName]
 111 |   }
 112 | 
 113 |   function children(element) {
 114 |     return 'children' in element ?
 115 |       slice.call(element.children) :
 116 |       $.map(element.childNodes, function(node){ if (node.nodeType == 1) return node })
 117 |   }
 118 | 
 119 |   // `$.zepto.fragment` takes a html string and an optional tag name
 120 |   // to generate DOM nodes nodes from the given html string.
 121 |   // The generated DOM nodes are returned as an array.
 122 |   // This function can be overriden in plugins for example to make
 123 |   // it compatible with browsers that don't support the DOM fully.
 124 |   zepto.fragment = function(html, name, properties) {
 125 |     var dom, nodes, container
 126 | 
 127 |     // A special case optimization for a single tag
 128 |     if (singleTagRE.test(html)) dom = $(document.createElement(RegExp.$1))
 129 | 
 130 |     if (!dom) {
 131 |       if (html.replace) html = html.replace(tagExpanderRE, "<$1></$2>")
 132 |       if (name === undefined) name = fragmentRE.test(html) && RegExp.$1
 133 |       if (!(name in containers)) name = '*'
 134 | 
 135 |       container = containers[name]
 136 |       container.innerHTML = '' + html
 137 |       dom = $.each(slice.call(container.childNodes), function(){
 138 |         container.removeChild(this)
 139 |       })
 140 |     }
 141 | 
 142 |     if (isPlainObject(properties)) {
 143 |       nodes = $(dom)
 144 |       $.each(properties, function(key, value) {
 145 |         if (methodAttributes.indexOf(key) > -1) nodes[key](value)
 146 |         else nodes.attr(key, value)
 147 |       })
 148 |     }
 149 | 
 150 |     return dom
 151 |   }
 152 | 
 153 |   // `$.zepto.Z` swaps out the prototype of the given `dom` array
 154 |   // of nodes with `$.fn` and thus supplying all the Zepto functions
 155 |   // to the array. Note that `__proto__` is not supported on Internet
 156 |   // Explorer. This method can be overriden in plugins.
 157 |   zepto.Z = function(dom, selector) {
 158 |     dom = dom || []
 159 |     dom.__proto__ = $.fn
 160 |     dom.selector = selector || ''
 161 |     return dom
 162 |   }
 163 | 
 164 |   // `$.zepto.isZ` should return `true` if the given object is a Zepto
 165 |   // collection. This method can be overriden in plugins.
 166 |   zepto.isZ = function(object) {
 167 |     return object instanceof zepto.Z
 168 |   }
 169 | 
 170 |   // `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and
 171 |   // takes a CSS selector and an optional context (and handles various
 172 |   // special cases).
 173 |   // This method can be overriden in plugins.
 174 |   zepto.init = function(selector, context) {
 175 |     var dom
 176 |     // If nothing given, return an empty Zepto collection
 177 |     if (!selector) return zepto.Z()
 178 |     // Optimize for string selectors
 179 |     else if (typeof selector == 'string') {
 180 |       selector = selector.trim()
 181 |       // If it's a html fragment, create nodes from it
 182 |       // Note: In both Chrome 21 and Firefox 15, DOM error 12
 183 |       // is thrown if the fragment doesn't begin with <
 184 |       if (selector[0] == '<' && fragmentRE.test(selector))
 185 |         dom = zepto.fragment(selector, RegExp.$1, context), selector = null
 186 |       // If there's a context, create a collection on that context first, and select
 187 |       // nodes from there
 188 |       else if (context !== undefined) return $(context).find(selector)
 189 |       // If it's a CSS selector, use it to select nodes.
 190 |       else dom = zepto.qsa(document, selector)
 191 |     }
 192 |     // If a function is given, call it when the DOM is ready
 193 |     else if (isFunction(selector)) return $(document).ready(selector)
 194 |     // If a Zepto collection is given, just return it
 195 |     else if (zepto.isZ(selector)) return selector
 196 |     else {
 197 |       // normalize array if an array of nodes is given
 198 |       if (isArray(selector)) dom = compact(selector)
 199 |       // Wrap DOM nodes.
 200 |       else if (isObject(selector))
 201 |         dom = [selector], selector = null
 202 |       // If it's a html fragment, create nodes from it
 203 |       else if (fragmentRE.test(selector))
 204 |         dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null
 205 |       // If there's a context, create a collection on that context first, and select
 206 |       // nodes from there
 207 |       else if (context !== undefined) return $(context).find(selector)
 208 |       // And last but no least, if it's a CSS selector, use it to select nodes.
 209 |       else dom = zepto.qsa(document, selector)
 210 |     }
 211 |     // create a new Zepto collection from the nodes found
 212 |     return zepto.Z(dom, selector)
 213 |   }
 214 | 
 215 |   // `$` will be the base `Zepto` object. When calling this
 216 |   // function just call `$.zepto.init, which makes the implementation
 217 |   // details of selecting nodes and creating Zepto collections
 218 |   // patchable in plugins.
 219 |   $ = function(selector, context){
 220 |     return zepto.init(selector, context)
 221 |   }
 222 | 
 223 |   function extend(target, source, deep) {
 224 |     for (key in source)
 225 |       if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {
 226 |         if (isPlainObject(source[key]) && !isPlainObject(target[key]))
 227 |           target[key] = {}
 228 |         if (isArray(source[key]) && !isArray(target[key]))
 229 |           target[key] = []
 230 |         extend(target[key], source[key], deep)
 231 |       }
 232 |       else if (source[key] !== undefined) target[key] = source[key]
 233 |   }
 234 | 
 235 |   // Copy all but undefined properties from one or more
 236 |   // objects to the `target` object.
 237 |   $.extend = function(target){
 238 |     var deep, args = slice.call(arguments, 1)
 239 |     if (typeof target == 'boolean') {
 240 |       deep = target
 241 |       target = args.shift()
 242 |     }
 243 |     args.forEach(function(arg){ extend(target, arg, deep) })
 244 |     return target
 245 |   }
 246 | 
 247 |   // `$.zepto.qsa` is Zepto's CSS selector implementation which
 248 |   // uses `document.querySelectorAll` and optimizes for some special cases, like `#id`.
 249 |   // This method can be overriden in plugins.
 250 |   zepto.qsa = function(element, selector){
 251 |     var found,
 252 |         maybeID = selector[0] == '#',
 253 |         maybeClass = !maybeID && selector[0] == '.',
 254 |         nameOnly = maybeID || maybeClass ? selector.slice(1) : selector, // Ensure that a 1 char tag name still gets checked
 255 |         isSimple = simpleSelectorRE.test(nameOnly)
 256 |     return (isDocument(element) && isSimple && maybeID) ?
 257 |       ( (found = element.getElementById(nameOnly)) ? [found] : [] ) :
 258 |       (element.nodeType !== 1 && element.nodeType !== 9) ? [] :
 259 |       slice.call(
 260 |         isSimple && !maybeID ?
 261 |           maybeClass ? element.getElementsByClassName(nameOnly) : // If it's simple, it could be a class
 262 |           element.getElementsByTagName(selector) : // Or a tag
 263 |           element.querySelectorAll(selector) // Or it's not simple, and we need to query all
 264 |       )
 265 |   }
 266 | 
 267 |   function filtered(nodes, selector) {
 268 |     return selector == null ? $(nodes) : $(nodes).filter(selector)
 269 |   }
 270 | 
 271 |   $.contains = document.documentElement.contains ?
 272 |     function(parent, node) {
 273 |       return parent !== node && parent.contains(node)
 274 |     } :
 275 |     function(parent, node) {
 276 |       while (node && (node = node.parentNode))
 277 |         if (node === parent) return true
 278 |       return false
 279 |     }
 280 | 
 281 |   function funcArg(context, arg, idx, payload) {
 282 |     return isFunction(arg) ? arg.call(context, idx, payload) : arg
 283 |   }
 284 | 
 285 |   function setAttribute(node, name, value) {
 286 |     value == null ? node.removeAttribute(name) : node.setAttribute(name, value)
 287 |   }
 288 | 
 289 |   // access className property while respecting SVGAnimatedString
 290 |   function className(node, value){
 291 |     var klass = node.className,
 292 |         svg   = klass && klass.baseVal !== undefined
 293 | 
 294 |     if (value === undefined) return svg ? klass.baseVal : klass
 295 |     svg ? (klass.baseVal = value) : (node.className = value)
 296 |   }
 297 | 
 298 |   // "true"  => true
 299 |   // "false" => false
 300 |   // "null"  => null
 301 |   // "42"    => 42
 302 |   // "42.5"  => 42.5
 303 |   // "08"    => "08"
 304 |   // JSON    => parse if valid
 305 |   // String  => self
 306 |   function deserializeValue(value) {
 307 |     var num
 308 |     try {
 309 |       return value ?
 310 |         value == "true" ||
 311 |         ( value == "false" ? false :
 312 |           value == "null" ? null :
 313 |           !/^0/.test(value) && !isNaN(num = Number(value)) ? num :
 314 |           /^[\[\{]/.test(value) ? $.parseJSON(value) :
 315 |           value )
 316 |         : value
 317 |     } catch(e) {
 318 |       return value
 319 |     }
 320 |   }
 321 | 
 322 |   $.type = type
 323 |   $.isFunction = isFunction
 324 |   $.isWindow = isWindow
 325 |   $.isArray = isArray
 326 |   $.isPlainObject = isPlainObject
 327 | 
 328 |   $.isEmptyObject = function(obj) {
 329 |     var name
 330 |     for (name in obj) return false
 331 |     return true
 332 |   }
 333 | 
 334 |   $.inArray = function(elem, array, i){
 335 |     return emptyArray.indexOf.call(array, elem, i)
 336 |   }
 337 | 
 338 |   $.camelCase = camelize
 339 |   $.trim = function(str) {
 340 |     return str == null ? "" : String.prototype.trim.call(str)
 341 |   }
 342 | 
 343 |   // plugin compatibility
 344 |   $.uuid = 0
 345 |   $.support = { }
 346 |   $.expr = { }
 347 | 
 348 |   $.map = function(elements, callback){
 349 |     var value, values = [], i, key
 350 |     if (likeArray(elements))
 351 |       for (i = 0; i < elements.length; i++) {
 352 |         value = callback(elements[i], i)
 353 |         if (value != null) values.push(value)
 354 |       }
 355 |     else
 356 |       for (key in elements) {
 357 |         value = callback(elements[key], key)
 358 |         if (value != null) values.push(value)
 359 |       }
 360 |     return flatten(values)
 361 |   }
 362 | 
 363 |   $.each = function(elements, callback){
 364 |     var i, key
 365 |     if (likeArray(elements)) {
 366 |       for (i = 0; i < elements.length; i++)
 367 |         if (callback.call(elements[i], i, elements[i]) === false) return elements
 368 |     } else {
 369 |       for (key in elements)
 370 |         if (callback.call(elements[key], key, elements[key]) === false) return elements
 371 |     }
 372 | 
 373 |     return elements
 374 |   }
 375 | 
 376 |   $.grep = function(elements, callback){
 377 |     return filter.call(elements, callback)
 378 |   }
 379 | 
 380 |   if (window.JSON) $.parseJSON = JSON.parse
 381 | 
 382 |   // Populate the class2type map
 383 |   $.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
 384 |     class2type[ "[object " + name + "]" ] = name.toLowerCase()
 385 |   })
 386 | 
 387 |   // Define methods that will be available on all
 388 |   // Zepto collections
 389 |   $.fn = {
 390 |     // Because a collection acts like an array
 391 |     // copy over these useful array functions.
 392 |     forEach: emptyArray.forEach,
 393 |     reduce: emptyArray.reduce,
 394 |     push: emptyArray.push,
 395 |     sort: emptyArray.sort,
 396 |     indexOf: emptyArray.indexOf,
 397 |     concat: emptyArray.concat,
 398 | 
 399 |     // `map` and `slice` in the jQuery API work differently
 400 |     // from their array counterparts
 401 |     map: function(fn){
 402 |       return $($.map(this, function(el, i){ return fn.call(el, i, el) }))
 403 |     },
 404 |     slice: function(){
 405 |       return $(slice.apply(this, arguments))
 406 |     },
 407 | 
 408 |     ready: function(callback){
 409 |       // need to check if document.body exists for IE as that browser reports
 410 |       // document ready when it hasn't yet created the body element
 411 |       if (readyRE.test(document.readyState) && document.body) callback($)
 412 |       else document.addEventListener('DOMContentLoaded', function(){ callback($) }, false)
 413 |       return this
 414 |     },
 415 |     get: function(idx){
 416 |       return idx === undefined ? slice.call(this) : this[idx >= 0 ? idx : idx + this.length]
 417 |     },
 418 |     toArray: function(){ return this.get() },
 419 |     size: function(){
 420 |       return this.length
 421 |     },
 422 |     remove: function(){
 423 |       return this.each(function(){
 424 |         if (this.parentNode != null)
 425 |           this.parentNode.removeChild(this)
 426 |       })
 427 |     },
 428 |     each: function(callback){
 429 |       emptyArray.every.call(this, function(el, idx){
 430 |         return callback.call(el, idx, el) !== false
 431 |       })
 432 |       return this
 433 |     },
 434 |     filter: function(selector){
 435 |       if (isFunction(selector)) return this.not(this.not(selector))
 436 |       return $(filter.call(this, function(element){
 437 |         return zepto.matches(element, selector)
 438 |       }))
 439 |     },
 440 |     add: function(selector,context){
 441 |       return $(uniq(this.concat($(selector,context))))
 442 |     },
 443 |     is: function(selector){
 444 |       return this.length > 0 && zepto.matches(this[0], selector)
 445 |     },
 446 |     not: function(selector){
 447 |       var nodes=[]
 448 |       if (isFunction(selector) && selector.call !== undefined)
 449 |         this.each(function(idx){
 450 |           if (!selector.call(this,idx)) nodes.push(this)
 451 |         })
 452 |       else {
 453 |         var excludes = typeof selector == 'string' ? this.filter(selector) :
 454 |           (likeArray(selector) && isFunction(selector.item)) ? slice.call(selector) : $(selector)
 455 |         this.forEach(function(el){
 456 |           if (excludes.indexOf(el) < 0) nodes.push(el)
 457 |         })
 458 |       }
 459 |       return $(nodes)
 460 |     },
 461 |     has: function(selector){
 462 |       return this.filter(function(){
 463 |         return isObject(selector) ?
 464 |           $.contains(this, selector) :
 465 |           $(this).find(selector).size()
 466 |       })
 467 |     },
 468 |     eq: function(idx){
 469 |       return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1)
 470 |     },
 471 |     first: function(){
 472 |       var el = this[0]
 473 |       return el && !isObject(el) ? el : $(el)
 474 |     },
 475 |     last: function(){
 476 |       var el = this[this.length - 1]
 477 |       return el && !isObject(el) ? el : $(el)
 478 |     },
 479 |     find: function(selector){
 480 |       var result, $this = this
 481 |       if (!selector) result = []
 482 |       else if (typeof selector == 'object')
 483 |         result = $(selector).filter(function(){
 484 |           var node = this
 485 |           return emptyArray.some.call($this, function(parent){
 486 |             return $.contains(parent, node)
 487 |           })
 488 |         })
 489 |       else if (this.length == 1) result = $(zepto.qsa(this[0], selector))
 490 |       else result = this.map(function(){ return zepto.qsa(this, selector) })
 491 |       return result
 492 |     },
 493 |     closest: function(selector, context){
 494 |       var node = this[0], collection = false
 495 |       if (typeof selector == 'object') collection = $(selector)
 496 |       while (node && !(collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector)))
 497 |         node = node !== context && !isDocument(node) && node.parentNode
 498 |       return $(node)
 499 |     },
 500 |     parents: function(selector){
 501 |       var ancestors = [], nodes = this
 502 |       while (nodes.length > 0)
 503 |         nodes = $.map(nodes, function(node){
 504 |           if ((node = node.parentNode) && !isDocument(node) && ancestors.indexOf(node) < 0) {
 505 |             ancestors.push(node)
 506 |             return node
 507 |           }
 508 |         })
 509 |       return filtered(ancestors, selector)
 510 |     },
 511 |     parent: function(selector){
 512 |       return filtered(uniq(this.pluck('parentNode')), selector)
 513 |     },
 514 |     children: function(selector){
 515 |       return filtered(this.map(function(){ return children(this) }), selector)
 516 |     },
 517 |     contents: function() {
 518 |       return this.map(function() { return slice.call(this.childNodes) })
 519 |     },
 520 |     siblings: function(selector){
 521 |       return filtered(this.map(function(i, el){
 522 |         return filter.call(children(el.parentNode), function(child){ return child!==el })
 523 |       }), selector)
 524 |     },
 525 |     empty: function(){
 526 |       return this.each(function(){ this.innerHTML = '' })
 527 |     },
 528 |     // `pluck` is borrowed from Prototype.js
 529 |     pluck: function(property){
 530 |       return $.map(this, function(el){ return el[property] })
 531 |     },
 532 |     show: function(){
 533 |       return this.each(function(){
 534 |         this.style.display == "none" && (this.style.display = '')
 535 |         if (getComputedStyle(this, '').getPropertyValue("display") == "none")
 536 |           this.style.display = defaultDisplay(this.nodeName)
 537 |       })
 538 |     },
 539 |     replaceWith: function(newContent){
 540 |       return this.before(newContent).remove()
 541 |     },
 542 |     wrap: function(structure){
 543 |       var func = isFunction(structure)
 544 |       if (this[0] && !func)
 545 |         var dom   = $(structure).get(0),
 546 |             clone = dom.parentNode || this.length > 1
 547 | 
 548 |       return this.each(function(index){
 549 |         $(this).wrapAll(
 550 |           func ? structure.call(this, index) :
 551 |             clone ? dom.cloneNode(true) : dom
 552 |         )
 553 |       })
 554 |     },
 555 |     wrapAll: function(structure){
 556 |       if (this[0]) {
 557 |         $(this[0]).before(structure = $(structure))
 558 |         var children
 559 |         // drill down to the inmost element
 560 |         while ((children = structure.children()).length) structure = children.first()
 561 |         $(structure).append(this)
 562 |       }
 563 |       return this
 564 |     },
 565 |     wrapInner: function(structure){
 566 |       var func = isFunction(structure)
 567 |       return this.each(function(index){
 568 |         var self = $(this), contents = self.contents(),
 569 |             dom  = func ? structure.call(this, index) : structure
 570 |         contents.length ? contents.wrapAll(dom) : self.append(dom)
 571 |       })
 572 |     },
 573 |     unwrap: function(){
 574 |       this.parent().each(function(){
 575 |         $(this).replaceWith($(this).children())
 576 |       })
 577 |       return this
 578 |     },
 579 |     clone: function(){
 580 |       return this.map(function(){ return this.cloneNode(true) })
 581 |     },
 582 |     hide: function(){
 583 |       return this.css("display", "none")
 584 |     },
 585 |     toggle: function(setting){
 586 |       return this.each(function(){
 587 |         var el = $(this)
 588 |         ;(setting === undefined ? el.css("display") == "none" : setting) ? el.show() : el.hide()
 589 |       })
 590 |     },
 591 |     prev: function(selector){ return $(this.pluck('previousElementSibling')).filter(selector || '*') },
 592 |     next: function(selector){ return $(this.pluck('nextElementSibling')).filter(selector || '*') },
 593 |     html: function(html){
 594 |       return 0 in arguments ?
 595 |         this.each(function(idx){
 596 |           var originHtml = this.innerHTML
 597 |           $(this).empty().append( funcArg(this, html, idx, originHtml) )
 598 |         }) :
 599 |         (0 in this ? this[0].innerHTML : null)
 600 |     },
 601 |     text: function(text){
 602 |       return 0 in arguments ?
 603 |         this.each(function(idx){
 604 |           var newText = funcArg(this, text, idx, this.textContent)
 605 |           this.textContent = newText == null ? '' : ''+newText
 606 |         }) :
 607 |         (0 in this ? this[0].textContent : null)
 608 |     },
 609 |     attr: function(name, value){
 610 |       var result
 611 |       return (typeof name == 'string' && !(1 in arguments)) ?
 612 |         (!this.length || this[0].nodeType !== 1 ? undefined :
 613 |           (!(result = this[0].getAttribute(name)) && name in this[0]) ? this[0][name] : result
 614 |         ) :
 615 |         this.each(function(idx){
 616 |           if (this.nodeType !== 1) return
 617 |           if (isObject(name)) for (key in name) setAttribute(this, key, name[key])
 618 |           else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name)))
 619 |         })
 620 |     },
 621 |     removeAttr: function(name){
 622 |       return this.each(function(){ this.nodeType === 1 && setAttribute(this, name) })
 623 |     },
 624 |     prop: function(name, value){
 625 |       name = propMap[name] || name
 626 |       return (1 in arguments) ?
 627 |         this.each(function(idx){
 628 |           this[name] = funcArg(this, value, idx, this[name])
 629 |         }) :
 630 |         (this[0] && this[0][name])
 631 |     },
 632 |     data: function(name, value){
 633 |       var attrName = 'data-' + name.replace(capitalRE, '-$1').toLowerCase()
 634 | 
 635 |       var data = (1 in arguments) ?
 636 |         this.attr(attrName, value) :
 637 |         this.attr(attrName)
 638 | 
 639 |       return data !== null ? deserializeValue(data) : undefined
 640 |     },
 641 |     val: function(value){
 642 |       return 0 in arguments ?
 643 |         this.each(function(idx){
 644 |           this.value = funcArg(this, value, idx, this.value)
 645 |         }) :
 646 |         (this[0] && (this[0].multiple ?
 647 |            $(this[0]).find('option').filter(function(){ return this.selected }).pluck('value') :
 648 |            this[0].value)
 649 |         )
 650 |     },
 651 |     offset: function(coordinates){
 652 |       if (coordinates) return this.each(function(index){
 653 |         var $this = $(this),
 654 |             coords = funcArg(this, coordinates, index, $this.offset()),
 655 |             parentOffset = $this.offsetParent().offset(),
 656 |             props = {
 657 |               top:  coords.top  - parentOffset.top,
 658 |               left: coords.left - parentOffset.left
 659 |             }
 660 | 
 661 |         if ($this.css('position') == 'static') props['position'] = 'relative'
 662 |         $this.css(props)
 663 |       })
 664 |       if (!this.length) return null
 665 |       var obj = this[0].getBoundingClientRect()
 666 |       return {
 667 |         left: obj.left + window.pageXOffset,
 668 |         top: obj.top + window.pageYOffset,
 669 |         width: Math.round(obj.width),
 670 |         height: Math.round(obj.height)
 671 |       }
 672 |     },
 673 |     css: function(property, value){
 674 |       if (arguments.length < 2) {
 675 |         var element = this[0], computedStyle = getComputedStyle(element, '')
 676 |         if(!element) return
 677 |         if (typeof property == 'string')
 678 |           return element.style[camelize(property)] || computedStyle.getPropertyValue(property)
 679 |         else if (isArray(property)) {
 680 |           var props = {}
 681 |           $.each(isArray(property) ? property: [property], function(_, prop){
 682 |             props[prop] = (element.style[camelize(prop)] || computedStyle.getPropertyValue(prop))
 683 |           })
 684 |           return props
 685 |         }
 686 |       }
 687 | 
 688 |       var css = ''
 689 |       if (type(property) == 'string') {
 690 |         if (!value && value !== 0)
 691 |           this.each(function(){ this.style.removeProperty(dasherize(property)) })
 692 |         else
 693 |           css = dasherize(property) + ":" + maybeAddPx(property, value)
 694 |       } else {
 695 |         for (key in property)
 696 |           if (!property[key] && property[key] !== 0)
 697 |             this.each(function(){ this.style.removeProperty(dasherize(key)) })
 698 |           else
 699 |             css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';'
 700 |       }
 701 | 
 702 |       return this.each(function(){ this.style.cssText += ';' + css })
 703 |     },
 704 |     index: function(element){
 705 |       return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0])
 706 |     },
 707 |     hasClass: function(name){
 708 |       if (!name) return false
 709 |       return emptyArray.some.call(this, function(el){
 710 |         return this.test(className(el))
 711 |       }, classRE(name))
 712 |     },
 713 |     addClass: function(name){
 714 |       if (!name) return this
 715 |       return this.each(function(idx){
 716 |         classList = []
 717 |         var cls = className(this), newName = funcArg(this, name, idx, cls)
 718 |         newName.split(/\s+/g).forEach(function(klass){
 719 |           if (!$(this).hasClass(klass)) classList.push(klass)
 720 |         }, this)
 721 |         classList.length && className(this, cls + (cls ? " " : "") + classList.join(" "))
 722 |       })
 723 |     },
 724 |     removeClass: function(name){
 725 |       return this.each(function(idx){
 726 |         if (name === undefined) return className(this, '')
 727 |         classList = className(this)
 728 |         funcArg(this, name, idx, classList).split(/\s+/g).forEach(function(klass){
 729 |           classList = classList.replace(classRE(klass), " ")
 730 |         })
 731 |         className(this, classList.trim())
 732 |       })
 733 |     },
 734 |     toggleClass: function(name, when){
 735 |       if (!name) return this
 736 |       return this.each(function(idx){
 737 |         var $this = $(this), names = funcArg(this, name, idx, className(this))
 738 |         names.split(/\s+/g).forEach(function(klass){
 739 |           (when === undefined ? !$this.hasClass(klass) : when) ?
 740 |             $this.addClass(klass) : $this.removeClass(klass)
 741 |         })
 742 |       })
 743 |     },
 744 |     scrollTop: function(value){
 745 |       if (!this.length) return
 746 |       var hasScrollTop = 'scrollTop' in this[0]
 747 |       if (value === undefined) return hasScrollTop ? this[0].scrollTop : this[0].pageYOffset
 748 |       return this.each(hasScrollTop ?
 749 |         function(){ this.scrollTop = value } :
 750 |         function(){ this.scrollTo(this.scrollX, value) })
 751 |     },
 752 |     scrollLeft: function(value){
 753 |       if (!this.length) return
 754 |       var hasScrollLeft = 'scrollLeft' in this[0]
 755 |       if (value === undefined) return hasScrollLeft ? this[0].scrollLeft : this[0].pageXOffset
 756 |       return this.each(hasScrollLeft ?
 757 |         function(){ this.scrollLeft = value } :
 758 |         function(){ this.scrollTo(value, this.scrollY) })
 759 |     },
 760 |     position: function() {
 761 |       if (!this.length) return
 762 | 
 763 |       var elem = this[0],
 764 |         // Get *real* offsetParent
 765 |         offsetParent = this.offsetParent(),
 766 |         // Get correct offsets
 767 |         offset       = this.offset(),
 768 |         parentOffset = rootNodeRE.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset()
 769 | 
 770 |       // Subtract element margins
 771 |       // note: when an element has margin: auto the offsetLeft and marginLeft
 772 |       // are the same in Safari causing offset.left to incorrectly be 0
 773 |       offset.top  -= parseFloat( $(elem).css('margin-top') ) || 0
 774 |       offset.left -= parseFloat( $(elem).css('margin-left') ) || 0
 775 | 
 776 |       // Add offsetParent borders
 777 |       parentOffset.top  += parseFloat( $(offsetParent[0]).css('border-top-width') ) || 0
 778 |       parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0
 779 | 
 780 |       // Subtract the two offsets
 781 |       return {
 782 |         top:  offset.top  - parentOffset.top,
 783 |         left: offset.left - parentOffset.left
 784 |       }
 785 |     },
 786 |     offsetParent: function() {
 787 |       return this.map(function(){
 788 |         var parent = this.offsetParent || document.body
 789 |         while (parent && !rootNodeRE.test(parent.nodeName) && $(parent).css("position") == "static")
 790 |           parent = parent.offsetParent
 791 |         return parent
 792 |       })
 793 |     }
 794 |   }
 795 | 
 796 |   // for now
 797 |   $.fn.detach = $.fn.remove
 798 | 
 799 |   // Generate the `width` and `height` functions
 800 |   ;['width', 'height'].forEach(function(dimension){
 801 |     var dimensionProperty =
 802 |       dimension.replace(/./, function(m){ return m[0].toUpperCase() })
 803 | 
 804 |     $.fn[dimension] = function(value){
 805 |       var offset, el = this[0]
 806 |       if (value === undefined) return isWindow(el) ? el['inner' + dimensionProperty] :
 807 |         isDocument(el) ? el.documentElement['scroll' + dimensionProperty] :
 808 |         (offset = this.offset()) && offset[dimension]
 809 |       else return this.each(function(idx){
 810 |         el = $(this)
 811 |         el.css(dimension, funcArg(this, value, idx, el[dimension]()))
 812 |       })
 813 |     }
 814 |   })
 815 | 
 816 |   function traverseNode(node, fun) {
 817 |     fun(node)
 818 |     for (var i = 0, len = node.childNodes.length; i < len; i++)
 819 |       traverseNode(node.childNodes[i], fun)
 820 |   }
 821 | 
 822 |   // Generate the `after`, `prepend`, `before`, `append`,
 823 |   // `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods.
 824 |   adjacencyOperators.forEach(function(operator, operatorIndex) {
 825 |     var inside = operatorIndex % 2 //=> prepend, append
 826 | 
 827 |     $.fn[operator] = function(){
 828 |       // arguments can be nodes, arrays of nodes, Zepto objects and HTML strings
 829 |       var argType, nodes = $.map(arguments, function(arg) {
 830 |             argType = type(arg)
 831 |             return argType == "object" || argType == "array" || arg == null ?
 832 |               arg : zepto.fragment(arg)
 833 |           }),
 834 |           parent, copyByClone = this.length > 1
 835 |       if (nodes.length < 1) return this
 836 | 
 837 |       return this.each(function(_, target){
 838 |         parent = inside ? target : target.parentNode
 839 | 
 840 |         // convert all methods to a "before" operation
 841 |         target = operatorIndex == 0 ? target.nextSibling :
 842 |                  operatorIndex == 1 ? target.firstChild :
 843 |                  operatorIndex == 2 ? target :
 844 |                  null
 845 | 
 846 |         var parentInDocument = $.contains(document.documentElement, parent)
 847 | 
 848 |         nodes.forEach(function(node){
 849 |           if (copyByClone) node = node.cloneNode(true)
 850 |           else if (!parent) return $(node).remove()
 851 | 
 852 |           parent.insertBefore(node, target)
 853 |           if (parentInDocument) traverseNode(node, function(el){
 854 |             if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&
 855 |                (!el.type || el.type === 'text/javascript') && !el.src)
 856 |               window['eval'].call(window, el.innerHTML)
 857 |           })
 858 |         })
 859 |       })
 860 |     }
 861 | 
 862 |     // after    => insertAfter
 863 |     // prepend  => prependTo
 864 |     // before   => insertBefore
 865 |     // append   => appendTo
 866 |     $.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){
 867 |       $(html)[operator](this)
 868 |       return this
 869 |     }
 870 |   })
 871 | 
 872 |   zepto.Z.prototype = $.fn
 873 | 
 874 |   // Export internal API functions in the `$.zepto` namespace
 875 |   zepto.uniq = uniq
 876 |   zepto.deserializeValue = deserializeValue
 877 |   $.zepto = zepto
 878 | 
 879 |   return $
 880 | })()
 881 | 
 882 | // If `$` is not yet defined, point it to `Zepto`
 883 | window.Zepto = Zepto
 884 | window.$ === undefined && (window.$ = Zepto)
 885 | 
 886 | //     Zepto.js
 887 | //     (c) 2010-2014 Thomas Fuchs
 888 | //     Zepto.js may be freely distributed under the MIT license.
 889 | 
 890 | ;(function($){
 891 |   var jsonpID = 0,
 892 |       document = window.document,
 893 |       key,
 894 |       name,
 895 |       rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
 896 |       scriptTypeRE = /^(?:text|application)\/javascript/i,
 897 |       xmlTypeRE = /^(?:text|application)\/xml/i,
 898 |       jsonType = 'application/json',
 899 |       htmlType = 'text/html',
 900 |       blankRE = /^\s*$/
 901 | 
 902 |   // trigger a custom event and return false if it was cancelled
 903 |   function triggerAndReturn(context, eventName, data) {
 904 |     var event = $.Event(eventName)
 905 |     $(context).trigger(event, data)
 906 |     return !event.isDefaultPrevented()
 907 |   }
 908 | 
 909 |   // trigger an Ajax "global" event
 910 |   function triggerGlobal(settings, context, eventName, data) {
 911 |     if (settings.global) return triggerAndReturn(context || document, eventName, data)
 912 |   }
 913 | 
 914 |   // Number of active Ajax requests
 915 |   $.active = 0
 916 | 
 917 |   function ajaxStart(settings) {
 918 |     if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
 919 |   }
 920 |   function ajaxStop(settings) {
 921 |     if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
 922 |   }
 923 | 
 924 |   // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
 925 |   function ajaxBeforeSend(xhr, settings) {
 926 |     var context = settings.context
 927 |     if (settings.beforeSend.call(context, xhr, settings) === false ||
 928 |         triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
 929 |       return false
 930 | 
 931 |     triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
 932 |   }
 933 |   function ajaxSuccess(data, xhr, settings, deferred) {
 934 |     var context = settings.context, status = 'success'
 935 |     settings.success.call(context, data, status, xhr)
 936 |     if (deferred) deferred.resolveWith(context, [data, status, xhr])
 937 |     triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
 938 |     ajaxComplete(status, xhr, settings)
 939 |   }
 940 |   // type: "timeout", "error", "abort", "parsererror"
 941 |   function ajaxError(error, type, xhr, settings, deferred) {
 942 |     var context = settings.context
 943 |     settings.error.call(context, xhr, type, error)
 944 |     if (deferred) deferred.rejectWith(context, [xhr, type, error])
 945 |     triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
 946 |     ajaxComplete(type, xhr, settings)
 947 |   }
 948 |   // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
 949 |   function ajaxComplete(status, xhr, settings) {
 950 |     var context = settings.context
 951 |     settings.complete.call(context, xhr, status)
 952 |     triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
 953 |     ajaxStop(settings)
 954 |   }
 955 | 
 956 |   // Empty function, used as default callback
 957 |   function empty() {}
 958 | 
 959 |   $.ajaxJSONP = function(options, deferred){
 960 |     if (!('type' in options)) return $.ajax(options)
 961 | 
 962 |     var _callbackName = options.jsonpCallback,
 963 |       callbackName = ($.isFunction(_callbackName) ?
 964 |         _callbackName() : _callbackName) || ('jsonp' + (++jsonpID)),
 965 |       script = document.createElement('script'),
 966 |       originalCallback = window[callbackName],
 967 |       responseData,
 968 |       abort = function(errorType) {
 969 |         $(script).triggerHandler('error', errorType || 'abort')
 970 |       },
 971 |       xhr = { abort: abort }, abortTimeout
 972 | 
 973 |     if (deferred) deferred.promise(xhr)
 974 | 
 975 |     $(script).on('load error', function(e, errorType){
 976 |       clearTimeout(abortTimeout)
 977 |       $(script).off().remove()
 978 | 
 979 |       if (e.type == 'error' || !responseData) {
 980 |         ajaxError(null, errorType || 'error', xhr, options, deferred)
 981 |       } else {
 982 |         ajaxSuccess(responseData[0], xhr, options, deferred)
 983 |       }
 984 | 
 985 |       window[callbackName] = originalCallback
 986 |       if (responseData && $.isFunction(originalCallback))
 987 |         originalCallback(responseData[0])
 988 | 
 989 |       originalCallback = responseData = undefined
 990 |     })
 991 | 
 992 |     if (ajaxBeforeSend(xhr, options) === false) {
 993 |       abort('abort')
 994 |       return xhr
 995 |     }
 996 | 
 997 |     window[callbackName] = function(){
 998 |       responseData = arguments
 999 |     }
1000 | 
1001 |     script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
1002 |     document.head.appendChild(script)
1003 | 
1004 |     if (options.timeout > 0) abortTimeout = setTimeout(function(){
1005 |       abort('timeout')
1006 |     }, options.timeout)
1007 | 
1008 |     return xhr
1009 |   }
1010 | 
1011 |   $.ajaxSettings = {
1012 |     // Default type of request
1013 |     type: 'GET',
1014 |     // Callback that is executed before request
1015 |     beforeSend: empty,
1016 |     // Callback that is executed if the request succeeds
1017 |     success: empty,
1018 |     // Callback that is executed the the server drops error
1019 |     error: empty,
1020 |     // Callback that is executed on request complete (both: error and success)
1021 |     complete: empty,
1022 |     // The context for the callbacks
1023 |     context: null,
1024 |     // Whether to trigger "global" Ajax events
1025 |     global: true,
1026 |     // Transport
1027 |     xhr: function () {
1028 |       return new window.XMLHttpRequest()
1029 |     },
1030 |     // MIME types mapping
1031 |     // IIS returns Javascript as "application/x-javascript"
1032 |     accepts: {
1033 |       script: 'text/javascript, application/javascript, application/x-javascript',
1034 |       json:   jsonType,
1035 |       xml:    'application/xml, text/xml',
1036 |       html:   htmlType,
1037 |       text:   'text/plain'
1038 |     },
1039 |     // Whether the request is to another domain
1040 |     crossDomain: false,
1041 |     // Default timeout
1042 |     timeout: 0,
1043 |     // Whether data should be serialized to string
1044 |     processData: true,
1045 |     // Whether the browser should be allowed to cache GET responses
1046 |     cache: true
1047 |   }
1048 | 
1049 |   function mimeToDataType(mime) {
1050 |     if (mime) mime = mime.split(';', 2)[0]
1051 |     return mime && ( mime == htmlType ? 'html' :
1052 |       mime == jsonType ? 'json' :
1053 |       scriptTypeRE.test(mime) ? 'script' :
1054 |       xmlTypeRE.test(mime) && 'xml' ) || 'text'
1055 |   }
1056 | 
1057 |   function appendQuery(url, query) {
1058 |     if (query == '') return url
1059 |     return (url + '&' + query).replace(/[&?]{1,2}/, '?')
1060 |   }
1061 | 
1062 |   // serialize payload and append it to the URL for GET requests
1063 |   function serializeData(options) {
1064 |     if (options.processData && options.data && $.type(options.data) != "string")
1065 |       options.data = $.param(options.data, options.traditional)
1066 |     if (options.data && (!options.type || options.type.toUpperCase() == 'GET'))
1067 |       options.url = appendQuery(options.url, options.data), options.data = undefined
1068 |   }
1069 | 
1070 |   $.ajax = function(options){
1071 |     var settings = $.extend({}, options || {}),
1072 |         deferred = $.Deferred && $.Deferred()
1073 |     for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]
1074 | 
1075 |     ajaxStart(settings)
1076 | 
1077 |     if (!settings.crossDomain) settings.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(settings.url) &&
1078 |       RegExp.$2 != window.location.host
1079 | 
1080 |     if (!settings.url) settings.url = window.location.toString()
1081 |     serializeData(settings)
1082 | 
1083 |     var dataType = settings.dataType, hasPlaceholder = /\?.+=\?/.test(settings.url)
1084 |     if (hasPlaceholder) dataType = 'jsonp'
1085 | 
1086 |     if (settings.cache === false || (
1087 |          (!options || options.cache !== true) &&
1088 |          ('script' == dataType || 'jsonp' == dataType)
1089 |         ))
1090 |       settings.url = appendQuery(settings.url, '_=' + Date.now())
1091 | 
1092 |     if ('jsonp' == dataType) {
1093 |       if (!hasPlaceholder)
1094 |         settings.url = appendQuery(settings.url,
1095 |           settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
1096 |       return $.ajaxJSONP(settings, deferred)
1097 |     }
1098 | 
1099 |     var mime = settings.accepts[dataType],
1100 |         headers = { },
1101 |         setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
1102 |         protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
1103 |         xhr = settings.xhr(),
1104 |         nativeSetHeader = xhr.setRequestHeader,
1105 |         abortTimeout
1106 | 
1107 |     if (deferred) deferred.promise(xhr)
1108 | 
1109 |     if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
1110 |     setHeader('Accept', mime || '*/*')
1111 |     if (mime = settings.mimeType || mime) {
1112 |       if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
1113 |       xhr.overrideMimeType && xhr.overrideMimeType(mime)
1114 |     }
1115 |     if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
1116 |       setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')
1117 | 
1118 |     if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
1119 |     xhr.setRequestHeader = setHeader
1120 | 
1121 |     xhr.onreadystatechange = function(){
1122 |       if (xhr.readyState == 4) {
1123 |         xhr.onreadystatechange = empty
1124 |         clearTimeout(abortTimeout)
1125 |         var result, error = false
1126 |         if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
1127 |           dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))
1128 |           result = xhr.responseText
1129 | 
1130 |           try {
1131 |             // http://perfectionkills.com/global-eval-what-are-the-options/
1132 |             if (dataType == 'script')    (1,eval)(result)
1133 |             else if (dataType == 'xml')  result = xhr.responseXML
1134 |             else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
1135 |           } catch (e) { error = e }
1136 | 
1137 |           if (error) ajaxError(error, 'parsererror', xhr, settings, deferred)
1138 |           else ajaxSuccess(result, xhr, settings, deferred)
1139 |         } else {
1140 |           ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
1141 |         }
1142 |       }
1143 |     }
1144 | 
1145 |     if (ajaxBeforeSend(xhr, settings) === false) {
1146 |       xhr.abort()
1147 |       ajaxError(null, 'abort', xhr, settings, deferred)
1148 |       return xhr
1149 |     }
1150 | 
1151 |     if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]
1152 | 
1153 |     var async = 'async' in settings ? settings.async : true
1154 |     xhr.open(settings.type, settings.url, async, settings.username, settings.password)
1155 | 
1156 |     for (name in headers) nativeSetHeader.apply(xhr, headers[name])
1157 | 
1158 |     if (settings.timeout > 0) abortTimeout = setTimeout(function(){
1159 |         xhr.onreadystatechange = empty
1160 |         xhr.abort()
1161 |         ajaxError(null, 'timeout', xhr, settings, deferred)
1162 |       }, settings.timeout)
1163 | 
1164 |     // avoid sending empty string (#319)
1165 |     xhr.send(settings.data ? settings.data : null)
1166 |     return xhr
1167 |   }
1168 | 
1169 |   // handle optional data/success arguments
1170 |   function parseArguments(url, data, success, dataType) {
1171 |     if ($.isFunction(data)) dataType = success, success = data, data = undefined
1172 |     if (!$.isFunction(success)) dataType = success, success = undefined
1173 |     return {
1174 |       url: url
1175 |     , data: data
1176 |     , success: success
1177 |     , dataType: dataType
1178 |     }
1179 |   }
1180 | 
1181 |   $.get = function(/* url, data, success, dataType */){
1182 |     return $.ajax(parseArguments.apply(null, arguments))
1183 |   }
1184 | 
1185 |   $.post = function(/* url, data, success, dataType */){
1186 |     var options = parseArguments.apply(null, arguments)
1187 |     options.type = 'POST'
1188 |     return $.ajax(options)
1189 |   }
1190 | 
1191 |   $.getJSON = function(/* url, data, success */){
1192 |     var options = parseArguments.apply(null, arguments)
1193 |     options.dataType = 'json'
1194 |     return $.ajax(options)
1195 |   }
1196 | 
1197 |   $.fn.load = function(url, data, success){
1198 |     if (!this.length) return this
1199 |     var self = this, parts = url.split(/\s/), selector,
1200 |         options = parseArguments(url, data, success),
1201 |         callback = options.success
1202 |     if (parts.length > 1) options.url = parts[0], selector = parts[1]
1203 |     options.success = function(response){
1204 |       self.html(selector ?
1205 |         $('<div>').html(response.replace(rscript, "")).find(selector)
1206 |         : response)
1207 |       callback && callback.apply(self, arguments)
1208 |     }
1209 |     $.ajax(options)
1210 |     return this
1211 |   }
1212 | 
1213 |   var escape = encodeURIComponent
1214 | 
1215 |   function serialize(params, obj, traditional, scope){
1216 |     var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
1217 |     $.each(obj, function(key, value) {
1218 |       type = $.type(value)
1219 |       if (scope) key = traditional ? scope :
1220 |         scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
1221 |       // handle data in serializeArray() format
1222 |       if (!scope && array) params.add(value.name, value.value)
1223 |       // recurse into nested objects
1224 |       else if (type == "array" || (!traditional && type == "object"))
1225 |         serialize(params, value, traditional, key)
1226 |       else params.add(key, value)
1227 |     })
1228 |   }
1229 | 
1230 |   $.param = function(obj, traditional){
1231 |     var params = []
1232 |     params.add = function(k, v){ this.push(escape(k) + '=' + escape(v)) }
1233 |     serialize(params, obj, traditional)
1234 |     return params.join('&').replace(/%20/g, '+')
1235 |   }
1236 | })(Zepto)
1237 | 
1238 | //     Zepto.js
1239 | //     (c) 2010-2014 Thomas Fuchs
1240 | //     Zepto.js may be freely distributed under the MIT license.
1241 | 
1242 | // The following code is heavily inspired by jQuery's $.fn.data()
1243 | 
1244 | ;(function($){
1245 |   var data = {}, dataAttr = $.fn.data, camelize = $.camelCase,
1246 |     exp = $.expando = 'Zepto' + (+new Date()), emptyArray = []
1247 | 
1248 |   // Get value from node:
1249 |   // 1. first try key as given,
1250 |   // 2. then try camelized key,
1251 |   // 3. fall back to reading "data-*" attribute.
1252 |   function getData(node, name) {
1253 |     var id = node[exp], store = id && data[id]
1254 |     if (name === undefined) return store || setData(node)
1255 |     else {
1256 |       if (store) {
1257 |         if (name in store) return store[name]
1258 |         var camelName = camelize(name)
1259 |         if (camelName in store) return store[camelName]
1260 |       }
1261 |       return dataAttr.call($(node), name)
1262 |     }
1263 |   }
1264 | 
1265 |   // Store value under camelized key on node
1266 |   function setData(node, name, value) {
1267 |     var id = node[exp] || (node[exp] = ++$.uuid),
1268 |       store = data[id] || (data[id] = attributeData(node))
1269 |     if (name !== undefined) store[camelize(name)] = value
1270 |     return store
1271 |   }
1272 | 
1273 |   // Read all "data-*" attributes from a node
1274 |   function attributeData(node) {
1275 |     var store = {}
1276 |     $.each(node.attributes || emptyArray, function(i, attr){
1277 |       if (attr.name.indexOf('data-') == 0)
1278 |         store[camelize(attr.name.replace('data-', ''))] =
1279 |           $.zepto.deserializeValue(attr.value)
1280 |     })
1281 |     return store
1282 |   }
1283 | 
1284 |   $.fn.data = function(name, value) {
1285 |     return value === undefined ?
1286 |       // set multiple values via object
1287 |       $.isPlainObject(name) ?
1288 |         this.each(function(i, node){
1289 |           $.each(name, function(key, value){ setData(node, key, value) })
1290 |         }) :
1291 |         // get value from first element
1292 |         (0 in this ? getData(this[0], name) : undefined) :
1293 |       // set value on all elements
1294 |       this.each(function(){ setData(this, name, value) })
1295 |   }
1296 | 
1297 |   $.fn.removeData = function(names) {
1298 |     if (typeof names == 'string') names = names.split(/\s+/)
1299 |     return this.each(function(){
1300 |       var id = this[exp], store = id && data[id]
1301 |       if (store) $.each(names || store, function(key){
1302 |         delete store[names ? camelize(this) : key]
1303 |       })
1304 |     })
1305 |   }
1306 | 
1307 |   // Generate extended `remove` and `empty` functions
1308 |   ;['remove', 'empty'].forEach(function(methodName){
1309 |     var origFn = $.fn[methodName]
1310 |     $.fn[methodName] = function() {
1311 |       var elements = this.find('*')
1312 |       if (methodName === 'remove') elements = elements.add(this)
1313 |       elements.removeData()
1314 |       return origFn.call(this)
1315 |     }
1316 |   })
1317 | })(Zepto)
1318 | 
1319 | //     Zepto.js
1320 | //     (c) 2010-2014 Thomas Fuchs
1321 | //     Zepto.js may be freely distributed under the MIT license.
1322 | 
1323 | ;(function($){
1324 |   var _zid = 1, undefined,
1325 |       slice = Array.prototype.slice,
1326 |       isFunction = $.isFunction,
1327 |       isString = function(obj){ return typeof obj == 'string' },
1328 |       handlers = {},
1329 |       specialEvents={},
1330 |       focusinSupported = 'onfocusin' in window,
1331 |       focus = { focus: 'focusin', blur: 'focusout' },
1332 |       hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' }
1333 | 
1334 |   specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents'
1335 | 
1336 |   function zid(element) {
1337 |     return element._zid || (element._zid = _zid++)
1338 |   }
1339 |   function findHandlers(element, event, fn, selector) {
1340 |     event = parse(event)
1341 |     if (event.ns) var matcher = matcherFor(event.ns)
1342 |     return (handlers[zid(element)] || []).filter(function(handler) {
1343 |       return handler
1344 |         && (!event.e  || handler.e == event.e)
1345 |         && (!event.ns || matcher.test(handler.ns))
1346 |         && (!fn       || zid(handler.fn) === zid(fn))
1347 |         && (!selector || handler.sel == selector)
1348 |     })
1349 |   }
1350 |   function parse(event) {
1351 |     var parts = ('' + event).split('.')
1352 |     return {e: parts[0], ns: parts.slice(1).sort().join(' ')}
1353 |   }
1354 |   function matcherFor(ns) {
1355 |     return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)')
1356 |   }
1357 | 
1358 |   function eventCapture(handler, captureSetting) {
1359 |     return handler.del &&
1360 |       (!focusinSupported && (handler.e in focus)) ||
1361 |       !!captureSetting
1362 |   }
1363 | 
1364 |   function realEvent(type) {
1365 |     return hover[type] || (focusinSupported && focus[type]) || type
1366 |   }
1367 | 
1368 |   function add(element, events, fn, data, selector, delegator, capture){
1369 |     var id = zid(element), set = (handlers[id] || (handlers[id] = []))
1370 |     events.split(/\s/).forEach(function(event){
1371 |       if (event == 'ready') return $(document).ready(fn)
1372 |       var handler   = parse(event)
1373 |       handler.fn    = fn
1374 |       handler.sel   = selector
1375 |       // emulate mouseenter, mouseleave
1376 |       if (handler.e in hover) fn = function(e){
1377 |         var related = e.relatedTarget
1378 |         if (!related || (related !== this && !$.contains(this, related)))
1379 |           return handler.fn.apply(this, arguments)
1380 |       }
1381 |       handler.del   = delegator
1382 |       var callback  = delegator || fn
1383 |       handler.proxy = function(e){
1384 |         e = compatible(e)
1385 |         if (e.isImmediatePropagationStopped()) return
1386 |         e.data = data
1387 |         var result = callback.apply(element, e._args == undefined ? [e] : [e].concat(e._args))
1388 |         if (result === false) e.preventDefault(), e.stopPropagation()
1389 |         return result
1390 |       }
1391 |       handler.i = set.length
1392 |       set.push(handler)
1393 |       if ('addEventListener' in element)
1394 |         element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
1395 |     })
1396 |   }
1397 |   function remove(element, events, fn, selector, capture){
1398 |     var id = zid(element)
1399 |     ;(events || '').split(/\s/).forEach(function(event){
1400 |       findHandlers(element, event, fn, selector).forEach(function(handler){
1401 |         delete handlers[id][handler.i]
1402 |       if ('removeEventListener' in element)
1403 |         element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
1404 |       })
1405 |     })
1406 |   }
1407 | 
1408 |   $.event = { add: add, remove: remove }
1409 | 
1410 |   $.proxy = function(fn, context) {
1411 |     var args = (2 in arguments) && slice.call(arguments, 2)
1412 |     if (isFunction(fn)) {
1413 |       var proxyFn = function(){ return fn.apply(context, args ? args.concat(slice.call(arguments)) : arguments) }
1414 |       proxyFn._zid = zid(fn)
1415 |       return proxyFn
1416 |     } else if (isString(context)) {
1417 |       if (args) {
1418 |         args.unshift(fn[context], fn)
1419 |         return $.proxy.apply(null, args)
1420 |       } else {
1421 |         return $.proxy(fn[context], fn)
1422 |       }
1423 |     } else {
1424 |       throw new TypeError("expected function")
1425 |     }
1426 |   }
1427 | 
1428 |   $.fn.bind = function(event, data, callback){
1429 |     return this.on(event, data, callback)
1430 |   }
1431 |   $.fn.unbind = function(event, callback){
1432 |     return this.off(event, callback)
1433 |   }
1434 |   $.fn.one = function(event, selector, data, callback){
1435 |     return this.on(event, selector, data, callback, 1)
1436 |   }
1437 | 
1438 |   var returnTrue = function(){return true},
1439 |       returnFalse = function(){return false},
1440 |       ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$)/,
1441 |       eventMethods = {
1442 |         preventDefault: 'isDefaultPrevented',
1443 |         stopImmediatePropagation: 'isImmediatePropagationStopped',
1444 |         stopPropagation: 'isPropagationStopped'
1445 |       }
1446 | 
1447 |   function compatible(event, source) {
1448 |     if (source || !event.isDefaultPrevented) {
1449 |       source || (source = event)
1450 | 
1451 |       $.each(eventMethods, function(name, predicate) {
1452 |         var sourceMethod = source[name]
1453 |         event[name] = function(){
1454 |           this[predicate] = returnTrue
1455 |           return sourceMethod && sourceMethod.apply(source, arguments)
1456 |         }
1457 |         event[predicate] = returnFalse
1458 |       })
1459 | 
1460 |       if (source.defaultPrevented !== undefined ? source.defaultPrevented :
1461 |           'returnValue' in source ? source.returnValue === false :
1462 |           source.getPreventDefault && source.getPreventDefault())
1463 |         event.isDefaultPrevented = returnTrue
1464 |     }
1465 |     return event
1466 |   }
1467 | 
1468 |   function createProxy(event) {
1469 |     var key, proxy = { originalEvent: event }
1470 |     for (key in event)
1471 |       if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key]
1472 | 
1473 |     return compatible(proxy, event)
1474 |   }
1475 | 
1476 |   $.fn.delegate = function(selector, event, callback){
1477 |     return this.on(event, selector, callback)
1478 |   }
1479 |   $.fn.undelegate = function(selector, event, callback){
1480 |     return this.off(event, selector, callback)
1481 |   }
1482 | 
1483 |   $.fn.live = function(event, callback){
1484 |     $(document.body).delegate(this.selector, event, callback)
1485 |     return this
1486 |   }
1487 |   $.fn.die = function(event, callback){
1488 |     $(document.body).undelegate(this.selector, event, callback)
1489 |     return this
1490 |   }
1491 | 
1492 |   $.fn.on = function(event, selector, data, callback, one){
1493 |     var autoRemove, delegator, $this = this
1494 |     if (event && !isString(event)) {
1495 |       $.each(event, function(type, fn){
1496 |         $this.on(type, selector, data, fn, one)
1497 |       })
1498 |       return $this
1499 |     }
1500 | 
1501 |     if (!isString(selector) && !isFunction(callback) && callback !== false)
1502 |       callback = data, data = selector, selector = undefined
1503 |     if (isFunction(data) || data === false)
1504 |       callback = data, data = undefined
1505 | 
1506 |     if (callback === false) callback = returnFalse
1507 | 
1508 |     return $this.each(function(_, element){
1509 |       if (one) autoRemove = function(e){
1510 |         remove(element, e.type, callback)
1511 |         return callback.apply(this, arguments)
1512 |       }
1513 | 
1514 |       if (selector) delegator = function(e){
1515 |         var evt, match = $(e.target).closest(selector, element).get(0)
1516 |         if (match && match !== element) {
1517 |           evt = $.extend(createProxy(e), {currentTarget: match, liveFired: element})
1518 |           return (autoRemove || callback).apply(match, [evt].concat(slice.call(arguments, 1)))
1519 |         }
1520 |       }
1521 | 
1522 |       add(element, event, callback, data, selector, delegator || autoRemove)
1523 |     })
1524 |   }
1525 |   $.fn.off = function(event, selector, callback){
1526 |     var $this = this
1527 |     if (event && !isString(event)) {
1528 |       $.each(event, function(type, fn){
1529 |         $this.off(type, selector, fn)
1530 |       })
1531 |       return $this
1532 |     }
1533 | 
1534 |     if (!isString(selector) && !isFunction(callback) && callback !== false)
1535 |       callback = selector, selector = undefined
1536 | 
1537 |     if (callback === false) callback = returnFalse
1538 | 
1539 |     return $this.each(function(){
1540 |       remove(this, event, callback, selector)
1541 |     })
1542 |   }
1543 | 
1544 |   $.fn.trigger = function(event, args){
1545 |     event = (isString(event) || $.isPlainObject(event)) ? $.Event(event) : compatible(event)
1546 |     event._args = args
1547 |     return this.each(function(){
1548 |       // items in the collection might not be DOM elements
1549 |       if('dispatchEvent' in this) this.dispatchEvent(event)
1550 |       else $(this).triggerHandler(event, args)
1551 |     })
1552 |   }
1553 | 
1554 |   // triggers event handlers on current element just as if an event occurred,
1555 |   // doesn't trigger an actual event, doesn't bubble
1556 |   $.fn.triggerHandler = function(event, args){
1557 |     var e, result
1558 |     this.each(function(i, element){
1559 |       e = createProxy(isString(event) ? $.Event(event) : event)
1560 |       e._args = args
1561 |       e.target = element
1562 |       $.each(findHandlers(element, event.type || event), function(i, handler){
1563 |         result = handler.proxy(e)
1564 |         if (e.isImmediatePropagationStopped()) return false
1565 |       })
1566 |     })
1567 |     return result
1568 |   }
1569 | 
1570 |   // shortcut methods for `.bind(event, fn)` for each event type
1571 |   ;('focusin focusout load resize scroll unload click dblclick '+
1572 |   'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '+
1573 |   'change select keydown keypress keyup error').split(' ').forEach(function(event) {
1574 |     $.fn[event] = function(callback) {
1575 |       return callback ?
1576 |         this.bind(event, callback) :
1577 |         this.trigger(event)
1578 |     }
1579 |   })
1580 | 
1581 |   ;['focus', 'blur'].forEach(function(name) {
1582 |     $.fn[name] = function(callback) {
1583 |       if (callback) this.bind(name, callback)
1584 |       else this.each(function(){
1585 |         try { this[name]() }
1586 |         catch(e) {}
1587 |       })
1588 |       return this
1589 |     }
1590 |   })
1591 | 
1592 |   $.Event = function(type, props) {
1593 |     if (!isString(type)) props = type, type = props.type
1594 |     var event = document.createEvent(specialEvents[type] || 'Events'), bubbles = true
1595 |     if (props) for (var name in props) (name == 'bubbles') ? (bubbles = !!props[name]) : (event[name] = props[name])
1596 |     event.initEvent(type, bubbles, true)
1597 |     return compatible(event)
1598 |   }
1599 | 
1600 | })(Zepto)
1601 | 
1602 | //     Zepto.js
1603 | //     (c) 2010-2014 Thomas Fuchs
1604 | //     Zepto.js may be freely distributed under the MIT license.
1605 | 
1606 | ;(function($){
1607 |   $.fn.serializeArray = function() {
1608 |     var el, type, result = []
1609 |     $([].slice.call(this.get(0).elements)).each(function(){
1610 |       el = $(this)
1611 |       type = el.attr('type')
1612 |       if (this.nodeName.toLowerCase() != 'fieldset' &&
1613 |         !this.disabled && type != 'submit' && type != 'reset' && type != 'button' &&
1614 |         ((type != 'radio' && type != 'checkbox') || this.checked))
1615 |         result.push({
1616 |           name: el.attr('name'),
1617 |           value: el.val()
1618 |         })
1619 |     })
1620 |     return result
1621 |   }
1622 | 
1623 |   $.fn.serialize = function(){
1624 |     var result = []
1625 |     this.serializeArray().forEach(function(elm){
1626 |       result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
1627 |     })
1628 |     return result.join('&')
1629 |   }
1630 | 
1631 |   $.fn.submit = function(callback) {
1632 |     if (callback) this.bind('submit', callback)
1633 |     else if (this.length) {
1634 |       var event = $.Event('submit')
1635 |       this.eq(0).trigger(event)
1636 |       if (!event.isDefaultPrevented()) this.get(0).submit()
1637 |     }
1638 |     return this
1639 |   }
1640 | 
1641 | })(Zepto)
1642 | 
1643 | //     Zepto.js
1644 | //     (c) 2010-2014 Thomas Fuchs
1645 | //     Zepto.js may be freely distributed under the MIT license.
1646 | 
1647 | ;(function($){
1648 |   // __proto__ doesn't exist on IE<11, so redefine
1649 |   // the Z function to use object extension instead
1650 |   if (!('__proto__' in {})) {
1651 |     $.extend($.zepto, {
1652 |       Z: function(dom, selector){
1653 |         dom = dom || []
1654 |         $.extend(dom, $.fn)
1655 |         dom.selector = selector || ''
1656 |         dom.__Z = true
1657 |         return dom
1658 |       },
1659 |       // this is a kludge but works
1660 |       isZ: function(object){
1661 |         return $.type(object) === 'array' && '__Z' in object
1662 |       }
1663 |     })
1664 |   }
1665 | 
1666 |   // getComputedStyle shouldn't freak out when called
1667 |   // without a valid element as argument
1668 |   try {
1669 |     getComputedStyle(undefined)
1670 |   } catch(e) {
1671 |     var nativeGetComputedStyle = getComputedStyle;
1672 |     window.getComputedStyle = function(element){
1673 |       try {
1674 |         return nativeGetComputedStyle(element)
1675 |       } catch(e) {
1676 |         return null
1677 |       }
1678 |     }
1679 |   }
1680 | })(Zepto)
1681 | 


--------------------------------------------------------------------------------
/velocity.ui.js:
--------------------------------------------------------------------------------
  1 | /**********************
  2 |    Velocity UI Pack
  3 | **********************/
  4 | 
  5 | /* VelocityJS.org UI Pack (5.0.4). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License. Portions copyright Daniel Eden, Christian Pucci. */
  6 | 
  7 | ;(function (factory) {
  8 |     /* CommonJS module. */
  9 |     if (typeof require === "function" && typeof exports === "object" ) {
 10 |         module.exports = factory();
 11 |     /* AMD module. */
 12 |     } else if (typeof define === "function" && define.amd) {
 13 |         define([ "velocity" ], factory);
 14 |     /* Browser globals. */
 15 |     } else {
 16 |         factory();
 17 |     }
 18 | }(function() {
 19 | return function (global, window, document, undefined) {
 20 | 
 21 |     /*************
 22 |         Checks
 23 |     *************/
 24 | 
 25 |     if (!global.Velocity || !global.Velocity.Utilities) {
 26 |         window.console && console.log("Velocity UI Pack: Velocity must be loaded first. Aborting.");
 27 |         return;
 28 |     } else {
 29 |         var Velocity = global.Velocity,
 30 |             $ = Velocity.Utilities;
 31 |     }
 32 | 
 33 |     var velocityVersion = Velocity.version,
 34 |         requiredVersion = { major: 1, minor: 1, patch: 0 };
 35 | 
 36 |     function greaterSemver (primary, secondary) {
 37 |         var versionInts = [];
 38 | 
 39 |         if (!primary || !secondary) { return false; }
 40 | 
 41 |         $.each([ primary, secondary ], function(i, versionObject) {
 42 |             var versionIntsComponents = [];
 43 | 
 44 |             $.each(versionObject, function(component, value) {
 45 |                 while (value.toString().length < 5) {
 46 |                     value = "0" + value;
 47 |                 }
 48 |                 versionIntsComponents.push(value);
 49 |             });
 50 | 
 51 |             versionInts.push(versionIntsComponents.join(""))
 52 |         });
 53 | 
 54 |         return (parseFloat(versionInts[0]) > parseFloat(versionInts[1]));
 55 |     }
 56 | 
 57 |     if (greaterSemver(requiredVersion, velocityVersion)){
 58 |         var abortError = "Velocity UI Pack: You need to update Velocity (jquery.velocity.js) to a newer version. Visit http://github.com/julianshapiro/velocity.";
 59 |         alert(abortError);
 60 |         throw new Error(abortError);
 61 |     }
 62 | 
 63 |     /************************
 64 |        Effect Registration
 65 |     ************************/
 66 | 
 67 |     /* Note: RegisterUI is a legacy name. */
 68 |     Velocity.RegisterEffect = Velocity.RegisterUI = function (effectName, properties) {
 69 |         /* Animate the expansion/contraction of the elements' parent's height for In/Out effects. */
 70 |         function animateParentHeight (elements, direction, totalDuration, stagger) {
 71 |             var totalHeightDelta = 0,
 72 |                 parentNode;
 73 | 
 74 |             /* Sum the total height (including padding and margin) of all targeted elements. */
 75 |             $.each(elements.nodeType ? [ elements ] : elements, function(i, element) {
 76 |                 if (stagger) {
 77 |                     /* Increase the totalDuration by the successive delay amounts produced by the stagger option. */
 78 |                     totalDuration += i * stagger;
 79 |                 }
 80 | 
 81 |                 parentNode = element.parentNode;
 82 | 
 83 |                 $.each([ "height", "paddingTop", "paddingBottom", "marginTop", "marginBottom"], function(i, property) {
 84 |                     totalHeightDelta += parseFloat(Velocity.CSS.getPropertyValue(element, property));
 85 |                 });
 86 |             });
 87 | 
 88 |             /* Animate the parent element's height adjustment (with a varying duration multiplier for aesthetic benefits). */
 89 |             Velocity.animate(
 90 |                 parentNode,
 91 |                 { height: (direction === "In" ? "+" : "-") + "=" + totalHeightDelta },
 92 |                 { queue: false, easing: "ease-in-out", duration: totalDuration * (direction === "In" ? 0.6 : 1) }
 93 |             );
 94 |         }
 95 | 
 96 |         /* Register a custom redirect for each effect. */
 97 |         Velocity.Redirects[effectName] = function (element, redirectOptions, elementsIndex, elementsSize, elements, promiseData) {
 98 |             var finalElement = (elementsIndex === elementsSize - 1);
 99 | 
100 |             if (typeof properties.defaultDuration === "function") {
101 |                 properties.defaultDuration = properties.defaultDuration.call(elements, elements);
102 |             } else {
103 |                 properties.defaultDuration = parseFloat(properties.defaultDuration);
104 |             }
105 | 
106 |             /* Iterate through each effect's call array. */
107 |             for (var callIndex = 0; callIndex < properties.calls.length; callIndex++) {
108 |                 var call = properties.calls[callIndex],
109 |                     propertyMap = call[0],
110 |                     redirectDuration = (redirectOptions.duration || properties.defaultDuration || 1000),
111 |                     durationPercentage = call[1],
112 |                     callOptions = call[2] || {},
113 |                     opts = {};
114 | 
115 |                 /* Assign the whitelisted per-call options. */
116 |                 opts.duration = redirectDuration * (durationPercentage || 1);
117 |                 opts.queue = redirectOptions.queue || "";
118 |                 opts.easing = callOptions.easing || "ease";
119 |                 opts.delay = parseFloat(callOptions.delay) || 0;
120 |                 opts._cacheValues = callOptions._cacheValues || true;
121 | 
122 |                 /* Special processing for the first effect call. */
123 |                 if (callIndex === 0) {
124 |                     /* If a delay was passed into the redirect, combine it with the first call's delay. */
125 |                     opts.delay += (parseFloat(redirectOptions.delay) || 0);
126 | 
127 |                     if (elementsIndex === 0) {
128 |                         opts.begin = function() {
129 |                             /* Only trigger a begin callback on the first effect call with the first element in the set. */
130 |                             redirectOptions.begin && redirectOptions.begin.call(elements, elements);
131 | 
132 |                             var direction = effectName.match(/(In|Out)$/);
133 | 
134 |                             /* Make "in" transitioning elements invisible immediately so that there's no FOUC between now
135 |                                and the first RAF tick. */
136 |                             if ((direction && direction[0] === "In") && propertyMap.opacity !== undefined) {
137 |                                 $.each(elements.nodeType ? [ elements ] : elements, function(i, element) {
138 |                                     Velocity.CSS.setPropertyValue(element, "opacity", 0);
139 |                                 });
140 |                             }
141 | 
142 |                             /* Only trigger animateParentHeight() if we're using an In/Out transition. */
143 |                             if (redirectOptions.animateParentHeight && direction) {
144 |                                 animateParentHeight(elements, direction[0], redirectDuration + opts.delay, redirectOptions.stagger);
145 |                             }
146 |                         }
147 |                     }
148 | 
149 |                     /* If the user isn't overriding the display option, default to "auto" for "In"-suffixed transitions. */
150 |                     if (redirectOptions.display !== null) {
151 |                         if (redirectOptions.display !== undefined && redirectOptions.display !== "none") {
152 |                             opts.display = redirectOptions.display;
153 |                         } else if (/In$/.test(effectName)) {
154 |                             /* Inline elements cannot be subjected to transforms, so we switch them to inline-block. */
155 |                             var defaultDisplay = Velocity.CSS.Values.getDisplayType(element);
156 |                             opts.display = (defaultDisplay === "inline") ? "inline-block" : defaultDisplay;
157 |                         }
158 |                     }
159 | 
160 |                     if (redirectOptions.visibility && redirectOptions.visibility !== "hidden") {
161 |                         opts.visibility = redirectOptions.visibility;
162 |                     }
163 |                 }
164 | 
165 |                 /* Special processing for the last effect call. */
166 |                 if (callIndex === properties.calls.length - 1) {
167 |                     /* Append promise resolving onto the user's redirect callback. */
168 |                     function injectFinalCallbacks () {
169 |                         if ((redirectOptions.display === undefined || redirectOptions.display === "none") && /Out$/.test(effectName)) {
170 |                             $.each(elements.nodeType ? [ elements ] : elements, function(i, element) {
171 |                                 Velocity.CSS.setPropertyValue(element, "display", "none");
172 |                             });
173 |                         }
174 | 
175 |                         redirectOptions.complete && redirectOptions.complete.call(elements, elements);
176 | 
177 |                         if (promiseData) {
178 |                             promiseData.resolver(elements || element);
179 |                         }
180 |                     }
181 | 
182 |                     opts.complete = function() {
183 |                         if (properties.reset) {
184 |                             for (var resetProperty in properties.reset) {
185 |                                 var resetValue = properties.reset[resetProperty];
186 | 
187 |                                 /* Format each non-array value in the reset property map to [ value, value ] so that changes apply
188 |                                    immediately and DOM querying is avoided (via forcefeeding). */
189 |                                 /* Note: Don't forcefeed hooks, otherwise their hook roots will be defaulted to their null values. */
190 |                                 if (Velocity.CSS.Hooks.registered[resetProperty] === undefined && (typeof resetValue === "string" || typeof resetValue === "number")) {
191 |                                     properties.reset[resetProperty] = [ properties.reset[resetProperty], properties.reset[resetProperty] ];
192 |                                 }
193 |                             }
194 | 
195 |                             /* So that the reset values are applied instantly upon the next rAF tick, use a zero duration and parallel queueing. */
196 |                             var resetOptions = { duration: 0, queue: false };
197 | 
198 |                             /* Since the reset option uses up the complete callback, we trigger the user's complete callback at the end of ours. */
199 |                             if (finalElement) {
200 |                                 resetOptions.complete = injectFinalCallbacks;
201 |                             }
202 | 
203 |                             Velocity.animate(element, properties.reset, resetOptions);
204 |                         /* Only trigger the user's complete callback on the last effect call with the last element in the set. */
205 |                         } else if (finalElement) {
206 |                             injectFinalCallbacks();
207 |                         }
208 |                     };
209 | 
210 |                     if (redirectOptions.visibility === "hidden") {
211 |                         opts.visibility = redirectOptions.visibility;
212 |                     }
213 |                 }
214 | 
215 |                 Velocity.animate(element, propertyMap, opts);
216 |             }
217 |         };
218 | 
219 |         /* Return the Velocity object so that RegisterUI calls can be chained. */
220 |         return Velocity;
221 |     };
222 | 
223 |     /*********************
224 |        Packaged Effects
225 |     *********************/
226 | 
227 |     /* Externalize the packagedEffects data so that they can optionally be modified and re-registered. */
228 |     /* Support: <=IE8: Callouts will have no effect, and transitions will simply fade in/out. IE9/Android 2.3: Most effects are fully supported, the rest fade in/out. All other browsers: full support. */
229 |     Velocity.RegisterEffect.packagedEffects =
230 |         {
231 |             /* Animate.css */
232 |             "callout.bounce": {
233 |                 defaultDuration: 550,
234 |                 calls: [
235 |                     [ { translateY: -30 }, 0.25 ],
236 |                     [ { translateY: 0 }, 0.125 ],
237 |                     [ { translateY: -15 }, 0.125 ],
238 |                     [ { translateY: 0 }, 0.25 ]
239 |                 ]
240 |             },
241 |             /* Animate.css */
242 |             "callout.shake": {
243 |                 defaultDuration: 800,
244 |                 calls: [
245 |                     [ { translateX: -11 }, 0.125 ],
246 |                     [ { translateX: 11 }, 0.125 ],
247 |                     [ { translateX: -11 }, 0.125 ],
248 |                     [ { translateX: 11 }, 0.125 ],
249 |                     [ { translateX: -11 }, 0.125 ],
250 |                     [ { translateX: 11 }, 0.125 ],
251 |                     [ { translateX: -11 }, 0.125 ],
252 |                     [ { translateX: 0 }, 0.125 ]
253 |                 ]
254 |             },
255 |             /* Animate.css */
256 |             "callout.flash": {
257 |                 defaultDuration: 1100,
258 |                 calls: [
259 |                     [ { opacity: [ 0, "easeInOutQuad", 1 ] }, 0.25 ],
260 |                     [ { opacity: [ 1, "easeInOutQuad" ] }, 0.25 ],
261 |                     [ { opacity: [ 0, "easeInOutQuad" ] }, 0.25 ],
262 |                     [ { opacity: [ 1, "easeInOutQuad" ] }, 0.25 ]
263 |                 ]
264 |             },
265 |             /* Animate.css */
266 |             "callout.pulse": {
267 |                 defaultDuration: 825,
268 |                 calls: [
269 |                     [ { scaleX: 1.1, scaleY: 1.1 }, 0.50, { easing: "easeInExpo" } ],
270 |                     [ { scaleX: 1, scaleY: 1 }, 0.50 ]
271 |                 ]
272 |             },
273 |             /* Animate.css */
274 |             "callout.swing": {
275 |                 defaultDuration: 950,
276 |                 calls: [
277 |                     [ { rotateZ: 15 }, 0.20 ],
278 |                     [ { rotateZ: -10 }, 0.20 ],
279 |                     [ { rotateZ: 5 }, 0.20 ],
280 |                     [ { rotateZ: -5 }, 0.20 ],
281 |                     [ { rotateZ: 0 }, 0.20 ]
282 |                 ]
283 |             },
284 |             /* Animate.css */
285 |             "callout.tada": {
286 |                 defaultDuration: 1000,
287 |                 calls: [
288 |                     [ { scaleX: 0.9, scaleY: 0.9, rotateZ: -3 }, 0.10 ],
289 |                     [ { scaleX: 1.1, scaleY: 1.1, rotateZ: 3 }, 0.10 ],
290 |                     [ { scaleX: 1.1, scaleY: 1.1, rotateZ: -3 }, 0.10 ],
291 |                     [ "reverse", 0.125 ],
292 |                     [ "reverse", 0.125 ],
293 |                     [ "reverse", 0.125 ],
294 |                     [ "reverse", 0.125 ],
295 |                     [ "reverse", 0.125 ],
296 |                     [ { scaleX: 1, scaleY: 1, rotateZ: 0 }, 0.20 ]
297 |                 ]
298 |             },
299 |             "transition.fadeIn": {
300 |                 defaultDuration: 500,
301 |                 calls: [
302 |                     [ { opacity: [ 1, 0 ] } ]
303 |                 ]
304 |             },
305 |             "transition.fadeOut": {
306 |                 defaultDuration: 500,
307 |                 calls: [
308 |                     [ { opacity: [ 0, 1 ] } ]
309 |                 ]
310 |             },
311 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
312 |             "transition.flipXIn": {
313 |                 defaultDuration: 700,
314 |                 calls: [
315 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 800, 800 ], rotateY: [ 0, -55 ] } ]
316 |                 ],
317 |                 reset: { transformPerspective: 0 }
318 |             },
319 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
320 |             "transition.flipXOut": {
321 |                 defaultDuration: 700,
322 |                 calls: [
323 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 800, 800 ], rotateY: 55 } ]
324 |                 ],
325 |                 reset: { transformPerspective: 0, rotateY: 0 }
326 |             },
327 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
328 |             "transition.flipYIn": {
329 |                 defaultDuration: 800,
330 |                 calls: [
331 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 800, 800 ], rotateX: [ 0, -45 ] } ]
332 |                 ],
333 |                 reset: { transformPerspective: 0 }
334 |             },
335 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
336 |             "transition.flipYOut": {
337 |                 defaultDuration: 800,
338 |                 calls: [
339 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 800, 800 ], rotateX: 25 } ]
340 |                 ],
341 |                 reset: { transformPerspective: 0, rotateX: 0 }
342 |             },
343 |             /* Animate.css */
344 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
345 |             "transition.flipBounceXIn": {
346 |                 defaultDuration: 900,
347 |                 calls: [
348 |                     [ { opacity: [ 0.725, 0 ], transformPerspective: [ 400, 400 ], rotateY: [ -10, 90 ] }, 0.50 ],
349 |                     [ { opacity: 0.80, rotateY: 10 }, 0.25 ],
350 |                     [ { opacity: 1, rotateY: 0 }, 0.25 ]
351 |                 ],
352 |                 reset: { transformPerspective: 0 }
353 |             },
354 |             /* Animate.css */
355 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
356 |             "transition.flipBounceXOut": {
357 |                 defaultDuration: 800,
358 |                 calls: [
359 |                     [ { opacity: [ 0.9, 1 ], transformPerspective: [ 400, 400 ], rotateY: -10 }, 0.50 ],
360 |                     [ { opacity: 0, rotateY: 90 }, 0.50 ]
361 |                 ],
362 |                 reset: { transformPerspective: 0, rotateY: 0 }
363 |             },
364 |             /* Animate.css */
365 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
366 |             "transition.flipBounceYIn": {
367 |                 defaultDuration: 850,
368 |                 calls: [
369 |                     [ { opacity: [ 0.725, 0 ], transformPerspective: [ 400, 400 ], rotateX: [ -10, 90 ] }, 0.50 ],
370 |                     [ { opacity: 0.80, rotateX: 10 }, 0.25 ],
371 |                     [ { opacity: 1, rotateX: 0 }, 0.25 ]
372 |                 ],
373 |                 reset: { transformPerspective: 0 }
374 |             },
375 |             /* Animate.css */
376 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
377 |             "transition.flipBounceYOut": {
378 |                 defaultDuration: 800,
379 |                 calls: [
380 |                     [ { opacity: [ 0.9, 1 ], transformPerspective: [ 400, 400 ], rotateX: -15 }, 0.50 ],
381 |                     [ { opacity: 0, rotateX: 90 }, 0.50 ]
382 |                 ],
383 |                 reset: { transformPerspective: 0, rotateX: 0 }
384 |             },
385 |             /* Magic.css */
386 |             "transition.swoopIn": {
387 |                 defaultDuration: 850,
388 |                 calls: [
389 |                     [ { opacity: [ 1, 0 ], transformOriginX: [ "100%", "50%" ], transformOriginY: [ "100%", "100%" ], scaleX: [ 1, 0 ], scaleY: [ 1, 0 ], translateX: [ 0, -700 ], translateZ: 0 } ]
390 |                 ],
391 |                 reset: { transformOriginX: "50%", transformOriginY: "50%" }
392 |             },
393 |             /* Magic.css */
394 |             "transition.swoopOut": {
395 |                 defaultDuration: 850,
396 |                 calls: [
397 |                     [ { opacity: [ 0, 1 ], transformOriginX: [ "50%", "100%" ], transformOriginY: [ "100%", "100%" ], scaleX: 0, scaleY: 0, translateX: -700, translateZ: 0 } ]
398 |                 ],
399 |                 reset: { transformOriginX: "50%", transformOriginY: "50%", scaleX: 1, scaleY: 1, translateX: 0 }
400 |             },
401 |             /* Magic.css */
402 |             /* Support: Loses rotation in IE9/Android 2.3. (Fades and scales only.) */
403 |             "transition.whirlIn": {
404 |                 defaultDuration: 850,
405 |                 calls: [
406 |                     [ { opacity: [ 1, 0 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: [ 1, 0 ], scaleY: [ 1, 0 ], rotateY: [ 0, 160 ] }, 1, { easing: "easeInOutSine" } ]
407 |                 ]
408 |             },
409 |             /* Magic.css */
410 |             /* Support: Loses rotation in IE9/Android 2.3. (Fades and scales only.) */
411 |             "transition.whirlOut": {
412 |                 defaultDuration: 750,
413 |                 calls: [
414 |                     [ { opacity: [ 0, "easeInOutQuint", 1 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: 0, scaleY: 0, rotateY: 160 }, 1, { easing: "swing" } ]
415 |                 ],
416 |                 reset: { scaleX: 1, scaleY: 1, rotateY: 0 }
417 |             },
418 |             "transition.shrinkIn": {
419 |                 defaultDuration: 750,
420 |                 calls: [
421 |                     [ { opacity: [ 1, 0 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: [ 1, 1.5 ], scaleY: [ 1, 1.5 ], translateZ: 0 } ]
422 |                 ]
423 |             },
424 |             "transition.shrinkOut": {
425 |                 defaultDuration: 600,
426 |                 calls: [
427 |                     [ { opacity: [ 0, 1 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: 1.3, scaleY: 1.3, translateZ: 0 } ]
428 |                 ],
429 |                 reset: { scaleX: 1, scaleY: 1 }
430 |             },
431 |             "transition.expandIn": {
432 |                 defaultDuration: 700,
433 |                 calls: [
434 |                     [ { opacity: [ 1, 0 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: [ 1, 0.625 ], scaleY: [ 1, 0.625 ], translateZ: 0 } ]
435 |                 ]
436 |             },
437 |             "transition.expandOut": {
438 |                 defaultDuration: 700,
439 |                 calls: [
440 |                     [ { opacity: [ 0, 1 ], transformOriginX: [ "50%", "50%" ], transformOriginY: [ "50%", "50%" ], scaleX: 0.5, scaleY: 0.5, translateZ: 0 } ]
441 |                 ],
442 |                 reset: { scaleX: 1, scaleY: 1 }
443 |             },
444 |             /* Animate.css */
445 |             "transition.bounceIn": {
446 |                 defaultDuration: 800,
447 |                 calls: [
448 |                     [ { opacity: [ 1, 0 ], scaleX: [ 1.05, 0.3 ], scaleY: [ 1.05, 0.3 ] }, 0.40 ],
449 |                     [ { scaleX: 0.9, scaleY: 0.9, translateZ: 0 }, 0.20 ],
450 |                     [ { scaleX: 1, scaleY: 1 }, 0.50 ]
451 |                 ]
452 |             },
453 |             /* Animate.css */
454 |             "transition.bounceOut": {
455 |                 defaultDuration: 800,
456 |                 calls: [
457 |                     [ { scaleX: 0.95, scaleY: 0.95 }, 0.35 ],
458 |                     [ { scaleX: 1.1, scaleY: 1.1, translateZ: 0 }, 0.35 ],
459 |                     [ { opacity: [ 0, 1 ], scaleX: 0.3, scaleY: 0.3 }, 0.30 ]
460 |                 ],
461 |                 reset: { scaleX: 1, scaleY: 1 }
462 |             },
463 |             /* Animate.css */
464 |             "transition.bounceUpIn": {
465 |                 defaultDuration: 800,
466 |                 calls: [
467 |                     [ { opacity: [ 1, 0 ], translateY: [ -30, 1000 ] }, 0.60, { easing: "easeOutCirc" } ],
468 |                     [ { translateY: 10 }, 0.20 ],
469 |                     [ { translateY: 0 }, 0.20 ]
470 |                 ]
471 |             },
472 |             /* Animate.css */
473 |             "transition.bounceUpOut": {
474 |                 defaultDuration: 1000,
475 |                 calls: [
476 |                     [ { translateY: 20 }, 0.20 ],
477 |                     [ { opacity: [ 0, "easeInCirc", 1 ], translateY: -1000 }, 0.80 ]
478 |                 ],
479 |                 reset: { translateY: 0 }
480 |             },
481 |             /* Animate.css */
482 |             "transition.bounceDownIn": {
483 |                 defaultDuration: 800,
484 |                 calls: [
485 |                     [ { opacity: [ 1, 0 ], translateY: [ 30, -1000 ] }, 0.60, { easing: "easeOutCirc" } ],
486 |                     [ { translateY: -10 }, 0.20 ],
487 |                     [ { translateY: 0 }, 0.20 ]
488 |                 ]
489 |             },
490 |             /* Animate.css */
491 |             "transition.bounceDownOut": {
492 |                 defaultDuration: 1000,
493 |                 calls: [
494 |                     [ { translateY: -20 }, 0.20 ],
495 |                     [ { opacity: [ 0, "easeInCirc", 1 ], translateY: 1000 }, 0.80 ]
496 |                 ],
497 |                 reset: { translateY: 0 }
498 |             },
499 |             /* Animate.css */
500 |             "transition.bounceLeftIn": {
501 |                 defaultDuration: 750,
502 |                 calls: [
503 |                     [ { opacity: [ 1, 0 ], translateX: [ 30, -1250 ] }, 0.60, { easing: "easeOutCirc" } ],
504 |                     [ { translateX: -10 }, 0.20 ],
505 |                     [ { translateX: 0 }, 0.20 ]
506 |                 ]
507 |             },
508 |             /* Animate.css */
509 |             "transition.bounceLeftOut": {
510 |                 defaultDuration: 750,
511 |                 calls: [
512 |                     [ { translateX: 30 }, 0.20 ],
513 |                     [ { opacity: [ 0, "easeInCirc", 1 ], translateX: -1250 }, 0.80 ]
514 |                 ],
515 |                 reset: { translateX: 0 }
516 |             },
517 |             /* Animate.css */
518 |             "transition.bounceRightIn": {
519 |                 defaultDuration: 750,
520 |                 calls: [
521 |                     [ { opacity: [ 1, 0 ], translateX: [ -30, 1250 ] }, 0.60, { easing: "easeOutCirc" } ],
522 |                     [ { translateX: 10 }, 0.20 ],
523 |                     [ { translateX: 0 }, 0.20 ]
524 |                 ]
525 |             },
526 |             /* Animate.css */
527 |             "transition.bounceRightOut": {
528 |                 defaultDuration: 750,
529 |                 calls: [
530 |                     [ { translateX: -30 }, 0.20 ],
531 |                     [ { opacity: [ 0, "easeInCirc", 1 ], translateX: 1250 }, 0.80 ]
532 |                 ],
533 |                 reset: { translateX: 0 }
534 |             },
535 |             "transition.slideUpIn": {
536 |                 defaultDuration: 900,
537 |                 calls: [
538 |                     [ { opacity: [ 1, 0 ], translateY: [ 0, 20 ], translateZ: 0 } ]
539 |                 ]
540 |             },
541 |             "transition.slideUpOut": {
542 |                 defaultDuration: 900,
543 |                 calls: [
544 |                     [ { opacity: [ 0, 1 ], translateY: -20, translateZ: 0 } ]
545 |                 ],
546 |                 reset: { translateY: 0 }
547 |             },
548 |             "transition.slideDownIn": {
549 |                 defaultDuration: 900,
550 |                 calls: [
551 |                     [ { opacity: [ 1, 0 ], translateY: [ 0, -20 ], translateZ: 0 } ]
552 |                 ]
553 |             },
554 |             "transition.slideDownOut": {
555 |                 defaultDuration: 900,
556 |                 calls: [
557 |                     [ { opacity: [ 0, 1 ], translateY: 20, translateZ: 0 } ]
558 |                 ],
559 |                 reset: { translateY: 0 }
560 |             },
561 |             "transition.slideLeftIn": {
562 |                 defaultDuration: 1000,
563 |                 calls: [
564 |                     [ { opacity: [ 1, 0 ], translateX: [ 0, -20 ], translateZ: 0 } ]
565 |                 ]
566 |             },
567 |             "transition.slideLeftOut": {
568 |                 defaultDuration: 1050,
569 |                 calls: [
570 |                     [ { opacity: [ 0, 1 ], translateX: -20, translateZ: 0 } ]
571 |                 ],
572 |                 reset: { translateX: 0 }
573 |             },
574 |             "transition.slideRightIn": {
575 |                 defaultDuration: 1000,
576 |                 calls: [
577 |                     [ { opacity: [ 1, 0 ], translateX: [ 0, 20 ], translateZ: 0 } ]
578 |                 ]
579 |             },
580 |             "transition.slideRightOut": {
581 |                 defaultDuration: 1050,
582 |                 calls: [
583 |                     [ { opacity: [ 0, 1 ], translateX: 20, translateZ: 0 } ]
584 |                 ],
585 |                 reset: { translateX: 0 }
586 |             },
587 |             "transition.slideUpBigIn": {
588 |                 defaultDuration: 850,
589 |                 calls: [
590 |                     [ { opacity: [ 1, 0 ], translateY: [ 0, 75 ], translateZ: 0 } ]
591 |                 ]
592 |             },
593 |             "transition.slideUpBigOut": {
594 |                 defaultDuration: 800,
595 |                 calls: [
596 |                     [ { opacity: [ 0, 1 ], translateY: -75, translateZ: 0 } ]
597 |                 ],
598 |                 reset: { translateY: 0 }
599 |             },
600 |             "transition.slideDownBigIn": {
601 |                 defaultDuration: 850,
602 |                 calls: [
603 |                     [ { opacity: [ 1, 0 ], translateY: [ 0, -75 ], translateZ: 0 } ]
604 |                 ]
605 |             },
606 |             "transition.slideDownBigOut": {
607 |                 defaultDuration: 800,
608 |                 calls: [
609 |                     [ { opacity: [ 0, 1 ], translateY: 75, translateZ: 0 } ]
610 |                 ],
611 |                 reset: { translateY: 0 }
612 |             },
613 |             "transition.slideLeftBigIn": {
614 |                 defaultDuration: 800,
615 |                 calls: [
616 |                     [ { opacity: [ 1, 0 ], translateX: [ 0, -75 ], translateZ: 0 } ]
617 |                 ]
618 |             },
619 |             "transition.slideLeftBigOut": {
620 |                 defaultDuration: 750,
621 |                 calls: [
622 |                     [ { opacity: [ 0, 1 ], translateX: -75, translateZ: 0 } ]
623 |                 ],
624 |                 reset: { translateX: 0 }
625 |             },
626 |             "transition.slideRightBigIn": {
627 |                 defaultDuration: 800,
628 |                 calls: [
629 |                     [ { opacity: [ 1, 0 ], translateX: [ 0, 75 ], translateZ: 0 } ]
630 |                 ]
631 |             },
632 |             "transition.slideRightBigOut": {
633 |                 defaultDuration: 750,
634 |                 calls: [
635 |                     [ { opacity: [ 0, 1 ], translateX: 75, translateZ: 0 } ]
636 |                 ],
637 |                 reset: { translateX: 0 }
638 |             },
639 |             /* Magic.css */
640 |             "transition.perspectiveUpIn": {
641 |                 defaultDuration: 800,
642 |                 calls: [
643 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 800, 800 ], transformOriginX: [ 0, 0 ], transformOriginY: [ "100%", "100%" ], rotateX: [ 0, -180 ] } ]
644 |                 ],
645 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%" }
646 |             },
647 |             /* Magic.css */
648 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
649 |             "transition.perspectiveUpOut": {
650 |                 defaultDuration: 850,
651 |                 calls: [
652 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 800, 800 ], transformOriginX: [ 0, 0 ], transformOriginY: [ "100%", "100%" ], rotateX: -180 } ]
653 |                 ],
654 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%", rotateX: 0 }
655 |             },
656 |             /* Magic.css */
657 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
658 |             "transition.perspectiveDownIn": {
659 |                 defaultDuration: 800,
660 |                 calls: [
661 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 800, 800 ], transformOriginX: [ 0, 0 ], transformOriginY: [ 0, 0 ], rotateX: [ 0, 180 ] } ]
662 |                 ],
663 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%" }
664 |             },
665 |             /* Magic.css */
666 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
667 |             "transition.perspectiveDownOut": {
668 |                 defaultDuration: 850,
669 |                 calls: [
670 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 800, 800 ], transformOriginX: [ 0, 0 ], transformOriginY: [ 0, 0 ], rotateX: 180 } ]
671 |                 ],
672 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%", rotateX: 0 }
673 |             },
674 |             /* Magic.css */
675 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
676 |             "transition.perspectiveLeftIn": {
677 |                 defaultDuration: 950,
678 |                 calls: [
679 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 2000, 2000 ], transformOriginX: [ 0, 0 ], transformOriginY: [ 0, 0 ], rotateY: [ 0, -180 ] } ]
680 |                 ],
681 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%" }
682 |             },
683 |             /* Magic.css */
684 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
685 |             "transition.perspectiveLeftOut": {
686 |                 defaultDuration: 950,
687 |                 calls: [
688 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 2000, 2000 ], transformOriginX: [ 0, 0 ], transformOriginY: [ 0, 0 ], rotateY: -180 } ]
689 |                 ],
690 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%", rotateY: 0 }
691 |             },
692 |             /* Magic.css */
693 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
694 |             "transition.perspectiveRightIn": {
695 |                 defaultDuration: 950,
696 |                 calls: [
697 |                     [ { opacity: [ 1, 0 ], transformPerspective: [ 2000, 2000 ], transformOriginX: [ "100%", "100%" ], transformOriginY: [ 0, 0 ], rotateY: [ 0, 180 ] } ]
698 |                 ],
699 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%" }
700 |             },
701 |             /* Magic.css */
702 |             /* Support: Loses rotation in IE9/Android 2.3 (fades only). */
703 |             "transition.perspectiveRightOut": {
704 |                 defaultDuration: 950,
705 |                 calls: [
706 |                     [ { opacity: [ 0, 1 ], transformPerspective: [ 2000, 2000 ], transformOriginX: [ "100%", "100%" ], transformOriginY: [ 0, 0 ], rotateY: 180 } ]
707 |                 ],
708 |                 reset: { transformPerspective: 0, transformOriginX: "50%", transformOriginY: "50%", rotateY: 0 }
709 |             }
710 |         };
711 | 
712 |     /* Register the packaged effects. */
713 |     for (var effectName in Velocity.RegisterEffect.packagedEffects) {
714 |         Velocity.RegisterEffect(effectName, Velocity.RegisterEffect.packagedEffects[effectName]);
715 |     }
716 | 
717 |     /*********************
718 |        Sequence Running
719 |     **********************/
720 | 
721 |     /* Note: Sequence calls must use Velocity's single-object arguments syntax. */
722 |     Velocity.RunSequence = function (originalSequence) {
723 |         var sequence = $.extend(true, [], originalSequence);
724 | 
725 |         if (sequence.length > 1) {
726 |             $.each(sequence.reverse(), function(i, currentCall) {
727 |                 var nextCall = sequence[i + 1];
728 | 
729 |                 if (nextCall) {
730 |                     /* Parallel sequence calls (indicated via sequenceQueue:false) are triggered
731 |                        in the previous call's begin callback. Otherwise, chained calls are normally triggered
732 |                        in the previous call's complete callback. */
733 |                     var currentCallOptions = currentCall.o || currentCall.options,
734 |                         nextCallOptions = nextCall.o || nextCall.options;
735 | 
736 |                     var timing = (currentCallOptions && currentCallOptions.sequenceQueue === false) ? "begin" : "complete",
737 |                         callbackOriginal = nextCallOptions && nextCallOptions[timing],
738 |                         options = {};
739 | 
740 |                     options[timing] = function() {
741 |                         var nextCallElements = nextCall.e || nextCall.elements;
742 |                         var elements = nextCallElements.nodeType ? [ nextCallElements ] : nextCallElements;
743 | 
744 |                         callbackOriginal && callbackOriginal.call(elements, elements);
745 |                         Velocity(currentCall);
746 |                     }
747 | 
748 |                     if (nextCall.o) {
749 |                         nextCall.o = $.extend({}, nextCallOptions, options);
750 |                     } else {
751 |                         nextCall.options = $.extend({}, nextCallOptions, options);
752 |                     }
753 |                 }
754 |             });
755 | 
756 |             sequence.reverse();
757 |         }
758 | 
759 |         Velocity(sequence[0]);
760 |     };
761 | }((window.jQuery || window.Zepto || window), window, document);
762 | }));


--------------------------------------------------------------------------------
/velocity.ui.min.js:
--------------------------------------------------------------------------------
1 | /* VelocityJS.org UI Pack (5.0.4). (C) 2014 Julian Shapiro. MIT @license: en.wikipedia.org/wiki/MIT_License. Portions copyright Daniel Eden, Christian Pucci. */
2 | !function(t){"function"==typeof require&&"object"==typeof exports?module.exports=t():"function"==typeof define&&define.amd?define(["velocity"],t):t()}(function(){return function(t,a,e,r){function n(t,a){var e=[];return t&&a?($.each([t,a],function(t,a){var r=[];$.each(a,function(t,a){for(;a.toString().length<5;)a="0"+a;r.push(a)}),e.push(r.join(""))}),parseFloat(e[0])>parseFloat(e[1])):!1}if(!t.Velocity||!t.Velocity.Utilities)return void(a.console&&console.log("Velocity UI Pack: Velocity must be loaded first. Aborting."));var i=t.Velocity,$=i.Utilities,s=i.version,o={major:1,minor:1,patch:0};if(n(o,s)){var l="Velocity UI Pack: You need to update Velocity (jquery.velocity.js) to a newer version. Visit http://github.com/julianshapiro/velocity.";throw alert(l),new Error(l)}i.RegisterEffect=i.RegisterUI=function(t,a){function e(t,a,e,r){var n=0,s;$.each(t.nodeType?[t]:t,function(t,a){r&&(e+=t*r),s=a.parentNode,$.each(["height","paddingTop","paddingBottom","marginTop","marginBottom"],function(t,e){n+=parseFloat(i.CSS.getPropertyValue(a,e))})}),i.animate(s,{height:("In"===a?"+":"-")+"="+n},{queue:!1,easing:"ease-in-out",duration:e*("In"===a?.6:1)})}return i.Redirects[t]=function(n,s,o,l,c,u){function f(){s.display!==r&&"none"!==s.display||!/Out$/.test(t)||$.each(c.nodeType?[c]:c,function(t,a){i.CSS.setPropertyValue(a,"display","none")}),s.complete&&s.complete.call(c,c),u&&u.resolver(c||n)}var p=o===l-1;a.defaultDuration="function"==typeof a.defaultDuration?a.defaultDuration.call(c,c):parseFloat(a.defaultDuration);for(var d=0;d<a.calls.length;d++){var g=a.calls[d],y=g[0],m=s.duration||a.defaultDuration||1e3,X=g[1],Y=g[2]||{},O={};if(O.duration=m*(X||1),O.queue=s.queue||"",O.easing=Y.easing||"ease",O.delay=parseFloat(Y.delay)||0,O._cacheValues=Y._cacheValues||!0,0===d){if(O.delay+=parseFloat(s.delay)||0,0===o&&(O.begin=function(){s.begin&&s.begin.call(c,c);var a=t.match(/(In|Out)$/);a&&"In"===a[0]&&y.opacity!==r&&$.each(c.nodeType?[c]:c,function(t,a){i.CSS.setPropertyValue(a,"opacity",0)}),s.animateParentHeight&&a&&e(c,a[0],m+O.delay,s.stagger)}),null!==s.display)if(s.display!==r&&"none"!==s.display)O.display=s.display;else if(/In$/.test(t)){var v=i.CSS.Values.getDisplayType(n);O.display="inline"===v?"inline-block":v}s.visibility&&"hidden"!==s.visibility&&(O.visibility=s.visibility)}d===a.calls.length-1&&(O.complete=function(){if(a.reset){for(var t in a.reset){var e=a.reset[t];i.CSS.Hooks.registered[t]!==r||"string"!=typeof e&&"number"!=typeof e||(a.reset[t]=[a.reset[t],a.reset[t]])}var s={duration:0,queue:!1};p&&(s.complete=f),i.animate(n,a.reset,s)}else p&&f()},"hidden"===s.visibility&&(O.visibility=s.visibility)),i.animate(n,y,O)}},i},i.RegisterEffect.packagedEffects={"callout.bounce":{defaultDuration:550,calls:[[{translateY:-30},.25],[{translateY:0},.125],[{translateY:-15},.125],[{translateY:0},.25]]},"callout.shake":{defaultDuration:800,calls:[[{translateX:-11},.125],[{translateX:11},.125],[{translateX:-11},.125],[{translateX:11},.125],[{translateX:-11},.125],[{translateX:11},.125],[{translateX:-11},.125],[{translateX:0},.125]]},"callout.flash":{defaultDuration:1100,calls:[[{opacity:[0,"easeInOutQuad",1]},.25],[{opacity:[1,"easeInOutQuad"]},.25],[{opacity:[0,"easeInOutQuad"]},.25],[{opacity:[1,"easeInOutQuad"]},.25]]},"callout.pulse":{defaultDuration:825,calls:[[{scaleX:1.1,scaleY:1.1},.5,{easing:"easeInExpo"}],[{scaleX:1,scaleY:1},.5]]},"callout.swing":{defaultDuration:950,calls:[[{rotateZ:15},.2],[{rotateZ:-10},.2],[{rotateZ:5},.2],[{rotateZ:-5},.2],[{rotateZ:0},.2]]},"callout.tada":{defaultDuration:1e3,calls:[[{scaleX:.9,scaleY:.9,rotateZ:-3},.1],[{scaleX:1.1,scaleY:1.1,rotateZ:3},.1],[{scaleX:1.1,scaleY:1.1,rotateZ:-3},.1],["reverse",.125],["reverse",.125],["reverse",.125],["reverse",.125],["reverse",.125],[{scaleX:1,scaleY:1,rotateZ:0},.2]]},"transition.fadeIn":{defaultDuration:500,calls:[[{opacity:[1,0]}]]},"transition.fadeOut":{defaultDuration:500,calls:[[{opacity:[0,1]}]]},"transition.flipXIn":{defaultDuration:700,calls:[[{opacity:[1,0],transformPerspective:[800,800],rotateY:[0,-55]}]],reset:{transformPerspective:0}},"transition.flipXOut":{defaultDuration:700,calls:[[{opacity:[0,1],transformPerspective:[800,800],rotateY:55}]],reset:{transformPerspective:0,rotateY:0}},"transition.flipYIn":{defaultDuration:800,calls:[[{opacity:[1,0],transformPerspective:[800,800],rotateX:[0,-45]}]],reset:{transformPerspective:0}},"transition.flipYOut":{defaultDuration:800,calls:[[{opacity:[0,1],transformPerspective:[800,800],rotateX:25}]],reset:{transformPerspective:0,rotateX:0}},"transition.flipBounceXIn":{defaultDuration:900,calls:[[{opacity:[.725,0],transformPerspective:[400,400],rotateY:[-10,90]},.5],[{opacity:.8,rotateY:10},.25],[{opacity:1,rotateY:0},.25]],reset:{transformPerspective:0}},"transition.flipBounceXOut":{defaultDuration:800,calls:[[{opacity:[.9,1],transformPerspective:[400,400],rotateY:-10},.5],[{opacity:0,rotateY:90},.5]],reset:{transformPerspective:0,rotateY:0}},"transition.flipBounceYIn":{defaultDuration:850,calls:[[{opacity:[.725,0],transformPerspective:[400,400],rotateX:[-10,90]},.5],[{opacity:.8,rotateX:10},.25],[{opacity:1,rotateX:0},.25]],reset:{transformPerspective:0}},"transition.flipBounceYOut":{defaultDuration:800,calls:[[{opacity:[.9,1],transformPerspective:[400,400],rotateX:-15},.5],[{opacity:0,rotateX:90},.5]],reset:{transformPerspective:0,rotateX:0}},"transition.swoopIn":{defaultDuration:850,calls:[[{opacity:[1,0],transformOriginX:["100%","50%"],transformOriginY:["100%","100%"],scaleX:[1,0],scaleY:[1,0],translateX:[0,-700],translateZ:0}]],reset:{transformOriginX:"50%",transformOriginY:"50%"}},"transition.swoopOut":{defaultDuration:850,calls:[[{opacity:[0,1],transformOriginX:["50%","100%"],transformOriginY:["100%","100%"],scaleX:0,scaleY:0,translateX:-700,translateZ:0}]],reset:{transformOriginX:"50%",transformOriginY:"50%",scaleX:1,scaleY:1,translateX:0}},"transition.whirlIn":{defaultDuration:850,calls:[[{opacity:[1,0],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:[1,0],scaleY:[1,0],rotateY:[0,160]},1,{easing:"easeInOutSine"}]]},"transition.whirlOut":{defaultDuration:750,calls:[[{opacity:[0,"easeInOutQuint",1],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:0,scaleY:0,rotateY:160},1,{easing:"swing"}]],reset:{scaleX:1,scaleY:1,rotateY:0}},"transition.shrinkIn":{defaultDuration:750,calls:[[{opacity:[1,0],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:[1,1.5],scaleY:[1,1.5],translateZ:0}]]},"transition.shrinkOut":{defaultDuration:600,calls:[[{opacity:[0,1],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:1.3,scaleY:1.3,translateZ:0}]],reset:{scaleX:1,scaleY:1}},"transition.expandIn":{defaultDuration:700,calls:[[{opacity:[1,0],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:[1,.625],scaleY:[1,.625],translateZ:0}]]},"transition.expandOut":{defaultDuration:700,calls:[[{opacity:[0,1],transformOriginX:["50%","50%"],transformOriginY:["50%","50%"],scaleX:.5,scaleY:.5,translateZ:0}]],reset:{scaleX:1,scaleY:1}},"transition.bounceIn":{defaultDuration:800,calls:[[{opacity:[1,0],scaleX:[1.05,.3],scaleY:[1.05,.3]},.4],[{scaleX:.9,scaleY:.9,translateZ:0},.2],[{scaleX:1,scaleY:1},.5]]},"transition.bounceOut":{defaultDuration:800,calls:[[{scaleX:.95,scaleY:.95},.35],[{scaleX:1.1,scaleY:1.1,translateZ:0},.35],[{opacity:[0,1],scaleX:.3,scaleY:.3},.3]],reset:{scaleX:1,scaleY:1}},"transition.bounceUpIn":{defaultDuration:800,calls:[[{opacity:[1,0],translateY:[-30,1e3]},.6,{easing:"easeOutCirc"}],[{translateY:10},.2],[{translateY:0},.2]]},"transition.bounceUpOut":{defaultDuration:1e3,calls:[[{translateY:20},.2],[{opacity:[0,"easeInCirc",1],translateY:-1e3},.8]],reset:{translateY:0}},"transition.bounceDownIn":{defaultDuration:800,calls:[[{opacity:[1,0],translateY:[30,-1e3]},.6,{easing:"easeOutCirc"}],[{translateY:-10},.2],[{translateY:0},.2]]},"transition.bounceDownOut":{defaultDuration:1e3,calls:[[{translateY:-20},.2],[{opacity:[0,"easeInCirc",1],translateY:1e3},.8]],reset:{translateY:0}},"transition.bounceLeftIn":{defaultDuration:750,calls:[[{opacity:[1,0],translateX:[30,-1250]},.6,{easing:"easeOutCirc"}],[{translateX:-10},.2],[{translateX:0},.2]]},"transition.bounceLeftOut":{defaultDuration:750,calls:[[{translateX:30},.2],[{opacity:[0,"easeInCirc",1],translateX:-1250},.8]],reset:{translateX:0}},"transition.bounceRightIn":{defaultDuration:750,calls:[[{opacity:[1,0],translateX:[-30,1250]},.6,{easing:"easeOutCirc"}],[{translateX:10},.2],[{translateX:0},.2]]},"transition.bounceRightOut":{defaultDuration:750,calls:[[{translateX:-30},.2],[{opacity:[0,"easeInCirc",1],translateX:1250},.8]],reset:{translateX:0}},"transition.slideUpIn":{defaultDuration:900,calls:[[{opacity:[1,0],translateY:[0,20],translateZ:0}]]},"transition.slideUpOut":{defaultDuration:900,calls:[[{opacity:[0,1],translateY:-20,translateZ:0}]],reset:{translateY:0}},"transition.slideDownIn":{defaultDuration:900,calls:[[{opacity:[1,0],translateY:[0,-20],translateZ:0}]]},"transition.slideDownOut":{defaultDuration:900,calls:[[{opacity:[0,1],translateY:20,translateZ:0}]],reset:{translateY:0}},"transition.slideLeftIn":{defaultDuration:1e3,calls:[[{opacity:[1,0],translateX:[0,-20],translateZ:0}]]},"transition.slideLeftOut":{defaultDuration:1050,calls:[[{opacity:[0,1],translateX:-20,translateZ:0}]],reset:{translateX:0}},"transition.slideRightIn":{defaultDuration:1e3,calls:[[{opacity:[1,0],translateX:[0,20],translateZ:0}]]},"transition.slideRightOut":{defaultDuration:1050,calls:[[{opacity:[0,1],translateX:20,translateZ:0}]],reset:{translateX:0}},"transition.slideUpBigIn":{defaultDuration:850,calls:[[{opacity:[1,0],translateY:[0,75],translateZ:0}]]},"transition.slideUpBigOut":{defaultDuration:800,calls:[[{opacity:[0,1],translateY:-75,translateZ:0}]],reset:{translateY:0}},"transition.slideDownBigIn":{defaultDuration:850,calls:[[{opacity:[1,0],translateY:[0,-75],translateZ:0}]]},"transition.slideDownBigOut":{defaultDuration:800,calls:[[{opacity:[0,1],translateY:75,translateZ:0}]],reset:{translateY:0}},"transition.slideLeftBigIn":{defaultDuration:800,calls:[[{opacity:[1,0],translateX:[0,-75],translateZ:0}]]},"transition.slideLeftBigOut":{defaultDuration:750,calls:[[{opacity:[0,1],translateX:-75,translateZ:0}]],reset:{translateX:0}},"transition.slideRightBigIn":{defaultDuration:800,calls:[[{opacity:[1,0],translateX:[0,75],translateZ:0}]]},"transition.slideRightBigOut":{defaultDuration:750,calls:[[{opacity:[0,1],translateX:75,translateZ:0}]],reset:{translateX:0}},"transition.perspectiveUpIn":{defaultDuration:800,calls:[[{opacity:[1,0],transformPerspective:[800,800],transformOriginX:[0,0],transformOriginY:["100%","100%"],rotateX:[0,-180]}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%"}},"transition.perspectiveUpOut":{defaultDuration:850,calls:[[{opacity:[0,1],transformPerspective:[800,800],transformOriginX:[0,0],transformOriginY:["100%","100%"],rotateX:-180}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%",rotateX:0}},"transition.perspectiveDownIn":{defaultDuration:800,calls:[[{opacity:[1,0],transformPerspective:[800,800],transformOriginX:[0,0],transformOriginY:[0,0],rotateX:[0,180]}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%"}},"transition.perspectiveDownOut":{defaultDuration:850,calls:[[{opacity:[0,1],transformPerspective:[800,800],transformOriginX:[0,0],transformOriginY:[0,0],rotateX:180}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%",rotateX:0}},"transition.perspectiveLeftIn":{defaultDuration:950,calls:[[{opacity:[1,0],transformPerspective:[2e3,2e3],transformOriginX:[0,0],transformOriginY:[0,0],rotateY:[0,-180]}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%"}},"transition.perspectiveLeftOut":{defaultDuration:950,calls:[[{opacity:[0,1],transformPerspective:[2e3,2e3],transformOriginX:[0,0],transformOriginY:[0,0],rotateY:-180}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%",rotateY:0}},"transition.perspectiveRightIn":{defaultDuration:950,calls:[[{opacity:[1,0],transformPerspective:[2e3,2e3],transformOriginX:["100%","100%"],transformOriginY:[0,0],rotateY:[0,180]}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%"}},"transition.perspectiveRightOut":{defaultDuration:950,calls:[[{opacity:[0,1],transformPerspective:[2e3,2e3],transformOriginX:["100%","100%"],transformOriginY:[0,0],rotateY:180}]],reset:{transformPerspective:0,transformOriginX:"50%",transformOriginY:"50%",rotateY:0}}};for(var c in i.RegisterEffect.packagedEffects)i.RegisterEffect(c,i.RegisterEffect.packagedEffects[c]);i.RunSequence=function(t){var a=$.extend(!0,[],t);a.length>1&&($.each(a.reverse(),function(t,e){var r=a[t+1];if(r){var n=e.o||e.options,s=r.o||r.options,o=n&&n.sequenceQueue===!1?"begin":"complete",l=s&&s[o],c={};c[o]=function(){var t=r.e||r.elements,a=t.nodeType?[t]:t;l&&l.call(a,a),i(e)},r.o?r.o=$.extend({},s,c):r.options=$.extend({},s,c)}}),a.reverse()),i(a[0])}}(window.jQuery||window.Zepto||window,window,document)});


--------------------------------------------------------------------------------