!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.collage=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,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.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = 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');
};

},{}],2:[function(_dereq_,module,exports){
(function (global){
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.BigSurface=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);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 _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
(function (global){
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.easyTween=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);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 _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
'use strict';

// Adapted from http://gizma.com/easing/ (which was created by Robert Penner)

exports.linear = function(currentTime, startValue, changeInValue, totalTime) {
	return changeInValue * currentTime / totalTime + startValue; 
};


exports.quadraticIn = function(currentTime, startValue, changeInValue, totalTime) {
	return changeInValue * (currentTime /= totalTime) * currentTime + startValue;
};

exports.quadraticOut = function(currentTime, startValue, changeInValue, totalTime) {
	return -changeInValue * (currentTime /= totalTime) * (currentTime - 2) + startValue;
};

exports.quadraticInOut = function(currentTime, startValue, changeInValue, totalTime) {
	currentTime /= totalTime / 2;
	
	if(currentTime < 1) return changeInValue / 2 * currentTime * currentTime + startValue;
	
	return -changeInValue / 2 * (--currentTime * (currentTime - 2) - 1) + startValue;
};

exports.cubicIn = function(currentTime, startValue, changeInValue, totalTime) {
	return changeInValue * (currentTime /= totalTime) * currentTime * currentTime + startValue;
};

exports.cubicOut = function(currentTime, startValue, changeInValue, totalTime) {
	currentTime /= totalTime;

	return changeInValue * (--currentTime * currentTime * currentTime + 1) + startValue;
};

exports.cubicInOut = function(currentTime, startValue, changeInValue, totalTime) {
	currentTime /= totalTime / 2;
	
	if(currentTime < 1) return changeInValue * (currentTime /= totalTime) * currentTime * currentTime + startValue;

	return changeInValue / 2 * ((currentTime -= 2) * currentTime * currentTime + 2) + startValue;
};


var HALF_PI = Math.PI / 2;
exports.sinusoidalIn = function(currentTime, startValue, changeInValue, totalTime) {
	return -changeInValue * Math.cos(currentTime / totalTime * HALF_PI) + changeInValue + startValue;
};

exports.sinusoidalOut = function(currentTime, startValue, changeInValue, totalTime) {
	return changeInValue * Math.sin(currentTime / totalTime * HALF_PI) + startValue;
};

exports.sinusoidalInOut = function(currentTime, startValue, changeInValue, totalTime){
	return -changeInValue / 2 * (Math.cos(Math.PI * currentTime / totalTime) - 1) + startValue;
};


exports.exponentialIn = function(currentTime, startValue, changeInValue, totalTime){
	return changeInValue * Math.pow(2, 10 * (currentTime / totalTime - 1)) + startValue;
};

exports.exponentialOut = function(currentTime, startValue, changeInValue, totalTime){
	return changeInValue * (-Math.pow(2, -10 * currentTime / totalTime) + 1) + startValue;
};

exports.exponentialInOut = function(currentTime, startValue, changeInValue, totalTime){
	currentTime /= totalTime / 2;
	
	if(currentTime < 1) return changeInValue / 2 * Math.pow(2, 10 * (currentTime -1))  + startValue;

	return changeInValue / 2 * (-Math.pow(2, -10 * --currentTime) + 2) + startValue;
};

},{}],2:[function(_dereq_,module,exports){
'use strict';

var tween = module.exports = function(easingFunc, obj, prop, targetValue, duration, callback){
	duration = duration || 0;
	
	var startValue = obj[prop],
		valueDiff = targetValue - startValue,
		startTime = Date.now(),
		pauseStart = startTime,
		paused = true,
		animationRequestId;

	function pause(){
		if(paused) return;
		paused = true;

		cancelAnimationFrame(animationRequestId);	
		pauseStart = Date.now();
	}

	function resume(){
		if(!paused) return;
		paused = false;

		startTime += Date.now() - pauseStart;
		
		animationRequestId = requestAnimationFrame(step);
	}

	function step(){
		var currentTime = Date.now() - startTime;

		if(currentTime < duration){
			obj[prop] = easingFunc(currentTime, startValue, valueDiff, duration);
			animationRequestId = requestAnimationFrame(step);
		} else {
			obj[prop] = easingFunc(duration, startValue, valueDiff, duration);
			if(callback) callback();
		}
	}

	resume();

	return {
		resume: resume,
		pause: pause
	};
};

// Bind easing helpers
var easing = _dereq_('./easing.js'),
	easingFuncName;

for(easingFuncName in easing){
	if(easing.hasOwnProperty(easingFuncName)){
		tween[easingFuncName] = tween.bind(void 0, easing[easingFuncName]);
	}
}

tween.easing = easing;
},{"./easing.js":1}]},{},[2])

(2)
});


}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],2:[function(_dereq_,module,exports){
/*!
 * EventEmitter v4.2.8 - git.io/ee
 * Oliver Caldwell
 * MIT license
 * @preserve
 */

(function () {
	'use strict';

	/**
	 * Class for managing events.
	 * Can be extended to provide event functionality in other classes.
	 *
	 * @class EventEmitter Manages event registering and emitting.
	 */
	function EventEmitter() {}

	// Shortcuts to improve speed and size
	var proto = EventEmitter.prototype;
	var exports = this;
	var originalGlobalValue = exports.EventEmitter;

	/**
	 * Finds the index of the listener for the event in its storage array.
	 *
	 * @param {Function[]} listeners Array of listeners to search through.
	 * @param {Function} listener Method to look for.
	 * @return {Number} Index of the specified listener, -1 if not found
	 * @api private
	 */
	function indexOfListener(listeners, listener) {
		var i = listeners.length;
		while (i--) {
			if (listeners[i].listener === listener) {
				return i;
			}
		}

		return -1;
	}

	/**
	 * Alias a method while keeping the context correct, to allow for overwriting of target method.
	 *
	 * @param {String} name The name of the target method.
	 * @return {Function} The aliased method
	 * @api private
	 */
	function alias(name) {
		return function aliasClosure() {
			return this[name].apply(this, arguments);
		};
	}

	/**
	 * Returns the listener array for the specified event.
	 * Will initialise the event object and listener arrays if required.
	 * Will return an object if you use a regex search. The object contains keys for each matched event. So /ba[rz]/ might return an object containing bar and baz. But only if you have either defined them with defineEvent or added some listeners to them.
	 * Each property in the object response is an array of listener functions.
	 *
	 * @param {String|RegExp} evt Name of the event to return the listeners from.
	 * @return {Function[]|Object} All listener functions for the event.
	 */
	proto.getListeners = function getListeners(evt) {
		var events = this._getEvents();
		var response;
		var key;

		// Return a concatenated array of all matching events if
		// the selector is a regular expression.
		if (evt instanceof RegExp) {
			response = {};
			for (key in events) {
				if (events.hasOwnProperty(key) && evt.test(key)) {
					response[key] = events[key];
				}
			}
		}
		else {
			response = events[evt] || (events[evt] = []);
		}

		return response;
	};

	/**
	 * Takes a list of listener objects and flattens it into a list of listener functions.
	 *
	 * @param {Object[]} listeners Raw listener objects.
	 * @return {Function[]} Just the listener functions.
	 */
	proto.flattenListeners = function flattenListeners(listeners) {
		var flatListeners = [];
		var i;

		for (i = 0; i < listeners.length; i += 1) {
			flatListeners.push(listeners[i].listener);
		}

		return flatListeners;
	};

	/**
	 * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful.
	 *
	 * @param {String|RegExp} evt Name of the event to return the listeners from.
	 * @return {Object} All listener functions for an event in an object.
	 */
	proto.getListenersAsObject = function getListenersAsObject(evt) {
		var listeners = this.getListeners(evt);
		var response;

		if (listeners instanceof Array) {
			response = {};
			response[evt] = listeners;
		}

		return response || listeners;
	};

	/**
	 * Adds a listener function to the specified event.
	 * The listener will not be added if it is a duplicate.
	 * If the listener returns true then it will be removed after it is called.
	 * If you pass a regular expression as the event name then the listener will be added to all events that match it.
	 *
	 * @param {String|RegExp} evt Name of the event to attach the listener to.
	 * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.addListener = function addListener(evt, listener) {
		var listeners = this.getListenersAsObject(evt);
		var listenerIsWrapped = typeof listener === 'object';
		var key;

		for (key in listeners) {
			if (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) {
				listeners[key].push(listenerIsWrapped ? listener : {
					listener: listener,
					once: false
				});
			}
		}

		return this;
	};

	/**
	 * Alias of addListener
	 */
	proto.on = alias('addListener');

	/**
	 * Semi-alias of addListener. It will add a listener that will be
	 * automatically removed after its first execution.
	 *
	 * @param {String|RegExp} evt Name of the event to attach the listener to.
	 * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.addOnceListener = function addOnceListener(evt, listener) {
		return this.addListener(evt, {
			listener: listener,
			once: true
		});
	};

	/**
	 * Alias of addOnceListener.
	 */
	proto.once = alias('addOnceListener');

	/**
	 * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad.
	 * You need to tell it what event names should be matched by a regex.
	 *
	 * @param {String} evt Name of the event to create.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.defineEvent = function defineEvent(evt) {
		this.getListeners(evt);
		return this;
	};

	/**
	 * Uses defineEvent to define multiple events.
	 *
	 * @param {String[]} evts An array of event names to define.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.defineEvents = function defineEvents(evts) {
		for (var i = 0; i < evts.length; i += 1) {
			this.defineEvent(evts[i]);
		}
		return this;
	};

	/**
	 * Removes a listener function from the specified event.
	 * When passed a regular expression as the event name, it will remove the listener from all events that match it.
	 *
	 * @param {String|RegExp} evt Name of the event to remove the listener from.
	 * @param {Function} listener Method to remove from the event.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.removeListener = function removeListener(evt, listener) {
		var listeners = this.getListenersAsObject(evt);
		var index;
		var key;

		for (key in listeners) {
			if (listeners.hasOwnProperty(key)) {
				index = indexOfListener(listeners[key], listener);

				if (index !== -1) {
					listeners[key].splice(index, 1);
				}
			}
		}

		return this;
	};

	/**
	 * Alias of removeListener
	 */
	proto.off = alias('removeListener');

	/**
	 * Adds listeners in bulk using the manipulateListeners method.
	 * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added.
	 * You can also pass it a regular expression to add the array of listeners to all events that match it.
	 * Yeah, this function does quite a bit. That's probably a bad thing.
	 *
	 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.
	 * @param {Function[]} [listeners] An optional array of listener functions to add.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.addListeners = function addListeners(evt, listeners) {
		// Pass through to manipulateListeners
		return this.manipulateListeners(false, evt, listeners);
	};

	/**
	 * Removes listeners in bulk using the manipulateListeners method.
	 * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
	 * You can also pass it an event name and an array of listeners to be removed.
	 * You can also pass it a regular expression to remove the listeners from all events that match it.
	 *
	 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.
	 * @param {Function[]} [listeners] An optional array of listener functions to remove.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.removeListeners = function removeListeners(evt, listeners) {
		// Pass through to manipulateListeners
		return this.manipulateListeners(true, evt, listeners);
	};

	/**
	 * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.
	 * The first argument will determine if the listeners are removed (true) or added (false).
	 * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
	 * You can also pass it an event name and an array of listeners to be added/removed.
	 * You can also pass it a regular expression to manipulate the listeners of all events that match it.
	 *
	 * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
	 * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.
	 * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.manipulateListeners = function manipulateListeners(remove, evt, listeners) {
		var i;
		var value;
		var single = remove ? this.removeListener : this.addListener;
		var multiple = remove ? this.removeListeners : this.addListeners;

		// If evt is an object then pass each of its properties to this method
		if (typeof evt === 'object' && !(evt instanceof RegExp)) {
			for (i in evt) {
				if (evt.hasOwnProperty(i) && (value = evt[i])) {
					// Pass the single listener straight through to the singular method
					if (typeof value === 'function') {
						single.call(this, i, value);
					}
					else {
						// Otherwise pass back to the multiple function
						multiple.call(this, i, value);
					}
				}
			}
		}
		else {
			// So evt must be a string
			// And listeners must be an array of listeners
			// Loop over it and pass each one to the multiple method
			i = listeners.length;
			while (i--) {
				single.call(this, evt, listeners[i]);
			}
		}

		return this;
	};

	/**
	 * Removes all listeners from a specified event.
	 * If you do not specify an event then all listeners will be removed.
	 * That means every event will be emptied.
	 * You can also pass a regex to remove all events that match it.
	 *
	 * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.removeEvent = function removeEvent(evt) {
		var type = typeof evt;
		var events = this._getEvents();
		var key;

		// Remove different things depending on the state of evt
		if (type === 'string') {
			// Remove all listeners for the specified event
			delete events[evt];
		}
		else if (evt instanceof RegExp) {
			// Remove all events matching the regex.
			for (key in events) {
				if (events.hasOwnProperty(key) && evt.test(key)) {
					delete events[key];
				}
			}
		}
		else {
			// Remove all listeners in all events
			delete this._events;
		}

		return this;
	};

	/**
	 * Alias of removeEvent.
	 *
	 * Added to mirror the node API.
	 */
	proto.removeAllListeners = alias('removeEvent');

	/**
	 * Emits an event of your choice.
	 * When emitted, every listener attached to that event will be executed.
	 * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
	 * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
	 * So they will not arrive within the array on the other side, they will be separate.
	 * You can also pass a regular expression to emit to all events that match it.
	 *
	 * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
	 * @param {Array} [args] Optional array of arguments to be passed to each listener.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.emitEvent = function emitEvent(evt, args) {
		var listeners = this.getListenersAsObject(evt);
		var listener;
		var i;
		var key;
		var response;

		for (key in listeners) {
			if (listeners.hasOwnProperty(key)) {
				i = listeners[key].length;

				while (i--) {
					// If the listener returns true then it shall be removed from the event
					// The function is executed either with a basic call or an apply if there is an args array
					listener = listeners[key][i];

					if (listener.once === true) {
						this.removeListener(evt, listener.listener);
					}

					response = listener.listener.apply(this, args || []);

					if (response === this._getOnceReturnValue()) {
						this.removeListener(evt, listener.listener);
					}
				}
			}
		}

		return this;
	};

	/**
	 * Alias of emitEvent
	 */
	proto.trigger = alias('emitEvent');

	/**
	 * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on.
	 * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.
	 *
	 * @param {String|RegExp} evt Name of the event to emit and execute listeners for.
	 * @param {...*} Optional additional arguments to be passed to each listener.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.emit = function emit(evt) {
		var args = Array.prototype.slice.call(arguments, 1);
		return this.emitEvent(evt, args);
	};

	/**
	 * Sets the current value to check against when executing listeners. If a
	 * listeners return value matches the one set here then it will be removed
	 * after execution. This value defaults to true.
	 *
	 * @param {*} value The new value to check for when executing listeners.
	 * @return {Object} Current instance of EventEmitter for chaining.
	 */
	proto.setOnceReturnValue = function setOnceReturnValue(value) {
		this._onceReturnValue = value;
		return this;
	};

	/**
	 * Fetches the current value to check against when executing listeners. If
	 * the listeners return value matches this one then it should be removed
	 * automatically. It will return true by default.
	 *
	 * @return {*|Boolean} The current value to check for or the default, true.
	 * @api private
	 */
	proto._getOnceReturnValue = function _getOnceReturnValue() {
		if (this.hasOwnProperty('_onceReturnValue')) {
			return this._onceReturnValue;
		}
		else {
			return true;
		}
	};

	/**
	 * Fetches the events object and creates one if required.
	 *
	 * @return {Object} The events storage object.
	 * @api private
	 */
	proto._getEvents = function _getEvents() {
		return this._events || (this._events = {});
	};

	/**
	 * Reverts the global {@link EventEmitter} to its previous value and returns a reference to this version.
	 *
	 * @return {Function} Non conflicting EventEmitter class.
	 */
	EventEmitter.noConflict = function noConflict() {
		exports.EventEmitter = originalGlobalValue;
		return EventEmitter;
	};

	// Expose the class either via AMD, CommonJS or the global object
	if (typeof define === 'function' && define.amd) {
		define(function () {
			return EventEmitter;
		});
	}
	else if (typeof module === 'object' && module.exports){
		module.exports = EventEmitter;
	}
	else {
		this.EventEmitter = EventEmitter;
	}
}.call(this));

},{}],3:[function(_dereq_,module,exports){
/*! Hammer.JS - v1.0.11 - 2014-05-20
 * http://eightmedia.github.io/hammer.js
 *
 * Copyright (c) 2014 Jorik Tangelder <j.tangelder@gmail.com>;
 * Licensed under the MIT license */

(function(window, undefined) {
  'use strict';

/**
 * Hammer
 * use this to create instances
 * @param   {HTMLElement}   element
 * @param   {Object}        options
 * @returns {Hammer.Instance}
 * @constructor
 */
var Hammer = function(element, options) {
  return new Hammer.Instance(element, options || {});
};

Hammer.VERSION = '1.0.11';

// default settings
Hammer.defaults = {
  // add styles and attributes to the element to prevent the browser from doing
  // its native behavior. this doesnt prevent the scrolling, but cancels
  // the contextmenu, tap highlighting etc
  // set to false to disable this
  stop_browser_behavior: {
    // this also triggers onselectstart=false for IE
    userSelect       : 'none',
    // this makes the element blocking in IE10> and Chrome 35>, you could experiment with the value
    // see for more options the wiki: https://github.com/EightMedia/hammer.js/wiki
    touchAction      : 'pan-y',

    touchCallout     : 'none',
    contentZooming   : 'none',
    userDrag         : 'none',
    tapHighlightColor: 'rgba(0,0,0,0)'
  }

  //
  // more settings are defined per gesture at /gestures
  //
};


// detect touchevents
Hammer.HAS_POINTEREVENTS = window.navigator.pointerEnabled || window.navigator.msPointerEnabled;
Hammer.HAS_TOUCHEVENTS = ('ontouchstart' in window);

// dont use mouseevents on mobile devices
Hammer.MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android|silk/i;
Hammer.NO_MOUSEEVENTS = Hammer.HAS_TOUCHEVENTS && window.navigator.userAgent.match(Hammer.MOBILE_REGEX);

// eventtypes per touchevent (start, move, end)
// are filled by Event.determineEventTypes on setup
Hammer.EVENT_TYPES = {};

// interval in which Hammer recalculates current velocity in ms
Hammer.UPDATE_VELOCITY_INTERVAL = 16;

// hammer document where the base events are added at
Hammer.DOCUMENT = window.document;

// define these also as vars, for better minification
// direction defines
var DIRECTION_DOWN = Hammer.DIRECTION_DOWN = 'down';
var DIRECTION_LEFT = Hammer.DIRECTION_LEFT = 'left';
var DIRECTION_UP = Hammer.DIRECTION_UP = 'up';
var DIRECTION_RIGHT = Hammer.DIRECTION_RIGHT = 'right';

// pointer type
var POINTER_MOUSE = Hammer.POINTER_MOUSE = 'mouse';
var POINTER_TOUCH = Hammer.POINTER_TOUCH = 'touch';
var POINTER_PEN = Hammer.POINTER_PEN = 'pen';

// touch event defines
var EVENT_START = Hammer.EVENT_START = 'start';
var EVENT_MOVE = Hammer.EVENT_MOVE = 'move';
var EVENT_END = Hammer.EVENT_END = 'end';


// plugins and gestures namespaces
Hammer.plugins = Hammer.plugins || {};
Hammer.gestures = Hammer.gestures || {};


// if the window events are set...
Hammer.READY = false;


/**
 * setup events to detect gestures on the document
 */
function setup() {
  if(Hammer.READY) {
    return;
  }

  // find what eventtypes we add listeners to
  Event.determineEventTypes();

  // Register all gestures inside Hammer.gestures
  Utils.each(Hammer.gestures, function(gesture){
    Detection.register(gesture);
  });

  // Add touch events on the document
  Event.onTouch(Hammer.DOCUMENT, EVENT_MOVE, Detection.detect);
  Event.onTouch(Hammer.DOCUMENT, EVENT_END, Detection.detect);

  // Hammer is ready...!
  Hammer.READY = true;
}


var Utils = Hammer.utils = {
  /**
   * extend method,
   * also used for cloning when dest is an empty object
   * @param   {Object}    dest
   * @param   {Object}    src
   * @parm  {Boolean}  merge    do a merge
   * @returns {Object}    dest
   */
  extend: function extend(dest, src, merge) {
    for(var key in src) {
      if(dest[key] !== undefined && merge) {
        continue;
      }
      dest[key] = src[key];
    }
    return dest;
  },


  /**
   * for each
   * @param obj
   * @param iterator
   */
  each: function each(obj, iterator, context) {
    var i, o;
    // native forEach on arrays
    if ('forEach' in obj) {
      obj.forEach(iterator, context);
    }
    // arrays
    else if(obj.length !== undefined) {
      for(i=-1; (o=obj[++i]);) {
        if (iterator.call(context, o, i, obj) === false) {
          return;
        }
      }
    }
    // objects
    else {
      for(i in obj) {
        if(obj.hasOwnProperty(i) &&
            iterator.call(context, obj[i], i, obj) === false) {
          return;
        }
      }
    }
  },


  /**
   * find if a string contains the needle
   * @param   {String}  src
   * @param   {String}  needle
   * @returns {Boolean} found
   */
  inStr: function inStr(src, needle) {
    return src.indexOf(needle) > -1;
  },


  /**
   * find if a node is in the given parent
   * used for event delegation tricks
   * @param   {HTMLElement}   node
   * @param   {HTMLElement}   parent
   * @returns {boolean}       has_parent
   */
  hasParent: function hasParent(node, parent) {
    while(node) {
      if(node == parent) {
        return true;
      }
      node = node.parentNode;
    }
    return false;
  },


  /**
   * get the center of all the touches
   * @param   {Array}     touches
   * @returns {Object}    center pageXY clientXY
   */
  getCenter: function getCenter(touches) {
    var pageX = []
      , pageY = []
      , clientX = []
      , clientY = []
      , min = Math.min
      , max = Math.max;

    // no need to loop when only one touch
    if(touches.length === 1) {
      return {
        pageX: touches[0].pageX,
        pageY: touches[0].pageY,
        clientX: touches[0].clientX,
        clientY: touches[0].clientY
      };
    }

    Utils.each(touches, function(touch) {
      pageX.push(touch.pageX);
      pageY.push(touch.pageY);
      clientX.push(touch.clientX);
      clientY.push(touch.clientY);
    });

    return {
      pageX: (min.apply(Math, pageX) + max.apply(Math, pageX)) / 2,
      pageY: (min.apply(Math, pageY) + max.apply(Math, pageY)) / 2,
      clientX: (min.apply(Math, clientX) + max.apply(Math, clientX)) / 2,
      clientY: (min.apply(Math, clientY) + max.apply(Math, clientY)) / 2
    };
  },


  /**
   * calculate the velocity between two points
   * @param   {Number}    delta_time
   * @param   {Number}    delta_x
   * @param   {Number}    delta_y
   * @returns {Object}    velocity
   */
  getVelocity: function getVelocity(delta_time, delta_x, delta_y) {
    return {
      x: Math.abs(delta_x / delta_time) || 0,
      y: Math.abs(delta_y / delta_time) || 0
    };
  },


  /**
   * calculate the angle between two coordinates
   * @param   {Touch}     touch1
   * @param   {Touch}     touch2
   * @returns {Number}    angle
   */
  getAngle: function getAngle(touch1, touch2) {
    var x = touch2.clientX - touch1.clientX
      , y = touch2.clientY - touch1.clientY;
    return Math.atan2(y, x) * 180 / Math.PI;
  },


  /**
   * angle to direction define
   * @param   {Touch}     touch1
   * @param   {Touch}     touch2
   * @returns {String}    direction constant, like DIRECTION_LEFT
   */
  getDirection: function getDirection(touch1, touch2) {
    var x = Math.abs(touch1.clientX - touch2.clientX)
      , y = Math.abs(touch1.clientY - touch2.clientY);
    if(x >= y) {
      return touch1.clientX - touch2.clientX > 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;
    }
    return touch1.clientY - touch2.clientY > 0 ? DIRECTION_UP : DIRECTION_DOWN;
  },


  /**
   * calculate the distance between two touches
   * @param   {Touch}     touch1
   * @param   {Touch}     touch2
   * @returns {Number}    distance
   */
  getDistance: function getDistance(touch1, touch2) {
    var x = touch2.clientX - touch1.clientX
      , y = touch2.clientY - touch1.clientY;
    return Math.sqrt((x * x) + (y * y));
  },


  /**
   * calculate the scale factor between two touchLists (fingers)
   * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
   * @param   {Array}     start
   * @param   {Array}     end
   * @returns {Number}    scale
   */
  getScale: function getScale(start, end) {
    // need two fingers...
    if(start.length >= 2 && end.length >= 2) {
      return this.getDistance(end[0], end[1]) / this.getDistance(start[0], start[1]);
    }
    return 1;
  },


  /**
   * calculate the rotation degrees between two touchLists (fingers)
   * @param   {Array}     start
   * @param   {Array}     end
   * @returns {Number}    rotation
   */
  getRotation: function getRotation(start, end) {
    // need two fingers
    if(start.length >= 2 && end.length >= 2) {
      return this.getAngle(end[1], end[0]) - this.getAngle(start[1], start[0]);
    }
    return 0;
  },


  /**
   * boolean if the direction is vertical
   * @param    {String}    direction
   * @returns  {Boolean}   is_vertical
   */
  isVertical: function isVertical(direction) {
    return direction == DIRECTION_UP || direction == DIRECTION_DOWN;
  },


  /**
   * toggle browser default behavior with css props
   * @param   {HtmlElement}   element
   * @param   {Object}        css_props
   * @param   {Boolean}       toggle
   */
  toggleDefaultBehavior: function toggleDefaultBehavior(element, css_props, toggle) {
    if(!css_props || !element || !element.style) {
      return;
    }

    // with css properties for modern browsers
    Utils.each(['webkit', 'moz', 'Moz', 'ms', 'o', ''], function setStyle(vendor) {
      Utils.each(css_props, function(value, prop) {
          // vender prefix at the property
          if(vendor) {
            prop = vendor + prop.substring(0, 1).toUpperCase() + prop.substring(1);
          }
          // set the style
          if(prop in element.style) {
            element.style[prop] = !toggle && value;
          }
      });
    });

    var false_fn = function(){ return false; };

    // also the disable onselectstart
    if(css_props.userSelect == 'none') {
      element.onselectstart = !toggle && false_fn;
    }
    // and disable ondragstart
    if(css_props.userDrag == 'none') {
      element.ondragstart = !toggle && false_fn;
    }
  }
};


/**
 * create new hammer instance
 * all methods should return the instance itself, so it is chainable.
 * @param   {HTMLElement}       element
 * @param   {Object}            [options={}]
 * @returns {Hammer.Instance}
 * @constructor
 */
Hammer.Instance = function(element, options) {
  var self = this;

  // setup HammerJS window events and register all gestures
  // this also sets up the default options
  setup();

  this.element = element;

  // start/stop detection option
  this.enabled = true;

  // merge options
  this.options = Utils.extend(
    Utils.extend({}, Hammer.defaults),
    options || {});

  // add some css to the element to prevent the browser from doing its native behavoir
  if(this.options.stop_browser_behavior) {
    Utils.toggleDefaultBehavior(this.element, this.options.stop_browser_behavior, false);
  }

  // start detection on touchstart
  this.eventStartHandler = Event.onTouch(element, EVENT_START, function(ev) {
    if(self.enabled) {
      Detection.startDetect(self, ev);
    }
  });

  // keep a list of user event handlers which needs to be removed when calling 'dispose'
  this.eventHandlers = [];

  // return instance
  return this;
};


Hammer.Instance.prototype = {
  /**
   * bind events to the instance
   * @param   {String}      gesture
   * @param   {Function}    handler
   * @returns {Hammer.Instance}
   */
  on: function onEvent(gesture, handler) {
    var gestures = gesture.split(' ');
    Utils.each(gestures, function(gesture) {
      this.element.addEventListener(gesture, handler, false);
      this.eventHandlers.push({ gesture: gesture, handler: handler });
    }, this);
    return this;
  },


  /**
   * unbind events to the instance
   * @param   {String}      gesture
   * @param   {Function}    handler
   * @returns {Hammer.Instance}
   */
  off: function offEvent(gesture, handler) {
    var gestures = gesture.split(' ')
      , i, eh;
    Utils.each(gestures, function(gesture) {
      this.element.removeEventListener(gesture, handler, false);

      // remove the event handler from the internal list
      for(i=-1; (eh=this.eventHandlers[++i]);) {
        if(eh.gesture === gesture && eh.handler === handler) {
          this.eventHandlers.splice(i, 1);
        }
      }
    }, this);
    return this;
  },


  /**
   * trigger gesture event
   * @param   {String}      gesture
   * @param   {Object}      [eventData]
   * @returns {Hammer.Instance}
   */
  trigger: function triggerEvent(gesture, eventData) {
    // optional
    if(!eventData) {
      eventData = {};
    }

    // create DOM event
    var event = Hammer.DOCUMENT.createEvent('Event');
    event.initEvent(gesture, true, true);
    event.gesture = eventData;

    // trigger on the target if it is in the instance element,
    // this is for event delegation tricks
    var element = this.element;
    if(Utils.hasParent(eventData.target, element)) {
      element = eventData.target;
    }

    element.dispatchEvent(event);
    return this;
  },


  /**
   * enable of disable hammer.js detection
   * @param   {Boolean}   state
   * @returns {Hammer.Instance}
   */
  enable: function enable(state) {
    this.enabled = state;
    return this;
  },


  /**
   * dispose this hammer instance
   * @returns {Hammer.Instance}
   */
  dispose: function dispose() {
    var i, eh;

    // undo all changes made by stop_browser_behavior
    if(this.options.stop_browser_behavior) {
      Utils.toggleDefaultBehavior(this.element, this.options.stop_browser_behavior, true);
    }

    // unbind all custom event handlers
    for(i=-1; (eh=this.eventHandlers[++i]);) {
      this.element.removeEventListener(eh.gesture, eh.handler, false);
    }
    this.eventHandlers = [];

    // unbind the start event listener
    Event.unbindDom(this.element, Hammer.EVENT_TYPES[EVENT_START], this.eventStartHandler);

    return null;
  }
};


/**
 * this holds the last move event,
 * used to fix empty touchend issue
 * see the onTouch event for an explanation
 * @type {Object}
 */
var last_move_event = null;

/**
 * when the mouse is hold down, this is true
 * @type {Boolean}
 */
var should_detect = false;

/**
 * when touch events have been fired, this is true
 * @type {Boolean}
 */
var touch_triggered = false;


var Event = Hammer.event = {
  /**
   * simple addEventListener
   * @param   {HTMLElement}   element
   * @param   {String}        type
   * @param   {Function}      handler
   */
  bindDom: function(element, type, handler) {
    var types = type.split(' ');
    Utils.each(types, function(type){
      element.addEventListener(type, handler, false);
    });
  },


  /**
   * simple removeEventListener
   * @param   {HTMLElement}   element
   * @param   {String}        type
   * @param   {Function}      handler
   */
  unbindDom: function(element, type, handler) {
    var types = type.split(' ');
    Utils.each(types, function(type){
      element.removeEventListener(type, handler, false);
    });
  },


  /**
   * touch events with mouse fallback
   * @param   {HTMLElement}   element
   * @param   {String}        eventType        like EVENT_MOVE
   * @param   {Function}      handler
   */
  onTouch: function onTouch(element, eventType, handler) {
    var self = this;


    var bindDomOnTouch = function bindDomOnTouch(ev) {
      var srcEventType = ev.type.toLowerCase();

      // onmouseup, but when touchend has been fired we do nothing.
      // this is for touchdevices which also fire a mouseup on touchend
      if(Utils.inStr(srcEventType, 'mouse') && touch_triggered) {
        return;
      }

      // mousebutton must be down or a touch event
      else if(Utils.inStr(srcEventType, 'touch') ||   // touch events are always on screen
        Utils.inStr(srcEventType, 'pointerdown') || // pointerevents touch
        (Utils.inStr(srcEventType, 'mouse') && ev.which === 1)   // mouse is pressed
        ) {
        should_detect = true;
      }

      // mouse isn't pressed
      else if(Utils.inStr(srcEventType, 'mouse') && !ev.which) {
        should_detect = false;
      }


      // we are in a touch event, set the touch triggered bool to true,
      // this for the conflicts that may occur on ios and android
      if(Utils.inStr(srcEventType, 'touch') || Utils.inStr(srcEventType, 'pointer')) {
        touch_triggered = true;
      }

      // count the total touches on the screen
      var count_touches = 0;

      // when touch has been triggered in this detection session
      // and we are now handling a mouse event, we stop that to prevent conflicts
      if(should_detect) {
        // update pointerevent
        if(Hammer.HAS_POINTEREVENTS && eventType != EVENT_END) {
          count_touches = PointerEvent.updatePointer(eventType, ev);
        }
        // touch
        else if(Utils.inStr(srcEventType, 'touch')) {
          count_touches = ev.touches.length;
        }
        // mouse
        else if(!touch_triggered) {
          count_touches = Utils.inStr(srcEventType, 'up') ? 0 : 1;
        }


        // if we are in a end event, but when we remove one touch and
        // we still have enough, set eventType to move
        if(count_touches > 0 && eventType == EVENT_END) {
          eventType = EVENT_MOVE;
        }
        // no touches, force the end event
        else if(!count_touches) {
          eventType = EVENT_END;
        }

        // store the last move event
        if(count_touches || last_move_event === null) {
          last_move_event = ev;
        }


        // trigger the handler
        handler.call(Detection, self.collectEventData(element, eventType,
                                  self.getTouchList(last_move_event, eventType),
                                  ev) );

        // remove pointerevent from list
        if(Hammer.HAS_POINTEREVENTS && eventType == EVENT_END) {
          count_touches = PointerEvent.updatePointer(eventType, ev);
        }
      }

      // on the end we reset everything
      if(!count_touches) {
        last_move_event = null;
        should_detect = false;
        touch_triggered = false;
        PointerEvent.reset();
      }
    };

    this.bindDom(element, Hammer.EVENT_TYPES[eventType], bindDomOnTouch);

    // return the bound function to be able to unbind it later
    return bindDomOnTouch;
  },


  /**
   * we have different events for each device/browser
   * determine what we need and set them in the Hammer.EVENT_TYPES constant
   */
  determineEventTypes: function determineEventTypes() {
    // determine the eventtype we want to set
    var types;

    // pointerEvents magic
    if(Hammer.HAS_POINTEREVENTS) {
      types = PointerEvent.getEvents();
    }
    // on Android, iOS, blackberry, windows mobile we dont want any mouseevents
    else if(Hammer.NO_MOUSEEVENTS) {
      types = [
        'touchstart',
        'touchmove',
        'touchend touchcancel'];
    }
    // for non pointer events browsers and mixed browsers,
    // like chrome on windows8 touch laptop
    else {
      types = [
        'touchstart mousedown',
        'touchmove mousemove',
        'touchend touchcancel mouseup'];
    }

    Hammer.EVENT_TYPES[EVENT_START] = types[0];
    Hammer.EVENT_TYPES[EVENT_MOVE] = types[1];
    Hammer.EVENT_TYPES[EVENT_END] = types[2];
  },


  /**
   * create touchlist depending on the event
   * @param   {Object}    ev
   * @param   {String}    eventType   used by the fakemultitouch plugin
   */
  getTouchList: function getTouchList(ev/*, eventType*/) {
    // get the fake pointerEvent touchlist
    if(Hammer.HAS_POINTEREVENTS) {
      return PointerEvent.getTouchList();
    }

    // get the touchlist
    if(ev.touches) {
      return ev.touches;
    }

    // make fake touchlist from mouse position
    ev.identifier = 1;
    return [ev];
  },


  /**
   * collect event data for Hammer js
   * @param   {HTMLElement}   element
   * @param   {String}        eventType        like EVENT_MOVE
   * @param   {Object}        eventData
   */
  collectEventData: function collectEventData(element, eventType, touches, ev) {
    // find out pointerType
    var pointerType = POINTER_TOUCH;
    if(Utils.inStr(ev.type, 'mouse') || PointerEvent.matchType(POINTER_MOUSE, ev)) {
      pointerType = POINTER_MOUSE;
    }

    return {
      center     : Utils.getCenter(touches),
      timeStamp  : Date.now(),
      target     : ev.target,
      touches    : touches,
      eventType  : eventType,
      pointerType: pointerType,
      srcEvent   : ev,

      /**
       * prevent the browser default actions
       * mostly used to disable scrolling of the browser
       */
      preventDefault: function() {
        var srcEvent = this.srcEvent;
        srcEvent.preventManipulation && srcEvent.preventManipulation();
        srcEvent.preventDefault && srcEvent.preventDefault();
      },

      /**
       * stop bubbling the event up to its parents
       */
      stopPropagation: function() {
        this.srcEvent.stopPropagation();
      },

      /**
       * immediately stop gesture detection
       * might be useful after a swipe was detected
       * @return {*}
       */
      stopDetect: function() {
        return Detection.stopDetect();
      }
    };
  }
};

var PointerEvent = Hammer.PointerEvent = {
  /**
   * holds all pointers
   * @type {Object}
   */
  pointers: {},

  /**
   * get a list of pointers
   * @returns {Array}     touchlist
   */
  getTouchList: function getTouchList() {
    var touchlist = [];
    // we can use forEach since pointerEvents only is in IE10
    Utils.each(this.pointers, function(pointer){
      touchlist.push(pointer);
    });

    return touchlist;
  },

  /**
   * update the position of a pointer
   * @param   {String}   type             EVENT_END
   * @param   {Object}   pointerEvent
   */
  updatePointer: function updatePointer(type, pointerEvent) {
    if(type == EVENT_END) {
      delete this.pointers[pointerEvent.pointerId];
    }
    else {
      pointerEvent.identifier = pointerEvent.pointerId;
      this.pointers[pointerEvent.pointerId] = pointerEvent;
    }

    // it's save to use Object.keys, since pointerEvents are only in newer browsers
    return Object.keys(this.pointers).length;
  },

  /**
   * check if ev matches pointertype
   * @param   {String}        pointerType     POINTER_MOUSE
   * @param   {PointerEvent}  ev
   */
  matchType: function matchType(pointerType, ev) {
    if(!ev.pointerType) {
      return false;
    }

    var pt = ev.pointerType
      , types = {};

    types[POINTER_MOUSE] = (pt === POINTER_MOUSE);
    types[POINTER_TOUCH] = (pt === POINTER_TOUCH);
    types[POINTER_PEN] = (pt === POINTER_PEN);
    return types[pointerType];
  },


  /**
   * get events
   */
  getEvents: function getEvents() {
    return [
      'pointerdown MSPointerDown',
      'pointermove MSPointerMove',
      'pointerup pointercancel MSPointerUp MSPointerCancel'
    ];
  },

  /**
   * reset the list
   */
  reset: function resetList() {
    this.pointers = {};
  }
};


var Detection = Hammer.detection = {
  // contains all registred Hammer.gestures in the correct order
  gestures: [],

  // data of the current Hammer.gesture detection session
  current : null,

  // the previous Hammer.gesture session data
  // is a full clone of the previous gesture.current object
  previous: null,

  // when this becomes true, no gestures are fired
  stopped : false,


  /**
   * start Hammer.gesture detection
   * @param   {Hammer.Instance}   inst
   * @param   {Object}            eventData
   */
  startDetect: function startDetect(inst, eventData) {
    // already busy with a Hammer.gesture detection on an element
    if(this.current) {
      return;
    }

    this.stopped = false;

    // holds current session
    this.current = {
      inst              : inst, // reference to HammerInstance we're working for
      startEvent        : Utils.extend({}, eventData), // start eventData for distances, timing etc
      lastEvent         : false, // last eventData
      lastVelocityEvent : false, // last eventData for velocity.
      velocity          : false, // current velocity
      name              : '' // current gesture we're in/detected, can be 'tap', 'hold' etc
    };

    this.detect(eventData);
  },


  /**
   * Hammer.gesture detection
   * @param   {Object}    eventData
   */
  detect: function detect(eventData) {
    if(!this.current || this.stopped) {
      return;
    }

    // extend event data with calculations about scale, distance etc
    eventData = this.extendEventData(eventData);

    // hammer instance and instance options
    var inst = this.current.inst,
        inst_options = inst.options;

    // call Hammer.gesture handlers
    Utils.each(this.gestures, function triggerGesture(gesture) {
      // only when the instance options have enabled this gesture
      if(!this.stopped && inst_options[gesture.name] !== false && inst.enabled !== false ) {
        // if a handler returns false, we stop with the detection
        if(gesture.handler.call(gesture, eventData, inst) === false) {
          this.stopDetect();
          return false;
        }
      }
    }, this);

    // store as previous event event
    if(this.current) {
      this.current.lastEvent = eventData;
    }

    // end event, but not the last touch, so dont stop
    if(eventData.eventType == EVENT_END && !eventData.touches.length - 1) {
      this.stopDetect();
    }

    return eventData;
  },


  /**
   * clear the Hammer.gesture vars
   * this is called on endDetect, but can also be used when a final Hammer.gesture has been detected
   * to stop other Hammer.gestures from being fired
   */
  stopDetect: function stopDetect() {
    // clone current data to the store as the previous gesture
    // used for the double tap gesture, since this is an other gesture detect session
    this.previous = Utils.extend({}, this.current);

    // reset the current
    this.current = null;

    // stopped!
    this.stopped = true;
  },


  /**
   * calculate velocity
   * @param   {Object}  ev
   * @param   {Number}  delta_time
   * @param   {Number}  delta_x
   * @param   {Number}  delta_y
   */
  getVelocityData: function getVelocityData(ev, delta_time, delta_x, delta_y) {
    var cur = this.current
      , velocityEv = cur.lastVelocityEvent
      , velocity = cur.velocity;

    // calculate velocity every x ms
    if (velocityEv && ev.timeStamp - velocityEv.timeStamp > Hammer.UPDATE_VELOCITY_INTERVAL) {
      velocity = Utils.getVelocity(ev.timeStamp - velocityEv.timeStamp,
                                   ev.center.clientX - velocityEv.center.clientX,
                                  ev.center.clientY - velocityEv.center.clientY);
      cur.lastVelocityEvent = ev;
    }
    else if(!cur.velocity) {
      velocity = Utils.getVelocity(delta_time, delta_x, delta_y);
      cur.lastVelocityEvent = ev;
    }

    cur.velocity = velocity;

    ev.velocityX = velocity.x;
    ev.velocityY = velocity.y;
  },


  /**
   * calculate interim angle and direction
   * @param   {Object}  ev
   */
  getInterimData: function getInterimData(ev) {
    var lastEvent = this.current.lastEvent
      , angle
      , direction;

    // end events (e.g. dragend) don't have useful values for interimDirection & interimAngle
    // because the previous event has exactly the same coordinates
    // so for end events, take the previous values of interimDirection & interimAngle
    // instead of recalculating them and getting a spurious '0'
    if(ev.eventType == EVENT_END) {
      angle = lastEvent && lastEvent.interimAngle;
      direction = lastEvent && lastEvent.interimDirection;
    }
    else {
      angle = lastEvent && Utils.getAngle(lastEvent.center, ev.center);
      direction = lastEvent && Utils.getDirection(lastEvent.center, ev.center);
    }

    ev.interimAngle = angle;
    ev.interimDirection = direction;
  },


  /**
   * extend eventData for Hammer.gestures
   * @param   {Object}   evData
   * @returns {Object}   evData
   */
  extendEventData: function extendEventData(ev) {
    var cur = this.current
      , startEv = cur.startEvent;

    // if the touches change, set the new touches over the startEvent touches
    // this because touchevents don't have all the touches on touchstart, or the
    // user must place his fingers at the EXACT same time on the screen, which is not realistic
    // but, sometimes it happens that both fingers are touching at the EXACT same time
    if(ev.touches.length != startEv.touches.length || ev.touches === startEv.touches) {
      // extend 1 level deep to get the touchlist with the touch objects
      startEv.touches = [];
      Utils.each(ev.touches, function(touch) {
        startEv.touches.push(Utils.extend({}, touch));
      });
    }

    var delta_time = ev.timeStamp - startEv.timeStamp
      , delta_x = ev.center.clientX - startEv.center.clientX
      , delta_y = ev.center.clientY - startEv.center.clientY;

    this.getVelocityData(ev, delta_time, delta_x, delta_y);
    this.getInterimData(ev);

    Utils.extend(ev, {
      startEvent: startEv,

      deltaTime : delta_time,
      deltaX    : delta_x,
      deltaY    : delta_y,

      distance  : Utils.getDistance(startEv.center, ev.center),
      angle     : Utils.getAngle(startEv.center, ev.center),
      direction : Utils.getDirection(startEv.center, ev.center),

      scale     : Utils.getScale(startEv.touches, ev.touches),
      rotation  : Utils.getRotation(startEv.touches, ev.touches)
    });

    return ev;
  },


  /**
   * register new gesture
   * @param   {Object}    gesture object, see gestures.js for documentation
   * @returns {Array}     gestures
   */
  register: function register(gesture) {
    // add an enable gesture options if there is no given
    var options = gesture.defaults || {};
    if(options[gesture.name] === undefined) {
      options[gesture.name] = true;
    }

    // extend Hammer default options with the Hammer.gesture options
    Utils.extend(Hammer.defaults, options, true);

    // set its index
    gesture.index = gesture.index || 1000;

    // add Hammer.gesture to the list
    this.gestures.push(gesture);

    // sort the list by index
    this.gestures.sort(function(a, b) {
      if(a.index < b.index) { return -1; }
      if(a.index > b.index) { return 1; }
      return 0;
    });

    return this.gestures;
  }
};


/**
 * Drag
 * Move with x fingers (default 1) around on the page. Blocking the scrolling when
 * moving left and right is a good practice. When all the drag events are blocking
 * you disable scrolling on that area.
 * @events  drag, drapleft, dragright, dragup, dragdown
 */
Hammer.gestures.Drag = {
  name     : 'drag',
  index    : 50,
  defaults : {
    drag_min_distance            : 10,

    // Set correct_for_drag_min_distance to true to make the starting point of the drag
    // be calculated from where the drag was triggered, not from where the touch started.
    // Useful to avoid a jerk-starting drag, which can make fine-adjustments
    // through dragging difficult, and be visually unappealing.
    correct_for_drag_min_distance: true,

    // set 0 for unlimited, but this can conflict with transform
    drag_max_touches             : 1,

    // prevent default browser behavior when dragging occurs
    // be careful with it, it makes the element a blocking element
    // when you are using the drag gesture, it is a good practice to set this true
    drag_block_horizontal        : false,
    drag_block_vertical          : false,

    // drag_lock_to_axis keeps the drag gesture on the axis that it started on,
    // It disallows vertical directions if the initial direction was horizontal, and vice versa.
    drag_lock_to_axis            : false,

    // drag lock only kicks in when distance > drag_lock_min_distance
    // This way, locking occurs only when the distance has become large enough to reliably determine the direction
    drag_lock_min_distance       : 25
  },

  triggered: false,
  handler  : function dragGesture(ev, inst) {
    var cur = Detection.current;

    // current gesture isnt drag, but dragged is true
    // this means an other gesture is busy. now call dragend
    if(cur.name != this.name && this.triggered) {
      inst.trigger(this.name + 'end', ev);
      this.triggered = false;
      return;
    }

    // max touches
    if(inst.options.drag_max_touches > 0 &&
      ev.touches.length > inst.options.drag_max_touches) {
      return;
    }

    switch(ev.eventType) {
      case EVENT_START:
        this.triggered = false;
        break;

      case EVENT_MOVE:
        // when the distance we moved is too small we skip this gesture
        // or we can be already in dragging
        if(ev.distance < inst.options.drag_min_distance &&
          cur.name != this.name) {
          return;
        }

        var startCenter = cur.startEvent.center;

        // we are dragging!
        if(cur.name != this.name) {
          cur.name = this.name;
          if(inst.options.correct_for_drag_min_distance && ev.distance > 0) {
            // When a drag is triggered, set the event center to drag_min_distance pixels from the original event center.
            // Without this correction, the dragged distance would jumpstart at drag_min_distance pixels instead of at 0.
            // It might be useful to save the original start point somewhere
            var factor = Math.abs(inst.options.drag_min_distance / ev.distance);
            startCenter.pageX += ev.deltaX * factor;
            startCenter.pageY += ev.deltaY * factor;
            startCenter.clientX += ev.deltaX * factor;
            startCenter.clientY += ev.deltaY * factor;

            // recalculate event data using new start point
            ev = Detection.extendEventData(ev);
          }
        }

        // lock drag to axis?
        if(cur.lastEvent.drag_locked_to_axis ||
            ( inst.options.drag_lock_to_axis &&
              inst.options.drag_lock_min_distance <= ev.distance
            )) {
          ev.drag_locked_to_axis = true;
        }
        var last_direction = cur.lastEvent.direction;
        if(ev.drag_locked_to_axis && last_direction !== ev.direction) {
          // keep direction on the axis that the drag gesture started on
          if(Utils.isVertical(last_direction)) {
            ev.direction = (ev.deltaY < 0) ? DIRECTION_UP : DIRECTION_DOWN;
          }
          else {
            ev.direction = (ev.deltaX < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;
          }
        }

        // first time, trigger dragstart event
        if(!this.triggered) {
          inst.trigger(this.name + 'start', ev);
          this.triggered = true;
        }

        // trigger events
        inst.trigger(this.name, ev);
        inst.trigger(this.name + ev.direction, ev);

        var is_vertical = Utils.isVertical(ev.direction);

        // block the browser events
        if((inst.options.drag_block_vertical && is_vertical) ||
          (inst.options.drag_block_horizontal && !is_vertical)) {
          ev.preventDefault();
        }
        break;

      case EVENT_END:
        // trigger dragend
        if(this.triggered) {
          inst.trigger(this.name + 'end', ev);
        }

        this.triggered = false;
        break;
    }
  }
};

/**
 * Hold
 * Touch stays at the same place for x time
 * @events  hold
 */
Hammer.gestures.Hold = {
  name    : 'hold',
  index   : 10,
  defaults: {
    hold_timeout  : 500,
    hold_threshold: 2
  },
  timer   : null,

  handler : function holdGesture(ev, inst) {
    switch(ev.eventType) {
      case EVENT_START:
        // clear any running timers
        clearTimeout(this.timer);

        // set the gesture so we can check in the timeout if it still is
        Detection.current.name = this.name;

        // set timer and if after the timeout it still is hold,
        // we trigger the hold event
        this.timer = setTimeout(function() {
          if(Detection.current.name == 'hold') {
            inst.trigger('hold', ev);
          }
        }, inst.options.hold_timeout);
        break;

      // when you move or end we clear the timer
      case EVENT_MOVE:
        if(ev.distance > inst.options.hold_threshold) {
          clearTimeout(this.timer);
        }
        break;

      case EVENT_END:
        clearTimeout(this.timer);
        break;
    }
  }
};

/**
 * Release
 * Called as last, tells the user has released the screen
 * @events  release
 */
Hammer.gestures.Release = {
  name   : 'release',
  index  : Infinity,
  handler: function releaseGesture(ev, inst) {
    if(ev.eventType == EVENT_END) {
      inst.trigger(this.name, ev);
    }
  }
};

/**
 * Swipe
 * triggers swipe events when the end velocity is above the threshold
 * for best usage, set prevent_default (on the drag gesture) to true
 * @events  swipe, swipeleft, swiperight, swipeup, swipedown
 */
Hammer.gestures.Swipe = {
  name    : 'swipe',
  index   : 40,
  defaults: {
    swipe_min_touches: 1,
    swipe_max_touches: 1,
    swipe_velocity   : 0.7
  },
  handler : function swipeGesture(ev, inst) {
    if(ev.eventType == EVENT_END) {
      // max touches
      if(ev.touches.length < inst.options.swipe_min_touches ||
        ev.touches.length > inst.options.swipe_max_touches) {
        return;
      }

      // when the distance we moved is too small we skip this gesture
      // or we can be already in dragging
      if(ev.velocityX > inst.options.swipe_velocity ||
        ev.velocityY > inst.options.swipe_velocity) {
        // trigger swipe events
        inst.trigger(this.name, ev);
        inst.trigger(this.name + ev.direction, ev);
      }
    }
  }
};

/**
 * Tap/DoubleTap
 * Quick touch at a place or double at the same place
 * @events  tap, doubletap
 */
Hammer.gestures.Tap = {
  name    : 'tap',
  index   : 100,
  defaults: {
    tap_max_touchtime : 250,
    tap_max_distance  : 10,
    tap_always        : true,
    doubletap_distance: 20,
    doubletap_interval: 300
  },

  has_moved: false,

  handler : function tapGesture(ev, inst) {
    var prev, since_prev, did_doubletap;

    // reset moved state
    if(ev.eventType == EVENT_START) {
      this.has_moved = false;
    }

    // Track the distance we've moved. If it's above the max ONCE, remember that (fixes #406).
    else if(ev.eventType == EVENT_MOVE && !this.moved) {
      this.has_moved = (ev.distance > inst.options.tap_max_distance);
    }

    else if(ev.eventType == EVENT_END &&
        ev.srcEvent.type != 'touchcancel' &&
        ev.deltaTime < inst.options.tap_max_touchtime && !this.has_moved) {

      // previous gesture, for the double tap since these are two different gesture detections
      prev = Detection.previous;
      since_prev = prev && prev.lastEvent && ev.timeStamp - prev.lastEvent.timeStamp;
      did_doubletap = false;

      // check if double tap
      if(prev && prev.name == 'tap' &&
          (since_prev && since_prev < inst.options.doubletap_interval) &&
          ev.distance < inst.options.doubletap_distance) {
        inst.trigger('doubletap', ev);
        did_doubletap = true;
      }

      // do a single tap
      if(!did_doubletap || inst.options.tap_always) {
        Detection.current.name = 'tap';
        inst.trigger(Detection.current.name, ev);
      }
    }
  }
};

/**
 * Touch
 * Called as first, tells the user has touched the screen
 * @events  touch
 */
Hammer.gestures.Touch = {
  name    : 'touch',
  index   : -Infinity,
  defaults: {
    // call preventDefault at touchstart, and makes the element blocking by
    // disabling the scrolling of the page, but it improves gestures like
    // transforming and dragging.
    // be careful with using this, it can be very annoying for users to be stuck
    // on the page
    prevent_default    : false,

    // disable mouse events, so only touch (or pen!) input triggers events
    prevent_mouseevents: false
  },
  handler : function touchGesture(ev, inst) {
    if(inst.options.prevent_mouseevents &&
        ev.pointerType == POINTER_MOUSE) {
      ev.stopDetect();
      return;
    }

    if(inst.options.prevent_default) {
      ev.preventDefault();
    }

    if(ev.eventType == EVENT_START) {
      inst.trigger(this.name, ev);
    }
  }
};


/**
 * Transform
 * User want to scale or rotate with 2 fingers
 * @events  transform, pinch, pinchin, pinchout, rotate
 */
Hammer.gestures.Transform = {
  name     : 'transform',
  index    : 45,
  defaults : {
    // factor, no scale is 1, zoomin is to 0 and zoomout until higher then 1
    transform_min_scale      : 0.01,
    // rotation in degrees
    transform_min_rotation   : 1,
    // prevent default browser behavior when two touches are on the screen
    // but it makes the element a blocking element
    // when you are using the transform gesture, it is a good practice to set this true
    transform_always_block   : false,
    // ensures that all touches occurred within the instance element
    transform_within_instance: false
  },

  triggered: false,

  handler  : function transformGesture(ev, inst) {
    // current gesture isnt drag, but dragged is true
    // this means an other gesture is busy. now call dragend
    if(Detection.current.name != this.name && this.triggered) {
      inst.trigger(this.name + 'end', ev);
      this.triggered = false;
      return;
    }

    // at least multitouch
    if(ev.touches.length < 2) {
      return;
    }

    // prevent default when two fingers are on the screen
    if(inst.options.transform_always_block) {
      ev.preventDefault();
    }

    // check if all touches occurred within the instance element
    if(inst.options.transform_within_instance) {
      for(var i=-1; ev.touches[++i];) {
        if(!Utils.hasParent(ev.touches[i].target, inst.element)) {
          return;
        }
      }
    }

    switch(ev.eventType) {
      case EVENT_START:
        this.triggered = false;
        break;

      case EVENT_MOVE:
        var scale_threshold = Math.abs(1 - ev.scale);
        var rotation_threshold = Math.abs(ev.rotation);

        // when the distance we moved is too small we skip this gesture
        // or we can be already in dragging
        if(scale_threshold < inst.options.transform_min_scale &&
          rotation_threshold < inst.options.transform_min_rotation) {
          return;
        }

        // we are transforming!
        Detection.current.name = this.name;

        // first time, trigger dragstart event
        if(!this.triggered) {
          inst.trigger(this.name + 'start', ev);
          this.triggered = true;
        }

        inst.trigger(this.name, ev); // basic transform event

        // trigger rotate event
        if(rotation_threshold > inst.options.transform_min_rotation) {
          inst.trigger('rotate', ev);
        }

        // trigger pinch event
        if(scale_threshold > inst.options.transform_min_scale) {
          inst.trigger('pinch', ev);
          inst.trigger('pinch' + (ev.scale<1 ? 'in' : 'out'), ev);
        }
        break;

      case EVENT_END:
        // trigger dragend
        if(this.triggered) {
          inst.trigger(this.name + 'end', ev);
        }

        this.triggered = false;
        break;
    }
  }
};

// AMD export
if(typeof define == 'function' && define.amd) {
  define(function(){
    return Hammer;
  });
}
// commonjs export
else if(typeof module == 'object' && module.exports) {
  module.exports = Hammer;
}
// browser export
else {
  window.Hammer = Hammer;
}

})(window);
},{}],4:[function(_dereq_,module,exports){
'use strict';

var EventEmitter = _dereq_('../bower_components/eventEmitter/EventEmitter.js');
var hammer = _dereq_('../bower_components/hammerjs/hammer.js');

var isTouchDevice = 'ontouchstart' in document.documentElement;

var utils = _dereq_('./utils.js'),
	tween = _dereq_('../bower_components/easy-tween/dist/easyTween.js');

var Surface = module.exports = function(container){
	this.container = container;
	this.element = document.createElement('div');
	this.element.style.position = 'absolute';
	container.appendChild(this.element);

	this.refit();
	this.emitter = new EventEmitter();

	this.horizontalPosition = 0;
	this.verticalPosition = 0;
	
	this.horizontalVelocity = 0;
	this.verticalVelocity = 0;

	this.cssTransitions = {};
	this.cssFilters = {};
	this.cssTransforms = {};

	this.pointerEventHandler = this.pointerEventHandler.bind(this);
	this.dragEventHandler = this.dragEventHandler.bind(this);
	this.transformStep = this.transformStep.bind(this);
};

Surface.create = function(container){
	var surface = new Surface(container);

	return Surface.getApi(surface);
};

Surface.getApi = function(surface){
	var api = {};

	api.on = surface.emitter.on.bind(surface.emitter);
	api.removeListener = surface.emitter.removeListener.bind(surface.emitter);

	api.refit = surface.refit.bind(surface);
	api.element = surface.element;
	api.container = surface.container;

	api.css = surface.setCssStyle.bind(surface);
	api.cssTransform = surface.setCssTransform.bind(surface);
	api.cssFilter = surface.setCssFilter.bind(surface);
	api.cssTransition = surface.setCssTransition.bind(surface);

	api.speed = surface.setVelocityScalar.bind(surface);
	api.horizontalSpeed = surface.setHorizontalVelocityScalar.bind(surface);
	api.verticalSpeed = surface.setVerticalVelocityScalar.bind(surface);

	api.horizontalWind = surface.setBaseHorizontalVelocity.bind(surface);
	api.verticalWind = surface.setBaseVerticalVelocity.bind(surface);
	
	Object.defineProperty(api, 'speedGradient', {
		get: function(){
			return (surface.horizontalVelocityGradient === surface.verticalVelocityGradient)? 
						surface.horizontalVelocityGradient : 
						void 0;
		},
		set: function(value){
			surface.horizontalVelocityGradient = value;
			surface.verticalVelocityGradient = value;
		}
	});

	Object.defineProperty(api, 'horizontalVelocityGradient', {
		get: function(){ return surface.horizontalVelocityGradient;},
		set: function(value){ surface.horizontalVelocityGradient = value;}
	});

	Object.defineProperty(api, 'verticalVelocityGradient', {
		get: function(){ return surface.verticalVelocityGradient;},
		set: function(value){ surface.verticalVelocityGradient = value;}
	});

	Object.defineProperty(api, 'width', {
		get: function(){return surface.width;}
	});

	Object.defineProperty(api, 'height', {
		get: function(){return surface.height;}
	});

	Object.defineProperty(api, 'top', {
		get: function(){return surface.top;}
	});

	Object.defineProperty(api, 'left', {
		get: function(){return surface.left;}
	});

	return api;
};

Surface.prototype.horizontalVelocityScalar = 0;
Surface.prototype.verticalVelocityScalar = 0;

Surface.prototype.baseHorizontalVelocity = 0;
Surface.prototype.baseVerticalVelocity = 0;

Surface.prototype.msPerStep = 16; // Milliseconds per step

// These functions take current position relative to the center and return a number between -1 and 1
Surface.prototype.horizontalVelocityGradient = tween.easing.quadraticIn;
Surface.prototype.verticalVelocityGradient = tween.easing.quadraticIn;

Surface.prototype.pointerTrackingEvents = ['mousemove'];//, 'touchstart', 'touchend', 'touchmove'];

Surface.prototype.refit = function(){
	var rect = this.container.getBoundingClientRect();

	this.width = rect.width;
	this.halfWidth = this.width / 2;

	this.height = rect.height;
	this.halfHeight = this.height / 2;

	this.top = rect.top;
	this.left = rect.left;
};

Surface.prototype.startTransformLoop = function(){
	if(this.transforming) return;

	this.transforming = true;
	this.lastStepTime = Date.now();
	this.animationRequestId = requestAnimationFrame(this.transformStep);
	this.attachPointerListeners();
	this.emitter.emit('move start');
};

Surface.prototype.stopTransformLoop = function(){
	if(!this.transforming) return;

	this.transforming = false;
	cancelAnimationFrame(this.animationRequestId);
	this.emitter.emit('move stop');
};

Surface.prototype.transformStep = function(){
	var currentTime = Date.now(),
		lagScalar = (currentTime - this.lastStepTime) / this.msPerStep;
	
	this.lastHorizontalDisplacement = lagScalar * (this.baseHorizontalVelocity + 
		(this.horizontalVelocity * this.horizontalVelocityScalar));
	this.lastVerticalDisplacement = lagScalar * (this.baseVerticalVelocity + 
		(this.verticalVelocity * this.verticalVelocityScalar));
	this.lastStepTime = currentTime;
	
	if(this.lastHorizontalDisplacement || this.lastVerticalDisplacement){
		this.horizontalPosition += this.lastHorizontalDisplacement;
		this.verticalPosition += this.lastVerticalDisplacement;
		this.setCssTransform('translate', this.horizontalPosition + 'px, ' + this.verticalPosition + 'px');
		this.animationRequestId = requestAnimationFrame(this.transformStep);
	} else if(this.trackingPointer || this.baseHorizontalVelocity || this.baseVerticalVelocity){
		this.animationRequestId = requestAnimationFrame(this.transformStep);
	}
};

Surface.prototype.setBaseHorizontalVelocity = function(target, duration, easingFunc){
	if(target === void 0) return this.baseHorizontalVelocity;

	if(this.horizontalWindTween) this.horizontalWindTween.pause();

	if(duration){
		duration *= 1000; // Tweening occurs in milliseconds
		easingFunc = easingFunc || (this.baseHorizontalVelocity < target)? 
			tween.easing.quadraticIn : tween.easing.quadraticOut;
		this.horizontalWindTween = tween(easingFunc, this, 'baseHorizontalVelocity', target, duration);
	} else {
		this.baseHorizontalVelocity = target;
	}
};

Surface.prototype.setBaseVerticalVelocity = function(target, duration, easingFunc){
	if(target === void 0) return this.baseVerticalVelocity;
	
	if(this.verticalWindTween) this.verticalWindTween.pause();

	if(duration){
		duration *= 1000; // Tweening occurs in milliseconds
		easingFunc = easingFunc || (this.baseVerticalVelocity < target)? 
			tween.easing.quadraticIn : tween.easing.quadraticOut;
		this.verticalWindTween = tween(easingFunc, this, 'baseVerticalVelocity', target, duration);
	} else {
		this.baseVerticalVelocity = target;
	}
};

Surface.prototype.setVelocityScalar = function(target, duration, easingFunc, callback){
	if(target === void 0){
		if(this.horizontalVelocityScalar === this.verticalVelocityScalar){
			return this.horizontalVelocityScalar;
		}

		return void 0;
	}
	
	this.setHorizontalVelocityScalar(target, duration, easingFunc, callback);
	this.setVerticalVelocityScalar(target, duration, easingFunc);
};

Surface.prototype.setHorizontalVelocityScalar = function(target, duration, easingFunc, callback){
	if(target === void 0) return this.horizontalVelocityScalar;

	if(this.horizontalSpeedTween) this.horizontalSpeedTween.pause();

	if(duration){
		duration *= 1000; // Tweening occurs in milliseconds
		easingFunc = easingFunc || (this.horizontalVelocityScalar < target)? 
			tween.easing.quadraticIn : tween.easing.quadraticOut;
		this.horizontalSpeedTween = tween(easingFunc, this, 'horizontalVelocityScalar', target, duration, callback);
	} else {
		this.horizontalVelocityScalar = target;
	}
};

Surface.prototype.setVerticalVelocityScalar = function(target, duration, easingFunc, callback){
	if(target === void 0) return this.verticalVelocityScalar;

	if(this.verticalSpeedTween) this.verticalSpeedTween.pause();

	if(duration){
		duration *= 1000; // Tweening occurs in milliseconds
		easingFunc = easingFunc || (this.verticalVelocityScalar < target)? 
			tween.easing.quadraticIn : tween.easing.quadraticOut;
		this.verticalSpeedTween = tween(easingFunc, this, 'verticalVelocityScalar', target, duration, callback);
	} else {
		this.verticalVelocityScalar = target;
	}
};

function preventDefault(e){
	e.preventDefault();
}

Surface.prototype.attachPointerListeners = function(){
	if(this.trackingPointer) return;
	this.trackingPointer = true;

	if(isTouchDevice){
		hammer(this.container).on('drag', this.dragEventHandler);	
		this.container.addEventListener('touchmove', preventDefault);
	} else {
		this.container.addEventListener('mousemove', this.pointerEventHandler);
	}
	
	this.emitter.emit('pointer tracking start');
};

Surface.prototype.detachPointerListeners = function(){
	if(!this.trackingPointer) return;
	this.trackingPointer = false;
	
	if(isTouchDevice){
		hammer(this.container).off('drag', this.dragEventHandler);	
		this.container.removeEventListener('touchmove', preventDefault);
	} else {
		this.container.removeEventListener('mousemove', this.pointerEventHandler);
	}
	

	this.emitter.emit('pointer tracking stop');
};

Surface.prototype.dragEventHandler = function(e){
	this.horizontalVelocity = e.gesture.velocityX;
	this.verticalVelocity = e.gesture.velocityY;
	
	if(this.horizontalVelocity < 0.1) this.horizontalVelocity = 0;
	if(this.verticalVelocity < 0.1) this.verticalVelocity = 0;

	if(this.horizontalVelocity > 1) this.horizontalVelocity = 1;
	if(this.verticalVelocity > 1) this.verticalVelocity = 1;

	if(e.gesture.deltaX < 0) this.horizontalVelocity *= -1;
	if(e.gesture.deltaY < 0) this.verticalVelocity *= -1;

};

// This updates the x and y speed multipliers based on the pointers relative position to the
// center of the container element
Surface.prototype.pointerEventHandler = function(e){
	// If touch event, find first touch
	var pointer = (e.changedTouches && e.changedTouches[0] || e),
		x = pointer.clientX - this.left,
		y = pointer.clientY - this.top;

	this.horizontalVelocity = this.horizontalVelocityGradient(
		x - this.halfWidth, 
		0, 
		(x > this.halfWidth? -1 : 1), 
		this.halfWidth
	);
	this.verticalVelocity = this.verticalVelocityGradient(
		y - this.halfHeight, 
		0, 
		(y > this.halfHeight? -1 : 1), 
		this.halfHeight
	);
};

Surface.prototype.setCssStyle = function(name, value, duration){
	if(value === void 0) return this.element.style[name];

	if(duration !== void 0) this.setCssTransition(name, duration + 's');
	
	this.element.style[name] = value;
};

Surface.prototype.setCssTransform = function(name, value){
	if(value === void 0) return this.cssTransforms[name];

	this.cssTransforms[name] = value;
	this.updateMultiAttributeStyle(utils.transformAttribute, this.cssTransforms);
};

Surface.prototype.setCssFilter = function(name, value, duration){
	if(value === void 0) return this.cssFilters[name];
	
	if(duration !== void 0) this.setCssTransition(utils.cssFilterAttribute, duration + 's');
	
	this.cssFilters[name] = value;
	this.updateMultiAttributeStyle(utils.filterAttribute, this.cssFilters);
};

Surface.prototype.setCssTransition = function(name, value){
	if(value === void 0) return this.cssTransitions[name];
	
	this.cssTransitions[name] = value;
	this.updateMultiAttributeStyle(utils.transitionAttribute, this.cssTransitions, true);
};

Surface.prototype.updateMultiAttributeStyle = function(styleName, attributes, withComma){
	var name,
		style = '',
		first = true;

	for(name in attributes){
		if(attributes.hasOwnProperty(name)){
			if(first) first = false;
			else style += withComma?', ': ' ';

			if(withComma){
				style += name + ' ' + attributes[name];
			} else {
				style += name + '(' + attributes[name] + ')';
			}
		}
	}

	this.element.style[styleName] = style;
};

},{"../bower_components/easy-tween/dist/easyTween.js":1,"../bower_components/eventEmitter/EventEmitter.js":2,"../bower_components/hammerjs/hammer.js":3,"./utils.js":5}],5:[function(_dereq_,module,exports){
'use strict';

var noop = exports.noop = function(){};

exports.requestFullscreen = document.documentElement.requestFullscreen ||
							document.documentElement.mozRequestFullScreen ||
							document.documentElement.webkitRequestFullscreen ||
							noop;

var bodyStyle = document.body.style;
exports.transformAttribute = 	(bodyStyle.msTransform !== void 0) && 'msTransform' ||
								(bodyStyle.webkitTransform !== void 0) && 'webkitTransform' ||
								(bodyStyle.MozTransform !== void 0) && 'MozTransform' ||
								'transform';
								
exports.transitionAttribute =	(bodyStyle.msTransition !== void 0) && 'msTransition' ||
								(bodyStyle.webkitTransition !== void 0) && 'webkitTransition' ||
								(bodyStyle.MozTransition !== void 0) && 'MozTransition' || 
								'transition';

exports.filterAttribute = 		(bodyStyle.msFilter !== void 0) && 'msFilter' ||
								(bodyStyle.webkitFilter !== void 0) && 'webkitFilter' ||
								(bodyStyle.MozFilter !== void 0) && 'MozFilter' ||
								'filter';

exports.cssFilterAttribute = 	(bodyStyle.msFilter !== void 0) && '-ms-filter' ||
								(bodyStyle.webkitFilter !== void 0) && '-webkit-filter' ||
								(bodyStyle.MozFilter !== void 0) && '-moz-filter' ||
								'filter';

exports.cssTransformAttribute = (bodyStyle.msTransform !== void 0) && '-ms-transform' ||
								(bodyStyle.webkitTransform !== void 0) && '-webkit-transform' ||
								(bodyStyle.MozTransform !== void 0) && '-moz-transform' ||
								'filter';
},{}]},{},[4])

(4)
});


}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],3:[function(_dereq_,module,exports){
/**
 * EventEmitter v4.0.5 - git.io/ee
 * Oliver Caldwell
 * MIT license
 * @preserve
 */

;(function(exports) {
    // JSHint config - http://www.jshint.com/
    /*jshint laxcomma:true*/
    /*global define:true*/

    // Place the script in strict mode
    'use strict';

    /**
     * Class for managing events.
     * Can be extended to provide event functionality in other classes.
     *
     * @class Manages event registering and emitting.
     */
    function EventEmitter(){}

    // Shortcuts to improve speed and size

        // Easy access to the prototype
    var proto = EventEmitter.prototype

      // Existence of a native indexOf
      , nativeIndexOf = Array.prototype.indexOf ? true : false;

    /**
     * Finds the index of the listener for the event in it's storage array
     *
     * @param {Function} listener Method to look for.
     * @param {Function[]} listeners Array of listeners to search through.
     * @return {Number} Index of the specified listener, -1 if not found
     */
    function indexOfListener(listener, listeners) {
        // Return the index via the native method if possible
        if(nativeIndexOf) {
            return listeners.indexOf(listener);
        }

        // There is no native method
        // Use a manual loop to find the index
        var i = listeners.length;
        while(i--) {
            // If the listener matches, return it's index
            if(listeners[i] === listener) {
                return i;
            }
        }

        // Default to returning -1
        return -1;
    }

    /**
     * Fetches the events object and creates one if required.
     *
     * @return {Object} The events storage object.
     */
    proto._getEvents = function() {
        return this._events || (this._events = {});
    };

    /**
     * Returns the listener array for the specified event.
     * Will initialise the event object and listener arrays if required.
     *
     * @param {String} evt Name of the event to return the listeners from.
     * @return {Function[]} All listener functions for the event.
     * @doc
     */
    proto.getListeners = function(evt) {
        // Create a shortcut to the storage object
        // Initialise it if it does not exists yet
        var events = this._getEvents();

        // Return the listener array
        // Initialise it if it does not exist
        return events[evt] || (events[evt] = []);
    };

    /**
     * Adds a listener function to the specified event.
     * The listener will not be added if it is a duplicate.
     * If the listener returns true then it will be removed after it is called.
     *
     * @param {String} evt Name of the event to attach the listener to.
     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.addListener = function(evt, listener) {
        // Fetch the listeners
        var listeners = this.getListeners(evt);

        // Push the listener into the array if it is not already there
        if(indexOfListener(listener, listeners) === -1) {
            listeners.push(listener);
        }

        // Return the instance of EventEmitter to allow chaining
        return this;
    };

    /**
     * Alias of addListener
     * @doc
     */
    proto.on = proto.addListener;

    /**
     * Removes a listener function from the specified event.
     *
     * @param {String} evt Name of the event to remove the listener from.
     * @param {Function} listener Method to remove from the event.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.removeListener = function(evt, listener) {
        // Fetch the listeners
        // And get the index of the listener in the array
        var listeners = this.getListeners(evt)
          , index = indexOfListener(listener, listeners);

        // If the listener was found then remove it
        if(index !== -1) {
            listeners.splice(index, 1);

            // If there are no more listeners in this array then remove it
            if(listeners.length === 0) {
                this.removeEvent(evt);
            }
        }

        // Return the instance of EventEmitter to allow chaining
        return this;
    };

    /**
     * Alias of removeListener
     * @doc
     */
    proto.off = proto.removeListener;

    /**
     * Adds listeners in bulk using the manipulateListeners method.
     * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
     * You can also pass it an event name and an array of listeners to be added.
     *
     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.
     * @param {Function[]} [listeners] An optional array of listener functions to add.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.addListeners = function(evt, listeners) {
        // Pass through to manipulateListeners
        return this.manipulateListeners(false, evt, listeners);
    };

    /**
     * Removes listeners in bulk using the manipulateListeners method.
     * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
     * You can also pass it an event name and an array of listeners to be removed.
     *
     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.
     * @param {Function[]} [listeners] An optional array of listener functions to remove.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.removeListeners = function(evt, listeners) {
        // Pass through to manipulateListeners
        return this.manipulateListeners(true, evt, listeners);
    };

    /**
     * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.
     * The first argument will determine if the listeners are removed (true) or added (false).
     * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.
     * You can also pass it an event name and an array of listeners to be added/removed.
     *
     * @param {Boolean} remove True if you want to remove listeners, false if you want to add.
     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.
     * @param {Function[]} [listeners] An optional array of listener functions to add/remove.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.manipulateListeners = function(remove, evt, listeners) {
        // Initialise any required variables
        var i
          , value
          , single = remove ? this.removeListener : this.addListener
          , multiple = remove ? this.removeListeners : this.addListeners;

        // If evt is an object then pass each of it's properties to this method
        if(typeof evt === 'object') {
            for(i in evt) {
                if(evt.hasOwnProperty(i) && (value = evt[i])) {
                    // Pass the single listener straight through to the singular method
                    if(typeof value === 'function') {
                        single.call(this, i, value);
                    }
                    else {
                        // Otherwise pass back to the multiple function
                        multiple.call(this, i, value);
                    }
                }
            }
        }
        else {
            // So evt must be a string
            // And listeners must be an array of listeners
            // Loop over it and pass each one to the multiple method
            i = listeners.length;
            while(i--) {
                single.call(this, evt, listeners[i]);
            }
        }

        // Return the instance of EventEmitter to allow chaining
        return this;
    };

    /**
     * Removes all listeners from a specified event.
     * If you do not specify an event then all listeners will be removed.
     * That means every event will be emptied.
     *
     * @param {String} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.removeEvent = function(evt) {
        // Remove different things depending on the state of evt
        if(evt) {
            // Remove all listeners for the specified event
            delete this._getEvents()[evt];
        }
        else {
            // Remove all listeners in all events
            delete this._events;
        }

        // Return the instance of EventEmitter to allow chaining
        return this;
    };

    /**
     * Emits an event of your choice.
     * When emitted, every listener attached to that event will be executed.
     * If you pass the optional argument array then those arguments will be passed to every listener upon execution.
     * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.
     * So they will not arrive within the array on the other side, they will be separate.
     *
     * @param {String} evt Name of the event to emit and execute listeners for.
     * @param {Array} [args] Optional array of arguments to be passed to each listener.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.emitEvent = function(evt, args) {
        // Get the listeners for the event
        // Also initialise any other required variables
        var listeners = this.getListeners(evt)
          , i = listeners.length
          , response;

        // Loop over all listeners assigned to the event
        // Apply the arguments array to each listener function
        while(i--) {
            // If the listener returns true then it shall be removed from the event
            // The function is executed either with a basic call or an apply if there is an args array
            response = args ? listeners[i].apply(null, args) : listeners[i]();
            if(response === true) {
                this.removeListener(evt, listeners[i]);
            }
        }

        // Return the instance of EventEmitter to allow chaining
        return this;
    };

    /**
     * Alias of emitEvent
     * @doc
     */
    proto.trigger = proto.emitEvent;

    /**
     * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as
     * opposed to taking a single array of arguments to pass on.
     *
     * @param {String} evt Name of the event to emit and execute listeners for.
     * @param {...*} Optional additional arguments to be passed to each listener.
     * @return {Object} Current instance of EventEmitter for chaining.
     * @doc
     */
    proto.emit = function(evt) {
        var args = Array.prototype.slice.call(arguments, 1);
        return this.emitEvent(evt, args);
    };

    // Expose the class either via AMD or the global object
    if(typeof define === 'function' && define.amd) {
        define(function() {
            return EventEmitter;
        });
    }
    else {
        exports.EventEmitter = EventEmitter;
    }
}(this));
},{}],4:[function(_dereq_,module,exports){
(function (global){
!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.GiantQuadtree=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);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 _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
'use strict';

module.exports = Node;

function Node(left, top, width, height, parent){
	this.objects = [];

	this.left = left;
	this.top = top;
	this.width = width;
	this.height = height;
	this.right = this.left + this.width;
	this.bottom = this.top + this.height;
	this.isBase = (this.width / 2) < this.minimumSize;

	this.parent = parent;
}

Node.prototype.tl = void 0;
Node.prototype.tr = void 0;
Node.prototype.br = void 0;
Node.prototype.bl = void 0;

Node.prototype.objectLimit = 200;
Node.prototype.minimumSize = 3000;

Node.prototype.clear = function(){
	this.objects = [];

	if(this.tl){
		this.tl.clear();
		this.tr.clear();
		this.br.clear();
		this.bl.clear();
	}
};

Node.prototype.getObjects = function(){
	if(this.tl){
		return this.objects.concat(this.tl.getObjects(), this.tr.getObjects(), this.br.getObjects(), this.bl.getObjects());
	} else {
		return this.objects.slice();
	}
};

Node.prototype.split = function(){
	var childWidth = this.width / 2,
		childHeight = this.height / 2,
		left = this.left,
		top = this.top;

	this.tl = new Node(left, top, childWidth, childHeight, this);
	this.tr = new Node(left + childWidth, top, childWidth, childHeight, this);
	this.br = new Node(left + childWidth, top + childHeight, childWidth, childHeight, this);
	this.bl = new Node(left, top + childHeight, childWidth, childHeight, this);
};

// This can be called from ANY node in the tree, it'll return the top most node of the tree
// that can contain the element (it will grow the tree if nescessary)
Node.prototype.parentNode = function(obj){
	var node = this,
		parent;

	// If object is left of this node
	if(obj.left < node.left){
		// If object is to the top of this node
		if(obj.top < node.top){
			// Grow towards top left
			parent = node.grow(node.width, node.height);
		} else {
			// Grow towards bottom left
			parent = node.grow(node.width, 0);
		}
	// If object is right of this node
	} else if(obj.left + obj.width > node.left + node.width){
		// If object is to the top of this node
		if(obj.top < node.top){
			// Grow towards top right
			parent = node.grow(0, node.height);
		} else {
			// Grow towards bottom right
			parent = node.grow(0, 0);
		} 

	// If object is within x-axis but top of node
	} else if(obj.top < node.top){
		// Grow towards top right (top left is just as valid though)
		parent = node.grow(0, node.height);
	// If object is within x-axis but bottom of node
	} else if(obj.top + obj.height > node.top + node.height){
		// Grow towards bottom right (bottom left is just as valid though)
		parent = node.grow(0, 0);
	}
	
	// If we had to grow, find the quadrant in the parent
	if(parent){
		return parent.parentNode(obj);
	}

	return node;
};

// Helper function which gets the quadrant node at a given x/y position
// caller function has to check to see if this node is split before calling this
Node.prototype.getQuadrantAt = function(x, y){
	if(!this.tl) return this;

	var xMid = this.left + this.width / 2,
		yMid = this.top + this.height / 2;

	if(x < xMid){
		if(y < yMid){
			return this.tl.tl && this.tl.getQuadrantAt(x, y) || this.tl;
		} else {
			return this.bl.tl && this.bl.getQuadrantAt(x, y) || this.bl;
		}
	} else {
		if(y < yMid){
			return this.tr.tl && this.tr.getQuadrantAt(x, y) || this.tr;
		} else {
			return this.br.tl && this.br.getQuadrantAt(x, y) || this.br;
		}
	}
};

// Gets all the objects in quadrants within the given dimensions. 
// This assumes that the given dimensions can't be larger than a quadrant, 
// meaning it can at most touch 4 quadrants
Node.prototype.getInteractableObjects = function(left, top, width, height){
	if(!this.tl) return this.objects.slice();	

	var node = this.getQuadrant(left, top, width, height),
		objectsList = [node.objects],
		quadrants = [node], // Keeps track to prevent dupes
		parent = node.parent;

	while(parent){
		objectsList.push(parent.objects);
		quadrants.push(parent);
		parent = parent.parent;
	}

	if(node.tl){
		// top left corner
		var quadrant = node.getQuadrantAt(left, top);
		if(!~quadrants.indexOf(quadrant)){
			quadrants.push(quadrant);
			objectsList.push(quadrant.objects);

			if(quadrant.parent && !~quadrants.indexOf(quadrant.parent)){
				quadrants.push(quadrant.parent);
				objectsList.push(quadrant.parent.objects);	
			}
		}
		
		// top right corner
		quadrant = node.getQuadrantAt(left + width, top);
		if(!~quadrants.indexOf(quadrant)){
			quadrants.push(quadrant);
			objectsList.push(quadrant.objects);

			if(quadrant.parent && !~quadrants.indexOf(quadrant.parent)){
				quadrants.push(quadrant.parent);
				objectsList.push(quadrant.parent.objects);	
			}
		}

		// bottom right corner
		quadrant = node.getQuadrantAt(left + width, top + height);
		if(!~quadrants.indexOf(quadrant)){
			quadrants.push(quadrant);
			objectsList.push(quadrant.objects);

			if(quadrant.parent && !~quadrants.indexOf(quadrant.parent)){
				quadrants.push(quadrant.parent);
				objectsList.push(quadrant.parent.objects);	
			}
		}

		// bottom left corner
		quadrant = node.getQuadrantAt(left, top + height);
		if(!~quadrants.indexOf(quadrant)){
			quadrants.push(quadrant);
			objectsList.push(quadrant.objects);
			if(quadrant.parent && !~quadrants.indexOf(quadrant.parent)) objectsList.push(quadrant.parent.objects);
		}
	}

	return Array.prototype.concat.apply([], objectsList);
};

// Gets the quadrant a given bounding box dimensions would be inserted into
Node.prototype.getQuadrant = function(left, top, width, height){
	if(!this.tl) return this;

	var	xMid = this.left + this.width / 2,
		yMid = this.top + this.height / 2,
		topQuadrant = (top < yMid) && ((top + height) < yMid),
		bottomQuadrand = top > yMid;

	if((left < xMid) && ((left + width) < xMid)){
		if(topQuadrant){
			return this.tl.tl && this.tl.getQuadrant(left, top, width, height) || this.tl;
		} else if(bottomQuadrand){
			return this.bl.tl && this.bl.getQuadrant(left, top, width, height) || this.bl;
		}
	} else if(left > xMid){
		if(topQuadrant){
			return this.tr.tl && this.tr.getQuadrant(left, top, width, height) || this.tr;
		} else if(bottomQuadrand) {
			return this.br.tl && this.br.getQuadrant(left, top, width, height) || this.br;
		}
	}

	return this;
};

// Inserts the object to the Node, spliting or growing the tree if nescessary
// Returns the top-most node of this tree
Node.prototype.insert = function(obj){
	var quadrant,
		index,
		length,
		remainingObjects,
		objects,
		node;

	// This call will grow the tree if nescessary and return the parent node
	// if the tree doesn't need to grow, `node` will be `this`.
	node = this.parentNode(obj);
	quadrant = node.getQuadrant(obj.left, obj.top, obj.width, obj.height);

	if(quadrant !== node){
		quadrant.insert(obj);
	} else {
		objects = node.objects;
		objects.push(obj);

		index = 0;
		length = objects.length;
		if(!this.isBase && length > node.objectLimit){
			// Split if not already split
			if(!node.tl) node.split();

			// For objects that don't fit to quadrants
			remainingObjects = [];
		
			// Iterate through all object and try to put them in a
			// Quadrant node, if that doesn't work, retain them	
			for(; index < length; index++){

				// Reusing the obj var
				obj = node.objects[index];
				quadrant = node.getQuadrant(obj.left, obj.top, obj.width, obj.height);
				if(quadrant !== node){
					quadrant.insert(obj);
				} else {
					remainingObjects.push(obj);
				}
			}

			node.objects = remainingObjects;
		}
	}

	return node;
};

// Creates a pre-split parent Node and attaches this Node as a
// node at the given x/y offset (so 0,0 would make this Node the top left node)
Node.prototype.grow = function(xOffset, yOffset){
	var left = this.left - xOffset,
		top = this.top - yOffset,
		parent = new Node(left, top, this.width * 2, this.height * 2);
	
	this.parent = parent;

	if(xOffset){
		if(yOffset){
			parent.br = this;
		} else {
			parent.tr = this;
		}
	} else if(yOffset) {
		parent.bl = this;
	} else {
		parent.tl = this;
	}

	parent.tl = parent.tl || new Node(left, top, this.width, this.height, this);
	parent.tr = parent.tr || new Node(left + this.width, top, this.width, this.height, this);
	parent.br = parent.br || new Node(left + this.width, top + this.height, this.width, this.height, this);
	parent.bl = parent.bl || new Node(left, top + this.height, this.width, this.height, this);

	return parent;
};


},{}],2:[function(_dereq_,module,exports){
'use strict';

var TreeNode = _dereq_('./node');

/* Quadtree by Ozan Turgut (ozanturgut@gmail.com)

   A Quadtree is a structure for managing many nodes interacting in space by
   organizing them within a tree, where each node contains elements which may
   interact with other elements within the node. This is particularly useful in
   collision detection, in which a brute-force algorithm requires the checking of
   every element against every other element, regardless of their distance in space.

   This quadtree handles object in 2d space by their bounding boxes. It splits
   a node once it exceeds the object limit per-node. When a node is split, it's
   contents are divied up in to 4 smaller nodes to fulfill the per-node object limit.
   Nodes are infinitely divisible.

   If an object is inserted which exceeds the bounds of this quadtree, the quadtree
   will grow in the direction the object was inserted in order to encapsulate it. This is
   similar to a node split, except in this case we create a parent node and assign the existing
   quadtree as a quadrant within it. This allows the quadtree to contain any object, regardless of
   its position in space.

   One function is exported which creates a quadtree given a width and height.

   The quadtree api has two methods:

   insert(bounds)
   		Inserts a bounding box (it should contain an left, top, width, and height property).

   	retrieve(bounds)
   		Retrieves a list of bounding boxes that share a node with the given bounds object.
*/

var Quadtree = module.exports = function(width, height){
	if(width){
		this.width = width;
		this.height = height? height : width;
	}
	
	this.reset();
};

Quadtree.create = function(width, height){
	var quadtree = new Quadtree(width, height);
	return Quadtree.getApi(quadtree);
};

Quadtree.getApi = function(quadtree){
	var api = {};
	api.insert = quadtree.insert.bind(quadtree);
	api.reset = quadtree.reset.bind(quadtree);
	api.getObjects = quadtree.getObjects.bind(quadtree);
	api.get = api.getObjects; // alias
	api.prune = quadtree.prune.bind(quadtree);

	return api;
};

Quadtree.prototype.width = 10000;
Quadtree.prototype.height = 10000;

Quadtree.prototype.reset = function(x, y){
	x = x || 0;
	y = y || 0;

	this.top = new TreeNode(x, y, this.width, this.height);
};

Quadtree.prototype.insert = function(obj){
	this.top = this.top.insert(obj);
};

/*
function isInNode(node, left, top, right, bottom){
	return node.left <= left && node.top <= top && node.right >= right && node.bottom >= bottom;
}
*/

function getContainingNodeHelper(left, top, right, bottom, node){
	if(!node.tl) return node;

	if(left < node.tr.left){
		if(right < node.tr.left){
			if(bottom < node.bl.top){
				return getContainingNodeHelper(left, top, right, bottom, node.tl);
			} else if(top > node.bl.top) {
				return getContainingNodeHelper(left, top, right, bottom, node.bl);
			}
		}
	} else {
		if(bottom < node.br.top){
			return getContainingNodeHelper(left, top, right, bottom, node.tr);
		} else if(top > node.br.top) {
			return getContainingNodeHelper(left, top, right, bottom, node.br);
		}
	}

	return node;
}

Quadtree.prototype.getContainingNode = function(left, top, right, bottom){
	if(left < this.top.left || 
		top < this.top.top || 
		right > this.top.right || 
		bottom > this.top.bottom){
		return;	
	}

	return getContainingNodeHelper(left, top, right, bottom, this.top);
};

Quadtree.prototype.minimumSize = 3000;
Quadtree.prototype.getInteractableObjects = function(left, top, right, bottom){
	var self = this,
		minimumSize = this.minimumSize,
		tl = this.getContainingNode(left, top, left + 1, top + 1),
		tr,
		bl,
		br,
		objectsList = tl ? [tl.getObjects()] : [];

	function addAncestorElements(left, top, right, bottom){
		var ancestor = self.getContainingNode(left, top, right, bottom);
		if(ancestor && !~objectsList.indexOf(ancestor.objects)) objectsList.push(ancestor.objects);
	}

	if(!tl || tl.right < right){
		tr = this.getContainingNode(right - 1, top, right, top + 1);
		if(tr) objectsList.push(tr.getObjects());
		else tr = tl;
	} else {
		tr = tl;
	}

	if(!tl || tl.bottom < bottom){
		bl = this.getContainingNode(left, bottom - 1, left + 1, bottom);
		if(bl) objectsList.push(bl.getObjects());
		else bl = tl;
	} else {
		bl = tl;
	}

	if(!tr || tr.bottom < bottom){
		if(!bl || bl.right < right){
			br = this.getContainingNode(right - 1, bottom - 1, right, bottom);
			if(br) objectsList.push(br.getObjects());
			else br = bl;
		} else {
			br = bl;
		}
	} else {
		br = tr;
	}
	
	if(tl !== tr) addAncestorElements(left, top, right, top + 1);
	if(tr !== br) addAncestorElements(right - 1, top, right, bottom);
	if(br !== bl) addAncestorElements(left, bottom - 1, right, bottom);
	if(bl !== tl) addAncestorElements(left, top, left + 1, bottom);
		
	// Intersections towards top left
	if(tl){
		if((left - minimumSize) < tl.left){
			addAncestorElements(left - minimumSize, top, left + 1, top + 1);
		}

		if((top - minimumSize) < tl.top){
			addAncestorElements(left, top - minimumSize, left + 1, top + 1);
		}
	}
	
	// Intersections towards top right
	if(tr){
		if(tr !== tl && (top - minimumSize) < tr.top){
			addAncestorElements(right - 1, top - minimumSize, right, top + 1);
		}

		if((right + minimumSize) > tr.right){
			addAncestorElements(right - 1, top, right + minimumSize, top + 1);
		}
	}

	// Intersections towards bottom right
	if(br){
		if(br !== tr && (right + minimumSize) > br.right){
			addAncestorElements(right - 1, bottom - 1, right + minimumSize, bottom);
		}

		if((bottom + minimumSize) > br.bottom){
			addAncestorElements(right - 1, bottom - 1, right, bottom + minimumSize);
		}
	}

	// Intersections towards bottom left
	if(bl){
		if(bl !== br && (bottom + minimumSize) > bl.bottom){
			addAncestorElements(left, bottom - 1, left + 1, bottom + minimumSize);
		}

		if(bl !== tl && (left - minimumSize) < bl.left){
			addAncestorElements(left - minimumSize, bottom - 1, left + 1, bottom);
		}
	}

	return Array.prototype.concat.apply([], objectsList);
};

Quadtree.prototype.getObjects = function(left, top, width, height){
	if(left !== void 0){
		var bottom = top + height,
			right = left + width,
			rectangles = this.getInteractableObjects(left, top, right, bottom),
			rectangleIndex = rectangles.length,
			result = [],
			rectangle;

		while(rectangleIndex--){
			rectangle = rectangles[rectangleIndex];
			
			// If there is intersection along the y-axis
			if(	(top <= rectangle.top ?
					(bottom >= rectangle.top) :
					(rectangle.bottom >= top)) && 
				// And if there is intersection along the x-axis
				(left <= rectangle.left ? 
					(right >= rectangle.left) :
					(rectangle.right >= left))){

				
				result.push(rectangle);
			}
		}
		
		return result;
	}

	return this.top.getObjects();
};

Quadtree.prototype.prune = function(left, top, width, height){
	var right = left + width,
		bottom = top + height,
		candidate,
		rejectedObjects = [],
		keptObjects = [];

	var objects = this.top.getObjects(),
		index = 0,
		length = objects.length;

	for(; index < length; index++){
		candidate = objects[index];

		if(	candidate.left < left || 
			candidate.top < top || 
			(candidate.left + candidate.width) > right ||
			(candidate.top + candidate.height) > bottom){
			rejectedObjects.push(candidate);
		} else {
			keptObjects.push(candidate);
		}
	}
	if(keptObjects.length){
		this.reset(keptObjects[0].left, keptObjects[0].top);
		index = 0;
		length = keptObjects.length;
		for(; index < length; index++){
			this.insert(keptObjects[index]);
		}
	} else {
		this.reset();
	}
	
	return rejectedObjects;
};

},{"./node":1}]},{},[2])

(2)
});


}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],5:[function(_dereq_,module,exports){
/*!
 * mustache.js - Logic-less {{mustache}} templates with JavaScript
 * http://github.com/janl/mustache.js
 */

/*global define: false*/

(function (root, factory) {
  if (typeof exports === "object" && exports) {
    factory(exports); // CommonJS
  } else {
    var mustache = {};
    factory(mustache);
    if (typeof define === "function" && define.amd) {
      define(mustache); // AMD
    } else {
      root.Mustache = mustache; // <script>
    }
  }
}(this, function (mustache) {

  var whiteRe = /\s*/;
  var spaceRe = /\s+/;
  var nonSpaceRe = /\S/;
  var eqRe = /\s*=/;
  var curlyRe = /\s*\}/;
  var tagRe = /#|\^|\/|>|\{|&|=|!/;

  // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577
  // See https://github.com/janl/mustache.js/issues/189
  var RegExp_test = RegExp.prototype.test;
  function testRegExp(re, string) {
    return RegExp_test.call(re, string);
  }

  function isWhitespace(string) {
    return !testRegExp(nonSpaceRe, string);
  }

  var Object_toString = Object.prototype.toString;
  var isArray = Array.isArray || function (object) {
    return Object_toString.call(object) === '[object Array]';
  };

  function isFunction(object) {
    return typeof object === 'function';
  }

  function escapeRegExp(string) {
    return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
  }

  var entityMap = {
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
    '"': '&quot;',
    "'": '&#39;',
    "/": '&#x2F;'
  };

  function escapeHtml(string) {
    return String(string).replace(/[&<>"'\/]/g, function (s) {
      return entityMap[s];
    });
  }

  function Scanner(string) {
    this.string = string;
    this.tail = string;
    this.pos = 0;
  }

  /**
   * Returns `true` if the tail is empty (end of string).
   */
  Scanner.prototype.eos = function () {
    return this.tail === "";
  };

  /**
   * Tries to match the given regular expression at the current position.
   * Returns the matched text if it can match, the empty string otherwise.
   */
  Scanner.prototype.scan = function (re) {
    var match = this.tail.match(re);

    if (match && match.index === 0) {
      var string = match[0];
      this.tail = this.tail.substring(string.length);
      this.pos += string.length;
      return string;
    }

    return "";
  };

  /**
   * Skips all text until the given regular expression can be matched. Returns
   * the skipped string, which is the entire tail if no match can be made.
   */
  Scanner.prototype.scanUntil = function (re) {
    var index = this.tail.search(re), match;

    switch (index) {
    case -1:
      match = this.tail;
      this.tail = "";
      break;
    case 0:
      match = "";
      break;
    default:
      match = this.tail.substring(0, index);
      this.tail = this.tail.substring(index);
    }

    this.pos += match.length;

    return match;
  };

  function Context(view, parent) {
    this.view = view == null ? {} : view;
    this.parent = parent;
    this._cache = { '.': this.view };
  }

  Context.make = function (view) {
    return (view instanceof Context) ? view : new Context(view);
  };

  Context.prototype.push = function (view) {
    return new Context(view, this);
  };

  Context.prototype.lookup = function (name) {
    var value;
    if (name in this._cache) {
      value = this._cache[name];
    } else {
      var context = this;

      while (context) {
        if (name.indexOf('.') > 0) {
          value = context.view;

          var names = name.split('.'), i = 0;
          while (value != null && i < names.length) {
            value = value[names[i++]];
          }
        } else {
          value = context.view[name];
        }

        if (value != null) break;

        context = context.parent;
      }

      this._cache[name] = value;
    }

    if (isFunction(value)) {
      value = value.call(this.view);
    }

    return value;
  };

  function Writer() {
    this.clearCache();
  }

  Writer.prototype.clearCache = function () {
    this._cache = {};
    this._partialCache = {};
  };

  Writer.prototype.compile = function (template, tags) {
    var fn = this._cache[template];

    if (!fn) {
      var tokens = mustache.parse(template, tags);
      fn = this._cache[template] = this.compileTokens(tokens, template);
    }

    return fn;
  };

  Writer.prototype.compilePartial = function (name, template, tags) {
    var fn = this.compile(template, tags);
    this._partialCache[name] = fn;
    return fn;
  };

  Writer.prototype.getPartial = function (name) {
    if (!(name in this._partialCache) && this._loadPartial) {
      this.compilePartial(name, this._loadPartial(name));
    }

    return this._partialCache[name];
  };

  Writer.prototype.compileTokens = function (tokens, template) {
    var self = this;
    return function (view, partials) {
      if (partials) {
        if (isFunction(partials)) {
          self._loadPartial = partials;
        } else {
          for (var name in partials) {
            self.compilePartial(name, partials[name]);
          }
        }
      }

      return renderTokens(tokens, self, Context.make(view), template);
    };
  };

  Writer.prototype.render = function (template, view, partials) {
    return this.compile(template)(view, partials);
  };

  /**
   * Low-level function that renders the given `tokens` using the given `writer`
   * and `context`. The `template` string is only needed for templates that use
   * higher-order sections to extract the portion of the original template that
   * was contained in that section.
   */
  function renderTokens(tokens, writer, context, template) {
    var buffer = '';

    // This function is used to render an artbitrary template
    // in the current context by higher-order functions.
    function subRender(template) {
      return writer.render(template, context);
    }

    var token, tokenValue, value;
    for (var i = 0, len = tokens.length; i < len; ++i) {
      token = tokens[i];
      tokenValue = token[1];

      switch (token[0]) {
      case '#':
        value = context.lookup(tokenValue);

        if (typeof value === 'object' || typeof value === 'string') {
          if (isArray(value)) {
            for (var j = 0, jlen = value.length; j < jlen; ++j) {
              buffer += renderTokens(token[4], writer, context.push(value[j]), template);
            }
          } else if (value) {
            buffer += renderTokens(token[4], writer, context.push(value), template);
          }
        } else if (isFunction(value)) {
          var text = template == null ? null : template.slice(token[3], token[5]);
          value = value.call(context.view, text, subRender);
          if (value != null) buffer += value;
        } else if (value) {
          buffer += renderTokens(token[4], writer, context, template);
        }

        break;
      case '^':
        value = context.lookup(tokenValue);

        // Use JavaScript's definition of falsy. Include empty arrays.
        // See https://github.com/janl/mustache.js/issues/186
        if (!value || (isArray(value) && value.length === 0)) {
          buffer += renderTokens(token[4], writer, context, template);
        }

        break;
      case '>':
        value = writer.getPartial(tokenValue);
        if (isFunction(value)) buffer += value(context);
        break;
      case '&':
        value = context.lookup(tokenValue);
        if (value != null) buffer += value;
        break;
      case 'name':
        value = context.lookup(tokenValue);
        if (value != null) buffer += mustache.escape(value);
        break;
      case 'text':
        buffer += tokenValue;
        break;
      }
    }

    return buffer;
  }

  /**
   * Forms the given array of `tokens` into a nested tree structure where
   * tokens that represent a section have two additional items: 1) an array of
   * all tokens that appear in that section and 2) the index in the original
   * template that represents the end of that section.
   */
  function nestTokens(tokens) {
    var tree = [];
    var collector = tree;
    var sections = [];

    var token;
    for (var i = 0, len = tokens.length; i < len; ++i) {
      token = tokens[i];
      switch (token[0]) {
      case '#':
      case '^':
        sections.push(token);
        collector.push(token);
        collector = token[4] = [];
        break;
      case '/':
        var section = sections.pop();
        section[5] = token[2];
        collector = sections.length > 0 ? sections[sections.length - 1][4] : tree;
        break;
      default:
        collector.push(token);
      }
    }

    return tree;
  }

  /**
   * Combines the values of consecutive text tokens in the given `tokens` array
   * to a single token.
   */
  function squashTokens(tokens) {
    var squashedTokens = [];

    var token, lastToken;
    for (var i = 0, len = tokens.length; i < len; ++i) {
      token = tokens[i];
      if (token) {
        if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {
          lastToken[1] += token[1];
          lastToken[3] = token[3];
        } else {
          lastToken = token;
          squashedTokens.push(token);
        }
      }
    }

    return squashedTokens;
  }

  function escapeTags(tags) {
    return [
      new RegExp(escapeRegExp(tags[0]) + "\\s*"),
      new RegExp("\\s*" + escapeRegExp(tags[1]))
    ];
  }

  /**
   * Breaks up the given `template` string into a tree of token objects. If
   * `tags` is given here it must be an array with two string values: the
   * opening and closing tags used in the template (e.g. ["<%", "%>"]). Of
   * course, the default is to use mustaches (i.e. Mustache.tags).
   */
  function parseTemplate(template, tags) {
    template = template || '';
    tags = tags || mustache.tags;

    if (typeof tags === 'string') tags = tags.split(spaceRe);
    if (tags.length !== 2) throw new Error('Invalid tags: ' + tags.join(', '));

    var tagRes = escapeTags(tags);
    var scanner = new Scanner(template);

    var sections = [];     // Stack to hold section tokens
    var tokens = [];       // Buffer to hold the tokens
    var spaces = [];       // Indices of whitespace tokens on the current line
    var hasTag = false;    // Is there a {{tag}} on the current line?
    var nonSpace = false;  // Is there a non-space char on the current line?

    // Strips all whitespace tokens array for the current line
    // if there was a {{#tag}} on it and otherwise only space.
    function stripSpace() {
      if (hasTag && !nonSpace) {
        while (spaces.length) {
          delete tokens[spaces.pop()];
        }
      } else {
        spaces = [];
      }

      hasTag = false;
      nonSpace = false;
    }

    var start, type, value, chr, token, openSection;
    while (!scanner.eos()) {
      start = scanner.pos;

      // Match any text between tags.
      value = scanner.scanUntil(tagRes[0]);
      if (value) {
        for (var i = 0, len = value.length; i < len; ++i) {
          chr = value.charAt(i);

          if (isWhitespace(chr)) {
            spaces.push(tokens.length);
          } else {
            nonSpace = true;
          }

          tokens.push(['text', chr, start, start + 1]);
          start += 1;

          // Check for whitespace on the current line.
          if (chr == '\n') stripSpace();
        }
      }

      // Match the opening tag.
      if (!scanner.scan(tagRes[0])) break;
      hasTag = true;

      // Get the tag type.
      type = scanner.scan(tagRe) || 'name';
      scanner.scan(whiteRe);

      // Get the tag value.
      if (type === '=') {
        value = scanner.scanUntil(eqRe);
        scanner.scan(eqRe);
        scanner.scanUntil(tagRes[1]);
      } else if (type === '{') {
        value = scanner.scanUntil(new RegExp('\\s*' + escapeRegExp('}' + tags[1])));
        scanner.scan(curlyRe);
        scanner.scanUntil(tagRes[1]);
        type = '&';
      } else {
        value = scanner.scanUntil(tagRes[1]);
      }

      // Match the closing tag.
      if (!scanner.scan(tagRes[1])) throw new Error('Unclosed tag at ' + scanner.pos);

      token = [type, value, start, scanner.pos];
      tokens.push(token);

      if (type === '#' || type === '^') {
        sections.push(token);
      } else if (type === '/') {
        // Check section nesting.
        openSection = sections.pop();
        if (!openSection) {
          throw new Error('Unopened section "' + value + '" at ' + start);
        }
        if (openSection[1] !== value) {
          throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
        }
      } else if (type === 'name' || type === '{' || type === '&') {
        nonSpace = true;
      } else if (type === '=') {
        // Set the tags for the next time around.
        tags = value.split(spaceRe);
        if (tags.length !== 2) {
          throw new Error('Invalid tags at ' + start + ': ' + tags.join(', '));
        }
        tagRes = escapeTags(tags);
      }
    }

    // Make sure there are no open sections when we're done.
    openSection = sections.pop();
    if (openSection) {
      throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
    }

    return nestTokens(squashTokens(tokens));
  }

  mustache.name = "mustache.js";
  mustache.version = "0.7.3";
  mustache.tags = ["{{", "}}"];

  mustache.Scanner = Scanner;
  mustache.Context = Context;
  mustache.Writer = Writer;

  mustache.parse = parseTemplate;

  // Export the escaping function so that the user may override it.
  // See https://github.com/janl/mustache.js/issues/244
  mustache.escape = escapeHtml;

  // All Mustache.* functions use this writer.
  var defaultWriter = new Writer();

  /**
   * Clears all cached templates and partials in the default writer.
   */
  mustache.clearCache = function () {
    return defaultWriter.clearCache();
  };

  /**
   * Compiles the given `template` to a reusable function using the default
   * writer.
   */
  mustache.compile = function (template, tags) {
    return defaultWriter.compile(template, tags);
  };

  /**
   * Compiles the partial with the given `name` and `template` to a reusable
   * function using the default writer.
   */
  mustache.compilePartial = function (name, template, tags) {
    return defaultWriter.compilePartial(name, template, tags);
  };

  /**
   * Compiles the given array of tokens (the output of a parse) to a reusable
   * function using the default writer.
   */
  mustache.compileTokens = function (tokens, template) {
    return defaultWriter.compileTokens(tokens, template);
  };

  /**
   * Renders the `template` with the given `view` and `partials` using the
   * default writer.
   */
  mustache.render = function (template, view, partials) {
    return defaultWriter.render(template, view, partials);
  };

  // This is here for backwards compatibility with 0.4.x.
  mustache.to_html = function (template, view, partials, send) {
    var result = mustache.render(template, view, partials);

    if (isFunction(send)) {
      send(result);
    } else {
      return result;
    }
  };

}));

},{}],6:[function(_dereq_,module,exports){
(function (process){
// vim:ts=4:sts=4:sw=4:
/*!
 *
 * Copyright 2009-2012 Kris Kowal under the terms of the MIT
 * license found at http://github.com/kriskowal/q/raw/master/LICENSE
 *
 * With parts by Tyler Close
 * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
 * at http://www.opensource.org/licenses/mit-license.html
 * Forked at ref_send.js version: 2009-05-11
 *
 * With parts by Mark Miller
 * Copyright (C) 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

(function (definition) {
    // Turn off strict mode for this function so we can assign to global.Q
    /*jshint strict: false*/

    // This file will function properly as a <script> tag, or a module
    // using CommonJS and NodeJS or RequireJS module formats.  In
    // Common/Node/RequireJS, the module exports the Q API and when
    // executed as a simple <script>, it creates a Q global instead.

    // Montage Require
    if (typeof bootstrap === "function") {
        bootstrap("promise", definition);

    // CommonJS
    } else if (typeof exports === "object") {
        definition(void 0, exports);

    // RequireJS
    } else if (typeof define === "function") {
        define(definition);

    // SES (Secure EcmaScript)
    } else if (typeof ses !== "undefined") {
        if (!ses.ok()) {
            return;
        } else {
            ses.makeQ = function () {
                var Q = {};
                return definition(void 0, Q);
            };
        }

    // <script>
    } else {
        definition(void 0, Q = {});
    }

})(function (_dereq_, exports) {
"use strict";

// All code after this point will be filtered from stack traces reported
// by Q.
var qStartingLine = captureLine();
var qFileName;

// shims

// used for fallback "defend" and in "allResolved"
var noop = function () {};

// for the security conscious, defend may be a deep freeze as provided
// by cajaVM.  Otherwise we try to provide a shallow freeze just to
// discourage promise changes that are not compatible with secure
// usage.  If Object.freeze does not exist, fall back to doing nothing
// (no op).
var defend = Object.freeze || noop;
if (typeof cajaVM !== "undefined") {
    defend = cajaVM.def;
}

// use the fastest possible means to execute a task in a future turn
// of the event loop.
var nextTick;
if (typeof process !== "undefined") {
    // node
    nextTick = process.nextTick;
} else if (typeof setImmediate === "function") {
    // In IE10, or use https://github.com/NobleJS/setImmediate
    nextTick = setImmediate;
} else if (typeof MessageChannel !== "undefined") {
    // modern browsers
    // http://www.nonblocking.io/2011/06/windownexttick.html
    var channel = new MessageChannel();
    // linked list of tasks (single, with head node)
    var head = {}, tail = head;
    channel.port1.onmessage = function () {
        head = head.next;
        var task = head.task;
        delete head.task;
        task();
    };
    nextTick = function (task) {
        tail = tail.next = {task: task};
        channel.port2.postMessage(0);
    };
} else {
    // old browsers
    nextTick = function (task) {
        setTimeout(task, 0);
    };
}

// Attempt to make generics safe in the face of downstream
// modifications.
// There is no situation where this is necessary.
// If you need a security guarantee, these primordials need to be
// deeply frozen anyway, and if you don’t need a security guarantee,
// this is just plain paranoid.
// However, this does have the nice side-effect of reducing the size
// of the code by reducing x.call() to merely x(), eliminating many
// hard-to-minify characters.
// See Mark Miller’s explanation of what this does.
// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
var uncurryThis;
// I have kept both variations because the first is theoretically
// faster, if bind is available.
if (Function.prototype.bind) {
    var Function_bind = Function.prototype.bind;
    uncurryThis = Function_bind.bind(Function_bind.call);
} else {
    uncurryThis = function (f) {
        return function () {
            return f.call.apply(f, arguments);
        };
    };
}

var array_slice = uncurryThis(Array.prototype.slice);

var array_reduce = uncurryThis(
    Array.prototype.reduce || function (callback, basis) {
        var index = 0,
            length = this.length;
        // concerning the initial value, if one is not provided
        if (arguments.length === 1) {
            // seek to the first value in the array, accounting
            // for the possibility that is is a sparse array
            do {
                if (index in this) {
                    basis = this[index++];
                    break;
                }
                if (++index >= length) {
                    throw new TypeError();
                }
            } while (1);
        }
        // reduce
        for (; index < length; index++) {
            // account for the possibility that the array is sparse
            if (index in this) {
                basis = callback(basis, this[index], index);
            }
        }
        return basis;
    }
);

var array_indexOf = uncurryThis(
    Array.prototype.indexOf || function (value) {
        // not a very good shim, but good enough for our one use of it
        for (var i = 0; i < this.length; i++) {
            if (this[i] === value) {
                return i;
            }
        }
        return -1;
    }
);

var array_map = uncurryThis(
    Array.prototype.map || function (callback, thisp) {
        var self = this;
        var collect = [];
        array_reduce(self, function (undefined, value, index) {
            collect.push(callback.call(thisp, value, index, self));
        }, void 0);
        return collect;
    }
);

var object_create = Object.create || function (prototype) {
    function Type() { }
    Type.prototype = prototype;
    return new Type();
};

var object_keys = Object.keys || function (object) {
    var keys = [];
    for (var key in object) {
        keys.push(key);
    }
    return keys;
};

var object_toString = Object.prototype.toString;

// generator related shims

function isStopIteration(exception) {
    return (
        object_toString(exception) === "[object StopIteration]" ||
        exception instanceof QReturnValue
    );
}

var QReturnValue;
if (typeof ReturnValue !== "undefined") {
    QReturnValue = ReturnValue;
} else {
    QReturnValue = function (value) {
        this.value = value;
    };
}

// long stack traces

var STACK_JUMP_SEPARATOR = "From previous event:";

function makeStackTraceLong(error, promise) {
    // If possible (that is, if in V8), transform the error stack
    // trace by removing Node and Q cruft, then concatenating with
    // the stack trace of the promise we are ``done``ing. See #57.
    if (promise.stack &&
        typeof error === "object" &&
        error !== null &&
        error.stack &&
        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
    ) {
        error.stack = filterStackString(error.stack) +
            "\n" + STACK_JUMP_SEPARATOR + "\n" +
            filterStackString(promise.stack);
    }
}

function filterStackString(stackString) {
    var lines = stackString.split("\n");
    var desiredLines = [];
    for (var i = 0; i < lines.length; ++i) {
        var line = lines[i];

        if (!isInternalFrame(line) && !isNodeFrame(line)) {
            desiredLines.push(line);
        }
    }
    return desiredLines.join("\n");
}

function isNodeFrame(stackLine) {
    return stackLine.indexOf("(module.js:") !== -1 ||
           stackLine.indexOf("(node.js:") !== -1;
}

function isInternalFrame(stackLine) {
    var pieces = /at .+ \((.*):(\d+):\d+\)/.exec(stackLine);

    if (!pieces) {
        return false;
    }

    var fileName = pieces[1];
    var lineNumber = pieces[2];

    return fileName === qFileName &&
        lineNumber >= qStartingLine &&
        lineNumber <= qEndingLine;
}

// discover own file name and line number range for filtering stack
// traces
function captureLine() {
    if (Error.captureStackTrace) {
        var fileName, lineNumber;

        var oldPrepareStackTrace = Error.prepareStackTrace;

        Error.prepareStackTrace = function (error, frames) {
            fileName = frames[1].getFileName();
            lineNumber = frames[1].getLineNumber();
        };

        // teases call of temporary prepareStackTrace
        // JSHint and Closure Compiler generate known warnings here
        /*jshint expr: true */
        new Error().stack;

        Error.prepareStackTrace = oldPrepareStackTrace;
        qFileName = fileName;
        return lineNumber;
    }
}

function deprecate(callback, name, alternative) {
    return function () {
        if (typeof console !== "undefined" && typeof console.warn === "function") {
            console.warn(name + " is deprecated, use " + alternative + " instead.", new Error("").stack);
        }
        return callback.apply(callback, arguments);
    };
}

// end of shims
// beginning of real work

/**
 * Performs a task in a future turn of the event loop.
 * @param {Function} task
 */
exports.nextTick = nextTick;

/**
 * Constructs a {promise, resolve} object.
 *
 * The resolver is a callback to invoke with a more resolved value for the
 * promise. To fulfill the promise, invoke the resolver with any value that is
 * not a function. To reject the promise, invoke the resolver with a rejection
 * object. To put the promise in the same state as another promise, invoke the
 * resolver with that other promise.
 */
exports.defer = defer;
function defer() {
    // if "pending" is an "Array", that indicates that the promise has not yet
    // been resolved.  If it is "undefined", it has been resolved.  Each
    // element of the pending array is itself an array of complete arguments to
    // forward to the resolved promise.  We coerce the resolution value to a
    // promise using the ref promise because it handles both fully
    // resolved values and other promises gracefully.
    var pending = [], progressListeners = [], value;

    var deferred = object_create(defer.prototype);
    var promise = object_create(makePromise.prototype);

    promise.promiseSend = function (op, _, __, progress) {
        var args = array_slice(arguments);
        if (pending) {
            pending.push(args);
            if (op === "when" && progress) {
                progressListeners.push(progress);
            }
        } else {
            nextTick(function () {
                value.promiseSend.apply(value, args);
            });
        }
    };

    promise.valueOf = function () {
        if (pending) {
            return promise;
        }
        return value.valueOf();
    };

    if (Error.captureStackTrace) {
        Error.captureStackTrace(promise, defer);

        // Reify the stack into a string by using the accessor; this prevents
        // memory leaks as per GH-111. At the same time, cut off the first line;
        // it's always just "[object Promise]\n", as per the `toString`.
        promise.stack = promise.stack.substring(promise.stack.indexOf("\n") + 1);
    }

    function become(resolvedValue) {
        if (!pending) {
            return;
        }
        value = resolve(resolvedValue);
        array_reduce(pending, function (undefined, pending) {
            nextTick(function () {
                value.promiseSend.apply(value, pending);
            });
        }, void 0);
        pending = void 0;
        progressListeners = void 0;
    }

    defend(promise);

    deferred.promise = promise;
    deferred.resolve = become;
    deferred.reject = function (exception) {
        become(reject(exception));
    };
    deferred.notify = function (progress) {
        if (pending) {
            array_reduce(progressListeners, function (undefined, progressListener) {
                nextTick(function () {
                    progressListener(progress);
                });
            }, void 0);
        }
    };

    return deferred;
}

/**
 * Creates a Node-style callback that will resolve or reject the deferred
 * promise.
 * @returns a nodeback
 */
defer.prototype.makeNodeResolver = function () {
    var self = this;
    return function (error, value) {
        if (error) {
            self.reject(error);
        } else if (arguments.length > 2) {
            self.resolve(array_slice(arguments, 1));
        } else {
            self.resolve(value);
        }
    };
};
// XXX deprecated
defer.prototype.node = deprecate(defer.prototype.makeNodeResolver, "node", "makeNodeResolver");

/**
 * @param makePromise {Function} a function that returns nothing and accepts
 * the resolve, reject, and notify functions for a deferred.
 * @returns a promise that may be resolved with the given resolve and reject
 * functions, or rejected by a thrown exception in makePromise
 */
exports.promise = promise;
function promise(makePromise) {
    var deferred = defer();
    fcall(
        makePromise,
        deferred.resolve,
        deferred.reject,
        deferred.notify
    ).fail(deferred.reject);
    return deferred.promise;
}

/**
 * Constructs a Promise with a promise descriptor object and optional fallback
 * function.  The descriptor contains methods like when(rejected), get(name),
 * put(name, value), post(name, args), and delete(name), which all
 * return either a value, a promise for a value, or a rejection.  The fallback
 * accepts the operation name, a resolver, and any further arguments that would
 * have been forwarded to the appropriate method above had a method been
 * provided with the proper name.  The API makes no guarantees about the nature
 * of the returned object, apart from that it is usable whereever promises are
 * bought and sold.
 */
exports.makePromise = makePromise;
function makePromise(descriptor, fallback, valueOf, exception) {
    if (fallback === void 0) {
        fallback = function (op) {
            return reject(new Error("Promise does not support operation: " + op));
        };
    }

    var promise = object_create(makePromise.prototype);

    promise.promiseSend = function (op, resolved /* ...args */) {
        var args = array_slice(arguments, 2);
        var result;
        try {
            if (descriptor[op]) {
                result = descriptor[op].apply(promise, args);
            } else {
                result = fallback.apply(promise, [op].concat(args));
            }
        } catch (exception) {
            result = reject(exception);
        }
        if (resolved) {
            resolved(result);
        }
    };

    if (valueOf) {
        promise.valueOf = valueOf;
    }

    if (exception) {
        promise.exception = exception;
    }

    defend(promise);

    return promise;
}

// provide thenables, CommonJS/Promises/A
makePromise.prototype.then = function (fulfilled, rejected, progressed) {
    return when(this, fulfilled, rejected, progressed);
};

makePromise.prototype.thenResolve = function (value) {
    return when(this, function () { return value; });
};

// Chainable methods
array_reduce(
    [
        "isResolved", "isFulfilled", "isRejected",
        "when", "spread", "send",
        "get", "put", "del",
        "post", "invoke",
        "keys",
        "apply", "call", "bind",
        "fapply", "fcall", "fbind",
        "all", "allResolved",
        "view", "viewInfo",
        "timeout", "delay",
        "catch", "finally", "fail", "fin", "progress", "end", "done",
        "nfcall", "nfapply", "nfbind",
        "ncall", "napply", "nbind",
        "npost", "ninvoke",
        "nend", "nodeify"
    ],
    function (undefined, name) {
        makePromise.prototype[name] = function () {
            return exports[name].apply(
                exports,
                [this].concat(array_slice(arguments))
            );
        };
    },
    void 0
);

makePromise.prototype.toSource = function () {
    return this.toString();
};

makePromise.prototype.toString = function () {
    return "[object Promise]";
};

defend(makePromise.prototype);

/**
 * If an object is not a promise, it is as "near" as possible.
 * If a promise is rejected, it is as "near" as possible too.
 * If it’s a fulfilled promise, the fulfillment value is nearer.
 * If it’s a deferred promise and the deferred has been resolved, the
 * resolution is "nearer".
 * @param object
 * @returns most resolved (nearest) form of the object
 */
exports.nearer = valueOf;
function valueOf(value) {
    if (isPromise(value)) {
        return value.valueOf();
    }
    return value;
}

/**
 * @returns whether the given object is a promise.
 * Otherwise it is a fulfilled value.
 */
exports.isPromise = isPromise;
function isPromise(object) {
    return object && typeof object.promiseSend === "function";
}

/**
 * @returns whether the given object can be coerced to a promise.
 * Otherwise it is a fulfilled value.
 */
exports.isPromiseAlike = isPromiseAlike;
function isPromiseAlike(object) {
    return object && typeof object.then === "function";
}

/**
 * @returns whether the given object is a resolved promise.
 */
exports.isResolved = isResolved;
function isResolved(object) {
    return isFulfilled(object) || isRejected(object);
}

/**
 * @returns whether the given object is a value or fulfilled
 * promise.
 */
exports.isFulfilled = isFulfilled;
function isFulfilled(object) {
    return !isPromiseAlike(valueOf(object));
}

/**
 * @returns whether the given object is a rejected promise.
 */
exports.isRejected = isRejected;
function isRejected(object) {
    object = valueOf(object);
    return isPromise(object) && 'exception' in object;
}

var rejections = [];
var errors = [];
var errorsDisplayed;
function displayErrors() {
    if (
        !errorsDisplayed &&
        typeof window !== "undefined" &&
        !window.Touch &&
        window.console
    ) {
        // This promise library consumes exceptions thrown in handlers so
        // they can be handled by a subsequent promise.  The rejected
        // promises get added to this array when they are created, and
        // removed when they are handled.
        console.log("Should be empty:", errors);
    }
    errorsDisplayed = true;
}

/**
 * Constructs a rejected promise.
 * @param exception value describing the failure
 */
exports.reject = reject;
function reject(exception) {
    var rejection = makePromise({
        "when": function (rejected) {
            // note that the error has been handled
            if (rejected) {
                var at = array_indexOf(rejections, this);
                if (at !== -1) {
                    errors.splice(at, 1);
                    rejections.splice(at, 1);
                }
            }
            return rejected ? rejected(exception) : reject(exception);
        }
    }, function fallback() {
        return reject(exception);
    }, function valueOf() {
        return this;
    }, exception);
    // note that the error has not been handled
    displayErrors();
    rejections.push(rejection);
    errors.push(exception);
    return rejection;
}

/**
 * Constructs a promise for an immediate reference.
 * @param value immediate reference
 */
exports.begin = resolve; // XXX experimental
exports.resolve = resolve;
exports.ref = deprecate(resolve, "ref", "resolve"); // XXX deprecated, use resolve
function resolve(object) {
    // If the object is already a Promise, return it directly.  This enables
    // the resolve function to both be used to created references from objects,
    // but to tolerably coerce non-promises to promises.
    if (isPromise(object)) {
        return object;
    }
    // In order to break infinite recursion or loops between `then` and
    // `resolve`, it is necessary to attempt to extract fulfilled values
    // out of foreign promise implementations before attempting to wrap
    // them as unresolved promises.  It is my hope that other
    // implementations will implement `valueOf` to synchronously extract
    // the fulfillment value from their fulfilled promises.  If the
    // other promise library does not implement `valueOf`, the
    // implementations on primordial prototypes are harmless.
    object = valueOf(object);
    // assimilate thenables, CommonJS/Promises/A
    if (isPromiseAlike(object)) {
        var deferred = defer();
        object.then(deferred.resolve, deferred.reject, deferred.notify);
        return deferred.promise;
    }
    return makePromise({
        "when": function () {
            return object;
        },
        "get": function (name) {
            return object[name];
        },
        "put": function (name, value) {
            object[name] = value;
            return object;
        },
        "del": function (name) {
            delete object[name];
            return object;
        },
        "post": function (name, value) {
            return object[name].apply(object, value);
        },
        "apply": function (self, args) {
            return object.apply(self, args);
        },
        "fapply": function (args) {
            return object.apply(void 0, args);
        },
        "viewInfo": function () {
            var on = object;
            var properties = {};

            function fixFalsyProperty(name) {
                if (!properties[name]) {
                    properties[name] = typeof on[name];
                }
            }

            while (on) {
                Object.getOwnPropertyNames(on).forEach(fixFalsyProperty);
                on = Object.getPrototypeOf(on);
            }
            return {
                "type": typeof object,
                "properties": properties
            };
        },
        "keys": function () {
            return object_keys(object);
        }
    }, void 0, function valueOf() {
        return object;
    });
}

/**
 * Annotates an object such that it will never be
 * transferred away from this process over any promise
 * communication channel.
 * @param object
 * @returns promise a wrapping of that object that
 * additionally responds to the "isDef" message
 * without a rejection.
 */
exports.master = master;
function master(object) {
    return makePromise({
        "isDef": function () {}
    }, function fallback() {
        var args = array_slice(arguments);
        return send.apply(void 0, [object].concat(args));
    }, function () {
        return valueOf(object);
    });
}

exports.viewInfo = viewInfo;
function viewInfo(object, info) {
    object = resolve(object);
    if (info) {
        return makePromise({
            "viewInfo": function () {
                return info;
            }
        }, function fallback() {
            var args = array_slice(arguments);
            return send.apply(void 0, [object].concat(args));
        }, function () {
            return valueOf(object);
        });
    } else {
        return send(object, "viewInfo");
    }
}

exports.view = view;
function view(object) {
    return viewInfo(object).when(function (info) {
        var view;
        if (info.type === "function") {
            view = function () {
                return apply(object, void 0, arguments);
            };
        } else {
            view = {};
        }
        var properties = info.properties || {};
        object_keys(properties).forEach(function (name) {
            if (properties[name] === "function") {
                view[name] = function () {
                    return post(object, name, arguments);
                };
            }
        });
        return resolve(view);
    });
}

/**
 * Registers an observer on a promise.
 *
 * Guarantees:
 *
 * 1. that fulfilled and rejected will be called only once.
 * 2. that either the fulfilled callback or the rejected callback will be
 *    called, but not both.
 * 3. that fulfilled and rejected will not be called in this turn.
 *
 * @param value      promise or immediate reference to observe
 * @param fulfilled  function to be called with the fulfilled value
 * @param rejected   function to be called with the rejection exception
 * @param progressed function to be called on any progress notifications
 * @return promise for the return value from the invoked callback
 */
exports.when = when;
function when(value, fulfilled, rejected, progressed) {
    var deferred = defer();
    var done = false;   // ensure the untrusted promise makes at most a
                        // single call to one of the callbacks

    function _fulfilled(value) {
        try {
            return typeof fulfilled === "function" ? fulfilled(value) : value;
        } catch (exception) {
            return reject(exception);
        }
    }

    function _rejected(exception) {
        if (typeof rejected === "function") {
            makeStackTraceLong(exception, resolvedValue);
            try {
                return rejected(exception);
            } catch (newException) {
                return reject(newException);
            }
        }
        return reject(exception);
    }

    function _progressed(value) {
        return typeof progressed === "function" ? progressed(value) : value;
    }

    var resolvedValue = resolve(value);
    nextTick(function () {
        resolvedValue.promiseSend("when", function (value) {
            if (done) {
                return;
            }
            done = true;

            deferred.resolve(_fulfilled(value));
        }, function (exception) {
            if (done) {
                return;
            }
            done = true;

            deferred.resolve(_rejected(exception));
        });
    });

    // Progress propagator need to be attached in the current tick.
    resolvedValue.promiseSend("when", void 0, void 0, function (value) {
        deferred.notify(_progressed(value));
    });

    return deferred.promise;
}

/**
 * Spreads the values of a promised array of arguments into the
 * fulfillment callback.
 * @param fulfilled callback that receives variadic arguments from the
 * promised array
 * @param rejected callback that receives the exception if the promise
 * is rejected.
 * @returns a promise for the return value or thrown exception of
 * either callback.
 */
exports.spread = spread;
function spread(promise, fulfilled, rejected) {
    return when(promise, function (valuesOrPromises) {
        return all(valuesOrPromises).then(function (values) {
            return fulfilled.apply(void 0, values);
        }, rejected);
    }, rejected);
}

/**
 * The async function is a decorator for generator functions, turning
 * them into asynchronous generators.  This presently only works in
 * Firefox/Spidermonkey, however, this code does not cause syntax
 * errors in older engines.  This code should continue to work and
 * will in fact improve over time as the language improves.
 *
 * Decorates a generator function such that:
 *  - it may yield promises
 *  - execution will continue when that promise is fulfilled
 *  - the value of the yield expression will be the fulfilled value
 *  - it returns a promise for the return value (when the generator
 *    stops iterating)
 *  - the decorated function returns a promise for the return value
 *    of the generator or the first rejected promise among those
 *    yielded.
 *  - if an error is thrown in the generator, it propagates through
 *    every following yield until it is caught, or until it escapes
 *    the generator function altogether, and is translated into a
 *    rejection for the promise returned by the decorated generator.
 *  - in present implementations of generators, when a generator
 *    function is complete, it throws ``StopIteration``, ``return`` is
 *    a syntax error in the presence of ``yield``, so there is no
 *    observable return value. There is a proposal[1] to add support
 *    for ``return``, which would permit the value to be carried by a
 *    ``StopIteration`` instance, in which case it would fulfill the
 *    promise returned by the asynchronous generator.  This can be
 *    emulated today by throwing StopIteration explicitly with a value
 *    property.
 *
 *  [1]: http://wiki.ecmascript.org/doku.php?id=strawman:async_functions#reference_implementation
 *
 */
exports.async = async;
function async(makeGenerator) {
    return function () {
        // when verb is "send", arg is a value
        // when verb is "throw", arg is an exception
        function continuer(verb, arg) {
            var result;
            try {
                result = generator[verb](arg);
            } catch (exception) {
                if (isStopIteration(exception)) {
                    return exception.value;
                } else {
                    return reject(exception);
                }
            }
            return when(result, callback, errback);
        }
        var generator = makeGenerator.apply(this, arguments);
        var callback = continuer.bind(continuer, "send");
        var errback = continuer.bind(continuer, "throw");
        return callback();
    };
}

/**
 * Throws a ReturnValue exception to stop an asynchronous generator.
 * Only useful presently in Firefox/SpiderMonkey since generators are
 * implemented.
 * @param value the return value for the surrounding generator
 * @throws ReturnValue exception with the value.
 * @example
 * Q.async(function () {
 *      var foo = yield getFooPromise();
 *      var bar = yield getBarPromise();
 *      Q.return(foo + bar);
 * })
 */
exports['return'] = _return;
function _return(value) {
    throw new QReturnValue(value);
}

/**
 * The promised function decorator ensures that any promise arguments
 * are resolved and passed as values (`this` is also resolved and passed
 * as a value).  It will also ensure that the result of a function is
 * always a promise.
 *
 * @example
 * var add = Q.promised(function (a, b) {
 *     return a + b;
 * });
 * add(Q.resolve(a), Q.resolve(B));
 *
 * @param {function} callback The function to decorate
 * @returns {function} a function that has been decorated.
 */
exports.promised = promised;
function promised(callback) {
    return function () {
        return all([this, all(arguments)]).spread(function (self, args) {
          return callback.apply(self, args);
        });
    };
}

/**
 * Constructs a promise method that can be used to safely observe resolution of
 * a promise for an arbitrarily named method like "propfind" in a future turn.
 */
exports.sender = deprecate(sender, "sender", "dispatcher"); // XXX deprecated, use dispatcher
exports.Method = deprecate(sender, "Method", "dispatcher"); // XXX deprecated, use dispatcher
function sender(op) {
    return function (object) {
        var args = array_slice(arguments, 1);
        return send.apply(void 0, [object, op].concat(args));
    };
}

/**
 * sends a message to a value in a future turn
 * @param object* the recipient
 * @param op the name of the message operation, e.g., "when",
 * @param ...args further arguments to be forwarded to the operation
 * @returns result {Promise} a promise for the result of the operation
 */
exports.send = deprecate(send, "send", "dispatch"); // XXX deprecated, use dispatch
function send(object, op) {
    var deferred = defer();
    var args = array_slice(arguments, 2);
    object = resolve(object);
    nextTick(function () {
        object.promiseSend.apply(
            object,
            [op, deferred.resolve].concat(args)
        );
    });
    return deferred.promise;
}

/**
 * sends a message to a value in a future turn
 * @param object* the recipient
 * @param op the name of the message operation, e.g., "when",
 * @param args further arguments to be forwarded to the operation
 * @returns result {Promise} a promise for the result of the operation
 */
exports.dispatch = dispatch;
function dispatch(object, op, args) {
    var deferred = defer();
    object = resolve(object);
    nextTick(function () {
        object.promiseSend.apply(
            object,
            [op, deferred.resolve].concat(args)
        );
    });
    return deferred.promise;
}

/**
 * Constructs a promise method that can be used to safely observe resolution of
 * a promise for an arbitrarily named method like "propfind" in a future turn.
 *
 * "dispatcher" constructs methods like "get(promise, name)" and "put(promise)".
 */
exports.dispatcher = dispatcher;
function dispatcher(op) {
    return function (object) {
        var args = array_slice(arguments, 1);
        return dispatch(object, op, args);
    };
}

/**
 * Gets the value of a property in a future turn.
 * @param object    promise or immediate reference for target object
 * @param name      name of property to get
 * @return promise for the property value
 */
exports.get = dispatcher("get");

/**
 * Sets the value of a property in a future turn.
 * @param object    promise or immediate reference for object object
 * @param name      name of property to set
 * @param value     new value of property
 * @return promise for the return value
 */
exports.put = dispatcher("put");

/**
 * Deletes a property in a future turn.
 * @param object    promise or immediate reference for target object
 * @param name      name of property to delete
 * @return promise for the return value
 */
exports["delete"] = // XXX experimental
exports.del = dispatcher("del");

/**
 * Invokes a method in a future turn.
 * @param object    promise or immediate reference for target object
 * @param name      name of method to invoke
 * @param value     a value to post, typically an array of
 *                  invocation arguments for promises that
 *                  are ultimately backed with `resolve` values,
 *                  as opposed to those backed with URLs
 *                  wherein the posted value can be any
 *                  JSON serializable object.
 * @return promise for the return value
 */
// bound locally because it is used by other methods
var post = exports.post = dispatcher("post");

/**
 * Invokes a method in a future turn.
 * @param object    promise or immediate reference for target object
 * @param name      name of method to invoke
 * @param ...args   array of invocation arguments
 * @return promise for the return value
 */
exports.invoke = function (value, name) {
    var args = array_slice(arguments, 2);
    return post(value, name, args);
};

/**
 * Applies the promised function in a future turn.
 * @param object    promise or immediate reference for target function
 * @param thisp     the `this` object for the call
 * @param args      array of application arguments
 */
// XXX deprecated, use fapply
var apply = exports.apply = deprecate(dispatcher("apply"), "apply", "fapply");

/**
 * Applies the promised function in a future turn.
 * @param object    promise or immediate reference for target function
 * @param args      array of application arguments
 */
var fapply = exports.fapply = dispatcher("fapply");

/**
 * Calls the promised function in a future turn.
 * @param object    promise or immediate reference for target function
 * @param thisp     the `this` object for the call
 * @param ...args   array of application arguments
 */
// XXX deprecated, use fcall
exports.call = deprecate(call, "call", "fcall");
function call(value, thisp) {
    var args = array_slice(arguments, 2);
    return apply(value, thisp, args);
}

/**
 * Calls the promised function in a future turn.
 * @param object    promise or immediate reference for target function
 * @param ...args   array of application arguments
 */
exports["try"] = fcall; // XXX experimental
exports.fcall = fcall;
function fcall(value) {
    var args = array_slice(arguments, 1);
    return fapply(value, args);
}

/**
 * Binds the promised function, transforming return values into a fulfilled
 * promise and thrown errors into a rejected one.
 * @param object    promise or immediate reference for target function
 * @param thisp   the `this` object for the call
 * @param ...args   array of application arguments
 */
exports.bind = deprecate(bind, "bind", "fbind"); // XXX deprecated, use fbind
function bind(value, thisp) {
    var args = array_slice(arguments, 2);
    return function bound() {
        var allArgs = args.concat(array_slice(arguments));
        return apply(value, thisp, allArgs);
    };
}

/**
 * Binds the promised function, transforming return values into a fulfilled
 * promise and thrown errors into a rejected one.
 * @param object    promise or immediate reference for target function
 * @param ...args   array of application arguments
 */
exports.fbind = fbind;
function fbind(value) {
    var args = array_slice(arguments, 1);
    return function fbound() {
        var allArgs = args.concat(array_slice(arguments));
        return fapply(value, allArgs);
    };
}

/**
 * Requests the names of the owned properties of a promised
 * object in a future turn.
 * @param object    promise or immediate reference for target object
 * @return promise for the keys of the eventually resolved object
 */
exports.keys = dispatcher("keys");

/**
 * Turns an array of promises into a promise for an array.  If any of
 * the promises gets rejected, the whole array is rejected immediately.
 * @param {Array*} an array (or promise for an array) of values (or
 * promises for values)
 * @returns a promise for an array of the corresponding values
 */
// By Mark Miller
// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
exports.all = all;
function all(promises) {
    return when(promises, function (promises) {
        var countDown = promises.length;
        if (countDown === 0) {
            return resolve(promises);
        }
        var deferred = defer();
        array_reduce(promises, function (undefined, promise, index) {
            if (isFulfilled(promise)) {
                promises[index] = valueOf(promise);
                if (--countDown === 0) {
                    deferred.resolve(promises);
                }
            } else {
                when(promise, function (value) {
                    promises[index] = value;
                    if (--countDown === 0) {
                        deferred.resolve(promises);
                    }
                })
                .fail(deferred.reject);
            }
        }, void 0);
        return deferred.promise;
    });
}

/**
 * Waits for all promises to be resolved, either fulfilled or
 * rejected.  This is distinct from `all` since that would stop
 * waiting at the first rejection.  The promise returned by
 * `allResolved` will never be rejected.
 * @param promises a promise for an array (or an array) of promises
 * (or values)
 * @return a promise for an array of promises
 */
exports.allResolved = allResolved;
function allResolved(promises) {
    return when(promises, function (promises) {
        return when(all(array_map(promises, function (promise) {
            return when(promise, noop, noop);
        })), function () {
            return array_map(promises, resolve);
        });
    });
}

/**
 * Captures the failure of a promise, giving an oportunity to recover
 * with a callback.  If the given promise is fulfilled, the returned
 * promise is fulfilled.
 * @param {Any*} promise for something
 * @param {Function} callback to fulfill the returned promise if the
 * given promise is rejected
 * @returns a promise for the return value of the callback
 */
exports["catch"] = // XXX experimental
exports.fail = fail;
function fail(promise, rejected) {
    return when(promise, void 0, rejected);
}

/**
 * Attaches a listener that can respond to progress notifications from a
 * promise's originating deferred. This listener receives the exact arguments
 * passed to ``deferred.notify``.
 * @param {Any*} promise for something
 * @param {Function} callback to receive any progress notifications
 * @returns the given promise, unchanged
 */
exports.progress = progress;
function progress(promise, progressed) {
    return when(promise, void 0, void 0, progressed);
}

/**
 * Provides an opportunity to observe the rejection of a promise,
 * regardless of whether the promise is fulfilled or rejected.  Forwards
 * the resolution to the returned promise when the callback is done.
 * The callback can return a promise to defer completion.
 * @param {Any*} promise
 * @param {Function} callback to observe the resolution of the given
 * promise, takes no arguments.
 * @returns a promise for the resolution of the given promise when
 * ``fin`` is done.
 */
exports["finally"] = // XXX experimental
exports.fin = fin;
function fin(promise, callback) {
    return when(promise, function (value) {
        return when(callback(), function () {
            return value;
        });
    }, function (exception) {
        return when(callback(), function () {
            return reject(exception);
        });
    });
}

/**
 * Terminates a chain of promises, forcing rejections to be
 * thrown as exceptions.
 * @param {Any*} promise at the end of a chain of promises
 * @returns nothing
 */
exports.end = deprecate(done, "end", "done"); // XXX deprecated, use done
exports.done = done;
function done(promise, fulfilled, rejected, progress) {
    function onUnhandledError(error) {
        // forward to a future turn so that ``when``
        // does not catch it and turn it into a rejection.
        nextTick(function () {
            makeStackTraceLong(error, promise);

            if (exports.onerror) {
                exports.onerror(error);
            } else {
                throw error;
            }
        });
    }

    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.
    var promiseToHandle = fulfilled || rejected || progress ?
        when(promise, fulfilled, rejected, progress) :
        promise;

    fail(promiseToHandle, onUnhandledError);
}

/**
 * Causes a promise to be rejected if it does not get fulfilled before
 * some milliseconds time out.
 * @param {Any*} promise
 * @param {Number} milliseconds timeout
 * @returns a promise for the resolution of the given promise if it is
 * fulfilled before the timeout, otherwise rejected.
 */
exports.timeout = timeout;
function timeout(promise, ms) {
    var deferred = defer();
    var timeoutId = setTimeout(function () {
        deferred.reject(new Error("Timed out after " + ms + " ms"));
    }, ms);

    when(promise, function (value) {
        clearTimeout(timeoutId);
        deferred.resolve(value);
    }, function (exception) {
        clearTimeout(timeoutId);
        deferred.reject(exception);
    });

    return deferred.promise;
}

/**
 * Returns a promise for the given value (or promised value) after some
 * milliseconds.
 * @param {Any*} promise
 * @param {Number} milliseconds
 * @returns a promise for the resolution of the given promise after some
 * time has elapsed.
 */
exports.delay = delay;
function delay(promise, timeout) {
    if (timeout === void 0) {
        timeout = promise;
        promise = void 0;
    }
    var deferred = defer();
    setTimeout(function () {
        deferred.resolve(promise);
    }, timeout);
    return deferred.promise;
}

/**
 * Passes a continuation to a Node function, which is called with the given
 * arguments provided as an array, and returns a promise.
 *
 *      Q.nfapply(FS.readFile, [__filename])
 *      .then(function (content) {
 *      })
 *
 */
exports.nfapply = nfapply;
function nfapply(callback, args) {
    var nodeArgs = array_slice(args);
    var deferred = defer();
    nodeArgs.push(deferred.makeNodeResolver());

    fapply(callback, nodeArgs).fail(deferred.reject);
    return deferred.promise;
}

/**
 * Passes a continuation to a Node function, which is called with the given
 * arguments provided individually, and returns a promise.
 *
 *      Q.nfcall(FS.readFile, __filename)
 *      .then(function (content) {
 *      })
 *
 */
exports.nfcall = nfcall;
function nfcall(callback/*, ...args */) {
    var nodeArgs = array_slice(arguments, 1);
    var deferred = defer();
    nodeArgs.push(deferred.makeNodeResolver());

    fapply(callback, nodeArgs).fail(deferred.reject);
    return deferred.promise;
}

/**
 * Wraps a NodeJS continuation passing function and returns an equivalent
 * version that returns a promise.
 *
 *      Q.nfbind(FS.readFile, __filename)("utf-8")
 *      .then(console.log)
 *      .done()
 *
 */
exports.nfbind = nfbind;
function nfbind(callback/*, ...args */) {
    var baseArgs = array_slice(arguments, 1);
    return function () {
        var nodeArgs = baseArgs.concat(array_slice(arguments));
        var deferred = defer();
        nodeArgs.push(deferred.makeNodeResolver());

        fapply(callback, nodeArgs).fail(deferred.reject);
        return deferred.promise;
    };
}

/**
 * Passes a continuation to a Node function, which is called with a given
 * `this` value and arguments provided as an array, and returns a promise.
 *
 *      Q.napply(FS.readFile, FS, [__filename])
 *      .then(function (content) {
 *      })
 *
 */
exports.napply = deprecate(napply, "napply", "npost");
function napply(callback, thisp, args) {
    return nbind(callback, thisp).apply(void 0, args);
}

/**
 * Passes a continuation to a Node function, which is called with a given
 * `this` value and arguments provided individually, and returns a promise.
 *
 *      Q.ncall(FS.readFile, FS, __filename)
 *      .then(function (content) {
 *      })
 *
 */
exports.ncall = deprecate(ncall, "ncall", "ninvoke");
function ncall(callback, thisp /*, ...args*/) {
    var args = array_slice(arguments, 2);
    return napply(callback, thisp, args);
}

/**
 * Wraps a NodeJS continuation passing function and returns an equivalent
 * version that returns a promise.
 *
 *      Q.nbind(FS.readFile, FS)(__filename)
 *      .then(console.log)
 *      .done()
 *
 */
exports.nbind = deprecate(nbind, "nbind", "nfbind");
function nbind(callback /* thisp, ...args*/) {
    if (arguments.length > 1) {
        var thisp = arguments[1];
        var args = array_slice(arguments, 2);

        var originalCallback = callback;
        callback = function () {
            var combinedArgs = args.concat(array_slice(arguments));
            return originalCallback.apply(thisp, combinedArgs);
        };
    }
    return function () {
        var deferred = defer();
        var args = array_slice(arguments);
        // add a continuation that resolves the promise
        args.push(deferred.makeNodeResolver());
        // trap exceptions thrown by the callback
        fapply(callback, args)
        .fail(deferred.reject);
        return deferred.promise;
    };
}

/**
 * Calls a method of a Node-style object that accepts a Node-style
 * callback with a given array of arguments, plus a provided callback.
 * @param object an object that has the named method
 * @param {String} name name of the method of object
 * @param {Array} args arguments to pass to the method; the callback
 * will be provided by Q and appended to these arguments.
 * @returns a promise for the value or error
 */
exports.npost = npost;
function npost(object, name, args) {
    var nodeArgs = array_slice(args);
    var deferred = defer();
    nodeArgs.push(deferred.makeNodeResolver());

    post(object, name, nodeArgs).fail(deferred.reject);
    return deferred.promise;
}

/**
 * Calls a method of a Node-style object that accepts a Node-style
 * callback, forwarding the given variadic arguments, plus a provided
 * callback argument.
 * @param object an object that has the named method
 * @param {String} name name of the method of object
 * @param ...args arguments to pass to the method; the callback will
 * be provided by Q and appended to these arguments.
 * @returns a promise for the value or error
 */
exports.ninvoke = ninvoke;
function ninvoke(object, name /*, ...args*/) {
    var nodeArgs = array_slice(arguments, 2);
    var deferred = defer();
    nodeArgs.push(deferred.makeNodeResolver());

    post(object, name, nodeArgs).fail(deferred.reject);
    return deferred.promise;
}

exports.nend = deprecate(nodeify, "nend", "nodeify"); // XXX deprecated, use nodeify
exports.nodeify = nodeify;
function nodeify(promise, nodeback) {
    if (nodeback) {
        promise.then(function (value) {
            nextTick(function () {
                nodeback(null, value);
            });
        }, function (error) {
            nextTick(function () {
                nodeback(error);
            });
        });
    } else {
        return promise;
    }
}

// All code before this point will be filtered from stack traces.
var qEndingLine = captureLine();

});

}).call(this,_dereq_("Mk2NyG"))
},{"Mk2NyG":1}],7:[function(_dereq_,module,exports){
'use strict';

var BoundingBox = module.exports = function(element, left, top){
	this.element = element;
	this.top = top || 0;
	this.left = left || 0;
	this.width = this.element.width;
	this.height = this.element.height;
	this.bottom = this.top + this.height;
	this.right = this.left + this.width;

	element.locations.push(this);
};

BoundingBox.prototype.show = function(container){
	if(this.visible) return;
	
	this.visible = true;
	this.element.show(this.left, this.top, container);
};

BoundingBox.prototype.hide = function(container){
	if(!this.visible) return;

	this.visible = false;
	this.element.hide(container);
};
},{}],8:[function(_dereq_,module,exports){
'use strict';

module.exports = Tag;

function Tag(){
	this.elements = [];
}

Tag.create = function(options){
	options = options || {};
	var tag = new Tag();
	
	if('skipProbability' in options) tag.skipProbability = options.skipProbability;
	if('tryLimit' in options) tag.tryLimit = options.tryLimit;

	return tag;
};

Tag.prototype.chanceMultiplier = 1;
Tag.prototype.skipProbability = 0;

Tag.prototype.add = function(element){
	var chanceMultiplier = element.chanceMultiplier;
	while(chanceMultiplier--) this.elements.push(element);
};

Tag.prototype.remove = function(element){
	var	index;

	// Remove all instances of the element
	while(~(index =  this.elements.indexOf(element))){
		this.elements.splice(index, 1);
	}
};

Tag.prototype.getElements = function(){
	return this.elements.slice();
};

Tag.prototype.getRandomElement = function(){
	return this.elements[(Math.random() * this.elements.length)|0];
};



},{}],9:[function(_dereq_,module,exports){
'use strict';

var Q = _dereq_('../bower_components/q/q.js');
var createQuadtree = _dereq_('../bower_components/giant-quadtree/dist/GiantQuadtree.js').create,
	Surface = _dereq_('../bower_components/big-surface/dist/BigSurface.js');

var BoundingBox = _dereq_('./BoundingBox.js'),
	Tag = _dereq_('./Tag.js');

var Collage = module.exports = function(container){
	Surface.call(this, container);
	this.quadtree = createQuadtree(15000);

	this.tags = {};
	this.activeTags = [];

	this.updateCanvasDimensions();
};

Collage.prototype = Object.create(Surface.prototype);

Collage.create = function(container){
	var collage = new Collage(container);
	return Collage.getApi(collage);
};

Collage.getApi = function(collage){
	var api = Surface.getApi(collage);

	api.createTag = collage.createTag.bind(collage);
	api.configureTag = collage.configureTag.bind(collage);
	
	api.setActiveTags = collage.setActiveTags.bind(collage);
	
	api.pause = collage.pause.bind(collage);
	api.resume = collage.resume.bind(collage);

	api.load = collage.loadElements.bind(collage);
	api.add = collage.addElements.bind(collage);
	api.remove = collage.removeElement.bind(collage);
	api.get = collage.getElements.bind(collage);
	api.showElement = collage.showElement.bind(collage);
	api.loader = collage.loader;

	api.fill = function(){
		collage.updateCanvasDimensions();
		collage.pickNextElement();

		if(collage.nextElement){
			return collage.fillCenter();	
		}

		return [];
	};

	api.start = collage.start.bind(collage);
	
	return api;
};

Collage.loader = _dereq_('./loader/index.js');
Collage.element = _dereq_('./element/index.js');

// How many random spot will be checked to place elements per frame
Collage.prototype.scanTryLimit = 20;

// Max number of frames an element has to find a place before another is picked
// this prevents large gaps due to large elements
Collage.prototype.missLimit = 4;

// Minimum pixel spacing between elements
Collage.prototype.elementMargin = 25;

// How much beyond the window to scan for places to put objects when filling
Collage.prototype.overScan = 0;

Collage.prototype.hidingArea =  document.createDocumentFragment();
Collage.prototype.minElementSize = 50;

Collage.prototype.createTag = function(name, options){
	this.tags[name] = Tag.create(options);
	return this.tags[name];
};

Collage.prototype.configureTag = function(name, options){
	var tag = this.tags[name];
	if(!tag){
		this.createTag(options);
		return;
	}

	if('skipProbability' in options) tag.skipProbability = options.skipProbability;
	if('tryLimit' in options) tag.tryLimit = options.tryLimit;
};

Collage.prototype.loadElements = function(tagNames, arg2, arg3){
	var addElements = this.addElements.bind(this, tagNames),
		loaderMap,
		loaderName,
		loader,
		loaderConfig,
		loaderConfigs,
		loaderConfigIndex,
		promise,
		promises = [];

	if(typeof arg2 === 'string'){
		// Handle the .load([tag name], [loader name], [loader config]) case
		loaderMap = {};
		loaderMap[arg2] = arg3;	
	} else {
		// Handle the .load([tag name], [loader map]) case
		loaderMap = arg2;
	} 

	for(loaderName in loaderMap){
		if(loaderMap.hasOwnProperty(loaderName)){
			loader = Collage.loader[loaderName];
			loaderConfigs = loaderMap[loaderName];
			if(!Array.isArray(loaderConfigs)) loaderConfigs = [loaderConfigs];		
			loaderConfigIndex = loaderConfigs.length;

			loaderConfig = loaderConfigs[--loaderConfigIndex];
			while(loaderConfig){
				promise = loader(this, loaderConfig).then(addElements);
				promises.push(promise);	
				loaderConfig = loaderConfigs[--loaderConfigIndex];
			}
		}
	}

	return Q.allResolved(promises);
};

Collage.prototype.addElements = function(tagNames, elements){
	if(!Array.isArray(tagNames)) tagNames = [tagNames];
	if(!Array.isArray(elements)) elements = [elements];
	
	var tagNameIndex = tagNames.length,
		tagName,
		tag,
		elementIndex;

	// For each tag...
	tagName = tagNames[--tagNameIndex];
	while(tagName){
		tag = this.tags[tagName] || this.createTag(tagName);
		elementIndex = elements.length;
		while(elementIndex--) tag.add(elements[elementIndex]);
		tagName = tagNames[--tagNameIndex];
	}
};

Collage.prototype.fadeInToCenter = function(){};

Collage.prototype.removeElement = function(tagNames, element){
	if(!Array.isArray(tagNames)) tagNames = [tagNames];
	
	var tagNameIndex = tagNames.length,
		tagName,
		tag;

	tagName = tagNames[tagNameIndex--];
	while(tagName){
		tag = this.tags[tagName];
		if(!tag) continue;
		tag.remove(element);
		tagName = tagNames[tagNameIndex--];
	}
};

Collage.prototype.getElements = function(){
	var tagNames = (arguments.length > 0)? arguments : Object.keys(this.tags),
		tagNameIndex = tagNames.length,
		tagName,
		tag,
		elements = [];

	tagName = tagNames[--tagNameIndex];
	while(tagName){
		tag = this.tags[tagName];
		if(tag){
			elements = elements.concat(tag.getElements());
		}
		tagName = tagNames[--tagNameIndex];
	}

	return elements;
};

Collage.prototype.setActiveTags = function(){
	var index = arguments.length,
		tagName,
		tag,
		chanceMultiplier,
		activeTags = [];

	tagName = arguments[--index];
	while(tagName){
		tag = this.tags[tagName];
		if(tag){
			chanceMultiplier = tag.chanceMultiplier;
			while(chanceMultiplier--) activeTags.push(tag);
		}
		tagName = arguments[--index];
	}

	this.activeTags = activeTags;
};

Collage.prototype.getRandomActiveTag = function(){
	var tag,
		failSafe = this.getRandomActiveTagFailSafe;

	while(failSafe--){
		tag = this.activeTags[(Math.random() * this.activeTags.length)|0];
		if(tag.skipProbability < Math.random()) break;
	}
	
	return tag;
};

Collage.prototype.pause = function(duration){
	if(this.savedHorizontalVelocityScalar !== void 0) return;
	this.savedHorizontalVelocityScalar = this.horizontalVelocityScalar;
	this.savedVerticalVelocityScalar = this.verticalVelocityScalar;
	this.setVelocityScalar(0, duration || 0.4);
};

Collage.prototype.resume = function(duration){
	if(this.savedHorizontalVelocityScalar === void 0) return;

	this.setHorizontalVelocityScalar(this.savedHorizontalVelocityScalar, (duration || 0.4));
	this.setVerticalVelocityScalar(this.savedVerticalVelocityScalar, (duration || 0.4));
	this.savedHorizontalVelocityScalar = void 0;
};

Collage.prototype.savedHorizontalVelocityScalar = void 0;
Collage.prototype.savedVerticalVelocityScalar = void 0;

Collage.prototype.getRandomActiveTagFailSafe = 20;
Collage.prototype.getRandomElementFailSafe = 20;
Collage.prototype.getRandomElementTryLimit = 20;
Collage.prototype.maxElementWidth = 2000;
Collage.prototype.maxElementHeight = 1000;

Collage.prototype.getRandomElement = function(){
	var failSafe = this.getRandomElementFailSafe,
		inCanvasRange = true,
		left = this.viewportLeft - this.maxElementWidth,
		top = this.viewportTop - this.maxElementHeight,
		right = this.viewportRight + this.maxElementWidth,
		bottom = this.viewportBottom + this.maxElementHeight,
		element,
		tag,
		tryLimit;

	while(inCanvasRange && failSafe--){
		tag = this.getRandomActiveTag();
		tryLimit = tag.tryLimit || this.getRandomElementTryLimit;

		while(tryLimit--){
			element = tag.getRandomElement();

			if(!element.isIn(left, top, right, bottom)){
				return element;
			}
		}
	}
};

Collage.prototype.transformStep = function(){
	Surface.prototype.transformStep.call(this);
	this.updateCanvasDimensions();
	this.updateElementVisibility();
	this.maxCheckHeight = 0;
	this.maxCheckWidth = 0;

	this.pickNextElement();
	if(this.nextElement) this.fill();
};

Collage.prototype.start = function(){
	if(arguments.length > 0) this.setActiveTags.apply(this, arguments);
	
	if(this.activeTags.length === 0){
		throw new Error('Unable to start without active tags');
	}
	this.startTransformLoop();
	this.updateCanvasDimensions();
	this.pickNextElement();

	if(this.nextElement){
		this.fillCenter();	
	}
};

Collage.prototype.pickNextElement = function(){
	this.nextElement = this.getRandomElement();
	this.missCount = 0;

	if(this.nextElement){
		this.updateBounds();
	}
};

Collage.prototype.insertNextElement = function(left, top, show){
	var box = this.showElement(this.nextElement, left, top, show);
	this.pickNextElement();
	return box;
};

Collage.prototype.showElement = function(element, left, top, show){
	var boundingBox = new BoundingBox(element, left, top);
	this.quadtree.insert(boundingBox);
	
	if(show){
		boundingBox.show(this.element);
	} else {
		boundingBox.hide(this.hidingArea);
	}

	return boundingBox;
};

Collage.prototype.getViewportBoundingBoxes = function(){
	return this.quadtree.getObjects(this.viewportLeft, this.viewportTop, this.viewportWidth, this.viewportHeight);
};


Collage.prototype.getViewportElements = function(){
	var boundingBoxes = this.getViewportBoundingBoxes(),
		index = boundingBoxes.length,
		result = [];

	// boundingBoxes.map would be proper but is less proc efficient
	while(index--) result.push(boundingBoxes[index].element);

	return result;
};

Collage.prototype.updateElementVisibility = function(){
	var oldBoxes = this.visibleBoxes || [],
		newBoxes = this.quadtree.getObjects(this.viewportLeft, this.viewportTop, this.viewportWidth, this.viewportHeight),
		index,
		box;

	// Mark old visible to hide
	index = oldBoxes.length;
	while(index--) oldBoxes[index].hidePending = true;

	index = newBoxes.length;
	while(index--){
		box = newBoxes[index];
		if(!box.visible) box.show(this.element);

		// Clear hide flags for things that are still visible
		box.hidePending = false;
	}

	// Hide elements no longer in view
	index = oldBoxes.length;
	while(index--){
		box = oldBoxes[index];
		if(box.hidePending) box.hide(this.hidingArea);
	}

	this.visibleBoxes = newBoxes;
};

Collage.prototype.updateCanvasDimensions = function(){
	this.viewportLeft = -1 * this.horizontalPosition - this.overScan;
	this.viewportTop = -1 * this.verticalPosition - this.overScan;
	this.viewportWidth = this.width + this.overScan * 2;
	this.viewportHeight = this.height + this.overScan * 2;
	this.viewportRight = this.viewportLeft + this.viewportWidth;
	this.viewportBottom = this.viewportTop + this.viewportHeight;
	
	this.movingUp = this.lastVerticalDisplacement > 0;
	this.movingLeft = this.lastHorizontalDisplacement > 0;
};

Collage.prototype.fillCenter = function(){
	var boxes = this.quadtree.getObjects(
		this.viewportLeft - this.checkWidth,
		this.viewportTop - this.checkHeight,
		this.viewportWidth + this.checkWidth * 2,
		this.viewportHeight + this.checkHeight * 2
	);

	var	boundingBoxes = [],
		scanCheckLeft,
		scanCheckTop,
		scanCheckRight,
		scanCheckBottom,

		tryCount = 0,
		tryLimit = this.scanTryLimit * 10,
		missCount = 0,
		missLimit = tryLimit / 20;

	for(;tryCount < tryLimit; tryCount++){
		missCount++;

		if(missCount > missLimit){
			missCount = 0;
			this.pickNextElement();
			if(!this.nextElement) break;
		}

		scanCheckLeft = (this.viewportLeft - this.checkWidth) + 
			Math.floor((this.viewportWidth + this.checkWidth) * Math.random());
		scanCheckTop = (this.viewportTop - this.checkHeight) + 
			Math.floor((this.viewportHeight + this.checkHeight) * Math.random());
		scanCheckRight = scanCheckLeft + this.checkWidth;
		scanCheckBottom = scanCheckTop + this.checkHeight;
	
		if(!hasCollision(boxes, scanCheckLeft, scanCheckTop, scanCheckRight, scanCheckBottom)){
			boundingBoxes.push(this.insertNextElement(scanCheckLeft + this.elementMargin, scanCheckTop + this.elementMargin));
			if(!this.nextElement) break;

			missCount = 0;
			boxes = this.quadtree.getObjects(
				this.viewportLeft - this.checkWidth,
				this.viewportTop - this.checkHeight,
				this.viewportWidth + this.checkWidth * 2,
				this.viewportHeight + this.checkHeight * 2
			);
		}
	}

	this.updateElementVisibility();
	return boundingBoxes;
};

Collage.prototype.updateBounds = function(){
	this.checkHeight = this.nextElement.height + this.elementMargin * 2;
	this.checkWidth = this.nextElement.width + this.elementMargin * 2;

	this.checkLeft = this.movingLeft ? (this.viewportLeft - this.checkWidth) : this.viewportRight;
	this.checkTop = this.movingUp ? this.viewportTop - this.checkHeight : this.viewportBottom;
	this.checkRight = this.checkLeft + this.checkWidth;
	this.checkBottom = this.checkTop + this.checkHeight;
		
	this.scanLeft = this.viewportLeft - this.checkWidth;
	this.scanTop = this.viewportTop - this.checkHeight;
	this.scanWidth = this.viewportWidth + this.checkWidth;
	this.scanHeight = this.viewportHeight + this.checkHeight;

	this.horizontalBoxes = this.quadtree.getObjects(
		(this.movingLeft ?  this.viewportLeft - this.checkWidth : this.viewportRight),
		this.scanTop,
		this.checkWidth,
		this.scanHeight + this.checkHeight
	);

	this.verticalBoxes = this.quadtree.getObjects(
		this.scanLeft,
		(this.movingUp ? (this.viewportTop - this.checkHeight) : this.viewportBottom),
		this.scanWidth + this.checkWidth,
		this.checkHeight
	);
};

function hasCollision(boxList, left, top, right, bottom){
	var index = boxList.length,
		box;

	while(index--){
		box = boxList[index];

		// If there is a y-axis intersection
		if ((top <= box.top ?
						(bottom >= box.top) :
						(box.bottom >= top)) && 
							// And if there is intersection along the x-axis
							(left <= box.left ?
								(right >= box.left) :
								(box.right >= left))){
			return true;
		}
	}

	return false;
}

Collage.prototype.fill = function(){
	var tryCount = 0,
		tryLimit = this.scanTryLimit,
		scanCheckLeft,
		scanCheckTop,
		scanCheckRight,
		scanCheckBottom;

	this.missCount++;
	if(this.missCount > this.missLimit){
		this.pickNextElement();
		if(!this.nextElement) return;
	}

	for(;tryCount < tryLimit; tryCount++){
		// VERTICAL
		scanCheckLeft = this.scanLeft + Math.floor(this.scanWidth * Math.random());
		scanCheckRight = scanCheckLeft + this.checkWidth;
		
		if(!hasCollision(this.verticalBoxes, scanCheckLeft, this.checkTop, scanCheckRight, this.checkBottom)){
			this.insertNextElement(scanCheckLeft + this.elementMargin, this.checkTop + this.elementMargin);
			if(!this.nextElement) break;
		}

		// HORIZONTAL
		scanCheckTop = this.scanTop + Math.floor(this.scanHeight * Math.random());
		scanCheckBottom = scanCheckTop + this.checkHeight;

		if(!hasCollision(this.horizontalBoxes, this.checkLeft, scanCheckTop, this.checkRight, scanCheckBottom)){
			var box = this.insertNextElement(this.checkLeft + this.elementMargin, scanCheckTop + this.elementMargin);
			this.horizontalBoxes.push(box);

			if(!this.nextElement) break;
		}
	}
};

},{"../bower_components/big-surface/dist/BigSurface.js":2,"../bower_components/giant-quadtree/dist/GiantQuadtree.js":4,"../bower_components/q/q.js":6,"./BoundingBox.js":7,"./Tag.js":8,"./element/index.js":14,"./loader/index.js":22}],10:[function(_dereq_,module,exports){
'use strict';

module.exports = BaseElement;

function BaseElement(domElement, width, height){
	this.element = domElement;
	this.width = width || domElement.width || parseInt(domElement.clientWidth);
	this.height = height || domElement.height || parseInt(domElement.clientHeight);
	this.locations = [];
	this.isVisible = undefined;
	
	this.element.style.position = 'absolute';
}

BaseElement.create = function(domElement, width, height){
	var element = new BaseElement(domElement, width, height);
	return BaseElement.getApi(element);
};

BaseElement.getApi = function(element){
	var api = {};
	api.element = element.element;
	api.isIn = element.isIn.bind(element);
	api.reposition = element.reposition.bind(element);
	api.show = element.show.bind(element);
	api.hide = element.hide.bind(element);

	Object.defineProperty(api, 'width', {
		get: function(){return element.width;}
	});

	Object.defineProperty(api, 'visible', {
		get: function(){return element.isVisible;}
	});

	Object.defineProperty(api, 'height', {
		get: function(){return element.height;}
	});

	Object.defineProperty(api, 'chanceMultiplier', {
		get: function(){return element.chanceMultiplier;},
		set: function(value){ element.chanceMultiplier = value;}
	});

	Object.defineProperty(api, 'locations', {
		get: function(){return element.locations; }
	});

	return api;
};

BaseElement.prototype.chanceMultiplier = 1;

BaseElement.prototype.isIn = function(left, top, right, bottom){
	var locationIndex = this.locations.length,
		boundingBox = this.locations[--locationIndex];

	while(boundingBox){
		if((((left < boundingBox.left && boundingBox.left < right) ||
				(boundingBox.right < right && left < boundingBox.right)) &&
			((top < boundingBox.top && boundingBox.top < bottom) || 
				(boundingBox.bottom < bottom && top < boundingBox.bottom)))){
			return true;
		}
		boundingBox = this.locations[--locationIndex];
	}

	return false;
};

BaseElement.prototype.reposition = function(left, top){
	this.element.style.left = left + 'px';
	this.element.style.top = top + 'px';
};

BaseElement.prototype.hide = function(){
	this.isVisible = false;
};

BaseElement.prototype.show = function(left, top){
	this.reposition(left, top);
	this.isVisible = true;
};
},{}],11:[function(_dereq_,module,exports){
'use strict';

var BaseElement = _dereq_('./Element.js');

module.exports = IframeElement;

// iOS has a rendering bug related to iframes,
var isiOS = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? true : false );

function IframeElement (element){
	BaseElement.call(this, element, parseInt(element.width), parseInt(element.height));

	this.iframe = this.element.querySelector('iframe') || this.element;
	this.isLocal = this.iframe.contentDocument && this.iframe.contentDocument.body && 
		this.iframe.contentDocument.body.innerHTML !== '';
	
	// Hack to fix for iOS's failure to render the inside of a iframe 
	// when using css transforms. If we have permission to edit the iframe,
	// this method is much more performant that the hack in .show
	if(isiOS && this.isLocal){
		this.iframe.contentDocument.body.style.webkitTransform = 'translate3d(0, 0, 0)';
	}
	
	this.hide();
}
IframeElement.prototype = Object.create(BaseElement.prototype);

IframeElement.create = function(element){
	element = new IframeElement(element);
	return IframeElement.getApi(element);
};

IframeElement.getApi = function(element){
	return BaseElement.getApi(element);
};

IframeElement.prototype.hide = function(){
	BaseElement.prototype.hide.call(this);
	this.element.style.opacity = 0;
	
	if(this.fidget){
		clearInterval(this.fidget);
		this.fidget = void 0;
	}
};

IframeElement.prototype.show = function(left, top){
	BaseElement.prototype.show.call(this, left, top);
	this.element.style.opacity = 1;

	// Hack to fix for iOS's failure to render the 
	// inside of a iframe when using css transforms.
	if(isiOS && !this.isLocal && !this.fidget){
		var iframe = this.iframe,
			flipper = 0.001;

		this.fidget = setInterval(function(){
			iframe.style.opacity = 1 + flipper;
			flipper *= -1;
		}, 200);
	}
};

},{"./Element.js":10}],12:[function(_dereq_,module,exports){
'use strict';

var BaseElement = _dereq_('./Element.js');

module.exports = SimpleElement;

function SimpleElement (element){
	BaseElement.call(this, element, parseInt(element.width), parseInt(element.height));
	this.appended = undefined;
}
SimpleElement.prototype = Object.create(BaseElement.prototype);

SimpleElement.create = function(element){
	element = new SimpleElement(element);
	return SimpleElement.getApi(element);
};

SimpleElement.getApi = function(element){
	return BaseElement.getApi(element);
};

//var hidingArea = document.createDocumentFragment();
SimpleElement.prototype.hide = function(){	
	BaseElement.prototype.hide.call(this);
	this.element.style.display = 'none';
	//hidingArea.appendChild(this.element);
};

SimpleElement.prototype.show = function(left, top, container){
	BaseElement.prototype.show.call(this, left, top);
	this.element.style.display = 'block';
	if(!this.appended){
		container.appendChild(this.element);
		this.appended = true;
	}
};
},{"./Element.js":10}],13:[function(_dereq_,module,exports){
'use strict';

var EventEmitter = _dereq_('../../bower_components/eventEmitter/EventEmitter.js').EventEmitter;
var BaseElement = _dereq_('./Element.js');
module.exports = VideoElement;

// Manages global tasks, such as periodic polling of players
// to gather time information
var timeManager = (function(){
	var ACTIVE_ELEMENTS = [],
		PERIODIC_LISTENER,
		api = {};

	api.add = function(element){
		ACTIVE_ELEMENTS.push(element);
		if(ACTIVE_ELEMENTS.length === 1){
			PERIODIC_LISTENER = setInterval(function(){
				ACTIVE_ELEMENTS.forEach(function(element){
					var time = Math.round(element.player.getCurrentTime()),
						elapsed = time - element.lastReportedTime;
					
					if(elapsed === 0) return;
					if(elapsed === 1){
						element.lastReportedTime = time;
						element.emitter.emit('time', time);
						element.emitter.emit('time:' + time);
					} else { // In case we missed some ticks, make up for them
						var start = element.lastReportedTime + 1;
						for(; start < time; start++){
							element.lastReportedTime = start;
							element.emitter.emit('time', start);
							element.emitter.emit('time:' + start);
						}
					}
				});
			}, 500); 	// 500 ms ensures that we account for fluctuations in 
					// timing so we report the time accurate to the second
		}
	};

	api.remove = function(element){
		var index = ACTIVE_ELEMENTS.indexOf(element);
		if(~index){
			ACTIVE_ELEMENTS.splice(index, 1);
			if(ACTIVE_ELEMENTS.length === 0){
				clearInterval(PERIODIC_LISTENER);  
			}	
		}
	};

	return api;
}());

function VideoElement (element, player){
	BaseElement.call(this, element);
	this.player = player;
	this.emitter = new EventEmitter();
	this.lastReportedTime = 0;
	player.addEventListener('onStateChange', this.statusChangeHandler.bind(this));
	player.addEventListener('onError', this.errorHandler.bind(this));
	this.hide();
}
VideoElement.prototype = Object.create(BaseElement.prototype);

VideoElement.create = function(element, player, options){
	var videoElement = new VideoElement(element, player);

	if(options.continuousPlay) videoElement.continuousPlay = true;
	if(options.autoplay) videoElement.autoplay = true;
	if(options.loop) videoElement.loop = true;
	
	return VideoElement.getApi(videoElement);
};

VideoElement.getApi = function(element){
	var api = BaseElement.getApi(element);
	api.player = element.player;
	api.element = element.element;
	api.on = element.emitter.on.bind(element.emitter);
	api.removeListener = element.emitter.removeListener.bind(element.emitter);
	api.destroy = element.destroy.bind(element);
	return api;
};

VideoElement.prototype.continuousPlay = false;
VideoElement.prototype.autoplay = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? false : true );
VideoElement.prototype.loop = false;
VideoElement.prototype.playing = false;

VideoElement.prototype.errorHandler = function(e){
	if(e.data === 150){
		console.log(this);
		this.destroy();
	}
};

VideoElement.prototype.destroy = function(){
	this.height = 0;
	this.width = 0;
	this.bottom = this.top;
	this.left = this.right;
	this.element.parentNode.removeChild(this.element);
};

VideoElement.prototype.hide = function(){
	BaseElement.prototype.hide.call(this);
	this.element.style.opacity = 0;
	
	if(!this.continuousPlay){
		this.player.pauseVideo();
	}
};

VideoElement.prototype.show = function(left, top){
	this.element.style.opacity = 1;
	BaseElement.prototype.show.call(this, left, top);
	
	if(this.playing && !this.continuousPlay){
		this.player.playVideo();
	} else if(!this.playing && this.autoplay) {
		this.playing = true;
		this.player.playVideo();
	}
};

VideoElement.prototype.statusChangeHandler = function(status){
	switch(status.data){
		case -1:
			this.emitter.emit('unstarted');
		break;
		case 0:
			this.emitter.emit('ended');
			timeManager.remove(this);
			if(this.loop){
				this.player.seekTo(0);
				this.player.playVideo();
			}
		break;
		case 1:
			this.emitter.emit('playing');
			timeManager.add(this);
		break;
		case 2:
			this.emitter.emit('paused');
			timeManager.remove(this);
		break;
		case 3:
			this.emitter.emit('buffering');
		break;
		case 5:
			this.emitter.emit('video cued');
		break;
	}
};
},{"../../bower_components/eventEmitter/EventEmitter.js":3,"./Element.js":10}],14:[function(_dereq_,module,exports){
'use strict';

exports.Iframe = _dereq_('./Iframe.js');
exports.Simple = _dereq_('./Simple.js');
exports.Video = _dereq_('./Video.js');
},{"./Iframe.js":11,"./Simple.js":12,"./Video.js":13}],15:[function(_dereq_,module,exports){
'use strict';
/* globals FB */

var Q = _dereq_('../../bower_components/q/q.js'),
	getFromApi = _dereq_('./getFromCommonApi.js'),
	IframeElement = _dereq_('../element/Iframe.js'),
	utils = _dereq_('../utils.js');

var endpoint = 'https://graph.facebook.com/search';
//var endpoint = '/search';

window.credits = window.credits || {};
var credits = window.credits.facebook = {};

module.exports = function(collage, options){
	if(!options.type) options.type = 'pages';
	
	switch(options.type){
		case 'pages':
			return createPages(collage, options);
	}
};
/*
var ACTIVITY_BOX_TEMPLATE = '<div class="fb-activity" data-site="www.hrc.org" ' + 
	'data-width="{{width}}" data-height="{{height}}" data-header="false" ' + 
	'data-recommendations="false"></div>';
var LIKE_BOX_TEMPLATE = '<div class="fb-like-box" ' + 
	'data-href="http://www.facebook.com/{{id}}" data-width="{{width}}" ' + 
	'data-height="{{height}}" data-show-faces="true" data-stream="false" ' + 
	'data-header="false"></div>';
*/
var defaults = {
	limit: 3,
	width: 400,
	height: 600,
	minLikes: 0,
	showFaces: true,
	showStream: true,
	showHeader: false,
	ids: []
};

function createPages(collage, options){
	utils.extend(options, defaults);
	var ids = options.ids;
	
	if(options.query){
		return getFromApi(endpoint, [
			'type=page',
			'fields=name,link,likes,category',
			'limit=' + options.limit,
			'q=' + encodeURIComponent(options.query)
		]).then(function(response){
			response.data.forEach(function(item){
				if(item.likes < options.minLikes) return;
			
				credits[item.name] = item.link;
				ids.push(item.id);
			});

			return loadLikeBoxes(collage, ids, options);
		});
	} else {
		return Q.when(loadLikeBoxes(collage, ids, options));
	}
}

function loadLikeBoxes(collage, ids, options){
	var elements = [];

	ids.forEach(function(id){
		var element = document.createElement('div');
		element.className='fb-like-box';
		element.setAttribute('data-href', 'http://www.facebook.com/' + id);
		element.setAttribute('data-width', options.width);
		element.setAttribute('data-height', options.height);
		element.setAttribute('data-show-faces', options.showFaces);
		element.setAttribute('data-stream', options.showStream);
		element.setAttribute('data-header', options.showHeader);

		var iframeElement = utils.attachIframeToCollage(collage, element, options.width, options.height);
		
		FB.XFBML.parse(iframeElement);

		elements.push(new IframeElement(iframeElement));
	});
	
	return elements;
}

},{"../../bower_components/q/q.js":6,"../element/Iframe.js":11,"../utils.js":27,"./getFromCommonApi.js":17}],16:[function(_dereq_,module,exports){
'use strict';
/* jslint camelcase:false */
var Q = _dereq_('../../bower_components/q/q.js'),
	SimpleElement = _dereq_('../element/Simple.js'),
	utils = _dereq_('../utils.js'),
	getFromApi = _dereq_('./getFromCommonApi.js');

window.credits = window.credits || {};
var credits = window.credits.flickr = {};

var endpoint = 'https://api.flickr.com/services/rest/';
//var endpoint = '/services/rest/';

module.exports = getPhotos;

var defaults = {
	sort: 'relevance',
	count: '20',
	license: '1,2,3,4,5,6,7,8', // http://www.flickr.com/services/api/flickr.photos.licenses.getInfo.html
	apiKey: '06960d3c3c8affd01e65ec032513557b',
	media: 'photos',
	tagMode: 'all',
	isCommons: false,
	contentType: '1' // Photos only (not screenshots or drawings)
};

function getPhotos(collage, options){
	var deferred = Q.defer(),
		params;
	
	if(typeof options === 'string') options = {tags: options};
	utils.extend(options, defaults);

	params = [
		'format=json',
		'method=flickr.photos.search',
		'extras=url_z,url_m,path_alias',
		'api_key=' + options.apiKey,
		'license=' + options.license, 
		'sort=' + options.sort,
		'tag_mode=' + options.tagMode,
		'per_page=' + options.count,
		'content_type=' + options.contentType,
		'media=' + options.media,
		'tags=' + options.tags,
		'api_key=' + '50af342c4178f4a984377a4b4b55998b'
	];

	if(options.isCommons){
		params.push('is_commons=' + options.isCommons);
	}

	getFromApi(endpoint, 'jsoncallback', params).then(function(response){
		var elements = [],
			photos = response.photos && response.photos.photo || [],
			waiting = photos.length;

		photos.forEach(function(item){
			var url = item.url_z || item.url_m;

			if(!url){
				waiting--;
				return;
			}

			loadImage(item.url_z || item.url_m).then(function(element){
				var anchor = document.createElement('a');
				anchor.href = 'http://www.flickr.com/photos/' + item.pathalias + '/' + item.id + '/';
				anchor.width = element.width;
				anchor.height = element.height;
				anchor.target = '_blank';
				anchor.style.display = 'block';
				anchor.appendChild(element);
				
				credits[item.pathalias] = anchor.href;
				
				elements.push(SimpleElement.create(anchor));
				if(--waiting === 0) deferred.resolve(elements);
			}, function(){
				if(--waiting === 0) deferred.resolve(elements);
			});
		});
	});

	return deferred.promise;
}

var documentFragment = document.createDocumentFragment();
function loadImage(src){
	var	deferred = Q.defer(),
		img = new Image();
	
	img.src = src;

	img.onload = function(){
		// This forces FF to set the width/height
		documentFragment.appendChild(img);
		deferred.resolve(img);
	};

	img.onerror = deferred.reject.bind(deferred);

	return deferred.promise;
}
},{"../../bower_components/q/q.js":6,"../element/Simple.js":12,"../utils.js":27,"./getFromCommonApi.js":17}],17:[function(_dereq_,module,exports){
'use strict';

var Q = _dereq_('../../bower_components/q/q.js');

window.API_CALLBACKS = {};

module.exports = (function(){
	var callbackCounter = 0,
		callbacks = window.API_CALLBACKS,
		defaultTimeout = 10 * 1000;

	return function(endpoint, callbackParam, params, timeout){
		var callbackId = 'c' + callbackCounter++,
			deferred = Q.defer(),
			script = document.createElement('script'),
			timeoutId;
		
		if(typeof callbackParam !== 'string'){
			timeout = params;
			params = callbackParam;
			callbackParam = 'callback';
		}

		timeout = timeout || defaultTimeout;
		params = params || [];
		params.push(callbackParam + '=API_CALLBACKS.' + callbackId);

		timeoutId = setTimeout(function(){
			deferred.reject('timeout');
		}, timeout);
		
		callbacks[callbackId] = function(response){
			clearTimeout(timeoutId);
			delete callbacks[callbackId];
			deferred.resolve(response);
		};

		script.async = true;
		script.src = endpoint + '?' + params.join('&'); 
		document.body.appendChild(script);

		return deferred.promise;
	};
}());
},{"../../bower_components/q/q.js":6}],18:[function(_dereq_,module,exports){
'use strict';

// This one is a bit questionable since it's deprecated, and the TOS for use in
// collages is unclear.

var mustache = _dereq_('../../bower_components/mustache/mustache.js');
var getFromApi = _dereq_('./getFromCommonApi.js');
var SimpleElement = _dereq_('../element/Simple.js');
	
window.credits = window.credits || {};
var credits = window.credits.googleNews = {};

module.exports = function(collage, query){
	return search(query);
};

var ARTICLE_TEMPLATE = '' +
'<div class="article-wrapper">' +
	'{{#image}}' +
		'<a href="{{image.contextUrl}}">' +
			'<img title="Image by {{image.publisher}}" class="article-image" ' + 
			'src="{{image.src}}" width="{{image.width}}" height="{{image.height}}"/>' + 
		'</a>' +
	'{{/image}}' +
	'<a class="article-title" href="{{sourceUrl}}">{{{title}}}</a>' + 
	'<p class="article-attribution">' +
		'<span class="article-publisher">{{{publisher}}}</span>' +
		' &ndash; <span class="article-date">{{date}}</span>' +
		' via {{#gnewsUrl}}<a class="article-via" href="{{gnewsUrl}}">{{/gnewsUrl}}' + 
		'Google News{{#gnewsUrl}}</a>{{/gnewsUrl}}' +
	'</p>' +
	'<p class="article-body">{{{body}}}</p>' +
'</div>';

var documentFragment = document.createDocumentFragment();

var search = (function(){
	var endpoint = 'https://ajax.googleapis.com/ajax/services/search/news';
	//var endpoint = '/ajax/services/search/news';

	return function(query){
		var params = [
				'v=1.0',
				'rsz=8',
				'q=' + encodeURIComponent(query)
			];
		
		return getFromApi(endpoint, params).then(function(response){
			var elements = [];
			response.responseData.results.forEach(function(item){
				credits[item.publisher] = item.unescapedUrl;

				var templateParams = {
					title: item.titleNoFormatting,
					sourceUrl: item.unescapedUrl,
					publisher: item.publisher,
					date: (new Date(item.publishedDate)).toLocaleDateString(),
					gnewsUrl: item.clusterUrl,
					body: item.content
				};
								
				if(item.image){
					templateParams.image = {
						src: item.image.tbUrl,
						width: item.image.tbWidth,
						height: item.image.tbHeight,
						publisher: item.image.publisher,
						contextUrl: item.image.originalContextUrl
					};
				}

				var element = document.createElement('div');
				element.className = 'gnews-article';
				element.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateParams);
				document.body.appendChild(element);
				
				element.width = element.clientWidth;
				element.height = element.clientHeight;

				elements.push(new SimpleElement(element));
				documentFragment.appendChild(element);
			});

			return elements;
		});
	};
}());


},{"../../bower_components/mustache/mustache.js":5,"../element/Simple.js":12,"./getFromCommonApi.js":17}],19:[function(_dereq_,module,exports){
'use strict';

var mustache = _dereq_('../../bower_components/mustache/mustache.js');
var getFromApi = _dereq_('./getFromCommonApi.js');
var SimpleElement = _dereq_('../element/Simple.js');
	
module.exports = function(collage, query){
	return queryActivities(query);
};

var ARTICLE_TEMPLATE = '' +
'<div class="article-wrapper">' +
	'<div class="post-attribution">' +
		'<a href="{{authorUrl}}">' +
			'{{#authorImage}}<img class="author-image" src="{{authorImage.src}}" ' + 
				'width="{{authorImage.width}}" height="{{authorImage.height}}"/>{{/authorImage}}' +
			'<span class="author-name">{{authorName}}</span>' +
		'</a>' + 
		'<span class="post-date">on Google Plus &ndash; {{date}}</span>' +
	'</div>' +
	'<p class="author-comments">{{{authorComments}}}</p>' + 
	'<div class="article">' + 
		'<a href="{{articleUrl}}">' +
			'{{#image}}<img class="article-image" src="{{image.src}}" width="{{image.width}}" ' + 
				'height="{{image.height}}"/>{{/image}}' + 
			'<div class="article-attribution">' +
				'<span>{{title}}</span>' + 
			'</div>' + 
		'</a>' +
		'<p class="article-body">{{body}}</p>' +
	'</div>' +
'</div>';

var documentFragment = document.createDocumentFragment();

var queryActivities = (function(){
	var endpoint = 'https://www.googleapis.com/plus/v1/activities';

	return function(query){
		var params = [
				'key=AIzaSyAZw0kviWeCOidthcZAYs5oCZ0k8DsOuUk',
				'query=' + encodeURIComponent(query)
			];
		
		return getFromApi(endpoint, params).then(function(response){
			var elements = [];

			response.items.forEach(function(item){
				if(!(item && item.object && item.object.attachments && item.object.attachments.length > 0)) return;
				var article = item.object.attachments[0];
				if(article.objectType !== 'article') return;

				var actor = item.object.actor || item.actor,
					authorComments = item.object.content;
				if(authorComments && authorComments.length > 150){
					authorComments = authorComments.substr(0, 150) + '&hellip;';
				}

				var templateParams = {
					authorName: actor.displayName,
					authorUrl: actor.url,
					authorId: actor.id,
					date: new Date(item.published).toLocaleDateString(),
					authorComments: authorComments,
					articleUrl: article.url,
					title: article.displayName,
					body: article.content
				};
								
				if(actor.image){
					templateParams.authorImage = {
						src: actor.image.url,
						width: 50,
						height: 50
					};
				}

				if(article.image){
					templateParams.image = {
						src: article.image.url,
						width: article.image.width,
						height: article.image.height
					};
				}
				
				var element = document.createElement('div');
				element.className = 'gplus-article';
				element.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateParams);
				document.body.appendChild(element);
				
				element.width = element.clientWidth;
				element.height = element.clientHeight;

				elements.push(new SimpleElement(element));
				documentFragment.appendChild(element);

			});

			return elements;
		});
	};
}());

},{"../../bower_components/mustache/mustache.js":5,"../element/Simple.js":12,"./getFromCommonApi.js":17}],20:[function(_dereq_,module,exports){
'use strict';

var Q = _dereq_('../../bower_components/q/q.js'),
	IframeElement = _dereq_('../element/Iframe.js'),
	utils = _dereq_('../utils.js');

module.exports = function(collage, options){
	var width = options.width || 500,
		height = options.height || 500;

	var iframe = document.createElement('iframe');
	iframe.src = options.url;

	var element = utils.attachIframeToCollage(collage, iframe, width, height);

	return Q.when(new IframeElement(element));
};

},{"../../bower_components/q/q.js":6,"../element/Iframe.js":11,"../utils.js":27}],21:[function(_dereq_,module,exports){
'use strict';

var Q = _dereq_('../../bower_components/q/q.js');
var SimpleElement = _dereq_('../element/Simple.js');

var documentFragment = document.createDocumentFragment();

module.exports = function(collage, src){
	var	deferred = Q.defer(),
		img = new Image();
	
	img.src = src;

	img.onload = function(){
		// This forces FF to set the width/height
		documentFragment.appendChild(img);
		deferred.resolve(new SimpleElement(img));
	};

	img.onerror = deferred.reject.bind(deferred);

	return deferred.promise;
};
},{"../../bower_components/q/q.js":6,"../element/Simple.js":12}],22:[function(_dereq_,module,exports){
'use strict';

exports.flickr = _dereq_('./flickr.js');
exports.image = _dereq_('./image.js');
exports.youtube = _dereq_('./youtube.js');
exports.googlePlus = _dereq_('./googlePlus.js');
exports.googleNews = _dereq_('./googleNews.js');
exports.nyTimes = _dereq_('./nyTimes.js');
exports.twitter = _dereq_('./twitter.js');
exports.facebook = _dereq_('./facebook.js');
exports.iframe = _dereq_('./iframe.js');
exports.reddit = _dereq_('./reddit.js');
},{"./facebook.js":15,"./flickr.js":16,"./googleNews.js":18,"./googlePlus.js":19,"./iframe.js":20,"./image.js":21,"./nyTimes.js":23,"./reddit.js":24,"./twitter.js":25,"./youtube.js":26}],23:[function(_dereq_,module,exports){
'use strict';

/* jshint camelcase:false */

var Q = _dereq_('../../bower_components/q/q.js'),
	SimpleElement = _dereq_('../element/Simple.js'),
	mustache = _dereq_('../../bower_components/mustache/mustache.js');

window.credits = window.credits || {};
var credits = window.credits.nyTimes = {};

var ARTICLE_TEMPLATE = '' +
		'<h2><a href="{{url}}">{{{title}}}</a></h2>' +
		'{{#image}}<img class="article-image" src="{{image.src}}" ' + 
			'width="{{image.width}}" height="{{image.height}}"/>{{/image}}' + 
		'<div class="article-attribution">' +
			'<img class="nyt-brand" ' + 
				'src="http://graphics8.nytimes.com/packages/images/developer/' + 
				'logos/poweredby_nytimes_30a.png"/>' +
			'<span class="byline">{{{byline}}}</span>' + 
			'<span class="date">{{date}}</span>' + 
		'</div>' +
		'<p>{{{body}}}</p>';

var documentFragment = document.createDocumentFragment();

var endpoint = '/svc/search/v1/article';
//var endpoint = "http://api.nytimes.com/svc/search/v1/article";

module.exports = function(collage, options){
	return query(options);
};

function query(options){
	function parseResponse(data){
		return data.results.map(function(data){
			var element = document.createElement('div');
			element.className = 'nytimes-article';

			if(data.byline){
				credits[data.byline.replace('By ', '')] = data.url;
			}
			
			var templateData = {
				title: data.title,
				byline: data.byline,
				date: (new Date(data.publication_year, data.publication_month, data.publication_day)).toLocaleDateString(),
				body: data.body,
				url: data.url
			};

			if(data.small_image_url){
				templateData.image = {
					src: data.small_image_url.replace(/thumbStandard.*\./, 'hpMedium.'),
					height: 253,
					width: 337
				};
			}

			element.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateData);
			document.body.appendChild(element);

			element.width = element.clientWidth;
			element.height = element.clientHeight;

			documentFragment.appendChild(element);
			return new SimpleElement(element);
		});
	}

	if(options.data){
		return Q.when(parseResponse(options.data));
	} else {

	}
	return load(options).then(function(response){
		return parseResponse(response);
	});
}

function load(options){
	var deferred = Q.defer();

	var params = [
		'format=json',
		'fields=publication_year,publication_month,publication_day,body,date,' + 
			'title,url,byline,small_image_url,small_image_height,small_image_width',
		'api-key=af04c123c8988a12245668f5b5fa4f4c:8:67325739',
		'query=' + options.query
	];
	
	var request = new XMLHttpRequest();

	request.onload = function(){
		deferred.resolve(JSON.parse(this.responseText));
	};

	request.onerror = function(){
		deferred.reject();
	};

	request.open('get', endpoint + '?' + params.join('&'), true);
	request.send();

	return deferred.promise;
}

},{"../../bower_components/mustache/mustache.js":5,"../../bower_components/q/q.js":6,"../element/Simple.js":12}],24:[function(_dereq_,module,exports){
'use strict';

/* jshint camelcase:false */

var Q = _dereq_('../../bower_components/q/q.js'),
	SimpleElement = _dereq_('../element/Simple.js'),
	IframeElement = _dereq_('../element/Iframe.js'),
	utils = _dereq_('../utils.js'),
	getFromApi = _dereq_('./getFromCommonApi.js');

window.credits = window.credits || {};
var credits = window.credits.reddit = {};

var endpoint = 'http://www.reddit.com/r/all/search.json';
//var endpoint = '/r/all/search.json';

module.exports = function(collage, options){
	if(options.type === 'embed'){
		return getEmbed(collage, options);
	} else {
		return getPhotos(collage, options);
	}
};

function getEmbed(collage, options){
	utils.extend(options, defaults);
	var params = [
		'limit=' + options.limit,
		'restrict_sr=' + options.restrict_sr, 
		'sort=' + options.sort,
		't=' + options.time,
		'q=' + options.query
	];

	var iframe = document.createElement('IFRAME'),
		iframeDoc,
		iframeContent;

	var element = utils.attachIframeToCollage(collage, iframe, options.width, options.height);

	iframeDoc = (iframe.contentDocument) ? iframe.contentDocument : iframe.contentWindow.document;
	iframeContent = '<html><head><title></title></head><body>';
	iframeContent += '<script type="text/javascript" src="http://www.reddit.com/r/' + 
		options.subreddit + '/search.embed?' + params.join('&').replace(' ', '%20') + '"></script>';
	iframeContent += '</body></html>';
	
	iframeDoc.open();
	iframeDoc.write(iframeContent);
	iframeDoc.close();
	
	return Q.when(new IframeElement(element));
}

var defaults = {
	limit: '20',
	subreddit: 'all',
	restrict_sr: 'false',
	sort: 'top',
	time: 'all',
	nsfw: 'false',
	minComments: 0,
	width: 500,
	height:600,
	minScore: 0
};

function getPhotos(collage, options){
	var deferred = Q.defer(),
		params;
	
	if(typeof options === 'string') options = {tags: options};
	utils.extend(options, defaults);

	params = [
		'limit=' + options.limit,
		'restrict_sr=' + options.restrict_sr, 
		'sort=' + options.sort,
		't=' + options.time,
		'q=' + options.query
	];
	
	getFromApi(endpoint, 'jsonp', params).then(function(response){
		var elements = [],
			photos = response.data && response.data.children || [],
			waiting;

		photos = photos.filter(function(item){
			item = item.data;

			if(	item.score < options.minScore || 
				item.num_comments < options.minComments ||
				(!~item.url.indexOf('.jpg'))){
				return false;	
			}

			return true;
		});

		waiting = photos.length;
		photos.forEach(function(item){
			item = item.data;
			
			credits[item.author] = 'http://www.reddit.com' + item.permalink;
			
			loadImage(item.url).then(function(element){
				var anchor = document.createElement('a');
				anchor.href = 'http://www.reddit.com' + item.permalink;
				anchor.width = element.width;
				anchor.height = element.height;
				anchor.target = '_blank';
				anchor.style.display = 'block';
				anchor.appendChild(element);
				
				elements.push(SimpleElement.create(anchor));

				if(--waiting === 0) deferred.resolve(elements);
			}, function(){
				if(--waiting === 0) deferred.resolve(elements);
			});
		});
	});

	return deferred.promise;
}

var documentFragment = document.createDocumentFragment();
function loadImage(src){
	var	deferred = Q.defer(),
		img = new Image();
	
	img.src = src;

	img.onload = function(){
		// This forces FF to set the width/height
		documentFragment.appendChild(img);
		deferred.resolve(img);
	};

	img.onerror = deferred.reject.bind(deferred);

	return deferred.promise;
}
},{"../../bower_components/q/q.js":6,"../element/Iframe.js":11,"../element/Simple.js":12,"../utils.js":27,"./getFromCommonApi.js":17}],25:[function(_dereq_,module,exports){
'use strict';
/* globals twttr */
/* jshint camelcase:false */

// This uses an undocumented twitter api (twttr.widget.createTweet) so it might break

var Q = _dereq_('../../bower_components/q/q.js'),
	getFromApi = _dereq_('./getFromCommonApi.js'),	
	IframeElement = _dereq_('../element/Iframe.js');

var TIMEOUT = 1000 * 10;

window.credits = window.credits || {};
var credits = window.credits.twitter = {};

// options should have container and query
module.exports = function(collage, options){
	var container = collage.element;

	if(options.query){
		return queryTweets(options.query).then(function(tweetIds){
			return loadTweets(tweetIds, container, collage);
		});	
	} else if(options.ids) {
		return loadTweets(options.ids, container, collage);
	} else if(options.id){
		return loadTweets([options.id], container, collage).then(function(elements){
			if(elements && elements.length) return elements[0];
		});
	}
};

var loadTweets = (function(){
	return function(ids, container){
		if(!Array.isArray(ids) || !container) return;

		var index = ids.length,
			deferred = Q.defer(),
			elements = [],
			timedOut = false,
			waitingForResize = [],
			timeout = setTimeout(function(){
				timedOut = true;
				clearInterval(heightChecker);
				deferred.resolve(elements);
			}, TIMEOUT);

		function heightCheck(){
			var index = waitingForResize.length,
				element;

			while(index--){
				element = waitingForResize[index];
				if(element.height !== '0'  && element.width !== '0'){
					elements.push(IframeElement.create(element));

					if(elements.length === ids.length){
						clearTimeout(timeout);
						clearInterval(heightChecker);
						deferred.resolve(elements);
					}

					waitingForResize.splice(index, 1);
				}
			}
		}

		var heightChecker = setInterval(heightCheck, 250);

		function handleElement(element){
			if(timedOut) return;

			var iframeWindow =  'contentWindow' in element? element.contentWindow : element.contentDocument.defaultView;
			
			var onMouseMoveCallback = iframeWindow.onmousemove;
			
			// Iframes capture all events, this allows us to bubble the event
			// up to this window's scope
			iframeWindow.onmousemove = function(e){
				if(onMouseMoveCallback) onMouseMoveCallback(e);
				var evt = document.createEvent('MouseEvents'),
					boundingClientRect = element.getBoundingClientRect();

				evt.initMouseEvent(	'mousemove', 
									true, 
									false, 
									window,
									e.detail,
									e.screenX,
									e.screenY, 
									e.clientX + boundingClientRect.left, 
									e.clientY + boundingClientRect.top, 
									e.ctrlKey, 
									e.altKey,
									e.shiftKey, 
									e.metaKey,
									e.button, 
									null);
				
				element.dispatchEvent(evt);
			};

			waitingForResize.push(element);
			element.style.opacity = 0;
		}

		while(index--){
			twttr.widgets.createTweet(ids[index], container, handleElement);
		}

		return deferred.promise;
	};
}());

var queryTweets = (function(){
	var endpoint = 'http://search.twitter.com/search.json';
	//var endpoint = '/search.json';

	return function(query){
		return getFromApi(endpoint, [
			'format=json',
			'q=' + encodeURIComponent(query)
		]).then(function(response){
			var tweetIds = [],
				dupeCheck = [];

			response.results.forEach(function(item){
				// Skip retweets
				if(~dupeCheck.indexOf(item.text)){
					return;
				} else {
					dupeCheck.push(item.text);
				}

				// Skip matches on username
				if(~item.from_user.toLowerCase().indexOf(query.toLowerCase())){
					return;	
				}

				credits[item.from_user] = 'http://twitter.com/' + item.from_user;

				tweetIds.push(item.id_str);
			});

			return tweetIds;
		});
	};
}());
},{"../../bower_components/q/q.js":6,"../element/Iframe.js":11,"./getFromCommonApi.js":17}],26:[function(_dereq_,module,exports){
'use strict';
/* globals YT */

var Q = _dereq_('../../bower_components/q/q.js');
var VideoElement = _dereq_('../element/Video.js');
var getFromApi = _dereq_('./getFromCommonApi.js');
var utils = _dereq_('../utils.js');
var TIMEOUT = 10 * 1000;

window.credits = window.credits || {};
var credits = window.credits.youtube = {};

module.exports = function(collage, options){
	if(options.query){
		return queryVideos(options).then(function(videoIds){
			options.videoIds = videoIds;
			return loadVideos(collage, options);
		});
	}

	if(options.videoId){
		options.videoIds = [options.videoId];

		return loadVideos(collage, options).then(function(elements){
			return elements[0];
		});
	} else if(options.videoIds){
		return loadVideos(collage, options);	
	}
};

var defaults = {
	duration: 'short',
	key: 'AIzaSyAZw0kviWeCOidthcZAYs5oCZ0k8DsOuUk'
};

var queryVideos = (function(){
	var endpoint = 'https://www.googleapis.com/youtube/v3/search';
	//var endpoint = 'https://d3ggoqbhpexke2.cloudfront.net/youtube/v3/search';

	return function(options){
		utils.extend(options, defaults);

		var params = [
				'part=id,snippet',
				'videoDuration=' + options.duration,
				'type=video',
				'videoEmbeddable=true',
				'videoSyndicated=true',
				'key=' + options.key,
				'q=' + encodeURIComponent(options.query)
			];
		
		return getFromApi(endpoint, params).then(function(response){
			var videoIds = [];

			response.items.forEach(function(item){
				credits[item.snippet.channelTitle] = 'http://youtube.com/' + item.snippet.channelTitle;
				videoIds.push(item.id.videoId);
			});

			return videoIds;
		});
	};
}());

var loadVideos = (function(){
	return function(collage, options){
		if(!Array.isArray(options.videoIds)) return;
		
		var index = options.videoIds.length,
			deferred = Q.defer(),
			elements = [],
			videoOptions,
			timedOut = false,
			timeout = setTimeout(function(){
				timedOut = true;
				deferred.resolve(elements);
			}, TIMEOUT);

		options.callback = function(element){
			if(timedOut || !element) return;
			elements.push(element);

			if(elements.length === options.videoIds.length){
				clearTimeout(timeout);
				deferred.resolve(elements);
			}
		};

		while(index--){
			videoOptions = Object.create(options);
			videoOptions.videoId = options.videoIds[index];
			loadVideo(collage, videoOptions);
		}

		return deferred.promise;
	};
}());

var isiOS = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? true : false );

var loadVideo = (function(){
	var playerIdCounter = 0;
	return function(collage, options){
		var videoId = options.videoId,
			width = options.width || 1060,
			height = options.height || 650;

		var playerId = 'player' + (playerIdCounter++);

		var element = document.createElement('div');
		element.width = width;
		element.height = height;
		element.className = 'youtube-video';
		
		if(isiOS) element.className += ' hide-video-mask';

		element.innerHTML = '<div id="' + playerId + '"></div><div class="video-mask"></div>';
		collage.element.appendChild(element);
		
		var videoElement;

		new YT.Player(playerId, {
			height: height,
			width: width,
			playerVars: { 
				controls: 0, 
				html5: 1,
				start: (options.startTime || 0)
			},
			videoId: videoId,
			events: {
				onReady: function(e){
					var playerObj = e.target;
					videoElement = VideoElement.create(element, playerObj, {
						continuousPlay: options.continuousPlay,
						autoplay: options.autoplay,
						loop: options.loop
					});
					
					if(isiOS){
						videoElement.on('playing', function(){
							element.className = element.className.replace(' hide-video-mask', '');
						});

						videoElement.on('paused', function(){
							element.className += ' hide-video-mask';
						});
					}

					playerObj.pauseVideo();
					if(options.continuousPlay){
						playerObj.unMute();
						playerObj.setVolume(100);
					}

					if(options.mute){
						playerObj.mute();
						playerObj.setVolume(0);
					}
					
					if(options.callback) options.callback(videoElement);
				},
				onError: function(){
				}
			}
		});
	};
}());

},{"../../bower_components/q/q.js":6,"../element/Video.js":13,"../utils.js":27,"./getFromCommonApi.js":17}],27:[function(_dereq_,module,exports){
'use strict';

exports.extend = function(destination){
	var sources = arguments.length,
		index = 1,
		source,
		key;

	for(; index < sources; index++){
		source = arguments[index];
		for(key in source){
			if(source.hasOwnProperty(key) && !(key in destination)){
				destination[key] = source[key];
			}
		}
	}
};

exports.attachIframeToCollage = function(collage, iframe, width, height){
	var container = document.createElement('div');
	container.className='iframe-container';
	
	var overflowWrapper = document.createElement('div');
	overflowWrapper.className = 'iframe-overflow-wrapper';
	overflowWrapper.style.width = width + 'px';
	overflowWrapper.style.height = height + 'px';
	container.appendChild(overflowWrapper);

	iframe.style.width = width + 'px';
	iframe.style.height = height + 'px';
	overflowWrapper.appendChild(iframe);

	var mask = document.createElement('div');
	mask.className = 'iframe-mask';
	container.appendChild(mask);

	var hasFocus = false;
	mask.addEventListener('click', function(){
		hasFocus = true;
		container.className += ' in-focus';
		collage.pause(0.4);
	});

	mask.addEventListener('mouseover', function(){
		if(!hasFocus) return;
		hasFocus = false;
		container.className = container.className.replace(' in-focus', '');
		collage.resume(0.4);
	});

	collage.element.appendChild(container);
	
	return container;
};


exports.requestAnimationFrame = window.requestAnimationFrame || 
								window.mozRequestAnimationFrame ||
                              	window.webkitRequestAnimationFrame || 
                              	window.msRequestAnimationFrame || 
                              	function(cb){return setTimeout(cb, 15);};

exports.cancelAnimationFrame = 	window.cancelAnimationFrame || 
								window.mozCancelAnimationFrame ||
                              	window.webkitCancelAnimationFrame || 
                              	window.msCancelAnimationFrame || 
                              	function(timeout){return clearTimeout(timeout);};

exports.requestFullscreen = document.documentElement.requestFullscreen ||
							document.documentElement.mozRequestFullScreen ||
							document.documentElement.webkitRequestFullscreen ||
							function(){};

var bodyStyle = document.body.style;	
exports.transitionAttribute =	(bodyStyle.msTransition !== void 0) && 'msTransition' ||
								(bodyStyle.webkitTransition !== void 0) && 'webkitTransition' ||
								(bodyStyle.MozTransition !== void 0) && 'MozTransition' || 
								(bodyStyle.transition !== void 0) && 'transition';

},{}]},{},[9])

(9)
});

//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/ozan/code/boilerplate-gulp/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/ozan/code/boilerplate-gulp/node_modules/browserify/node_modules/process/browser.js","/Users/ozan/code/collage/bower_components/eventEmitter/EventEmitter.js","/Users/ozan/code/giant-quadtree/node_modules/boilerplate-gulp/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/ozan/code/collage/bower_components/mustache/mustache.js","/Users/ozan/code/collage/bower_components/q/q.js","/Users/ozan/code/collage/src/BoundingBox.js","/Users/ozan/code/collage/src/Tag.js","/Users/ozan/code/collage/src/collage.js","/Users/ozan/code/collage/src/element/Element.js","/Users/ozan/code/collage/src/element/Iframe.js","/Users/ozan/code/collage/src/element/Simple.js","/Users/ozan/code/collage/src/element/Video.js","/Users/ozan/code/collage/src/element/index.js","/Users/ozan/code/collage/src/loader/facebook.js","/Users/ozan/code/collage/src/loader/flickr.js","/Users/ozan/code/collage/src/loader/getFromCommonApi.js","/Users/ozan/code/collage/src/loader/googleNews.js","/Users/ozan/code/collage/src/loader/googlePlus.js","/Users/ozan/code/collage/src/loader/iframe.js","/Users/ozan/code/collage/src/loader/image.js","/Users/ozan/code/collage/src/loader/index.js","/Users/ozan/code/collage/src/loader/nyTimes.js","/Users/ozan/code/collage/src/loader/reddit.js","/Users/ozan/code/collage/src/loader/twitter.js","/Users/ozan/code/collage/src/loader/youtube.js","/Users/ozan/code/collage/src/utils.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AD/DA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAz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xdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AA1gDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AA1WA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AEjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzTA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAzSA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;ACnRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACviBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACni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gBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACt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nJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"collage.js","sourcesContent":["(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})","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","/**\n * EventEmitter v4.0.5 - git.io/ee\n * Oliver Caldwell\n * MIT license\n * @preserve\n */\n\n;(function(exports) {\n    // JSHint config - http://www.jshint.com/\n    /*jshint laxcomma:true*/\n    /*global define:true*/\n\n    // Place the script in strict mode\n    'use strict';\n\n    /**\n     * Class for managing events.\n     * Can be extended to provide event functionality in other classes.\n     *\n     * @class Manages event registering and emitting.\n     */\n    function EventEmitter(){}\n\n    // Shortcuts to improve speed and size\n\n        // Easy access to the prototype\n    var proto = EventEmitter.prototype\n\n      // Existence of a native indexOf\n      , nativeIndexOf = Array.prototype.indexOf ? true : false;\n\n    /**\n     * Finds the index of the listener for the event in it's storage array\n     *\n     * @param {Function} listener Method to look for.\n     * @param {Function[]} listeners Array of listeners to search through.\n     * @return {Number} Index of the specified listener, -1 if not found\n     */\n    function indexOfListener(listener, listeners) {\n        // Return the index via the native method if possible\n        if(nativeIndexOf) {\n            return listeners.indexOf(listener);\n        }\n\n        // There is no native method\n        // Use a manual loop to find the index\n        var i = listeners.length;\n        while(i--) {\n            // If the listener matches, return it's index\n            if(listeners[i] === listener) {\n                return i;\n            }\n        }\n\n        // Default to returning -1\n        return -1;\n    }\n\n    /**\n     * Fetches the events object and creates one if required.\n     *\n     * @return {Object} The events storage object.\n     */\n    proto._getEvents = function() {\n        return this._events || (this._events = {});\n    };\n\n    /**\n     * Returns the listener array for the specified event.\n     * Will initialise the event object and listener arrays if required.\n     *\n     * @param {String} evt Name of the event to return the listeners from.\n     * @return {Function[]} All listener functions for the event.\n     * @doc\n     */\n    proto.getListeners = function(evt) {\n        // Create a shortcut to the storage object\n        // Initialise it if it does not exists yet\n        var events = this._getEvents();\n\n        // Return the listener array\n        // Initialise it if it does not exist\n        return events[evt] || (events[evt] = []);\n    };\n\n    /**\n     * Adds a listener function to the specified event.\n     * The listener will not be added if it is a duplicate.\n     * If the listener returns true then it will be removed after it is called.\n     *\n     * @param {String} evt Name of the event to attach the listener to.\n     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.addListener = function(evt, listener) {\n        // Fetch the listeners\n        var listeners = this.getListeners(evt);\n\n        // Push the listener into the array if it is not already there\n        if(indexOfListener(listener, listeners) === -1) {\n            listeners.push(listener);\n        }\n\n        // Return the instance of EventEmitter to allow chaining\n        return this;\n    };\n\n    /**\n     * Alias of addListener\n     * @doc\n     */\n    proto.on = proto.addListener;\n\n    /**\n     * Removes a listener function from the specified event.\n     *\n     * @param {String} evt Name of the event to remove the listener from.\n     * @param {Function} listener Method to remove from the event.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.removeListener = function(evt, listener) {\n        // Fetch the listeners\n        // And get the index of the listener in the array\n        var listeners = this.getListeners(evt)\n          , index = indexOfListener(listener, listeners);\n\n        // If the listener was found then remove it\n        if(index !== -1) {\n            listeners.splice(index, 1);\n\n            // If there are no more listeners in this array then remove it\n            if(listeners.length === 0) {\n                this.removeEvent(evt);\n            }\n        }\n\n        // Return the instance of EventEmitter to allow chaining\n        return this;\n    };\n\n    /**\n     * Alias of removeListener\n     * @doc\n     */\n    proto.off = proto.removeListener;\n\n    /**\n     * Adds listeners in bulk using the manipulateListeners method.\n     * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n     * You can also pass it an event name and an array of listeners to be added.\n     *\n     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to add.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.addListeners = function(evt, listeners) {\n        // Pass through to manipulateListeners\n        return this.manipulateListeners(false, evt, listeners);\n    };\n\n    /**\n     * Removes listeners in bulk using the manipulateListeners method.\n     * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n     * You can also pass it an event name and an array of listeners to be removed.\n     *\n     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to remove.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.removeListeners = function(evt, listeners) {\n        // Pass through to manipulateListeners\n        return this.manipulateListeners(true, evt, listeners);\n    };\n\n    /**\n     * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.\n     * The first argument will determine if the listeners are removed (true) or added (false).\n     * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n     * You can also pass it an event name and an array of listeners to be added/removed.\n     *\n     * @param {Boolean} remove True if you want to remove listeners, false if you want to add.\n     * @param {String|Object} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to add/remove.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.manipulateListeners = function(remove, evt, listeners) {\n        // Initialise any required variables\n        var i\n          , value\n          , single = remove ? this.removeListener : this.addListener\n          , multiple = remove ? this.removeListeners : this.addListeners;\n\n        // If evt is an object then pass each of it's properties to this method\n        if(typeof evt === 'object') {\n            for(i in evt) {\n                if(evt.hasOwnProperty(i) && (value = evt[i])) {\n                    // Pass the single listener straight through to the singular method\n                    if(typeof value === 'function') {\n                        single.call(this, i, value);\n                    }\n                    else {\n                        // Otherwise pass back to the multiple function\n                        multiple.call(this, i, value);\n                    }\n                }\n            }\n        }\n        else {\n            // So evt must be a string\n            // And listeners must be an array of listeners\n            // Loop over it and pass each one to the multiple method\n            i = listeners.length;\n            while(i--) {\n                single.call(this, evt, listeners[i]);\n            }\n        }\n\n        // Return the instance of EventEmitter to allow chaining\n        return this;\n    };\n\n    /**\n     * Removes all listeners from a specified event.\n     * If you do not specify an event then all listeners will be removed.\n     * That means every event will be emptied.\n     *\n     * @param {String} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.removeEvent = function(evt) {\n        // Remove different things depending on the state of evt\n        if(evt) {\n            // Remove all listeners for the specified event\n            delete this._getEvents()[evt];\n        }\n        else {\n            // Remove all listeners in all events\n            delete this._events;\n        }\n\n        // Return the instance of EventEmitter to allow chaining\n        return this;\n    };\n\n    /**\n     * Emits an event of your choice.\n     * When emitted, every listener attached to that event will be executed.\n     * If you pass the optional argument array then those arguments will be passed to every listener upon execution.\n     * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.\n     * So they will not arrive within the array on the other side, they will be separate.\n     *\n     * @param {String} evt Name of the event to emit and execute listeners for.\n     * @param {Array} [args] Optional array of arguments to be passed to each listener.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.emitEvent = function(evt, args) {\n        // Get the listeners for the event\n        // Also initialise any other required variables\n        var listeners = this.getListeners(evt)\n          , i = listeners.length\n          , response;\n\n        // Loop over all listeners assigned to the event\n        // Apply the arguments array to each listener function\n        while(i--) {\n            // If the listener returns true then it shall be removed from the event\n            // The function is executed either with a basic call or an apply if there is an args array\n            response = args ? listeners[i].apply(null, args) : listeners[i]();\n            if(response === true) {\n                this.removeListener(evt, listeners[i]);\n            }\n        }\n\n        // Return the instance of EventEmitter to allow chaining\n        return this;\n    };\n\n    /**\n     * Alias of emitEvent\n     * @doc\n     */\n    proto.trigger = proto.emitEvent;\n\n    /**\n     * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as\n     * opposed to taking a single array of arguments to pass on.\n     *\n     * @param {String} evt Name of the event to emit and execute listeners for.\n     * @param {...*} Optional additional arguments to be passed to each listener.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     * @doc\n     */\n    proto.emit = function(evt) {\n        var args = Array.prototype.slice.call(arguments, 1);\n        return this.emitEvent(evt, args);\n    };\n\n    // Expose the class either via AMD or the global object\n    if(typeof define === 'function' && define.amd) {\n        define(function() {\n            return EventEmitter;\n        });\n    }\n    else {\n        exports.EventEmitter = EventEmitter;\n    }\n}(this));","(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})","/*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http://github.com/janl/mustache.js\n */\n\n/*global define: false*/\n\n(function (root, factory) {\n  if (typeof exports === \"object\" && exports) {\n    factory(exports); // CommonJS\n  } else {\n    var mustache = {};\n    factory(mustache);\n    if (typeof define === \"function\" && define.amd) {\n      define(mustache); // AMD\n    } else {\n      root.Mustache = mustache; // <script>\n    }\n  }\n}(this, function (mustache) {\n\n  var whiteRe = /\\s*/;\n  var spaceRe = /\\s+/;\n  var nonSpaceRe = /\\S/;\n  var eqRe = /\\s*=/;\n  var curlyRe = /\\s*\\}/;\n  var tagRe = /#|\\^|\\/|>|\\{|&|=|!/;\n\n  // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577\n  // See https://github.com/janl/mustache.js/issues/189\n  var RegExp_test = RegExp.prototype.test;\n  function testRegExp(re, string) {\n    return RegExp_test.call(re, string);\n  }\n\n  function isWhitespace(string) {\n    return !testRegExp(nonSpaceRe, string);\n  }\n\n  var Object_toString = Object.prototype.toString;\n  var isArray = Array.isArray || function (object) {\n    return Object_toString.call(object) === '[object Array]';\n  };\n\n  function isFunction(object) {\n    return typeof object === 'function';\n  }\n\n  function escapeRegExp(string) {\n    return string.replace(/[\\-\\[\\]{}()*+?.,\\\\\\^$|#\\s]/g, \"\\\\$&\");\n  }\n\n  var entityMap = {\n    \"&\": \"&amp;\",\n    \"<\": \"&lt;\",\n    \">\": \"&gt;\",\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    \"/\": '&#x2F;'\n  };\n\n  function escapeHtml(string) {\n    return String(string).replace(/[&<>\"'\\/]/g, function (s) {\n      return entityMap[s];\n    });\n  }\n\n  function Scanner(string) {\n    this.string = string;\n    this.tail = string;\n    this.pos = 0;\n  }\n\n  /**\n   * Returns `true` if the tail is empty (end of string).\n   */\n  Scanner.prototype.eos = function () {\n    return this.tail === \"\";\n  };\n\n  /**\n   * Tries to match the given regular expression at the current position.\n   * Returns the matched text if it can match, the empty string otherwise.\n   */\n  Scanner.prototype.scan = function (re) {\n    var match = this.tail.match(re);\n\n    if (match && match.index === 0) {\n      var string = match[0];\n      this.tail = this.tail.substring(string.length);\n      this.pos += string.length;\n      return string;\n    }\n\n    return \"\";\n  };\n\n  /**\n   * Skips all text until the given regular expression can be matched. Returns\n   * the skipped string, which is the entire tail if no match can be made.\n   */\n  Scanner.prototype.scanUntil = function (re) {\n    var index = this.tail.search(re), match;\n\n    switch (index) {\n    case -1:\n      match = this.tail;\n      this.tail = \"\";\n      break;\n    case 0:\n      match = \"\";\n      break;\n    default:\n      match = this.tail.substring(0, index);\n      this.tail = this.tail.substring(index);\n    }\n\n    this.pos += match.length;\n\n    return match;\n  };\n\n  function Context(view, parent) {\n    this.view = view == null ? {} : view;\n    this.parent = parent;\n    this._cache = { '.': this.view };\n  }\n\n  Context.make = function (view) {\n    return (view instanceof Context) ? view : new Context(view);\n  };\n\n  Context.prototype.push = function (view) {\n    return new Context(view, this);\n  };\n\n  Context.prototype.lookup = function (name) {\n    var value;\n    if (name in this._cache) {\n      value = this._cache[name];\n    } else {\n      var context = this;\n\n      while (context) {\n        if (name.indexOf('.') > 0) {\n          value = context.view;\n\n          var names = name.split('.'), i = 0;\n          while (value != null && i < names.length) {\n            value = value[names[i++]];\n          }\n        } else {\n          value = context.view[name];\n        }\n\n        if (value != null) break;\n\n        context = context.parent;\n      }\n\n      this._cache[name] = value;\n    }\n\n    if (isFunction(value)) {\n      value = value.call(this.view);\n    }\n\n    return value;\n  };\n\n  function Writer() {\n    this.clearCache();\n  }\n\n  Writer.prototype.clearCache = function () {\n    this._cache = {};\n    this._partialCache = {};\n  };\n\n  Writer.prototype.compile = function (template, tags) {\n    var fn = this._cache[template];\n\n    if (!fn) {\n      var tokens = mustache.parse(template, tags);\n      fn = this._cache[template] = this.compileTokens(tokens, template);\n    }\n\n    return fn;\n  };\n\n  Writer.prototype.compilePartial = function (name, template, tags) {\n    var fn = this.compile(template, tags);\n    this._partialCache[name] = fn;\n    return fn;\n  };\n\n  Writer.prototype.getPartial = function (name) {\n    if (!(name in this._partialCache) && this._loadPartial) {\n      this.compilePartial(name, this._loadPartial(name));\n    }\n\n    return this._partialCache[name];\n  };\n\n  Writer.prototype.compileTokens = function (tokens, template) {\n    var self = this;\n    return function (view, partials) {\n      if (partials) {\n        if (isFunction(partials)) {\n          self._loadPartial = partials;\n        } else {\n          for (var name in partials) {\n            self.compilePartial(name, partials[name]);\n          }\n        }\n      }\n\n      return renderTokens(tokens, self, Context.make(view), template);\n    };\n  };\n\n  Writer.prototype.render = function (template, view, partials) {\n    return this.compile(template)(view, partials);\n  };\n\n  /**\n   * Low-level function that renders the given `tokens` using the given `writer`\n   * and `context`. The `template` string is only needed for templates that use\n   * higher-order sections to extract the portion of the original template that\n   * was contained in that section.\n   */\n  function renderTokens(tokens, writer, context, template) {\n    var buffer = '';\n\n    // This function is used to render an artbitrary template\n    // in the current context by higher-order functions.\n    function subRender(template) {\n      return writer.render(template, context);\n    }\n\n    var token, tokenValue, value;\n    for (var i = 0, len = tokens.length; i < len; ++i) {\n      token = tokens[i];\n      tokenValue = token[1];\n\n      switch (token[0]) {\n      case '#':\n        value = context.lookup(tokenValue);\n\n        if (typeof value === 'object' || typeof value === 'string') {\n          if (isArray(value)) {\n            for (var j = 0, jlen = value.length; j < jlen; ++j) {\n              buffer += renderTokens(token[4], writer, context.push(value[j]), template);\n            }\n          } else if (value) {\n            buffer += renderTokens(token[4], writer, context.push(value), template);\n          }\n        } else if (isFunction(value)) {\n          var text = template == null ? null : template.slice(token[3], token[5]);\n          value = value.call(context.view, text, subRender);\n          if (value != null) buffer += value;\n        } else if (value) {\n          buffer += renderTokens(token[4], writer, context, template);\n        }\n\n        break;\n      case '^':\n        value = context.lookup(tokenValue);\n\n        // Use JavaScript's definition of falsy. Include empty arrays.\n        // See https://github.com/janl/mustache.js/issues/186\n        if (!value || (isArray(value) && value.length === 0)) {\n          buffer += renderTokens(token[4], writer, context, template);\n        }\n\n        break;\n      case '>':\n        value = writer.getPartial(tokenValue);\n        if (isFunction(value)) buffer += value(context);\n        break;\n      case '&':\n        value = context.lookup(tokenValue);\n        if (value != null) buffer += value;\n        break;\n      case 'name':\n        value = context.lookup(tokenValue);\n        if (value != null) buffer += mustache.escape(value);\n        break;\n      case 'text':\n        buffer += tokenValue;\n        break;\n      }\n    }\n\n    return buffer;\n  }\n\n  /**\n   * Forms the given array of `tokens` into a nested tree structure where\n   * tokens that represent a section have two additional items: 1) an array of\n   * all tokens that appear in that section and 2) the index in the original\n   * template that represents the end of that section.\n   */\n  function nestTokens(tokens) {\n    var tree = [];\n    var collector = tree;\n    var sections = [];\n\n    var token;\n    for (var i = 0, len = tokens.length; i < len; ++i) {\n      token = tokens[i];\n      switch (token[0]) {\n      case '#':\n      case '^':\n        sections.push(token);\n        collector.push(token);\n        collector = token[4] = [];\n        break;\n      case '/':\n        var section = sections.pop();\n        section[5] = token[2];\n        collector = sections.length > 0 ? sections[sections.length - 1][4] : tree;\n        break;\n      default:\n        collector.push(token);\n      }\n    }\n\n    return tree;\n  }\n\n  /**\n   * Combines the values of consecutive text tokens in the given `tokens` array\n   * to a single token.\n   */\n  function squashTokens(tokens) {\n    var squashedTokens = [];\n\n    var token, lastToken;\n    for (var i = 0, len = tokens.length; i < len; ++i) {\n      token = tokens[i];\n      if (token) {\n        if (token[0] === 'text' && lastToken && lastToken[0] === 'text') {\n          lastToken[1] += token[1];\n          lastToken[3] = token[3];\n        } else {\n          lastToken = token;\n          squashedTokens.push(token);\n        }\n      }\n    }\n\n    return squashedTokens;\n  }\n\n  function escapeTags(tags) {\n    return [\n      new RegExp(escapeRegExp(tags[0]) + \"\\\\s*\"),\n      new RegExp(\"\\\\s*\" + escapeRegExp(tags[1]))\n    ];\n  }\n\n  /**\n   * Breaks up the given `template` string into a tree of token objects. If\n   * `tags` is given here it must be an array with two string values: the\n   * opening and closing tags used in the template (e.g. [\"<%\", \"%>\"]). Of\n   * course, the default is to use mustaches (i.e. Mustache.tags).\n   */\n  function parseTemplate(template, tags) {\n    template = template || '';\n    tags = tags || mustache.tags;\n\n    if (typeof tags === 'string') tags = tags.split(spaceRe);\n    if (tags.length !== 2) throw new Error('Invalid tags: ' + tags.join(', '));\n\n    var tagRes = escapeTags(tags);\n    var scanner = new Scanner(template);\n\n    var sections = [];     // Stack to hold section tokens\n    var tokens = [];       // Buffer to hold the tokens\n    var spaces = [];       // Indices of whitespace tokens on the current line\n    var hasTag = false;    // Is there a {{tag}} on the current line?\n    var nonSpace = false;  // Is there a non-space char on the current line?\n\n    // Strips all whitespace tokens array for the current line\n    // if there was a {{#tag}} on it and otherwise only space.\n    function stripSpace() {\n      if (hasTag && !nonSpace) {\n        while (spaces.length) {\n          delete tokens[spaces.pop()];\n        }\n      } else {\n        spaces = [];\n      }\n\n      hasTag = false;\n      nonSpace = false;\n    }\n\n    var start, type, value, chr, token, openSection;\n    while (!scanner.eos()) {\n      start = scanner.pos;\n\n      // Match any text between tags.\n      value = scanner.scanUntil(tagRes[0]);\n      if (value) {\n        for (var i = 0, len = value.length; i < len; ++i) {\n          chr = value.charAt(i);\n\n          if (isWhitespace(chr)) {\n            spaces.push(tokens.length);\n          } else {\n            nonSpace = true;\n          }\n\n          tokens.push(['text', chr, start, start + 1]);\n          start += 1;\n\n          // Check for whitespace on the current line.\n          if (chr == '\\n') stripSpace();\n        }\n      }\n\n      // Match the opening tag.\n      if (!scanner.scan(tagRes[0])) break;\n      hasTag = true;\n\n      // Get the tag type.\n      type = scanner.scan(tagRe) || 'name';\n      scanner.scan(whiteRe);\n\n      // Get the tag value.\n      if (type === '=') {\n        value = scanner.scanUntil(eqRe);\n        scanner.scan(eqRe);\n        scanner.scanUntil(tagRes[1]);\n      } else if (type === '{') {\n        value = scanner.scanUntil(new RegExp('\\\\s*' + escapeRegExp('}' + tags[1])));\n        scanner.scan(curlyRe);\n        scanner.scanUntil(tagRes[1]);\n        type = '&';\n      } else {\n        value = scanner.scanUntil(tagRes[1]);\n      }\n\n      // Match the closing tag.\n      if (!scanner.scan(tagRes[1])) throw new Error('Unclosed tag at ' + scanner.pos);\n\n      token = [type, value, start, scanner.pos];\n      tokens.push(token);\n\n      if (type === '#' || type === '^') {\n        sections.push(token);\n      } else if (type === '/') {\n        // Check section nesting.\n        openSection = sections.pop();\n        if (!openSection) {\n          throw new Error('Unopened section \"' + value + '\" at ' + start);\n        }\n        if (openSection[1] !== value) {\n          throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + start);\n        }\n      } else if (type === 'name' || type === '{' || type === '&') {\n        nonSpace = true;\n      } else if (type === '=') {\n        // Set the tags for the next time around.\n        tags = value.split(spaceRe);\n        if (tags.length !== 2) {\n          throw new Error('Invalid tags at ' + start + ': ' + tags.join(', '));\n        }\n        tagRes = escapeTags(tags);\n      }\n    }\n\n    // Make sure there are no open sections when we're done.\n    openSection = sections.pop();\n    if (openSection) {\n      throw new Error('Unclosed section \"' + openSection[1] + '\" at ' + scanner.pos);\n    }\n\n    return nestTokens(squashTokens(tokens));\n  }\n\n  mustache.name = \"mustache.js\";\n  mustache.version = \"0.7.3\";\n  mustache.tags = [\"{{\", \"}}\"];\n\n  mustache.Scanner = Scanner;\n  mustache.Context = Context;\n  mustache.Writer = Writer;\n\n  mustache.parse = parseTemplate;\n\n  // Export the escaping function so that the user may override it.\n  // See https://github.com/janl/mustache.js/issues/244\n  mustache.escape = escapeHtml;\n\n  // All Mustache.* functions use this writer.\n  var defaultWriter = new Writer();\n\n  /**\n   * Clears all cached templates and partials in the default writer.\n   */\n  mustache.clearCache = function () {\n    return defaultWriter.clearCache();\n  };\n\n  /**\n   * Compiles the given `template` to a reusable function using the default\n   * writer.\n   */\n  mustache.compile = function (template, tags) {\n    return defaultWriter.compile(template, tags);\n  };\n\n  /**\n   * Compiles the partial with the given `name` and `template` to a reusable\n   * function using the default writer.\n   */\n  mustache.compilePartial = function (name, template, tags) {\n    return defaultWriter.compilePartial(name, template, tags);\n  };\n\n  /**\n   * Compiles the given array of tokens (the output of a parse) to a reusable\n   * function using the default writer.\n   */\n  mustache.compileTokens = function (tokens, template) {\n    return defaultWriter.compileTokens(tokens, template);\n  };\n\n  /**\n   * Renders the `template` with the given `view` and `partials` using the\n   * default writer.\n   */\n  mustache.render = function (template, view, partials) {\n    return defaultWriter.render(template, view, partials);\n  };\n\n  // This is here for backwards compatibility with 0.4.x.\n  mustache.to_html = function (template, view, partials, send) {\n    var result = mustache.render(template, view, partials);\n\n    if (isFunction(send)) {\n      send(result);\n    } else {\n      return result;\n    }\n  };\n\n}));\n","(function (process){\n// vim:ts=4:sts=4:sw=4:\n/*!\n *\n * Copyright 2009-2012 Kris Kowal under the terms of the MIT\n * license found at http://github.com/kriskowal/q/raw/master/LICENSE\n *\n * With parts by Tyler Close\n * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found\n * at http://www.opensource.org/licenses/mit-license.html\n * Forked at ref_send.js version: 2009-05-11\n *\n * With parts by Mark Miller\n * Copyright (C) 2011 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n(function (definition) {\n    // Turn off strict mode for this function so we can assign to global.Q\n    /*jshint strict: false*/\n\n    // This file will function properly as a <script> tag, or a module\n    // using CommonJS and NodeJS or RequireJS module formats.  In\n    // Common/Node/RequireJS, the module exports the Q API and when\n    // executed as a simple <script>, it creates a Q global instead.\n\n    // Montage Require\n    if (typeof bootstrap === \"function\") {\n        bootstrap(\"promise\", definition);\n\n    // CommonJS\n    } else if (typeof exports === \"object\") {\n        definition(void 0, exports);\n\n    // RequireJS\n    } else if (typeof define === \"function\") {\n        define(definition);\n\n    // SES (Secure EcmaScript)\n    } else if (typeof ses !== \"undefined\") {\n        if (!ses.ok()) {\n            return;\n        } else {\n            ses.makeQ = function () {\n                var Q = {};\n                return definition(void 0, Q);\n            };\n        }\n\n    // <script>\n    } else {\n        definition(void 0, Q = {});\n    }\n\n})(function (require, exports) {\n\"use strict\";\n\n// All code after this point will be filtered from stack traces reported\n// by Q.\nvar qStartingLine = captureLine();\nvar qFileName;\n\n// shims\n\n// used for fallback \"defend\" and in \"allResolved\"\nvar noop = function () {};\n\n// for the security conscious, defend may be a deep freeze as provided\n// by cajaVM.  Otherwise we try to provide a shallow freeze just to\n// discourage promise changes that are not compatible with secure\n// usage.  If Object.freeze does not exist, fall back to doing nothing\n// (no op).\nvar defend = Object.freeze || noop;\nif (typeof cajaVM !== \"undefined\") {\n    defend = cajaVM.def;\n}\n\n// use the fastest possible means to execute a task in a future turn\n// of the event loop.\nvar nextTick;\nif (typeof process !== \"undefined\") {\n    // node\n    nextTick = process.nextTick;\n} else if (typeof setImmediate === \"function\") {\n    // In IE10, or use https://github.com/NobleJS/setImmediate\n    nextTick = setImmediate;\n} else if (typeof MessageChannel !== \"undefined\") {\n    // modern browsers\n    // http://www.nonblocking.io/2011/06/windownexttick.html\n    var channel = new MessageChannel();\n    // linked list of tasks (single, with head node)\n    var head = {}, tail = head;\n    channel.port1.onmessage = function () {\n        head = head.next;\n        var task = head.task;\n        delete head.task;\n        task();\n    };\n    nextTick = function (task) {\n        tail = tail.next = {task: task};\n        channel.port2.postMessage(0);\n    };\n} else {\n    // old browsers\n    nextTick = function (task) {\n        setTimeout(task, 0);\n    };\n}\n\n// Attempt to make generics safe in the face of downstream\n// modifications.\n// There is no situation where this is necessary.\n// If you need a security guarantee, these primordials need to be\n// deeply frozen anyway, and if you don’t need a security guarantee,\n// this is just plain paranoid.\n// However, this does have the nice side-effect of reducing the size\n// of the code by reducing x.call() to merely x(), eliminating many\n// hard-to-minify characters.\n// See Mark Miller’s explanation of what this does.\n// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming\nvar uncurryThis;\n// I have kept both variations because the first is theoretically\n// faster, if bind is available.\nif (Function.prototype.bind) {\n    var Function_bind = Function.prototype.bind;\n    uncurryThis = Function_bind.bind(Function_bind.call);\n} else {\n    uncurryThis = function (f) {\n        return function () {\n            return f.call.apply(f, arguments);\n        };\n    };\n}\n\nvar array_slice = uncurryThis(Array.prototype.slice);\n\nvar array_reduce = uncurryThis(\n    Array.prototype.reduce || function (callback, basis) {\n        var index = 0,\n            length = this.length;\n        // concerning the initial value, if one is not provided\n        if (arguments.length === 1) {\n            // seek to the first value in the array, accounting\n            // for the possibility that is is a sparse array\n            do {\n                if (index in this) {\n                    basis = this[index++];\n                    break;\n                }\n                if (++index >= length) {\n                    throw new TypeError();\n                }\n            } while (1);\n        }\n        // reduce\n        for (; index < length; index++) {\n            // account for the possibility that the array is sparse\n            if (index in this) {\n                basis = callback(basis, this[index], index);\n            }\n        }\n        return basis;\n    }\n);\n\nvar array_indexOf = uncurryThis(\n    Array.prototype.indexOf || function (value) {\n        // not a very good shim, but good enough for our one use of it\n        for (var i = 0; i < this.length; i++) {\n            if (this[i] === value) {\n                return i;\n            }\n        }\n        return -1;\n    }\n);\n\nvar array_map = uncurryThis(\n    Array.prototype.map || function (callback, thisp) {\n        var self = this;\n        var collect = [];\n        array_reduce(self, function (undefined, value, index) {\n            collect.push(callback.call(thisp, value, index, self));\n        }, void 0);\n        return collect;\n    }\n);\n\nvar object_create = Object.create || function (prototype) {\n    function Type() { }\n    Type.prototype = prototype;\n    return new Type();\n};\n\nvar object_keys = Object.keys || function (object) {\n    var keys = [];\n    for (var key in object) {\n        keys.push(key);\n    }\n    return keys;\n};\n\nvar object_toString = Object.prototype.toString;\n\n// generator related shims\n\nfunction isStopIteration(exception) {\n    return (\n        object_toString(exception) === \"[object StopIteration]\" ||\n        exception instanceof QReturnValue\n    );\n}\n\nvar QReturnValue;\nif (typeof ReturnValue !== \"undefined\") {\n    QReturnValue = ReturnValue;\n} else {\n    QReturnValue = function (value) {\n        this.value = value;\n    };\n}\n\n// long stack traces\n\nvar STACK_JUMP_SEPARATOR = \"From previous event:\";\n\nfunction makeStackTraceLong(error, promise) {\n    // If possible (that is, if in V8), transform the error stack\n    // trace by removing Node and Q cruft, then concatenating with\n    // the stack trace of the promise we are ``done``ing. See #57.\n    if (promise.stack &&\n        typeof error === \"object\" &&\n        error !== null &&\n        error.stack &&\n        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1\n    ) {\n        error.stack = filterStackString(error.stack) +\n            \"\\n\" + STACK_JUMP_SEPARATOR + \"\\n\" +\n            filterStackString(promise.stack);\n    }\n}\n\nfunction filterStackString(stackString) {\n    var lines = stackString.split(\"\\n\");\n    var desiredLines = [];\n    for (var i = 0; i < lines.length; ++i) {\n        var line = lines[i];\n\n        if (!isInternalFrame(line) && !isNodeFrame(line)) {\n            desiredLines.push(line);\n        }\n    }\n    return desiredLines.join(\"\\n\");\n}\n\nfunction isNodeFrame(stackLine) {\n    return stackLine.indexOf(\"(module.js:\") !== -1 ||\n           stackLine.indexOf(\"(node.js:\") !== -1;\n}\n\nfunction isInternalFrame(stackLine) {\n    var pieces = /at .+ \\((.*):(\\d+):\\d+\\)/.exec(stackLine);\n\n    if (!pieces) {\n        return false;\n    }\n\n    var fileName = pieces[1];\n    var lineNumber = pieces[2];\n\n    return fileName === qFileName &&\n        lineNumber >= qStartingLine &&\n        lineNumber <= qEndingLine;\n}\n\n// discover own file name and line number range for filtering stack\n// traces\nfunction captureLine() {\n    if (Error.captureStackTrace) {\n        var fileName, lineNumber;\n\n        var oldPrepareStackTrace = Error.prepareStackTrace;\n\n        Error.prepareStackTrace = function (error, frames) {\n            fileName = frames[1].getFileName();\n            lineNumber = frames[1].getLineNumber();\n        };\n\n        // teases call of temporary prepareStackTrace\n        // JSHint and Closure Compiler generate known warnings here\n        /*jshint expr: true */\n        new Error().stack;\n\n        Error.prepareStackTrace = oldPrepareStackTrace;\n        qFileName = fileName;\n        return lineNumber;\n    }\n}\n\nfunction deprecate(callback, name, alternative) {\n    return function () {\n        if (typeof console !== \"undefined\" && typeof console.warn === \"function\") {\n            console.warn(name + \" is deprecated, use \" + alternative + \" instead.\", new Error(\"\").stack);\n        }\n        return callback.apply(callback, arguments);\n    };\n}\n\n// end of shims\n// beginning of real work\n\n/**\n * Performs a task in a future turn of the event loop.\n * @param {Function} task\n */\nexports.nextTick = nextTick;\n\n/**\n * Constructs a {promise, resolve} object.\n *\n * The resolver is a callback to invoke with a more resolved value for the\n * promise. To fulfill the promise, invoke the resolver with any value that is\n * not a function. To reject the promise, invoke the resolver with a rejection\n * object. To put the promise in the same state as another promise, invoke the\n * resolver with that other promise.\n */\nexports.defer = defer;\nfunction defer() {\n    // if \"pending\" is an \"Array\", that indicates that the promise has not yet\n    // been resolved.  If it is \"undefined\", it has been resolved.  Each\n    // element of the pending array is itself an array of complete arguments to\n    // forward to the resolved promise.  We coerce the resolution value to a\n    // promise using the ref promise because it handles both fully\n    // resolved values and other promises gracefully.\n    var pending = [], progressListeners = [], value;\n\n    var deferred = object_create(defer.prototype);\n    var promise = object_create(makePromise.prototype);\n\n    promise.promiseSend = function (op, _, __, progress) {\n        var args = array_slice(arguments);\n        if (pending) {\n            pending.push(args);\n            if (op === \"when\" && progress) {\n                progressListeners.push(progress);\n            }\n        } else {\n            nextTick(function () {\n                value.promiseSend.apply(value, args);\n            });\n        }\n    };\n\n    promise.valueOf = function () {\n        if (pending) {\n            return promise;\n        }\n        return value.valueOf();\n    };\n\n    if (Error.captureStackTrace) {\n        Error.captureStackTrace(promise, defer);\n\n        // Reify the stack into a string by using the accessor; this prevents\n        // memory leaks as per GH-111. At the same time, cut off the first line;\n        // it's always just \"[object Promise]\\n\", as per the `toString`.\n        promise.stack = promise.stack.substring(promise.stack.indexOf(\"\\n\") + 1);\n    }\n\n    function become(resolvedValue) {\n        if (!pending) {\n            return;\n        }\n        value = resolve(resolvedValue);\n        array_reduce(pending, function (undefined, pending) {\n            nextTick(function () {\n                value.promiseSend.apply(value, pending);\n            });\n        }, void 0);\n        pending = void 0;\n        progressListeners = void 0;\n    }\n\n    defend(promise);\n\n    deferred.promise = promise;\n    deferred.resolve = become;\n    deferred.reject = function (exception) {\n        become(reject(exception));\n    };\n    deferred.notify = function (progress) {\n        if (pending) {\n            array_reduce(progressListeners, function (undefined, progressListener) {\n                nextTick(function () {\n                    progressListener(progress);\n                });\n            }, void 0);\n        }\n    };\n\n    return deferred;\n}\n\n/**\n * Creates a Node-style callback that will resolve or reject the deferred\n * promise.\n * @returns a nodeback\n */\ndefer.prototype.makeNodeResolver = function () {\n    var self = this;\n    return function (error, value) {\n        if (error) {\n            self.reject(error);\n        } else if (arguments.length > 2) {\n            self.resolve(array_slice(arguments, 1));\n        } else {\n            self.resolve(value);\n        }\n    };\n};\n// XXX deprecated\ndefer.prototype.node = deprecate(defer.prototype.makeNodeResolver, \"node\", \"makeNodeResolver\");\n\n/**\n * @param makePromise {Function} a function that returns nothing and accepts\n * the resolve, reject, and notify functions for a deferred.\n * @returns a promise that may be resolved with the given resolve and reject\n * functions, or rejected by a thrown exception in makePromise\n */\nexports.promise = promise;\nfunction promise(makePromise) {\n    var deferred = defer();\n    fcall(\n        makePromise,\n        deferred.resolve,\n        deferred.reject,\n        deferred.notify\n    ).fail(deferred.reject);\n    return deferred.promise;\n}\n\n/**\n * Constructs a Promise with a promise descriptor object and optional fallback\n * function.  The descriptor contains methods like when(rejected), get(name),\n * put(name, value), post(name, args), and delete(name), which all\n * return either a value, a promise for a value, or a rejection.  The fallback\n * accepts the operation name, a resolver, and any further arguments that would\n * have been forwarded to the appropriate method above had a method been\n * provided with the proper name.  The API makes no guarantees about the nature\n * of the returned object, apart from that it is usable whereever promises are\n * bought and sold.\n */\nexports.makePromise = makePromise;\nfunction makePromise(descriptor, fallback, valueOf, exception) {\n    if (fallback === void 0) {\n        fallback = function (op) {\n            return reject(new Error(\"Promise does not support operation: \" + op));\n        };\n    }\n\n    var promise = object_create(makePromise.prototype);\n\n    promise.promiseSend = function (op, resolved /* ...args */) {\n        var args = array_slice(arguments, 2);\n        var result;\n        try {\n            if (descriptor[op]) {\n                result = descriptor[op].apply(promise, args);\n            } else {\n                result = fallback.apply(promise, [op].concat(args));\n            }\n        } catch (exception) {\n            result = reject(exception);\n        }\n        if (resolved) {\n            resolved(result);\n        }\n    };\n\n    if (valueOf) {\n        promise.valueOf = valueOf;\n    }\n\n    if (exception) {\n        promise.exception = exception;\n    }\n\n    defend(promise);\n\n    return promise;\n}\n\n// provide thenables, CommonJS/Promises/A\nmakePromise.prototype.then = function (fulfilled, rejected, progressed) {\n    return when(this, fulfilled, rejected, progressed);\n};\n\nmakePromise.prototype.thenResolve = function (value) {\n    return when(this, function () { return value; });\n};\n\n// Chainable methods\narray_reduce(\n    [\n        \"isResolved\", \"isFulfilled\", \"isRejected\",\n        \"when\", \"spread\", \"send\",\n        \"get\", \"put\", \"del\",\n        \"post\", \"invoke\",\n        \"keys\",\n        \"apply\", \"call\", \"bind\",\n        \"fapply\", \"fcall\", \"fbind\",\n        \"all\", \"allResolved\",\n        \"view\", \"viewInfo\",\n        \"timeout\", \"delay\",\n        \"catch\", \"finally\", \"fail\", \"fin\", \"progress\", \"end\", \"done\",\n        \"nfcall\", \"nfapply\", \"nfbind\",\n        \"ncall\", \"napply\", \"nbind\",\n        \"npost\", \"ninvoke\",\n        \"nend\", \"nodeify\"\n    ],\n    function (undefined, name) {\n        makePromise.prototype[name] = function () {\n            return exports[name].apply(\n                exports,\n                [this].concat(array_slice(arguments))\n            );\n        };\n    },\n    void 0\n);\n\nmakePromise.prototype.toSource = function () {\n    return this.toString();\n};\n\nmakePromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\ndefend(makePromise.prototype);\n\n/**\n * If an object is not a promise, it is as \"near\" as possible.\n * If a promise is rejected, it is as \"near\" as possible too.\n * If it’s a fulfilled promise, the fulfillment value is nearer.\n * If it’s a deferred promise and the deferred has been resolved, the\n * resolution is \"nearer\".\n * @param object\n * @returns most resolved (nearest) form of the object\n */\nexports.nearer = valueOf;\nfunction valueOf(value) {\n    if (isPromise(value)) {\n        return value.valueOf();\n    }\n    return value;\n}\n\n/**\n * @returns whether the given object is a promise.\n * Otherwise it is a fulfilled value.\n */\nexports.isPromise = isPromise;\nfunction isPromise(object) {\n    return object && typeof object.promiseSend === \"function\";\n}\n\n/**\n * @returns whether the given object can be coerced to a promise.\n * Otherwise it is a fulfilled value.\n */\nexports.isPromiseAlike = isPromiseAlike;\nfunction isPromiseAlike(object) {\n    return object && typeof object.then === \"function\";\n}\n\n/**\n * @returns whether the given object is a resolved promise.\n */\nexports.isResolved = isResolved;\nfunction isResolved(object) {\n    return isFulfilled(object) || isRejected(object);\n}\n\n/**\n * @returns whether the given object is a value or fulfilled\n * promise.\n */\nexports.isFulfilled = isFulfilled;\nfunction isFulfilled(object) {\n    return !isPromiseAlike(valueOf(object));\n}\n\n/**\n * @returns whether the given object is a rejected promise.\n */\nexports.isRejected = isRejected;\nfunction isRejected(object) {\n    object = valueOf(object);\n    return isPromise(object) && 'exception' in object;\n}\n\nvar rejections = [];\nvar errors = [];\nvar errorsDisplayed;\nfunction displayErrors() {\n    if (\n        !errorsDisplayed &&\n        typeof window !== \"undefined\" &&\n        !window.Touch &&\n        window.console\n    ) {\n        // This promise library consumes exceptions thrown in handlers so\n        // they can be handled by a subsequent promise.  The rejected\n        // promises get added to this array when they are created, and\n        // removed when they are handled.\n        console.log(\"Should be empty:\", errors);\n    }\n    errorsDisplayed = true;\n}\n\n/**\n * Constructs a rejected promise.\n * @param exception value describing the failure\n */\nexports.reject = reject;\nfunction reject(exception) {\n    var rejection = makePromise({\n        \"when\": function (rejected) {\n            // note that the error has been handled\n            if (rejected) {\n                var at = array_indexOf(rejections, this);\n                if (at !== -1) {\n                    errors.splice(at, 1);\n                    rejections.splice(at, 1);\n                }\n            }\n            return rejected ? rejected(exception) : reject(exception);\n        }\n    }, function fallback() {\n        return reject(exception);\n    }, function valueOf() {\n        return this;\n    }, exception);\n    // note that the error has not been handled\n    displayErrors();\n    rejections.push(rejection);\n    errors.push(exception);\n    return rejection;\n}\n\n/**\n * Constructs a promise for an immediate reference.\n * @param value immediate reference\n */\nexports.begin = resolve; // XXX experimental\nexports.resolve = resolve;\nexports.ref = deprecate(resolve, \"ref\", \"resolve\"); // XXX deprecated, use resolve\nfunction resolve(object) {\n    // If the object is already a Promise, return it directly.  This enables\n    // the resolve function to both be used to created references from objects,\n    // but to tolerably coerce non-promises to promises.\n    if (isPromise(object)) {\n        return object;\n    }\n    // In order to break infinite recursion or loops between `then` and\n    // `resolve`, it is necessary to attempt to extract fulfilled values\n    // out of foreign promise implementations before attempting to wrap\n    // them as unresolved promises.  It is my hope that other\n    // implementations will implement `valueOf` to synchronously extract\n    // the fulfillment value from their fulfilled promises.  If the\n    // other promise library does not implement `valueOf`, the\n    // implementations on primordial prototypes are harmless.\n    object = valueOf(object);\n    // assimilate thenables, CommonJS/Promises/A\n    if (isPromiseAlike(object)) {\n        var deferred = defer();\n        object.then(deferred.resolve, deferred.reject, deferred.notify);\n        return deferred.promise;\n    }\n    return makePromise({\n        \"when\": function () {\n            return object;\n        },\n        \"get\": function (name) {\n            return object[name];\n        },\n        \"put\": function (name, value) {\n            object[name] = value;\n            return object;\n        },\n        \"del\": function (name) {\n            delete object[name];\n            return object;\n        },\n        \"post\": function (name, value) {\n            return object[name].apply(object, value);\n        },\n        \"apply\": function (self, args) {\n            return object.apply(self, args);\n        },\n        \"fapply\": function (args) {\n            return object.apply(void 0, args);\n        },\n        \"viewInfo\": function () {\n            var on = object;\n            var properties = {};\n\n            function fixFalsyProperty(name) {\n                if (!properties[name]) {\n                    properties[name] = typeof on[name];\n                }\n            }\n\n            while (on) {\n                Object.getOwnPropertyNames(on).forEach(fixFalsyProperty);\n                on = Object.getPrototypeOf(on);\n            }\n            return {\n                \"type\": typeof object,\n                \"properties\": properties\n            };\n        },\n        \"keys\": function () {\n            return object_keys(object);\n        }\n    }, void 0, function valueOf() {\n        return object;\n    });\n}\n\n/**\n * Annotates an object such that it will never be\n * transferred away from this process over any promise\n * communication channel.\n * @param object\n * @returns promise a wrapping of that object that\n * additionally responds to the \"isDef\" message\n * without a rejection.\n */\nexports.master = master;\nfunction master(object) {\n    return makePromise({\n        \"isDef\": function () {}\n    }, function fallback() {\n        var args = array_slice(arguments);\n        return send.apply(void 0, [object].concat(args));\n    }, function () {\n        return valueOf(object);\n    });\n}\n\nexports.viewInfo = viewInfo;\nfunction viewInfo(object, info) {\n    object = resolve(object);\n    if (info) {\n        return makePromise({\n            \"viewInfo\": function () {\n                return info;\n            }\n        }, function fallback() {\n            var args = array_slice(arguments);\n            return send.apply(void 0, [object].concat(args));\n        }, function () {\n            return valueOf(object);\n        });\n    } else {\n        return send(object, \"viewInfo\");\n    }\n}\n\nexports.view = view;\nfunction view(object) {\n    return viewInfo(object).when(function (info) {\n        var view;\n        if (info.type === \"function\") {\n            view = function () {\n                return apply(object, void 0, arguments);\n            };\n        } else {\n            view = {};\n        }\n        var properties = info.properties || {};\n        object_keys(properties).forEach(function (name) {\n            if (properties[name] === \"function\") {\n                view[name] = function () {\n                    return post(object, name, arguments);\n                };\n            }\n        });\n        return resolve(view);\n    });\n}\n\n/**\n * Registers an observer on a promise.\n *\n * Guarantees:\n *\n * 1. that fulfilled and rejected will be called only once.\n * 2. that either the fulfilled callback or the rejected callback will be\n *    called, but not both.\n * 3. that fulfilled and rejected will not be called in this turn.\n *\n * @param value      promise or immediate reference to observe\n * @param fulfilled  function to be called with the fulfilled value\n * @param rejected   function to be called with the rejection exception\n * @param progressed function to be called on any progress notifications\n * @return promise for the return value from the invoked callback\n */\nexports.when = when;\nfunction when(value, fulfilled, rejected, progressed) {\n    var deferred = defer();\n    var done = false;   // ensure the untrusted promise makes at most a\n                        // single call to one of the callbacks\n\n    function _fulfilled(value) {\n        try {\n            return typeof fulfilled === \"function\" ? fulfilled(value) : value;\n        } catch (exception) {\n            return reject(exception);\n        }\n    }\n\n    function _rejected(exception) {\n        if (typeof rejected === \"function\") {\n            makeStackTraceLong(exception, resolvedValue);\n            try {\n                return rejected(exception);\n            } catch (newException) {\n                return reject(newException);\n            }\n        }\n        return reject(exception);\n    }\n\n    function _progressed(value) {\n        return typeof progressed === \"function\" ? progressed(value) : value;\n    }\n\n    var resolvedValue = resolve(value);\n    nextTick(function () {\n        resolvedValue.promiseSend(\"when\", function (value) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_fulfilled(value));\n        }, function (exception) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_rejected(exception));\n        });\n    });\n\n    // Progress propagator need to be attached in the current tick.\n    resolvedValue.promiseSend(\"when\", void 0, void 0, function (value) {\n        deferred.notify(_progressed(value));\n    });\n\n    return deferred.promise;\n}\n\n/**\n * Spreads the values of a promised array of arguments into the\n * fulfillment callback.\n * @param fulfilled callback that receives variadic arguments from the\n * promised array\n * @param rejected callback that receives the exception if the promise\n * is rejected.\n * @returns a promise for the return value or thrown exception of\n * either callback.\n */\nexports.spread = spread;\nfunction spread(promise, fulfilled, rejected) {\n    return when(promise, function (valuesOrPromises) {\n        return all(valuesOrPromises).then(function (values) {\n            return fulfilled.apply(void 0, values);\n        }, rejected);\n    }, rejected);\n}\n\n/**\n * The async function is a decorator for generator functions, turning\n * them into asynchronous generators.  This presently only works in\n * Firefox/Spidermonkey, however, this code does not cause syntax\n * errors in older engines.  This code should continue to work and\n * will in fact improve over time as the language improves.\n *\n * Decorates a generator function such that:\n *  - it may yield promises\n *  - execution will continue when that promise is fulfilled\n *  - the value of the yield expression will be the fulfilled value\n *  - it returns a promise for the return value (when the generator\n *    stops iterating)\n *  - the decorated function returns a promise for the return value\n *    of the generator or the first rejected promise among those\n *    yielded.\n *  - if an error is thrown in the generator, it propagates through\n *    every following yield until it is caught, or until it escapes\n *    the generator function altogether, and is translated into a\n *    rejection for the promise returned by the decorated generator.\n *  - in present implementations of generators, when a generator\n *    function is complete, it throws ``StopIteration``, ``return`` is\n *    a syntax error in the presence of ``yield``, so there is no\n *    observable return value. There is a proposal[1] to add support\n *    for ``return``, which would permit the value to be carried by a\n *    ``StopIteration`` instance, in which case it would fulfill the\n *    promise returned by the asynchronous generator.  This can be\n *    emulated today by throwing StopIteration explicitly with a value\n *    property.\n *\n *  [1]: http://wiki.ecmascript.org/doku.php?id=strawman:async_functions#reference_implementation\n *\n */\nexports.async = async;\nfunction async(makeGenerator) {\n    return function () {\n        // when verb is \"send\", arg is a value\n        // when verb is \"throw\", arg is an exception\n        function continuer(verb, arg) {\n            var result;\n            try {\n                result = generator[verb](arg);\n            } catch (exception) {\n                if (isStopIteration(exception)) {\n                    return exception.value;\n                } else {\n                    return reject(exception);\n                }\n            }\n            return when(result, callback, errback);\n        }\n        var generator = makeGenerator.apply(this, arguments);\n        var callback = continuer.bind(continuer, \"send\");\n        var errback = continuer.bind(continuer, \"throw\");\n        return callback();\n    };\n}\n\n/**\n * Throws a ReturnValue exception to stop an asynchronous generator.\n * Only useful presently in Firefox/SpiderMonkey since generators are\n * implemented.\n * @param value the return value for the surrounding generator\n * @throws ReturnValue exception with the value.\n * @example\n * Q.async(function () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      Q.return(foo + bar);\n * })\n */\nexports['return'] = _return;\nfunction _return(value) {\n    throw new QReturnValue(value);\n}\n\n/**\n * The promised function decorator ensures that any promise arguments\n * are resolved and passed as values (`this` is also resolved and passed\n * as a value).  It will also ensure that the result of a function is\n * always a promise.\n *\n * @example\n * var add = Q.promised(function (a, b) {\n *     return a + b;\n * });\n * add(Q.resolve(a), Q.resolve(B));\n *\n * @param {function} callback The function to decorate\n * @returns {function} a function that has been decorated.\n */\nexports.promised = promised;\nfunction promised(callback) {\n    return function () {\n        return all([this, all(arguments)]).spread(function (self, args) {\n          return callback.apply(self, args);\n        });\n    };\n}\n\n/**\n * Constructs a promise method that can be used to safely observe resolution of\n * a promise for an arbitrarily named method like \"propfind\" in a future turn.\n */\nexports.sender = deprecate(sender, \"sender\", \"dispatcher\"); // XXX deprecated, use dispatcher\nexports.Method = deprecate(sender, \"Method\", \"dispatcher\"); // XXX deprecated, use dispatcher\nfunction sender(op) {\n    return function (object) {\n        var args = array_slice(arguments, 1);\n        return send.apply(void 0, [object, op].concat(args));\n    };\n}\n\n/**\n * sends a message to a value in a future turn\n * @param object* the recipient\n * @param op the name of the message operation, e.g., \"when\",\n * @param ...args further arguments to be forwarded to the operation\n * @returns result {Promise} a promise for the result of the operation\n */\nexports.send = deprecate(send, \"send\", \"dispatch\"); // XXX deprecated, use dispatch\nfunction send(object, op) {\n    var deferred = defer();\n    var args = array_slice(arguments, 2);\n    object = resolve(object);\n    nextTick(function () {\n        object.promiseSend.apply(\n            object,\n            [op, deferred.resolve].concat(args)\n        );\n    });\n    return deferred.promise;\n}\n\n/**\n * sends a message to a value in a future turn\n * @param object* the recipient\n * @param op the name of the message operation, e.g., \"when\",\n * @param args further arguments to be forwarded to the operation\n * @returns result {Promise} a promise for the result of the operation\n */\nexports.dispatch = dispatch;\nfunction dispatch(object, op, args) {\n    var deferred = defer();\n    object = resolve(object);\n    nextTick(function () {\n        object.promiseSend.apply(\n            object,\n            [op, deferred.resolve].concat(args)\n        );\n    });\n    return deferred.promise;\n}\n\n/**\n * Constructs a promise method that can be used to safely observe resolution of\n * a promise for an arbitrarily named method like \"propfind\" in a future turn.\n *\n * \"dispatcher\" constructs methods like \"get(promise, name)\" and \"put(promise)\".\n */\nexports.dispatcher = dispatcher;\nfunction dispatcher(op) {\n    return function (object) {\n        var args = array_slice(arguments, 1);\n        return dispatch(object, op, args);\n    };\n}\n\n/**\n * Gets the value of a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to get\n * @return promise for the property value\n */\nexports.get = dispatcher(\"get\");\n\n/**\n * Sets the value of a property in a future turn.\n * @param object    promise or immediate reference for object object\n * @param name      name of property to set\n * @param value     new value of property\n * @return promise for the return value\n */\nexports.put = dispatcher(\"put\");\n\n/**\n * Deletes a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to delete\n * @return promise for the return value\n */\nexports[\"delete\"] = // XXX experimental\nexports.del = dispatcher(\"del\");\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param value     a value to post, typically an array of\n *                  invocation arguments for promises that\n *                  are ultimately backed with `resolve` values,\n *                  as opposed to those backed with URLs\n *                  wherein the posted value can be any\n *                  JSON serializable object.\n * @return promise for the return value\n */\n// bound locally because it is used by other methods\nvar post = exports.post = dispatcher(\"post\");\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param ...args   array of invocation arguments\n * @return promise for the return value\n */\nexports.invoke = function (value, name) {\n    var args = array_slice(arguments, 2);\n    return post(value, name, args);\n};\n\n/**\n * Applies the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param thisp     the `this` object for the call\n * @param args      array of application arguments\n */\n// XXX deprecated, use fapply\nvar apply = exports.apply = deprecate(dispatcher(\"apply\"), \"apply\", \"fapply\");\n\n/**\n * Applies the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param args      array of application arguments\n */\nvar fapply = exports.fapply = dispatcher(\"fapply\");\n\n/**\n * Calls the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param thisp     the `this` object for the call\n * @param ...args   array of application arguments\n */\n// XXX deprecated, use fcall\nexports.call = deprecate(call, \"call\", \"fcall\");\nfunction call(value, thisp) {\n    var args = array_slice(arguments, 2);\n    return apply(value, thisp, args);\n}\n\n/**\n * Calls the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nexports[\"try\"] = fcall; // XXX experimental\nexports.fcall = fcall;\nfunction fcall(value) {\n    var args = array_slice(arguments, 1);\n    return fapply(value, args);\n}\n\n/**\n * Binds the promised function, transforming return values into a fulfilled\n * promise and thrown errors into a rejected one.\n * @param object    promise or immediate reference for target function\n * @param thisp   the `this` object for the call\n * @param ...args   array of application arguments\n */\nexports.bind = deprecate(bind, \"bind\", \"fbind\"); // XXX deprecated, use fbind\nfunction bind(value, thisp) {\n    var args = array_slice(arguments, 2);\n    return function bound() {\n        var allArgs = args.concat(array_slice(arguments));\n        return apply(value, thisp, allArgs);\n    };\n}\n\n/**\n * Binds the promised function, transforming return values into a fulfilled\n * promise and thrown errors into a rejected one.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nexports.fbind = fbind;\nfunction fbind(value) {\n    var args = array_slice(arguments, 1);\n    return function fbound() {\n        var allArgs = args.concat(array_slice(arguments));\n        return fapply(value, allArgs);\n    };\n}\n\n/**\n * Requests the names of the owned properties of a promised\n * object in a future turn.\n * @param object    promise or immediate reference for target object\n * @return promise for the keys of the eventually resolved object\n */\nexports.keys = dispatcher(\"keys\");\n\n/**\n * Turns an array of promises into a promise for an array.  If any of\n * the promises gets rejected, the whole array is rejected immediately.\n * @param {Array*} an array (or promise for an array) of values (or\n * promises for values)\n * @returns a promise for an array of the corresponding values\n */\n// By Mark Miller\n// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled\nexports.all = all;\nfunction all(promises) {\n    return when(promises, function (promises) {\n        var countDown = promises.length;\n        if (countDown === 0) {\n            return resolve(promises);\n        }\n        var deferred = defer();\n        array_reduce(promises, function (undefined, promise, index) {\n            if (isFulfilled(promise)) {\n                promises[index] = valueOf(promise);\n                if (--countDown === 0) {\n                    deferred.resolve(promises);\n                }\n            } else {\n                when(promise, function (value) {\n                    promises[index] = value;\n                    if (--countDown === 0) {\n                        deferred.resolve(promises);\n                    }\n                })\n                .fail(deferred.reject);\n            }\n        }, void 0);\n        return deferred.promise;\n    });\n}\n\n/**\n * Waits for all promises to be resolved, either fulfilled or\n * rejected.  This is distinct from `all` since that would stop\n * waiting at the first rejection.  The promise returned by\n * `allResolved` will never be rejected.\n * @param promises a promise for an array (or an array) of promises\n * (or values)\n * @return a promise for an array of promises\n */\nexports.allResolved = allResolved;\nfunction allResolved(promises) {\n    return when(promises, function (promises) {\n        return when(all(array_map(promises, function (promise) {\n            return when(promise, noop, noop);\n        })), function () {\n            return array_map(promises, resolve);\n        });\n    });\n}\n\n/**\n * Captures the failure of a promise, giving an oportunity to recover\n * with a callback.  If the given promise is fulfilled, the returned\n * promise is fulfilled.\n * @param {Any*} promise for something\n * @param {Function} callback to fulfill the returned promise if the\n * given promise is rejected\n * @returns a promise for the return value of the callback\n */\nexports[\"catch\"] = // XXX experimental\nexports.fail = fail;\nfunction fail(promise, rejected) {\n    return when(promise, void 0, rejected);\n}\n\n/**\n * Attaches a listener that can respond to progress notifications from a\n * promise's originating deferred. This listener receives the exact arguments\n * passed to ``deferred.notify``.\n * @param {Any*} promise for something\n * @param {Function} callback to receive any progress notifications\n * @returns the given promise, unchanged\n */\nexports.progress = progress;\nfunction progress(promise, progressed) {\n    return when(promise, void 0, void 0, progressed);\n}\n\n/**\n * Provides an opportunity to observe the rejection of a promise,\n * regardless of whether the promise is fulfilled or rejected.  Forwards\n * the resolution to the returned promise when the callback is done.\n * The callback can return a promise to defer completion.\n * @param {Any*} promise\n * @param {Function} callback to observe the resolution of the given\n * promise, takes no arguments.\n * @returns a promise for the resolution of the given promise when\n * ``fin`` is done.\n */\nexports[\"finally\"] = // XXX experimental\nexports.fin = fin;\nfunction fin(promise, callback) {\n    return when(promise, function (value) {\n        return when(callback(), function () {\n            return value;\n        });\n    }, function (exception) {\n        return when(callback(), function () {\n            return reject(exception);\n        });\n    });\n}\n\n/**\n * Terminates a chain of promises, forcing rejections to be\n * thrown as exceptions.\n * @param {Any*} promise at the end of a chain of promises\n * @returns nothing\n */\nexports.end = deprecate(done, \"end\", \"done\"); // XXX deprecated, use done\nexports.done = done;\nfunction done(promise, fulfilled, rejected, progress) {\n    function onUnhandledError(error) {\n        // forward to a future turn so that ``when``\n        // does not catch it and turn it into a rejection.\n        nextTick(function () {\n            makeStackTraceLong(error, promise);\n\n            if (exports.onerror) {\n                exports.onerror(error);\n            } else {\n                throw error;\n            }\n        });\n    }\n\n    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.\n    var promiseToHandle = fulfilled || rejected || progress ?\n        when(promise, fulfilled, rejected, progress) :\n        promise;\n\n    fail(promiseToHandle, onUnhandledError);\n}\n\n/**\n * Causes a promise to be rejected if it does not get fulfilled before\n * some milliseconds time out.\n * @param {Any*} promise\n * @param {Number} milliseconds timeout\n * @returns a promise for the resolution of the given promise if it is\n * fulfilled before the timeout, otherwise rejected.\n */\nexports.timeout = timeout;\nfunction timeout(promise, ms) {\n    var deferred = defer();\n    var timeoutId = setTimeout(function () {\n        deferred.reject(new Error(\"Timed out after \" + ms + \" ms\"));\n    }, ms);\n\n    when(promise, function (value) {\n        clearTimeout(timeoutId);\n        deferred.resolve(value);\n    }, function (exception) {\n        clearTimeout(timeoutId);\n        deferred.reject(exception);\n    });\n\n    return deferred.promise;\n}\n\n/**\n * Returns a promise for the given value (or promised value) after some\n * milliseconds.\n * @param {Any*} promise\n * @param {Number} milliseconds\n * @returns a promise for the resolution of the given promise after some\n * time has elapsed.\n */\nexports.delay = delay;\nfunction delay(promise, timeout) {\n    if (timeout === void 0) {\n        timeout = promise;\n        promise = void 0;\n    }\n    var deferred = defer();\n    setTimeout(function () {\n        deferred.resolve(promise);\n    }, timeout);\n    return deferred.promise;\n}\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided as an array, and returns a promise.\n *\n *      Q.nfapply(FS.readFile, [__filename])\n *      .then(function (content) {\n *      })\n *\n */\nexports.nfapply = nfapply;\nfunction nfapply(callback, args) {\n    var nodeArgs = array_slice(args);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n\n    fapply(callback, nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n}\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided individually, and returns a promise.\n *\n *      Q.nfcall(FS.readFile, __filename)\n *      .then(function (content) {\n *      })\n *\n */\nexports.nfcall = nfcall;\nfunction nfcall(callback/*, ...args */) {\n    var nodeArgs = array_slice(arguments, 1);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n\n    fapply(callback, nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n}\n\n/**\n * Wraps a NodeJS continuation passing function and returns an equivalent\n * version that returns a promise.\n *\n *      Q.nfbind(FS.readFile, __filename)(\"utf-8\")\n *      .then(console.log)\n *      .done()\n *\n */\nexports.nfbind = nfbind;\nfunction nfbind(callback/*, ...args */) {\n    var baseArgs = array_slice(arguments, 1);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n\n        fapply(callback, nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n}\n\n/**\n * Passes a continuation to a Node function, which is called with a given\n * `this` value and arguments provided as an array, and returns a promise.\n *\n *      Q.napply(FS.readFile, FS, [__filename])\n *      .then(function (content) {\n *      })\n *\n */\nexports.napply = deprecate(napply, \"napply\", \"npost\");\nfunction napply(callback, thisp, args) {\n    return nbind(callback, thisp).apply(void 0, args);\n}\n\n/**\n * Passes a continuation to a Node function, which is called with a given\n * `this` value and arguments provided individually, and returns a promise.\n *\n *      Q.ncall(FS.readFile, FS, __filename)\n *      .then(function (content) {\n *      })\n *\n */\nexports.ncall = deprecate(ncall, \"ncall\", \"ninvoke\");\nfunction ncall(callback, thisp /*, ...args*/) {\n    var args = array_slice(arguments, 2);\n    return napply(callback, thisp, args);\n}\n\n/**\n * Wraps a NodeJS continuation passing function and returns an equivalent\n * version that returns a promise.\n *\n *      Q.nbind(FS.readFile, FS)(__filename)\n *      .then(console.log)\n *      .done()\n *\n */\nexports.nbind = deprecate(nbind, \"nbind\", \"nfbind\");\nfunction nbind(callback /* thisp, ...args*/) {\n    if (arguments.length > 1) {\n        var thisp = arguments[1];\n        var args = array_slice(arguments, 2);\n\n        var originalCallback = callback;\n        callback = function () {\n            var combinedArgs = args.concat(array_slice(arguments));\n            return originalCallback.apply(thisp, combinedArgs);\n        };\n    }\n    return function () {\n        var deferred = defer();\n        var args = array_slice(arguments);\n        // add a continuation that resolves the promise\n        args.push(deferred.makeNodeResolver());\n        // trap exceptions thrown by the callback\n        fapply(callback, args)\n        .fail(deferred.reject);\n        return deferred.promise;\n    };\n}\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback with a given array of arguments, plus a provided callback.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param {Array} args arguments to pass to the method; the callback\n * will be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nexports.npost = npost;\nfunction npost(object, name, args) {\n    var nodeArgs = array_slice(args);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n\n    post(object, name, nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n}\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback, forwarding the given variadic arguments, plus a provided\n * callback argument.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param ...args arguments to pass to the method; the callback will\n * be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nexports.ninvoke = ninvoke;\nfunction ninvoke(object, name /*, ...args*/) {\n    var nodeArgs = array_slice(arguments, 2);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n\n    post(object, name, nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n}\n\nexports.nend = deprecate(nodeify, \"nend\", \"nodeify\"); // XXX deprecated, use nodeify\nexports.nodeify = nodeify;\nfunction nodeify(promise, nodeback) {\n    if (nodeback) {\n        promise.then(function (value) {\n            nextTick(function () {\n                nodeback(null, value);\n            });\n        }, function (error) {\n            nextTick(function () {\n                nodeback(error);\n            });\n        });\n    } else {\n        return promise;\n    }\n}\n\n// All code before this point will be filtered from stack traces.\nvar qEndingLine = captureLine();\n\n});\n\n}).call(this,require(\"Mk2NyG\"))","'use strict';\n\nvar BoundingBox = module.exports = function(element, left, top){\n\tthis.element = element;\n\tthis.top = top || 0;\n\tthis.left = left || 0;\n\tthis.width = this.element.width;\n\tthis.height = this.element.height;\n\tthis.bottom = this.top + this.height;\n\tthis.right = this.left + this.width;\n\n\telement.locations.push(this);\n};\n\nBoundingBox.prototype.show = function(container){\n\tif(this.visible) return;\n\t\n\tthis.visible = true;\n\tthis.element.show(this.left, this.top, container);\n};\n\nBoundingBox.prototype.hide = function(container){\n\tif(!this.visible) return;\n\n\tthis.visible = false;\n\tthis.element.hide(container);\n};","'use strict';\n\nmodule.exports = Tag;\n\nfunction Tag(){\n\tthis.elements = [];\n}\n\nTag.create = function(options){\n\toptions = options || {};\n\tvar tag = new Tag();\n\t\n\tif('skipProbability' in options) tag.skipProbability = options.skipProbability;\n\tif('tryLimit' in options) tag.tryLimit = options.tryLimit;\n\n\treturn tag;\n};\n\nTag.prototype.chanceMultiplier = 1;\nTag.prototype.skipProbability = 0;\n\nTag.prototype.add = function(element){\n\tvar chanceMultiplier = element.chanceMultiplier;\n\twhile(chanceMultiplier--) this.elements.push(element);\n};\n\nTag.prototype.remove = function(element){\n\tvar\tindex;\n\n\t// Remove all instances of the element\n\twhile(~(index =  this.elements.indexOf(element))){\n\t\tthis.elements.splice(index, 1);\n\t}\n};\n\nTag.prototype.getElements = function(){\n\treturn this.elements.slice();\n};\n\nTag.prototype.getRandomElement = function(){\n\treturn this.elements[(Math.random() * this.elements.length)|0];\n};\n\n\n","'use strict';\n\nvar Q = require('../bower_components/q/q.js');\nvar createQuadtree = require('../bower_components/giant-quadtree/dist/GiantQuadtree.js').create,\n\tSurface = require('../bower_components/big-surface/dist/BigSurface.js');\n\nvar BoundingBox = require('./BoundingBox.js'),\n\tTag = require('./Tag.js');\n\nvar Collage = module.exports = function(container){\n\tSurface.call(this, container);\n\tthis.quadtree = createQuadtree(15000);\n\n\tthis.tags = {};\n\tthis.activeTags = [];\n\n\tthis.updateCanvasDimensions();\n};\n\nCollage.prototype = Object.create(Surface.prototype);\n\nCollage.create = function(container){\n\tvar collage = new Collage(container);\n\treturn Collage.getApi(collage);\n};\n\nCollage.getApi = function(collage){\n\tvar api = Surface.getApi(collage);\n\n\tapi.createTag = collage.createTag.bind(collage);\n\tapi.configureTag = collage.configureTag.bind(collage);\n\t\n\tapi.setActiveTags = collage.setActiveTags.bind(collage);\n\t\n\tapi.pause = collage.pause.bind(collage);\n\tapi.resume = collage.resume.bind(collage);\n\n\tapi.load = collage.loadElements.bind(collage);\n\tapi.add = collage.addElements.bind(collage);\n\tapi.remove = collage.removeElement.bind(collage);\n\tapi.get = collage.getElements.bind(collage);\n\tapi.showElement = collage.showElement.bind(collage);\n\tapi.loader = collage.loader;\n\n\tapi.fill = function(){\n\t\tcollage.updateCanvasDimensions();\n\t\tcollage.pickNextElement();\n\n\t\tif(collage.nextElement){\n\t\t\treturn collage.fillCenter();\t\n\t\t}\n\n\t\treturn [];\n\t};\n\n\tapi.start = collage.start.bind(collage);\n\t\n\treturn api;\n};\n\nCollage.loader = require('./loader/index.js');\nCollage.element = require('./element/index.js');\n\n// How many random spot will be checked to place elements per frame\nCollage.prototype.scanTryLimit = 20;\n\n// Max number of frames an element has to find a place before another is picked\n// this prevents large gaps due to large elements\nCollage.prototype.missLimit = 4;\n\n// Minimum pixel spacing between elements\nCollage.prototype.elementMargin = 25;\n\n// How much beyond the window to scan for places to put objects when filling\nCollage.prototype.overScan = 0;\n\nCollage.prototype.hidingArea =  document.createDocumentFragment();\nCollage.prototype.minElementSize = 50;\n\nCollage.prototype.createTag = function(name, options){\n\tthis.tags[name] = Tag.create(options);\n\treturn this.tags[name];\n};\n\nCollage.prototype.configureTag = function(name, options){\n\tvar tag = this.tags[name];\n\tif(!tag){\n\t\tthis.createTag(options);\n\t\treturn;\n\t}\n\n\tif('skipProbability' in options) tag.skipProbability = options.skipProbability;\n\tif('tryLimit' in options) tag.tryLimit = options.tryLimit;\n};\n\nCollage.prototype.loadElements = function(tagNames, arg2, arg3){\n\tvar addElements = this.addElements.bind(this, tagNames),\n\t\tloaderMap,\n\t\tloaderName,\n\t\tloader,\n\t\tloaderConfig,\n\t\tloaderConfigs,\n\t\tloaderConfigIndex,\n\t\tpromise,\n\t\tpromises = [];\n\n\tif(typeof arg2 === 'string'){\n\t\t// Handle the .load([tag name], [loader name], [loader config]) case\n\t\tloaderMap = {};\n\t\tloaderMap[arg2] = arg3;\t\n\t} else {\n\t\t// Handle the .load([tag name], [loader map]) case\n\t\tloaderMap = arg2;\n\t} \n\n\tfor(loaderName in loaderMap){\n\t\tif(loaderMap.hasOwnProperty(loaderName)){\n\t\t\tloader = Collage.loader[loaderName];\n\t\t\tloaderConfigs = loaderMap[loaderName];\n\t\t\tif(!Array.isArray(loaderConfigs)) loaderConfigs = [loaderConfigs];\t\t\n\t\t\tloaderConfigIndex = loaderConfigs.length;\n\n\t\t\tloaderConfig = loaderConfigs[--loaderConfigIndex];\n\t\t\twhile(loaderConfig){\n\t\t\t\tpromise = loader(this, loaderConfig).then(addElements);\n\t\t\t\tpromises.push(promise);\t\n\t\t\t\tloaderConfig = loaderConfigs[--loaderConfigIndex];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn Q.allResolved(promises);\n};\n\nCollage.prototype.addElements = function(tagNames, elements){\n\tif(!Array.isArray(tagNames)) tagNames = [tagNames];\n\tif(!Array.isArray(elements)) elements = [elements];\n\t\n\tvar tagNameIndex = tagNames.length,\n\t\ttagName,\n\t\ttag,\n\t\telementIndex;\n\n\t// For each tag...\n\ttagName = tagNames[--tagNameIndex];\n\twhile(tagName){\n\t\ttag = this.tags[tagName] || this.createTag(tagName);\n\t\telementIndex = elements.length;\n\t\twhile(elementIndex--) tag.add(elements[elementIndex]);\n\t\ttagName = tagNames[--tagNameIndex];\n\t}\n};\n\nCollage.prototype.fadeInToCenter = function(){};\n\nCollage.prototype.removeElement = function(tagNames, element){\n\tif(!Array.isArray(tagNames)) tagNames = [tagNames];\n\t\n\tvar tagNameIndex = tagNames.length,\n\t\ttagName,\n\t\ttag;\n\n\ttagName = tagNames[tagNameIndex--];\n\twhile(tagName){\n\t\ttag = this.tags[tagName];\n\t\tif(!tag) continue;\n\t\ttag.remove(element);\n\t\ttagName = tagNames[tagNameIndex--];\n\t}\n};\n\nCollage.prototype.getElements = function(){\n\tvar tagNames = (arguments.length > 0)? arguments : Object.keys(this.tags),\n\t\ttagNameIndex = tagNames.length,\n\t\ttagName,\n\t\ttag,\n\t\telements = [];\n\n\ttagName = tagNames[--tagNameIndex];\n\twhile(tagName){\n\t\ttag = this.tags[tagName];\n\t\tif(tag){\n\t\t\telements = elements.concat(tag.getElements());\n\t\t}\n\t\ttagName = tagNames[--tagNameIndex];\n\t}\n\n\treturn elements;\n};\n\nCollage.prototype.setActiveTags = function(){\n\tvar index = arguments.length,\n\t\ttagName,\n\t\ttag,\n\t\tchanceMultiplier,\n\t\tactiveTags = [];\n\n\ttagName = arguments[--index];\n\twhile(tagName){\n\t\ttag = this.tags[tagName];\n\t\tif(tag){\n\t\t\tchanceMultiplier = tag.chanceMultiplier;\n\t\t\twhile(chanceMultiplier--) activeTags.push(tag);\n\t\t}\n\t\ttagName = arguments[--index];\n\t}\n\n\tthis.activeTags = activeTags;\n};\n\nCollage.prototype.getRandomActiveTag = function(){\n\tvar tag,\n\t\tfailSafe = this.getRandomActiveTagFailSafe;\n\n\twhile(failSafe--){\n\t\ttag = this.activeTags[(Math.random() * this.activeTags.length)|0];\n\t\tif(tag.skipProbability < Math.random()) break;\n\t}\n\t\n\treturn tag;\n};\n\nCollage.prototype.pause = function(duration){\n\tif(this.savedHorizontalVelocityScalar !== void 0) return;\n\tthis.savedHorizontalVelocityScalar = this.horizontalVelocityScalar;\n\tthis.savedVerticalVelocityScalar = this.verticalVelocityScalar;\n\tthis.setVelocityScalar(0, duration || 0.4);\n};\n\nCollage.prototype.resume = function(duration){\n\tif(this.savedHorizontalVelocityScalar === void 0) return;\n\n\tthis.setHorizontalVelocityScalar(this.savedHorizontalVelocityScalar, (duration || 0.4));\n\tthis.setVerticalVelocityScalar(this.savedVerticalVelocityScalar, (duration || 0.4));\n\tthis.savedHorizontalVelocityScalar = void 0;\n};\n\nCollage.prototype.savedHorizontalVelocityScalar = void 0;\nCollage.prototype.savedVerticalVelocityScalar = void 0;\n\nCollage.prototype.getRandomActiveTagFailSafe = 20;\nCollage.prototype.getRandomElementFailSafe = 20;\nCollage.prototype.getRandomElementTryLimit = 20;\nCollage.prototype.maxElementWidth = 2000;\nCollage.prototype.maxElementHeight = 1000;\n\nCollage.prototype.getRandomElement = function(){\n\tvar failSafe = this.getRandomElementFailSafe,\n\t\tinCanvasRange = true,\n\t\tleft = this.viewportLeft - this.maxElementWidth,\n\t\ttop = this.viewportTop - this.maxElementHeight,\n\t\tright = this.viewportRight + this.maxElementWidth,\n\t\tbottom = this.viewportBottom + this.maxElementHeight,\n\t\telement,\n\t\ttag,\n\t\ttryLimit;\n\n\twhile(inCanvasRange && failSafe--){\n\t\ttag = this.getRandomActiveTag();\n\t\ttryLimit = tag.tryLimit || this.getRandomElementTryLimit;\n\n\t\twhile(tryLimit--){\n\t\t\telement = tag.getRandomElement();\n\n\t\t\tif(!element.isIn(left, top, right, bottom)){\n\t\t\t\treturn element;\n\t\t\t}\n\t\t}\n\t}\n};\n\nCollage.prototype.transformStep = function(){\n\tSurface.prototype.transformStep.call(this);\n\tthis.updateCanvasDimensions();\n\tthis.updateElementVisibility();\n\tthis.maxCheckHeight = 0;\n\tthis.maxCheckWidth = 0;\n\n\tthis.pickNextElement();\n\tif(this.nextElement) this.fill();\n};\n\nCollage.prototype.start = function(){\n\tif(arguments.length > 0) this.setActiveTags.apply(this, arguments);\n\t\n\tif(this.activeTags.length === 0){\n\t\tthrow new Error('Unable to start without active tags');\n\t}\n\tthis.startTransformLoop();\n\tthis.updateCanvasDimensions();\n\tthis.pickNextElement();\n\n\tif(this.nextElement){\n\t\tthis.fillCenter();\t\n\t}\n};\n\nCollage.prototype.pickNextElement = function(){\n\tthis.nextElement = this.getRandomElement();\n\tthis.missCount = 0;\n\n\tif(this.nextElement){\n\t\tthis.updateBounds();\n\t}\n};\n\nCollage.prototype.insertNextElement = function(left, top, show){\n\tvar box = this.showElement(this.nextElement, left, top, show);\n\tthis.pickNextElement();\n\treturn box;\n};\n\nCollage.prototype.showElement = function(element, left, top, show){\n\tvar boundingBox = new BoundingBox(element, left, top);\n\tthis.quadtree.insert(boundingBox);\n\t\n\tif(show){\n\t\tboundingBox.show(this.element);\n\t} else {\n\t\tboundingBox.hide(this.hidingArea);\n\t}\n\n\treturn boundingBox;\n};\n\nCollage.prototype.getViewportBoundingBoxes = function(){\n\treturn this.quadtree.getObjects(this.viewportLeft, this.viewportTop, this.viewportWidth, this.viewportHeight);\n};\n\n\nCollage.prototype.getViewportElements = function(){\n\tvar boundingBoxes = this.getViewportBoundingBoxes(),\n\t\tindex = boundingBoxes.length,\n\t\tresult = [];\n\n\t// boundingBoxes.map would be proper but is less proc efficient\n\twhile(index--) result.push(boundingBoxes[index].element);\n\n\treturn result;\n};\n\nCollage.prototype.updateElementVisibility = function(){\n\tvar oldBoxes = this.visibleBoxes || [],\n\t\tnewBoxes = this.quadtree.getObjects(this.viewportLeft, this.viewportTop, this.viewportWidth, this.viewportHeight),\n\t\tindex,\n\t\tbox;\n\n\t// Mark old visible to hide\n\tindex = oldBoxes.length;\n\twhile(index--) oldBoxes[index].hidePending = true;\n\n\tindex = newBoxes.length;\n\twhile(index--){\n\t\tbox = newBoxes[index];\n\t\tif(!box.visible) box.show(this.element);\n\n\t\t// Clear hide flags for things that are still visible\n\t\tbox.hidePending = false;\n\t}\n\n\t// Hide elements no longer in view\n\tindex = oldBoxes.length;\n\twhile(index--){\n\t\tbox = oldBoxes[index];\n\t\tif(box.hidePending) box.hide(this.hidingArea);\n\t}\n\n\tthis.visibleBoxes = newBoxes;\n};\n\nCollage.prototype.updateCanvasDimensions = function(){\n\tthis.viewportLeft = -1 * this.horizontalPosition - this.overScan;\n\tthis.viewportTop = -1 * this.verticalPosition - this.overScan;\n\tthis.viewportWidth = this.width + this.overScan * 2;\n\tthis.viewportHeight = this.height + this.overScan * 2;\n\tthis.viewportRight = this.viewportLeft + this.viewportWidth;\n\tthis.viewportBottom = this.viewportTop + this.viewportHeight;\n\t\n\tthis.movingUp = this.lastVerticalDisplacement > 0;\n\tthis.movingLeft = this.lastHorizontalDisplacement > 0;\n};\n\nCollage.prototype.fillCenter = function(){\n\tvar boxes = this.quadtree.getObjects(\n\t\tthis.viewportLeft - this.checkWidth,\n\t\tthis.viewportTop - this.checkHeight,\n\t\tthis.viewportWidth + this.checkWidth * 2,\n\t\tthis.viewportHeight + this.checkHeight * 2\n\t);\n\n\tvar\tboundingBoxes = [],\n\t\tscanCheckLeft,\n\t\tscanCheckTop,\n\t\tscanCheckRight,\n\t\tscanCheckBottom,\n\n\t\ttryCount = 0,\n\t\ttryLimit = this.scanTryLimit * 10,\n\t\tmissCount = 0,\n\t\tmissLimit = tryLimit / 20;\n\n\tfor(;tryCount < tryLimit; tryCount++){\n\t\tmissCount++;\n\n\t\tif(missCount > missLimit){\n\t\t\tmissCount = 0;\n\t\t\tthis.pickNextElement();\n\t\t\tif(!this.nextElement) break;\n\t\t}\n\n\t\tscanCheckLeft = (this.viewportLeft - this.checkWidth) + \n\t\t\tMath.floor((this.viewportWidth + this.checkWidth) * Math.random());\n\t\tscanCheckTop = (this.viewportTop - this.checkHeight) + \n\t\t\tMath.floor((this.viewportHeight + this.checkHeight) * Math.random());\n\t\tscanCheckRight = scanCheckLeft + this.checkWidth;\n\t\tscanCheckBottom = scanCheckTop + this.checkHeight;\n\t\n\t\tif(!hasCollision(boxes, scanCheckLeft, scanCheckTop, scanCheckRight, scanCheckBottom)){\n\t\t\tboundingBoxes.push(this.insertNextElement(scanCheckLeft + this.elementMargin, scanCheckTop + this.elementMargin));\n\t\t\tif(!this.nextElement) break;\n\n\t\t\tmissCount = 0;\n\t\t\tboxes = this.quadtree.getObjects(\n\t\t\t\tthis.viewportLeft - this.checkWidth,\n\t\t\t\tthis.viewportTop - this.checkHeight,\n\t\t\t\tthis.viewportWidth + this.checkWidth * 2,\n\t\t\t\tthis.viewportHeight + this.checkHeight * 2\n\t\t\t);\n\t\t}\n\t}\n\n\tthis.updateElementVisibility();\n\treturn boundingBoxes;\n};\n\nCollage.prototype.updateBounds = function(){\n\tthis.checkHeight = this.nextElement.height + this.elementMargin * 2;\n\tthis.checkWidth = this.nextElement.width + this.elementMargin * 2;\n\n\tthis.checkLeft = this.movingLeft ? (this.viewportLeft - this.checkWidth) : this.viewportRight;\n\tthis.checkTop = this.movingUp ? this.viewportTop - this.checkHeight : this.viewportBottom;\n\tthis.checkRight = this.checkLeft + this.checkWidth;\n\tthis.checkBottom = this.checkTop + this.checkHeight;\n\t\t\n\tthis.scanLeft = this.viewportLeft - this.checkWidth;\n\tthis.scanTop = this.viewportTop - this.checkHeight;\n\tthis.scanWidth = this.viewportWidth + this.checkWidth;\n\tthis.scanHeight = this.viewportHeight + this.checkHeight;\n\n\tthis.horizontalBoxes = this.quadtree.getObjects(\n\t\t(this.movingLeft ?  this.viewportLeft - this.checkWidth : this.viewportRight),\n\t\tthis.scanTop,\n\t\tthis.checkWidth,\n\t\tthis.scanHeight + this.checkHeight\n\t);\n\n\tthis.verticalBoxes = this.quadtree.getObjects(\n\t\tthis.scanLeft,\n\t\t(this.movingUp ? (this.viewportTop - this.checkHeight) : this.viewportBottom),\n\t\tthis.scanWidth + this.checkWidth,\n\t\tthis.checkHeight\n\t);\n};\n\nfunction hasCollision(boxList, left, top, right, bottom){\n\tvar index = boxList.length,\n\t\tbox;\n\n\twhile(index--){\n\t\tbox = boxList[index];\n\n\t\t// If there is a y-axis intersection\n\t\tif ((top <= box.top ?\n\t\t\t\t\t\t(bottom >= box.top) :\n\t\t\t\t\t\t(box.bottom >= top)) && \n\t\t\t\t\t\t\t// And if there is intersection along the x-axis\n\t\t\t\t\t\t\t(left <= box.left ?\n\t\t\t\t\t\t\t\t(right >= box.left) :\n\t\t\t\t\t\t\t\t(box.right >= left))){\n\t\t\treturn true;\n\t\t}\n\t}\n\n\treturn false;\n}\n\nCollage.prototype.fill = function(){\n\tvar tryCount = 0,\n\t\ttryLimit = this.scanTryLimit,\n\t\tscanCheckLeft,\n\t\tscanCheckTop,\n\t\tscanCheckRight,\n\t\tscanCheckBottom;\n\n\tthis.missCount++;\n\tif(this.missCount > this.missLimit){\n\t\tthis.pickNextElement();\n\t\tif(!this.nextElement) return;\n\t}\n\n\tfor(;tryCount < tryLimit; tryCount++){\n\t\t// VERTICAL\n\t\tscanCheckLeft = this.scanLeft + Math.floor(this.scanWidth * Math.random());\n\t\tscanCheckRight = scanCheckLeft + this.checkWidth;\n\t\t\n\t\tif(!hasCollision(this.verticalBoxes, scanCheckLeft, this.checkTop, scanCheckRight, this.checkBottom)){\n\t\t\tthis.insertNextElement(scanCheckLeft + this.elementMargin, this.checkTop + this.elementMargin);\n\t\t\tif(!this.nextElement) break;\n\t\t}\n\n\t\t// HORIZONTAL\n\t\tscanCheckTop = this.scanTop + Math.floor(this.scanHeight * Math.random());\n\t\tscanCheckBottom = scanCheckTop + this.checkHeight;\n\n\t\tif(!hasCollision(this.horizontalBoxes, this.checkLeft, scanCheckTop, this.checkRight, scanCheckBottom)){\n\t\t\tvar box = this.insertNextElement(this.checkLeft + this.elementMargin, scanCheckTop + this.elementMargin);\n\t\t\tthis.horizontalBoxes.push(box);\n\n\t\t\tif(!this.nextElement) break;\n\t\t}\n\t}\n};\n","'use strict';\n\nmodule.exports = BaseElement;\n\nfunction BaseElement(domElement, width, height){\n\tthis.element = domElement;\n\tthis.width = width || domElement.width || parseInt(domElement.clientWidth);\n\tthis.height = height || domElement.height || parseInt(domElement.clientHeight);\n\tthis.locations = [];\n\tthis.isVisible = undefined;\n\t\n\tthis.element.style.position = 'absolute';\n}\n\nBaseElement.create = function(domElement, width, height){\n\tvar element = new BaseElement(domElement, width, height);\n\treturn BaseElement.getApi(element);\n};\n\nBaseElement.getApi = function(element){\n\tvar api = {};\n\tapi.element = element.element;\n\tapi.isIn = element.isIn.bind(element);\n\tapi.reposition = element.reposition.bind(element);\n\tapi.show = element.show.bind(element);\n\tapi.hide = element.hide.bind(element);\n\n\tObject.defineProperty(api, 'width', {\n\t\tget: function(){return element.width;}\n\t});\n\n\tObject.defineProperty(api, 'visible', {\n\t\tget: function(){return element.isVisible;}\n\t});\n\n\tObject.defineProperty(api, 'height', {\n\t\tget: function(){return element.height;}\n\t});\n\n\tObject.defineProperty(api, 'chanceMultiplier', {\n\t\tget: function(){return element.chanceMultiplier;},\n\t\tset: function(value){ element.chanceMultiplier = value;}\n\t});\n\n\tObject.defineProperty(api, 'locations', {\n\t\tget: function(){return element.locations; }\n\t});\n\n\treturn api;\n};\n\nBaseElement.prototype.chanceMultiplier = 1;\n\nBaseElement.prototype.isIn = function(left, top, right, bottom){\n\tvar locationIndex = this.locations.length,\n\t\tboundingBox = this.locations[--locationIndex];\n\n\twhile(boundingBox){\n\t\tif((((left < boundingBox.left && boundingBox.left < right) ||\n\t\t\t\t(boundingBox.right < right && left < boundingBox.right)) &&\n\t\t\t((top < boundingBox.top && boundingBox.top < bottom) || \n\t\t\t\t(boundingBox.bottom < bottom && top < boundingBox.bottom)))){\n\t\t\treturn true;\n\t\t}\n\t\tboundingBox = this.locations[--locationIndex];\n\t}\n\n\treturn false;\n};\n\nBaseElement.prototype.reposition = function(left, top){\n\tthis.element.style.left = left + 'px';\n\tthis.element.style.top = top + 'px';\n};\n\nBaseElement.prototype.hide = function(){\n\tthis.isVisible = false;\n};\n\nBaseElement.prototype.show = function(left, top){\n\tthis.reposition(left, top);\n\tthis.isVisible = true;\n};","'use strict';\n\nvar BaseElement = require('./Element.js');\n\nmodule.exports = IframeElement;\n\n// iOS has a rendering bug related to iframes,\nvar isiOS = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? true : false );\n\nfunction IframeElement (element){\n\tBaseElement.call(this, element, parseInt(element.width), parseInt(element.height));\n\n\tthis.iframe = this.element.querySelector('iframe') || this.element;\n\tthis.isLocal = this.iframe.contentDocument && this.iframe.contentDocument.body && \n\t\tthis.iframe.contentDocument.body.innerHTML !== '';\n\t\n\t// Hack to fix for iOS's failure to render the inside of a iframe \n\t// when using css transforms. If we have permission to edit the iframe,\n\t// this method is much more performant that the hack in .show\n\tif(isiOS && this.isLocal){\n\t\tthis.iframe.contentDocument.body.style.webkitTransform = 'translate3d(0, 0, 0)';\n\t}\n\t\n\tthis.hide();\n}\nIframeElement.prototype = Object.create(BaseElement.prototype);\n\nIframeElement.create = function(element){\n\telement = new IframeElement(element);\n\treturn IframeElement.getApi(element);\n};\n\nIframeElement.getApi = function(element){\n\treturn BaseElement.getApi(element);\n};\n\nIframeElement.prototype.hide = function(){\n\tBaseElement.prototype.hide.call(this);\n\tthis.element.style.opacity = 0;\n\t\n\tif(this.fidget){\n\t\tclearInterval(this.fidget);\n\t\tthis.fidget = void 0;\n\t}\n};\n\nIframeElement.prototype.show = function(left, top){\n\tBaseElement.prototype.show.call(this, left, top);\n\tthis.element.style.opacity = 1;\n\n\t// Hack to fix for iOS's failure to render the \n\t// inside of a iframe when using css transforms.\n\tif(isiOS && !this.isLocal && !this.fidget){\n\t\tvar iframe = this.iframe,\n\t\t\tflipper = 0.001;\n\n\t\tthis.fidget = setInterval(function(){\n\t\t\tiframe.style.opacity = 1 + flipper;\n\t\t\tflipper *= -1;\n\t\t}, 200);\n\t}\n};\n","'use strict';\n\nvar BaseElement = require('./Element.js');\n\nmodule.exports = SimpleElement;\n\nfunction SimpleElement (element){\n\tBaseElement.call(this, element, parseInt(element.width), parseInt(element.height));\n\tthis.appended = undefined;\n}\nSimpleElement.prototype = Object.create(BaseElement.prototype);\n\nSimpleElement.create = function(element){\n\telement = new SimpleElement(element);\n\treturn SimpleElement.getApi(element);\n};\n\nSimpleElement.getApi = function(element){\n\treturn BaseElement.getApi(element);\n};\n\n//var hidingArea = document.createDocumentFragment();\nSimpleElement.prototype.hide = function(){\t\n\tBaseElement.prototype.hide.call(this);\n\tthis.element.style.display = 'none';\n\t//hidingArea.appendChild(this.element);\n};\n\nSimpleElement.prototype.show = function(left, top, container){\n\tBaseElement.prototype.show.call(this, left, top);\n\tthis.element.style.display = 'block';\n\tif(!this.appended){\n\t\tcontainer.appendChild(this.element);\n\t\tthis.appended = true;\n\t}\n};","'use strict';\n\nvar EventEmitter = require('../../bower_components/eventEmitter/EventEmitter.js').EventEmitter;\nvar BaseElement = require('./Element.js');\nmodule.exports = VideoElement;\n\n// Manages global tasks, such as periodic polling of players\n// to gather time information\nvar timeManager = (function(){\n\tvar ACTIVE_ELEMENTS = [],\n\t\tPERIODIC_LISTENER,\n\t\tapi = {};\n\n\tapi.add = function(element){\n\t\tACTIVE_ELEMENTS.push(element);\n\t\tif(ACTIVE_ELEMENTS.length === 1){\n\t\t\tPERIODIC_LISTENER = setInterval(function(){\n\t\t\t\tACTIVE_ELEMENTS.forEach(function(element){\n\t\t\t\t\tvar time = Math.round(element.player.getCurrentTime()),\n\t\t\t\t\t\telapsed = time - element.lastReportedTime;\n\t\t\t\t\t\n\t\t\t\t\tif(elapsed === 0) return;\n\t\t\t\t\tif(elapsed === 1){\n\t\t\t\t\t\telement.lastReportedTime = time;\n\t\t\t\t\t\telement.emitter.emit('time', time);\n\t\t\t\t\t\telement.emitter.emit('time:' + time);\n\t\t\t\t\t} else { // In case we missed some ticks, make up for them\n\t\t\t\t\t\tvar start = element.lastReportedTime + 1;\n\t\t\t\t\t\tfor(; start < time; start++){\n\t\t\t\t\t\t\telement.lastReportedTime = start;\n\t\t\t\t\t\t\telement.emitter.emit('time', start);\n\t\t\t\t\t\t\telement.emitter.emit('time:' + start);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}, 500); \t// 500 ms ensures that we account for fluctuations in \n\t\t\t\t\t// timing so we report the time accurate to the second\n\t\t}\n\t};\n\n\tapi.remove = function(element){\n\t\tvar index = ACTIVE_ELEMENTS.indexOf(element);\n\t\tif(~index){\n\t\t\tACTIVE_ELEMENTS.splice(index, 1);\n\t\t\tif(ACTIVE_ELEMENTS.length === 0){\n\t\t\t\tclearInterval(PERIODIC_LISTENER);  \n\t\t\t}\t\n\t\t}\n\t};\n\n\treturn api;\n}());\n\nfunction VideoElement (element, player){\n\tBaseElement.call(this, element);\n\tthis.player = player;\n\tthis.emitter = new EventEmitter();\n\tthis.lastReportedTime = 0;\n\tplayer.addEventListener('onStateChange', this.statusChangeHandler.bind(this));\n\tplayer.addEventListener('onError', this.errorHandler.bind(this));\n\tthis.hide();\n}\nVideoElement.prototype = Object.create(BaseElement.prototype);\n\nVideoElement.create = function(element, player, options){\n\tvar videoElement = new VideoElement(element, player);\n\n\tif(options.continuousPlay) videoElement.continuousPlay = true;\n\tif(options.autoplay) videoElement.autoplay = true;\n\tif(options.loop) videoElement.loop = true;\n\t\n\treturn VideoElement.getApi(videoElement);\n};\n\nVideoElement.getApi = function(element){\n\tvar api = BaseElement.getApi(element);\n\tapi.player = element.player;\n\tapi.element = element.element;\n\tapi.on = element.emitter.on.bind(element.emitter);\n\tapi.removeListener = element.emitter.removeListener.bind(element.emitter);\n\tapi.destroy = element.destroy.bind(element);\n\treturn api;\n};\n\nVideoElement.prototype.continuousPlay = false;\nVideoElement.prototype.autoplay = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? false : true );\nVideoElement.prototype.loop = false;\nVideoElement.prototype.playing = false;\n\nVideoElement.prototype.errorHandler = function(e){\n\tif(e.data === 150){\n\t\tconsole.log(this);\n\t\tthis.destroy();\n\t}\n};\n\nVideoElement.prototype.destroy = function(){\n\tthis.height = 0;\n\tthis.width = 0;\n\tthis.bottom = this.top;\n\tthis.left = this.right;\n\tthis.element.parentNode.removeChild(this.element);\n};\n\nVideoElement.prototype.hide = function(){\n\tBaseElement.prototype.hide.call(this);\n\tthis.element.style.opacity = 0;\n\t\n\tif(!this.continuousPlay){\n\t\tthis.player.pauseVideo();\n\t}\n};\n\nVideoElement.prototype.show = function(left, top){\n\tthis.element.style.opacity = 1;\n\tBaseElement.prototype.show.call(this, left, top);\n\t\n\tif(this.playing && !this.continuousPlay){\n\t\tthis.player.playVideo();\n\t} else if(!this.playing && this.autoplay) {\n\t\tthis.playing = true;\n\t\tthis.player.playVideo();\n\t}\n};\n\nVideoElement.prototype.statusChangeHandler = function(status){\n\tswitch(status.data){\n\t\tcase -1:\n\t\t\tthis.emitter.emit('unstarted');\n\t\tbreak;\n\t\tcase 0:\n\t\t\tthis.emitter.emit('ended');\n\t\t\ttimeManager.remove(this);\n\t\t\tif(this.loop){\n\t\t\t\tthis.player.seekTo(0);\n\t\t\t\tthis.player.playVideo();\n\t\t\t}\n\t\tbreak;\n\t\tcase 1:\n\t\t\tthis.emitter.emit('playing');\n\t\t\ttimeManager.add(this);\n\t\tbreak;\n\t\tcase 2:\n\t\t\tthis.emitter.emit('paused');\n\t\t\ttimeManager.remove(this);\n\t\tbreak;\n\t\tcase 3:\n\t\t\tthis.emitter.emit('buffering');\n\t\tbreak;\n\t\tcase 5:\n\t\t\tthis.emitter.emit('video cued');\n\t\tbreak;\n\t}\n};","'use strict';\n\nexports.Iframe = require('./Iframe.js');\nexports.Simple = require('./Simple.js');\nexports.Video = require('./Video.js');","'use strict';\n/* globals FB */\n\nvar Q = require('../../bower_components/q/q.js'),\n\tgetFromApi = require('./getFromCommonApi.js'),\n\tIframeElement = require('../element/Iframe.js'),\n\tutils = require('../utils.js');\n\nvar endpoint = 'https://graph.facebook.com/search';\n//var endpoint = '/search';\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.facebook = {};\n\nmodule.exports = function(collage, options){\n\tif(!options.type) options.type = 'pages';\n\t\n\tswitch(options.type){\n\t\tcase 'pages':\n\t\t\treturn createPages(collage, options);\n\t}\n};\n/*\nvar ACTIVITY_BOX_TEMPLATE = '<div class=\"fb-activity\" data-site=\"www.hrc.org\" ' + \n\t'data-width=\"{{width}}\" data-height=\"{{height}}\" data-header=\"false\" ' + \n\t'data-recommendations=\"false\"></div>';\nvar LIKE_BOX_TEMPLATE = '<div class=\"fb-like-box\" ' + \n\t'data-href=\"http://www.facebook.com/{{id}}\" data-width=\"{{width}}\" ' + \n\t'data-height=\"{{height}}\" data-show-faces=\"true\" data-stream=\"false\" ' + \n\t'data-header=\"false\"></div>';\n*/\nvar defaults = {\n\tlimit: 3,\n\twidth: 400,\n\theight: 600,\n\tminLikes: 0,\n\tshowFaces: true,\n\tshowStream: true,\n\tshowHeader: false,\n\tids: []\n};\n\nfunction createPages(collage, options){\n\tutils.extend(options, defaults);\n\tvar ids = options.ids;\n\t\n\tif(options.query){\n\t\treturn getFromApi(endpoint, [\n\t\t\t'type=page',\n\t\t\t'fields=name,link,likes,category',\n\t\t\t'limit=' + options.limit,\n\t\t\t'q=' + encodeURIComponent(options.query)\n\t\t]).then(function(response){\n\t\t\tresponse.data.forEach(function(item){\n\t\t\t\tif(item.likes < options.minLikes) return;\n\t\t\t\n\t\t\t\tcredits[item.name] = item.link;\n\t\t\t\tids.push(item.id);\n\t\t\t});\n\n\t\t\treturn loadLikeBoxes(collage, ids, options);\n\t\t});\n\t} else {\n\t\treturn Q.when(loadLikeBoxes(collage, ids, options));\n\t}\n}\n\nfunction loadLikeBoxes(collage, ids, options){\n\tvar elements = [];\n\n\tids.forEach(function(id){\n\t\tvar element = document.createElement('div');\n\t\telement.className='fb-like-box';\n\t\telement.setAttribute('data-href', 'http://www.facebook.com/' + id);\n\t\telement.setAttribute('data-width', options.width);\n\t\telement.setAttribute('data-height', options.height);\n\t\telement.setAttribute('data-show-faces', options.showFaces);\n\t\telement.setAttribute('data-stream', options.showStream);\n\t\telement.setAttribute('data-header', options.showHeader);\n\n\t\tvar iframeElement = utils.attachIframeToCollage(collage, element, options.width, options.height);\n\t\t\n\t\tFB.XFBML.parse(iframeElement);\n\n\t\telements.push(new IframeElement(iframeElement));\n\t});\n\t\n\treturn elements;\n}\n","'use strict';\n/* jslint camelcase:false */\nvar Q = require('../../bower_components/q/q.js'),\n\tSimpleElement = require('../element/Simple.js'),\n\tutils = require('../utils.js'),\n\tgetFromApi = require('./getFromCommonApi.js');\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.flickr = {};\n\nvar endpoint = 'https://api.flickr.com/services/rest/';\n//var endpoint = '/services/rest/';\n\nmodule.exports = getPhotos;\n\nvar defaults = {\n\tsort: 'relevance',\n\tcount: '20',\n\tlicense: '1,2,3,4,5,6,7,8', // http://www.flickr.com/services/api/flickr.photos.licenses.getInfo.html\n\tapiKey: '06960d3c3c8affd01e65ec032513557b',\n\tmedia: 'photos',\n\ttagMode: 'all',\n\tisCommons: false,\n\tcontentType: '1' // Photos only (not screenshots or drawings)\n};\n\nfunction getPhotos(collage, options){\n\tvar deferred = Q.defer(),\n\t\tparams;\n\t\n\tif(typeof options === 'string') options = {tags: options};\n\tutils.extend(options, defaults);\n\n\tparams = [\n\t\t'format=json',\n\t\t'method=flickr.photos.search',\n\t\t'extras=url_z,url_m,path_alias',\n\t\t'api_key=' + options.apiKey,\n\t\t'license=' + options.license, \n\t\t'sort=' + options.sort,\n\t\t'tag_mode=' + options.tagMode,\n\t\t'per_page=' + options.count,\n\t\t'content_type=' + options.contentType,\n\t\t'media=' + options.media,\n\t\t'tags=' + options.tags,\n\t\t'api_key=' + '50af342c4178f4a984377a4b4b55998b'\n\t];\n\n\tif(options.isCommons){\n\t\tparams.push('is_commons=' + options.isCommons);\n\t}\n\n\tgetFromApi(endpoint, 'jsoncallback', params).then(function(response){\n\t\tvar elements = [],\n\t\t\tphotos = response.photos && response.photos.photo || [],\n\t\t\twaiting = photos.length;\n\n\t\tphotos.forEach(function(item){\n\t\t\tvar url = item.url_z || item.url_m;\n\n\t\t\tif(!url){\n\t\t\t\twaiting--;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tloadImage(item.url_z || item.url_m).then(function(element){\n\t\t\t\tvar anchor = document.createElement('a');\n\t\t\t\tanchor.href = 'http://www.flickr.com/photos/' + item.pathalias + '/' + item.id + '/';\n\t\t\t\tanchor.width = element.width;\n\t\t\t\tanchor.height = element.height;\n\t\t\t\tanchor.target = '_blank';\n\t\t\t\tanchor.style.display = 'block';\n\t\t\t\tanchor.appendChild(element);\n\t\t\t\t\n\t\t\t\tcredits[item.pathalias] = anchor.href;\n\t\t\t\t\n\t\t\t\telements.push(SimpleElement.create(anchor));\n\t\t\t\tif(--waiting === 0) deferred.resolve(elements);\n\t\t\t}, function(){\n\t\t\t\tif(--waiting === 0) deferred.resolve(elements);\n\t\t\t});\n\t\t});\n\t});\n\n\treturn deferred.promise;\n}\n\nvar documentFragment = document.createDocumentFragment();\nfunction loadImage(src){\n\tvar\tdeferred = Q.defer(),\n\t\timg = new Image();\n\t\n\timg.src = src;\n\n\timg.onload = function(){\n\t\t// This forces FF to set the width/height\n\t\tdocumentFragment.appendChild(img);\n\t\tdeferred.resolve(img);\n\t};\n\n\timg.onerror = deferred.reject.bind(deferred);\n\n\treturn deferred.promise;\n}","'use strict';\n\nvar Q = require('../../bower_components/q/q.js');\n\nwindow.API_CALLBACKS = {};\n\nmodule.exports = (function(){\n\tvar callbackCounter = 0,\n\t\tcallbacks = window.API_CALLBACKS,\n\t\tdefaultTimeout = 10 * 1000;\n\n\treturn function(endpoint, callbackParam, params, timeout){\n\t\tvar callbackId = 'c' + callbackCounter++,\n\t\t\tdeferred = Q.defer(),\n\t\t\tscript = document.createElement('script'),\n\t\t\ttimeoutId;\n\t\t\n\t\tif(typeof callbackParam !== 'string'){\n\t\t\ttimeout = params;\n\t\t\tparams = callbackParam;\n\t\t\tcallbackParam = 'callback';\n\t\t}\n\n\t\ttimeout = timeout || defaultTimeout;\n\t\tparams = params || [];\n\t\tparams.push(callbackParam + '=API_CALLBACKS.' + callbackId);\n\n\t\ttimeoutId = setTimeout(function(){\n\t\t\tdeferred.reject('timeout');\n\t\t}, timeout);\n\t\t\n\t\tcallbacks[callbackId] = function(response){\n\t\t\tclearTimeout(timeoutId);\n\t\t\tdelete callbacks[callbackId];\n\t\t\tdeferred.resolve(response);\n\t\t};\n\n\t\tscript.async = true;\n\t\tscript.src = endpoint + '?' + params.join('&'); \n\t\tdocument.body.appendChild(script);\n\n\t\treturn deferred.promise;\n\t};\n}());","'use strict';\n\n// This one is a bit questionable since it's deprecated, and the TOS for use in\n// collages is unclear.\n\nvar mustache = require('../../bower_components/mustache/mustache.js');\nvar getFromApi = require('./getFromCommonApi.js');\nvar SimpleElement = require('../element/Simple.js');\n\t\nwindow.credits = window.credits || {};\nvar credits = window.credits.googleNews = {};\n\nmodule.exports = function(collage, query){\n\treturn search(query);\n};\n\nvar ARTICLE_TEMPLATE = '' +\n'<div class=\"article-wrapper\">' +\n\t'{{#image}}' +\n\t\t'<a href=\"{{image.contextUrl}}\">' +\n\t\t\t'<img title=\"Image by {{image.publisher}}\" class=\"article-image\" ' + \n\t\t\t'src=\"{{image.src}}\" width=\"{{image.width}}\" height=\"{{image.height}}\"/>' + \n\t\t'</a>' +\n\t'{{/image}}' +\n\t'<a class=\"article-title\" href=\"{{sourceUrl}}\">{{{title}}}</a>' + \n\t'<p class=\"article-attribution\">' +\n\t\t'<span class=\"article-publisher\">{{{publisher}}}</span>' +\n\t\t' &ndash; <span class=\"article-date\">{{date}}</span>' +\n\t\t' via {{#gnewsUrl}}<a class=\"article-via\" href=\"{{gnewsUrl}}\">{{/gnewsUrl}}' + \n\t\t'Google News{{#gnewsUrl}}</a>{{/gnewsUrl}}' +\n\t'</p>' +\n\t'<p class=\"article-body\">{{{body}}}</p>' +\n'</div>';\n\nvar documentFragment = document.createDocumentFragment();\n\nvar search = (function(){\n\tvar endpoint = 'https://ajax.googleapis.com/ajax/services/search/news';\n\t//var endpoint = '/ajax/services/search/news';\n\n\treturn function(query){\n\t\tvar params = [\n\t\t\t\t'v=1.0',\n\t\t\t\t'rsz=8',\n\t\t\t\t'q=' + encodeURIComponent(query)\n\t\t\t];\n\t\t\n\t\treturn getFromApi(endpoint, params).then(function(response){\n\t\t\tvar elements = [];\n\t\t\tresponse.responseData.results.forEach(function(item){\n\t\t\t\tcredits[item.publisher] = item.unescapedUrl;\n\n\t\t\t\tvar templateParams = {\n\t\t\t\t\ttitle: item.titleNoFormatting,\n\t\t\t\t\tsourceUrl: item.unescapedUrl,\n\t\t\t\t\tpublisher: item.publisher,\n\t\t\t\t\tdate: (new Date(item.publishedDate)).toLocaleDateString(),\n\t\t\t\t\tgnewsUrl: item.clusterUrl,\n\t\t\t\t\tbody: item.content\n\t\t\t\t};\n\t\t\t\t\t\t\t\t\n\t\t\t\tif(item.image){\n\t\t\t\t\ttemplateParams.image = {\n\t\t\t\t\t\tsrc: item.image.tbUrl,\n\t\t\t\t\t\twidth: item.image.tbWidth,\n\t\t\t\t\t\theight: item.image.tbHeight,\n\t\t\t\t\t\tpublisher: item.image.publisher,\n\t\t\t\t\t\tcontextUrl: item.image.originalContextUrl\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tvar element = document.createElement('div');\n\t\t\t\telement.className = 'gnews-article';\n\t\t\t\telement.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateParams);\n\t\t\t\tdocument.body.appendChild(element);\n\t\t\t\t\n\t\t\t\telement.width = element.clientWidth;\n\t\t\t\telement.height = element.clientHeight;\n\n\t\t\t\telements.push(new SimpleElement(element));\n\t\t\t\tdocumentFragment.appendChild(element);\n\t\t\t});\n\n\t\t\treturn elements;\n\t\t});\n\t};\n}());\n\n","'use strict';\n\nvar mustache = require('../../bower_components/mustache/mustache.js');\nvar getFromApi = require('./getFromCommonApi.js');\nvar SimpleElement = require('../element/Simple.js');\n\t\nmodule.exports = function(collage, query){\n\treturn queryActivities(query);\n};\n\nvar ARTICLE_TEMPLATE = '' +\n'<div class=\"article-wrapper\">' +\n\t'<div class=\"post-attribution\">' +\n\t\t'<a href=\"{{authorUrl}}\">' +\n\t\t\t'{{#authorImage}}<img class=\"author-image\" src=\"{{authorImage.src}}\" ' + \n\t\t\t\t'width=\"{{authorImage.width}}\" height=\"{{authorImage.height}}\"/>{{/authorImage}}' +\n\t\t\t'<span class=\"author-name\">{{authorName}}</span>' +\n\t\t'</a>' + \n\t\t'<span class=\"post-date\">on Google Plus &ndash; {{date}}</span>' +\n\t'</div>' +\n\t'<p class=\"author-comments\">{{{authorComments}}}</p>' + \n\t'<div class=\"article\">' + \n\t\t'<a href=\"{{articleUrl}}\">' +\n\t\t\t'{{#image}}<img class=\"article-image\" src=\"{{image.src}}\" width=\"{{image.width}}\" ' + \n\t\t\t\t'height=\"{{image.height}}\"/>{{/image}}' + \n\t\t\t'<div class=\"article-attribution\">' +\n\t\t\t\t'<span>{{title}}</span>' + \n\t\t\t'</div>' + \n\t\t'</a>' +\n\t\t'<p class=\"article-body\">{{body}}</p>' +\n\t'</div>' +\n'</div>';\n\nvar documentFragment = document.createDocumentFragment();\n\nvar queryActivities = (function(){\n\tvar endpoint = 'https://www.googleapis.com/plus/v1/activities';\n\n\treturn function(query){\n\t\tvar params = [\n\t\t\t\t'key=AIzaSyAZw0kviWeCOidthcZAYs5oCZ0k8DsOuUk',\n\t\t\t\t'query=' + encodeURIComponent(query)\n\t\t\t];\n\t\t\n\t\treturn getFromApi(endpoint, params).then(function(response){\n\t\t\tvar elements = [];\n\n\t\t\tresponse.items.forEach(function(item){\n\t\t\t\tif(!(item && item.object && item.object.attachments && item.object.attachments.length > 0)) return;\n\t\t\t\tvar article = item.object.attachments[0];\n\t\t\t\tif(article.objectType !== 'article') return;\n\n\t\t\t\tvar actor = item.object.actor || item.actor,\n\t\t\t\t\tauthorComments = item.object.content;\n\t\t\t\tif(authorComments && authorComments.length > 150){\n\t\t\t\t\tauthorComments = authorComments.substr(0, 150) + '&hellip;';\n\t\t\t\t}\n\n\t\t\t\tvar templateParams = {\n\t\t\t\t\tauthorName: actor.displayName,\n\t\t\t\t\tauthorUrl: actor.url,\n\t\t\t\t\tauthorId: actor.id,\n\t\t\t\t\tdate: new Date(item.published).toLocaleDateString(),\n\t\t\t\t\tauthorComments: authorComments,\n\t\t\t\t\tarticleUrl: article.url,\n\t\t\t\t\ttitle: article.displayName,\n\t\t\t\t\tbody: article.content\n\t\t\t\t};\n\t\t\t\t\t\t\t\t\n\t\t\t\tif(actor.image){\n\t\t\t\t\ttemplateParams.authorImage = {\n\t\t\t\t\t\tsrc: actor.image.url,\n\t\t\t\t\t\twidth: 50,\n\t\t\t\t\t\theight: 50\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\tif(article.image){\n\t\t\t\t\ttemplateParams.image = {\n\t\t\t\t\t\tsrc: article.image.url,\n\t\t\t\t\t\twidth: article.image.width,\n\t\t\t\t\t\theight: article.image.height\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvar element = document.createElement('div');\n\t\t\t\telement.className = 'gplus-article';\n\t\t\t\telement.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateParams);\n\t\t\t\tdocument.body.appendChild(element);\n\t\t\t\t\n\t\t\t\telement.width = element.clientWidth;\n\t\t\t\telement.height = element.clientHeight;\n\n\t\t\t\telements.push(new SimpleElement(element));\n\t\t\t\tdocumentFragment.appendChild(element);\n\n\t\t\t});\n\n\t\t\treturn elements;\n\t\t});\n\t};\n}());\n","'use strict';\n\nvar Q = require('../../bower_components/q/q.js'),\n\tIframeElement = require('../element/Iframe.js'),\n\tutils = require('../utils.js');\n\nmodule.exports = function(collage, options){\n\tvar width = options.width || 500,\n\t\theight = options.height || 500;\n\n\tvar iframe = document.createElement('iframe');\n\tiframe.src = options.url;\n\n\tvar element = utils.attachIframeToCollage(collage, iframe, width, height);\n\n\treturn Q.when(new IframeElement(element));\n};\n","'use strict';\n\nvar Q = require('../../bower_components/q/q.js');\nvar SimpleElement = require('../element/Simple.js');\n\nvar documentFragment = document.createDocumentFragment();\n\nmodule.exports = function(collage, src){\n\tvar\tdeferred = Q.defer(),\n\t\timg = new Image();\n\t\n\timg.src = src;\n\n\timg.onload = function(){\n\t\t// This forces FF to set the width/height\n\t\tdocumentFragment.appendChild(img);\n\t\tdeferred.resolve(new SimpleElement(img));\n\t};\n\n\timg.onerror = deferred.reject.bind(deferred);\n\n\treturn deferred.promise;\n};","'use strict';\n\nexports.flickr = require('./flickr.js');\nexports.image = require('./image.js');\nexports.youtube = require('./youtube.js');\nexports.googlePlus = require('./googlePlus.js');\nexports.googleNews = require('./googleNews.js');\nexports.nyTimes = require('./nyTimes.js');\nexports.twitter = require('./twitter.js');\nexports.facebook = require('./facebook.js');\nexports.iframe = require('./iframe.js');\nexports.reddit = require('./reddit.js');","'use strict';\n\n/* jshint camelcase:false */\n\nvar Q = require('../../bower_components/q/q.js'),\n\tSimpleElement = require('../element/Simple.js'),\n\tmustache = require('../../bower_components/mustache/mustache.js');\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.nyTimes = {};\n\nvar ARTICLE_TEMPLATE = '' +\n\t\t'<h2><a href=\"{{url}}\">{{{title}}}</a></h2>' +\n\t\t'{{#image}}<img class=\"article-image\" src=\"{{image.src}}\" ' + \n\t\t\t'width=\"{{image.width}}\" height=\"{{image.height}}\"/>{{/image}}' + \n\t\t'<div class=\"article-attribution\">' +\n\t\t\t'<img class=\"nyt-brand\" ' + \n\t\t\t\t'src=\"http://graphics8.nytimes.com/packages/images/developer/' + \n\t\t\t\t'logos/poweredby_nytimes_30a.png\"/>' +\n\t\t\t'<span class=\"byline\">{{{byline}}}</span>' + \n\t\t\t'<span class=\"date\">{{date}}</span>' + \n\t\t'</div>' +\n\t\t'<p>{{{body}}}</p>';\n\nvar documentFragment = document.createDocumentFragment();\n\nvar endpoint = '/svc/search/v1/article';\n//var endpoint = \"http://api.nytimes.com/svc/search/v1/article\";\n\nmodule.exports = function(collage, options){\n\treturn query(options);\n};\n\nfunction query(options){\n\tfunction parseResponse(data){\n\t\treturn data.results.map(function(data){\n\t\t\tvar element = document.createElement('div');\n\t\t\telement.className = 'nytimes-article';\n\n\t\t\tif(data.byline){\n\t\t\t\tcredits[data.byline.replace('By ', '')] = data.url;\n\t\t\t}\n\t\t\t\n\t\t\tvar templateData = {\n\t\t\t\ttitle: data.title,\n\t\t\t\tbyline: data.byline,\n\t\t\t\tdate: (new Date(data.publication_year, data.publication_month, data.publication_day)).toLocaleDateString(),\n\t\t\t\tbody: data.body,\n\t\t\t\turl: data.url\n\t\t\t};\n\n\t\t\tif(data.small_image_url){\n\t\t\t\ttemplateData.image = {\n\t\t\t\t\tsrc: data.small_image_url.replace(/thumbStandard.*\\./, 'hpMedium.'),\n\t\t\t\t\theight: 253,\n\t\t\t\t\twidth: 337\n\t\t\t\t};\n\t\t\t}\n\n\t\t\telement.innerHTML = mustache.render(ARTICLE_TEMPLATE, templateData);\n\t\t\tdocument.body.appendChild(element);\n\n\t\t\telement.width = element.clientWidth;\n\t\t\telement.height = element.clientHeight;\n\n\t\t\tdocumentFragment.appendChild(element);\n\t\t\treturn new SimpleElement(element);\n\t\t});\n\t}\n\n\tif(options.data){\n\t\treturn Q.when(parseResponse(options.data));\n\t} else {\n\n\t}\n\treturn load(options).then(function(response){\n\t\treturn parseResponse(response);\n\t});\n}\n\nfunction load(options){\n\tvar deferred = Q.defer();\n\n\tvar params = [\n\t\t'format=json',\n\t\t'fields=publication_year,publication_month,publication_day,body,date,' + \n\t\t\t'title,url,byline,small_image_url,small_image_height,small_image_width',\n\t\t'api-key=af04c123c8988a12245668f5b5fa4f4c:8:67325739',\n\t\t'query=' + options.query\n\t];\n\t\n\tvar request = new XMLHttpRequest();\n\n\trequest.onload = function(){\n\t\tdeferred.resolve(JSON.parse(this.responseText));\n\t};\n\n\trequest.onerror = function(){\n\t\tdeferred.reject();\n\t};\n\n\trequest.open('get', endpoint + '?' + params.join('&'), true);\n\trequest.send();\n\n\treturn deferred.promise;\n}\n","'use strict';\n\n/* jshint camelcase:false */\n\nvar Q = require('../../bower_components/q/q.js'),\n\tSimpleElement = require('../element/Simple.js'),\n\tIframeElement = require('../element/Iframe.js'),\n\tutils = require('../utils.js'),\n\tgetFromApi = require('./getFromCommonApi.js');\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.reddit = {};\n\nvar endpoint = 'http://www.reddit.com/r/all/search.json';\n//var endpoint = '/r/all/search.json';\n\nmodule.exports = function(collage, options){\n\tif(options.type === 'embed'){\n\t\treturn getEmbed(collage, options);\n\t} else {\n\t\treturn getPhotos(collage, options);\n\t}\n};\n\nfunction getEmbed(collage, options){\n\tutils.extend(options, defaults);\n\tvar params = [\n\t\t'limit=' + options.limit,\n\t\t'restrict_sr=' + options.restrict_sr, \n\t\t'sort=' + options.sort,\n\t\t't=' + options.time,\n\t\t'q=' + options.query\n\t];\n\n\tvar iframe = document.createElement('IFRAME'),\n\t\tiframeDoc,\n\t\tiframeContent;\n\n\tvar element = utils.attachIframeToCollage(collage, iframe, options.width, options.height);\n\n\tiframeDoc = (iframe.contentDocument) ? iframe.contentDocument : iframe.contentWindow.document;\n\tiframeContent = '<html><head><title></title></head><body>';\n\tiframeContent += '<script type=\"text/javascript\" src=\"http://www.reddit.com/r/' + \n\t\toptions.subreddit + '/search.embed?' + params.join('&').replace(' ', '%20') + '\"></script>';\n\tiframeContent += '</body></html>';\n\t\n\tiframeDoc.open();\n\tiframeDoc.write(iframeContent);\n\tiframeDoc.close();\n\t\n\treturn Q.when(new IframeElement(element));\n}\n\nvar defaults = {\n\tlimit: '20',\n\tsubreddit: 'all',\n\trestrict_sr: 'false',\n\tsort: 'top',\n\ttime: 'all',\n\tnsfw: 'false',\n\tminComments: 0,\n\twidth: 500,\n\theight:600,\n\tminScore: 0\n};\n\nfunction getPhotos(collage, options){\n\tvar deferred = Q.defer(),\n\t\tparams;\n\t\n\tif(typeof options === 'string') options = {tags: options};\n\tutils.extend(options, defaults);\n\n\tparams = [\n\t\t'limit=' + options.limit,\n\t\t'restrict_sr=' + options.restrict_sr, \n\t\t'sort=' + options.sort,\n\t\t't=' + options.time,\n\t\t'q=' + options.query\n\t];\n\t\n\tgetFromApi(endpoint, 'jsonp', params).then(function(response){\n\t\tvar elements = [],\n\t\t\tphotos = response.data && response.data.children || [],\n\t\t\twaiting;\n\n\t\tphotos = photos.filter(function(item){\n\t\t\titem = item.data;\n\n\t\t\tif(\titem.score < options.minScore || \n\t\t\t\titem.num_comments < options.minComments ||\n\t\t\t\t(!~item.url.indexOf('.jpg'))){\n\t\t\t\treturn false;\t\n\t\t\t}\n\n\t\t\treturn true;\n\t\t});\n\n\t\twaiting = photos.length;\n\t\tphotos.forEach(function(item){\n\t\t\titem = item.data;\n\t\t\t\n\t\t\tcredits[item.author] = 'http://www.reddit.com' + item.permalink;\n\t\t\t\n\t\t\tloadImage(item.url).then(function(element){\n\t\t\t\tvar anchor = document.createElement('a');\n\t\t\t\tanchor.href = 'http://www.reddit.com' + item.permalink;\n\t\t\t\tanchor.width = element.width;\n\t\t\t\tanchor.height = element.height;\n\t\t\t\tanchor.target = '_blank';\n\t\t\t\tanchor.style.display = 'block';\n\t\t\t\tanchor.appendChild(element);\n\t\t\t\t\n\t\t\t\telements.push(SimpleElement.create(anchor));\n\n\t\t\t\tif(--waiting === 0) deferred.resolve(elements);\n\t\t\t}, function(){\n\t\t\t\tif(--waiting === 0) deferred.resolve(elements);\n\t\t\t});\n\t\t});\n\t});\n\n\treturn deferred.promise;\n}\n\nvar documentFragment = document.createDocumentFragment();\nfunction loadImage(src){\n\tvar\tdeferred = Q.defer(),\n\t\timg = new Image();\n\t\n\timg.src = src;\n\n\timg.onload = function(){\n\t\t// This forces FF to set the width/height\n\t\tdocumentFragment.appendChild(img);\n\t\tdeferred.resolve(img);\n\t};\n\n\timg.onerror = deferred.reject.bind(deferred);\n\n\treturn deferred.promise;\n}","'use strict';\n/* globals twttr */\n/* jshint camelcase:false */\n\n// This uses an undocumented twitter api (twttr.widget.createTweet) so it might break\n\nvar Q = require('../../bower_components/q/q.js'),\n\tgetFromApi = require('./getFromCommonApi.js'),\t\n\tIframeElement = require('../element/Iframe.js');\n\nvar TIMEOUT = 1000 * 10;\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.twitter = {};\n\n// options should have container and query\nmodule.exports = function(collage, options){\n\tvar container = collage.element;\n\n\tif(options.query){\n\t\treturn queryTweets(options.query).then(function(tweetIds){\n\t\t\treturn loadTweets(tweetIds, container, collage);\n\t\t});\t\n\t} else if(options.ids) {\n\t\treturn loadTweets(options.ids, container, collage);\n\t} else if(options.id){\n\t\treturn loadTweets([options.id], container, collage).then(function(elements){\n\t\t\tif(elements && elements.length) return elements[0];\n\t\t});\n\t}\n};\n\nvar loadTweets = (function(){\n\treturn function(ids, container){\n\t\tif(!Array.isArray(ids) || !container) return;\n\n\t\tvar index = ids.length,\n\t\t\tdeferred = Q.defer(),\n\t\t\telements = [],\n\t\t\ttimedOut = false,\n\t\t\twaitingForResize = [],\n\t\t\ttimeout = setTimeout(function(){\n\t\t\t\ttimedOut = true;\n\t\t\t\tclearInterval(heightChecker);\n\t\t\t\tdeferred.resolve(elements);\n\t\t\t}, TIMEOUT);\n\n\t\tfunction heightCheck(){\n\t\t\tvar index = waitingForResize.length,\n\t\t\t\telement;\n\n\t\t\twhile(index--){\n\t\t\t\telement = waitingForResize[index];\n\t\t\t\tif(element.height !== '0'  && element.width !== '0'){\n\t\t\t\t\telements.push(IframeElement.create(element));\n\n\t\t\t\t\tif(elements.length === ids.length){\n\t\t\t\t\t\tclearTimeout(timeout);\n\t\t\t\t\t\tclearInterval(heightChecker);\n\t\t\t\t\t\tdeferred.resolve(elements);\n\t\t\t\t\t}\n\n\t\t\t\t\twaitingForResize.splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tvar heightChecker = setInterval(heightCheck, 250);\n\n\t\tfunction handleElement(element){\n\t\t\tif(timedOut) return;\n\n\t\t\tvar iframeWindow =  'contentWindow' in element? element.contentWindow : element.contentDocument.defaultView;\n\t\t\t\n\t\t\tvar onMouseMoveCallback = iframeWindow.onmousemove;\n\t\t\t\n\t\t\t// Iframes capture all events, this allows us to bubble the event\n\t\t\t// up to this window's scope\n\t\t\tiframeWindow.onmousemove = function(e){\n\t\t\t\tif(onMouseMoveCallback) onMouseMoveCallback(e);\n\t\t\t\tvar evt = document.createEvent('MouseEvents'),\n\t\t\t\t\tboundingClientRect = element.getBoundingClientRect();\n\n\t\t\t\tevt.initMouseEvent(\t'mousemove', \n\t\t\t\t\t\t\t\t\ttrue, \n\t\t\t\t\t\t\t\t\tfalse, \n\t\t\t\t\t\t\t\t\twindow,\n\t\t\t\t\t\t\t\t\te.detail,\n\t\t\t\t\t\t\t\t\te.screenX,\n\t\t\t\t\t\t\t\t\te.screenY, \n\t\t\t\t\t\t\t\t\te.clientX + boundingClientRect.left, \n\t\t\t\t\t\t\t\t\te.clientY + boundingClientRect.top, \n\t\t\t\t\t\t\t\t\te.ctrlKey, \n\t\t\t\t\t\t\t\t\te.altKey,\n\t\t\t\t\t\t\t\t\te.shiftKey, \n\t\t\t\t\t\t\t\t\te.metaKey,\n\t\t\t\t\t\t\t\t\te.button, \n\t\t\t\t\t\t\t\t\tnull);\n\t\t\t\t\n\t\t\t\telement.dispatchEvent(evt);\n\t\t\t};\n\n\t\t\twaitingForResize.push(element);\n\t\t\telement.style.opacity = 0;\n\t\t}\n\n\t\twhile(index--){\n\t\t\ttwttr.widgets.createTweet(ids[index], container, handleElement);\n\t\t}\n\n\t\treturn deferred.promise;\n\t};\n}());\n\nvar queryTweets = (function(){\n\tvar endpoint = 'http://search.twitter.com/search.json';\n\t//var endpoint = '/search.json';\n\n\treturn function(query){\n\t\treturn getFromApi(endpoint, [\n\t\t\t'format=json',\n\t\t\t'q=' + encodeURIComponent(query)\n\t\t]).then(function(response){\n\t\t\tvar tweetIds = [],\n\t\t\t\tdupeCheck = [];\n\n\t\t\tresponse.results.forEach(function(item){\n\t\t\t\t// Skip retweets\n\t\t\t\tif(~dupeCheck.indexOf(item.text)){\n\t\t\t\t\treturn;\n\t\t\t\t} else {\n\t\t\t\t\tdupeCheck.push(item.text);\n\t\t\t\t}\n\n\t\t\t\t// Skip matches on username\n\t\t\t\tif(~item.from_user.toLowerCase().indexOf(query.toLowerCase())){\n\t\t\t\t\treturn;\t\n\t\t\t\t}\n\n\t\t\t\tcredits[item.from_user] = 'http://twitter.com/' + item.from_user;\n\n\t\t\t\ttweetIds.push(item.id_str);\n\t\t\t});\n\n\t\t\treturn tweetIds;\n\t\t});\n\t};\n}());","'use strict';\n/* globals YT */\n\nvar Q = require('../../bower_components/q/q.js');\nvar VideoElement = require('../element/Video.js');\nvar getFromApi = require('./getFromCommonApi.js');\nvar utils = require('../utils.js');\nvar TIMEOUT = 10 * 1000;\n\nwindow.credits = window.credits || {};\nvar credits = window.credits.youtube = {};\n\nmodule.exports = function(collage, options){\n\tif(options.query){\n\t\treturn queryVideos(options).then(function(videoIds){\n\t\t\toptions.videoIds = videoIds;\n\t\t\treturn loadVideos(collage, options);\n\t\t});\n\t}\n\n\tif(options.videoId){\n\t\toptions.videoIds = [options.videoId];\n\n\t\treturn loadVideos(collage, options).then(function(elements){\n\t\t\treturn elements[0];\n\t\t});\n\t} else if(options.videoIds){\n\t\treturn loadVideos(collage, options);\t\n\t}\n};\n\nvar defaults = {\n\tduration: 'short',\n\tkey: 'AIzaSyAZw0kviWeCOidthcZAYs5oCZ0k8DsOuUk'\n};\n\nvar queryVideos = (function(){\n\tvar endpoint = 'https://www.googleapis.com/youtube/v3/search';\n\t//var endpoint = 'https://d3ggoqbhpexke2.cloudfront.net/youtube/v3/search';\n\n\treturn function(options){\n\t\tutils.extend(options, defaults);\n\n\t\tvar params = [\n\t\t\t\t'part=id,snippet',\n\t\t\t\t'videoDuration=' + options.duration,\n\t\t\t\t'type=video',\n\t\t\t\t'videoEmbeddable=true',\n\t\t\t\t'videoSyndicated=true',\n\t\t\t\t'key=' + options.key,\n\t\t\t\t'q=' + encodeURIComponent(options.query)\n\t\t\t];\n\t\t\n\t\treturn getFromApi(endpoint, params).then(function(response){\n\t\t\tvar videoIds = [];\n\n\t\t\tresponse.items.forEach(function(item){\n\t\t\t\tcredits[item.snippet.channelTitle] = 'http://youtube.com/' + item.snippet.channelTitle;\n\t\t\t\tvideoIds.push(item.id.videoId);\n\t\t\t});\n\n\t\t\treturn videoIds;\n\t\t});\n\t};\n}());\n\nvar loadVideos = (function(){\n\treturn function(collage, options){\n\t\tif(!Array.isArray(options.videoIds)) return;\n\t\t\n\t\tvar index = options.videoIds.length,\n\t\t\tdeferred = Q.defer(),\n\t\t\telements = [],\n\t\t\tvideoOptions,\n\t\t\ttimedOut = false,\n\t\t\ttimeout = setTimeout(function(){\n\t\t\t\ttimedOut = true;\n\t\t\t\tdeferred.resolve(elements);\n\t\t\t}, TIMEOUT);\n\n\t\toptions.callback = function(element){\n\t\t\tif(timedOut || !element) return;\n\t\t\telements.push(element);\n\n\t\t\tif(elements.length === options.videoIds.length){\n\t\t\t\tclearTimeout(timeout);\n\t\t\t\tdeferred.resolve(elements);\n\t\t\t}\n\t\t};\n\n\t\twhile(index--){\n\t\t\tvideoOptions = Object.create(options);\n\t\t\tvideoOptions.videoId = options.videoIds[index];\n\t\t\tloadVideo(collage, videoOptions);\n\t\t}\n\n\t\treturn deferred.promise;\n\t};\n}());\n\nvar isiOS = (navigator.userAgent.match(/(iPad|iPhone|iPod)/g) ? true : false );\n\nvar loadVideo = (function(){\n\tvar playerIdCounter = 0;\n\treturn function(collage, options){\n\t\tvar videoId = options.videoId,\n\t\t\twidth = options.width || 1060,\n\t\t\theight = options.height || 650;\n\n\t\tvar playerId = 'player' + (playerIdCounter++);\n\n\t\tvar element = document.createElement('div');\n\t\telement.width = width;\n\t\telement.height = height;\n\t\telement.className = 'youtube-video';\n\t\t\n\t\tif(isiOS) element.className += ' hide-video-mask';\n\n\t\telement.innerHTML = '<div id=\"' + playerId + '\"></div><div class=\"video-mask\"></div>';\n\t\tcollage.element.appendChild(element);\n\t\t\n\t\tvar videoElement;\n\n\t\tnew YT.Player(playerId, {\n\t\t\theight: height,\n\t\t\twidth: width,\n\t\t\tplayerVars: { \n\t\t\t\tcontrols: 0, \n\t\t\t\thtml5: 1,\n\t\t\t\tstart: (options.startTime || 0)\n\t\t\t},\n\t\t\tvideoId: videoId,\n\t\t\tevents: {\n\t\t\t\tonReady: function(e){\n\t\t\t\t\tvar playerObj = e.target;\n\t\t\t\t\tvideoElement = VideoElement.create(element, playerObj, {\n\t\t\t\t\t\tcontinuousPlay: options.continuousPlay,\n\t\t\t\t\t\tautoplay: options.autoplay,\n\t\t\t\t\t\tloop: options.loop\n\t\t\t\t\t});\n\t\t\t\t\t\n\t\t\t\t\tif(isiOS){\n\t\t\t\t\t\tvideoElement.on('playing', function(){\n\t\t\t\t\t\t\telement.className = element.className.replace(' hide-video-mask', '');\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tvideoElement.on('paused', function(){\n\t\t\t\t\t\t\telement.className += ' hide-video-mask';\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\n\t\t\t\t\tplayerObj.pauseVideo();\n\t\t\t\t\tif(options.continuousPlay){\n\t\t\t\t\t\tplayerObj.unMute();\n\t\t\t\t\t\tplayerObj.setVolume(100);\n\t\t\t\t\t}\n\n\t\t\t\t\tif(options.mute){\n\t\t\t\t\t\tplayerObj.mute();\n\t\t\t\t\t\tplayerObj.setVolume(0);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif(options.callback) options.callback(videoElement);\n\t\t\t\t},\n\t\t\t\tonError: function(){\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t};\n}());\n","'use strict';\n\nexports.extend = function(destination){\n\tvar sources = arguments.length,\n\t\tindex = 1,\n\t\tsource,\n\t\tkey;\n\n\tfor(; index < sources; index++){\n\t\tsource = arguments[index];\n\t\tfor(key in source){\n\t\t\tif(source.hasOwnProperty(key) && !(key in destination)){\n\t\t\t\tdestination[key] = source[key];\n\t\t\t}\n\t\t}\n\t}\n};\n\nexports.attachIframeToCollage = function(collage, iframe, width, height){\n\tvar container = document.createElement('div');\n\tcontainer.className='iframe-container';\n\t\n\tvar overflowWrapper = document.createElement('div');\n\toverflowWrapper.className = 'iframe-overflow-wrapper';\n\toverflowWrapper.style.width = width + 'px';\n\toverflowWrapper.style.height = height + 'px';\n\tcontainer.appendChild(overflowWrapper);\n\n\tiframe.style.width = width + 'px';\n\tiframe.style.height = height + 'px';\n\toverflowWrapper.appendChild(iframe);\n\n\tvar mask = document.createElement('div');\n\tmask.className = 'iframe-mask';\n\tcontainer.appendChild(mask);\n\n\tvar hasFocus = false;\n\tmask.addEventListener('click', function(){\n\t\thasFocus = true;\n\t\tcontainer.className += ' in-focus';\n\t\tcollage.pause(0.4);\n\t});\n\n\tmask.addEventListener('mouseover', function(){\n\t\tif(!hasFocus) return;\n\t\thasFocus = false;\n\t\tcontainer.className = container.className.replace(' in-focus', '');\n\t\tcollage.resume(0.4);\n\t});\n\n\tcollage.element.appendChild(container);\n\t\n\treturn container;\n};\n\n\nexports.requestAnimationFrame = window.requestAnimationFrame || \n\t\t\t\t\t\t\t\twindow.mozRequestAnimationFrame ||\n                              \twindow.webkitRequestAnimationFrame || \n                              \twindow.msRequestAnimationFrame || \n                              \tfunction(cb){return setTimeout(cb, 15);};\n\nexports.cancelAnimationFrame = \twindow.cancelAnimationFrame || \n\t\t\t\t\t\t\t\twindow.mozCancelAnimationFrame ||\n                              \twindow.webkitCancelAnimationFrame || \n                              \twindow.msCancelAnimationFrame || \n                              \tfunction(timeout){return clearTimeout(timeout);};\n\nexports.requestFullscreen = document.documentElement.requestFullscreen ||\n\t\t\t\t\t\t\tdocument.documentElement.mozRequestFullScreen ||\n\t\t\t\t\t\t\tdocument.documentElement.webkitRequestFullscreen ||\n\t\t\t\t\t\t\tfunction(){};\n\nvar bodyStyle = document.body.style;\t\nexports.transitionAttribute =\t(bodyStyle.msTransition !== void 0) && 'msTransition' ||\n\t\t\t\t\t\t\t\t(bodyStyle.webkitTransition !== void 0) && 'webkitTransition' ||\n\t\t\t\t\t\t\t\t(bodyStyle.MozTransition !== void 0) && 'MozTransition' || \n\t\t\t\t\t\t\t\t(bodyStyle.transition !== void 0) && 'transition';\n"],"sourceRoot":"/source/"}