Remove RSVP dependency and add all sections

dist/psd.js

 (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){
-var File, PSD;
+var File, Header, PSD, RSVP, fs;
+
+fs = require('fs');
+
+RSVP = require('rsvp');
 
 File = require('./psd/file.coffee');
 
+Header = require('./psd/header.coffee');
+
 module.exports = PSD = (function() {
+  PSD.fromFile = function(file) {
+    return new PSD(fs.readFileSync(file));
+  };
+
   function PSD(data) {
     this.file = new File(data);
+    this.parsed = false;
+    this.header = null;
   }
 
+  PSD.prototype.parse = function() {
+    return new RSVP.Promise((function(_this) {
+      return function(resolve, reject) {
+        if (_this.parsed) {
+          return resolve(_this);
+        }
+        return _this.parseHeader().then(function(header) {
+          _this.header = header;
+          return resolve(_this);
+        });
+      };
+    })(this));
+  };
+
+  PSD.prototype.parseHeader = function() {
+    return new Header(this.file).parse();
+  };
+
   return PSD;
 
 })();
 
 
-},{"./psd/file.coffee":2}],2:[function(require,module,exports){
-var File;
+},{"./psd/file.coffee":2,"./psd/header.coffee":3,"fs":29,"rsvp":5}],2:[function(require,module,exports){
+var File, jspack,
+  __hasProp = {}.hasOwnProperty;
+
+jspack = require('jspack').jspack;
 
 module.exports = File = (function() {
-  function File(data) {}
+  var FORMATS, format, info, _fn;
+
+  FORMATS = {
+    Int: {
+      code: '>i',
+      length: 4
+    },
+    UInt: {
+      code: '>I',
+      length: 4
+    },
+    Short: {
+      code: '>h',
+      length: 2
+    },
+    UShort: {
+      code: '>H',
+      length: 2
+    },
+    Float: {
+      code: '>f',
+      length: 4
+    },
+    Double: {
+      code: '>d',
+      length: 8
+    }
+  };
+
+  _fn = function(format, info) {
+    return File.prototype["read" + format] = function() {
+      return this.readf(info.code, info.length)[0];
+    };
+  };
+  for (format in FORMATS) {
+    if (!__hasProp.call(FORMATS, format)) continue;
+    info = FORMATS[format];
+    _fn(format, info);
+  }
+
+  function File(data) {
+    this.data = data;
+    this.pos = 0;
+  }
+
+  File.prototype.tell = function() {
+    return this.pos;
+  };
+
+  File.prototype.read = function(length) {
+    var data;
+    data = this.data.slice(this.pos, this.pos + length);
+    this.pos += length;
+    return data;
+  };
+
+  File.prototype.readf = function(format, len) {
+    if (len == null) {
+      len = null;
+    }
+    return jspack.Unpack(format, this.read(len || jspack.CalcLength(format)));
+  };
+
+  File.prototype.seek = function(amt, rel) {
+    if (rel == null) {
+      rel = false;
+    }
+    if (rel) {
+      return this.pos += amt;
+    } else {
+      return this.pos = amt;
+    }
+  };
+
+  File.prototype.readString = function(length) {
+    return this.read(length).toString();
+  };
 
   return File;
 
 })();
 
 
+},{"jspack":4}],3:[function(require,module,exports){
+var Header, RSVP;
+
+RSVP = require('rsvp');
+
+module.exports = Header = (function() {
+  function Header(file) {
+    this.file = file;
+    this.sig = null;
+    this.version = null;
+    this.channels = null;
+    this.rows = null;
+    this.cols = null;
+    this.depth = null;
+    this.mode = null;
+  }
+
+  Header.prototype.parse = function() {
+    return new RSVP.Promise((function(_this) {
+      return function(resolve, reject) {
+        var colorDataLen;
+        _this.sig = _this.file.readString(4);
+        _this.version = _this.file.readUShort();
+        _this.file.seek(6, true);
+        _this.channels = _this.file.readUShort();
+        _this.rows = _this.file.readUInt();
+        _this.cols = _this.file.readUInt();
+        _this.depth = _this.file.readUShort();
+        _this.mode = _this.file.readUShort();
+        colorDataLen = _this.file.readUInt();
+        _this.file.seek(colorDataLen, true);
+        return resolve(_this);
+      };
+    })(this));
+  };
+
+  return Header;
+
+})();
+
+
+},{"rsvp":5}],4:[function(require,module,exports){
+/*!
+ *  Copyright © 2008 Fair Oaks Labs, Inc.
+ *  All rights reserved.
+ */
+
+// Utility object:  Encode/Decode C-style binary primitives to/from octet arrays
+function JSPack()
+{
+	// Module-level (private) variables
+	var el,  bBE = false, m = this;
+
+
+	// Raw byte arrays
+	m._DeArray = function (a, p, l)
+	{
+		return [a.slice(p,p+l)];
+	};
+	m._EnArray = function (a, p, l, v)
+	{
+		for (var i = 0; i < l; a[p+i] = v[i]?v[i]:0, i++);
+	};
+
+	// ASCII characters
+	m._DeChar = function (a, p)
+	{
+		return String.fromCharCode(a[p]);
+	};
+	m._EnChar = function (a, p, v)
+	{
+		a[p] = v.charCodeAt(0);
+	};
+
+	// Little-endian (un)signed N-byte integers
+	m._DeInt = function (a, p)
+	{
+		var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, rv, i, f;
+		for (rv = 0, i = lsb, f = 1; i != stop; rv+=(a[p+i]*f), i+=nsb, f*=256);
+		if (el.bSigned && (rv & Math.pow(2, el.len*8-1))) { rv -= Math.pow(2, el.len*8); }
+		return rv;
+	};
+	m._EnInt = function (a, p, v)
+	{
+		var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, i;
+		v = (v<el.min)?el.min:(v>el.max)?el.max:v;
+		for (i = lsb; i != stop; a[p+i]=v&0xff, i+=nsb, v>>=8);
+	};
+
+	// ASCII character strings
+	m._DeString = function (a, p, l)
+	{
+		for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p+i]), i++);
+		return rv.join('');
+	};
+	m._EnString = function (a, p, l, v)
+	{
+		for (var t, i = 0; i < l; a[p+i] = (t=v.charCodeAt(i))?t:0, i++);
+	};
+
+	// Little-endian N-bit IEEE 754 floating point
+	m._De754 = function (a, p)
+	{
+		var s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;
+		mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;
+
+		i = bBE?0:(el.len-1); d = bBE?1:-1; s = a[p+i]; i+=d; nBits = -7;
+		for (e = s&((1<<(-nBits))-1), s>>=(-nBits), nBits += eLen; nBits > 0; e=e*256+a[p+i], i+=d, nBits-=8);
+		for (m = e&((1<<(-nBits))-1), e>>=(-nBits), nBits += mLen; nBits > 0; m=m*256+a[p+i], i+=d, nBits-=8);
+
+		switch (e)
+		{
+			case 0:
+				// Zero, or denormalized number
+				e = 1-eBias;
+				break;
+			case eMax:
+				// NaN, or +/-Infinity
+				return m?NaN:((s?-1:1)*Infinity);
+			default:
+				// Normalized number
+				m = m + Math.pow(2, mLen);
+				e = e - eBias;
+				break;
+		}
+		return (s?-1:1) * m * Math.pow(2, e-mLen);
+	};
+	m._En754 = function (a, p, v)
+	{
+		var s, e, m, i, d, c, mLen, eLen, eBias, eMax;
+		mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;
+
+		s = v<0?1:0;
+		v = Math.abs(v);
+		if (isNaN(v) || (v == Infinity))
+		{
+			m = isNaN(v)?1:0;
+			e = eMax;
+		}
+		else
+		{
+			e = Math.floor(Math.log(v)/Math.LN2);			// Calculate log2 of the value
+			if (v*(c = Math.pow(2, -e)) < 1) { e--; c*=2; }		// Math.log() isn't 100% reliable
+
+			// Round by adding 1/2 the significand's LSD
+			if (e+eBias >= 1) { v += el.rt/c; }			// Normalized:  mLen significand digits
+			else { v += el.rt*Math.pow(2, 1-eBias); } 		// Denormalized:  <= mLen significand digits
+			if (v*c >= 2) { e++; c/=2; }				// Rounding can increment the exponent
+
+			if (e+eBias >= eMax)
+			{
+				// Overflow
+				m = 0;
+				e = eMax;
+			}
+			else if (e+eBias >= 1)
+			{
+				// Normalized - term order matters, as Math.pow(2, 52-e) and v*Math.pow(2, 52) can overflow
+				m = (v*c-1)*Math.pow(2, mLen);
+				e = e + eBias;
+			}
+			else
+			{
+				// Denormalized - also catches the '0' case, somewhat by chance
+				m = v*Math.pow(2, eBias-1)*Math.pow(2, mLen);
+				e = 0;
+			}
+		}
+
+		for (i = bBE?(el.len-1):0, d=bBE?-1:1; mLen >= 8; a[p+i]=m&0xff, i+=d, m/=256, mLen-=8);
+		for (e=(e<<mLen)|m, eLen+=mLen; eLen > 0; a[p+i]=e&0xff, i+=d, e/=256, eLen-=8);
+		a[p+i-d] |= s*128;
+	};
+
+
+	// Class data
+	m._sPattern	= '(\\d+)?([AxcbBhHsfdiIlLqQ])';
+	m._lenLut	= {'A':1, 'x':1, 'c':1, 'b':1, 'B':1, 'h':2, 'H':2, 's':1, 'f':4, 'd':8, 'i':4, 'I':4, 'l':4, 'L':4, 'q':8, 'Q':8};
+	m._elLut	= {	'A': {en:m._EnArray, de:m._DeArray},
+				's': {en:m._EnString, de:m._DeString},
+				'c': {en:m._EnChar, de:m._DeChar},
+				'b': {en:m._EnInt, de:m._DeInt, len:1, bSigned:true, min:-Math.pow(2, 7), max:Math.pow(2, 7)-1},
+				'B': {en:m._EnInt, de:m._DeInt, len:1, bSigned:false, min:0, max:Math.pow(2, 8)-1},
+				'h': {en:m._EnInt, de:m._DeInt, len:2, bSigned:true, min:-Math.pow(2, 15), max:Math.pow(2, 15)-1},
+				'H': {en:m._EnInt, de:m._DeInt, len:2, bSigned:false, min:0, max:Math.pow(2, 16)-1},
+				'i': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},
+				'I': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},
+				'l': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},
+				'L': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},
+				'f': {en:m._En754, de:m._De754, len:4, mLen:23, rt:Math.pow(2, -24)-Math.pow(2, -77)},
+				'd': {en:m._En754, de:m._De754, len:8, mLen:52, rt:0},
+				'q': {en:m._EnInt, de:m._DeInt, len:8, bSigned:true, min:-Math.pow(2, 63), max:Math.pow(2, 63)-1},
+				'Q': {en:m._EnInt, de:m._DeInt, len:8, bSigned:false, min:0, max:Math.pow(2, 64)-1}};
+
+	// Unpack a series of n elements of size s from array a at offset p with fxn
+	m._UnpackSeries = function (n, s, a, p)
+	{
+		for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p+i*s)), i++);
+		return rv;
+	};
+
+	// Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
+	m._PackSeries = function (n, s, a, p, v, i)
+	{
+		for (var fxn = el.en, o = 0; o < n; fxn(a, p+o*s, v[i+o]), o++);
+	};
+
+	// Unpack the octet array a, beginning at offset p, according to the fmt string
+	m.Unpack = function (fmt, a, p)
+	{
+		// Set the private bBE flag based on the format string - assume big-endianness
+		bBE = (fmt.charAt(0) != '<');
+
+		p = p?p:0;
+		var re = new RegExp(this._sPattern, 'g'), m, n, s, rv = [];
+		while (m = re.exec(fmt))
+		{
+			n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
+			s = this._lenLut[m[2]];
+			if ((p + n*s) > a.length)
+			{
+				return undefined;
+			}
+			switch (m[2])
+			{
+				case 'A': case 's':
+					rv.push(this._elLut[m[2]].de(a, p, n));
+					break;
+				case 'c': case 'b': case 'B': case 'h': case 'H':
+				case 'i': case 'I': case 'l': case 'L': case 'f': case 'd': case 'q': case 'Q':
+					el = this._elLut[m[2]];
+					rv.push(this._UnpackSeries(n, s, a, p));
+					break;
+			}
+			p += n*s;
+		}
+		return Array.prototype.concat.apply([], rv);
+	};
+
+	// Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
+	m.PackTo = function (fmt, a, p, values)
+	{
+		// Set the private bBE flag based on the format string - assume big-endianness
+		bBE = (fmt.charAt(0) != '<');
+
+		var re = new RegExp(this._sPattern, 'g'), m, n, s, i = 0, j;
+		while (m = re.exec(fmt))
+		{
+			n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
+			s = this._lenLut[m[2]];
+			if ((p + n*s) > a.length)
+			{
+				return false;
+			}
+			switch (m[2])
+			{
+				case 'A': case 's':
+					if ((i + 1) > values.length) { return false; }
+					this._elLut[m[2]].en(a, p, n, values[i]);
+					i += 1;
+					break;
+				case 'c': case 'b': case 'B': case 'h': case 'H':
+				case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':
+					el = this._elLut[m[2]];
+					if ((i + n) > values.length) { return false; }
+					this._PackSeries(n, s, a, p, values, i);
+					i += n;
+					break;
+				case 'x':
+					for (j = 0; j < n; j++) { a[p+j] = 0; }
+					break;
+			}
+			p += n*s;
+		}
+		return a;
+	};
+
+	// Pack the supplied values into a new octet array, according to the fmt string
+	m.Pack = function (fmt, values)
+	{
+		return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values);
+	};
+
+	// Determine the number of bytes represented by the format string
+	m.CalcLength = function (fmt)
+	{
+		var re = new RegExp(this._sPattern, 'g'), m, sum = 0;
+		while (m = re.exec(fmt))
+		{
+			sum += (((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1])) * this._lenLut[m[2]];
+		}
+		return sum;
+	};
+};
+
+exports.jspack = new JSPack();
+
+},{}],5:[function(require,module,exports){
+"use strict";
+var Promise = require("./rsvp/promise")["default"];
+var EventTarget = require("./rsvp/events")["default"];
+var denodeify = require("./rsvp/node")["default"];
+var all = require("./rsvp/all")["default"];
+var allSettled = require("./rsvp/all-settled")["default"];
+var race = require("./rsvp/race")["default"];
+var hash = require("./rsvp/hash")["default"];
+var hashSettled = require("./rsvp/hash-settled")["default"];
+var rethrow = require("./rsvp/rethrow")["default"];
+var defer = require("./rsvp/defer")["default"];
+var config = require("./rsvp/config").config;
+var configure = require("./rsvp/config").configure;
+var map = require("./rsvp/map")["default"];
+var resolve = require("./rsvp/resolve")["default"];
+var reject = require("./rsvp/reject")["default"];
+var filter = require("./rsvp/filter")["default"];
+var asap = require("./rsvp/asap")["default"];
+
+config.async = asap; // default async is asap;
+
+function async(callback, arg) {
+  config.async(callback, arg);
+}
+
+function on() {
+  config.on.apply(config, arguments);
+}
+
+function off() {
+  config.off.apply(config, arguments);
+}
+
+// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
+if (typeof window !== 'undefined' && typeof window.__PROMISE_INSTRUMENTATION__ === 'object') {
+  var callbacks = window.__PROMISE_INSTRUMENTATION__;
+  configure('instrument', true);
+  for (var eventName in callbacks) {
+    if (callbacks.hasOwnProperty(eventName)) {
+      on(eventName, callbacks[eventName]);
+    }
+  }
+}
+
+exports.Promise = Promise;
+exports.EventTarget = EventTarget;
+exports.all = all;
+exports.allSettled = allSettled;
+exports.race = race;
+exports.hash = hash;
+exports.hashSettled = hashSettled;
+exports.rethrow = rethrow;
+exports.defer = defer;
+exports.denodeify = denodeify;
+exports.configure = configure;
+exports.on = on;
+exports.off = off;
+exports.resolve = resolve;
+exports.reject = reject;
+exports.async = async;
+exports.map = map;
+exports.filter = filter;
+},{"./rsvp/all":7,"./rsvp/all-settled":6,"./rsvp/asap":8,"./rsvp/config":9,"./rsvp/defer":10,"./rsvp/events":11,"./rsvp/filter":12,"./rsvp/hash":14,"./rsvp/hash-settled":13,"./rsvp/map":16,"./rsvp/node":17,"./rsvp/promise":18,"./rsvp/race":24,"./rsvp/reject":25,"./rsvp/resolve":26,"./rsvp/rethrow":27}],6:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+var isArray = require('./utils').isArray;
+var isNonThenable = require('./utils').isNonThenable;
+/**
+  `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.
+*/
+exports['default'] = function allSettled(entries, label) {
+    return new Promise(function (resolve, reject) {
+        if (!isArray(entries)) {
+            throw new TypeError('You must pass an array to allSettled.');
+        }
+        var remaining = entries.length;
+        var entry;
+        if (remaining === 0) {
+            resolve([]);
+            return;
+        }
+        var results = new Array(remaining);
+        function fulfilledResolver(index$2) {
+            return function (value) {
+                resolveAll(index$2, fulfilled(value));
+            };
+        }
+        function rejectedResolver(index$2) {
+            return function (reason) {
+                resolveAll(index$2, rejected(reason));
+            };
+        }
+        function resolveAll(index$2, value) {
+            results[index$2] = value;
+            if (--remaining === 0) {
+                resolve(results);
+            }
+        }
+        for (var index = 0; index < entries.length; index++) {
+            entry = entries[index];
+            if (isNonThenable(entry)) {
+                resolveAll(index, fulfilled(entry));
+            } else {
+                Promise.resolve(entry).then(fulfilledResolver(index), rejectedResolver(index));
+            }
+        }
+    }, label);
+};
+function fulfilled(value) {
+    return {
+        state: 'fulfilled',
+        value: value
+    };
+}
+function rejected(reason) {
+    return {
+        state: 'rejected',
+        reason: reason
+    };
+}
+},{"./promise":18,"./utils":28}],7:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+/**
+  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.
+*/
+exports['default'] = function all(array, label) {
+    return Promise.all(array, label);
+};
+},{"./promise":18}],8:[function(require,module,exports){
+(function (process){
+'use strict';
+exports['default'] = function asap(callback, arg) {
+    var length = queue.push([
+            callback,
+            arg
+        ]);
+    if (length === 1) {
+        // If length 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;
+// 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;
+    };
+}
+function useSetTimeout() {
+    return function () {
+        setTimeout(flush, 1);
+    };
+}
+var queue = [];
+function flush() {
+    for (var i = 0; i < queue.length; i++) {
+        var tuple = queue[i];
+        var callback = tuple[0], arg = tuple[1];
+        callback(arg);
+    }
+    queue.length = 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 {
+    scheduleFlush = useSetTimeout();
+}
+}).call(this,require("/usr/local/share/npm/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/usr/local/share/npm/lib/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":30}],9:[function(require,module,exports){
+'use strict';
+var EventTarget = require('./events')['default'];
+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];
+    }
+}
+exports.config = config;
+exports.configure = configure;
+},{"./events":11}],10:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+/**
+  `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}
+ */
+exports['default'] = function defer(label) {
+    var deferred = {};
+    deferred.promise = new Promise(function (resolve, reject) {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    }, label);
+    return deferred;
+};
+},{"./promise":18}],11:[function(require,module,exports){
+'use strict';
+function indexOf(callbacks, callback) {
+    for (var i = 0, l = callbacks.length; i < l; i++) {
+        if (callbacks[i] === callback) {
+            return i;
+        }
+    }
+    return -1;
+}
+function callbacksFor(object) {
+    var callbacks = object._promiseCallbacks;
+    if (!callbacks) {
+        callbacks = object._promiseCallbacks = {};
+    }
+    return callbacks;
+}
+/**
+  @class RSVP.EventTarget
+*/
+exports['default'] = {
+    mixin: function (object) {
+        object.on = this.on;
+        object.off = this.off;
+        object.trigger = this.trigger;
+        object._promiseCallbacks = undefined;
+        return object;
+    },
+    on: function (eventName, callback) {
+        var allCallbacks = callbacksFor(this), callbacks;
+        callbacks = allCallbacks[eventName];
+        if (!callbacks) {
+            callbacks = allCallbacks[eventName] = [];
+        }
+        if (indexOf(callbacks, callback) === -1) {
+            callbacks.push(callback);
+        }
+    },
+    off: function (eventName, callback) {
+        var allCallbacks = callbacksFor(this), callbacks, index;
+        if (!callback) {
+            allCallbacks[eventName] = [];
+            return;
+        }
+        callbacks = allCallbacks[eventName];
+        index = indexOf(callbacks, callback);
+        if (index !== -1) {
+            callbacks.splice(index, 1);
+        }
+    },
+    trigger: function (eventName, options) {
+        var allCallbacks = callbacksFor(this), callbacks, callbackTuple, callback, binding;
+        if (callbacks = allCallbacks[eventName]) {
+            // Don't cache the callbacks.length since it may grow
+            for (var i = 0; i < callbacks.length; i++) {
+                callback = callbacks[i];
+                callback(options);
+            }
+        }
+    }
+};
+},{}],12:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+var isFunction = require('./utils').isFunction;
+/**
+ `RSVP.filter` is similar to JavaScript's native `filter` method, except that it
+  waits for all promises to become fulfilled before running the `filterFn` on
+  each item in given to `promises`. `RSVP.filter` returns a promise that will
+  become fulfilled with the result of running `filterFn` on the values the
+  promises become fulfilled with.
+
+  For example:
+
+  ```javascript
+
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.resolve(2);
+  var promise3 = RSVP.resolve(3);
+
+  var filterFn = function(item){
+    return item > 1;
+  };
+
+  RSVP.filter(promises, filterFn).then(function(result){
+    // result is [ 2, 3 ]
+  });
+  ```
+
+  If any of the `promises` given to `RSVP.filter` are rejected, the first promise
+  that is rejected will be given as an argument to the returned promise's
+  rejection handler. For example:
+
+  ```javascript
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.reject(new Error("2"));
+  var promise3 = RSVP.reject(new Error("3"));
+  var promises = [ promise1, promise2, promise3 ];
+
+  var filterFn = function(item){
+    return item > 1;
+  };
+
+  RSVP.filter(promises, filterFn).then(function(array){
+    // Code here never runs because there are rejected promises!
+  }, function(reason) {
+    // reason.message === "2"
+  });
+  ```
+
+  `RSVP.filter` will also wait for any promises returned from `filterFn`.
+  For instance, you may want to fetch a list of users then return a subset
+  of those users based on some asynchronous operation:
+
+  ```javascript
+
+  var alice = { name: 'alice' };
+  var bob   = { name: 'bob' };
+  var users = [ alice, bob ];
+
+  var promises = users.map(function(user){
+    return RSVP.resolve(user);
+  });
+
+  var filterFn = function(user){
+    // Here, Alice has permissions to create a blog post, but Bob does not.
+    return getPrivilegesForUser(user).then(function(privs){
+      return privs.can_create_blog_post === true;
+    });
+  };
+  RSVP.filter(promises, filterFn).then(function(users){
+    // true, because the server told us only Alice can create a blog post.
+    users.length === 1;
+    // false, because Alice is the only user present in `users`
+    users[0] === bob;
+  });
+  ```
+
+  @method filter
+  @static
+  @for RSVP
+  @param {Array} promises
+  @param {Function} filterFn - function to be called on each resolved value to
+  filter the final results.
+  @param {String} label optional string describing the promise. Useful for
+  tooling.
+  @return {Promise}
+*/
+exports['default'] = function filter(promises, filterFn, label) {
+    return Promise.all(promises, label).then(function (values) {
+        if (!isFunction(filterFn)) {
+            throw new TypeError('You must pass a function as filter\'s second argument.');
+        }
+        var length = values.length;
+        var filtered = new Array(length);
+        for (var i = 0; i < length; i++) {
+            filtered[i] = filterFn(values[i]);
+        }
+        return Promise.all(filtered, label).then(function (filtered$2) {
+            var results = new Array(length);
+            var newLength = 0;
+            for (var i$2 = 0; i$2 < length; i$2++) {
+                if (filtered$2[i$2] === true) {
+                    results[newLength] = values[i$2];
+                    newLength++;
+                }
+            }
+            results.length = newLength;
+            return results;
+        });
+    });
+};
+},{"./promise":18,"./utils":28}],13:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+var isNonThenable = require('./utils').isNonThenable;
+var keysOf = require('./utils').keysOf;
+/**
+  `RSVP.hashSettled` is similar to `RSVP.allSettled`, but takes an object
+  instead of an array for its `promises` argument.
+
+  Unlike `RSVP.all` or `RSVP.hash`, which implement a fail-fast method,
+  but like `RSVP.allSettled`, `hashSettled` waits until all the
+  constituent promises have returned and then shows you all the results
+  with their states and values/reasons. 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, or rejected if the passed parameters are invalid.
+
+  The returned promise is fulfilled with a hash that has the same key names as
+  the `promises` object argument. If any of the values in the object are not
+  promises, they will be copied over to the fulfilled object and marked with state
+  'fulfilled'.
+
+  Example:
+
+  ```javascript
+  var promises = {
+    myPromise: RSVP.Promise.resolve(1),
+    yourPromise: RSVP.Promise.resolve(2),
+    theirPromise: RSVP.Promise.resolve(3),
+    notAPromise: 4
+  };
+
+  RSVP.hashSettled(promises).then(function(hash){
+    // hash here is an object that looks like:
+    // {
+    //   myPromise: { state: 'fulfilled', value: 1 },
+    //   yourPromise: { state: 'fulfilled', value: 2 },
+    //   theirPromise: { state: 'fulfilled', value: 3 },
+    //   notAPromise: { state: 'fulfilled', value: 4 }
+    // }
+  });
+  ```
+
+  If any of the `promises` given to `RSVP.hash` are rejected, the state will
+  be set to 'rejected' and the reason for rejection provided.
+
+  Example:
+
+  ```javascript
+  var promises = {
+    myPromise: RSVP.Promise.resolve(1),
+    rejectedPromise: RSVP.Promise.reject(new Error('rejection')),
+    anotherRejectedPromise: RSVP.Promise.reject(new Error('more rejection')),
+  };
+
+  RSVP.hashSettled(promises).then(function(hash){
+    // hash here is an object that looks like:
+    // {
+    //   myPromise:              { state: 'fulfilled', value: 1 },
+    //   rejectedPromise:        { state: 'rejected', reason: Error },
+    //   anotherRejectedPromise: { state: 'rejected', reason: Error },
+    // }
+    // Note that for rejectedPromise, reason.message == 'rejection',
+    // and for anotherRejectedPromise, reason.message == 'more rejection'.
+  });
+  ```
+
+  An important note: `RSVP.hashSettled` is intended for plain JavaScript objects that
+  are just a set of keys and values. `RSVP.hashSettled` will NOT preserve prototype
+  chains.
+
+  Example:
+
+  ```javascript
+  function MyConstructor(){
+    this.example = RSVP.Promise.resolve('Example');
+  }
+
+  MyConstructor.prototype = {
+    protoProperty: RSVP.Promise.resolve('Proto Property')
+  };
+
+  var myObject = new MyConstructor();
+
+  RSVP.hashSettled(myObject).then(function(hash){
+    // protoProperty will not be present, instead you will just have an
+    // object that looks like:
+    // {
+    //   example: { state: 'fulfilled', value: 'Example' }
+    // }
+    //
+    // hash.hasOwnProperty('protoProperty'); // false
+    // 'undefined' === typeof hash.protoProperty
+  });
+  ```
+
+  @method hashSettled
+  @for RSVP
+  @param {Object} promises
+  @param {String} label optional string that describes the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled when when all properties of `promises`
+  have been settled.
+  @static
+*/
+exports['default'] = function hashSettled(object, label) {
+    return new Promise(function (resolve, reject) {
+        var results = {};
+        var keys = keysOf(object);
+        var remaining = keys.length;
+        var entry, property;
+        if (remaining === 0) {
+            resolve(results);
+            return;
+        }
+        function fulfilledResolver(property$2) {
+            return function (value) {
+                resolveAll(property$2, fulfilled(value));
+            };
+        }
+        function rejectedResolver(property$2) {
+            return function (reason) {
+                resolveAll(property$2, rejected(reason));
+            };
+        }
+        function resolveAll(property$2, value) {
+            results[property$2] = value;
+            if (--remaining === 0) {
+                resolve(results);
+            }
+        }
+        for (var i = 0; i < keys.length; i++) {
+            property = keys[i];
+            entry = object[property];
+            if (isNonThenable(entry)) {
+                resolveAll(property, fulfilled(entry));
+            } else {
+                Promise.resolve(entry).then(fulfilledResolver(property), rejectedResolver(property));
+            }
+        }
+    });
+};
+function fulfilled(value) {
+    return {
+        state: 'fulfilled',
+        value: value
+    };
+}
+function rejected(reason) {
+    return {
+        state: 'rejected',
+        reason: reason
+    };
+}
+},{"./promise":18,"./utils":28}],14:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+var isNonThenable = require('./utils').isNonThenable;
+var keysOf = require('./utils').keysOf;
+/**
+  `RSVP.hash` is similar to `RSVP.all`, but takes an object instead of an array
+  for its `promises` argument.
+
+  Returns a promise that is fulfilled when all the given promises have been
+  fulfilled, or rejected if any of them become rejected. The returned promise
+  is fulfilled with a hash that has the same key names as the `promises` object
+  argument. If any of the values in the object are not promises, they will
+  simply be copied over to the fulfilled object.
+
+  Example:
+
+  ```javascript
+  var promises = {
+    myPromise: RSVP.resolve(1),
+    yourPromise: RSVP.resolve(2),
+    theirPromise: RSVP.resolve(3),
+    notAPromise: 4
+  };
+
+  RSVP.hash(promises).then(function(hash){
+    // hash here is an object that looks like:
+    // {
+    //   myPromise: 1,
+    //   yourPromise: 2,
+    //   theirPromise: 3,
+    //   notAPromise: 4
+    // }
+  });
+  ````
+
+  If any of the `promises` given to `RSVP.hash` are rejected, the first promise
+  that is rejected will be given as the reason to the rejection handler.
+
+  Example:
+
+  ```javascript
+  var promises = {
+    myPromise: RSVP.resolve(1),
+    rejectedPromise: RSVP.reject(new Error("rejectedPromise")),
+    anotherRejectedPromise: RSVP.reject(new Error("anotherRejectedPromise")),
+  };
+
+  RSVP.hash(promises).then(function(hash){
+    // Code here never runs because there are rejected promises!
+  }, function(reason) {
+    // reason.message === "rejectedPromise"
+  });
+  ```
+
+  An important note: `RSVP.hash` is intended for plain JavaScript objects that
+  are just a set of keys and values. `RSVP.hash` will NOT preserve prototype
+  chains.
+
+  Example:
+
+  ```javascript
+  function MyConstructor(){
+    this.example = RSVP.resolve("Example");
+  }
+
+  MyConstructor.prototype = {
+    protoProperty: RSVP.resolve("Proto Property")
+  };
+
+  var myObject = new MyConstructor();
+
+  RSVP.hash(myObject).then(function(hash){
+    // protoProperty will not be present, instead you will just have an
+    // object that looks like:
+    // {
+    //   example: "Example"
+    // }
+    //
+    // hash.hasOwnProperty('protoProperty'); // false
+    // 'undefined' === typeof hash.protoProperty
+  });
+  ```
+
+  @method hash
+  @static
+  @for RSVP
+  @param {Object} promises
+  @param {String} label optional string that describes the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled when all properties of `promises`
+  have been fulfilled, or rejected if any of them become rejected.
+*/
+exports['default'] = function hash(object, label) {
+    return new Promise(function (resolve, reject) {
+        var results = {};
+        var keys = keysOf(object);
+        var remaining = keys.length;
+        var entry, property;
+        if (remaining === 0) {
+            resolve(results);
+            return;
+        }
+        function fulfilledTo(property$2) {
+            return function (value) {
+                results[property$2] = value;
+                if (--remaining === 0) {
+                    resolve(results);
+                }
+            };
+        }
+        function onRejection(reason) {
+            remaining = 0;
+            reject(reason);
+        }
+        for (var i = 0; i < keys.length; i++) {
+            property = keys[i];
+            entry = object[property];
+            if (isNonThenable(entry)) {
+                results[property] = entry;
+                if (--remaining === 0) {
+                    resolve(results);
+                }
+            } else {
+                Promise.resolve(entry).then(fulfilledTo(property), onRejection);
+            }
+        }
+    });
+};
+},{"./promise":18,"./utils":28}],15:[function(require,module,exports){
+'use strict';
+var config = require('./config').config;
+var now = require('./utils').now;
+exports['default'] = function instrument(eventName, promise, child) {
+    // instrumentation should not disrupt normal usage.
+    try {
+        config.trigger(eventName, {
+            guid: promise._guidKey + promise._id,
+            eventName: eventName,
+            detail: promise._detail,
+            childGuid: child && promise._guidKey + child._id,
+            label: promise._label,
+            timeStamp: now(),
+            stack: new Error(promise._label).stack
+        });
+    } catch (error) {
+        setTimeout(function () {
+            throw error;
+        }, 0);
+    }
+};
+},{"./config":9,"./utils":28}],16:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+var isArray = require('./utils').isArray;
+var isFunction = require('./utils').isFunction;
+/**
+ `RSVP.map` is similar to JavaScript's native `map` method, except that it
+  waits for all promises to become fulfilled before running the `mapFn` on
+  each item in given to `promises`. `RSVP.map` returns a promise that will
+  become fulfilled with the result of running `mapFn` on the values the promises
+  become fulfilled with.
+
+  For example:
+
+  ```javascript
+
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.resolve(2);
+  var promise3 = RSVP.resolve(3);
+  var promises = [ promise1, promise2, promise3 ];
+
+  var mapFn = function(item){
+    return item + 1;
+  };
+
+  RSVP.map(promises, mapFn).then(function(result){
+    // result is [ 2, 3, 4 ]
+  });
+  ```
+
+  If any of the `promises` given to `RSVP.map` are rejected, the first promise
+  that is rejected will be given as an argument to the returned promise's
+  rejection handler. For example:
+
+  ```javascript
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.reject(new Error("2"));
+  var promise3 = RSVP.reject(new Error("3"));
+  var promises = [ promise1, promise2, promise3 ];
+
+  var mapFn = function(item){
+    return item + 1;
+  };
+
+  RSVP.map(promises, mapFn).then(function(array){
+    // Code here never runs because there are rejected promises!
+  }, function(reason) {
+    // reason.message === "2"
+  });
+  ```
+
+  `RSVP.map` will also wait if a promise is returned from `mapFn`. For example,
+  say you want to get all comments from a set of blog posts, but you need
+  the blog posts first becuase they contain a url to those comments.
+
+  ```javscript
+
+  var mapFn = function(blogPost){
+    // getComments does some ajax and returns an RSVP.Promise that is fulfilled
+    // with some comments data
+    return getComments(blogPost.comments_url);
+  };
+
+  // getBlogPosts does some ajax and returns an RSVP.Promise that is fulfilled
+  // with some blog post data
+  RSVP.map(getBlogPosts(), mapFn).then(function(comments){
+    // comments is the result of asking the server for the comments
+    // of all blog posts returned from getBlogPosts()
+  });
+  ```
+
+  @method map
+  @static
+  @for RSVP
+  @param {Array} promises
+  @param {Function} mapFn function to be called on each fulfilled promise.
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled with the result of calling
+  `mapFn` on each fulfilled promise or value when they become fulfilled.
+   The promise will be rejected if any of the given `promises` become rejected.
+  @static
+*/
+exports['default'] = function map(promises, mapFn, label) {
+    return Promise.all(promises, label).then(function (values) {
+        if (!isFunction(mapFn)) {
+            throw new TypeError('You must pass a function as map\'s second argument.');
+        }
+        var length = values.length;
+        var results = new Array(length);
+        for (var i = 0; i < length; i++) {
+            results[i] = mapFn(values[i]);
+        }
+        return Promise.all(results, label);
+    });
+};
+},{"./promise":18,"./utils":28}],17:[function(require,module,exports){
+'use strict';
+/* global  arraySlice */
+var Promise = require('./promise')['default'];
+var isArray = require('./utils').isArray;
+/**
+  `RSVP.denodeify` takes a "node-style" function and returns a function that
+  will return an `RSVP.Promise`. You can use `denodeify` in Node.js or the
+  browser when you'd prefer to use promises over using callbacks. For example,
+  `denodeify` transforms the following:
+
+  ```javascript
+  var fs = require('fs');
+
+  fs.readFile('myfile.txt', function(err, data){
+    if (err) return handleError(err);
+    handleData(data);
+  });
+  ```
+
+  into:
+
+  ```javascript
+  var fs = require('fs');
+  var readFile = RSVP.denodeify(fs.readFile);
+
+  readFile('myfile.txt').then(handleData, handleError);
+  ```
+
+  If the node function has multiple success parameters, then `denodeify`
+  just returns the first one:
+
+  ```javascript
+  var request = RSVP.denodeify(require('request'));
+
+  request('http://example.com').then(function(res) {
+    // ...
+  });
+  ```
+
+  However, if you need all success parameters, setting `denodeify`'s
+  second parameter to `true` causes it to return all success parameters
+  as an array:
+
+  ```javascript
+  var request = RSVP.denodeify(require('request'), true);
+
+  request('http://example.com').then(function(result) {
+    // result[0] -> res
+    // result[1] -> body
+  });
+  ```
+
+  Or if you pass it an array with names it returns the parameters as a hash:
+
+  ```javascript
+  var request = RSVP.denodeify(require('request'), ['res', 'body']);
+
+  request('http://example.com').then(function(result) {
+    // result.res
+    // result.body
+  });
+  ```
+
+  Sometimes you need to retain the `this`:
+
+  ```javascript
+  var app = require('express')();
+  var render = RSVP.denodeify(app.render.bind(app));
+  ```
+
+  The denodified function inherits from the original function. It works in all
+  environments, except IE 10 and below. Consequently all properties of the original
+  function are available to you. However, any properties you change on the
+  denodeified function won't be changed on the original function. Example:
+
+  ```javascript
+  var request = RSVP.denodeify(require('request')),
+      cookieJar = request.jar(); // <- Inheritance is used here
+
+  request('http://example.com', {jar: cookieJar}).then(function(res) {
+    // cookieJar.cookies holds now the cookies returned by example.com
+  });
+  ```
+
+  Using `denodeify` makes it easier to compose asynchronous operations instead
+  of using callbacks. For example, instead of:
+
+  ```javascript
+  var fs = require('fs');
+
+  fs.readFile('myfile.txt', function(err, data){
+    if (err) { ... } // Handle error
+    fs.writeFile('myfile2.txt', data, function(err){
+      if (err) { ... } // Handle error
+      console.log('done')
+    });
+  });
+  ```
+
+  you can chain the operations together using `then` from the returned promise:
+
+  ```javascript
+  var fs = require('fs');
+  var readFile = RSVP.denodeify(fs.readFile);
+  var writeFile = RSVP.denodeify(fs.writeFile);
+
+  readFile('myfile.txt').then(function(data){
+    return writeFile('myfile2.txt', data);
+  }).then(function(){
+    console.log('done')
+  }).catch(function(error){
+    // Handle error
+  });
+  ```
+
+  @method denodeify
+  @static
+  @for RSVP
+  @param {Function} nodeFunc a "node-style" function that takes a callback as
+  its last argument. The callback expects an error to be passed as its first
+  argument (if an error occurred, otherwise null), and the value from the
+  operation as its second argument ("function(err, value){ }").
+  @param {Boolean|Array} argumentNames An optional paramter that if set
+  to `true` causes the promise to fulfill with the callback's success arguments
+  as an array. This is useful if the node function has multiple success
+  paramters. If you set this paramter to an array with names, the promise will
+  fulfill with a hash with these names as keys and the success parameters as
+  values.
+  @return {Function} a function that wraps `nodeFunc` to return an
+  `RSVP.Promise`
+  @static
+*/
+exports['default'] = function denodeify(nodeFunc, argumentNames) {
+    var asArray = argumentNames === true;
+    var asHash = isArray(argumentNames);
+    function denodeifiedFunction() {
+        var length = arguments.length;
+        var nodeArgs = new Array(length);
+        for (var i = 0; i < length; i++) {
+            nodeArgs[i] = arguments[i];
+        }
+        var thisArg;
+        if (!asArray && !asHash && argumentNames) {
+            console.warn('Deprecation: RSVP.denodeify() doesn\'t allow setting the ' + '"this" binding anymore. Use yourFunction.bind(yourThis) instead.');
+            thisArg = argumentNames;
+        } else {
+            thisArg = this;
+        }
+        return Promise.all(nodeArgs).then(function (nodeArgs$2) {
+            return new Promise(resolver);
+            // sweet.js has a bug, this resolver can't be defined in the constructor
+            // or the arraySlice macro doesn't work
+            function resolver(resolve, reject) {
+                function callback() {
+                    var length$2 = arguments.length;
+                    var args = new Array(length$2);
+                    for (var i$2 = 0; i$2 < length$2; i$2++) {
+                        args[i$2] = arguments[i$2];
+                    }
+                    var error = args[0];
+                    var value = args[1];
+                    if (error) {
+                        reject(error);
+                    } else if (asArray) {
+                        resolve(args.slice(1));
+                    } else if (asHash) {
+                        var obj = {};
+                        var successArguments = args.slice(1);
+                        var name;
+                        var i$3;
+                        for (i$3 = 0; i$3 < argumentNames.length; i$3++) {
+                            name = argumentNames[i$3];
+                            obj[name] = successArguments[i$3];
+                        }
+                        resolve(obj);
+                    } else {
+                        resolve(value);
+                    }
+                }
+                nodeArgs$2.push(callback);
+                nodeFunc.apply(thisArg, nodeArgs$2);
+            }
+        });
+    }
+    denodeifiedFunction.__proto__ = nodeFunc;
+    return denodeifiedFunction;
+};
+},{"./promise":18,"./utils":28}],18:[function(require,module,exports){
+'use strict';
+var config = require('./config').config;
+var EventTarget = require('./events')['default'];
+var instrument = require('./instrument')['default'];
+var objectOrFunction = require('./utils').objectOrFunction;
+var isFunction = require('./utils').isFunction;
+var now = require('./utils').now;
+var cast = require('./promise/cast')['default'];
+var all = require('./promise/all')['default'];
+var race = require('./promise/race')['default'];
+var Resolve = require('./promise/resolve')['default'];
+var Reject = require('./promise/reject')['default'];
+var guidKey = 'rsvp_' + now() + '-';
+var counter = 0;
+function noop() {
+}
+exports['default'] = Promise;
+/**
+  Promise objects represent the eventual result of an asynchronous operation. The
+  primary way of interacting with a promise is through its `then` method, which
+  registers callbacks to receive either a promise’s eventual value or the reason
+  why the promise cannot be fulfilled.
+
+  Terminology
+  -----------
+
+  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+  - `thenable` is an object or function that defines a `then` method.
+  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+  - `exception` is a value that is thrown using the throw statement.
+  - `reason` is a value that indicates why a promise was rejected.
+  - `settled` the final resting state of a promise, fulfilled or rejected.
+
+  A promise can be in one of three states: pending, fulfilled, or rejected.
+
+  Promises that are fulfilled have a fulfillment value and are in the fulfilled
+  state.  Promises that are rejected have a rejection reason and are in the
+  rejected state.  A fulfillment value is never a thenable.
+
+  Promises can also be said to *resolve* a value.  If this value is also a
+  promise, then the original promise's settled state will match the value's
+  settled state.  So a promise that *resolves* a promise that rejects will
+  itself reject, and a promise that *resolves* a promise that fulfills will
+  itself fulfill.
+
+
+  Basic Usage:
+  ------------
+
+  ```js
+  var promise = new Promise(function(resolve, reject) {
+    // on success
+    resolve(value);
+
+    // on failure
+    reject(reason);
+  });
+
+  promise.then(function(value) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Advanced Usage:
+  ---------------
+
+  Promises shine when abstracting away asynchronous interactions such as
+  `XMLHttpRequest`s.
+
+  ```js
+  function getJSON(url) {
+    return new Promise(function(resolve, reject){
+      var xhr = new XMLHttpRequest();
+
+      xhr.open('GET', url);
+      xhr.onreadystatechange = handler;
+      xhr.responseType = 'json';
+      xhr.setRequestHeader('Accept', 'application/json');
+      xhr.send();
+
+      function handler() {
+        if (this.readyState === this.DONE) {
+          if (this.status === 200) {
+            resolve(this.response);
+          } else {
+            reject(new Error("getJSON: `" + url + "` failed with status: [" + this.status + "]");
+          }
+        }
+      };
+    });
+  }
+
+  getJSON('/posts.json').then(function(json) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Unlike callbacks, promises are great composable primitives.
+
+  ```js
+  Promise.all([
+    getJSON('/posts'),
+    getJSON('/comments')
+  ]).then(function(values){
+    values[0] // => postsJSON
+    values[1] // => commentsJSON
+
+    return values;
+  });
+  ```
+
+  @class RSVP.Promise
+  @param {function}
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @constructor
+*/
+function Promise(resolver, label) {
+    if (!isFunction(resolver)) {
+        throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+    }
+    if (!(this instanceof Promise)) {
+        throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
+    }
+    this._id = counter++;
+    this._label = label;
+    this._subscribers = [];
+    if (config.instrument) {
+        instrument('created', this);
+    }
+    if (noop !== resolver) {
+        invokeResolver(resolver, this);
+    }
+}
+function invokeResolver(resolver, promise) {
+    function resolvePromise(value) {
+        resolve(promise, value);
+    }
+    function rejectPromise(reason) {
+        reject(promise, reason);
+    }
+    try {
+        resolver(resolvePromise, rejectPromise);
+    } catch (e) {
+        rejectPromise(e);
+    }
+}
+Promise.cast = cast;
+Promise.all = all;
+Promise.race = race;
+Promise.resolve = Resolve;
+Promise.reject = Reject;
+var PENDING = void 0;
+var SEALED = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+function subscribe(parent, child, onFulfillment, onRejection) {
+    var subscribers = parent._subscribers;
+    var length = subscribers.length;
+    subscribers[length] = child;
+    subscribers[length + FULFILLED] = onFulfillment;
+    subscribers[length + REJECTED] = onRejection;
+}
+function publish(promise, settled) {
+    var child, callback, subscribers = promise._subscribers, detail = promise._detail;
+    if (config.instrument) {
+        instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
+    }
+    for (var i = 0; i < subscribers.length; i += 3) {
+        child = subscribers[i];
+        callback = subscribers[i + settled];
+        invokeCallback(settled, child, callback, detail);
+    }
+    promise._subscribers = null;
+}
+Promise.prototype = {
+    constructor: Promise,
+    _id: undefined,
+    _guidKey: guidKey,
+    _label: undefined,
+    _state: undefined,
+    _detail: undefined,
+    _subscribers: undefined,
+    _onerror: function (reason) {
+        config.trigger('error', reason);
+    },
+    then: function (onFulfillment, onRejection, label) {
+        var promise = this;
+        this._onerror = null;
+        var thenPromise = new this.constructor(noop, label);
+        if (this._state) {
+            var callbacks = arguments;
+            config.async(function invokePromiseCallback() {
+                invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
+            });
+        } else {
+            subscribe(this, thenPromise, onFulfillment, onRejection);
+        }
+        if (config.instrument) {
+            instrument('chained', promise, thenPromise);
+        }
+        return thenPromise;
+    },
+    'catch': function (onRejection, label) {
+        return this.then(null, onRejection, label);
+    },
+    'finally': function (callback, label) {
+        var constructor = this.constructor;
+        return this.then(function (value) {
+            return constructor.resolve(callback()).then(function () {
+                return value;
+            });
+        }, function (reason) {
+            return constructor.resolve(callback()).then(function () {
+                throw reason;
+            });
+        }, label);
+    }
+};
+function invokeCallback(settled, promise, callback, detail) {
+    var hasCallback = isFunction(callback), value, error, succeeded, failed;
+    if (hasCallback) {
+        try {
+            value = callback(detail);
+            succeeded = true;
+        } catch (e) {
+            failed = true;
+            error = e;
+        }
+    } else {
+        value = detail;
+        succeeded = true;
+    }
+    if (handleThenable(promise, value)) {
+        return;
+    } else if (hasCallback && succeeded) {
+        resolve(promise, value);
+    } else if (failed) {
+        reject(promise, error);
+    } else if (settled === FULFILLED) {
+        resolve(promise, value);
+    } else if (settled === REJECTED) {
+        reject(promise, value);
+    }
+}
+function handleThenable(promise, value) {
+    var then = null, resolved;
+    try {
+        if (promise === value) {
+            throw new TypeError('A promises callback cannot return that same promise.');
+        }
+        if (objectOrFunction(value)) {
+            then = value.then;
+            if (isFunction(then)) {
+                then.call(value, function (val) {
+                    if (resolved) {
+                        return true;
+                    }
+                    resolved = true;
+                    if (value !== val) {
+                        resolve(promise, val);
+                    } else {
+                        fulfill(promise, val);
+                    }
+                }, function (val) {
+                    if (resolved) {
+                        return true;
+                    }
+                    resolved = true;
+                    reject(promise, val);
+                }, 'Settle: ' + (promise._label || ' unknown promise'));
+                return true;
+            }
+        }
+    } catch (error) {
+        if (resolved) {
+            return true;
+        }
+        reject(promise, error);
+        return true;
+    }
+    return false;
+}
+function resolve(promise, value) {
+    if (promise === value) {
+        fulfill(promise, value);
+    } else if (!handleThenable(promise, value)) {
+        fulfill(promise, value);
+    }
+}
+function fulfill(promise, value) {
+    if (promise._state !== PENDING) {
+        return;
+    }
+    promise._state = SEALED;
+    promise._detail = value;
+    config.async(publishFulfillment, promise);
+}
+function reject(promise, reason) {
+    if (promise._state !== PENDING) {
+        return;
+    }
+    promise._state = SEALED;
+    promise._detail = reason;
+    config.async(publishRejection, promise);
+}
+function publishFulfillment(promise) {
+    publish(promise, promise._state = FULFILLED);
+}
+function publishRejection(promise) {
+    if (promise._onerror) {
+        promise._onerror(promise._detail);
+    }
+    publish(promise, promise._state = REJECTED);
+}
+},{"./config":9,"./events":11,"./instrument":15,"./promise/all":19,"./promise/cast":20,"./promise/race":21,"./promise/reject":22,"./promise/resolve":23,"./utils":28}],19:[function(require,module,exports){
+'use strict';
+var isArray = require('../utils').isArray;
+var isNonThenable = require('../utils').isNonThenable;
+/**
+  `RSVP.Promise.all` accepts an array of promises, and returns a new promise which
+  is fulfilled with an array of fulfillment values for the passed promises, or
+  rejected with the reason of the first passed promise to be rejected. It casts all
+  elements of the passed iterable to promises as it runs this algorithm.
+
+  Example:
+
+  ```javascript
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.resolve(2);
+  var promise3 = RSVP.resolve(3);
+  var promises = [ promise1, promise2, promise3 ];
+
+  RSVP.Promise.all(promises).then(function(array){
+    // The array here would be [ 1, 2, 3 ];
+  });
+  ```
+
+  If any of the `promises` given to `RSVP.all` are rejected, the first promise
+  that is rejected will be given as an argument to the returned promises's
+  rejection handler. For example:
+
+  Example:
+
+  ```javascript
+  var promise1 = RSVP.resolve(1);
+  var promise2 = RSVP.reject(new Error("2"));
+  var promise3 = RSVP.reject(new Error("3"));
+  var promises = [ promise1, promise2, promise3 ];
+
+  RSVP.Promise.all(promises).then(function(array){
+    // Code here never runs because there are rejected promises!
+  }, function(error) {
+    // error.message === "2"
+  });
+  ```
+
+  @method all
+  @static
+  @param {Array} entries array of promises
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled when all `promises` have been
+  fulfilled, or rejected if any of them become rejected.
+  @static
+*/
+exports['default'] = function all(entries, label) {
+    /*jshint validthis:true */
+    var Constructor = this;
+    return new Constructor(function (resolve, reject) {
+        if (!isArray(entries)) {
+            throw new TypeError('You must pass an array to all.');
+        }
+        var remaining = entries.length;
+        var results = new Array(remaining);
+        var entry, pending = true;
+        if (remaining === 0) {
+            resolve(results);
+            return;
+        }
+        function fulfillmentAt(index$2) {
+            return function (value) {
+                results[index$2] = value;
+                if (--remaining === 0) {
+                    resolve(results);
+                }
+            };
+        }
+        function onRejection(reason) {
+            remaining = 0;
+            reject(reason);
+        }
+        for (var index = 0; index < entries.length; index++) {
+            entry = entries[index];
+            if (isNonThenable(entry)) {
+                results[index] = entry;
+                if (--remaining === 0) {
+                    resolve(results);
+                }
+            } else {
+                Constructor.resolve(entry).then(fulfillmentAt(index), onRejection);
+            }
+        }
+    }, label);
+};
+},{"../utils":28}],20:[function(require,module,exports){
+'use strict';
+/**
+  @deprecated
+
+  `RSVP.Promise.cast` coerces its argument to a promise, or returns the
+  argument if it is already a promise which shares a constructor with the caster.
+
+  Example:
+
+  ```javascript
+  var promise = RSVP.Promise.resolve(1);
+  var casted = RSVP.Promise.cast(promise);
+
+  console.log(promise === casted); // true
+  ```
+
+  In the case of a promise whose constructor does not match, it is assimilated.
+  The resulting promise will fulfill or reject based on the outcome of the
+  promise being casted.
+
+  Example:
+
+  ```javascript
+  var thennable = $.getJSON('/api/foo');
+  var casted = RSVP.Promise.cast(thennable);
+
+  console.log(thennable === casted); // false
+  console.log(casted instanceof RSVP.Promise) // true
+
+  casted.then(function(data) {
+    // data is the value getJSON fulfills with
+  });
+  ```
+
+  In the case of a non-promise, a promise which will fulfill with that value is
+  returned.
+
+  Example:
+
+  ```javascript
+  var value = 1; // could be a number, boolean, string, undefined...
+  var casted = RSVP.Promise.cast(value);
+
+  console.log(value === casted); // false
+  console.log(casted instanceof RSVP.Promise) // true
+
+  casted.then(function(val) {
+    val === value // => true
+  });
+  ```
+
+  `RSVP.Promise.cast` is similar to `RSVP.Promise.resolve`, but `RSVP.Promise.cast` differs in the
+  following ways:
+
+  * `RSVP.Promise.cast` serves as a memory-efficient way of getting a promise, when you
+  have something that could either be a promise or a value. RSVP.resolve
+  will have the same effect but will create a new promise wrapper if the
+  argument is a promise.
+  * `RSVP.Promise.cast` is a way of casting incoming thenables or promise subclasses to
+  promises of the exact class specified, so that the resulting object's `then` is
+  ensured to have the behavior of the constructor you are calling cast on (i.e., RSVP.Promise).
+
+  @method cast
+  @static
+  @param {Object} object to be casted
+  @param {String} label optional string for labeling the promise.
+  Useful for tooling.
+  @return {Promise} promise
+*/
+exports['default'] = function cast(object, label) {
+    /*jshint validthis:true */
+    var Constructor = this;
+    if (object && typeof object === 'object' && object.constructor === Constructor) {
+        return object;
+    }
+    return new Constructor(function (resolve) {
+        resolve(object);
+    }, label);
+};
+},{}],21:[function(require,module,exports){
+'use strict';
+/* global toString */
+var isArray = require('../utils').isArray;
+var isFunction = require('../utils').isFunction;
+var isNonThenable = require('../utils').isNonThenable;
+/**
+  `RSVP.Promise.race` returns a new promise which is settled in the same way as the
+  first passed promise to settle.
+
+  Example:
+
+  ```javascript
+  var promise1 = new RSVP.Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve("promise 1");
+    }, 200);
+  });
+
+  var promise2 = new RSVP.Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve("promise 2");
+    }, 100);
+  });
+
+  RSVP.Promise.race([promise1, promise2]).then(function(result){
+    // result === "promise 2" because it was resolved before promise1
+    // was resolved.
+  });
+  ```
+
+  `RSVP.Promise.race` is deterministic in that only the state of the first
+  settled promise matters. For example, even if other promises given to the
+  `promises` array argument are resolved, but the first settled promise has
+  become rejected before the other promises became fulfilled, the returned
+  promise will become rejected:
+
+  ```javascript
+  var promise1 = new RSVP.Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve("promise 1");
+    }, 200);
+  });
+
+  var promise2 = new RSVP.Promise(function(resolve, reject){
+    setTimeout(function(){
+      reject(new Error("promise 2"));
+    }, 100);
+  });
+
+  RSVP.Promise.race([promise1, promise2]).then(function(result){
+    // Code here never runs
+  }, function(reason){
+    // reason.message === "promise2" because promise 2 became rejected before
+    // promise 1 became fulfilled
+  });
+  ```
+
+  An example real-world use case is implementing timeouts:
+
+  ```javascript
+  RSVP.Promise.race([ajax('foo.json'), timeout(5000)])
+  ```
+
+  @method race
+  @static
+  @param {Array} promises array of promises to observe
+  @param {String} label optional string for describing the promise returned.
+  Useful for tooling.
+  @return {Promise} a promise which settles in the same way as the first passed
+  promise to settle.
+*/
+exports['default'] = function race(entries, label) {
+    /*jshint validthis:true */
+    var Constructor = this, entry;
+    return new Constructor(function (resolve, reject) {
+        if (!isArray(entries)) {
+            throw new TypeError('You must pass an array to race.');
+        }
+        var pending = true;
+        function onFulfillment(value) {
+            if (pending) {
+                pending = false;
+                resolve(value);
+            }
+        }
+        function onRejection(reason) {
+            if (pending) {
+                pending = false;
+                reject(reason);
+            }
+        }
+        for (var i = 0; i < entries.length; i++) {
+            entry = entries[i];
+            if (isNonThenable(entry)) {
+                pending = false;
+                resolve(entry);
+                return;
+            } else {
+                Constructor.resolve(entry).then(onFulfillment, onRejection);
+            }
+        }
+    }, label);
+};
+},{"../utils":28}],22:[function(require,module,exports){
+'use strict';
+/**
+  `RSVP.Promise.reject` returns a promise rejected with the passed `reason`.
+  It is shorthand for the following:
+
+  ```javascript
+  var promise = new RSVP.Promise(function(resolve, reject){
+    reject(new Error('WHOOPS'));
+  });
+
+  promise.then(function(value){
+    // Code here doesn't run because the promise is rejected!
+  }, function(reason){
+    // reason.message === 'WHOOPS'
+  });
+  ```
+
+  Instead of writing the above, your code now simply becomes the following:
+
+  ```javascript
+  var promise = RSVP.Promise.reject(new Error('WHOOPS'));
+
+  promise.then(function(value){
+    // Code here doesn't run because the promise is rejected!
+  }, function(reason){
+    // reason.message === 'WHOOPS'
+  });
+  ```
+
+  @method reject
+  @static
+  @param {Any} reason value that the returned promise will be rejected with.
+  @param {String} label optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise rejected with the given `reason`.
+*/
+exports['default'] = function reject(reason, label) {
+    /*jshint validthis:true */
+    var Constructor = this;
+    return new Constructor(function (resolve, reject$2) {
+        reject$2(reason);
+    }, label);
+};
+},{}],23:[function(require,module,exports){
+'use strict';
+/**
+  `RSVP.Promise.resolve` returns a promise that will become resolved with the
+  passed `value`. It is shorthand for the following:
+
+  ```javascript
+  var promise = new RSVP.Promise(function(resolve, reject){
+    resolve(1);
+  });
+
+  promise.then(function(value){
+    // value === 1
+  });
+  ```
+
+  Instead of writing the above, your code now simply becomes the following:
+
+  ```javascript
+  var promise = RSVP.Promise.resolve(1);
+
+  promise.then(function(value){
+    // value === 1
+  });
+  ```
+
+  @method resolve
+  @static
+  @param {Any} value value that the returned promise will be resolved with
+  @param {String} label optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise that will become fulfilled with the given
+  `value`
+*/
+exports['default'] = function resolve(object, label) {
+    /*jshint validthis:true */
+    var Constructor = this;
+    if (object && typeof object === 'object' && object.constructor === Constructor) {
+        return object;
+    }
+    return new Constructor(function (resolve$2) {
+        resolve$2(object);
+    }, label);
+};
+},{}],24:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+/**
+  This is a convenient alias for `RSVP.Promise.race`.
+
+  @method race
+  @static
+  @for RSVP
+  @param {Array} array Array of promises.
+  @param {String} label An optional label. This is useful
+  for tooling.
+ */
+exports['default'] = function race(array, label) {
+    return Promise.race(array, label);
+};
+},{"./promise":18}],25:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+/**
+  This is a convenient alias for `RSVP.Promise.reject`.
+
+  @method reject
+  @static
+  @for RSVP
+  @param {Any} reason value that the returned promise will be rejected with.
+  @param {String} label optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise rejected with the given `reason`.
+*/
+exports['default'] = function reject(reason, label) {
+    return Promise.reject(reason, label);
+};
+},{"./promise":18}],26:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise')['default'];
+/**
+  This is a convenient alias for `RSVP.Promise.resolve`.
+
+  @method resolve
+  @static
+  @for RSVP
+  @param {Any} value value that the returned promise will be resolved with
+  @param {String} label optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise that will become fulfilled with the given
+  `value`
+*/
+exports['default'] = function resolve(value, label) {
+    return Promise.resolve(value, label);
+};
+},{"./promise":18}],27:[function(require,module,exports){
+'use strict';
+/**
+  `RSVP.rethrow` will rethrow an error on the next turn of the JavaScript event
+  loop in order to aid debugging.
+
+  Promises A+ specifies that any exceptions that occur with a promise must be
+  caught by the promises implementation and bubbled to the last handler. For
+  this reason, it is recommended that you always specify a second rejection
+  handler function to `then`. However, `RSVP.rethrow` will throw the exception
+  outside of the promise, so it bubbles up to your console if in the browser,
+  or domain/cause uncaught exception in Node. `rethrow` will also throw the
+  error again so the error can be handled by the promise per the spec.
+
+  ```javascript
+  function throws(){
+    throw new Error('Whoops!');
+  }
+
+  var promise = new RSVP.Promise(function(resolve, reject){
+    throws();
+  });
+
+  promise.catch(RSVP.rethrow).then(function(){
+    // Code here doesn't run because the promise became rejected due to an
+    // error!
+  }, function (err){
+    // handle the error here
+  });
+  ```
+
+  The 'Whoops' error will be thrown on the next turn of the event loop
+  and you can watch for it in your console. You can also handle it using a
+  rejection handler given to `.then` or `.catch` on the returned promise.
+
+  @method rethrow
+  @static
+  @for RSVP
+  @param {Error} reason reason the promise became rejected.
+  @throws Error
+  @static
+*/
+exports['default'] = function rethrow(reason) {
+    setTimeout(function () {
+        throw reason;
+    });
+    throw reason;
+};
+},{}],28:[function(require,module,exports){
+'use strict';
+function objectOrFunction(x) {
+    return typeof x === 'function' || typeof x === 'object' && x !== null;
+}
+exports.objectOrFunction = objectOrFunction;
+function isFunction(x) {
+    return typeof x === 'function';
+}
+exports.isFunction = isFunction;
+function isNonThenable(x) {
+    return !objectOrFunction(x);
+}
+exports.isNonThenable = isNonThenable;
+var _isArray;
+if (!Array.isArray) {
+    _isArray = function (x) {
+        return Object.prototype.toString.call(x) === '[object Array]';
+    };
+} else {
+    _isArray = Array.isArray;
+}
+var isArray = _isArray;
+exports.isArray = isArray;
+// Date.now is not available in browsers < IE9
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
+var now = Date.now || function () {
+        return new Date().getTime();
+    };
+exports.now = now;
+var keysOf = Object.keys || function (object) {
+        var result = [];
+        for (var prop in object) {
+            result.push(prop);
+        }
+        return result;
+    };
+exports.keysOf = keysOf;
+},{}],29:[function(require,module,exports){
+
+},{}],30:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+    var canSetImmediate = typeof window !== 'undefined'
+    && window.setImmediate;
+    var canPost = typeof window !== 'undefined'
+    && window.postMessage && window.addEventListener
+    ;
+
+    if (canSetImmediate) {
+        return function (f) { return window.setImmediate(f) };
+    }
+
+    if (canPost) {
+        var queue = [];
+        window.addEventListener('message', function (ev) {
+            var source = ev.source;
+            if ((source === window || source === null) && ev.data === 'process-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+
+        return function nextTick(fn) {
+            queue.push(fn);
+            window.postMessage('process-tick', '*');
+        };
+    }
+
+    return function nextTick(fn) {
+        setTimeout(fn, 0);
+    };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+function noop() {}
+
+process.on = noop;
+process.once = noop;
+process.off = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+
 },{}]},{},[1])
\ No newline at end of file

lib/psd.coffee

-fs    = require 'fs'
-RSVP  = require 'rsvp'
+fs        = require 'fs'
 
-File  = require './psd/file.coffee'
-Header = require './psd/header.coffee'
+File      = require './psd/file.coffee'
+Header    = require './psd/header.coffee'
+Resources = require './psd/resources.coffee'
+LayerMask = require './psd/layer_mask.coffee'
+Image     = require './psd/image.coffee'
 
 module.exports = class PSD
   @fromFile: (file) -> new PSD fs.readFileSync(file)
@@ -13,11 +15,27 @@ module.exports = class PSD
     @header = null
 
   parse: ->
-    new RSVP.Promise (resolve, reject) =>
-      return resolve(@) if @parsed
-      
-      @parseHeader().then (header) =>
-        @header = header
-        resolve(@)
-
-  parseHeader: -> new Header(@file).parse()
+    return if @parsed
+
+    @parseHeader()
+    @parseResources()
+    @parseLayerMask()
+    @parseImage()
+
+    @parsed = true
+
+  parseHeader: ->
+    @header = new Header(@file)
+    @header.parse()
+
+  parseResources: ->
+    @resources = new Resources(@file)
+    @resources.parse()
+
+  parseLayerMask: ->
+    @layerMask = new LayerMask(@file, @header)
+    @layerMask.parse()
+
+  parseImage: ->
+    @image = new Image(@file, @header)
+    @image.parse()
\ No newline at end of file

lib/psd/header.coffee

-RSVP = require ('rsvp')
-
 module.exports = class Header
+  # All of the color modes are stored internally as a short from 0-15.
+  # This is a mapping of that value to a human-readable name.
+  MODES = [
+    'Bitmap'
+    'GrayScale'
+    'IndexedColor'
+    'RGBColor'
+    'CMYKColor'
+    'HSLColor'
+    'HSBColor'
+    'Multichannel'
+    'Duotone'
+    'LabColor'
+    'Gray16'
+    'RGB48'
+    'Lab48'
+    'CMYK64'
+    'DeepMultichannel'
+    'Duotone16'
+  ]
+
   constructor: (@file) ->
     @sig = null
     @version = null
@@ -11,19 +30,25 @@ module.exports = class Header
     @mode = null
 
   parse: ->
-    new RSVP.Promise (resolve, reject) =>
-      @sig = @file.readString(4)
-      @version = @file.readUShort()
+    @sig = @file.readString(4)
+    @version = @file.readUShort()
+
+    @file.seek 6, true
+
+    @channels = @file.readUShort()
+    @rows = @file.readUInt()
+    @cols = @file.readUInt()
+    @depth = @file.readUShort()
+    @mode = @file.readUShort()
 
-      @file.seek 6, true
+    colorDataLen = @file.readUInt()
+    @file.seek colorDataLen, true
 
-      @channels = @file.readUShort()
-      @rows = @file.readUInt()
-      @cols = @file.readUInt()
-      @depth = @file.readUShort()
-      @mode = @file.readUShort()
+  modeName: -> MODES[@mode]
 
-      colorDataLen = @file.readUInt()
-      @file.seek colorDataLen, true
+  export: ->
+    data = {}
+    for key in ['sig', 'version', 'channels', 'rows', 'cols', 'depth', 'mode']
+      data[key] = @[key]
 
-      resolve(@)
+    data
\ No newline at end of file

lib/psd/image.coffee

+module.exports = class Image
+  constructor: (@file, @header) ->
+
+  parse: ->
+    
\ No newline at end of file

lib/psd/layer_mask.coffee

+Util = require('./util.coffee')
+
+module.exports = class LayerMask
+  constructor: (@file, @header) ->
+    @layers = []
+    @mergedAlpha = false
+    @globalMask = null
+
+  parse: ->
+    maskSize = @file.readInt()
+    finish = maskSize + @file.tell()
+    @file.seek finish
+    return
+
+    return if maskSize <= 0
+
+    layerInfoSize = Util.pad2 @file.readInt()
+
+    if layerInfoSize > 0
+      layerCount = @file.readShort()
+
+      if layerCount < 0
+        layerCount = Math.abs layerCount
+        @mergedAlpha = true
+

lib/psd/resources.coffee

+module.exports = class Resources
+  constructor: (@file) ->
+    @resources = {}
+    @typeIndex = {}
+    @length = null
+
+  parse: ->
+    @length = @file.readInt()
+    @file.seek @length, true
\ No newline at end of file

lib/psd/util.coffee

+module.exports = class Util
+  @pad2: (i) -> (i + 1) & ~0x01
+  @pad4: (i) -> ((i + 4) & ~0x03) - 1

package.json

@@ -3,7 +3,6 @@
   "version": "0.0.1",
   "dependencies": {
     "coffee-script": "~ 1.7.1",
-    "rsvp": "~ 3.0.6",
     "jspack": "~ 0.0.3"
   },
   "devDependencies": {