/**
 * hasOwnProperty.
 */

var has = Object.prototype.hasOwnProperty;

/**
 * Require the given path.
 *
 * @param {String} path
 * @return {Object} exports
 * @api public
 */

function require(path, parent, orig) {
  var resolved = require.resolve(path);

  // lookup failed
  if (null == resolved) {
    orig = orig || path;
    parent = parent || 'root';
    var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
    err.path = orig;
    err.parent = parent;
    err.require = true;
    throw err;
  }

  var module = require.modules[resolved];

  // perform real require()
  // by invoking the module's
  // registered function
  if (!module.exports) {
    module.exports = {};
    module.client = module.component = true;
    module.call(this, module.exports, require.relative(resolved), module);
  }

  return module.exports;
}

/**
 * Registered modules.
 */

require.modules = {};

/**
 * Registered aliases.
 */

require.aliases = {};

/**
 * Resolve `path`.
 *
 * Lookup:
 *
 *   - PATH/index.js
 *   - PATH.js
 *   - PATH
 *
 * @param {String} path
 * @return {String} path or null
 * @api private
 */

require.resolve = function(path) {
  if (path.charAt(0) === '/') path = path.slice(1);
  var index = path + '/index.js';

  var paths = [
    path,
    path + '.js',
    path + '.json',
    path + '/index.js',
    path + '/index.json'
  ];

  for (var i = 0; i < paths.length; i++) {
    var path = paths[i];
    if (has.call(require.modules, path)) return path;
  }

  if (has.call(require.aliases, index)) {
    return require.aliases[index];
  }
};

/**
 * Normalize `path` relative to the current path.
 *
 * @param {String} curr
 * @param {String} path
 * @return {String}
 * @api private
 */

require.normalize = function(curr, path) {
  var segs = [];

  if ('.' != path.charAt(0)) return path;

  curr = curr.split('/');
  path = path.split('/');

  for (var i = 0; i < path.length; ++i) {
    if ('..' == path[i]) {
      curr.pop();
    } else if ('.' != path[i] && '' != path[i]) {
      segs.push(path[i]);
    }
  }

  return curr.concat(segs).join('/');
};

/**
 * Register module at `path` with callback `definition`.
 *
 * @param {String} path
 * @param {Function} definition
 * @api private
 */

require.register = function(path, definition) {
  require.modules[path] = definition;
};

/**
 * Alias a module definition.
 *
 * @param {String} from
 * @param {String} to
 * @api private
 */

require.alias = function(from, to) {
  if (!has.call(require.modules, from)) {
    throw new Error('Failed to alias "' + from + '", it does not exist');
  }
  require.aliases[to] = from;
};

/**
 * Return a require function relative to the `parent` path.
 *
 * @param {String} parent
 * @return {Function}
 * @api private
 */

require.relative = function(parent) {
  var p = require.normalize(parent, '..');

  /**
   * lastIndexOf helper.
   */

  function lastIndexOf(arr, obj) {
    var i = arr.length;
    while (i--) {
      if (arr[i] === obj) return i;
    }
    return -1;
  }

  /**
   * The relative require() itself.
   */

  function localRequire(path) {
    var resolved = localRequire.resolve(path);
    return require(resolved, parent, path);
  }

  /**
   * Resolve relative to the parent.
   */

  localRequire.resolve = function(path) {
    var c = path.charAt(0);
    if ('/' == c) return path.slice(1);
    if ('.' == c) return require.normalize(p, path);

    // resolve deps by returning
    // the dep in the nearest "deps"
    // directory
    var segs = parent.split('/');
    var i = lastIndexOf(segs, 'deps') + 1;
    if (!i) i = 0;
    path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
    return path;
  };

  /**
   * Check if module is defined at `path`.
   */

  localRequire.exists = function(path) {
    return has.call(require.modules, localRequire.resolve(path));
  };

  return localRequire;
};
require.register("number/index.js", function(exports, require, module){
/**
 * Module dependencies
 */

var define = Object.defineProperty
	,	noop = Function()

/**
 * Exports
 */
var number = module.exports = {};


/**
 * Extends the `Number` prototype
 *
 * @api public
 * @function number.extend
 * @param {String} name
 * @param {Function} fn
 */

number.extend = function (name, isGetter, fn) {
	fn = (typeof isGetter === 'function')? isGetter : fn;
	isGetter = (isGetter === true)? true : false;

	define(Number.prototype, name, {
		configurable: false,
		enumerable: false,
		get: isGetter? fn : function () { return fn },
		set: noop
	});

	return this;
};


/**
 * Iterates a function `n` times
 *
 * @function Number#times
 * @api public
 * @param {Function} fn
 */

number.extend('times', function (fn) { 
  for (var i = 0; i < this; ++i) fn(i);
  return this;
});

/**
 * Iterates a function, passing increasing
 * values from `n` up to and including `limit`
 *
 * @function Number#upto
 * @api public
 * @param {Function} limit
 * @param {Function} fn
 */

number.extend('upto', function (limit, fn) { 
  for (var i = 0; i <= limit; ++i) fn(i);
  return this;
});

/**
 * Iterates a function, passing decreasing
 * values from `n` down to and including `limit`
 *
 * @function Number#downto
 * @api public
 * @param {Function} limit
 * @param {Function} fn
 */

number.extend('downto', function (limit, fn) {
	for (var i = this; i >= limit; i--) fn(i);
  return this;
});

/**
 * Returns a number equal to `n + 1`
 *
 * @function Number#next
 * @api public
 */

number.extend('next', true, function () { 
  return this + 1;
});

/**
 * Returns a number equal to `n - 1`
 *
 * @function Number#pred
 * @api public
 */

number.extend('pred', true, function () { 
  return this - 1;
});

/**
 * Returns `true` if `n` is even
 *
 * @function Number#even
 * @api public
 */

number.extend('even', true, function () { 
  return !(this % 2);
});

/**
 * Returns `true` if `n` is odd
 *
 * @function Number#odd
 * @api public
 */

number.extend('odd', true, function () { 
  return !!(this % 2);
});

});