/**

* 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 (require.modules.hasOwnProperty(path)) return path;
}

if (require.aliases.hasOwnProperty(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 (!require.modules.hasOwnProperty(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 require.modules.hasOwnProperty(localRequire.resolve(path));
};

return localRequire;

}; require.register(“isarray/index.js”, function(exports, require, module){ module.exports = Array.isArray || function (arr) {

return Object.prototype.toString.call(arr) == '[object Array]';

};

}); require.alias(“isarray/index.js”, “isarray/index.js”);