☰

Greasy Fork is available in English.

CheckChangelogFromGithubRelease

Check ChangeLog from Github Relase page.

  1. (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  2. // ==UserScript==
  3. // @name        CheckChangelogFromGithubRelease
  4. // @namespace   http://efcl.info/
  5. // @description Check ChangeLog from Github Relase page.
  6. // @license     MIT
  7. // @include     https://github.com/*/*/releases/tag/*
  8. // @version     1.2.1
  9. // @grant       GM_xmlhttpRequest
  10. // ==/UserScript==
  11. "use strict";
  12. var githubAPI = require("./lib/github_api");
  13. var searcher = require("./lib/seacher");
  14. var injector = require("./lib/injector");
  15. var ghObject = require("github-release-dom")(location.href);
  16. var treePromise = new Promise(function (resolve, reject) {
  17.     githubAPI.getTree(ghObject, function (error, res) {
  18.         if (error) {
  19.             reject(error);
  20.         } else {
  21.             resolve(res);
  22.         }
  23.     })
  24. });
  25.  
  26. treePromise.then(JSON.parse)
  27.     .then(searcher.findChangeLogInTrees)
  28.     .then(function (result) {
  29.         if (!result) {
  30.             return Promise.reject(new Error("Not found CHANGELOG in Repogitory."));
  31.         }
  32.         injector.injectChangelogLink(ghObject, result.path);
  33.     })
  34.     .catch(function (error) {
  35.         console.error(error);
  36.     });
  37.  
  38.  
  39. },{"./lib/github_api":2,"./lib/injector":3,"./lib/seacher":4,"github-release-dom":14}],2:[function(require,module,exports){
  40. /**
  41.  * Created by azu on 2014/06/18.
  42.  * LICENSE : MIT
  43.  */
  44. "use strict";
  45. // http://developer.github.com/v3/git/trees/
  46. // GET /repos/:owner/:repo/git/trees/:sha
  47. function getTree(ghObject, callback) {
  48.     var owner = ghObject.user,
  49.         repoName = ghObject.repo,
  50.         tagName = ghObject.tagName;
  51.     var treeAPI = "https://api.github.com/repos/" + owner + "/" + repoName + "/git/trees/" + tagName;
  52.     GM_xmlhttpRequest({
  53.         method: "GET",
  54.         url: treeAPI,
  55.         onload: function (res) {
  56.             if (res.status === 201 || res.status == 200) {
  57.                 callback(null, res.responseText);
  58.             } else {
  59.                 callback(new Error(res.statusText));
  60.             }
  61.         },
  62.         onerror: function (res) {
  63.             callback(res);
  64.         }
  65.     });
  66. }
  67.  
  68. function getFileRawContent(url, callback) {
  69.     // http://swanson.github.com/blog/2011/07/09/digging-around-the-github-v3-api.html
  70.     GM_xmlhttpRequest({
  71.         method: "GET",
  72.         url: url,
  73.         headers: {"Accept": "application/vnd.github-blob.raw"},
  74.         onload: function (res) {
  75.             callback(null, res.responseText);
  76.         },
  77.         onerror: function (res) {
  78.             callback(res);
  79.         }
  80.     });
  81. }
  82. module.exports = {
  83.     getTree: getTree,
  84.     getFileRawContent: getFileRawContent
  85. };
  86. },{}],3:[function(require,module,exports){
  87. /**
  88.  * Created by azu on 2014/06/18.
  89.  * LICENSE : MIT
  90.  */
  91. "use strict";
  92. var tagRef = document.querySelector(".tag-references");
  93. const GITHUBDOMAIN = "https://github.com/";
  94. function injectChangelogLink(ghObject, filePath) {
  95.     var span = document.createElement("span");
  96.     var a = document.createElement("a");
  97.     a.href = GITHUBDOMAIN + ghObject.user + "/" + ghObject.repo + "/blob/" + ghObject.tagName + "/" + filePath;
  98.     a.textContent = "CHANGELOG FILE";
  99.     span.appendChild(a);
  100.     if (tagRef.nextSibling === null) {
  101.         tagRef.parentNode.appendChild(span); // 末尾に追加
  102.     } else {
  103.         tagRef.parentNode.insertBefore(span, tagRef.nextSibling); // 基準ノードの後ろに追加
  104.     }
  105. }
  106.  
  107. module.exports = {
  108.     injectChangelogLink: injectChangelogLink
  109. };
  110. },{}],4:[function(require,module,exports){
  111. /**
  112.  * Created by azu on 2014/06/18.
  113.  * LICENSE : MIT
  114.  */
  115. "use strict";
  116. var find = require("lodash.find");
  117. function findChangeLogInTrees(trees) {
  118.     if (typeof trees !== "object") {
  119.         throw new Error("trees is not object");
  120.     }
  121.     var tree = trees["tree"];
  122.     var result = find(tree, function (object) {
  123.         return /(^changes|^changelog|^history)/i.test(object.path);
  124.     });
  125.     return result;
  126. }
  127. module.exports = {
  128.     findChangeLogInTrees: findChangeLogInTrees
  129. };
  130. },{"lodash.find":17}],5:[function(require,module,exports){
  131. if (typeof Object.create === 'function') {
  132.   // implementation from standard node.js 'util' module
  133.   module.exports = function inherits(ctor, superCtor) {
  134.     ctor.super_ = superCtor
  135.     ctor.prototype = Object.create(superCtor.prototype, {
  136.       constructor: {
  137.         value: ctor,
  138.         enumerable: false,
  139.         writable: true,
  140.         configurable: true
  141.       }
  142.     });
  143.   };
  144. } else {
  145.   // old school shim for old browsers
  146.   module.exports = function inherits(ctor, superCtor) {
  147.     ctor.super_ = superCtor
  148.     var TempCtor = function () {}
  149.     TempCtor.prototype = superCtor.prototype
  150.     ctor.prototype = new TempCtor()
  151.     ctor.prototype.constructor = ctor
  152.   }
  153. }
  154.  
  155. },{}],6:[function(require,module,exports){
  156. // shim for using process in browser
  157.  
  158. var process = module.exports = {};
  159.  
  160. process.nextTick = (function () {
  161.     var canSetImmediate = typeof window !== 'undefined'
  162.     && window.setImmediate;
  163.     var canPost = typeof window !== 'undefined'
  164.     && window.postMessage && window.addEventListener
  165.     ;
  166.  
  167.     if (canSetImmediate) {
  168.         return function (f) { return window.setImmediate(f) };
  169.     }
  170.  
  171.     if (canPost) {
  172.         var queue = [];
  173.         window.addEventListener('message', function (ev) {
  174.             var source = ev.source;
  175.             if ((source === window || source === null) && ev.data === 'process-tick') {
  176.                 ev.stopPropagation();
  177.                 if (queue.length > 0) {
  178.                     var fn = queue.shift();
  179.                     fn();
  180.                 }
  181.             }
  182.         }, true);
  183.  
  184.         return function nextTick(fn) {
  185.             queue.push(fn);
  186.             window.postMessage('process-tick', '*');
  187.         };
  188.     }
  189.  
  190.     return function nextTick(fn) {
  191.         setTimeout(fn, 0);
  192.     };
  193. })();
  194.  
  195. process.title = 'browser';
  196. process.browser = true;
  197. process.env = {};
  198. process.argv = [];
  199.  
  200. function noop() {}
  201.  
  202. process.on = noop;
  203. process.addListener = noop;
  204. process.once = noop;
  205. process.off = noop;
  206. process.removeListener = noop;
  207. process.removeAllListeners = noop;
  208. process.emit = noop;
  209.  
  210. process.binding = function (name) {
  211.     throw new Error('process.binding is not supported');
  212. }
  213.  
  214. // TODO(shtylman)
  215. process.cwd = function () { return '/' };
  216. process.chdir = function (dir) {
  217.     throw new Error('process.chdir is not supported');
  218. };
  219.  
  220. },{}],7:[function(require,module,exports){
  221. (function (global){
  222. /*! http://mths.be/punycode v1.2.4 by @mathias */
  223. ;(function(root) {
  224.  
  225. 	/** Detect free variables */
  226. 	var freeExports = typeof exports == 'object' && exports;
  227. 	var freeModule = typeof module == 'object' && module &&
  228. 		module.exports == freeExports && module;
  229. 	var freeGlobal = typeof global == 'object' && global;
  230. 	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
  231. 		root = freeGlobal;
  232. 	}
  233.  
  234. 	/**
  235. 	 * The `punycode` object.
  236. 	 * @name punycode
  237. 	 * @type Object
  238. 	 */
  239. 	var punycode,
  240.  
  241. 	/** Highest positive signed 32-bit float value */
  242. 	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
  243.  
  244. 	/** Bootstring parameters */
  245. 	base = 36,
  246. 	tMin = 1,
  247. 	tMax = 26,
  248. 	skew = 38,
  249. 	damp = 700,
  250. 	initialBias = 72,
  251. 	initialN = 128, // 0x80
  252. 	delimiter = '-', // '\x2D'
  253.  
  254. 	/** Regular expressions */
  255. 	regexPunycode = /^xn--/,
  256. 	regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
  257. 	regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
  258.  
  259. 	/** Error messages */
  260. 	errors = {
  261. 		'overflow': 'Overflow: input needs wider integers to process',
  262. 		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
  263. 		'invalid-input': 'Invalid input'
  264. 	},
  265.  
  266. 	/** Convenience shortcuts */
  267. 	baseMinusTMin = base - tMin,
  268. 	floor = Math.floor,
  269. 	stringFromCharCode = String.fromCharCode,
  270.  
  271. 	/** Temporary variable */
  272. 	key;
  273.  
  274. 	/*--------------------------------------------------------------------------*/
  275.  
  276. 	/**
  277. 	 * A generic error utility function.
  278. 	 * @private
  279. 	 * @param {String} type The error type.
  280. 	 * @returns {Error} Throws a `RangeError` with the applicable error message.
  281. 	 */
  282. 	function error(type) {
  283. 		throw RangeError(errors[type]);
  284. 	}
  285.  
  286. 	/**
  287. 	 * A generic `Array#map` utility function.
  288. 	 * @private
  289. 	 * @param {Array} array The array to iterate over.
  290. 	 * @param {Function} callback The function that gets called for every array
  291. 	 * item.
  292. 	 * @returns {Array} A new array of values returned by the callback function.
  293. 	 */
  294. 	function map(array, fn) {
  295. 		var length = array.length;
  296. 		while (length--) {
  297. 			array[length] = fn(array[length]);
  298. 		}
  299. 		return array;
  300. 	}
  301.  
  302. 	/**
  303. 	 * A simple `Array#map`-like wrapper to work with domain name strings.
  304. 	 * @private
  305. 	 * @param {String} domain The domain name.
  306. 	 * @param {Function} callback The function that gets called for every
  307. 	 * character.
  308. 	 * @returns {Array} A new string of characters returned by the callback
  309. 	 * function.
  310. 	 */
  311. 	function mapDomain(string, fn) {
  312. 		return map(string.split(regexSeparators), fn).join('.');
  313. 	}
  314.  
  315. 	/**
  316. 	 * Creates an array containing the numeric code points of each Unicode
  317. 	 * character in the string. While JavaScript uses UCS-2 internally,
  318. 	 * this function will convert a pair of surrogate halves (each of which
  319. 	 * UCS-2 exposes as separate characters) into a single code point,
  320. 	 * matching UTF-16.
  321. 	 * @see `punycode.ucs2.encode`
  322. 	 * @see <http://mathiasbynens.be/notes/javascript-encoding>
  323. 	 * @memberOf punycode.ucs2
  324. 	 * @name decode
  325. 	 * @param {String} string The Unicode input string (UCS-2).
  326. 	 * @returns {Array} The new array of code points.
  327. 	 */
  328. 	function ucs2decode(string) {
  329. 		var output = [],
  330. 		    counter = 0,
  331. 		    length = string.length,
  332. 		    value,
  333. 		    extra;
  334. 		while (counter < length) {
  335. 			value = string.charCodeAt(counter++);
  336. 			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  337. 				// high surrogate, and there is a next character
  338. 				extra = string.charCodeAt(counter++);
  339. 				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  340. 					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  341. 				} else {
  342. 					// unmatched surrogate; only append this code unit, in case the next
  343. 					// code unit is the high surrogate of a surrogate pair
  344. 					output.push(value);
  345. 					counter--;
  346. 				}
  347. 			} else {
  348. 				output.push(value);
  349. 			}
  350. 		}
  351. 		return output;
  352. 	}
  353.  
  354. 	/**
  355. 	 * Creates a string based on an array of numeric code points.
  356. 	 * @see `punycode.ucs2.decode`
  357. 	 * @memberOf punycode.ucs2
  358. 	 * @name encode
  359. 	 * @param {Array} codePoints The array of numeric code points.
  360. 	 * @returns {String} The new Unicode string (UCS-2).
  361. 	 */
  362. 	function ucs2encode(array) {
  363. 		return map(array, function(value) {
  364. 			var output = '';
  365. 			if (value > 0xFFFF) {
  366. 				value -= 0x10000;
  367. 				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  368. 				value = 0xDC00 | value & 0x3FF;
  369. 			}
  370. 			output += stringFromCharCode(value);
  371. 			return output;
  372. 		}).join('');
  373. 	}
  374.  
  375. 	/**
  376. 	 * Converts a basic code point into a digit/integer.
  377. 	 * @see `digitToBasic()`
  378. 	 * @private
  379. 	 * @param {Number} codePoint The basic numeric code point value.
  380. 	 * @returns {Number} The numeric value of a basic code point (for use in
  381. 	 * representing integers) in the range `0` to `base - 1`, or `base` if
  382. 	 * the code point does not represent a value.
  383. 	 */
  384. 	function basicToDigit(codePoint) {
  385. 		if (codePoint - 48 < 10) {
  386. 			return codePoint - 22;
  387. 		}
  388. 		if (codePoint - 65 < 26) {
  389. 			return codePoint - 65;
  390. 		}
  391. 		if (codePoint - 97 < 26) {
  392. 			return codePoint - 97;
  393. 		}
  394. 		return base;
  395. 	}
  396.  
  397. 	/**
  398. 	 * Converts a digit/integer into a basic code point.
  399. 	 * @see `basicToDigit()`
  400. 	 * @private
  401. 	 * @param {Number} digit The numeric value of a basic code point.
  402. 	 * @returns {Number} The basic code point whose value (when used for
  403. 	 * representing integers) is `digit`, which needs to be in the range
  404. 	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
  405. 	 * used; else, the lowercase form is used. The behavior is undefined
  406. 	 * if `flag` is non-zero and `digit` has no uppercase form.
  407. 	 */
  408. 	function digitToBasic(digit, flag) {
  409. 		//  0..25 map to ASCII a..z or A..Z
  410. 		// 26..35 map to ASCII 0..9
  411. 		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  412. 	}
  413.  
  414. 	/**
  415. 	 * Bias adaptation function as per section 3.4 of RFC 3492.
  416. 	 * http://tools.ietf.org/html/rfc3492#section-3.4
  417. 	 * @private
  418. 	 */
  419. 	function adapt(delta, numPoints, firstTime) {
  420. 		var k = 0;
  421. 		delta = firstTime ? floor(delta / damp) : delta >> 1;
  422. 		delta += floor(delta / numPoints);
  423. 		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
  424. 			delta = floor(delta / baseMinusTMin);
  425. 		}
  426. 		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  427. 	}
  428.  
  429. 	/**
  430. 	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
  431. 	 * symbols.
  432. 	 * @memberOf punycode
  433. 	 * @param {String} input The Punycode string of ASCII-only symbols.
  434. 	 * @returns {String} The resulting string of Unicode symbols.
  435. 	 */
  436. 	function decode(input) {
  437. 		// Don't use UCS-2
  438. 		var output = [],
  439. 		    inputLength = input.length,
  440. 		    out,
  441. 		    i = 0,
  442. 		    n = initialN,
  443. 		    bias = initialBias,
  444. 		    basic,
  445. 		    j,
  446. 		    index,
  447. 		    oldi,
  448. 		    w,
  449. 		    k,
  450. 		    digit,
  451. 		    t,
  452. 		    /** Cached calculation results */
  453. 		    baseMinusT;
  454.  
  455. 		// Handle the basic code points: let `basic` be the number of input code
  456. 		// points before the last delimiter, or `0` if there is none, then copy
  457. 		// the first basic code points to the output.
  458.  
  459. 		basic = input.lastIndexOf(delimiter);
  460. 		if (basic < 0) {
  461. 			basic = 0;
  462. 		}
  463.  
  464. 		for (j = 0; j < basic; ++j) {
  465. 			// if it's not a basic code point
  466. 			if (input.charCodeAt(j) >= 0x80) {
  467. 				error('not-basic');
  468. 			}
  469. 			output.push(input.charCodeAt(j));
  470. 		}
  471.  
  472. 		// Main decoding loop: start just after the last delimiter if any basic code
  473. 		// points were copied; start at the beginning otherwise.
  474.  
  475. 		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
  476.  
  477. 			// `index` is the index of the next character to be consumed.
  478. 			// Decode a generalized variable-length integer into `delta`,
  479. 			// which gets added to `i`. The overflow checking is easier
  480. 			// if we increase `i` as we go, then subtract off its starting
  481. 			// value at the end to obtain `delta`.
  482. 			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
  483.  
  484. 				if (index >= inputLength) {
  485. 					error('invalid-input');
  486. 				}
  487.  
  488. 				digit = basicToDigit(input.charCodeAt(index++));
  489.  
  490. 				if (digit >= base || digit > floor((maxInt - i) / w)) {
  491. 					error('overflow');
  492. 				}
  493.  
  494. 				i += digit * w;
  495. 				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  496.  
  497. 				if (digit < t) {
  498. 					break;
  499. 				}
  500.  
  501. 				baseMinusT = base - t;
  502. 				if (w > floor(maxInt / baseMinusT)) {
  503. 					error('overflow');
  504. 				}
  505.  
  506. 				w *= baseMinusT;
  507.  
  508. 			}
  509.  
  510. 			out = output.length + 1;
  511. 			bias = adapt(i - oldi, out, oldi == 0);
  512.  
  513. 			// `i` was supposed to wrap around from `out` to `0`,
  514. 			// incrementing `n` each time, so we'll fix that now:
  515. 			if (floor(i / out) > maxInt - n) {
  516. 				error('overflow');
  517. 			}
  518.  
  519. 			n += floor(i / out);
  520. 			i %= out;
  521.  
  522. 			// Insert `n` at position `i` of the output
  523. 			output.splice(i++, 0, n);
  524.  
  525. 		}
  526.  
  527. 		return ucs2encode(output);
  528. 	}
  529.  
  530. 	/**
  531. 	 * Converts a string of Unicode symbols to a Punycode string of ASCII-only
  532. 	 * symbols.
  533. 	 * @memberOf punycode
  534. 	 * @param {String} input The string of Unicode symbols.
  535. 	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
  536. 	 */
  537. 	function encode(input) {
  538. 		var n,
  539. 		    delta,
  540. 		    handledCPCount,
  541. 		    basicLength,
  542. 		    bias,
  543. 		    j,
  544. 		    m,
  545. 		    q,
  546. 		    k,
  547. 		    t,
  548. 		    currentValue,
  549. 		    output = [],
  550. 		    /** `inputLength` will hold the number of code points in `input`. */
  551. 		    inputLength,
  552. 		    /** Cached calculation results */
  553. 		    handledCPCountPlusOne,
  554. 		    baseMinusT,
  555. 		    qMinusT;
  556.  
  557. 		// Convert the input in UCS-2 to Unicode
  558. 		input = ucs2decode(input);
  559.  
  560. 		// Cache the length
  561. 		inputLength = input.length;
  562.  
  563. 		// Initialize the state
  564. 		n = initialN;
  565. 		delta = 0;
  566. 		bias = initialBias;
  567.  
  568. 		// Handle the basic code points
  569. 		for (j = 0; j < inputLength; ++j) {
  570. 			currentValue = input[j];
  571. 			if (currentValue < 0x80) {
  572. 				output.push(stringFromCharCode(currentValue));
  573. 			}
  574. 		}
  575.  
  576. 		handledCPCount = basicLength = output.length;
  577.  
  578. 		// `handledCPCount` is the number of code points that have been handled;
  579. 		// `basicLength` is the number of basic code points.
  580.  
  581. 		// Finish the basic string - if it is not empty - with a delimiter
  582. 		if (basicLength) {
  583. 			output.push(delimiter);
  584. 		}
  585.  
  586. 		// Main encoding loop:
  587. 		while (handledCPCount < inputLength) {
  588.  
  589. 			// All non-basic code points < n have been handled already. Find the next
  590. 			// larger one:
  591. 			for (m = maxInt, j = 0; j < inputLength; ++j) {
  592. 				currentValue = input[j];
  593. 				if (currentValue >= n && currentValue < m) {
  594. 					m = currentValue;
  595. 				}
  596. 			}
  597.  
  598. 			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
  599. 			// but guard against overflow
  600. 			handledCPCountPlusOne = handledCPCount + 1;
  601. 			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
  602. 				error('overflow');
  603. 			}
  604.  
  605. 			delta += (m - n) * handledCPCountPlusOne;
  606. 			n = m;
  607.  
  608. 			for (j = 0; j < inputLength; ++j) {
  609. 				currentValue = input[j];
  610.  
  611. 				if (currentValue < n && ++delta > maxInt) {
  612. 					error('overflow');
  613. 				}
  614.  
  615. 				if (currentValue == n) {
  616. 					// Represent delta as a generalized variable-length integer
  617. 					for (q = delta, k = base; /* no condition */; k += base) {
  618. 						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  619. 						if (q < t) {
  620. 							break;
  621. 						}
  622. 						qMinusT = q - t;
  623. 						baseMinusT = base - t;
  624. 						output.push(
  625. 							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
  626. 						);
  627. 						q = floor(qMinusT / baseMinusT);
  628. 					}
  629.  
  630. 					output.push(stringFromCharCode(digitToBasic(q, 0)));
  631. 					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
  632. 					delta = 0;
  633. 					++handledCPCount;
  634. 				}
  635. 			}
  636.  
  637. 			++delta;
  638. 			++n;
  639.  
  640. 		}
  641. 		return output.join('');
  642. 	}
  643.  
  644. 	/**
  645. 	 * Converts a Punycode string representing a domain name to Unicode. Only the
  646. 	 * Punycoded parts of the domain name will be converted, i.e. it doesn't
  647. 	 * matter if you call it on a string that has already been converted to
  648. 	 * Unicode.
  649. 	 * @memberOf punycode
  650. 	 * @param {String} domain The Punycode domain name to convert to Unicode.
  651. 	 * @returns {String} The Unicode representation of the given Punycode
  652. 	 * string.
  653. 	 */
  654. 	function toUnicode(domain) {
  655. 		return mapDomain(domain, function(string) {
  656. 			return regexPunycode.test(string)
  657. 				? decode(string.slice(4).toLowerCase())
  658. 				: string;
  659. 		});
  660. 	}
  661.  
  662. 	/**
  663. 	 * Converts a Unicode string representing a domain name to Punycode. Only the
  664. 	 * non-ASCII parts of the domain name will be converted, i.e. it doesn't
  665. 	 * matter if you call it with a domain that's already in ASCII.
  666. 	 * @memberOf punycode
  667. 	 * @param {String} domain The domain name to convert, as a Unicode string.
  668. 	 * @returns {String} The Punycode representation of the given domain name.
  669. 	 */
  670. 	function toASCII(domain) {
  671. 		return mapDomain(domain, function(string) {
  672. 			return regexNonASCII.test(string)
  673. 				? 'xn--' + encode(string)
  674. 				: string;
  675. 		});
  676. 	}
  677.  
  678. 	/*--------------------------------------------------------------------------*/
  679.  
  680. 	/** Define the public API */
  681. 	punycode = {
  682. 		/**
  683. 		 * A string representing the current Punycode.js version number.
  684. 		 * @memberOf punycode
  685. 		 * @type String
  686. 		 */
  687. 		'version': '1.2.4',
  688. 		/**
  689. 		 * An object of methods to convert from JavaScript's internal character
  690. 		 * representation (UCS-2) to Unicode code points, and back.
  691. 		 * @see <http://mathiasbynens.be/notes/javascript-encoding>
  692. 		 * @memberOf punycode
  693. 		 * @type Object
  694. 		 */
  695. 		'ucs2': {
  696. 			'decode': ucs2decode,
  697. 			'encode': ucs2encode
  698. 		},
  699. 		'decode': decode,
  700. 		'encode': encode,
  701. 		'toASCII': toASCII,
  702. 		'toUnicode': toUnicode
  703. 	};
  704.  
  705. 	/** Expose `punycode` */
  706. 	// Some AMD build optimizers, like r.js, check for specific condition patterns
  707. 	// like the following:
  708. 	if (
  709. 		typeof define == 'function' &&
  710. 		typeof define.amd == 'object' &&
  711. 		define.amd
  712. 	) {
  713. 		define('punycode', function() {
  714. 			return punycode;
  715. 		});
  716. 	} else if (freeExports && !freeExports.nodeType) {
  717. 		if (freeModule) { // in Node.js or RingoJS v0.8.0+
  718. 			freeModule.exports = punycode;
  719. 		} else { // in Narwhal or RingoJS v0.7.0-
  720. 			for (key in punycode) {
  721. 				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  722. 			}
  723. 		}
  724. 	} else { // in Rhino or a web browser
  725. 		root.punycode = punycode;
  726. 	}
  727.  
  728. }(this));
  729.  
  730. }).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  731. },{}],8:[function(require,module,exports){
  732. // Copyright Joyent, Inc. and other Node contributors.
  733. //
  734. // Permission is hereby granted, free of charge, to any person obtaining a
  735. // copy of this software and associated documentation files (the
  736. // "Software"), to deal in the Software without restriction, including
  737. // without limitation the rights to use, copy, modify, merge, publish,
  738. // distribute, sublicense, and/or sell copies of the Software, and to permit
  739. // persons to whom the Software is furnished to do so, subject to the
  740. // following conditions:
  741. //
  742. // The above copyright notice and this permission notice shall be included
  743. // in all copies or substantial portions of the Software.
  744. //
  745. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  746. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  747. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  748. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  749. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  750. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  751. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  752.  
  753. 'use strict';
  754.  
  755. // If obj.hasOwnProperty has been overridden, then calling
  756. // obj.hasOwnProperty(prop) will break.
  757. // See: https://github.com/joyent/node/issues/1707
  758. function hasOwnProperty(obj, prop) {
  759.   return Object.prototype.hasOwnProperty.call(obj, prop);
  760. }
  761.  
  762. module.exports = function(qs, sep, eq, options) {
  763.   sep = sep || '&';
  764.   eq = eq || '=';
  765.   var obj = {};
  766.  
  767.   if (typeof qs !== 'string' || qs.length === 0) {
  768.     return obj;
  769.   }
  770.  
  771.   var regexp = /\+/g;
  772.   qs = qs.split(sep);
  773.  
  774.   var maxKeys = 1000;
  775.   if (options && typeof options.maxKeys === 'number') {
  776.     maxKeys = options.maxKeys;
  777.   }
  778.  
  779.   var len = qs.length;
  780.   // maxKeys <= 0 means that we should not limit keys count
  781.   if (maxKeys > 0 && len > maxKeys) {
  782.     len = maxKeys;
  783.   }
  784.  
  785.   for (var i = 0; i < len; ++i) {
  786.     var x = qs[i].replace(regexp, '%20'),
  787.         idx = x.indexOf(eq),
  788.         kstr, vstr, k, v;
  789.  
  790.     if (idx >= 0) {
  791.       kstr = x.substr(0, idx);
  792.       vstr = x.substr(idx + 1);
  793.     } else {
  794.       kstr = x;
  795.       vstr = '';
  796.     }
  797.  
  798.     k = decodeURIComponent(kstr);
  799.     v = decodeURIComponent(vstr);
  800.  
  801.     if (!hasOwnProperty(obj, k)) {
  802.       obj[k] = v;
  803.     } else if (isArray(obj[k])) {
  804.       obj[k].push(v);
  805.     } else {
  806.       obj[k] = [obj[k], v];
  807.     }
  808.   }
  809.  
  810.   return obj;
  811. };
  812.  
  813. var isArray = Array.isArray || function (xs) {
  814.   return Object.prototype.toString.call(xs) === '[object Array]';
  815. };
  816.  
  817. },{}],9:[function(require,module,exports){
  818. // Copyright Joyent, Inc. and other Node contributors.
  819. //
  820. // Permission is hereby granted, free of charge, to any person obtaining a
  821. // copy of this software and associated documentation files (the
  822. // "Software"), to deal in the Software without restriction, including
  823. // without limitation the rights to use, copy, modify, merge, publish,
  824. // distribute, sublicense, and/or sell copies of the Software, and to permit
  825. // persons to whom the Software is furnished to do so, subject to the
  826. // following conditions:
  827. //
  828. // The above copyright notice and this permission notice shall be included
  829. // in all copies or substantial portions of the Software.
  830. //
  831. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  832. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  833. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  834. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  835. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  836. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  837. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  838.  
  839. 'use strict';
  840.  
  841. var stringifyPrimitive = function(v) {
  842.   switch (typeof v) {
  843.     case 'string':
  844.       return v;
  845.  
  846.     case 'boolean':
  847.       return v ? 'true' : 'false';
  848.  
  849.     case 'number':
  850.       return isFinite(v) ? v : '';
  851.  
  852.     default:
  853.       return '';
  854.   }
  855. };
  856.  
  857. module.exports = function(obj, sep, eq, name) {
  858.   sep = sep || '&';
  859.   eq = eq || '=';
  860.   if (obj === null) {
  861.     obj = undefined;
  862.   }
  863.  
  864.   if (typeof obj === 'object') {
  865.     return map(objectKeys(obj), function(k) {
  866.       var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
  867.       if (isArray(obj[k])) {
  868.         return map(obj[k], function(v) {
  869.           return ks + encodeURIComponent(stringifyPrimitive(v));
  870.         }).join(sep);
  871.       } else {
  872.         return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
  873.       }
  874.     }).join(sep);
  875.  
  876.   }
  877.  
  878.   if (!name) return '';
  879.   return encodeURIComponent(stringifyPrimitive(name)) + eq +
  880.          encodeURIComponent(stringifyPrimitive(obj));
  881. };
  882.  
  883. var isArray = Array.isArray || function (xs) {
  884.   return Object.prototype.toString.call(xs) === '[object Array]';
  885. };
  886.  
  887. function map (xs, f) {
  888.   if (xs.map) return xs.map(f);
  889.   var res = [];
  890.   for (var i = 0; i < xs.length; i++) {
  891.     res.push(f(xs[i], i));
  892.   }
  893.   return res;
  894. }
  895.  
  896. var objectKeys = Object.keys || function (obj) {
  897.   var res = [];
  898.   for (var key in obj) {
  899.     if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  900.   }
  901.   return res;
  902. };
  903.  
  904. },{}],10:[function(require,module,exports){
  905. 'use strict';
  906.  
  907. exports.decode = exports.parse = require('./decode');
  908. exports.encode = exports.stringify = require('./encode');
  909.  
  910. },{"./decode":8,"./encode":9}],11:[function(require,module,exports){
  911. // Copyright Joyent, Inc. and other Node contributors.
  912. //
  913. // Permission is hereby granted, free of charge, to any person obtaining a
  914. // copy of this software and associated documentation files (the
  915. // "Software"), to deal in the Software without restriction, including
  916. // without limitation the rights to use, copy, modify, merge, publish,
  917. // distribute, sublicense, and/or sell copies of the Software, and to permit
  918. // persons to whom the Software is furnished to do so, subject to the
  919. // following conditions:
  920. //
  921. // The above copyright notice and this permission notice shall be included
  922. // in all copies or substantial portions of the Software.
  923. //
  924. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  925. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  926. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  927. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  928. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  929. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  930. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  931.  
  932. var punycode = require('punycode');
  933.  
  934. exports.parse = urlParse;
  935. exports.resolve = urlResolve;
  936. exports.resolveObject = urlResolveObject;
  937. exports.format = urlFormat;
  938.  
  939. exports.Url = Url;
  940.  
  941. function Url() {
  942.   this.protocol = null;
  943.   this.slashes = null;
  944.   this.auth = null;
  945.   this.host = null;
  946.   this.port = null;
  947.   this.hostname = null;
  948.   this.hash = null;
  949.   this.search = null;
  950.   this.query = null;
  951.   this.pathname = null;
  952.   this.path = null;
  953.   this.href = null;
  954. }
  955.  
  956. // Reference: RFC 3986, RFC 1808, RFC 2396
  957.  
  958. // define these here so at least they only have to be
  959. // compiled once on the first module load.
  960. var protocolPattern = /^([a-z0-9.+-]+:)/i,
  961.     portPattern = /:[0-9]*$/,
  962.  
  963.     // RFC 2396: characters reserved for delimiting URLs.
  964.     // We actually just auto-escape these.
  965.     delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
  966.  
  967.     // RFC 2396: characters not allowed for various reasons.
  968.     unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
  969.  
  970.     // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
  971.     autoEscape = ['\''].concat(unwise),
  972.     // Characters that are never ever allowed in a hostname.
  973.     // Note that any invalid chars are also handled, but these
  974.     // are the ones that are *expected* to be seen, so we fast-path
  975.     // them.
  976.     nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
  977.     hostEndingChars = ['/', '?', '#'],
  978.     hostnameMaxLen = 255,
  979.     hostnamePartPattern = /^[a-z0-9A-Z_-]{0,63}$/,
  980.     hostnamePartStart = /^([a-z0-9A-Z_-]{0,63})(.*)$/,
  981.     // protocols that can allow "unsafe" and "unwise" chars.
  982.     unsafeProtocol = {
  983.       'javascript': true,
  984.       'javascript:': true
  985.     },
  986.     // protocols that never have a hostname.
  987.     hostlessProtocol = {
  988.       'javascript': true,
  989.       'javascript:': true
  990.     },
  991.     // protocols that always contain a // bit.
  992.     slashedProtocol = {
  993.       'http': true,
  994.       'https': true,
  995.       'ftp': true,
  996.       'gopher': true,
  997.       'file': true,
  998.       'http:': true,
  999.       'https:': true,
  1000.       'ftp:': true,
  1001.       'gopher:': true,
  1002.       'file:': true
  1003.     },
  1004.     querystring = require('querystring');
  1005.  
  1006. function urlParse(url, parseQueryString, slashesDenoteHost) {
  1007.   if (url && isObject(url) && url instanceof Url) return url;
  1008.  
  1009.   var u = new Url;
  1010.   u.parse(url, parseQueryString, slashesDenoteHost);
  1011.   return u;
  1012. }
  1013.  
  1014. Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  1015.   if (!isString(url)) {
  1016.     throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  1017.   }
  1018.  
  1019.   var rest = url;
  1020.  
  1021.   // trim before proceeding.
  1022.   // This is to support parse stuff like "  http://foo.com  \n"
  1023.   rest = rest.trim();
  1024.  
  1025.   var proto = protocolPattern.exec(rest);
  1026.   if (proto) {
  1027.     proto = proto[0];
  1028.     var lowerProto = proto.toLowerCase();
  1029.     this.protocol = lowerProto;
  1030.     rest = rest.substr(proto.length);
  1031.   }
  1032.  
  1033.   // figure out if it's got a host
  1034.   // user@server is *always* interpreted as a hostname, and url
  1035.   // resolution will treat //foo/bar as host=foo,path=bar because that's
  1036.   // how the browser resolves relative URLs.
  1037.   if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
  1038.     var slashes = rest.substr(0, 2) === '//';
  1039.     if (slashes && !(proto && hostlessProtocol[proto])) {
  1040.       rest = rest.substr(2);
  1041.       this.slashes = true;
  1042.     }
  1043.   }
  1044.  
  1045.   if (!hostlessProtocol[proto] &&
  1046.       (slashes || (proto && !slashedProtocol[proto]))) {
  1047.  
  1048.     // there's a hostname.
  1049.     // the first instance of /, ?, ;, or # ends the host.
  1050.     //
  1051.     // If there is an @ in the hostname, then non-host chars *are* allowed
  1052.     // to the left of the last @ sign, unless some host-ending character
  1053.     // comes *before* the @-sign.
  1054.     // URLs are obnoxious.
  1055.     //
  1056.     // ex:
  1057.     // http://a@b@c/ => user:a@b host:c
  1058.     // http://a@b?@c => user:a host:c path:/?@c
  1059.  
  1060.     // v0.12 TODO(isaacs): This is not quite how Chrome does things.
  1061.     // Review our test case against browsers more comprehensively.
  1062.  
  1063.     // find the first instance of any hostEndingChars
  1064.     var hostEnd = -1;
  1065.     for (var i = 0; i < hostEndingChars.length; i++) {
  1066.       var hec = rest.indexOf(hostEndingChars[i]);
  1067.       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  1068.         hostEnd = hec;
  1069.     }
  1070.  
  1071.     // at this point, either we have an explicit point where the
  1072.     // auth portion cannot go past, or the last @ char is the decider.
  1073.     var auth, atSign;
  1074.     if (hostEnd === -1) {
  1075.       // atSign can be anywhere.
  1076.       atSign = rest.lastIndexOf('@');
  1077.     } else {
  1078.       // atSign must be in auth portion.
  1079.       // http://a@b/c@d => host:b auth:a path:/c@d
  1080.       atSign = rest.lastIndexOf('@', hostEnd);
  1081.     }
  1082.  
  1083.     // Now we have a portion which is definitely the auth.
  1084.     // Pull that off.
  1085.     if (atSign !== -1) {
  1086.       auth = rest.slice(0, atSign);
  1087.       rest = rest.slice(atSign + 1);
  1088.       this.auth = decodeURIComponent(auth);
  1089.     }
  1090.  
  1091.     // the host is the remaining to the left of the first non-host char
  1092.     hostEnd = -1;
  1093.     for (var i = 0; i < nonHostChars.length; i++) {
  1094.       var hec = rest.indexOf(nonHostChars[i]);
  1095.       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
  1096.         hostEnd = hec;
  1097.     }
  1098.     // if we still have not hit it, then the entire thing is a host.
  1099.     if (hostEnd === -1)
  1100.       hostEnd = rest.length;
  1101.  
  1102.     this.host = rest.slice(0, hostEnd);
  1103.     rest = rest.slice(hostEnd);
  1104.  
  1105.     // pull out port.
  1106.     this.parseHost();
  1107.  
  1108.     // we've indicated that there is a hostname,
  1109.     // so even if it's empty, it has to be present.
  1110.     this.hostname = this.hostname || '';
  1111.  
  1112.     // if hostname begins with [ and ends with ]
  1113.     // assume that it's an IPv6 address.
  1114.     var ipv6Hostname = this.hostname[0] === '[' &&
  1115.         this.hostname[this.hostname.length - 1] === ']';
  1116.  
  1117.     // validate a little.
  1118.     if (!ipv6Hostname) {
  1119.       var hostparts = this.hostname.split(/\./);
  1120.       for (var i = 0, l = hostparts.length; i < l; i++) {
  1121.         var part = hostparts[i];
  1122.         if (!part) continue;
  1123.         if (!part.match(hostnamePartPattern)) {
  1124.           var newpart = '';
  1125.           for (var j = 0, k = part.length; j < k; j++) {
  1126.             if (part.charCodeAt(j) > 127) {
  1127.               // we replace non-ASCII char with a temporary placeholder
  1128.               // we need this to make sure size of hostname is not
  1129.               // broken by replacing non-ASCII by nothing
  1130.               newpart += 'x';
  1131.             } else {
  1132.               newpart += part[j];
  1133.             }
  1134.           }
  1135.           // we test again with ASCII char only
  1136.           if (!newpart.match(hostnamePartPattern)) {
  1137.             var validParts = hostparts.slice(0, i);
  1138.             var notHost = hostparts.slice(i + 1);
  1139.             var bit = part.match(hostnamePartStart);
  1140.             if (bit) {
  1141.               validParts.push(bit[1]);
  1142.               notHost.unshift(bit[2]);
  1143.             }
  1144.             if (notHost.length) {
  1145.               rest = '/' + notHost.join('.') + rest;
  1146.             }
  1147.             this.hostname = validParts.join('.');
  1148.             break;
  1149.           }
  1150.         }
  1151.       }
  1152.     }
  1153.  
  1154.     if (this.hostname.length > hostnameMaxLen) {
  1155.       this.hostname = '';
  1156.     } else {
  1157.       // hostnames are always lower case.
  1158.       this.hostname = this.hostname.toLowerCase();
  1159.     }
  1160.  
  1161.     if (!ipv6Hostname) {
  1162.       // IDNA Support: Returns a puny coded representation of "domain".
  1163.       // It only converts the part of the domain name that
  1164.       // has non ASCII characters. I.e. it dosent matter if
  1165.       // you call it with a domain that already is in ASCII.
  1166.       var domainArray = this.hostname.split('.');
  1167.       var newOut = [];
  1168.       for (var i = 0; i < domainArray.length; ++i) {
  1169.         var s = domainArray[i];
  1170.         newOut.push(s.match(/[^A-Za-z0-9_-]/) ?
  1171.             'xn--' + punycode.encode(s) : s);
  1172.       }
  1173.       this.hostname = newOut.join('.');
  1174.     }
  1175.  
  1176.     var p = this.port ? ':' + this.port : '';
  1177.     var h = this.hostname || '';
  1178.     this.host = h + p;
  1179.     this.href += this.host;
  1180.  
  1181.     // strip [ and ] from the hostname
  1182.     // the host field still retains them, though
  1183.     if (ipv6Hostname) {
  1184.       this.hostname = this.hostname.substr(1, this.hostname.length - 2);
  1185.       if (rest[0] !== '/') {
  1186.         rest = '/' + rest;
  1187.       }
  1188.     }
  1189.   }
  1190.  
  1191.   // now rest is set to the post-host stuff.
  1192.   // chop off any delim chars.
  1193.   if (!unsafeProtocol[lowerProto]) {
  1194.  
  1195.     // First, make 100% sure that any "autoEscape" chars get
  1196.     // escaped, even if encodeURIComponent doesn't think they
  1197.     // need to be.
  1198.     for (var i = 0, l = autoEscape.length; i < l; i++) {
  1199.       var ae = autoEscape[i];
  1200.       var esc = encodeURIComponent(ae);
  1201.       if (esc === ae) {
  1202.         esc = escape(ae);
  1203.       }
  1204.       rest = rest.split(ae).join(esc);
  1205.     }
  1206.   }
  1207.  
  1208.  
  1209.   // chop off from the tail first.
  1210.   var hash = rest.indexOf('#');
  1211.   if (hash !== -1) {
  1212.     // got a fragment string.
  1213.     this.hash = rest.substr(hash);
  1214.     rest = rest.slice(0, hash);
  1215.   }
  1216.   var qm = rest.indexOf('?');
  1217.   if (qm !== -1) {
  1218.     this.search = rest.substr(qm);
  1219.     this.query = rest.substr(qm + 1);
  1220.     if (parseQueryString) {
  1221.       this.query = querystring.parse(this.query);
  1222.     }
  1223.     rest = rest.slice(0, qm);
  1224.   } else if (parseQueryString) {
  1225.     // no query string, but parseQueryString still requested
  1226.     this.search = '';
  1227.     this.query = {};
  1228.   }
  1229.   if (rest) this.pathname = rest;
  1230.   if (slashedProtocol[lowerProto] &&
  1231.       this.hostname && !this.pathname) {
  1232.     this.pathname = '/';
  1233.   }
  1234.  
  1235.   //to support http.request
  1236.   if (this.pathname || this.search) {
  1237.     var p = this.pathname || '';
  1238.     var s = this.search || '';
  1239.     this.path = p + s;
  1240.   }
  1241.  
  1242.   // finally, reconstruct the href based on what has been validated.
  1243.   this.href = this.format();
  1244.   return this;
  1245. };
  1246.  
  1247. // format a parsed object into a url string
  1248. function urlFormat(obj) {
  1249.   // ensure it's an object, and not a string url.
  1250.   // If it's an obj, this is a no-op.
  1251.   // this way, you can call url_format() on strings
  1252.   // to clean up potentially wonky urls.
  1253.   if (isString(obj)) obj = urlParse(obj);
  1254.   if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
  1255.   return obj.format();
  1256. }
  1257.  
  1258. Url.prototype.format = function() {
  1259.   var auth = this.auth || '';
  1260.   if (auth) {
  1261.     auth = encodeURIComponent(auth);
  1262.     auth = auth.replace(/%3A/i, ':');
  1263.     auth += '@';
  1264.   }
  1265.  
  1266.   var protocol = this.protocol || '',
  1267.       pathname = this.pathname || '',
  1268.       hash = this.hash || '',
  1269.       host = false,
  1270.       query = '';
  1271.  
  1272.   if (this.host) {
  1273.     host = auth + this.host;
  1274.   } else if (this.hostname) {
  1275.     host = auth + (this.hostname.indexOf(':') === -1 ?
  1276.         this.hostname :
  1277.         '[' + this.hostname + ']');
  1278.     if (this.port) {
  1279.       host += ':' + this.port;
  1280.     }
  1281.   }
  1282.  
  1283.   if (this.query &&
  1284.       isObject(this.query) &&
  1285.       Object.keys(this.query).length) {
  1286.     query = querystring.stringify(this.query);
  1287.   }
  1288.  
  1289.   var search = this.search || (query && ('?' + query)) || '';
  1290.  
  1291.   if (protocol && protocol.substr(-1) !== ':') protocol += ':';
  1292.  
  1293.   // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
  1294.   // unless they had them to begin with.
  1295.   if (this.slashes ||
  1296.       (!protocol || slashedProtocol[protocol]) && host !== false) {
  1297.     host = '//' + (host || '');
  1298.     if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
  1299.   } else if (!host) {
  1300.     host = '';
  1301.   }
  1302.  
  1303.   if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
  1304.   if (search && search.charAt(0) !== '?') search = '?' + search;
  1305.  
  1306.   pathname = pathname.replace(/[?#]/g, function(match) {
  1307.     return encodeURIComponent(match);
  1308.   });
  1309.   search = search.replace('#', '%23');
  1310.  
  1311.   return protocol + host + pathname + search + hash;
  1312. };
  1313.  
  1314. function urlResolve(source, relative) {
  1315.   return urlParse(source, false, true).resolve(relative);
  1316. }
  1317.  
  1318. Url.prototype.resolve = function(relative) {
  1319.   return this.resolveObject(urlParse(relative, false, true)).format();
  1320. };
  1321.  
  1322. function urlResolveObject(source, relative) {
  1323.   if (!source) return relative;
  1324.   return urlParse(source, false, true).resolveObject(relative);
  1325. }
  1326.  
  1327. Url.prototype.resolveObject = function(relative) {
  1328.   if (isString(relative)) {
  1329.     var rel = new Url();
  1330.     rel.parse(relative, false, true);
  1331.     relative = rel;
  1332.   }
  1333.  
  1334.   var result = new Url();
  1335.   Object.keys(this).forEach(function(k) {
  1336.     result[k] = this[k];
  1337.   }, this);
  1338.  
  1339.   // hash is always overridden, no matter what.
  1340.   // even href="" will remove it.
  1341.   result.hash = relative.hash;
  1342.  
  1343.   // if the relative url is empty, then there's nothing left to do here.
  1344.   if (relative.href === '') {
  1345.     result.href = result.format();
  1346.     return result;
  1347.   }
  1348.  
  1349.   // hrefs like //foo/bar always cut to the protocol.
  1350.   if (relative.slashes && !relative.protocol) {
  1351.     // take everything except the protocol from relative
  1352.     Object.keys(relative).forEach(function(k) {
  1353.       if (k !== 'protocol')
  1354.         result[k] = relative[k];
  1355.     });
  1356.  
  1357.     //urlParse appends trailing / to urls like http://www.example.com
  1358.     if (slashedProtocol[result.protocol] &&
  1359.         result.hostname && !result.pathname) {
  1360.       result.path = result.pathname = '/';
  1361.     }
  1362.  
  1363.     result.href = result.format();
  1364.     return result;
  1365.   }
  1366.  
  1367.   if (relative.protocol && relative.protocol !== result.protocol) {
  1368.     // if it's a known url protocol, then changing
  1369.     // the protocol does weird things
  1370.     // first, if it's not file:, then we MUST have a host,
  1371.     // and if there was a path
  1372.     // to begin with, then we MUST have a path.
  1373.     // if it is file:, then the host is dropped,
  1374.     // because that's known to be hostless.
  1375.     // anything else is assumed to be absolute.
  1376.     if (!slashedProtocol[relative.protocol]) {
  1377.       Object.keys(relative).forEach(function(k) {
  1378.         result[k] = relative[k];
  1379.       });
  1380.       result.href = result.format();
  1381.       return result;
  1382.     }
  1383.  
  1384.     result.protocol = relative.protocol;
  1385.     if (!relative.host && !hostlessProtocol[relative.protocol]) {
  1386.       var relPath = (relative.pathname || '').split('/');
  1387.       while (relPath.length && !(relative.host = relPath.shift()));
  1388.       if (!relative.host) relative.host = '';
  1389.       if (!relative.hostname) relative.hostname = '';
  1390.       if (relPath[0] !== '') relPath.unshift('');
  1391.       if (relPath.length < 2) relPath.unshift('');
  1392.       result.pathname = relPath.join('/');
  1393.     } else {
  1394.       result.pathname = relative.pathname;
  1395.     }
  1396.     result.search = relative.search;
  1397.     result.query = relative.query;
  1398.     result.host = relative.host || '';
  1399.     result.auth = relative.auth;
  1400.     result.hostname = relative.hostname || relative.host;
  1401.     result.port = relative.port;
  1402.     // to support http.request
  1403.     if (result.pathname || result.search) {
  1404.       var p = result.pathname || '';
  1405.       var s = result.search || '';
  1406.       result.path = p + s;
  1407.     }
  1408.     result.slashes = result.slashes || relative.slashes;
  1409.     result.href = result.format();
  1410.     return result;
  1411.   }
  1412.  
  1413.   var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
  1414.       isRelAbs = (
  1415.           relative.host ||
  1416.           relative.pathname && relative.pathname.charAt(0) === '/'
  1417.       ),
  1418.       mustEndAbs = (isRelAbs || isSourceAbs ||
  1419.                     (result.host && relative.pathname)),
  1420.       removeAllDots = mustEndAbs,
  1421.       srcPath = result.pathname && result.pathname.split('/') || [],
  1422.       relPath = relative.pathname && relative.pathname.split('/') || [],
  1423.       psychotic = result.protocol && !slashedProtocol[result.protocol];
  1424.  
  1425.   // if the url is a non-slashed url, then relative
  1426.   // links like ../.. should be able
  1427.   // to crawl up to the hostname, as well.  This is strange.
  1428.   // result.protocol has already been set by now.
  1429.   // Later on, put the first path part into the host field.
  1430.   if (psychotic) {
  1431.     result.hostname = '';
  1432.     result.port = null;
  1433.     if (result.host) {
  1434.       if (srcPath[0] === '') srcPath[0] = result.host;
  1435.       else srcPath.unshift(result.host);
  1436.     }
  1437.     result.host = '';
  1438.     if (relative.protocol) {
  1439.       relative.hostname = null;
  1440.       relative.port = null;
  1441.       if (relative.host) {
  1442.         if (relPath[0] === '') relPath[0] = relative.host;
  1443.         else relPath.unshift(relative.host);
  1444.       }
  1445.       relative.host = null;
  1446.     }
  1447.     mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
  1448.   }
  1449.  
  1450.   if (isRelAbs) {
  1451.     // it's absolute.
  1452.     result.host = (relative.host || relative.host === '') ?
  1453.                   relative.host : result.host;
  1454.     result.hostname = (relative.hostname || relative.hostname === '') ?
  1455.                       relative.hostname : result.hostname;
  1456.     result.search = relative.search;
  1457.     result.query = relative.query;
  1458.     srcPath = relPath;
  1459.     // fall through to the dot-handling below.
  1460.   } else if (relPath.length) {
  1461.     // it's relative
  1462.     // throw away the existing file, and take the new path instead.
  1463.     if (!srcPath) srcPath = [];
  1464.     srcPath.pop();
  1465.     srcPath = srcPath.concat(relPath);
  1466.     result.search = relative.search;
  1467.     result.query = relative.query;
  1468.   } else if (!isNullOrUndefined(relative.search)) {
  1469.     // just pull out the search.
  1470.     // like href='?foo'.
  1471.     // Put this after the other two cases because it simplifies the booleans
  1472.     if (psychotic) {
  1473.       result.hostname = result.host = srcPath.shift();
  1474.       //occationaly the auth can get stuck only in host
  1475.       //this especialy happens in cases like
  1476.       //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  1477.       var authInHost = result.host && result.host.indexOf('@') > 0 ?
  1478.                        result.host.split('@') : false;
  1479.       if (authInHost) {
  1480.         result.auth = authInHost.shift();
  1481.         result.host = result.hostname = authInHost.shift();
  1482.       }
  1483.     }
  1484.     result.search = relative.search;
  1485.     result.query = relative.query;
  1486.     //to support http.request
  1487.     if (!isNull(result.pathname) || !isNull(result.search)) {
  1488.       result.path = (result.pathname ? result.pathname : '') +
  1489.                     (result.search ? result.search : '');
  1490.     }
  1491.     result.href = result.format();
  1492.     return result;
  1493.   }
  1494.  
  1495.   if (!srcPath.length) {
  1496.     // no path at all.  easy.
  1497.     // we've already handled the other stuff above.
  1498.     result.pathname = null;
  1499.     //to support http.request
  1500.     if (result.search) {
  1501.       result.path = '/' + result.search;
  1502.     } else {
  1503.       result.path = null;
  1504.     }
  1505.     result.href = result.format();
  1506.     return result;
  1507.   }
  1508.  
  1509.   // if a url ENDs in . or .., then it must get a trailing slash.
  1510.   // however, if it ends in anything else non-slashy,
  1511.   // then it must NOT get a trailing slash.
  1512.   var last = srcPath.slice(-1)[0];
  1513.   var hasTrailingSlash = (
  1514.       (result.host || relative.host) && (last === '.' || last === '..') ||
  1515.       last === '');
  1516.  
  1517.   // strip single dots, resolve double dots to parent dir
  1518.   // if the path tries to go above the root, `up` ends up > 0
  1519.   var up = 0;
  1520.   for (var i = srcPath.length; i >= 0; i--) {
  1521.     last = srcPath[i];
  1522.     if (last == '.') {
  1523.       srcPath.splice(i, 1);
  1524.     } else if (last === '..') {
  1525.       srcPath.splice(i, 1);
  1526.       up++;
  1527.     } else if (up) {
  1528.       srcPath.splice(i, 1);
  1529.       up--;
  1530.     }
  1531.   }
  1532.  
  1533.   // if the path is allowed to go above the root, restore leading ..s
  1534.   if (!mustEndAbs && !removeAllDots) {
  1535.     for (; up--; up) {
  1536.       srcPath.unshift('..');
  1537.     }
  1538.   }
  1539.  
  1540.   if (mustEndAbs && srcPath[0] !== '' &&
  1541.       (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
  1542.     srcPath.unshift('');
  1543.   }
  1544.  
  1545.   if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
  1546.     srcPath.push('');
  1547.   }
  1548.  
  1549.   var isAbsolute = srcPath[0] === '' ||
  1550.       (srcPath[0] && srcPath[0].charAt(0) === '/');
  1551.  
  1552.   // put the host back
  1553.   if (psychotic) {
  1554.     result.hostname = result.host = isAbsolute ? '' :
  1555.                                     srcPath.length ? srcPath.shift() : '';
  1556.     //occationaly the auth can get stuck only in host
  1557.     //this especialy happens in cases like
  1558.     //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
  1559.     var authInHost = result.host && result.host.indexOf('@') > 0 ?
  1560.                      result.host.split('@') : false;
  1561.     if (authInHost) {
  1562.       result.auth = authInHost.shift();
  1563.       result.host = result.hostname = authInHost.shift();
  1564.     }
  1565.   }
  1566.  
  1567.   mustEndAbs = mustEndAbs || (result.host && srcPath.length);
  1568.  
  1569.   if (mustEndAbs && !isAbsolute) {
  1570.     srcPath.unshift('');
  1571.   }
  1572.  
  1573.   if (!srcPath.length) {
  1574.     result.pathname = null;
  1575.     result.path = null;
  1576.   } else {
  1577.     result.pathname = srcPath.join('/');
  1578.   }
  1579.  
  1580.   //to support request.http
  1581.   if (!isNull(result.pathname) || !isNull(result.search)) {
  1582.     result.path = (result.pathname ? result.pathname : '') +
  1583.                   (result.search ? result.search : '');
  1584.   }
  1585.   result.auth = relative.auth || result.auth;
  1586.   result.slashes = result.slashes || relative.slashes;
  1587.   result.href = result.format();
  1588.   return result;
  1589. };
  1590.  
  1591. Url.prototype.parseHost = function() {
  1592.   var host = this.host;
  1593.   var port = portPattern.exec(host);
  1594.   if (port) {
  1595.     port = port[0];
  1596.     if (port !== ':') {
  1597.       this.port = port.substr(1);
  1598.     }
  1599.     host = host.substr(0, host.length - port.length);
  1600.   }
  1601.   if (host) this.hostname = host;
  1602. };
  1603.  
  1604. function isString(arg) {
  1605.   return typeof arg === "string";
  1606. }
  1607.  
  1608. function isObject(arg) {
  1609.   return typeof arg === 'object' && arg !== null;
  1610. }
  1611.  
  1612. function isNull(arg) {
  1613.   return arg === null;
  1614. }
  1615. function isNullOrUndefined(arg) {
  1616.   return  arg == null;
  1617. }
  1618.  
  1619. },{"punycode":7,"querystring":10}],12:[function(require,module,exports){
  1620. module.exports = function isBuffer(arg) {
  1621.   return arg && typeof arg === 'object'
  1622.     && typeof arg.copy === 'function'
  1623.     && typeof arg.fill === 'function'
  1624.     && typeof arg.readUInt8 === 'function';
  1625. }
  1626. },{}],13:[function(require,module,exports){
  1627. (function (process,global){
  1628. // Copyright Joyent, Inc. and other Node contributors.
  1629. //
  1630. // Permission is hereby granted, free of charge, to any person obtaining a
  1631. // copy of this software and associated documentation files (the
  1632. // "Software"), to deal in the Software without restriction, including
  1633. // without limitation the rights to use, copy, modify, merge, publish,
  1634. // distribute, sublicense, and/or sell copies of the Software, and to permit
  1635. // persons to whom the Software is furnished to do so, subject to the
  1636. // following conditions:
  1637. //
  1638. // The above copyright notice and this permission notice shall be included
  1639. // in all copies or substantial portions of the Software.
  1640. //
  1641. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  1642. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  1643. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  1644. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  1645. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  1646. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  1647. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  1648.  
  1649. var formatRegExp = /%[sdj%]/g;
  1650. exports.format = function(f) {
  1651.   if (!isString(f)) {
  1652.     var objects = [];
  1653.     for (var i = 0; i < arguments.length; i++) {
  1654.       objects.push(inspect(arguments[i]));
  1655.     }
  1656.     return objects.join(' ');
  1657.   }
  1658.  
  1659.   var i = 1;
  1660.   var args = arguments;
  1661.   var len = args.length;
  1662.   var str = String(f).replace(formatRegExp, function(x) {
  1663.     if (x === '%%') return '%';
  1664.     if (i >= len) return x;
  1665.     switch (x) {
  1666.       case '%s': return String(args[i++]);
  1667.       case '%d': return Number(args[i++]);
  1668.       case '%j':
  1669.         try {
  1670.           return JSON.stringify(args[i++]);
  1671.         } catch (_) {
  1672.           return '[Circular]';
  1673.         }
  1674.       default:
  1675.         return x;
  1676.     }
  1677.   });
  1678.   for (var x = args[i]; i < len; x = args[++i]) {
  1679.     if (isNull(x) || !isObject(x)) {
  1680.       str += ' ' + x;
  1681.     } else {
  1682.       str += ' ' + inspect(x);
  1683.     }
  1684.   }
  1685.   return str;
  1686. };
  1687.  
  1688.  
  1689. // Mark that a method should not be used.
  1690. // Returns a modified function which warns once by default.
  1691. // If --no-deprecation is set, then it is a no-op.
  1692. exports.deprecate = function(fn, msg) {
  1693.   // Allow for deprecating things in the process of starting up.
  1694.   if (isUndefined(global.process)) {
  1695.     return function() {
  1696.       return exports.deprecate(fn, msg).apply(this, arguments);
  1697.     };
  1698.   }
  1699.  
  1700.   if (process.noDeprecation === true) {
  1701.     return fn;
  1702.   }
  1703.  
  1704.   var warned = false;
  1705.   function deprecated() {
  1706.     if (!warned) {
  1707.       if (process.throwDeprecation) {
  1708.         throw new Error(msg);
  1709.       } else if (process.traceDeprecation) {
  1710.         console.trace(msg);
  1711.       } else {
  1712.         console.error(msg);
  1713.       }
  1714.       warned = true;
  1715.     }
  1716.     return fn.apply(this, arguments);
  1717.   }
  1718.  
  1719.   return deprecated;
  1720. };
  1721.  
  1722.  
  1723. var debugs = {};
  1724. var debugEnviron;
  1725. exports.debuglog = function(set) {
  1726.   if (isUndefined(debugEnviron))
  1727.     debugEnviron = process.env.NODE_DEBUG || '';
  1728.   set = set.toUpperCase();
  1729.   if (!debugs[set]) {
  1730.     if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
  1731.       var pid = process.pid;
  1732.       debugs[set] = function() {
  1733.         var msg = exports.format.apply(exports, arguments);
  1734.         console.error('%s %d: %s', set, pid, msg);
  1735.       };
  1736.     } else {
  1737.       debugs[set] = function() {};
  1738.     }
  1739.   }
  1740.   return debugs[set];
  1741. };
  1742.  
  1743.  
  1744. /**
  1745.  * Echos the value of a value. Trys to print the value out
  1746.  * in the best way possible given the different types.
  1747.  *
  1748.  * @param {Object} obj The object to print out.
  1749.  * @param {Object} opts Optional options object that alters the output.
  1750.  */
  1751. /* legacy: obj, showHidden, depth, colors*/
  1752. function inspect(obj, opts) {
  1753.   // default options
  1754.   var ctx = {
  1755.     seen: [],
  1756.     stylize: stylizeNoColor
  1757.   };
  1758.   // legacy...
  1759.   if (arguments.length >= 3) ctx.depth = arguments[2];
  1760.   if (arguments.length >= 4) ctx.colors = arguments[3];
  1761.   if (isBoolean(opts)) {
  1762.     // legacy...
  1763.     ctx.showHidden = opts;
  1764.   } else if (opts) {
  1765.     // got an "options" object
  1766.     exports._extend(ctx, opts);
  1767.   }
  1768.   // set default options
  1769.   if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  1770.   if (isUndefined(ctx.depth)) ctx.depth = 2;
  1771.   if (isUndefined(ctx.colors)) ctx.colors = false;
  1772.   if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  1773.   if (ctx.colors) ctx.stylize = stylizeWithColor;
  1774.   return formatValue(ctx, obj, ctx.depth);
  1775. }
  1776. exports.inspect = inspect;
  1777.  
  1778.  
  1779. // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
  1780. inspect.colors = {
  1781.   'bold' : [1, 22],
  1782.   'italic' : [3, 23],
  1783.   'underline' : [4, 24],
  1784.   'inverse' : [7, 27],
  1785.   'white' : [37, 39],
  1786.   'grey' : [90, 39],
  1787.   'black' : [30, 39],
  1788.   'blue' : [34, 39],
  1789.   'cyan' : [36, 39],
  1790.   'green' : [32, 39],
  1791.   'magenta' : [35, 39],
  1792.   'red' : [31, 39],
  1793.   'yellow' : [33, 39]
  1794. };
  1795.  
  1796. // Don't use 'blue' not visible on cmd.exe
  1797. inspect.styles = {
  1798.   'special': 'cyan',
  1799.   'number': 'yellow',
  1800.   'boolean': 'yellow',
  1801.   'undefined': 'grey',
  1802.   'null': 'bold',
  1803.   'string': 'green',
  1804.   'date': 'magenta',
  1805.   // "name": intentionally not styling
  1806.   'regexp': 'red'
  1807. };
  1808.  
  1809.  
  1810. function stylizeWithColor(str, styleType) {
  1811.   var style = inspect.styles[styleType];
  1812.  
  1813.   if (style) {
  1814.     return '\u001b[' + inspect.colors[style][0] + 'm' + str +
  1815.            '\u001b[' + inspect.colors[style][1] + 'm';
  1816.   } else {
  1817.     return str;
  1818.   }
  1819. }
  1820.  
  1821.  
  1822. function stylizeNoColor(str, styleType) {
  1823.   return str;
  1824. }
  1825.  
  1826.  
  1827. function arrayToHash(array) {
  1828.   var hash = {};
  1829.  
  1830.   array.forEach(function(val, idx) {
  1831.     hash[val] = true;
  1832.   });
  1833.  
  1834.   return hash;
  1835. }
  1836.  
  1837.  
  1838. function formatValue(ctx, value, recurseTimes) {
  1839.   // Provide a hook for user-specified inspect functions.
  1840.   // Check that value is an object with an inspect function on it
  1841.   if (ctx.customInspect &&
  1842.       value &&
  1843.       isFunction(value.inspect) &&
  1844.       // Filter out the util module, it's inspect function is special
  1845.       value.inspect !== exports.inspect &&
  1846.       // Also filter out any prototype objects using the circular check.
  1847.       !(value.constructor && value.constructor.prototype === value)) {
  1848.     var ret = value.inspect(recurseTimes, ctx);
  1849.     if (!isString(ret)) {
  1850.       ret = formatValue(ctx, ret, recurseTimes);
  1851.     }
  1852.     return ret;
  1853.   }
  1854.  
  1855.   // Primitive types cannot have properties
  1856.   var primitive = formatPrimitive(ctx, value);
  1857.   if (primitive) {
  1858.     return primitive;
  1859.   }
  1860.  
  1861.   // Look up the keys of the object.
  1862.   var keys = Object.keys(value);
  1863.   var visibleKeys = arrayToHash(keys);
  1864.  
  1865.   if (ctx.showHidden) {
  1866.     keys = Object.getOwnPropertyNames(value);
  1867.   }
  1868.  
  1869.   // IE doesn't make error fields non-enumerable
  1870.   // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  1871.   if (isError(value)
  1872.       && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
  1873.     return formatError(value);
  1874.   }
  1875.  
  1876.   // Some type of object without properties can be shortcutted.
  1877.   if (keys.length === 0) {
  1878.     if (isFunction(value)) {
  1879.       var name = value.name ? ': ' + value.name : '';
  1880.       return ctx.stylize('[Function' + name + ']', 'special');
  1881.     }
  1882.     if (isRegExp(value)) {
  1883.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  1884.     }
  1885.     if (isDate(value)) {
  1886.       return ctx.stylize(Date.prototype.toString.call(value), 'date');
  1887.     }
  1888.     if (isError(value)) {
  1889.       return formatError(value);
  1890.     }
  1891.   }
  1892.  
  1893.   var base = '', array = false, braces = ['{', '}'];
  1894.  
  1895.   // Make Array say that they are Array
  1896.   if (isArray(value)) {
  1897.     array = true;
  1898.     braces = ['[', ']'];
  1899.   }
  1900.  
  1901.   // Make functions say that they are functions
  1902.   if (isFunction(value)) {
  1903.     var n = value.name ? ': ' + value.name : '';
  1904.     base = ' [Function' + n + ']';
  1905.   }
  1906.  
  1907.   // Make RegExps say that they are RegExps
  1908.   if (isRegExp(value)) {
  1909.     base = ' ' + RegExp.prototype.toString.call(value);
  1910.   }
  1911.  
  1912.   // Make dates with properties first say the date
  1913.   if (isDate(value)) {
  1914.     base = ' ' + Date.prototype.toUTCString.call(value);
  1915.   }
  1916.  
  1917.   // Make error with message first say the error
  1918.   if (isError(value)) {
  1919.     base = ' ' + formatError(value);
  1920.   }
  1921.  
  1922.   if (keys.length === 0 && (!array || value.length == 0)) {
  1923.     return braces[0] + base + braces[1];
  1924.   }
  1925.  
  1926.   if (recurseTimes < 0) {
  1927.     if (isRegExp(value)) {
  1928.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  1929.     } else {
  1930.       return ctx.stylize('[Object]', 'special');
  1931.     }
  1932.   }
  1933.  
  1934.   ctx.seen.push(value);
  1935.  
  1936.   var output;
  1937.   if (array) {
  1938.     output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
  1939.   } else {
  1940.     output = keys.map(function(key) {
  1941.       return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
  1942.     });
  1943.   }
  1944.  
  1945.   ctx.seen.pop();
  1946.  
  1947.   return reduceToSingleString(output, base, braces);
  1948. }
  1949.  
  1950.  
  1951. function formatPrimitive(ctx, value) {
  1952.   if (isUndefined(value))
  1953.     return ctx.stylize('undefined', 'undefined');
  1954.   if (isString(value)) {
  1955.     var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
  1956.                                              .replace(/'/g, "\\'")
  1957.                                              .replace(/\\"/g, '"') + '\'';
  1958.     return ctx.stylize(simple, 'string');
  1959.   }
  1960.   if (isNumber(value))
  1961.     return ctx.stylize('' + value, 'number');
  1962.   if (isBoolean(value))
  1963.     return ctx.stylize('' + value, 'boolean');
  1964.   // For some reason typeof null is "object", so special case here.
  1965.   if (isNull(value))
  1966.     return ctx.stylize('null', 'null');
  1967. }
  1968.  
  1969.  
  1970. function formatError(value) {
  1971.   return '[' + Error.prototype.toString.call(value) + ']';
  1972. }
  1973.  
  1974.  
  1975. function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
  1976.   var output = [];
  1977.   for (var i = 0, l = value.length; i < l; ++i) {
  1978.     if (hasOwnProperty(value, String(i))) {
  1979.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  1980.           String(i), true));
  1981.     } else {
  1982.       output.push('');
  1983.     }
  1984.   }
  1985.   keys.forEach(function(key) {
  1986.     if (!key.match(/^\d+$/)) {
  1987.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  1988.           key, true));
  1989.     }
  1990.   });
  1991.   return output;
  1992. }
  1993.  
  1994.  
  1995. function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
  1996.   var name, str, desc;
  1997.   desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  1998.   if (desc.get) {
  1999.     if (desc.set) {
  2000.       str = ctx.stylize('[Getter/Setter]', 'special');
  2001.     } else {
  2002.       str = ctx.stylize('[Getter]', 'special');
  2003.     }
  2004.   } else {
  2005.     if (desc.set) {
  2006.       str = ctx.stylize('[Setter]', 'special');
  2007.     }
  2008.   }
  2009.   if (!hasOwnProperty(visibleKeys, key)) {
  2010.     name = '[' + key + ']';
  2011.   }
  2012.   if (!str) {
  2013.     if (ctx.seen.indexOf(desc.value) < 0) {
  2014.       if (isNull(recurseTimes)) {
  2015.         str = formatValue(ctx, desc.value, null);
  2016.       } else {
  2017.         str = formatValue(ctx, desc.value, recurseTimes - 1);
  2018.       }
  2019.       if (str.indexOf('\n') > -1) {
  2020.         if (array) {
  2021.           str = str.split('\n').map(function(line) {
  2022.             return '  ' + line;
  2023.           }).join('\n').substr(2);
  2024.         } else {
  2025.           str = '\n' + str.split('\n').map(function(line) {
  2026.             return '   ' + line;
  2027.           }).join('\n');
  2028.         }
  2029.       }
  2030.     } else {
  2031.       str = ctx.stylize('[Circular]', 'special');
  2032.     }
  2033.   }
  2034.   if (isUndefined(name)) {
  2035.     if (array && key.match(/^\d+$/)) {
  2036.       return str;
  2037.     }
  2038.     name = JSON.stringify('' + key);
  2039.     if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
  2040.       name = name.substr(1, name.length - 2);
  2041.       name = ctx.stylize(name, 'name');
  2042.     } else {
  2043.       name = name.replace(/'/g, "\\'")
  2044.                  .replace(/\\"/g, '"')
  2045.                  .replace(/(^"|"$)/g, "'");
  2046.       name = ctx.stylize(name, 'string');
  2047.     }
  2048.   }
  2049.  
  2050.   return name + ': ' + str;
  2051. }
  2052.  
  2053.  
  2054. function reduceToSingleString(output, base, braces) {
  2055.   var numLinesEst = 0;
  2056.   var length = output.reduce(function(prev, cur) {
  2057.     numLinesEst++;
  2058.     if (cur.indexOf('\n') >= 0) numLinesEst++;
  2059.     return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
  2060.   }, 0);
  2061.  
  2062.   if (length > 60) {
  2063.     return braces[0] +
  2064.            (base === '' ? '' : base + '\n ') +
  2065.            ' ' +
  2066.            output.join(',\n  ') +
  2067.            ' ' +
  2068.            braces[1];
  2069.   }
  2070.  
  2071.   return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
  2072. }
  2073.  
  2074.  
  2075. // NOTE: These type checking functions intentionally don't use `instanceof`
  2076. // because it is fragile and can be easily faked with `Object.create()`.
  2077. function isArray(ar) {
  2078.   return Array.isArray(ar);
  2079. }
  2080. exports.isArray = isArray;
  2081.  
  2082. function isBoolean(arg) {
  2083.   return typeof arg === 'boolean';
  2084. }
  2085. exports.isBoolean = isBoolean;
  2086.  
  2087. function isNull(arg) {
  2088.   return arg === null;
  2089. }
  2090. exports.isNull = isNull;
  2091.  
  2092. function isNullOrUndefined(arg) {
  2093.   return arg == null;
  2094. }
  2095. exports.isNullOrUndefined = isNullOrUndefined;
  2096.  
  2097. function isNumber(arg) {
  2098.   return typeof arg === 'number';
  2099. }
  2100. exports.isNumber = isNumber;
  2101.  
  2102. function isString(arg) {
  2103.   return typeof arg === 'string';
  2104. }
  2105. exports.isString = isString;
  2106.  
  2107. function isSymbol(arg) {
  2108.   return typeof arg === 'symbol';
  2109. }
  2110. exports.isSymbol = isSymbol;
  2111.  
  2112. function isUndefined(arg) {
  2113.   return arg === void 0;
  2114. }
  2115. exports.isUndefined = isUndefined;
  2116.  
  2117. function isRegExp(re) {
  2118.   return isObject(re) && objectToString(re) === '[object RegExp]';
  2119. }
  2120. exports.isRegExp = isRegExp;
  2121.  
  2122. function isObject(arg) {
  2123.   return typeof arg === 'object' && arg !== null;
  2124. }
  2125. exports.isObject = isObject;
  2126.  
  2127. function isDate(d) {
  2128.   return isObject(d) && objectToString(d) === '[object Date]';
  2129. }
  2130. exports.isDate = isDate;
  2131.  
  2132. function isError(e) {
  2133.   return isObject(e) &&
  2134.       (objectToString(e) === '[object Error]' || e instanceof Error);
  2135. }
  2136. exports.isError = isError;
  2137.  
  2138. function isFunction(arg) {
  2139.   return typeof arg === 'function';
  2140. }
  2141. exports.isFunction = isFunction;
  2142.  
  2143. function isPrimitive(arg) {
  2144.   return arg === null ||
  2145.          typeof arg === 'boolean' ||
  2146.          typeof arg === 'number' ||
  2147.          typeof arg === 'string' ||
  2148.          typeof arg === 'symbol' ||  // ES6 symbol
  2149.          typeof arg === 'undefined';
  2150. }
  2151. exports.isPrimitive = isPrimitive;
  2152.  
  2153. exports.isBuffer = require('./support/isBuffer');
  2154.  
  2155. function objectToString(o) {
  2156.   return Object.prototype.toString.call(o);
  2157. }
  2158.  
  2159.  
  2160. function pad(n) {
  2161.   return n < 10 ? '0' + n.toString(10) : n.toString(10);
  2162. }
  2163.  
  2164.  
  2165. var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
  2166.               'Oct', 'Nov', 'Dec'];
  2167.  
  2168. // 26 Feb 16:19:34
  2169. function timestamp() {
  2170.   var d = new Date();
  2171.   var time = [pad(d.getHours()),
  2172.               pad(d.getMinutes()),
  2173.               pad(d.getSeconds())].join(':');
  2174.   return [d.getDate(), months[d.getMonth()], time].join(' ');
  2175. }
  2176.  
  2177.  
  2178. // log is just a thin wrapper to console.log that prepends a timestamp
  2179. exports.log = function() {
  2180.   console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
  2181. };
  2182.  
  2183.  
  2184. /**
  2185.  * Inherit the prototype methods from one constructor into another.
  2186.  *
  2187.  * The Function.prototype.inherits from lang.js rewritten as a standalone
  2188.  * function (not on Function.prototype). NOTE: If this file is to be loaded
  2189.  * during bootstrapping this function needs to be rewritten using some native
  2190.  * functions as prototype setup using normal JavaScript does not work as
  2191.  * expected during bootstrapping (see mirror.js in r114903).
  2192.  *
  2193.  * @param {function} ctor Constructor function which needs to inherit the
  2194.  *     prototype.
  2195.  * @param {function} superCtor Constructor function to inherit prototype from.
  2196.  */
  2197. exports.inherits = require('inherits');
  2198.  
  2199. exports._extend = function(origin, add) {
  2200.   // Don't do anything if add isn't an object
  2201.   if (!add || !isObject(add)) return origin;
  2202.  
  2203.   var keys = Object.keys(add);
  2204.   var i = keys.length;
  2205.   while (i--) {
  2206.     origin[keys[i]] = add[keys[i]];
  2207.   }
  2208.   return origin;
  2209. };
  2210.  
  2211. function hasOwnProperty(obj, prop) {
  2212.   return Object.prototype.hasOwnProperty.call(obj, prop);
  2213. }
  2214.  
  2215. }).call(this,require("FWaASH"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  2216. },{"./support/isBuffer":12,"FWaASH":6,"inherits":5}],14:[function(require,module,exports){
  2217. "use strict";
  2218. var gh = require("github-url-to-object");
  2219. function getTagName(URL) {
  2220.     var reg = /\/releases\/tag\/(.*)[#?/]?/;
  2221.     var match = URL.match(reg);
  2222.     return match && match[1];
  2223. }
  2224. function convertURL(URL) {
  2225.     var ghParsed = gh(URL);
  2226.     ghParsed.tagName = getTagName(URL);
  2227.     return ghParsed;
  2228. }
  2229. module.exports = convertURL;
  2230. },{"github-url-to-object":15}],15:[function(require,module,exports){
  2231. "use strict"
  2232.  
  2233. var url = require("url")
  2234. var util = require("util")
  2235. var isUrl = require("is-url")
  2236.  
  2237. module.exports = function(repo_url) {
  2238.   var obj = {}
  2239.  
  2240.   if (!repo_url) return null
  2241.  
  2242.   var shorthand = repo_url.match(/^([\w-_]+)\/([\w-_\.]+)#?([\w-_\.]+)?$/)
  2243.   var mediumhand = repo_url.match(/^github:([\w-_]+)\/([\w-_\.]+)#?([\w-_\.]+)?$/)
  2244.   var antiquated = repo_url.match(/^git@[\w-_\.]+:([\w-_]+)\/([\w-_\.]+)$/)
  2245.  
  2246.   if (shorthand) {
  2247.     obj.user = shorthand[1]
  2248.     obj.repo = shorthand[2]
  2249.     obj.branch = shorthand[3] || "master"
  2250.   } else if (mediumhand) {
  2251.     obj.user = mediumhand[1]
  2252.     obj.repo = mediumhand[2]
  2253.     obj.branch = mediumhand[3] || "master"
  2254.   } else if (antiquated) {
  2255.     obj.user = antiquated[1]
  2256.     obj.repo = antiquated[2].replace(/\.git$/i, "")
  2257.     obj.branch = "master"
  2258.   } else {
  2259.     if (!isUrl(repo_url)) return null
  2260.     var parsedURL = url.parse(repo_url)
  2261.     if (parsedURL.hostname != "github.com") return null
  2262.     var parts = parsedURL.pathname.match(/^\/([\w-_]+)\/([\w-_\.]+)(\/tree\/[\w-_\.]+)?(\/blob\/[\w-_\.]+)?/)
  2263.     // ([\w-_\.]+)
  2264.     if (!parts) return null
  2265.     obj.user = parts[1]
  2266.     obj.repo = parts[2].replace(/\.git$/i, "")
  2267.  
  2268.     if (parts[3]) {
  2269.       obj.branch = parts[3].replace(/^\/tree\//, "")
  2270.     } else if (parts[4]) {
  2271.       obj.branch = parts[4].replace(/^\/blob\//, "")
  2272.     } else {
  2273.       obj.branch = "master"
  2274.     }
  2275.  
  2276.   }
  2277.  
  2278.   obj.tarball_url = util.format("https://api.github.com/repos/%s/%s/tarball/%s", obj.user, obj.repo, obj.branch)
  2279.  
  2280.   if (obj.branch === "master") {
  2281.     obj.https_url = util.format("https://github.com/%s/%s", obj.user, obj.repo)
  2282.     obj.travis_url = util.format("https://travis-ci.org/%s/%s", obj.user, obj.repo)
  2283.   } else {
  2284.     obj.https_url = util.format("https://github.com/%s/%s/tree/%s", obj.user, obj.repo, obj.branch)
  2285.     obj.travis_url = util.format("https://travis-ci.org/%s/%s?branch=%s", obj.user, obj.repo, obj.branch)
  2286.   }
  2287.  
  2288.   return obj
  2289. }
  2290.  
  2291. },{"is-url":16,"url":11,"util":13}],16:[function(require,module,exports){
  2292.  
  2293. /**
  2294.  * Expose `isUrl`.
  2295.  */
  2296.  
  2297. module.exports = isUrl;
  2298.  
  2299. /**
  2300.  * Matcher.
  2301.  */
  2302.  
  2303. var matcher = /^\w+:\/\/([^\s\.]+\.\S{2}|localhost[\:?\d]*)\S*$/;
  2304.  
  2305. /**
  2306.  * Loosely validate a URL `string`.
  2307.  *
  2308.  * @param {String} string
  2309.  * @return {Boolean}
  2310.  */
  2311.  
  2312. function isUrl(string){
  2313.   return matcher.test(string);
  2314. }
  2315.  
  2316. },{}],17:[function(require,module,exports){
  2317. /**
  2318.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2319.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2320.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2321.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2322.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2323.  * Available under MIT license <http://lodash.com/license>
  2324.  */
  2325. var createCallback = require('lodash.createcallback'),
  2326.     forOwn = require('lodash.forown');
  2327.  
  2328. /**
  2329.  * Iterates over elements of a collection, returning the first element that
  2330.  * the callback returns truey for. The callback is bound to `thisArg` and
  2331.  * invoked with three arguments; (value, index|key, collection).
  2332.  *
  2333.  * If a property name is provided for `callback` the created "_.pluck" style
  2334.  * callback will return the property value of the given element.
  2335.  *
  2336.  * If an object is provided for `callback` the created "_.where" style callback
  2337.  * will return `true` for elements that have the properties of the given object,
  2338.  * else `false`.
  2339.  *
  2340.  * @static
  2341.  * @memberOf _
  2342.  * @alias detect, findWhere
  2343.  * @category Collections
  2344.  * @param {Array|Object|string} collection The collection to iterate over.
  2345.  * @param {Function|Object|string} [callback=identity] The function called
  2346.  *  per iteration. If a property name or object is provided it will be used
  2347.  *  to create a "_.pluck" or "_.where" style callback, respectively.
  2348.  * @param {*} [thisArg] The `this` binding of `callback`.
  2349.  * @returns {*} Returns the found element, else `undefined`.
  2350.  * @example
  2351.  *
  2352.  * var characters = [
  2353.  *   { 'name': 'barney',  'age': 36, 'blocked': false },
  2354.  *   { 'name': 'fred',    'age': 40, 'blocked': true },
  2355.  *   { 'name': 'pebbles', 'age': 1,  'blocked': false }
  2356.  * ];
  2357.  *
  2358.  * _.find(characters, function(chr) {
  2359.  *   return chr.age < 40;
  2360.  * });
  2361.  * // => { 'name': 'barney', 'age': 36, 'blocked': false }
  2362.  *
  2363.  * // using "_.where" callback shorthand
  2364.  * _.find(characters, { 'age': 1 });
  2365.  * // =>  { 'name': 'pebbles', 'age': 1, 'blocked': false }
  2366.  *
  2367.  * // using "_.pluck" callback shorthand
  2368.  * _.find(characters, 'blocked');
  2369.  * // => { 'name': 'fred', 'age': 40, 'blocked': true }
  2370.  */
  2371. function find(collection, callback, thisArg) {
  2372.   callback = createCallback(callback, thisArg, 3);
  2373.  
  2374.   var index = -1,
  2375.       length = collection ? collection.length : 0;
  2376.  
  2377.   if (typeof length == 'number') {
  2378.     while (++index < length) {
  2379.       var value = collection[index];
  2380.       if (callback(value, index, collection)) {
  2381.         return value;
  2382.       }
  2383.     }
  2384.   } else {
  2385.     var result;
  2386.     forOwn(collection, function(value, index, collection) {
  2387.       if (callback(value, index, collection)) {
  2388.         result = value;
  2389.         return false;
  2390.       }
  2391.     });
  2392.     return result;
  2393.   }
  2394. }
  2395.  
  2396. module.exports = find;
  2397.  
  2398. },{"lodash.createcallback":18,"lodash.forown":54}],18:[function(require,module,exports){
  2399. /**
  2400.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2401.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2402.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2403.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2404.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2405.  * Available under MIT license <http://lodash.com/license>
  2406.  */
  2407. var baseCreateCallback = require('lodash._basecreatecallback'),
  2408.     baseIsEqual = require('lodash._baseisequal'),
  2409.     isObject = require('lodash.isobject'),
  2410.     keys = require('lodash.keys'),
  2411.     property = require('lodash.property');
  2412.  
  2413. /**
  2414.  * Produces a callback bound to an optional `thisArg`. If `func` is a property
  2415.  * name the created callback will return the property value for a given element.
  2416.  * If `func` is an object the created callback will return `true` for elements
  2417.  * that contain the equivalent object properties, otherwise it will return `false`.
  2418.  *
  2419.  * @static
  2420.  * @memberOf _
  2421.  * @category Utilities
  2422.  * @param {*} [func=identity] The value to convert to a callback.
  2423.  * @param {*} [thisArg] The `this` binding of the created callback.
  2424.  * @param {number} [argCount] The number of arguments the callback accepts.
  2425.  * @returns {Function} Returns a callback function.
  2426.  * @example
  2427.  *
  2428.  * var characters = [
  2429.  *   { 'name': 'barney', 'age': 36 },
  2430.  *   { 'name': 'fred',   'age': 40 }
  2431.  * ];
  2432.  *
  2433.  * // wrap to create custom callback shorthands
  2434.  * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
  2435.  *   var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
  2436.  *   return !match ? func(callback, thisArg) : function(object) {
  2437.  *     return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
  2438.  *   };
  2439.  * });
  2440.  *
  2441.  * _.filter(characters, 'age__gt38');
  2442.  * // => [{ 'name': 'fred', 'age': 40 }]
  2443.  */
  2444. function createCallback(func, thisArg, argCount) {
  2445.   var type = typeof func;
  2446.   if (func == null || type == 'function') {
  2447.     return baseCreateCallback(func, thisArg, argCount);
  2448.   }
  2449.   // handle "_.pluck" style callback shorthands
  2450.   if (type != 'object') {
  2451.     return property(func);
  2452.   }
  2453.   var props = keys(func),
  2454.       key = props[0],
  2455.       a = func[key];
  2456.  
  2457.   // handle "_.where" style callback shorthands
  2458.   if (props.length == 1 && a === a && !isObject(a)) {
  2459.     // fast path the common case of providing an object with a single
  2460.     // property containing a primitive value
  2461.     return function(object) {
  2462.       var b = object[key];
  2463.       return a === b && (a !== 0 || (1 / a == 1 / b));
  2464.     };
  2465.   }
  2466.   return function(object) {
  2467.     var length = props.length,
  2468.         result = false;
  2469.  
  2470.     while (length--) {
  2471.       if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
  2472.         break;
  2473.       }
  2474.     }
  2475.     return result;
  2476.   };
  2477. }
  2478.  
  2479. module.exports = createCallback;
  2480.  
  2481. },{"lodash._basecreatecallback":19,"lodash._baseisequal":38,"lodash.isobject":47,"lodash.keys":49,"lodash.property":53}],19:[function(require,module,exports){
  2482. /**
  2483.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2484.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2485.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2486.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2487.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2488.  * Available under MIT license <http://lodash.com/license>
  2489.  */
  2490. var bind = require('lodash.bind'),
  2491.     identity = require('lodash.identity'),
  2492.     setBindData = require('lodash._setbinddata'),
  2493.     support = require('lodash.support');
  2494.  
  2495. /** Used to detected named functions */
  2496. var reFuncName = /^\s*function[ \n\r\t]+\w/;
  2497.  
  2498. /** Used to detect functions containing a `this` reference */
  2499. var reThis = /\bthis\b/;
  2500.  
  2501. /** Native method shortcuts */
  2502. var fnToString = Function.prototype.toString;
  2503.  
  2504. /**
  2505.  * The base implementation of `_.createCallback` without support for creating
  2506.  * "_.pluck" or "_.where" style callbacks.
  2507.  *
  2508.  * @private
  2509.  * @param {*} [func=identity] The value to convert to a callback.
  2510.  * @param {*} [thisArg] The `this` binding of the created callback.
  2511.  * @param {number} [argCount] The number of arguments the callback accepts.
  2512.  * @returns {Function} Returns a callback function.
  2513.  */
  2514. function baseCreateCallback(func, thisArg, argCount) {
  2515.   if (typeof func != 'function') {
  2516.     return identity;
  2517.   }
  2518.   // exit early for no `thisArg` or already bound by `Function#bind`
  2519.   if (typeof thisArg == 'undefined' || !('prototype' in func)) {
  2520.     return func;
  2521.   }
  2522.   var bindData = func.__bindData__;
  2523.   if (typeof bindData == 'undefined') {
  2524.     if (support.funcNames) {
  2525.       bindData = !func.name;
  2526.     }
  2527.     bindData = bindData || !support.funcDecomp;
  2528.     if (!bindData) {
  2529.       var source = fnToString.call(func);
  2530.       if (!support.funcNames) {
  2531.         bindData = !reFuncName.test(source);
  2532.       }
  2533.       if (!bindData) {
  2534.         // checks if `func` references the `this` keyword and stores the result
  2535.         bindData = reThis.test(source);
  2536.         setBindData(func, bindData);
  2537.       }
  2538.     }
  2539.   }
  2540.   // exit early if there are no `this` references or `func` is bound
  2541.   if (bindData === false || (bindData !== true && bindData[1] & 1)) {
  2542.     return func;
  2543.   }
  2544.   switch (argCount) {
  2545.     case 1: return function(value) {
  2546.       return func.call(thisArg, value);
  2547.     };
  2548.     case 2: return function(a, b) {
  2549.       return func.call(thisArg, a, b);
  2550.     };
  2551.     case 3: return function(value, index, collection) {
  2552.       return func.call(thisArg, value, index, collection);
  2553.     };
  2554.     case 4: return function(accumulator, value, index, collection) {
  2555.       return func.call(thisArg, accumulator, value, index, collection);
  2556.     };
  2557.   }
  2558.   return bind(func, thisArg);
  2559. }
  2560.  
  2561. module.exports = baseCreateCallback;
  2562.  
  2563. },{"lodash._setbinddata":20,"lodash.bind":23,"lodash.identity":35,"lodash.support":36}],20:[function(require,module,exports){
  2564. /**
  2565.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2566.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2567.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2568.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2569.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2570.  * Available under MIT license <http://lodash.com/license>
  2571.  */
  2572. var isNative = require('lodash._isnative'),
  2573.     noop = require('lodash.noop');
  2574.  
  2575. /** Used as the property descriptor for `__bindData__` */
  2576. var descriptor = {
  2577.   'configurable': false,
  2578.   'enumerable': false,
  2579.   'value': null,
  2580.   'writable': false
  2581. };
  2582.  
  2583. /** Used to set meta data on functions */
  2584. var defineProperty = (function() {
  2585.   // IE 8 only accepts DOM elements
  2586.   try {
  2587.     var o = {},
  2588.         func = isNative(func = Object.defineProperty) && func,
  2589.         result = func(o, o, o) && func;
  2590.   } catch(e) { }
  2591.   return result;
  2592. }());
  2593.  
  2594. /**
  2595.  * Sets `this` binding data on a given function.
  2596.  *
  2597.  * @private
  2598.  * @param {Function} func The function to set data on.
  2599.  * @param {Array} value The data array to set.
  2600.  */
  2601. var setBindData = !defineProperty ? noop : function(func, value) {
  2602.   descriptor.value = value;
  2603.   defineProperty(func, '__bindData__', descriptor);
  2604. };
  2605.  
  2606. module.exports = setBindData;
  2607.  
  2608. },{"lodash._isnative":21,"lodash.noop":22}],21:[function(require,module,exports){
  2609. /**
  2610.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2611.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2612.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2613.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2614.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2615.  * Available under MIT license <http://lodash.com/license>
  2616.  */
  2617.  
  2618. /** Used for native method references */
  2619. var objectProto = Object.prototype;
  2620.  
  2621. /** Used to resolve the internal [[Class]] of values */
  2622. var toString = objectProto.toString;
  2623.  
  2624. /** Used to detect if a method is native */
  2625. var reNative = RegExp('^' +
  2626.   String(toString)
  2627.     .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
  2628.     .replace(/toString| for [^\]]+/g, '.*?') + '$'
  2629. );
  2630.  
  2631. /**
  2632.  * Checks if `value` is a native function.
  2633.  *
  2634.  * @private
  2635.  * @param {*} value The value to check.
  2636.  * @returns {boolean} Returns `true` if the `value` is a native function, else `false`.
  2637.  */
  2638. function isNative(value) {
  2639.   return typeof value == 'function' && reNative.test(value);
  2640. }
  2641.  
  2642. module.exports = isNative;
  2643.  
  2644. },{}],22:[function(require,module,exports){
  2645. /**
  2646.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2647.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2648.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2649.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2650.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2651.  * Available under MIT license <http://lodash.com/license>
  2652.  */
  2653.  
  2654. /**
  2655.  * A no-operation function.
  2656.  *
  2657.  * @static
  2658.  * @memberOf _
  2659.  * @category Utilities
  2660.  * @example
  2661.  *
  2662.  * var object = { 'name': 'fred' };
  2663.  * _.noop(object) === undefined;
  2664.  * // => true
  2665.  */
  2666. function noop() {
  2667.   // no operation performed
  2668. }
  2669.  
  2670. module.exports = noop;
  2671.  
  2672. },{}],23:[function(require,module,exports){
  2673. /**
  2674.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2675.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2676.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2677.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2678.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2679.  * Available under MIT license <http://lodash.com/license>
  2680.  */
  2681. var createWrapper = require('lodash._createwrapper'),
  2682.     slice = require('lodash._slice');
  2683.  
  2684. /**
  2685.  * Creates a function that, when called, invokes `func` with the `this`
  2686.  * binding of `thisArg` and prepends any additional `bind` arguments to those
  2687.  * provided to the bound function.
  2688.  *
  2689.  * @static
  2690.  * @memberOf _
  2691.  * @category Functions
  2692.  * @param {Function} func The function to bind.
  2693.  * @param {*} [thisArg] The `this` binding of `func`.
  2694.  * @param {...*} [arg] Arguments to be partially applied.
  2695.  * @returns {Function} Returns the new bound function.
  2696.  * @example
  2697.  *
  2698.  * var func = function(greeting) {
  2699.  *   return greeting + ' ' + this.name;
  2700.  * };
  2701.  *
  2702.  * func = _.bind(func, { 'name': 'fred' }, 'hi');
  2703.  * func();
  2704.  * // => 'hi fred'
  2705.  */
  2706. function bind(func, thisArg) {
  2707.   return arguments.length > 2
  2708.     ? createWrapper(func, 17, slice(arguments, 2), null, thisArg)
  2709.     : createWrapper(func, 1, null, null, thisArg);
  2710. }
  2711.  
  2712. module.exports = bind;
  2713.  
  2714. },{"lodash._createwrapper":24,"lodash._slice":34}],24:[function(require,module,exports){
  2715. /**
  2716.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2717.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2718.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2719.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2720.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2721.  * Available under MIT license <http://lodash.com/license>
  2722.  */
  2723. var baseBind = require('lodash._basebind'),
  2724.     baseCreateWrapper = require('lodash._basecreatewrapper'),
  2725.     isFunction = require('lodash.isfunction'),
  2726.     slice = require('lodash._slice');
  2727.  
  2728. /**
  2729.  * Used for `Array` method references.
  2730.  *
  2731.  * Normally `Array.prototype` would suffice, however, using an array literal
  2732.  * avoids issues in Narwhal.
  2733.  */
  2734. var arrayRef = [];
  2735.  
  2736. /** Native method shortcuts */
  2737. var push = arrayRef.push,
  2738.     unshift = arrayRef.unshift;
  2739.  
  2740. /**
  2741.  * Creates a function that, when called, either curries or invokes `func`
  2742.  * with an optional `this` binding and partially applied arguments.
  2743.  *
  2744.  * @private
  2745.  * @param {Function|string} func The function or method name to reference.
  2746.  * @param {number} bitmask The bitmask of method flags to compose.
  2747.  *  The bitmask may be composed of the following flags:
  2748.  *  1 - `_.bind`
  2749.  *  2 - `_.bindKey`
  2750.  *  4 - `_.curry`
  2751.  *  8 - `_.curry` (bound)
  2752.  *  16 - `_.partial`
  2753.  *  32 - `_.partialRight`
  2754.  * @param {Array} [partialArgs] An array of arguments to prepend to those
  2755.  *  provided to the new function.
  2756.  * @param {Array} [partialRightArgs] An array of arguments to append to those
  2757.  *  provided to the new function.
  2758.  * @param {*} [thisArg] The `this` binding of `func`.
  2759.  * @param {number} [arity] The arity of `func`.
  2760.  * @returns {Function} Returns the new function.
  2761.  */
  2762. function createWrapper(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
  2763.   var isBind = bitmask & 1,
  2764.       isBindKey = bitmask & 2,
  2765.       isCurry = bitmask & 4,
  2766.       isCurryBound = bitmask & 8,
  2767.       isPartial = bitmask & 16,
  2768.       isPartialRight = bitmask & 32;
  2769.  
  2770.   if (!isBindKey && !isFunction(func)) {
  2771.     throw new TypeError;
  2772.   }
  2773.   if (isPartial && !partialArgs.length) {
  2774.     bitmask &= ~16;
  2775.     isPartial = partialArgs = false;
  2776.   }
  2777.   if (isPartialRight && !partialRightArgs.length) {
  2778.     bitmask &= ~32;
  2779.     isPartialRight = partialRightArgs = false;
  2780.   }
  2781.   var bindData = func && func.__bindData__;
  2782.   if (bindData && bindData !== true) {
  2783.     // clone `bindData`
  2784.     bindData = slice(bindData);
  2785.     if (bindData[2]) {
  2786.       bindData[2] = slice(bindData[2]);
  2787.     }
  2788.     if (bindData[3]) {
  2789.       bindData[3] = slice(bindData[3]);
  2790.     }
  2791.     // set `thisBinding` is not previously bound
  2792.     if (isBind && !(bindData[1] & 1)) {
  2793.       bindData[4] = thisArg;
  2794.     }
  2795.     // set if previously bound but not currently (subsequent curried functions)
  2796.     if (!isBind && bindData[1] & 1) {
  2797.       bitmask |= 8;
  2798.     }
  2799.     // set curried arity if not yet set
  2800.     if (isCurry && !(bindData[1] & 4)) {
  2801.       bindData[5] = arity;
  2802.     }
  2803.     // append partial left arguments
  2804.     if (isPartial) {
  2805.       push.apply(bindData[2] || (bindData[2] = []), partialArgs);
  2806.     }
  2807.     // append partial right arguments
  2808.     if (isPartialRight) {
  2809.       unshift.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
  2810.     }
  2811.     // merge flags
  2812.     bindData[1] |= bitmask;
  2813.     return createWrapper.apply(null, bindData);
  2814.   }
  2815.   // fast path for `_.bind`
  2816.   var creater = (bitmask == 1 || bitmask === 17) ? baseBind : baseCreateWrapper;
  2817.   return creater([func, bitmask, partialArgs, partialRightArgs, thisArg, arity]);
  2818. }
  2819.  
  2820. module.exports = createWrapper;
  2821.  
  2822. },{"lodash._basebind":25,"lodash._basecreatewrapper":29,"lodash._slice":34,"lodash.isfunction":33}],25:[function(require,module,exports){
  2823. /**
  2824.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2825.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2826.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2827.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2828.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2829.  * Available under MIT license <http://lodash.com/license>
  2830.  */
  2831. var baseCreate = require('lodash._basecreate'),
  2832.     isObject = require('lodash.isobject'),
  2833.     setBindData = require('lodash._setbinddata'),
  2834.     slice = require('lodash._slice');
  2835.  
  2836. /**
  2837.  * Used for `Array` method references.
  2838.  *
  2839.  * Normally `Array.prototype` would suffice, however, using an array literal
  2840.  * avoids issues in Narwhal.
  2841.  */
  2842. var arrayRef = [];
  2843.  
  2844. /** Native method shortcuts */
  2845. var push = arrayRef.push;
  2846.  
  2847. /**
  2848.  * The base implementation of `_.bind` that creates the bound function and
  2849.  * sets its meta data.
  2850.  *
  2851.  * @private
  2852.  * @param {Array} bindData The bind data array.
  2853.  * @returns {Function} Returns the new bound function.
  2854.  */
  2855. function baseBind(bindData) {
  2856.   var func = bindData[0],
  2857.       partialArgs = bindData[2],
  2858.       thisArg = bindData[4];
  2859.  
  2860.   function bound() {
  2861.     // `Function#bind` spec
  2862.     // http://es5.github.io/#x15.3.4.5
  2863.     if (partialArgs) {
  2864.       // avoid `arguments` object deoptimizations by using `slice` instead
  2865.       // of `Array.prototype.slice.call` and not assigning `arguments` to a
  2866.       // variable as a ternary expression
  2867.       var args = slice(partialArgs);
  2868.       push.apply(args, arguments);
  2869.     }
  2870.     // mimic the constructor's `return` behavior
  2871.     // http://es5.github.io/#x13.2.2
  2872.     if (this instanceof bound) {
  2873.       // ensure `new bound` is an instance of `func`
  2874.       var thisBinding = baseCreate(func.prototype),
  2875.           result = func.apply(thisBinding, args || arguments);
  2876.       return isObject(result) ? result : thisBinding;
  2877.     }
  2878.     return func.apply(thisArg, args || arguments);
  2879.   }
  2880.   setBindData(bound, bindData);
  2881.   return bound;
  2882. }
  2883.  
  2884. module.exports = baseBind;
  2885.  
  2886. },{"lodash._basecreate":26,"lodash._setbinddata":20,"lodash._slice":34,"lodash.isobject":47}],26:[function(require,module,exports){
  2887. (function (global){
  2888. /**
  2889.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2890.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2891.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2892.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2893.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2894.  * Available under MIT license <http://lodash.com/license>
  2895.  */
  2896. var isNative = require('lodash._isnative'),
  2897.     isObject = require('lodash.isobject'),
  2898.     noop = require('lodash.noop');
  2899.  
  2900. /* Native method shortcuts for methods with the same name as other `lodash` methods */
  2901. var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate;
  2902.  
  2903. /**
  2904.  * The base implementation of `_.create` without support for assigning
  2905.  * properties to the created object.
  2906.  *
  2907.  * @private
  2908.  * @param {Object} prototype The object to inherit from.
  2909.  * @returns {Object} Returns the new object.
  2910.  */
  2911. function baseCreate(prototype, properties) {
  2912.   return isObject(prototype) ? nativeCreate(prototype) : {};
  2913. }
  2914. // fallback for browsers without `Object.create`
  2915. if (!nativeCreate) {
  2916.   baseCreate = (function() {
  2917.     function Object() {}
  2918.     return function(prototype) {
  2919.       if (isObject(prototype)) {
  2920.         Object.prototype = prototype;
  2921.         var result = new Object;
  2922.         Object.prototype = null;
  2923.       }
  2924.       return result || global.Object();
  2925.     };
  2926.   }());
  2927. }
  2928.  
  2929. module.exports = baseCreate;
  2930.  
  2931. }).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  2932. },{"lodash._isnative":27,"lodash.isobject":47,"lodash.noop":28}],27:[function(require,module,exports){
  2933. module.exports=require(21)
  2934. },{}],28:[function(require,module,exports){
  2935. module.exports=require(22)
  2936. },{}],29:[function(require,module,exports){
  2937. /**
  2938.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  2939.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  2940.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  2941.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  2942.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  2943.  * Available under MIT license <http://lodash.com/license>
  2944.  */
  2945. var baseCreate = require('lodash._basecreate'),
  2946.     isObject = require('lodash.isobject'),
  2947.     setBindData = require('lodash._setbinddata'),
  2948.     slice = require('lodash._slice');
  2949.  
  2950. /**
  2951.  * Used for `Array` method references.
  2952.  *
  2953.  * Normally `Array.prototype` would suffice, however, using an array literal
  2954.  * avoids issues in Narwhal.
  2955.  */
  2956. var arrayRef = [];
  2957.  
  2958. /** Native method shortcuts */
  2959. var push = arrayRef.push;
  2960.  
  2961. /**
  2962.  * The base implementation of `createWrapper` that creates the wrapper and
  2963.  * sets its meta data.
  2964.  *
  2965.  * @private
  2966.  * @param {Array} bindData The bind data array.
  2967.  * @returns {Function} Returns the new function.
  2968.  */
  2969. function baseCreateWrapper(bindData) {
  2970.   var func = bindData[0],
  2971.       bitmask = bindData[1],
  2972.       partialArgs = bindData[2],
  2973.       partialRightArgs = bindData[3],
  2974.       thisArg = bindData[4],
  2975.       arity = bindData[5];
  2976.  
  2977.   var isBind = bitmask & 1,
  2978.       isBindKey = bitmask & 2,
  2979.       isCurry = bitmask & 4,
  2980.       isCurryBound = bitmask & 8,
  2981.       key = func;
  2982.  
  2983.   function bound() {
  2984.     var thisBinding = isBind ? thisArg : this;
  2985.     if (partialArgs) {
  2986.       var args = slice(partialArgs);
  2987.       push.apply(args, arguments);
  2988.     }
  2989.     if (partialRightArgs || isCurry) {
  2990.       args || (args = slice(arguments));
  2991.       if (partialRightArgs) {
  2992.         push.apply(args, partialRightArgs);
  2993.       }
  2994.       if (isCurry && args.length < arity) {
  2995.         bitmask |= 16 & ~32;
  2996.         return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]);
  2997.       }
  2998.     }
  2999.     args || (args = arguments);
  3000.     if (isBindKey) {
  3001.       func = thisBinding[key];
  3002.     }
  3003.     if (this instanceof bound) {
  3004.       thisBinding = baseCreate(func.prototype);
  3005.       var result = func.apply(thisBinding, args);
  3006.       return isObject(result) ? result : thisBinding;
  3007.     }
  3008.     return func.apply(thisBinding, args);
  3009.   }
  3010.   setBindData(bound, bindData);
  3011.   return bound;
  3012. }
  3013.  
  3014. module.exports = baseCreateWrapper;
  3015.  
  3016. },{"lodash._basecreate":30,"lodash._setbinddata":20,"lodash._slice":34,"lodash.isobject":47}],30:[function(require,module,exports){
  3017. module.exports=require(26)
  3018. },{"lodash._isnative":31,"lodash.isobject":47,"lodash.noop":32}],31:[function(require,module,exports){
  3019. module.exports=require(21)
  3020. },{}],32:[function(require,module,exports){
  3021. module.exports=require(22)
  3022. },{}],33:[function(require,module,exports){
  3023. /**
  3024.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3025.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3026.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3027.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3028.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3029.  * Available under MIT license <http://lodash.com/license>
  3030.  */
  3031.  
  3032. /**
  3033.  * Checks if `value` is a function.
  3034.  *
  3035.  * @static
  3036.  * @memberOf _
  3037.  * @category Objects
  3038.  * @param {*} value The value to check.
  3039.  * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
  3040.  * @example
  3041.  *
  3042.  * _.isFunction(_);
  3043.  * // => true
  3044.  */
  3045. function isFunction(value) {
  3046.   return typeof value == 'function';
  3047. }
  3048.  
  3049. module.exports = isFunction;
  3050.  
  3051. },{}],34:[function(require,module,exports){
  3052. /**
  3053.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3054.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3055.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3056.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3057.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3058.  * Available under MIT license <http://lodash.com/license>
  3059.  */
  3060.  
  3061. /**
  3062.  * Slices the `collection` from the `start` index up to, but not including,
  3063.  * the `end` index.
  3064.  *
  3065.  * Note: This function is used instead of `Array#slice` to support node lists
  3066.  * in IE < 9 and to ensure dense arrays are returned.
  3067.  *
  3068.  * @private
  3069.  * @param {Array|Object|string} collection The collection to slice.
  3070.  * @param {number} start The start index.
  3071.  * @param {number} end The end index.
  3072.  * @returns {Array} Returns the new array.
  3073.  */
  3074. function slice(array, start, end) {
  3075.   start || (start = 0);
  3076.   if (typeof end == 'undefined') {
  3077.     end = array ? array.length : 0;
  3078.   }
  3079.   var index = -1,
  3080.       length = end - start || 0,
  3081.       result = Array(length < 0 ? 0 : length);
  3082.  
  3083.   while (++index < length) {
  3084.     result[index] = array[start + index];
  3085.   }
  3086.   return result;
  3087. }
  3088.  
  3089. module.exports = slice;
  3090.  
  3091. },{}],35:[function(require,module,exports){
  3092. /**
  3093.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3094.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3095.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3096.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3097.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3098.  * Available under MIT license <http://lodash.com/license>
  3099.  */
  3100.  
  3101. /**
  3102.  * This method returns the first argument provided to it.
  3103.  *
  3104.  * @static
  3105.  * @memberOf _
  3106.  * @category Utilities
  3107.  * @param {*} value Any value.
  3108.  * @returns {*} Returns `value`.
  3109.  * @example
  3110.  *
  3111.  * var object = { 'name': 'fred' };
  3112.  * _.identity(object) === object;
  3113.  * // => true
  3114.  */
  3115. function identity(value) {
  3116.   return value;
  3117. }
  3118.  
  3119. module.exports = identity;
  3120.  
  3121. },{}],36:[function(require,module,exports){
  3122. (function (global){
  3123. /**
  3124.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3125.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3126.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3127.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3128.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3129.  * Available under MIT license <http://lodash.com/license>
  3130.  */
  3131. var isNative = require('lodash._isnative');
  3132.  
  3133. /** Used to detect functions containing a `this` reference */
  3134. var reThis = /\bthis\b/;
  3135.  
  3136. /**
  3137.  * An object used to flag environments features.
  3138.  *
  3139.  * @static
  3140.  * @memberOf _
  3141.  * @type Object
  3142.  */
  3143. var support = {};
  3144.  
  3145. /**
  3146.  * Detect if functions can be decompiled by `Function#toString`
  3147.  * (all but PS3 and older Opera mobile browsers & avoided in Windows 8 apps).
  3148.  *
  3149.  * @memberOf _.support
  3150.  * @type boolean
  3151.  */
  3152. support.funcDecomp = !isNative(global.WinRTError) && reThis.test(function() { return this; });
  3153.  
  3154. /**
  3155.  * Detect if `Function#name` is supported (all but IE).
  3156.  *
  3157.  * @memberOf _.support
  3158.  * @type boolean
  3159.  */
  3160. support.funcNames = typeof Function.name == 'string';
  3161.  
  3162. module.exports = support;
  3163.  
  3164. }).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  3165. },{"lodash._isnative":37}],37:[function(require,module,exports){
  3166. module.exports=require(21)
  3167. },{}],38:[function(require,module,exports){
  3168. /**
  3169.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3170.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3171.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3172.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3173.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3174.  * Available under MIT license <http://lodash.com/license>
  3175.  */
  3176. var forIn = require('lodash.forin'),
  3177.     getArray = require('lodash._getarray'),
  3178.     isFunction = require('lodash.isfunction'),
  3179.     objectTypes = require('lodash._objecttypes'),
  3180.     releaseArray = require('lodash._releasearray');
  3181.  
  3182. /** `Object#toString` result shortcuts */
  3183. var argsClass = '[object Arguments]',
  3184.     arrayClass = '[object Array]',
  3185.     boolClass = '[object Boolean]',
  3186.     dateClass = '[object Date]',
  3187.     numberClass = '[object Number]',
  3188.     objectClass = '[object Object]',
  3189.     regexpClass = '[object RegExp]',
  3190.     stringClass = '[object String]';
  3191.  
  3192. /** Used for native method references */
  3193. var objectProto = Object.prototype;
  3194.  
  3195. /** Used to resolve the internal [[Class]] of values */
  3196. var toString = objectProto.toString;
  3197.  
  3198. /** Native method shortcuts */
  3199. var hasOwnProperty = objectProto.hasOwnProperty;
  3200.  
  3201. /**
  3202.  * The base implementation of `_.isEqual`, without support for `thisArg` binding,
  3203.  * that allows partial "_.where" style comparisons.
  3204.  *
  3205.  * @private
  3206.  * @param {*} a The value to compare.
  3207.  * @param {*} b The other value to compare.
  3208.  * @param {Function} [callback] The function to customize comparing values.
  3209.  * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
  3210.  * @param {Array} [stackA=[]] Tracks traversed `a` objects.
  3211.  * @param {Array} [stackB=[]] Tracks traversed `b` objects.
  3212.  * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
  3213.  */
  3214. function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
  3215.   // used to indicate that when comparing objects, `a` has at least the properties of `b`
  3216.   if (callback) {
  3217.     var result = callback(a, b);
  3218.     if (typeof result != 'undefined') {
  3219.       return !!result;
  3220.     }
  3221.   }
  3222.   // exit early for identical values
  3223.   if (a === b) {
  3224.     // treat `+0` vs. `-0` as not equal
  3225.     return a !== 0 || (1 / a == 1 / b);
  3226.   }
  3227.   var type = typeof a,
  3228.       otherType = typeof b;
  3229.  
  3230.   // exit early for unlike primitive values
  3231.   if (a === a &&
  3232.       !(a && objectTypes[type]) &&
  3233.       !(b && objectTypes[otherType])) {
  3234.     return false;
  3235.   }
  3236.   // exit early for `null` and `undefined` avoiding ES3's Function#call behavior
  3237.   // http://es5.github.io/#x15.3.4.4
  3238.   if (a == null || b == null) {
  3239.     return a === b;
  3240.   }
  3241.   // compare [[Class]] names
  3242.   var className = toString.call(a),
  3243.       otherClass = toString.call(b);
  3244.  
  3245.   if (className == argsClass) {
  3246.     className = objectClass;
  3247.   }
  3248.   if (otherClass == argsClass) {
  3249.     otherClass = objectClass;
  3250.   }
  3251.   if (className != otherClass) {
  3252.     return false;
  3253.   }
  3254.   switch (className) {
  3255.     case boolClass:
  3256.     case dateClass:
  3257.       // coerce dates and booleans to numbers, dates to milliseconds and booleans
  3258.       // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
  3259.       return +a == +b;
  3260.  
  3261.     case numberClass:
  3262.       // treat `NaN` vs. `NaN` as equal
  3263.       return (a != +a)
  3264.         ? b != +b
  3265.         // but treat `+0` vs. `-0` as not equal
  3266.         : (a == 0 ? (1 / a == 1 / b) : a == +b);
  3267.  
  3268.     case regexpClass:
  3269.     case stringClass:
  3270.       // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
  3271.       // treat string primitives and their corresponding object instances as equal
  3272.       return a == String(b);
  3273.   }
  3274.   var isArr = className == arrayClass;
  3275.   if (!isArr) {
  3276.     // unwrap any `lodash` wrapped values
  3277.     var aWrapped = hasOwnProperty.call(a, '__wrapped__'),
  3278.         bWrapped = hasOwnProperty.call(b, '__wrapped__');
  3279.  
  3280.     if (aWrapped || bWrapped) {
  3281.       return baseIsEqual(aWrapped ? a.__wrapped__ : a, bWrapped ? b.__wrapped__ : b, callback, isWhere, stackA, stackB);
  3282.     }
  3283.     // exit for functions and DOM nodes
  3284.     if (className != objectClass) {
  3285.       return false;
  3286.     }
  3287.     // in older versions of Opera, `arguments` objects have `Array` constructors
  3288.     var ctorA = a.constructor,
  3289.         ctorB = b.constructor;
  3290.  
  3291.     // non `Object` object instances with different constructors are not equal
  3292.     if (ctorA != ctorB &&
  3293.           !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) &&
  3294.           ('constructor' in a && 'constructor' in b)
  3295.         ) {
  3296.       return false;
  3297.     }
  3298.   }
  3299.   // assume cyclic structures are equal
  3300.   // the algorithm for detecting cyclic structures is adapted from ES 5.1
  3301.   // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
  3302.   var initedStack = !stackA;
  3303.   stackA || (stackA = getArray());
  3304.   stackB || (stackB = getArray());
  3305.  
  3306.   var length = stackA.length;
  3307.   while (length--) {
  3308.     if (stackA[length] == a) {
  3309.       return stackB[length] == b;
  3310.     }
  3311.   }
  3312.   var size = 0;
  3313.   result = true;
  3314.  
  3315.   // add `a` and `b` to the stack of traversed objects
  3316.   stackA.push(a);
  3317.   stackB.push(b);
  3318.  
  3319.   // recursively compare objects and arrays (susceptible to call stack limits)
  3320.   if (isArr) {
  3321.     // compare lengths to determine if a deep comparison is necessary
  3322.     length = a.length;
  3323.     size = b.length;
  3324.     result = size == length;
  3325.  
  3326.     if (result || isWhere) {
  3327.       // deep compare the contents, ignoring non-numeric properties
  3328.       while (size--) {
  3329.         var index = length,
  3330.             value = b[size];
  3331.  
  3332.         if (isWhere) {
  3333.           while (index--) {
  3334.             if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
  3335.               break;
  3336.             }
  3337.           }
  3338.         } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
  3339.           break;
  3340.         }
  3341.       }
  3342.     }
  3343.   }
  3344.   else {
  3345.     // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
  3346.     // which, in this case, is more costly
  3347.     forIn(b, function(value, key, b) {
  3348.       if (hasOwnProperty.call(b, key)) {
  3349.         // count the number of properties.
  3350.         size++;
  3351.         // deep compare each property value.
  3352.         return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
  3353.       }
  3354.     });
  3355.  
  3356.     if (result && !isWhere) {
  3357.       // ensure both objects have the same number of properties
  3358.       forIn(a, function(value, key, a) {
  3359.         if (hasOwnProperty.call(a, key)) {
  3360.           // `size` will be `-1` if `a` has more properties than `b`
  3361.           return (result = --size > -1);
  3362.         }
  3363.       });
  3364.     }
  3365.   }
  3366.   stackA.pop();
  3367.   stackB.pop();
  3368.  
  3369.   if (initedStack) {
  3370.     releaseArray(stackA);
  3371.     releaseArray(stackB);
  3372.   }
  3373.   return result;
  3374. }
  3375.  
  3376. module.exports = baseIsEqual;
  3377.  
  3378. },{"lodash._getarray":39,"lodash._objecttypes":41,"lodash._releasearray":42,"lodash.forin":45,"lodash.isfunction":46}],39:[function(require,module,exports){
  3379. /**
  3380.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3381.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3382.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3383.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3384.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3385.  * Available under MIT license <http://lodash.com/license>
  3386.  */
  3387. var arrayPool = require('lodash._arraypool');
  3388.  
  3389. /**
  3390.  * Gets an array from the array pool or creates a new one if the pool is empty.
  3391.  *
  3392.  * @private
  3393.  * @returns {Array} The array from the pool.
  3394.  */
  3395. function getArray() {
  3396.   return arrayPool.pop() || [];
  3397. }
  3398.  
  3399. module.exports = getArray;
  3400.  
  3401. },{"lodash._arraypool":40}],40:[function(require,module,exports){
  3402. /**
  3403.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3404.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3405.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3406.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3407.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3408.  * Available under MIT license <http://lodash.com/license>
  3409.  */
  3410.  
  3411. /** Used to pool arrays and objects used internally */
  3412. var arrayPool = [];
  3413.  
  3414. module.exports = arrayPool;
  3415.  
  3416. },{}],41:[function(require,module,exports){
  3417. /**
  3418.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3419.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3420.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3421.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3422.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3423.  * Available under MIT license <http://lodash.com/license>
  3424.  */
  3425.  
  3426. /** Used to determine if values are of the language type Object */
  3427. var objectTypes = {
  3428.   'boolean': false,
  3429.   'function': true,
  3430.   'object': true,
  3431.   'number': false,
  3432.   'string': false,
  3433.   'undefined': false
  3434. };
  3435.  
  3436. module.exports = objectTypes;
  3437.  
  3438. },{}],42:[function(require,module,exports){
  3439. /**
  3440.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3441.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3442.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3443.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3444.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3445.  * Available under MIT license <http://lodash.com/license>
  3446.  */
  3447. var arrayPool = require('lodash._arraypool'),
  3448.     maxPoolSize = require('lodash._maxpoolsize');
  3449.  
  3450. /**
  3451.  * Releases the given array back to the array pool.
  3452.  *
  3453.  * @private
  3454.  * @param {Array} [array] The array to release.
  3455.  */
  3456. function releaseArray(array) {
  3457.   array.length = 0;
  3458.   if (arrayPool.length < maxPoolSize) {
  3459.     arrayPool.push(array);
  3460.   }
  3461. }
  3462.  
  3463. module.exports = releaseArray;
  3464.  
  3465. },{"lodash._arraypool":43,"lodash._maxpoolsize":44}],43:[function(require,module,exports){
  3466. module.exports=require(40)
  3467. },{}],44:[function(require,module,exports){
  3468. /**
  3469.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3470.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3471.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3472.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3473.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3474.  * Available under MIT license <http://lodash.com/license>
  3475.  */
  3476.  
  3477. /** Used as the max size of the `arrayPool` and `objectPool` */
  3478. var maxPoolSize = 40;
  3479.  
  3480. module.exports = maxPoolSize;
  3481.  
  3482. },{}],45:[function(require,module,exports){
  3483. /**
  3484.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3485.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3486.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3487.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3488.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3489.  * Available under MIT license <http://lodash.com/license>
  3490.  */
  3491. var baseCreateCallback = require('lodash._basecreatecallback'),
  3492.     objectTypes = require('lodash._objecttypes');
  3493.  
  3494. /**
  3495.  * Iterates over own and inherited enumerable properties of an object,
  3496.  * executing the callback for each property. The callback is bound to `thisArg`
  3497.  * and invoked with three arguments; (value, key, object). Callbacks may exit
  3498.  * iteration early by explicitly returning `false`.
  3499.  *
  3500.  * @static
  3501.  * @memberOf _
  3502.  * @type Function
  3503.  * @category Objects
  3504.  * @param {Object} object The object to iterate over.
  3505.  * @param {Function} [callback=identity] The function called per iteration.
  3506.  * @param {*} [thisArg] The `this` binding of `callback`.
  3507.  * @returns {Object} Returns `object`.
  3508.  * @example
  3509.  *
  3510.  * function Shape() {
  3511.  *   this.x = 0;
  3512.  *   this.y = 0;
  3513.  * }
  3514.  *
  3515.  * Shape.prototype.move = function(x, y) {
  3516.  *   this.x += x;
  3517.  *   this.y += y;
  3518.  * };
  3519.  *
  3520.  * _.forIn(new Shape, function(value, key) {
  3521.  *   console.log(key);
  3522.  * });
  3523.  * // => logs 'x', 'y', and 'move' (property order is not guaranteed across environments)
  3524.  */
  3525. var forIn = function(collection, callback, thisArg) {
  3526.   var index, iterable = collection, result = iterable;
  3527.   if (!iterable) return result;
  3528.   if (!objectTypes[typeof iterable]) return result;
  3529.   callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
  3530.     for (index in iterable) {
  3531.       if (callback(iterable[index], index, collection) === false) return result;
  3532.     }
  3533.   return result
  3534. };
  3535.  
  3536. module.exports = forIn;
  3537.  
  3538. },{"lodash._basecreatecallback":19,"lodash._objecttypes":41}],46:[function(require,module,exports){
  3539. module.exports=require(33)
  3540. },{}],47:[function(require,module,exports){
  3541. /**
  3542.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3543.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3544.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3545.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3546.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3547.  * Available under MIT license <http://lodash.com/license>
  3548.  */
  3549. var objectTypes = require('lodash._objecttypes');
  3550.  
  3551. /**
  3552.  * Checks if `value` is the language type of Object.
  3553.  * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  3554.  *
  3555.  * @static
  3556.  * @memberOf _
  3557.  * @category Objects
  3558.  * @param {*} value The value to check.
  3559.  * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
  3560.  * @example
  3561.  *
  3562.  * _.isObject({});
  3563.  * // => true
  3564.  *
  3565.  * _.isObject([1, 2, 3]);
  3566.  * // => true
  3567.  *
  3568.  * _.isObject(1);
  3569.  * // => false
  3570.  */
  3571. function isObject(value) {
  3572.   // check if the value is the ECMAScript language type of Object
  3573.   // http://es5.github.io/#x8
  3574.   // and avoid a V8 bug
  3575.   // http://code.google.com/p/v8/issues/detail?id=2291
  3576.   return !!(value && objectTypes[typeof value]);
  3577. }
  3578.  
  3579. module.exports = isObject;
  3580.  
  3581. },{"lodash._objecttypes":48}],48:[function(require,module,exports){
  3582. module.exports=require(41)
  3583. },{}],49:[function(require,module,exports){
  3584. /**
  3585.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3586.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3587.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3588.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3589.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3590.  * Available under MIT license <http://lodash.com/license>
  3591.  */
  3592. var isNative = require('lodash._isnative'),
  3593.     isObject = require('lodash.isobject'),
  3594.     shimKeys = require('lodash._shimkeys');
  3595.  
  3596. /* Native method shortcuts for methods with the same name as other `lodash` methods */
  3597. var nativeKeys = isNative(nativeKeys = Object.keys) && nativeKeys;
  3598.  
  3599. /**
  3600.  * Creates an array composed of the own enumerable property names of an object.
  3601.  *
  3602.  * @static
  3603.  * @memberOf _
  3604.  * @category Objects
  3605.  * @param {Object} object The object to inspect.
  3606.  * @returns {Array} Returns an array of property names.
  3607.  * @example
  3608.  *
  3609.  * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
  3610.  * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
  3611.  */
  3612. var keys = !nativeKeys ? shimKeys : function(object) {
  3613.   if (!isObject(object)) {
  3614.     return [];
  3615.   }
  3616.   return nativeKeys(object);
  3617. };
  3618.  
  3619. module.exports = keys;
  3620.  
  3621. },{"lodash._isnative":50,"lodash._shimkeys":51,"lodash.isobject":47}],50:[function(require,module,exports){
  3622. module.exports=require(21)
  3623. },{}],51:[function(require,module,exports){
  3624. /**
  3625.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3626.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3627.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3628.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3629.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3630.  * Available under MIT license <http://lodash.com/license>
  3631.  */
  3632. var objectTypes = require('lodash._objecttypes');
  3633.  
  3634. /** Used for native method references */
  3635. var objectProto = Object.prototype;
  3636.  
  3637. /** Native method shortcuts */
  3638. var hasOwnProperty = objectProto.hasOwnProperty;
  3639.  
  3640. /**
  3641.  * A fallback implementation of `Object.keys` which produces an array of the
  3642.  * given object's own enumerable property names.
  3643.  *
  3644.  * @private
  3645.  * @type Function
  3646.  * @param {Object} object The object to inspect.
  3647.  * @returns {Array} Returns an array of property names.
  3648.  */
  3649. var shimKeys = function(object) {
  3650.   var index, iterable = object, result = [];
  3651.   if (!iterable) return result;
  3652.   if (!(objectTypes[typeof object])) return result;
  3653.     for (index in iterable) {
  3654.       if (hasOwnProperty.call(iterable, index)) {
  3655.         result.push(index);
  3656.       }
  3657.     }
  3658.   return result
  3659. };
  3660.  
  3661. module.exports = shimKeys;
  3662.  
  3663. },{"lodash._objecttypes":52}],52:[function(require,module,exports){
  3664. module.exports=require(41)
  3665. },{}],53:[function(require,module,exports){
  3666. /**
  3667.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3668.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3669.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3670.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3671.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3672.  * Available under MIT license <http://lodash.com/license>
  3673.  */
  3674.  
  3675. /**
  3676.  * Creates a "_.pluck" style function, which returns the `key` value of a
  3677.  * given object.
  3678.  *
  3679.  * @static
  3680.  * @memberOf _
  3681.  * @category Utilities
  3682.  * @param {string} key The name of the property to retrieve.
  3683.  * @returns {Function} Returns the new function.
  3684.  * @example
  3685.  *
  3686.  * var characters = [
  3687.  *   { 'name': 'fred',   'age': 40 },
  3688.  *   { 'name': 'barney', 'age': 36 }
  3689.  * ];
  3690.  *
  3691.  * var getName = _.property('name');
  3692.  *
  3693.  * _.map(characters, getName);
  3694.  * // => ['barney', 'fred']
  3695.  *
  3696.  * _.sortBy(characters, getName);
  3697.  * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred',   'age': 40 }]
  3698.  */
  3699. function property(key) {
  3700.   return function(object) {
  3701.     return object[key];
  3702.   };
  3703. }
  3704.  
  3705. module.exports = property;
  3706.  
  3707. },{}],54:[function(require,module,exports){
  3708. /**
  3709.  * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/>
  3710.  * Build: `lodash modularize modern exports="npm" -o ./npm/`
  3711.  * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
  3712.  * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
  3713.  * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  3714.  * Available under MIT license <http://lodash.com/license>
  3715.  */
  3716. var baseCreateCallback = require('lodash._basecreatecallback'),
  3717.     keys = require('lodash.keys'),
  3718.     objectTypes = require('lodash._objecttypes');
  3719.  
  3720. /**
  3721.  * Iterates over own enumerable properties of an object, executing the callback
  3722.  * for each property. The callback is bound to `thisArg` and invoked with three
  3723.  * arguments; (value, key, object). Callbacks may exit iteration early by
  3724.  * explicitly returning `false`.
  3725.  *
  3726.  * @static
  3727.  * @memberOf _
  3728.  * @type Function
  3729.  * @category Objects
  3730.  * @param {Object} object The object to iterate over.
  3731.  * @param {Function} [callback=identity] The function called per iteration.
  3732.  * @param {*} [thisArg] The `this` binding of `callback`.
  3733.  * @returns {Object} Returns `object`.
  3734.  * @example
  3735.  *
  3736.  * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
  3737.  *   console.log(key);
  3738.  * });
  3739.  * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
  3740.  */
  3741. var forOwn = function(collection, callback, thisArg) {
  3742.   var index, iterable = collection, result = iterable;
  3743.   if (!iterable) return result;
  3744.   if (!objectTypes[typeof iterable]) return result;
  3745.   callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
  3746.     var ownIndex = -1,
  3747.         ownProps = objectTypes[typeof iterable] && keys(iterable),
  3748.         length = ownProps ? ownProps.length : 0;
  3749.  
  3750.     while (++ownIndex < length) {
  3751.       index = ownProps[ownIndex];
  3752.       if (callback(iterable[index], index, collection) === false) return result;
  3753.     }
  3754.   return result
  3755. };
  3756.  
  3757. module.exports = forOwn;
  3758.  
  3759. },{"lodash._basecreatecallback":55,"lodash._objecttypes":76,"lodash.keys":77}],55:[function(require,module,exports){
  3760. module.exports=require(19)
  3761. },{"lodash._setbinddata":56,"lodash.bind":59,"lodash.identity":73,"lodash.support":74}],56:[function(require,module,exports){
  3762. module.exports=require(20)
  3763. },{"lodash._isnative":57,"lodash.noop":58}],57:[function(require,module,exports){
  3764. module.exports=require(21)
  3765. },{}],58:[function(require,module,exports){
  3766. module.exports=require(22)
  3767. },{}],59:[function(require,module,exports){
  3768. module.exports=require(23)
  3769. },{"lodash._createwrapper":60,"lodash._slice":72}],60:[function(require,module,exports){
  3770. module.exports=require(24)
  3771. },{"lodash._basebind":61,"lodash._basecreatewrapper":66,"lodash._slice":72,"lodash.isfunction":71}],61:[function(require,module,exports){
  3772. module.exports=require(25)
  3773. },{"lodash._basecreate":62,"lodash._setbinddata":56,"lodash._slice":72,"lodash.isobject":65}],62:[function(require,module,exports){
  3774. module.exports=require(26)
  3775. },{"lodash._isnative":63,"lodash.isobject":65,"lodash.noop":64}],63:[function(require,module,exports){
  3776. module.exports=require(21)
  3777. },{}],64:[function(require,module,exports){
  3778. module.exports=require(22)
  3779. },{}],65:[function(require,module,exports){
  3780. module.exports=require(47)
  3781. },{"lodash._objecttypes":76}],66:[function(require,module,exports){
  3782. module.exports=require(29)
  3783. },{"lodash._basecreate":67,"lodash._setbinddata":56,"lodash._slice":72,"lodash.isobject":70}],67:[function(require,module,exports){
  3784. module.exports=require(26)
  3785. },{"lodash._isnative":68,"lodash.isobject":70,"lodash.noop":69}],68:[function(require,module,exports){
  3786. module.exports=require(21)
  3787. },{}],69:[function(require,module,exports){
  3788. module.exports=require(22)
  3789. },{}],70:[function(require,module,exports){
  3790. module.exports=require(47)
  3791. },{"lodash._objecttypes":76}],71:[function(require,module,exports){
  3792. module.exports=require(33)
  3793. },{}],72:[function(require,module,exports){
  3794. module.exports=require(34)
  3795. },{}],73:[function(require,module,exports){
  3796. module.exports=require(35)
  3797. },{}],74:[function(require,module,exports){
  3798. module.exports=require(36)
  3799. },{"lodash._isnative":75}],75:[function(require,module,exports){
  3800. module.exports=require(21)
  3801. },{}],76:[function(require,module,exports){
  3802. module.exports=require(41)
  3803. },{}],77:[function(require,module,exports){
  3804. module.exports=require(49)
  3805. },{"lodash._isnative":78,"lodash._shimkeys":79,"lodash.isobject":80}],78:[function(require,module,exports){
  3806. module.exports=require(21)
  3807. },{}],79:[function(require,module,exports){
  3808. module.exports=require(51)
  3809. },{"lodash._objecttypes":76}],80:[function(require,module,exports){
  3810. module.exports=require(47)
  3811. },{"lodash._objecttypes":76}]},{},[1])