build.js

(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports = function makeCollisionCheckingFunction(level) {
	var levelHeight = level.length
	var levelWidth = level[0].length

	return function checkForCollision(row, col) {
	    // http://stackoverflow.com/questions/4228356/integer-division-in-javascript
	    row = Math.floor((row + levelHeight) % levelHeight)
	    col = Math.floor((col + levelWidth)  % levelWidth)

	    return level[row][col] == 6
	}
}

},{}],2:[function(require,module,exports){
var frameLoop = require('frame-loop')
var collisionChecker = require('./collision-checking')

var FPS_MULTIPLIER = 3 // based on 20fps
var NUM_OF_ROWS = 9
var NUM_OF_COLS = 10
var TILE_SIZE = 32
var BALL = document.getElementById("ball")
// http://stackoverflow.com/questions/5597060/detecting-arrow-key-presses-in-javascript
var LEFT_KEY = 37
var UP_KEY = 38
var RIGHT_KEY = 39
var DOWN_KEY = 40
var OFFSET_X = 14
var OFFSET_Y = 14

var BALL_SPEED_DECAY_ON = 0.99
var BALL_SPEED_DECAY_OFF = 0.9
var BALL_SPEED_THRESH = 0.1

var ballx = 0
var bally = 0
var ballsx = 0
var ballsy = 0

var REGISTER_KEYPRESSES_EVERY_MS = 50

function getTile(row, col) {
    // https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementById
    return document.getElementById(row + "_" + col)
}

function setTile(row, col, tileNum) {
    var numOfZeros = 3 - (tileNum + "").length
    var leadingZeros = ""
    for (var i = 0; i < numOfZeros; i++) {
        leadingZeros += "0"
    }
    // http://www.w3schools.com/jsref/prop_img_src.asp
    getTile(row, col).src = "tiles/tile" + leadingZeros + tileNum + ".gif"
}

function setBallPos(x, y) {
    // http://www.w3schools.com/jsref/prop_style_top.asp
    // http://stackoverflow.com/questions/2214387/setting-top-and-left-css-attributes
    BALL.style.left = ballx = x;
    BALL.style.top = bally = y;
}

function initBallPos(row, col) {
    setBallPos(col * TILE_SIZE, row * TILE_SIZE);
}

var level = [
    [6, 6, 6, 6, 6, 6, 6, 6, 6, 6],
    [6, 4, 4, 4, 4, 4, 4, 4, 4, 6],
    [6, 4, 6, 6, 6, 6, 6, 4, 6, 6],
    [6, 4, 6, 4, 4, 4, 6, 4, 7, 6],
    [6, 4, 4, 4, 6, 4, 6, 6, 4, 6],
    [6, 6, 6, 6, 6, 4, 4, 6, 4, 6],
    [6, 7, 4, 4, 6, 6, 4, 6, 4, 6],
    [6, -1, 6, 4, 4, 4, 4, 6, 5, 6],
    [6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
];

for(var i = 0; i < NUM_OF_ROWS; i++) {
    for(var j = 0; j < NUM_OF_COLS; j++) {
        if (level[i][j] == -1) {
            initBallPos(i, j)
            setTile(i, j, 4)
        } else {
            setTile(i, j, level[i][j])
        }
    }
}

/***** Movement *****/
// http://stackoverflow.com/questions/5597060/detecting-arrow-key-presses-in-javascript
// http://stackoverflow.com/questions/5203407/javascript-multiple-keys-pressed-at-once
var keysPressed = {37: 0, 38: 0, 39: 0, 40: 0}

document.onkeydown = function(e) {
    e = e || window.event
    // dirs = {38: [-1, 0], 40: [1, 0], 37: [0, -1], 39: [0, 1]}
    keysPressed[e.keyCode] = 1;
}

document.onkeyup = function(e) {
    e = e || window.event
    keysPressed[e.keyCode] = 0;
}

function getBallRow() {
    return (bally + OFFSET_Y) / TILE_SIZE
}

function getBallCol() {
    return (ballx + OFFSET_X) / TILE_SIZE
}

function getBallIX() {
    return (ballx + OFFSET_X) % TILE_SIZE * 16 / TILE_SIZE
}

function getBallIY() {
    return (bally + OFFSET_Y) % TILE_SIZE * 16 / TILE_SIZE
}

var checkForCollision = collisionChecker(level)


function updateBallPos(ballSpeedUpdatingTick) {
    if (ballSpeedUpdatingTick) {
        var extrax = -1 * keysPressed[LEFT_KEY] + keysPressed[RIGHT_KEY]
        var extray = -1 * keysPressed[UP_KEY]   + keysPressed[DOWN_KEY]
        ballsx = (ballsx + extrax) * (extrax ? BALL_SPEED_DECAY_ON : BALL_SPEED_DECAY_OFF)
        ballsy = (ballsy + extray) * (extray ? BALL_SPEED_DECAY_ON : BALL_SPEED_DECAY_OFF)
    }

    if ((ballsx > 0 && getBallIX() > 9 && checkForCollision(getBallRow(), getBallCol() + 1)) ||
        (ballsx < 0 && getBallIX() < 5 && checkForCollision(getBallRow(), getBallCol() - 1))) {
        ballsx = -ballsx
    }

    if ((ballsy > 0 && getBallIY() > 9 && checkForCollision(getBallRow() + 1, getBallCol())) ||
        (ballsy < 0 && getBallIY() < 5 && checkForCollision(getBallRow() - 1, getBallCol()))) {
        ballsy = -ballsy
    }

    // http://www.w3schools.com/jsref/jsref_abs.asp
    if (Math.abs(ballsx) < BALL_SPEED_THRESH) ballsx = 0;
    if (Math.abs(ballsy) < BALL_SPEED_THRESH) ballsy = 0;

    // console.log(ballsx, ballsy);
    setBallPos(ballx + ballsx / FPS_MULTIPLIER, bally + ballsy / FPS_MULTIPLIER)
}

/***** Main Game Loop *****/

function keypressToTickSynchronizer(registerKeypressesEveryMs) {

    var elapsedSinceLastTick = 0

    return function shouldUpdateMomentumThisTick(elapsedMs) {
        var shouldUpdateMomentum = false

        elapsedSinceLastTick += elapsedMs

        if (elapsedSinceLastTick > registerKeypressesEveryMs) {
            elapsedSinceLastTick = elapsedSinceLastTick - registerKeypressesEveryMs
            shouldUpdateMomentum = true
        }

        return shouldUpdateMomentum
    }
}

var shouldUpdateMomentumThisTick = keypressToTickSynchronizer(REGISTER_KEYPRESSES_EVERY_MS)

function main(elapsedMsSinceLastTick) {
    updateBallPos(shouldUpdateMomentumThisTick(elapsedMsSinceLastTick))
}

var engine = frameLoop({
    fps: 20 * FPS_MULTIPLIER
}, main)

engine.run()

},{"./collision-checking":1,"frame-loop":5}],3:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

function EventEmitter() {
  this._events = this._events || {};
  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
  if (!isNumber(n) || n < 0 || isNaN(n))
    throw TypeError('n must be a positive number');
  this._maxListeners = n;
  return this;
};

EventEmitter.prototype.emit = function(type) {
  var er, handler, len, args, i, listeners;

  if (!this._events)
    this._events = {};

  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events.error ||
        (isObject(this._events.error) && !this._events.error.length)) {
      er = arguments[1];
      if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      } else {
        // At least give some kind of context to the user
        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
        err.context = er;
        throw err;
      }
    }
  }

  handler = this._events[type];

  if (isUndefined(handler))
    return false;

  if (isFunction(handler)) {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
  } else if (isObject(handler)) {
    args = Array.prototype.slice.call(arguments, 1);
    listeners = handler.slice();
    len = listeners.length;
    for (i = 0; i < len; i++)
      listeners[i].apply(this, args);
  }

  return true;
};

EventEmitter.prototype.addListener = function(type, listener) {
  var m;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events)
    this._events = {};

  // To avoid recursion in the case that type === "newListener"! Before
  // adding it to the listeners, first emit "newListener".
  if (this._events.newListener)
    this.emit('newListener', type,
              isFunction(listener.listener) ?
              listener.listener : listener);

  if (!this._events[type])
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  else if (isObject(this._events[type]))
    // If we've already got an array, just append.
    this._events[type].push(listener);
  else
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];

  // Check for listener leak
  if (isObject(this._events[type]) && !this._events[type].warned) {
    if (!isUndefined(this._maxListeners)) {
      m = this._maxListeners;
    } else {
      m = EventEmitter.defaultMaxListeners;
    }

    if (m && m > 0 && this._events[type].length > m) {
      this._events[type].warned = true;
      console.error('(node) warning: possible EventEmitter memory ' +
                    'leak detected. %d listeners added. ' +
                    'Use emitter.setMaxListeners() to increase limit.',
                    this._events[type].length);
      if (typeof console.trace === 'function') {
        // not supported in IE 10
        console.trace();
      }
    }
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {
  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  var fired = false;

  function g() {
    this.removeListener(type, g);

    if (!fired) {
      fired = true;
      listener.apply(this, arguments);
    }
  }

  g.listener = listener;
  this.on(type, g);

  return this;
};

// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
  var list, position, length, i;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events || !this._events[type])
    return this;

  list = this._events[type];
  length = list.length;
  position = -1;

  if (list === listener ||
      (isFunction(list.listener) && list.listener === listener)) {
    delete this._events[type];
    if (this._events.removeListener)
      this.emit('removeListener', type, listener);

  } else if (isObject(list)) {
    for (i = length; i-- > 0;) {
      if (list[i] === listener ||
          (list[i].listener && list[i].listener === listener)) {
        position = i;
        break;
      }
    }

    if (position < 0)
      return this;

    if (list.length === 1) {
      list.length = 0;
      delete this._events[type];
    } else {
      list.splice(position, 1);
    }

    if (this._events.removeListener)
      this.emit('removeListener', type, listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
  var key, listeners;

  if (!this._events)
    return this;

  // not listening for removeListener, no need to emit
  if (!this._events.removeListener) {
    if (arguments.length === 0)
      this._events = {};
    else if (this._events[type])
      delete this._events[type];
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    for (key in this._events) {
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = {};
    return this;
  }

  listeners = this._events[type];

  if (isFunction(listeners)) {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    while (listeners.length)
      this.removeListener(type, listeners[listeners.length - 1]);
  }
  delete this._events[type];

  return this;
};

EventEmitter.prototype.listeners = function(type) {
  var ret;
  if (!this._events || !this._events[type])
    ret = [];
  else if (isFunction(this._events[type]))
    ret = [this._events[type]];
  else
    ret = this._events[type].slice();
  return ret;
};

EventEmitter.prototype.listenerCount = function(type) {
  if (this._events) {
    var evlistener = this._events[type];

    if (isFunction(evlistener))
      return 1;
    else if (evlistener)
      return evlistener.length;
  }
  return 0;
};

EventEmitter.listenerCount = function(emitter, type) {
  return emitter.listenerCount(type);
};

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

function isNumber(arg) {
  return typeof arg === 'number';
}

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
  return arg === void 0;
}

},{}],4:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

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');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],5:[function(require,module,exports){
var inherits = require('inherits');
var EventEmitter = require('events').EventEmitter;
var defined = require('defined');
var raf = require('raf');
var defaultTimer = require('./lib/now.js');

module.exports = Engine;
inherits(Engine, EventEmitter);

function Engine (opts, fn) {
    if (!(this instanceof Engine)) return new Engine(opts, fn);
    EventEmitter.call(this);
    
    if (typeof opts === 'function') {
        fn = opts;
        opts = {};
    }
    if (!opts) opts = {};
    
    this.running = false;
    this.now = opts.now || defaultTimer;
    this.last = this.now();
    this.time = 0;
    this._timers = [];
    this._timerId = 1;
    this._fpsTarget = defined(opts.fps, 60);
    this._fpsWindow = defined(opts.fpsWindow, 1000);
    this._info = null;
    this.fps = 0;
    this._requestFrame = opts.requestFrame || raf;
    this._correction = defined(opts.correction,
        typeof window !== 'undefined' ? 0 : 1
    );
    if (fn) this.on('tick', fn);
}

Engine.prototype.run = function () {
    var self = this;
    if (this.running) return;
    this.running = true;
    this.last = this.now();
    this._info = { frames: 0, start: this.last };
    
    (function tick () {
        if (!self.running) return;
        self.tick();
        var elapsed = (self.now() - self.last) / 1000;
        var delay = Math.max(0, (1 / self._fpsTarget) - elapsed);
        var dms = delay * 1000 - self._correction;
        if (dms <= 2) self._requestFrame(tick)
        else setTimeout(function () { self._requestFrame(tick) }, dms)
    })();
};

Engine.prototype.pause = function () {
    this.running = false;
};

Engine.prototype.toggle = function () {
    if (this.running) this.pause()
    else this.run()
};

Engine.prototype.tick = function () {
    if (!this.running) return;
    
    var now = this.now();
    var dt = Math.max(0, now - this.last);
    this.last = now;
    this.time += dt;
    this.emit('tick', dt);
    
    if (this._info && this._fpsWindow
    && now - this._info.start > this._fpsWindow) {
        this.fps = this._info.frames / this._fpsWindow * 1000;
        this._info = { frames: 0, start: now };
        this.emit('fps', this.fps);
    }
    if (this._info) { this._info.frames ++ }
    
    do {
        var called = false;
        for (var i = 0; i < this._timers.length; i++) {
            var t = this._timers[i];
            if (t.time <= this.time) {
                var c = this._cleared && this._cleared[t.id];
                if (!c) {
                    called = true;
                    t.fn();
                }
                this._timers.splice(i, 1);
                i --;
            }
            else break;
        }
    } while (called);
    this._cleared = null;
};

Engine.prototype.setTimeout = function (fn, ts) {
    var id = this._timerId ++;
    this._pushTimer({ fn: fn, time: this.time + ts, id: id });
    return id;
};

Engine.prototype._pushTimer = function (rec) {
    for (var i = 0; i < this._timers.length; i++) {
        var t = this._timers[i];
        if (rec.time < t.time) {
            this._timers.splice(i, 0, rec);
            return;
        }
    }
    this._timers.push(rec);
};

Engine.prototype.setInterval = function (fn, ts) {
    var self = this;
    var first = self.time, times = 1;
    var f = function () {
        fn();
        self._pushTimer({ fn: f, time: first + (++ times) * ts, id: id });
    };
    var id = this._timerId ++;
    this._pushTimer({ fn: f, time: first + ts, id: id });
    return id;
};

Engine.prototype.clearTimeout =
Engine.prototype.clearInterval = function (id) {
    for (var i = 0; i < this._timers.length; i++) {
        var t = this._timers[i];
        if (t.id === id) {
            if (!this._cleared) this._cleared = {};
            this._cleared[id] = true;
            this._timers.splice(i, 1);
            break;
        }
    }
};

},{"./lib/now.js":6,"defined":8,"events":3,"inherits":9,"raf":10}],6:[function(require,module,exports){
(function (process){
var hrtime = typeof process !== 'undefined' && process
&& typeof process.hrtime === 'function'
    ? process.hrtime
    : require('browser-process-hrtime')
;

module.exports = function () {
    var t = hrtime();
    return (t[0] + t[1] / 1e9) * 1000;
};

}).call(this,require('_process'))
},{"_process":4,"browser-process-hrtime":7}],7:[function(require,module,exports){
module.exports = hrtime

// polyfil for window.performance.now
var performance = window.performance || {}
var performanceNow =
  performance.now        ||
  performance.now        ||
  performance.mozNow     ||
  performance.msNow      ||
  performance.oNow       ||
  performance.webkitNow  ||
  function(){ return (new Date()).getTime() }

// generate timestamp or delta
// see http://nodejs.org/api/process.html#process_process_hrtime
function hrtime(previousTimestamp){
  var clocktime = performanceNow.call(performance)/10e3
  var seconds = Math.floor(clocktime)
  var nanoseconds = (clocktime%1)*10e9
  if (previousTimestamp) {
    seconds = seconds - previousTimestamp[0]
    nanoseconds = nanoseconds - previousTimestamp[1]
    if (nanoseconds<0) {
      seconds--
      nanoseconds += 10e9
    }
  }
  return [seconds,nanoseconds]
}

},{}],8:[function(require,module,exports){
module.exports = function () {
    for (var i = 0; i < arguments.length; i++) {
        if (arguments[i] !== undefined) return arguments[i];
    }
};

},{}],9:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    var TempCtor = function () {}
    TempCtor.prototype = superCtor.prototype
    ctor.prototype = new TempCtor()
    ctor.prototype.constructor = ctor
  }
}

},{}],10:[function(require,module,exports){
var now = require('performance-now')
  , global = typeof window === 'undefined' ? {} : window
  , vendors = ['moz', 'webkit']
  , suffix = 'AnimationFrame'
  , raf = global['request' + suffix]
  , caf = global['cancel' + suffix] || global['cancelRequest' + suffix]
  , isNative = true

for(var i = 0; i < vendors.length && !raf; i++) {
  raf = global[vendors[i] + 'Request' + suffix]
  caf = global[vendors[i] + 'Cancel' + suffix]
      || global[vendors[i] + 'CancelRequest' + suffix]
}

// Some versions of FF have rAF but not cAF
if(!raf || !caf) {
  isNative = false

  var last = 0
    , id = 0
    , queue = []
    , frameDuration = 1000 / 60

  raf = function(callback) {
    if(queue.length === 0) {
      var _now = now()
        , next = Math.max(0, frameDuration - (_now - last))
      last = next + _now
      setTimeout(function() {
        var cp = queue.slice(0)
        // Clear queue here to prevent
        // callbacks from appending listeners
        // to the current frame's queue
        queue.length = 0
        for(var i = 0; i < cp.length; i++) {
          if(!cp[i].cancelled) {
            try{
              cp[i].callback(last)
            } catch(e) {
              setTimeout(function() { throw e }, 0)
            }
          }
        }
      }, Math.round(next))
    }
    queue.push({
      handle: ++id,
      callback: callback,
      cancelled: false
    })
    return id
  }

  caf = function(handle) {
    for(var i = 0; i < queue.length; i++) {
      if(queue[i].handle === handle) {
        queue[i].cancelled = true
      }
    }
  }
}

module.exports = function(fn) {
  // Wrap in a new function to prevent
  // `cancel` potentially being assigned
  // to the native rAF function
  if(!isNative) {
    return raf.call(global, fn)
  }
  return raf.call(global, function() {
    try{
      fn.apply(this, arguments)
    } catch(e) {
      setTimeout(function() { throw e }, 0)
    }
  })
}
module.exports.cancel = function() {
  caf.apply(global, arguments)
}

},{"performance-now":11}],11:[function(require,module,exports){
(function (process){
// Generated by CoffeeScript 1.6.3
(function() {
  var getNanoSeconds, hrtime, loadTime;

  if ((typeof performance !== "undefined" && performance !== null) && performance.now) {
    module.exports = function() {
      return performance.now();
    };
  } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) {
    module.exports = function() {
      return (getNanoSeconds() - loadTime) / 1e6;
    };
    hrtime = process.hrtime;
    getNanoSeconds = function() {
      var hr;
      hr = hrtime();
      return hr[0] * 1e9 + hr[1];
    };
    loadTime = getNanoSeconds();
  } else if (Date.now) {
    module.exports = function() {
      return Date.now() - loadTime;
    };
    loadTime = Date.now();
  } else {
    module.exports = function() {
      return new Date().getTime() - loadTime;
    };
    loadTime = new Date().getTime();
  }

}).call(this);

/*

*/

}).call(this,require('_process'))
},{"_process":4}]},{},[2]);