Deployed the page to Github Pages.

node_modules/firebase-tools/LICENSE

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

node_modules/firebase-tools/README.md

@@ -0,0 +1,43 @@
+# firebase-tools
+
+[![Build Status](https://travis-ci.org/firebase/firebase-tools.svg?branch=master)](https://travis-ci.org/firebase/firebase-tools)
+[![Coverage Status](https://img.shields.io/coveralls/firebase/firebase-tools.svg?branch=master&style=flat)](https://coveralls.io/r/firebase/firebase-tools)
+[![NPM version](https://badge.fury.io/js/firebase-tools.svg)](http://badge.fury.io/js/firebase-tools)
+
+These are the Firebase Command Line (CLI) Tools. They can be used to:
+
+* Administer your Firebase account
+* Interact with [Firebase Hosting](https://www.firebase.com/hosting.html), our product to host your
+static HTML, JS, CSS, images, etc.
+
+To get started with the Firebase CLI, [read through our hosting quickstart guide](https://www.firebase.com/docs/hosting.html).
+
+
+## Installation
+
+To install the Firebase CLI, you first need to [sign up for a Firebase account](https://www.firebase.com/signup/).
+
+Then you need to install [Node.js](http://nodejs.org/) and [npm](https://npmjs.org/). Note that
+installing Node.js should install npm as well.
+
+Once npm is installed, get the Firebase CLI by running the following command:
+
+```bash
+npm install -g firebase-tools
+```
+
+This will provide you with the globally accessible `firebase` command.
+
+
+## Commands
+
+The command `firebase --help` lists the available commands and `firebase <command> --help` shows
+more details for an individual command.
+
+You can get more information about the available commands in our
+[command line documentation](https://www.firebase.com/docs/hosting/command-line-tool.html).
+
+
+## Credit
+
+Inspired by [Luke Vivier](https://github.com/lvivier/)'s Firebase command line tools.

node_modules/firebase-tools/lib/api.js

@@ -0,0 +1,92 @@
+var request = require('request'),
+    url = require('url'),
+    querystring = require('querystring');
+
+var api = {
+  realtimeUrl: 'https://firebaseio.com',
+  adminUrl: 'https://admin.firebase.com',
+  uploadUrl: 'https://hosting.firebase.com',
+  hostingUrl: 'https://firebaseapp.com',
+  request: function(method, resource, data, authenticate, callback) {
+
+    // Runtime fetch of Auth singleton to prevent circular module dependencies
+    var auth = require('./auth');
+
+    if ((typeof(data) === 'undefined') || !data) {
+      data = {};
+    }
+
+    if ((typeof(authenticate) !== 'undefined') && (authenticate)) {
+      data.token = auth.token;
+    }
+
+    var validMethods = ['GET', 'PUT', 'POST', 'DELETE'];
+
+    if (validMethods.indexOf(method) < 0) {
+      method = 'GET';
+    }
+
+    var options = {
+      method: method,
+      json: true
+    };
+
+    var dataString = '';
+
+    if (method === 'GET') {
+      dataString = querystring.stringify(data);
+      var separator = resource.match(/\?/) ? '&' : '?';
+      resource += separator + dataString;
+    } else if (Object.keys(data).length > 0) {
+      options.body = JSON.stringify(data, null, 2);
+    }
+
+    options.url = this.adminUrl + resource;
+
+    request(options, function(err, response, body) {
+      if (err) {
+        console.log('SERVER ERROR'.red + ' - Please try again');
+        process.exit(1);
+      }
+      setTimeout(callback, 0, response.statusCode, body);
+    });
+  },
+  setRules: function(firebase, rules, authToken, callback) {
+    request({
+      url: api.realtimeUrl.replace(/\/\//, '//' + firebase + '.') + '/.settings/rules.json?auth=' + authToken,
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: rules
+    }, function(err, response, body) {
+      if (err) {
+        console.log('SERVER ERROR'.red + ' - Please try again');
+        process.exit(1);
+      }
+      setTimeout(callback, 0, response.statusCode, body && JSON.parse(body));
+    });
+  }
+};
+
+function possiblyOverride(apiVariable, envVariable) {
+  if (typeof(process.env[envVariable]) !== 'undefined') {
+    var urlParts = null;
+    try {
+      urlParts = url.parse(process.env[envVariable]);
+    } catch (err) {
+      urlParts = null;
+    }
+
+    if (urlParts) {
+      api[apiVariable] = process.env[envVariable];
+    }
+  }
+}
+
+possiblyOverride('adminUrl', 'FIREBASE_ADMIN_URL');
+possiblyOverride('hostingUrl', 'FIREBASE_HOSTING_URL');
+possiblyOverride('realtimeUrl', 'FIREBASE_REALTIME_URL');
+possiblyOverride('uploadUrl', 'FIREBASE_UPLOAD_URL');
+
+module.exports = api;

node_modules/firebase-tools/lib/auth.js

@@ -0,0 +1,329 @@
+var prompt = require('prompt'),
+    fs = require('fs'),
+    path = require('path'),
+    api = require('./api'),
+    util = require('util'),
+    chalk = require('chalk'),
+    _when = require('when');
+
+var auth = {
+  configFile: path.join(
+                (process.env.HOME || process.env.USERPROFILE),
+                '.firebaserc'
+              ),
+  maxRetries: 3,
+  requireLogin: function(argv, callback) {
+    var that = this;
+
+    if (argv.email && argv.password) {
+      this._attemptLogin(argv, this.maxRetries, callback);
+    } else if ((this.email.length === 0) || (this.token.length === 0)) {
+      console.log('Please sign into your Firebase account to continue...');
+      this._attemptLogin(argv, this.maxRetries, callback);
+    } else {
+      this._validate(function(err) {
+        if (err) {
+          console.log('Please sign into your Firebase account to continue...');
+          that._attemptLogin(argv, that.maxRetries, callback);
+        } else {
+          setTimeout(callback, 0, null, that.email, that.token);
+        }
+      });
+    }
+  },
+  _validate: function(callback) {
+    api.request(
+      'GET',
+      '/token/validate',
+      {
+        cli: require('./firebase').version
+      },
+      true,
+      function(statusCode, response) {
+        if (typeof(callback) === 'function') {
+          if (typeof(response.error) !== 'undefined') {
+            console.log(chalk.red(response.error.message) + ' - Please update to at ' +
+                          'least v' + response.minCLI + ' by running ' +
+                          chalk.cyan('npm update -g ' + require('./firebase').name));
+            process.exit(1);
+          } else if (response.valid) {
+            setTimeout(callback, 0, null);
+          } else {
+            setTimeout(callback, 0, new Error('Invalid Access Token'));
+          }
+        }
+      }
+    );
+  },
+  login: function(argv, callback) {
+    this._attemptLogin(argv, this.maxRetries, callback);
+  },
+  _attemptLogin: function(argv, tries, callback) {
+    var that = this;
+    if (tries > 0) {
+      if (tries !== this.maxRetries) {
+        if (argv.silent) {
+          console.log(chalk.red('Input Error') + ' - Email or password incorrect');
+          process.exit(1);
+        }
+        console.log('Email or password incorrect, please try again');
+        delete prompt.override.email;
+        delete prompt.override.password;
+      }
+      this._loginRequest(argv, function(err, email, token) {
+        if (err) {
+          that._attemptLogin(argv, tries - 1, callback);
+        } else {
+          setTimeout(callback, 0, null, email, token);
+        }
+      });
+    } else {
+      console.log(chalk.red('Login Unsuccessful'));
+      process.exit(1);
+    }
+  },
+  _loginRequest: function(argv, callback) {
+    var that = this,
+        schema = [
+            {
+              name: 'email',
+              description: 'Email:',
+              pattern: /@/,
+              message: 'Must be a valid email address',
+              required: true,
+              type: 'string'
+            },{
+              name: 'password',
+              description: 'Password:',
+              hidden: true,
+              required: true,
+              type: 'string'
+            }
+        ];
+
+    if (this.email.length > 0) {
+      schema[0].default = this.email;
+    }
+
+    if (argv.silent) {
+      for (var i in schema) {
+        var item = schema[i];
+        if (!prompt.override[item.name] || (item.pattern && !item.pattern.test(prompt.override[item.name]))) {
+          console.log(chalk.red('Input Error') + ' - Not enough or invalid parameters specified while in silent mode');
+          console.log('Required ' + chalk.bold(item.name) + ' parameter missing or invalid');
+          process.exit(1);
+        }
+      }
+    }
+
+    prompt.get(schema, function(err, result) {
+      if (err) {
+        if (typeof(callback) === 'function') {
+          setTimeout(callback, 0, new Error('Error Getting User Input'));
+        }
+        return;
+      }
+      that.email = result.email;
+      that._authenticate.bind(that)(result.email, result.password, callback);
+    });
+  },
+  _authenticate: function(email, password, callback) {
+    var data = {
+      email: email,
+      password: password,
+      rememberMe: true,
+      cli: require('./firebase').version
+    };
+    api.request(
+      'GET',
+      '/account/login',
+      data,
+      false,
+      this._handleLogin.bind(this, callback)
+    );
+  },
+  _handleLogin: function(callback, statusCode, response) {
+    var token = response.adminToken;
+    if (token) {
+      this.token = token;
+      this.saveConfig(callback);
+    } else if (typeof(response.error) !== 'undefined') {
+      if (typeof(response.minCLI) === 'undefined') {
+        if (typeof(callback) === 'function') {
+          setTimeout(callback, 0, new Error('Email or Password Invalid'));
+        }
+      } else {
+        console.log(chalk.red(response.error.message) + ' - Please update to at ' +
+                      'least v' + response.minCLI + ' by running ' +
+                      chalk.cyan('npm update -g ' + require('./firebase').name));
+        process.exit(1);
+      }
+    }
+  },
+  saveConfig: function(callback) {
+    var data = {
+      email: this.email,
+      token: this.token
+    };
+    var dataString = JSON.stringify(data, null, 2) + '\n';
+    try {
+      fs.writeFileSync(this.configFile, dataString);
+    } catch (err) {
+      if (typeof(callback) === 'function') {
+        setTimeout(callback, 0, new Error('Could Not Save Settings'));
+      }
+      return;
+    }
+    if (typeof(callback) === 'function') {
+      setTimeout(callback, 0, null, this.email, this.token);
+    }
+  },
+  logout: function(deleteSettings, callback) {
+    var that = this;
+    this._invalidateToken(function(err) {
+      if (err) {
+        setTimeout(callback, 0, err);
+      }
+      if (deleteSettings) {
+        try {
+          fs.unlinkSync(that.configFile);
+        } catch (e) {
+          setTimeout(callback, 0, e);
+          return;
+        }
+        setTimeout(callback, 0, null);
+      } else {
+        that.token = '';
+        that.saveConfig(callback);
+      }
+    });
+  },
+  _invalidateToken: function(callback) {
+    if (this.token.length > 0) {
+      var url = '/account/token';
+      api.request('DELETE', url, {}, true, function(statusCode, response) {
+        setTimeout(callback, 0, null);
+      });
+    } else {
+      if (typeof(callback) === 'function') {
+        setTimeout(callback, 0, null);
+      }
+    }
+  },
+  checkCanAccess: function(firebase, callback) {
+    var url = '/firebase/' + firebase + '/token';
+    api.request('GET', url, {}, true, function(statusCode, response) {
+      if (!response.error) {
+        setTimeout(callback, 0, null, response);
+      } else {
+        setTimeout(callback, 0, new Error('Permission Denied'));
+      }
+    });
+  },
+  updateRules: function(firebase, authToken, rules, callback) {
+    var rulesString;
+    if (rules) {
+      if (!fs.existsSync(rules)) {
+        console.log(chalk.red('Security Rules Error') + ' - specified security' +
+                          ' rules file does not exist');
+        process.exit(1);
+      }
+      try {
+        rulesString = fs.readFileSync(rules, 'utf8');
+      } catch (err) {
+        console.log(chalk.red('Security Rules Error') + ' - couldn\'t read security ' +
+                          'rules');
+        process.exit(1);
+      }
+      if (rulesString.length === 0) {
+        console.log(chalk.red('Security Rules Error') + ' - couldn\'t read security ' +
+                          'rules');
+        process.exit(1);
+      }
+      console.log('Updating security rules...');
+      api.setRules(firebase, rulesString, authToken, callback);
+    } else {
+      setTimeout(callback, 0, 200, {});
+    }
+  },
+  getFirebases: function(callback) {
+    api.request('GET', '/account', {}, true, function(statusCode, response) {
+      if (typeof(response.firebases) !== 'undefined') {
+        var firebases = [];
+        for (var firebase in response.firebases) {
+          if (response.firebases.hasOwnProperty(firebase)) {
+            firebases.push(firebase);
+          }
+        }
+        if (typeof(callback) !== 'undefined') {
+          setTimeout(callback, 0, null, firebases);
+        }
+      } else {
+        if (typeof(callback) !== 'undefined') {
+          setTimeout(callback, 0, new Error('Could not get list of Firebases'));
+        }
+      }
+    });
+  },
+  getConfig: function() {
+    var config = {};
+    var data = fs.readFileSync(this.configFile, 'utf8');
+    try {
+      config = JSON.parse(data);
+    } catch (e) {}
+    return config;
+  },
+  listFirebases: function(argv) {
+    return _when.promise(function(resolve, reject, notify) {
+      auth.requireLogin(argv, function(err) {
+        if (err) {
+          var error = new Error('Login Unsuccessful');
+              error.type = 'LOGIN';
+          reject(error);
+       } else {
+          auth.getFirebases(function(err, firebases) {
+            if (err) {
+              var error = new Error('Could Not List Firebases');
+                  error.type = 'ACCOUNT';
+              reject(error);
+            } else {
+              resolve({
+                firebases: firebases,
+                showFirebases: function() {
+                  console.log(chalk.yellow('----------------------------------------------------'));
+                  console.log(chalk.yellow(util.format('Your Firebase Apps %s', auth.email)));
+                  console.log(chalk.yellow('----------------------------------------------------'));
+                  console.log(firebases.join('\n'));
+                  console.log(chalk.yellow('----------------------------------------------------'));
+                }
+              });
+            }
+          });
+        }
+      });
+    });
+  }
+};
+
+function initAuth() {
+  try {
+    var config = auth.getConfig();
+    if (typeof(config.token) === 'string') {
+      auth.token = config.token;
+    } else {
+      auth.token = '';
+    }
+    if (typeof(config.email) === 'string') {
+      auth.email = config.email;
+    } else {
+      auth.email = '';
+    }
+  } catch (err) {
+    auth.token = '';
+    auth.email = '';
+  }
+}
+
+initAuth();
+
+module.exports = auth;

node_modules/firebase-tools/node_modules/ansi-styles/index.js

@@ -0,0 +1,40 @@
+'use strict';
+var styles = module.exports;
+
+var codes = {
+	reset: [0, 0],
+
+	bold: [1, 22], // 21 isn't widely supported and 22 does the same thing
+	dim: [2, 22],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49]
+};
+
+Object.keys(codes).forEach(function (key) {
+	var val = codes[key];
+	var style = styles[key] = {};
+	style.open = '\u001b[' + val[0] + 'm';
+	style.close = '\u001b[' + val[1] + 'm';
+});

node_modules/firebase-tools/node_modules/ansi-styles/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "ansi-styles",
+  "version": "1.1.0",
+  "description": "ANSI escape codes for styling strings in the terminal",
+  "license": "MIT",
+  "repository": "sindresorhus/ansi-styles",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "http://sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "ansi",
+    "styles",
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "tty",
+    "escape",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "devDependencies": {
+    "mocha": "*"
+  }
+}

node_modules/firebase-tools/node_modules/ansi-styles/readme.md

@@ -0,0 +1,70 @@
+# ansi-styles [![Build Status](https://travis-ci.org/sindresorhus/ansi-styles.svg?branch=master)](https://travis-ci.org/sindresorhus/ansi-styles)
+
+> [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/sindresorhus/chalk) module for styling your strings.
+
+![screenshot](screenshot.png)
+
+
+## Install
+
+```sh
+$ npm install --save ansi-styles
+```
+
+
+## Usage
+
+```js
+var ansi = require('ansi-styles');
+
+console.log(ansi.green.open + 'Hello world!' + ansi.green.close);
+```
+
+
+## API
+
+Each style has an `open` and `close` property.
+
+
+## Styles
+
+### General
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(not widely supported)*
+
+### Text colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `gray`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)

node_modules/firebase-tools/node_modules/chalk/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "chalk",
+  "version": "0.5.1",
+  "description": "Terminal string styling done right. Created because the `colors` module does some really horrible things.",
+  "license": "MIT",
+  "repository": "sindresorhus/chalk",
+  "maintainers": [
+    "Sindre Sorhus <sindresorhus@gmail.com> (http://sindresorhus.com)",
+    "Joshua Appelman <joshua@jbna.nl>"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "bench": "matcha benchmark.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "string",
+    "ansi",
+    "styles",
+    "tty",
+    "formatting",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "log",
+    "logging",
+    "command-line",
+    "text"
+  ],
+  "dependencies": {
+    "ansi-styles": "^1.1.0",
+    "escape-string-regexp": "^1.0.0",
+    "has-ansi": "^0.1.0",
+    "strip-ansi": "^0.3.0",
+    "supports-color": "^0.2.0"
+  },
+  "devDependencies": {
+    "matcha": "^0.5.0",
+    "mocha": "*"
+  }
+}

node_modules/firebase-tools/node_modules/chalk/readme.md

@@ -0,0 +1,175 @@
+# <img width="300" src="https://cdn.rawgit.com/sindresorhus/chalk/77ae94f63ab1ac61389b190e5a59866569d1a376/logo.svg" alt="chalk">
+
+> Terminal string styling done right
+
+[![Build Status](https://travis-ci.org/sindresorhus/chalk.svg?branch=master)](https://travis-ci.org/sindresorhus/chalk)
+![](http://img.shields.io/badge/unicorn-approved-ff69b4.svg)
+
+[colors.js](https://github.com/Marak/colors.js) is currently the most popular string styling module, but it has serious deficiencies like extending String.prototype which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68). Although there are other ones, they either do too much or not enough.
+
+**Chalk is a clean and focused alternative.**
+
+![screenshot](https://github.com/sindresorhus/ansi-styles/raw/master/screenshot.png)
+
+
+## Why
+
+- Highly performant
+- Doesn't extend String.prototype
+- Expressive API
+- Ability to nest styles
+- Clean and focused
+- Auto-detects color support
+- Actively maintained
+- [Used by 1000+ modules](https://npmjs.org/browse/depended/chalk)
+
+
+## Install
+
+```sh
+$ npm install --save chalk
+```
+
+
+## Usage
+
+Chalk comes with an easy to use composable API where you just chain and nest the styles you want.
+
+```js
+var chalk = require('chalk');
+
+// style a string
+console.log(  chalk.blue('Hello world!')  );
+
+// combine styled and normal strings
+console.log(  chalk.blue('Hello'), 'World' + chalk.red('!')  );
+
+// compose multiple styles using the chainable API
+console.log(  chalk.blue.bgRed.bold('Hello world!')  );
+
+// pass in multiple arguments
+console.log(  chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz')  );
+
+// nest styles
+console.log(  chalk.red('Hello', chalk.underline.bgBlue('world') + '!')  );
+
+// nest styles of the same type even (color, underline, background)
+console.log(  chalk.green('I am a green line ' + chalk.blue('with a blue substring') + ' that becomes green again!')  );
+```
+
+Easily define your own themes.
+
+```js
+var chalk = require('chalk');
+var error = chalk.bold.red;
+console.log(error('Error!'));
+```
+
+Take advantage of console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data).
+
+```js
+var name = 'Sindre';
+console.log(chalk.green('Hello %s'), name);
+//=> Hello Sindre
+```
+
+
+## API
+
+### chalk.`<style>[.<style>...](string, [string...])`
+
+Example: `chalk.red.bold.underline('Hello', 'world');`
+
+Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter.
+
+Multiple arguments will be separated by space.
+
+### chalk.enabled
+
+Color support is automatically detected, but you can override it.
+
+### chalk.supportsColor
+
+Detect whether the terminal [supports color](https://github.com/sindresorhus/supports-color).
+
+Can be overridden by the user with the flags `--color` and `--no-color`.
+
+Used internally and handled for you, but exposed for convenience.
+
+### chalk.styles
+
+Exposes the styles as [ANSI escape codes](https://github.com/sindresorhus/ansi-styles).
+
+Generally not useful, but you might need just the `.open` or `.close` escape code if you're mixing externally styled strings with yours.
+
+```js
+var chalk = require('chalk');
+
+console.log(chalk.styles.red);
+//=> {open: '\u001b[31m', close: '\u001b[39m'}
+
+console.log(chalk.styles.red.open + 'Hello' + chalk.styles.red.close);
+```
+
+### chalk.hasColor(string)
+
+Check whether a string [has color](https://github.com/sindresorhus/has-ansi).
+
+### chalk.stripColor(string)
+
+[Strip color](https://github.com/sindresorhus/strip-ansi) from a string.
+
+Can be useful in combination with `.supportsColor` to strip color on externally styled text when it's not supported.
+
+Example:
+
+```js
+var chalk = require('chalk');
+var styledString = getText();
+
+if (!chalk.supportsColor) {
+	styledString = chalk.stripColor(styledString);
+}
+```
+
+
+## Styles
+
+### General
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(not widely supported)*
+
+### Text colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `gray`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)

node_modules/firebase-tools/node_modules/open/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "open",
+  "version": "0.0.5",
+  "description": "open a file or url in the user's preferred application",
+  "keywords": ["start", "open", "browser", "editor", "default"],
+  "homepage": "https://github.com/jjrdn/node-open",
+  "author": "J Jordan <jjrdn@styosis.com>",
+  "license": "MIT",
+  "contributors": [
+    "Victor Costan <victor@costan.us> (http://www.costan.us)"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pwnall/node-open.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pwnall/node-open/issues"
+  },
+  "engines": {
+    "node": ">= 0.6.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "*"
+  },
+  "optionalDependencies": {},
+  "main": "lib/open.js",
+  "scripts": {
+    "test": "node_modules/mocha/bin/mocha"
+  }
+}

node_modules/firebase-tools/node_modules/supports-color/index.js

@@ -0,0 +1,32 @@
+'use strict';
+module.exports = (function () {
+	if (process.argv.indexOf('--no-color') !== -1) {
+		return false;
+	}
+
+	if (process.argv.indexOf('--color') !== -1) {
+		return true;
+	}
+
+	if (process.stdout && !process.stdout.isTTY) {
+		return false;
+	}
+
+	if (process.platform === 'win32') {
+		return true;
+	}
+
+	if ('COLORTERM' in process.env) {
+		return true;
+	}
+
+	if (process.env.TERM === 'dumb') {
+		return false;
+	}
+
+	if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(process.env.TERM)) {
+		return true;
+	}
+
+	return false;
+})();

node_modules/firebase-tools/node_modules/supports-color/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "supports-color",
+  "version": "0.2.0",
+  "description": "Detect whether a terminal supports color",
+  "license": "MIT",
+  "repository": "sindresorhus/supports-color",
+  "bin": {
+    "supports-color": "cli.js"
+  },
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "http://sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "files": [
+    "index.js",
+    "cli.js"
+  ],
+  "keywords": [
+    "cli",
+    "bin",
+    "color",
+    "colour",
+    "colors",
+    "terminal",
+    "console",
+    "cli",
+    "ansi",
+    "styles",
+    "tty",
+    "rgb",
+    "256",
+    "shell",
+    "xterm",
+    "command-line",
+    "support",
+    "supports",
+    "capability",
+    "detect"
+  ],
+  "devDependencies": {
+    "mocha": "*"
+  }
+}

node_modules/firebase-tools/node_modules/supports-color/readme.md

@@ -0,0 +1,44 @@
+# supports-color [![Build Status](https://travis-ci.org/sindresorhus/supports-color.svg?branch=master)](https://travis-ci.org/sindresorhus/supports-color)
+
+> Detect whether a terminal supports color
+
+
+## Install
+
+```sh
+$ npm install --save supports-color
+```
+
+
+## Usage
+
+```js
+var supportsColor = require('supports-color');
+
+if (supportsColor) {
+	console.log('Terminal supports color');
+}
+```
+
+It obeys the `--color` and `--no-color` CLI flags.
+
+
+## CLI
+
+```sh
+$ npm install --global supports-color
+```
+
+```sh
+$ supports-color --help
+
+Usage
+  $ supports-color
+
+# Exits with code 0 if color is supported and 1 if not
+```
+
+
+## License
+
+MIT © [Sindre Sorhus](http://sindresorhus.com)

node_modules/firebase-tools/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "firebase-tools",
+  "description": "Firebase command line tools",
+  "version": "1.2.0",
+  "author": "Firebase <support@firebase.com> (https://www.firebase.com/)",
+  "homepage": "https://github.com/firebase/firebase-tools/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/firebase/firebase-tools.git"
+  },
+  "bugs": {
+    "url": "https://github.com/firebase/firebase-tools/issues"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://firebase.mit-license.org/"
+    }
+  ],
+  "keywords": [
+    "cdn",
+    "cli",
+    "ssl",
+    "cloud",
+    "hosting",
+    "firebase",
+    "realtime",
+    "websockets",
+    "synchronization"
+  ],
+  "preferGlobal": true,
+  "bin": {
+    "firebase": "./bin/firebase"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "engineStrict": true,
+  "files": [
+    "bin/**",
+    "lib/**",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "chalk": "0.5.x",
+    "filesize": "3.1.2",
+    "firebase": "2.2.x",
+    "fstream-ignore": "1.0.x",
+    "open": "0.0.x",
+    "optimist": "0.6.x",
+    "progress": "1.1.x",
+    "prompt": "0.2.x",
+    "request": "2.51.x",
+    "source-map-support": "0.2.7",
+    "source-processor": "0.0.7",
+    "tar": "1.0.x",
+    "when": "3.6.x"
+  },
+  "devDependencies": {
+    "chai": "^1.10.0",
+    "coveralls": "2.11.2",
+    "gulp": "3.8.10",
+    "gulp-exit": "0.0.2",
+    "gulp-istanbul": "0.5.0",
+    "gulp-jshint": "1.9.0",
+    "gulp-mocha": "2.0.0",
+    "jshint-stylish": "1.0.0"
+  },
+  "scripts": {
+    "test": "gulp test",
+    "travis": "gulp"
+  }
+}