spider-src 0.1.5 → 0.1.6

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/dist/rsvp.min.js

@@ -0,0 +1,25 @@
+/*!
+ * @overview RSVP - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors
+ * @license   Licensed under MIT license
+ *            See https://raw.githubusercontent.com/tildeio/rsvp.js/master/LICENSE
+ * @version   3.0.14
+ */
+
+(function(){function M(a,b){if(a&&"object"===typeof a&&a.constructor===this)return a;var c=new this(s,b);q(c,a);return c}function y(a,b,c){1===C.push({name:a,H:{M:b.q+b.r,L:a,detail:b.b,K:c&&b.q+c.r,label:b.u,timeStamp:N(),stack:Error(b.u).stack}})&&setTimeout(function(){for(var a,b=0;b<C.length;b++)a=C[b],h.l(a.name,a.H);C.length=0},50)}function O(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1}function G(a){var b=a.v;b||(b=a.v={});return b}function P(a,b){if("onerror"===a)h.k("error",
+b);else if(2===arguments.length)h[a]=b;else return h[a]}function z(a){return"function"===typeof a}function Q(){}function s(){}function aa(a,b,c,d){try{a.call(b,c,d)}catch(e){return e}}function ba(a,b,c){h.async(function(a){var e=!1,f=aa(c,b,function(c){e||(e=!0,b!==c?q(a,c):p(a,c))},function(b){e||(e=!0,m(a,b))});!e&&f&&(e=!0,m(a,f))},a)}function ca(a,b){1===b.a?p(a,b.b):2===a.a?m(a,b.b):D(b,void 0,function(c){b!==c?q(a,c):p(a,c)},function(b){m(a,b)})}function q(a,b){if(a===b)p(a,b);else if("function"===
+typeof b||"object"===typeof b&&null!==b)if(b.constructor===a.constructor)ca(a,b);else{var c;try{c=b.then}catch(d){E.error=d,c=E}c===E?m(a,E.error):void 0===c?p(a,b):z(c)?ba(a,b,c):p(a,b)}else p(a,b)}function da(a){a.d&&a.d(a.b);H(a)}function p(a,b){void 0===a.a&&(a.b=b,a.a=1,0===a.i.length?h.g&&y("fulfilled",a):h.async(H,a))}function m(a,b){void 0===a.a&&(a.a=2,a.b=b,h.async(da,a))}function D(a,b,c,d){var e=a.i,f=e.length;a.d=null;e[f]=b;e[f+1]=c;e[f+2]=d;0===f&&a.a&&h.async(H,a)}function H(a){var b=
+a.i,c=a.a;h.g&&y(1===c?"fulfilled":"rejected",a);if(0!==b.length){for(var d,e,f=a.b,g=0;g<b.length;g+=3)d=b[g],e=b[g+c],d?R(c,d,e,f):e(f);a.i.length=0}}function S(){this.error=null}function R(a,b,c,d){var e=z(c),f,g,h,l;if(e){try{f=c(d)}catch(k){I.error=k,f=I}f===I?(l=!0,g=f.error,f=null):h=!0;if(b===f){m(b,new TypeError("A promises callback cannot return that same promise."));return}}else f=d,h=!0;void 0===b.a&&(e&&h?q(b,f):l?m(b,g):1===a?p(b,f):2===a&&m(b,f))}function ea(a,b){try{b(function(b){q(a,
+b)},function(b){m(a,b)})}catch(c){m(a,c)}}function T(a,b,c){return 1===a?{state:"fulfilled",value:c}:{state:"rejected",reason:c}}function k(a,b,c,d){this.B=a;this.c=new a(s,d);this.A=c;this.w(b)?(this.t=b,this.e=this.length=b.length,this.s(),0===this.length?p(this.c,this.b):(this.length=this.length||0,this.p(),0===this.e&&p(this.c,this.b))):m(this.c,this.j())}function r(a,b){this.r=fa++;this.u=b;this.b=this.a=void 0;this.i=[];h.g&&y("created",this);if(s!==a){if(!z(a))throw new TypeError("You must pass a resolver function as the first argument to the promise constructor");
+if(!(this instanceof r))throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");ea(this,a)}}function U(){this.value=void 0}function V(a,b,c){try{a.apply(b,c)}catch(d){return (w.value = d, w)}}function ga(a,b){return{then:function(c,d){return a.call(b,c,d)}}}function ha(a,b,c,d){b=V(c,d,b);b===w&&m(a,b.value);return a}function ia(a,b,c,d){return l.all(b).then(function(b){b=V(c,d,b);b===w&&m(a,b.value);return a})}function A(a,
+b,c){this.f(a,b,!1,c)}function t(a,b,c){this.f(a,b,!0,c)}function B(a,b,c){this.f(a,b,!1,c)}function ja(){return function(){process.N(F)}}function ka(){var a=0,b=new W(F),c=document.createTextNode("");b.observe(c,{characterData:!0});return function(){c.data=a=++a%2}}function la(){var a=new MessageChannel;a.port1.onmessage=F;return function(){a.port2.postMessage(0)}}function ma(){return function(){setTimeout(F,1)}}function F(){for(var a=0;a<u;a+=2)(0,x[a])(x[a+1]),x[a]=void 0,x[a+1]=void 0;u=0}function X(){h.k.apply(h,
+arguments)}var Y={G:function(a){a.k=this.k;a.n=this.n;a.l=this.l;a.v=void 0;return a},k:function(a,b){var c=G(this),d;(d=c[a])||(d=c[a]=[]);-1===O(d,b)&&d.push(b)},n:function(a,b){var c=G(this),d;b?(c=c[a],d=O(c,b),-1!==d&&c.splice(d,1)):c[a]=[]},l:function(a,b){var c,d;if(c=G(this)[a])for(var e=0;e<c.length;e++)d=c[e],d(b)}},h={g:!1};Y.G(h);var J=Array.isArray?Array.isArray:function(a){return"[object Array]"===Object.prototype.toString.call(a)},N=Date.now||function(){return(new Date).getTime()},
+n=Object.create||function(a){if(1<arguments.length)throw Error("Second argument not supported");if("object"!==typeof a)throw new TypeError("Argument must be an object");Q.prototype=a;return new Q},C=[],E=new S,I=new S;k.prototype.w=function(a){return J(a)};k.prototype.j=function(){return Error("Array Methods must be provided an Array")};k.prototype.s=function(){this.b=Array(this.length)};k.prototype.p=function(){for(var a=this.length,b=this.c,c=this.t,d=0;void 0===b.a&&d<a;d++)this.o(c[d],d)};k.prototype.o=
+function(a,b){var c=this.B;"object"===typeof a&&null!==a?a.constructor===c&&void 0!==a.a?(a.d=null,this.m(a.a,b,a.b)):this.C(c.resolve(a),b):(this.e--,this.b[b]=this.h(1,b,a))};k.prototype.m=function(a,b,c){var d=this.c;void 0===d.a&&(this.e--,this.A&&2===a?m(d,c):this.b[b]=this.h(a,b,c));0===this.e&&p(d,this.b)};k.prototype.h=function(a,b,c){return c};k.prototype.C=function(a,b){var c=this;D(a,void 0,function(a){c.m(1,b,a)},function(a){c.m(2,b,a)})};var na="rsvp_"+N()+"-",fa=0,l=r;r.J=M;r.all=function(a,
+b){return(new k(this,a,!0,b)).c};r.race=function(a,b){function c(a){q(e,a)}function d(a){m(e,a)}var e=new this(s,b);if(!J(a))return (m(e,new TypeError("You must pass an array to race.")), e);for(var f=a.length,g=0;void 0===e.a&&g<f;g++)D(this.resolve(a[g]),void 0,c,d);return e};r.resolve=M;r.reject=function(a,b){var c=new this(s,b);m(c,a);return c};r.prototype={constructor:r,q:na,d:function(a){h.l("error",a)},then:function(a,b,c){var d=this.a;if(1===d&&!a||2===d&&!b)return (h.g&&y("chained",this,this), this);this.d=null;var e=new this.constructor(s,c),f=this.b;h.g&&y("chained",this,e);if(d){var g=arguments[d-1];h.async(function(){R(d,e,g,f)})}else D(this,e,a,b);return e},"catch":function(a,b){return this.then(null,a,b)}};var w=new U,Z=new U;A.prototype=n(k.prototype);A.prototype.f=k;A.prototype.h=T;A.prototype.j=function(){return Error("allSettled must be called with an array")};t.prototype=n(k.prototype);t.prototype.f=k;t.prototype.s=function(){this.b={}};t.prototype.w=function(a){return a&&"object"===
+typeof a};t.prototype.j=function(){return Error("Promise.hash must be called with an object")};t.prototype.p=function(){var a=this.c,b=this.t,c=[],d;for(d in b)void 0===a.a&&b.hasOwnProperty(d)&&c.push({position:d,D:b[d]});this.e=b=c.length;for(var e=0;void 0===a.a&&e<b;e++)d=c[e],this.o(d.D,d.position)};B.prototype=n(t.prototype);B.prototype.f=k;B.prototype.h=T;B.prototype.j=function(){return Error("hashSettled must be called with an object")};var u=0,n="undefined"!==typeof window?window:{},W=n.MutationObserver||
+n.WebKitMutationObserver,n="undefined"!==typeof Uint8ClampedArray&&"undefined"!==typeof importScripts&&"undefined"!==typeof MessageChannel,x=Array(1E3),$;$="undefined"!==typeof process&&"[object process]"==={}.toString.call(process)?ja():W?ka():n?la():ma();h.async=function(a,b){x[u]=a;x[u+1]=b;u+=2;2===u&&$()};if("undefined"!==typeof window&&"object"===typeof window.__PROMISE_INSTRUMENTATION__){n=window.__PROMISE_INSTRUMENTATION__;P("instrument",!0);for(var K in n)n.hasOwnProperty(K)&&X(K,n[K])}var L=
+{race:function(a,b){return l.race(a,b)},Promise:l,allSettled:function(a,b){return(new A(l,a,b)).c},hash:function(a,b){return(new t(l,a,b)).c},hashSettled:function(a,b){return(new B(l,a,b)).c},denodeify:function(a,b){function c(){for(var c=arguments.length,e=Array(c+1),f,g=!1,h=0;h<c;++h){f=arguments[h];if(!g){if(f&&"object"===typeof f){var k;if(f.constructor===l)k=!0;else try{k=f.then}catch(n){w.value=n,k=w}g=k}else g=!1;if(g===Z)return (c=new l(s), m(c,Z.value), c);g&&!0!==g&&(f=ga(g,f))}e[h]=f}var v=
+new l(s);e[c]=function(a,c){if(a)m(v,a);else if(void 0===b)q(v,c);else if(!0===b){for(var d=arguments,e=d.length,f=Array(e-1),g=1;g<e;g++)f[g-1]=d[g];q(v,f)}else if(J(b)){for(var f=arguments,d={},g=f.length,e=Array(g),h=0;h<g;h++)e[h]=f[h];for(g=0;g<b.length;g++)f=b[g],d[f]=e[g+1];q(v,d)}else q(v,c)};return g?ia(v,e,a,this):ha(v,e,a,this)}c.__proto__=a;return c},on:X,off:function(){h.n.apply(h,arguments)},map:function(a,b,c){return l.all(a,c).then(function(a){if(!z(b))throw new TypeError("You must pass a function as map's second argument.");
+for(var e=a.length,f=Array(e),g=0;g<e;g++)f[g]=b(a[g]);return l.all(f,c)})},filter:function(a,b,c){return l.all(a,c).then(function(a){if(!z(b))throw new TypeError("You must pass a function as filter's second argument.");for(var e=a.length,f=Array(e),g=0;g<e;g++)f[g]=b(a[g]);return l.all(f,c).then(function(b){for(var c=Array(e),f=0,g=0;g<e;g++)b[g]&&(c[f]=a[g],f++);c.length=f;return c})})},resolve:function(a,b){return l.resolve(a,b)},reject:function(a,b){return l.reject(a,b)},all:function(a,b){return l.all(a,
+b)},rethrow:function(a){setTimeout(function(){throw a;});throw a;},defer:function(a){var b={};b.c=new l(function(a,d){b.resolve=a;b.reject=d},a);return b},EventTarget:Y,configure:P,async:function(a,b){h.async(a,b)}};"function"===typeof define&&define.I?define(function(){return L}):"undefined"!==typeof module&&module.F?module.F=L:"undefined"!==typeof this&&(this.RSVP=L)}).call(this);

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/calculateVersion.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var fs   = require('fs');
+var path = require('path');
+
+module.exports = function () {
+  var packageVersion = require('../package.json').version;
+  var output         = [packageVersion];
+  var gitPath        = path.join(__dirname,'..','.git');
+  var headFilePath   = path.join(gitPath, 'HEAD');
+
+  if (packageVersion.indexOf('+') > -1) {
+    try {
+      if (fs.existsSync(headFilePath)) {
+        var headFile = fs.readFileSync(headFilePath, {encoding: 'utf8'});
+        var branchName = headFile.split('/').slice(-1)[0].trim();
+        var refPath = headFile.split(' ')[1];
+        var branchSHA;
+
+        if (refPath) {
+          var branchPath = path.join(gitPath, refPath.trim());
+          branchSHA  = fs.readFileSync(branchPath);
+        } else {
+          branchSHA = branchName;
+        }
+
+        output.push(branchSHA.slice(0,10));
+      }
+    } catch (err) {
+      console.error(err.stack);
+    }
+    return output.join('.');
+  } else {
+    return packageVersion;
+  }
+};

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/-internal.js

@@ -0,0 +1,256 @@
+import {
+  objectOrFunction,
+  isFunction
+} from './utils';
+
+import instrument from './instrument';
+
+import { config } from './config';
+
+function noop() {}
+
+var PENDING   = void 0;
+var FULFILLED = 1;
+var REJECTED  = 2;
+
+var GET_THEN_ERROR = new ErrorObject();
+
+function getThen(promise) {
+  try {
+    return promise.then;
+  } catch(error) {
+    GET_THEN_ERROR.error = error;
+    return GET_THEN_ERROR;
+  }
+}
+
+function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
+  try {
+    then.call(value, fulfillmentHandler, rejectionHandler);
+  } catch(e) {
+    return e;
+  }
+}
+
+function handleForeignThenable(promise, thenable, then) {
+  config.async(function(promise) {
+    var sealed = false;
+    var error = tryThen(then, thenable, function(value) {
+      if (sealed) { return; }
+      sealed = true;
+      if (thenable !== value) {
+        resolve(promise, value);
+      } else {
+        fulfill(promise, value);
+      }
+    }, function(reason) {
+      if (sealed) { return; }
+      sealed = true;
+
+      reject(promise, reason);
+    }, 'Settle: ' + (promise._label || ' unknown promise'));
+
+    if (!sealed && error) {
+      sealed = true;
+      reject(promise, error);
+    }
+  }, promise);
+}
+
+function handleOwnThenable(promise, thenable) {
+  if (thenable._state === FULFILLED) {
+    fulfill(promise, thenable._result);
+  } else if (promise._state === REJECTED) {
+    reject(promise, thenable._result);
+  } else {
+    subscribe(thenable, undefined, function(value) {
+      if (thenable !== value) {
+        resolve(promise, value);
+      } else {
+        fulfill(promise, value);
+      }
+    }, function(reason) {
+      reject(promise, reason);
+    });
+  }
+}
+
+function handleMaybeThenable(promise, maybeThenable) {
+  if (maybeThenable.constructor === promise.constructor) {
+    handleOwnThenable(promise, maybeThenable);
+  } else {
+    var then = getThen(maybeThenable);
+
+    if (then === GET_THEN_ERROR) {
+      reject(promise, GET_THEN_ERROR.error);
+    } else if (then === undefined) {
+      fulfill(promise, maybeThenable);
+    } else if (isFunction(then)) {
+      handleForeignThenable(promise, maybeThenable, then);
+    } else {
+      fulfill(promise, maybeThenable);
+    }
+  }
+}
+
+function resolve(promise, value) {
+  if (promise === value) {
+    fulfill(promise, value);
+  } else if (objectOrFunction(value)) {
+    handleMaybeThenable(promise, value);
+  } else {
+    fulfill(promise, value);
+  }
+}
+
+function publishRejection(promise) {
+  if (promise._onerror) {
+    promise._onerror(promise._result);
+  }
+
+  publish(promise);
+}
+
+function fulfill(promise, value) {
+  if (promise._state !== PENDING) { return; }
+
+  promise._result = value;
+  promise._state = FULFILLED;
+
+  if (promise._subscribers.length === 0) {
+    if (config.instrument) {
+      instrument('fulfilled', promise);
+    }
+  } else {
+    config.async(publish, promise);
+  }
+}
+
+function reject(promise, reason) {
+  if (promise._state !== PENDING) { return; }
+  promise._state = REJECTED;
+  promise._result = reason;
+
+  config.async(publishRejection, promise);
+}
+
+function subscribe(parent, child, onFulfillment, onRejection) {
+  var subscribers = parent._subscribers;
+  var length = subscribers.length;
+
+  parent._onerror = null;
+
+  subscribers[length] = child;
+  subscribers[length + FULFILLED] = onFulfillment;
+  subscribers[length + REJECTED]  = onRejection;
+
+  if (length === 0 && parent._state) {
+    config.async(publish, parent);
+  }
+}
+
+function publish(promise) {
+  var subscribers = promise._subscribers;
+  var settled = promise._state;
+
+  if (config.instrument) {
+    instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
+  }
+
+  if (subscribers.length === 0) { return; }
+
+  var child, callback, detail = promise._result;
+
+  for (var i = 0; i < subscribers.length; i += 3) {
+    child = subscribers[i];
+    callback = subscribers[i + settled];
+
+    if (child) {
+      invokeCallback(settled, child, callback, detail);
+    } else {
+      callback(detail);
+    }
+  }
+
+  promise._subscribers.length = 0;
+}
+
+function ErrorObject() {
+  this.error = null;
+}
+
+var TRY_CATCH_ERROR = new ErrorObject();
+
+function tryCatch(callback, detail) {
+  try {
+    return callback(detail);
+  } catch(e) {
+    TRY_CATCH_ERROR.error = e;
+    return TRY_CATCH_ERROR;
+  }
+}
+
+function invokeCallback(settled, promise, callback, detail) {
+  var hasCallback = isFunction(callback),
+      value, error, succeeded, failed;
+
+  if (hasCallback) {
+    value = tryCatch(callback, detail);
+
+    if (value === TRY_CATCH_ERROR) {
+      failed = true;
+      error = value.error;
+      value = null;
+    } else {
+      succeeded = true;
+    }
+
+    if (promise === value) {
+      reject(promise, new TypeError('A promises callback cannot return that same promise.'));
+      return;
+    }
+
+  } else {
+    value = detail;
+    succeeded = true;
+  }
+
+  if (promise._state !== PENDING) {
+    // noop
+  } else if (hasCallback && succeeded) {
+    resolve(promise, value);
+  } else if (failed) {
+    reject(promise, error);
+  } else if (settled === FULFILLED) {
+    fulfill(promise, value);
+  } else if (settled === REJECTED) {
+    reject(promise, value);
+  }
+}
+
+function initializePromise(promise, resolver) {
+  try {
+    resolver(function resolvePromise(value){
+      resolve(promise, value);
+    }, function rejectPromise(reason) {
+      reject(promise, reason);
+    });
+  } catch(e) {
+    reject(promise, e);
+  }
+}
+
+export {
+  noop,
+  resolve,
+  reject,
+  fulfill,
+  subscribe,
+  publish,
+  publishRejection,
+  initializePromise,
+  invokeCallback,
+  FULFILLED,
+  REJECTED,
+  PENDING
+};

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/all-settled.js

@@ -0,0 +1,71 @@
+import Enumerator from './enumerator';
+import { makeSettledResult } from './enumerator';
+import Promise from './promise';
+import { o_create } from './utils';
+
+function AllSettled(Constructor, entries, label) {
+  this._superConstructor(Constructor, entries, false /* don't abort on reject */, label);
+}
+
+AllSettled.prototype = o_create(Enumerator.prototype);
+AllSettled.prototype._superConstructor = Enumerator;
+AllSettled.prototype._makeResult = makeSettledResult;
+AllSettled.prototype._validationError = function() {
+  return new Error('allSettled must be called with an array');
+};
+
+/**
+  `RSVP.allSettled` is similar to `RSVP.all`, but instead of implementing
+  a fail-fast method, it waits until all the promises have returned and
+  shows you all the results. This is useful if you want to handle multiple
+  promises' failure states together as a set.
+
+  Returns a promise that is fulfilled when all the given promises have been
+  settled. The return promise is fulfilled with an array of the states of
+  the promises passed into the `promises` array argument.
+
+  Each state object will either indicate fulfillment or rejection, and
+  provide the corresponding value or reason. The states will take one of
+  the following formats:
+
+  ```javascript
+  { state: 'fulfilled', value: value }
+    or
+  { state: 'rejected', reason: reason }
+  ```
+
+  Example:
+
+  ```javascript
+  var promise1 = RSVP.Promise.resolve(1);
+  var promise2 = RSVP.Promise.reject(new Error('2'));
+  var promise3 = RSVP.Promise.reject(new Error('3'));
+  var promises = [ promise1, promise2, promise3 ];
+
+  RSVP.allSettled(promises).then(function(array){
+    // array == [
+    //   { state: 'fulfilled', value: 1 },
+    //   { state: 'rejected', reason: Error },
+    //   { state: 'rejected', reason: Error }
+    // ]
+    // Note that for the second item, reason.message will be '2', and for the
+    // third item, reason.message will be '3'.
+  }, function(error) {
+    // Not run. (This block would only be called if allSettled had failed,
+    // for instance if passed an incorrect argument type.)
+  });
+  ```
+
+  @method allSettled
+  @static
+  @for RSVP
+  @param {Array} promises
+  @param {String} label - optional string that describes the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled with an array of the settled
+  states of the constituent promises.
+*/
+
+export default function allSettled(entries, label) {
+  return new AllSettled(Promise, entries, label).promise;
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/all.js

@@ -0,0 +1,15 @@
+import Promise from "./promise";
+
+/**
+  This is a convenient alias for `RSVP.Promise.all`.
+
+  @method all
+  @static
+  @for RSVP
+  @param {Array} array Array of promises.
+  @param {String} label An optional label. This is useful
+  for tooling.
+*/
+export default function all(array, label) {
+  return Promise.all(array, label);
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/asap.js

@@ -0,0 +1,82 @@
+var len = 0;
+
+export default function asap(callback, arg) {
+  queue[len] = callback;
+  queue[len + 1] = arg;
+  len += 2;
+  if (len === 2) {
+    // If len is 1, that means that we need to schedule an async flush.
+    // If additional callbacks are queued before the queue is flushed, they
+    // will be processed by this flush that we are scheduling.
+    scheduleFlush();
+  }
+}
+
+var browserGlobal = (typeof window !== 'undefined') ? window : {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+
+// test for web worker but not in IE10
+var isWorker = typeof Uint8ClampedArray !== 'undefined' &&
+  typeof importScripts !== 'undefined' &&
+  typeof MessageChannel !== 'undefined';
+
+// node
+function useNextTick() {
+  return function() {
+    process.nextTick(flush);
+  };
+}
+
+function useMutationObserver() {
+  var iterations = 0;
+  var observer = new BrowserMutationObserver(flush);
+  var node = document.createTextNode('');
+  observer.observe(node, { characterData: true });
+
+  return function() {
+    node.data = (iterations = ++iterations % 2);
+  };
+}
+
+// web worker
+function useMessageChannel() {
+  var channel = new MessageChannel();
+  channel.port1.onmessage = flush;
+  return function () {
+    channel.port2.postMessage(0);
+  };
+}
+
+function useSetTimeout() {
+  return function() {
+    setTimeout(flush, 1);
+  };
+}
+
+var queue = new Array(1000);
+function flush() {
+  for (var i = 0; i < len; i+=2) {
+    var callback = queue[i];
+    var arg = queue[i+1];
+
+    callback(arg);
+
+    queue[i] = undefined;
+    queue[i+1] = undefined;
+  }
+
+  len = 0;
+}
+
+var scheduleFlush;
+
+// Decide what async method to use to triggering processing of queued callbacks:
+if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
+  scheduleFlush = useNextTick();
+} else if (BrowserMutationObserver) {
+  scheduleFlush = useMutationObserver();
+} else if (isWorker) {
+  scheduleFlush = useMessageChannel();
+} else {
+  scheduleFlush = useSetTimeout();
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/config.js

@@ -0,0 +1,28 @@
+import EventTarget from './events';
+
+var config = {
+  instrument: false
+};
+
+EventTarget.mixin(config);
+
+function configure(name, value) {
+  if (name === 'onerror') {
+    // handle for legacy users that expect the actual
+    // error to be passed to their function added via
+    // `RSVP.configure('onerror', someFunctionHere);`
+    config.on('error', value);
+    return;
+  }
+
+  if (arguments.length === 2) {
+    config[name] = value;
+  } else {
+    return config[name];
+  }
+}
+
+export {
+  config,
+  configure
+};

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/defer.js

@@ -0,0 +1,45 @@
+import Promise from "./promise";
+
+/**
+  `RSVP.defer` returns an object similar to jQuery's `$.Deferred`.
+  `RSVP.defer` should be used when porting over code reliant on `$.Deferred`'s
+  interface. New code should use the `RSVP.Promise` constructor instead.
+
+  The object returned from `RSVP.defer` is a plain object with three properties:
+
+  * promise - an `RSVP.Promise`.
+  * reject - a function that causes the `promise` property on this object to
+    become rejected
+  * resolve - a function that causes the `promise` property on this object to
+    become fulfilled.
+
+  Example:
+
+   ```javascript
+   var deferred = RSVP.defer();
+
+   deferred.resolve("Success!");
+
+   defered.promise.then(function(value){
+     // value here is "Success!"
+   });
+   ```
+
+  @method defer
+  @static
+  @for RSVP
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @return {Object}
+ */
+
+export default function defer(label) {
+  var deferred = { };
+
+  deferred.promise = new Promise(function(resolve, reject) {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  }, label);
+
+  return deferred;
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/lib/rsvp/enumerator.js

@@ -0,0 +1,125 @@
+import {
+  isArray,
+  isMaybeThenable
+} from './utils';
+
+import {
+  noop,
+  reject,
+  fulfill,
+  subscribe,
+  FULFILLED,
+  REJECTED,
+  PENDING
+} from './-internal';
+
+export function makeSettledResult(state, position, value) {
+  if (state === FULFILLED) {
+    return {
+      state: 'fulfilled',
+      value: value
+    };
+  } else {
+    return {
+      state: 'rejected',
+      reason: value
+    };
+  }
+}
+
+function Enumerator(Constructor, input, abortOnReject, label) {
+  this._instanceConstructor = Constructor;
+  this.promise = new Constructor(noop, label);
+  this._abortOnReject = abortOnReject;
+
+  if (this._validateInput(input)) {
+    this._input     = input;
+    this.length     = input.length;
+    this._remaining = input.length;
+
+    this._init();
+
+    if (this.length === 0) {
+      fulfill(this.promise, this._result);
+    } else {
+      this.length = this.length || 0;
+      this._enumerate();
+      if (this._remaining === 0) {
+        fulfill(this.promise, this._result);
+      }
+    }
+  } else {
+    reject(this.promise, this._validationError());
+  }
+}
+
+Enumerator.prototype._validateInput = function(input) {
+  return isArray(input);
+};
+
+Enumerator.prototype._validationError = function() {
+  return new Error('Array Methods must be provided an Array');
+};
+
+Enumerator.prototype._init = function() {
+  this._result = new Array(this.length);
+};
+
+export default Enumerator;
+
+Enumerator.prototype._enumerate = function() {
+  var length  = this.length;
+  var promise = this.promise;
+  var input   = this._input;
+
+  for (var i = 0; promise._state === PENDING && i < length; i++) {
+    this._eachEntry(input[i], i);
+  }
+};
+
+Enumerator.prototype._eachEntry = function(entry, i) {
+  var c = this._instanceConstructor;
+  if (isMaybeThenable(entry)) {
+    if (entry.constructor === c && entry._state !== PENDING) {
+      entry._onerror = null;
+      this._settledAt(entry._state, i, entry._result);
+    } else {
+      this._willSettleAt(c.resolve(entry), i);
+    }
+  } else {
+    this._remaining--;
+    this._result[i] = this._makeResult(FULFILLED, i, entry);
+  }
+};
+
+Enumerator.prototype._settledAt = function(state, i, value) {
+  var promise = this.promise;
+
+  if (promise._state === PENDING) {
+    this._remaining--;
+
+    if (this._abortOnReject && state === REJECTED) {
+      reject(promise, value);
+    } else {
+      this._result[i] = this._makeResult(state, i, value);
+    }
+  }
+
+  if (this._remaining === 0) {
+    fulfill(promise, this._result);
+  }
+};
+
+Enumerator.prototype._makeResult = function(state, i, value) {
+  return value;
+};
+
+Enumerator.prototype._willSettleAt = function(promise, i) {
+  var enumerator = this;
+
+  subscribe(promise, undefined, function(value) {
+    enumerator._settledAt(FULFILLED, i, value);
+  }, function(reason) {
+    enumerator._settledAt(REJECTED, i, reason);
+  });
+};