react app

react-app/node_modules/json5/.editorconfig

@@ -0,0 +1,8 @@
+# Don't allow rules from further up the tree.
+root = true
+
+[*]                             # Every file
+end_of_line = lf                # Unix sytle line endings
+insert_final_newline = true     # Ensure a new line at the end of each file
+indent_style = space            # Use spaces instead of tabs
+indent_size = 4                 # Indent 4 spaces

react-app/node_modules/json5/.npmignore

@@ -0,0 +1,2 @@
+node_modules
+npm-debug.log

react-app/node_modules/json5/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "0.6"
+  - "0.8"
+  - "0.10"

react-app/node_modules/json5/CHANGELOG.md

@@ -0,0 +1,144 @@
+### Unreleased [[code][cNew], [diff][dNew]]
+
+[cNew]: https://github.com/aseemk/json5/tree/develop
+[dNew]: https://github.com/aseemk/json5/compare/master...develop
+
+
+### v0.4.0 [[code][c0.4.0], [diff][d0.4.0]]
+
+[c0.4.0]: https://github.com/aseemk/json5/tree/v0.4.0
+[d0.4.0]: https://github.com/aseemk/json5/compare/v0.2.0...v0.4.0
+
+Note that v0.3.0 was tagged, but never published to npm, so this v0.4.0
+changelog entry includes v0.3.0 features.
+
+This is a massive release that adds `stringify` support, among other things.
+
+- **Major:** `JSON5.stringify()` now exists!
+  This method is analogous to the native `JSON.stringify()`;
+  it just avoids quoting keys where possible.
+  See the [usage documentation](./README.md#usage) for more.
+  ([#32][]; huge thanks and props [@aeisenberg][]!)
+
+- New: `NaN` and `-NaN` are now allowed number literals.
+  ([#30][]; thanks [@rowanhill][].)
+
+- New: Duplicate object keys are now allowed; the last value is used.
+  This is the same behavior as JSON. ([#57][]; thanks [@jordanbtucker][].)
+
+- Fix: Properly handle various whitespace and newline cases now.
+  E.g. JSON5 now properly supports escaped CR and CRLF newlines in strings,
+  and JSON5 now accepts the same whitespace as JSON (stricter than ES5).
+  ([#58][], [#60][], and [#63][]; thanks [@jordanbtucker][].)
+
+- New: Negative hexadecimal numbers (e.g. `-0xC8`) are allowed again.
+  (They were disallowed in v0.2.0; see below.)
+  It turns out they *are* valid in ES5, so JSON5 supports them now too.
+  ([#36][]; thanks [@jordanbtucker][]!)
+
+
+### v0.2.0 [[code][c0.2.0], [diff][d0.2.0]]
+
+[c0.2.0]: https://github.com/aseemk/json5/tree/v0.2.0
+[d0.2.0]: https://github.com/aseemk/json5/compare/v0.1.0...v0.2.0
+
+This release fixes some bugs and adds some more utility features to help you
+express data more easily:
+
+- **Breaking:** Negative hexadecimal numbers (e.g. `-0xC8`) are rejected now.
+  While V8 (e.g. Chrome and Node) supported them, it turns out they're invalid
+  in ES5. This has been [fixed in V8][v8-hex-fix] (and by extension, Chrome
+  and Node), so JSON5 officially rejects them now, too. ([#36][])
+
+- New: Trailing decimal points in decimal numbers are allowed again.
+  (They were disallowed in v0.1.0; see below.)
+  They're allowed by ES5, and differentiating between integers and floats may
+  make sense on some platforms. ([#16][]; thanks [@Midar][].)
+
+- New: `Infinity` and `-Infinity` are now allowed number literals.
+  ([#30][]; thanks [@pepkin88][].)
+
+- New: Plus signs (`+`) in front of numbers are now allowed, since it can
+  be helpful in some contexts to explicitly mark numbers as positive.
+  (E.g. when a property represents changes or deltas.)
+
+- Fix: unescaped newlines in strings are rejected now.
+  ([#24][]; thanks [@Midar][].)
+
+
+### v0.1.0 [[code][c0.1.0], [diff][d0.1.0]]
+
+[c0.1.0]: https://github.com/aseemk/json5/tree/v0.1.0
+[d0.1.0]: https://github.com/aseemk/json5/compare/v0.0.1...v0.1.0
+
+This release tightens JSON5 support and adds helpful utility features:
+
+- New: Support hexadecimal numbers. (Thanks [@MaxNanasy][].)
+
+- Fix: Reject octal numbers properly now. Previously, they were accepted but
+  improperly parsed as base-10 numbers. (Thanks [@MaxNanasy][].)
+
+- **Breaking:** Reject "noctal" numbers now (base-10 numbers that begin with a
+  leading zero). These are disallowed by both JSON5 and JSON, as well as by
+  ES5's strict mode. (Thanks [@MaxNanasy][].)
+
+- New: Support leading decimal points in decimal numbers.
+  (Thanks [@MaxNanasy][].)
+
+- **Breaking:** Reject trailing decimal points in decimal numbers now. These
+  are disallowed by both JSON5 and JSON. (Thanks [@MaxNanasy][].)
+
+- **Breaking:** Reject omitted elements in arrays now. These are disallowed by
+  both JSON5 and JSON.
+
+- Fix: Throw proper `SyntaxError` instances on errors now.
+
+- New: Add Node.js `require()` hook. Register via `json5/lib/require`.
+
+- New: Add Node.js `json5` executable to compile JSON5 files to JSON.
+
+
+### v0.0.1 [[code][c0.0.1], [diff][d0.0.1]]
+
+[c0.0.1]: https://github.com/aseemk/json5/tree/v0.0.1
+[d0.0.1]: https://github.com/aseemk/json5/compare/v0.0.0...v0.0.1
+
+This was the first implementation of this JSON5 parser.
+
+- Support unquoted object keys, including reserved words. Unicode characters
+  and escape sequences sequences aren't yet supported.
+
+- Support single-quoted strings.
+
+- Support multi-line strings.
+
+- Support trailing commas in arrays and objects.
+
+- Support comments, both inline and block.
+
+
+### v0.0.0 [[code](https://github.com/aseemk/json5/tree/v0.0.0)]
+
+Let's consider this to be Douglas Crockford's original [json_parse.js][] — a
+parser for the regular JSON format.
+
+
+[json_parse.js]: https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js
+[v8-hex-fix]: http://code.google.com/p/v8/issues/detail?id=2240
+
+[@MaxNanasy]: https://github.com/MaxNanasy
+[@Midar]: https://github.com/Midar
+[@pepkin88]: https://github.com/pepkin88
+[@rowanhill]: https://github.com/rowanhill
+[@aeisenberg]: https://github.com/aeisenberg
+[@jordanbtucker]: https://github.com/jordanbtucker
+
+[#16]: https://github.com/aseemk/json5/issues/16
+[#24]: https://github.com/aseemk/json5/issues/24
+[#30]: https://github.com/aseemk/json5/issues/30
+[#32]: https://github.com/aseemk/json5/issues/32
+[#36]: https://github.com/aseemk/json5/issues/36
+[#57]: https://github.com/aseemk/json5/issues/57
+[#58]: https://github.com/aseemk/json5/pull/58
+[#60]: https://github.com/aseemk/json5/pull/60
+[#63]: https://github.com/aseemk/json5/pull/63

react-app/node_modules/json5/README.md

@@ -0,0 +1,271 @@
+[![Build Status](https://travis-ci.org/aseemk/json5.png)](https://travis-ci.org/aseemk/json5)
+
+
+# JSON5 – Modern JSON
+
+JSON is an excellent data format, but we think it can be better.
+
+**JSON5 is a proposed extension to JSON** that aims to make it easier for
+*humans to write and maintain* by hand. It does this by adding some minimal
+syntax features directly from ECMAScript 5.
+
+JSON5 remains a **strict subset of JavaScript**, adds **no new data types**,
+and **works with all existing JSON content**.
+
+JSON5 is *not* an official successor to JSON, and JSON5 content may *not*
+work with existing JSON parsers. For this reason, JSON5 files use a new .json5
+extension. *(TODO: new MIME type needed too.)*
+
+The code here is a **reference JavaScript implementation** for both Node.js
+and all browsers. It's based directly off of Douglas Crockford's own [JSON
+implementation][json_parse.js], and it's both robust and secure.
+
+
+## Why
+
+JSON isn't the friendliest to *write*. Keys need to be quoted, objects and
+arrays can't have trailing commas, and comments aren't allowed — even though
+none of these are the case with regular JavaScript today.
+
+That was fine when JSON's goal was to be a great data format, but JSON's usage
+has expanded beyond *machines*. JSON is now used for writing [configs][ex1],
+[manifests][ex2], even [tests][ex3] — all by *humans*.
+
+[ex1]: http://plovr.com/docs.html
+[ex2]: http://npmjs.org/doc/json.html
+[ex3]: http://code.google.com/p/fuzztester/wiki/JSONFileFormat
+
+There are other formats that are human-friendlier, like YAML, but changing
+from JSON to a completely different format is undesirable in many cases.
+JSON5’s aim is to remain close to JSON and JavaScript.
+
+
+## Features
+
+The following is the exact list of additions to JSON's syntax introduced by
+JSON5. **All of these are optional**, and **all of these come from ES5**.
+
+### Objects
+
+- Object keys can be unquoted if they're valid [identifiers][mdn_variables].
+  Yes, even reserved keywords (like `default`) are valid unquoted keys in ES5
+  [[§11.1.5](http://es5.github.com/#x11.1.5), [§7.6](http://es5.github.com/#x7.6)].
+
+  *(TODO: Unicode characters and escape sequences aren’t yet supported in this
+  implementation.)*
+
+- Objects can have trailing commas.
+
+[mdn_variables]: https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Core_Language_Features#Variables
+
+### Arrays
+
+- Arrays can have trailing commas.
+
+### Strings
+
+- Strings can be single-quoted.
+
+- Strings can be split across multiple lines; just prefix each newline with a
+  backslash. [ES5 [§7.8.4](http://es5.github.com/#x7.8.4)]
+
+### Numbers
+
+- Numbers can be hexadecimal (base 16). (But note that neither signed
+  hexadecimals nor hexadecimal floats are allowed by ES5.)
+
+- Numbers can begin or end with a (leading or trailing) decimal point.
+
+- Numbers can include `Infinity` and `-Infinity`.
+
+- Numbers can begin with an explicit plus sign.
+
+### Comments
+
+- Both inline (single-line) and block (multi-line) comments are allowed.
+
+
+## Example
+
+The following is a contrived example, but it illustrates most of the features:
+
+```js
+{
+    foo: 'bar',
+    while: true,
+
+    this: 'is a \
+multi-line string',
+
+    // this is an inline comment
+    here: 'is another', // inline comment
+
+    /* this is a block comment
+       that continues on another line */
+
+    hex: 0xDEADbeef,
+    half: .5,
+    delta: +10,
+    to: Infinity,   // and beyond!
+
+    finally: 'a trailing comma',
+    oh: [
+        "we shouldn't forget",
+        'arrays can have',
+        'trailing commas too',
+    ],
+}
+```
+
+This implementation's own [package.json5](package.json5) is more realistic:
+
+```js
+// This file is written in JSON5 syntax, naturally, but npm needs a regular
+// JSON file, so compile via `npm run build`. Be sure to keep both in sync!
+
+{
+    name: 'json5',
+    version: '0.2.0',
+    description: 'JSON for the ES5 era.',
+    keywords: ['json', 'es5'],
+    author: 'Aseem Kishore <aseem.kishore@gmail.com>',
+    contributors: [
+        'Max Nanasy <max.nanasy@gmail.com>',
+    ],
+    main: 'lib/json5.js',
+    bin: 'lib/cli.js',
+    dependencies: {},
+    devDependencies: {
+        mocha: '~1.0.3',
+    },
+    scripts: {
+        build: './lib/cli.js -c package.json5',
+        test: 'mocha --ui exports --reporter spec',
+    },
+    homepage: 'http://json5.org/',
+    repository: {
+        type: 'git',
+        url: 'https://github.com/aseemk/json5.git',
+    },
+}
+```
+
+
+## Community
+
+Join the [Google Group](http://groups.google.com/group/json5) if you're
+interested in JSON5 news, updates, and general discussion.
+Don't worry, it's very low-traffic.
+
+The [GitHub wiki](https://github.com/aseemk/json5/wiki) is a good place to track
+JSON5 support and usage. Contribute freely there!
+
+[GitHub Issues](https://github.com/aseemk/json5/issues) is the place to
+formally propose feature requests and report bugs. Questions and general
+feedback are better directed at the Google Group.
+
+
+## Usage
+
+This JavaScript implementation of JSON5 simply provides a `JSON5` object just
+like the native ES5 `JSON` object.
+
+To use from Node:
+
+```
+npm install json5
+```
+
+```js
+var JSON5 = require('json5');
+```
+
+To use in the browser (adds the `JSON5` object to the global namespace):
+
+```
+<script src="json5.js"></script>
+```
+
+Then in both cases, you can simply replace native `JSON` calls with `JSON5`:
+
+```js
+var obj = JSON5.parse('{unquoted:"key",trailing:"comma",}');
+var str = JSON5.stringify(obj);
+```
+
+`JSON5.parse` supports all of the JSON5 features listed above (*TODO: except
+Unicode*), as well as the native [`reviver` argument][json-parse].
+
+[json-parse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse
+
+`JSON5.stringify` mainly avoids quoting keys where possible, but we hope to
+keep expanding it in the future (e.g. to also output trailing commas).
+It supports the native [`replacer` and `space` arguments][json-stringify],
+as well. *(TODO: Any implemented `toJSON` methods aren't used today.)*
+
+[json-stringify]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+
+
+### Extras
+
+If you're running this on Node, you can also register a JSON5 `require()` hook
+to let you `require()` `.json5` files just like you can `.json` files:
+
+```js
+require('json5/lib/require');
+require('./path/to/foo');   // tries foo.json5 after foo.js, foo.json, etc.
+require('./path/to/bar.json5');
+```
+
+This module also provides a `json5` executable (requires Node) for converting
+JSON5 files to JSON:
+
+```
+$ json5 -c path/to/foo.json5    # generates path/to/foo.json
+```
+
+
+## Development
+
+```
+git clone git://github.com/aseemk/json5.git
+cd json5
+npm install
+npm test
+```
+
+As the `package.json5` file states, be sure to run `npm run build` on changes
+to `package.json5`, since npm requires `package.json`.
+
+Feel free to [file issues](https://github.com/aseemk/json5/issues) and submit
+[pull requests](https://github.com/aseemk/json5/pulls) — contributions are
+welcome. If you do submit a pull request, please be sure to add or update the
+tests, and ensure that `npm test` continues to pass.
+
+
+## License
+
+MIT License. © 2012 Aseem Kishore, and [others](
+https://github.com/aseemk/json5/contributors).
+
+
+## Credits
+
+[Michael Bolin](http://bolinfest.com/) independently arrived at and published
+some of these same ideas with awesome explanations and detail.
+Recommended reading:
+[Suggested Improvements to JSON](http://bolinfest.com/essays/json.html)
+
+[Douglas Crockford](http://www.crockford.com/) of course designed and built
+JSON, but his state machine diagrams on the [JSON website](http://json.org/),
+as cheesy as it may sound, gave me motivation and confidence that building a
+new parser to implement these ideas this was within my reach!
+This code is also modeled directly off of Doug's open-source [json_parse.js][]
+parser. I'm super grateful for that clean and well-documented code.
+
+[json_parse.js]: https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js
+
+[Max Nanasy](https://github.com/MaxNanasy) has been an early and prolific
+supporter, contributing multiple patches and ideas. Thanks Max!
+
+[Andrew Eisenberg](https://github.com/aeisenberg) has contributed the `stringify` method.

react-app/node_modules/json5/lib/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// cli.js
+// JSON5 command-line interface.
+//
+// This is pretty minimal for now; just supports compiling files via `-c`.
+// TODO More useful functionality, like output path, watch, etc.?
+
+var FS = require('fs');
+var JSON5 = require('./json5');
+var Path = require('path');
+
+var USAGE = [
+    'Usage: json5 -c path/to/file.json5 ...',
+    'Compiles JSON5 files into sibling JSON files with the same basenames.',
+].join('\n');
+
+// if valid, args look like [node, json5, -c, file1, file2, ...]
+var args = process.argv;
+
+if (args.length < 4 || args[2] !== '-c') {
+    console.error(USAGE);
+    process.exit(1);
+}
+
+var cwd = process.cwd();
+var files = args.slice(3);
+
+// iterate over each file and convert JSON5 files to JSON:
+files.forEach(function (file) {
+    var path = Path.resolve(cwd, file);
+    var basename = Path.basename(path, '.json5');
+    var dirname = Path.dirname(path);
+
+    var json5 = FS.readFileSync(path, 'utf8');
+    var obj = JSON5.parse(json5);
+    var json = JSON.stringify(obj, null, 4); // 4 spaces; TODO configurable?
+
+    path = Path.join(dirname, basename + '.json');
+    FS.writeFileSync(path, json, 'utf8');
+});

react-app/node_modules/json5/lib/json5.js

@@ -0,0 +1,754 @@
+// json5.js
+// Modern JSON. See README.md for details.
+//
+// This file is based directly off of Douglas Crockford's json_parse.js:
+// https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js
+
+var JSON5 = (typeof exports === 'object' ? exports : {});
+
+JSON5.parse = (function () {
+    "use strict";
+
+// This is a function that can parse a JSON5 text, producing a JavaScript
+// data structure. It is a simple, recursive descent parser. It does not use
+// eval or regular expressions, so it can be used as a model for implementing
+// a JSON5 parser in other languages.
+
+// We are defining the function inside of another function to avoid creating
+// global variables.
+
+    var at,     // The index of the current character
+        ch,     // The current character
+        escapee = {
+            "'":  "'",
+            '"':  '"',
+            '\\': '\\',
+            '/':  '/',
+            '\n': '',       // Replace escaped newlines in strings w/ empty string
+            b:    '\b',
+            f:    '\f',
+            n:    '\n',
+            r:    '\r',
+            t:    '\t'
+        },
+        ws = [
+            ' ',
+            '\t',
+            '\r',
+            '\n',
+            '\v',
+            '\f',
+            '\xA0',
+            '\uFEFF'
+        ],
+        text,
+
+        error = function (m) {
+
+// Call error when something is wrong.
+
+            var error = new SyntaxError();
+            error.message = m;
+            error.at = at;
+            error.text = text;
+            throw error;
+        },
+
+        next = function (c) {
+
+// If a c parameter is provided, verify that it matches the current character.
+
+            if (c && c !== ch) {
+                error("Expected '" + c + "' instead of '" + ch + "'");
+            }
+
+// Get the next character. When there are no more characters,
+// return the empty string.
+
+            ch = text.charAt(at);
+            at += 1;
+            return ch;
+        },
+
+        peek = function () {
+
+// Get the next character without consuming it or
+// assigning it to the ch varaible.
+
+            return text.charAt(at);
+        },
+
+        identifier = function () {
+
+// Parse an identifier. Normally, reserved words are disallowed here, but we
+// only use this for unquoted object keys, where reserved words are allowed,
+// so we don't check for those here. References:
+// - http://es5.github.com/#x7.6
+// - https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Core_Language_Features#Variables
+// - http://docstore.mik.ua/orelly/webprog/jscript/ch02_07.htm
+// TODO Identifiers can have Unicode "letters" in them; add support for those.
+
+            var key = ch;
+
+            // Identifiers must start with a letter, _ or $.
+            if ((ch !== '_' && ch !== '$') &&
+                    (ch < 'a' || ch > 'z') &&
+                    (ch < 'A' || ch > 'Z')) {
+                error("Bad identifier");
+            }
+
+            // Subsequent characters can contain digits.
+            while (next() && (
+                    ch === '_' || ch === '$' ||
+                    (ch >= 'a' && ch <= 'z') ||
+                    (ch >= 'A' && ch <= 'Z') ||
+                    (ch >= '0' && ch <= '9'))) {
+                key += ch;
+            }
+
+            return key;
+        },
+
+        number = function () {
+
+// Parse a number value.
+
+            var number,
+                sign = '',
+                string = '',
+                base = 10;
+
+            if (ch === '-' || ch === '+') {
+                sign = ch;
+                next(ch);
+            }
+
+            // support for Infinity (could tweak to allow other words):
+            if (ch === 'I') {
+                number = word();
+                if (typeof number !== 'number' || isNaN(number)) {
+                    error('Unexpected word for number');
+                }
+                return (sign === '-') ? -number : number;
+            }
+
+            // support for NaN
+            if (ch === 'N' ) {
+              number = word();
+              if (!isNaN(number)) {
+                error('expected word to be NaN');
+              }
+              // ignore sign as -NaN also is NaN
+              return number;
+            }
+
+            if (ch === '0') {
+                string += ch;
+                next();
+                if (ch === 'x' || ch === 'X') {
+                    string += ch;
+                    next();
+                    base = 16;
+                } else if (ch >= '0' && ch <= '9') {
+                    error('Octal literal');
+                }
+            }
+
+            switch (base) {
+            case 10:
+                while (ch >= '0' && ch <= '9' ) {
+                    string += ch;
+                    next();
+                }
+                if (ch === '.') {
+                    string += '.';
+                    while (next() && ch >= '0' && ch <= '9') {
+                        string += ch;
+                    }
+                }
+                if (ch === 'e' || ch === 'E') {
+                    string += ch;
+                    next();
+                    if (ch === '-' || ch === '+') {
+                        string += ch;
+                        next();
+                    }
+                    while (ch >= '0' && ch <= '9') {
+                        string += ch;
+                        next();
+                    }
+                }
+                break;
+            case 16:
+                while (ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'F' || ch >= 'a' && ch <= 'f') {
+                    string += ch;
+                    next();
+                }
+                break;
+            }
+
+            if(sign === '-') {
+                number = -string;
+            } else {
+                number = +string;
+            }
+            
+            if (!isFinite(number)) {
+                error("Bad number");
+            } else {
+                return number;
+            }
+        },
+
+        string = function () {
+
+// Parse a string value.
+
+            var hex,
+                i,
+                string = '',
+                delim,      // double quote or single quote
+                uffff;
+
+// When parsing for string values, we must look for ' or " and \ characters.
+
+            if (ch === '"' || ch === "'") {
+                delim = ch;
+                while (next()) {
+                    if (ch === delim) {
+                        next();
+                        return string;
+                    } else if (ch === '\\') {
+                        next();
+                        if (ch === 'u') {
+                            uffff = 0;
+                            for (i = 0; i < 4; i += 1) {
+                                hex = parseInt(next(), 16);
+                                if (!isFinite(hex)) {
+                                    break;
+                                }
+                                uffff = uffff * 16 + hex;
+                            }
+                            string += String.fromCharCode(uffff);
+                        } else if (ch === '\r') {
+                            if (peek() === '\n') {
+                                next();
+                            }
+                        } else if (typeof escapee[ch] === 'string') {
+                            string += escapee[ch];
+                        } else {
+                            break;
+                        }
+                    } else if (ch === '\n') {
+                        // unescaped newlines are invalid; see:
+                        // https://github.com/aseemk/json5/issues/24
+                        // TODO this feels special-cased; are there other
+                        // invalid unescaped chars?
+                        break;
+                    } else {
+                        string += ch;
+                    }
+                }
+            }
+            error("Bad string");
+        },
+
+        inlineComment = function () {
+
+// Skip an inline comment, assuming this is one. The current character should
+// be the second / character in the // pair that begins this inline comment.
+// To finish the inline comment, we look for a newline or the end of the text.
+
+            if (ch !== '/') {
+                error("Not an inline comment");
+            }
+
+            do {
+                next();
+                if (ch === '\n' || ch === '\r') {
+                    next();
+                    return;
+                }
+            } while (ch);
+        },
+
+        blockComment = function () {
+
+// Skip a block comment, assuming this is one. The current character should be
+// the * character in the /* pair that begins this block comment.
+// To finish the block comment, we look for an ending */ pair of characters,
+// but we also watch for the end of text before the comment is terminated.
+
+            if (ch !== '*') {
+                error("Not a block comment");
+            }
+
+            do {
+                next();
+                while (ch === '*') {
+                    next('*');
+                    if (ch === '/') {
+                        next('/');
+                        return;
+                    }
+                }
+            } while (ch);
+
+            error("Unterminated block comment");
+        },
+
+        comment = function () {
+
+// Skip a comment, whether inline or block-level, assuming this is one.
+// Comments always begin with a / character.
+
+            if (ch !== '/') {
+                error("Not a comment");
+            }
+
+            next('/');
+
+            if (ch === '/') {
+                inlineComment();
+            } else if (ch === '*') {
+                blockComment();
+            } else {
+                error("Unrecognized comment");
+            }
+        },
+
+        white = function () {
+
+// Skip whitespace and comments.
+// Note that we're detecting comments by only a single / character.
+// This works since regular expressions are not valid JSON(5), but this will
+// break if there are other valid values that begin with a / character!
+
+            while (ch) {
+                if (ch === '/') {
+                    comment();
+                } else if (ws.indexOf(ch) >= 0) {
+                    next();
+                } else {
+                    return;
+                }
+            }
+        },
+
+        word = function () {
+
+// true, false, or null.
+
+            switch (ch) {
+            case 't':
+                next('t');
+                next('r');
+                next('u');
+                next('e');
+                return true;
+            case 'f':
+                next('f');
+                next('a');
+                next('l');
+                next('s');
+                next('e');
+                return false;
+            case 'n':
+                next('n');
+                next('u');
+                next('l');
+                next('l');
+                return null;
+            case 'I':
+                next('I');
+                next('n');
+                next('f');
+                next('i');
+                next('n');
+                next('i');
+                next('t');
+                next('y');
+                return Infinity;
+            case 'N':
+              next( 'N' );
+              next( 'a' );
+              next( 'N' );
+              return NaN;
+            }
+            error("Unexpected '" + ch + "'");
+        },
+
+        value,  // Place holder for the value function.
+
+        array = function () {
+
+// Parse an array value.
+
+            var array = [];
+
+            if (ch === '[') {
+                next('[');
+                white();
+                while (ch) {
+                    if (ch === ']') {
+                        next(']');
+                        return array;   // Potentially empty array
+                    }
+                    // ES5 allows omitting elements in arrays, e.g. [,] and
+                    // [,null]. We don't allow this in JSON5.
+                    if (ch === ',') {
+                        error("Missing array element");
+                    } else {
+                        array.push(value());
+                    }
+                    white();
+                    // If there's no comma after this value, this needs to
+                    // be the end of the array.
+                    if (ch !== ',') {
+                        next(']');
+                        return array;
+                    }
+                    next(',');
+                    white();
+                }
+            }
+            error("Bad array");
+        },
+
+        object = function () {
+
+// Parse an object value.
+
+            var key,
+                object = {};
+
+            if (ch === '{') {
+                next('{');
+                white();
+                while (ch) {
+                    if (ch === '}') {
+                        next('}');
+                        return object;   // Potentially empty object
+                    }
+
+                    // Keys can be unquoted. If they are, they need to be
+                    // valid JS identifiers.
+                    if (ch === '"' || ch === "'") {
+                        key = string();
+                    } else {
+                        key = identifier();
+                    }
+
+                    white();
+                    next(':');
+                    object[key] = value();
+                    white();
+                    // If there's no comma after this pair, this needs to be
+                    // the end of the object.
+                    if (ch !== ',') {
+                        next('}');
+                        return object;
+                    }
+                    next(',');
+                    white();
+                }
+            }
+            error("Bad object");
+        };
+
+    value = function () {
+
+// Parse a JSON value. It could be an object, an array, a string, a number,
+// or a word.
+
+        white();
+        switch (ch) {
+        case '{':
+            return object();
+        case '[':
+            return array();
+        case '"':
+        case "'":
+            return string();
+        case '-':
+        case '+':
+        case '.':
+            return number();
+        default:
+            return ch >= '0' && ch <= '9' ? number() : word();
+        }
+    };
+
+// Return the json_parse function. It will have access to all of the above
+// functions and variables.
+
+    return function (source, reviver) {
+        var result;
+
+        text = String(source);
+        at = 0;
+        ch = ' ';
+        result = value();
+        white();
+        if (ch) {
+            error("Syntax error");
+        }
+
+// If there is a reviver function, we recursively walk the new structure,
+// passing each name/value pair to the reviver function for possible
+// transformation, starting with a temporary root object that holds the result
+// in an empty key. If there is not a reviver function, we simply return the
+// result.
+
+        return typeof reviver === 'function' ? (function walk(holder, key) {
+            var k, v, value = holder[key];
+            if (value && typeof value === 'object') {
+                for (k in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        v = walk(value, k);
+                        if (v !== undefined) {
+                            value[k] = v;
+                        } else {
+                            delete value[k];
+                        }
+                    }
+                }
+            }
+            return reviver.call(holder, key, value);
+        }({'': result}, '')) : result;
+    };
+}());
+
+// JSON5 stringify will not quote keys where appropriate
+JSON5.stringify = function (obj, replacer, space) {
+    if (replacer && (typeof(replacer) !== "function" && !isArray(replacer))) {
+        throw new Error('Replacer must be a function or an array');
+    }
+    var getReplacedValueOrUndefined = function(holder, key, isTopLevel) {
+        var value = holder[key];
+
+        // Replace the value with its toJSON value first, if possible
+        if (value && value.toJSON && typeof value.toJSON === "function") {
+            value = value.toJSON();
+        }
+
+        // If the user-supplied replacer if a function, call it. If it's an array, check objects' string keys for
+        // presence in the array (removing the key/value pair from the resulting JSON if the key is missing).
+        if (typeof(replacer) === "function") {
+            return replacer.call(holder, key, value);
+        } else if(replacer) {
+            if (isTopLevel || isArray(holder) || replacer.indexOf(key) >= 0) {
+                return value;
+            } else {
+                return undefined;
+            }
+        } else {
+            return value;
+        }
+    };
+
+    function isWordChar(char) {
+        return (char >= 'a' && char <= 'z') ||
+            (char >= 'A' && char <= 'Z') ||
+            (char >= '0' && char <= '9') ||
+            char === '_' || char === '$';
+    }
+
+    function isWordStart(char) {
+        return (char >= 'a' && char <= 'z') ||
+            (char >= 'A' && char <= 'Z') ||
+            char === '_' || char === '$';
+    }
+
+    function isWord(key) {
+        if (typeof key !== 'string') {
+            return false;
+        }
+        if (!isWordStart(key[0])) {
+            return false;
+        }
+        var i = 1, length = key.length;
+        while (i < length) {
+            if (!isWordChar(key[i])) {
+                return false;
+            }
+            i++;
+        }
+        return true;
+    }
+
+    // export for use in tests
+    JSON5.isWord = isWord;
+
+    // polyfills
+    function isArray(obj) {
+        if (Array.isArray) {
+            return Array.isArray(obj);
+        } else {
+            return Object.prototype.toString.call(obj) === '[object Array]';
+        }
+    }
+
+    function isDate(obj) {
+        return Object.prototype.toString.call(obj) === '[object Date]';
+    }
+
+    isNaN = isNaN || function(val) {
+        return typeof val === 'number' && val !== val;
+    };
+
+    var objStack = [];
+    function checkForCircular(obj) {
+        for (var i = 0; i < objStack.length; i++) {
+            if (objStack[i] === obj) {
+                throw new TypeError("Converting circular structure to JSON");
+            }
+        }
+    }
+
+    function makeIndent(str, num, noNewLine) {
+        if (!str) {
+            return "";
+        }
+        // indentation no more than 10 chars
+        if (str.length > 10) {
+            str = str.substring(0, 10);
+        }
+
+        var indent = noNewLine ? "" : "\n";
+        for (var i = 0; i < num; i++) {
+            indent += str;
+        }
+
+        return indent;
+    }
+
+    var indentStr;
+    if (space) {
+        if (typeof space === "string") {
+            indentStr = space;
+        } else if (typeof space === "number" && space >= 0) {
+            indentStr = makeIndent(" ", space, true);
+        } else {
+            // ignore space parameter
+        }
+    }
+
+    // Copied from Crokford's implementation of JSON
+    // See https://github.com/douglascrockford/JSON-js/blob/e39db4b7e6249f04a195e7dd0840e610cc9e941e/json2.js#L195
+    // Begin
+    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        meta = { // table of character substitutions
+        '\b': '\\b',
+        '\t': '\\t',
+        '\n': '\\n',
+        '\f': '\\f',
+        '\r': '\\r',
+        '"' : '\\"',
+        '\\': '\\\\'
+    };
+    function escapeString(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+        escapable.lastIndex = 0;
+        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+            var c = meta[a];
+            return typeof c === 'string' ?
+                c :
+                '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"' : '"' + string + '"';
+    }
+    // End
+
+    function internalStringify(holder, key, isTopLevel) {
+        var buffer, res;
+
+        // Replace the value, if necessary
+        var obj_part = getReplacedValueOrUndefined(holder, key, isTopLevel);
+
+        if (obj_part && !isDate(obj_part)) {
+            // unbox objects
+            // don't unbox dates, since will turn it into number
+            obj_part = obj_part.valueOf();
+        }
+        switch(typeof obj_part) {
+            case "boolean":
+                return obj_part.toString();
+
+            case "number":
+                if (isNaN(obj_part) || !isFinite(obj_part)) {
+                    return "null";
+                }
+                return obj_part.toString();
+
+            case "string":
+                return escapeString(obj_part.toString());
+
+            case "object":
+                if (obj_part === null) {
+                    return "null";
+                } else if (isArray(obj_part)) {
+                    checkForCircular(obj_part);
+                    buffer = "[";
+                    objStack.push(obj_part);
+
+                    for (var i = 0; i < obj_part.length; i++) {
+                        res = internalStringify(obj_part, i, false);
+                        buffer += makeIndent(indentStr, objStack.length);
+                        if (res === null || typeof res === "undefined") {
+                            buffer += "null";
+                        } else {
+                            buffer += res;
+                        }
+                        if (i < obj_part.length-1) {
+                            buffer += ",";
+                        } else if (indentStr) {
+                            buffer += "\n";
+                        }
+                    }
+                    objStack.pop();
+                    buffer += makeIndent(indentStr, objStack.length, true) + "]";
+                } else {
+                    checkForCircular(obj_part);
+                    buffer = "{";
+                    var nonEmpty = false;
+                    objStack.push(obj_part);
+                    for (var prop in obj_part) {
+                        if (obj_part.hasOwnProperty(prop)) {
+                            var value = internalStringify(obj_part, prop, false);
+                            isTopLevel = false;
+                            if (typeof value !== "undefined" && value !== null) {
+                                buffer += makeIndent(indentStr, objStack.length);
+                                nonEmpty = true;
+                                var key = isWord(prop) ? prop : escapeString(prop);
+                                buffer += key + ":" + (indentStr ? ' ' : '') + value + ",";
+                            }
+                        }
+                    }
+                    objStack.pop();
+                    if (nonEmpty) {
+                        buffer = buffer.substring(0, buffer.length-1) + makeIndent(indentStr, objStack.length) + "}";
+                    } else {
+                        buffer = '{}';
+                    }
+                }
+                return buffer;
+            default:
+                // functions and undefined should be ignored
+                return undefined;
+        }
+    }
+
+    // special case...when undefined is used inside of
+    // a compound object/array, return null.
+    // but when top-level, return undefined
+    var topLevelHolder = {"":obj};
+    if (obj === undefined) {
+        return getReplacedValueOrUndefined(topLevelHolder, '', true);
+    }
+    return internalStringify(topLevelHolder, '', true);
+};

react-app/node_modules/json5/lib/require.js

@@ -0,0 +1,18 @@
+// require.js
+// Node.js only: adds a require() hook for .json5 files, just like the native
+// hook for .json files.
+//
+// Usage:
+// require('json5/require');
+// require('./foo');    // will check foo.json5 after foo.js, foo.json, etc.
+// require('./bar.json5');
+
+var FS = require('fs');
+var JSON5 = require('./json5');
+
+// Modeled off of (v0.6.18 link; check latest too):
+// https://github.com/joyent/node/blob/v0.6.18/lib/module.js#L468-L472
+require.extensions['.json5'] = function (module, filename) {
+    var content = FS.readFileSync(filename, 'utf8');
+    module.exports = JSON5.parse(content);
+};

react-app/node_modules/json5/package.json

@@ -0,0 +1,90 @@
+{
+  "_args": [
+    [
+      "json5@^0.4.0",
+      "/Users/mromano/dev/react-sfs/node_modules/babel-core"
+    ]
+  ],
+  "_from": "json5@>=0.4.0 <0.5.0",
+  "_id": "json5@0.4.0",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/json5",
+  "_npmUser": {
+    "email": "aseem.kishore@gmail.com",
+    "name": "aseemk"
+  },
+  "_npmVersion": "1.3.21",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "json5",
+    "raw": "json5@^0.4.0",
+    "rawSpec": "^0.4.0",
+    "scope": null,
+    "spec": ">=0.4.0 <0.5.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/babel-core"
+  ],
+  "_resolved": "https://registry.npmjs.org/json5/-/json5-0.4.0.tgz",
+  "_shasum": "054352e4c4c80c86c0923877d449de176a732c8d",
+  "_shrinkwrap": null,
+  "_spec": "json5@^0.4.0",
+  "_where": "/Users/mromano/dev/react-sfs/node_modules/babel-core",
+  "author": {
+    "email": "aseem.kishore@gmail.com",
+    "name": "Aseem Kishore"
+  },
+  "bin": {
+    "json5": "lib/cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/aseemk/json5/issues"
+  },
+  "contributors": [
+    {
+      "email": "max.nanasy@gmail.com",
+      "name": "Max Nanasy"
+    },
+    {
+      "email": "andrew@eisenberg.as",
+      "name": "Andrew Eisenberg"
+    }
+  ],
+  "dependencies": {},
+  "description": "JSON for the ES5 era.",
+  "devDependencies": {
+    "mocha": "~1.0.3"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "054352e4c4c80c86c0923877d449de176a732c8d",
+    "tarball": "https://registry.npmjs.org/json5/-/json5-0.4.0.tgz"
+  },
+  "homepage": "http://json5.org/",
+  "keywords": [
+    "json",
+    "es5"
+  ],
+  "license": "MIT",
+  "main": "lib/json5.js",
+  "maintainers": [
+    {
+      "email": "aseem.kishore@gmail.com",
+      "name": "aseemk"
+    }
+  ],
+  "name": "json5",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aseemk/json5.git"
+  },
+  "scripts": {
+    "build": "./lib/cli.js -c package.json5",
+    "test": "mocha --ui exports --reporter spec"
+  },
+  "version": "0.4.0"
+}

react-app/node_modules/json5/package.json5

@@ -0,0 +1,30 @@
+// This file is written in JSON5 syntax, naturally, but npm needs a regular
+// JSON file, so compile via `npm run build`. Be sure to keep both in sync!
+
+{
+    name: 'json5',
+    version: '0.4.0',
+    description: 'JSON for the ES5 era.',
+    keywords: ['json', 'es5'],
+    author: 'Aseem Kishore <aseem.kishore@gmail.com>',
+    license: 'MIT',
+    contributors: [
+        'Max Nanasy <max.nanasy@gmail.com>',
+        'Andrew Eisenberg <andrew@eisenberg.as>',
+    ],
+    main: 'lib/json5.js',
+    bin: 'lib/cli.js',
+    dependencies: {},
+    devDependencies: {
+        mocha: '~1.0.3',
+    },
+    scripts: {
+        build: './lib/cli.js -c package.json5',
+        test: 'mocha --ui exports --reporter spec',
+    },
+    homepage: 'http://json5.org/',
+    repository: {
+        type: 'git',
+        url: 'https://github.com/aseemk/json5.git',
+    },
+}

react-app/node_modules/json5/test/parse-cases/arrays/empty-array.json

@@ -0,0 +1 @@
+[]

react-app/node_modules/json5/test/parse-cases/arrays/leading-comma-array.js

@@ -0,0 +1,3 @@
+[
+    ,null
+]

react-app/node_modules/json5/test/parse-cases/arrays/lone-trailing-comma-array.js

@@ -0,0 +1,3 @@
+[
+    ,
+]

react-app/node_modules/json5/test/parse-cases/arrays/no-comma-array.txt

@@ -0,0 +1,4 @@
+[
+    true
+    false
+]

react-app/node_modules/json5/test/parse-cases/arrays/regular-array.json

@@ -0,0 +1,5 @@
+[
+    true,
+    false,
+    null
+]

react-app/node_modules/json5/test/parse-cases/arrays/trailing-comma-array.json5

@@ -0,0 +1,3 @@
+[
+    null,
+]

react-app/node_modules/json5/test/parse-cases/comments/block-comment-following-array-element.json5

@@ -0,0 +1,6 @@
+[
+    false
+    /*
+        true
+    */
+]

react-app/node_modules/json5/test/parse-cases/comments/block-comment-following-top-level-value.json5

@@ -0,0 +1,5 @@
+null
+/*
+    Some non-comment top-level value is needed;
+    we use null above.
+*/

react-app/node_modules/json5/test/parse-cases/comments/block-comment-in-string.json

@@ -0,0 +1 @@
+"This /* block comment */ isn't really a block comment."

react-app/node_modules/json5/test/parse-cases/comments/block-comment-preceding-top-level-value.json5

@@ -0,0 +1,5 @@
+/*
+    Some non-comment top-level value is needed;
+    we use null below.
+*/
+null

react-app/node_modules/json5/test/parse-cases/comments/block-comment-with-asterisks.json5

@@ -0,0 +1,7 @@
+/**
+ * This is a JavaDoc-like block comment.
+ * It contains asterisks inside of it.
+ * It might also be closed with multiple asterisks.
+ * Like this:
+ **/
+true

react-app/node_modules/json5/test/parse-cases/comments/inline-comment-following-array-element.json5

@@ -0,0 +1,3 @@
+[
+    false   // true
+]

react-app/node_modules/json5/test/parse-cases/comments/inline-comment-following-top-level-value.json5

@@ -0,0 +1 @@
+null // Some non-comment top-level value is needed; we use null here.

react-app/node_modules/json5/test/parse-cases/comments/inline-comment-in-string.json

@@ -0,0 +1 @@
+"This inline comment // isn't really an inline comment."

react-app/node_modules/json5/test/parse-cases/comments/inline-comment-preceding-top-level-value.json5

@@ -0,0 +1,2 @@
+// Some non-comment top-level value is needed; we use null below.
+null

react-app/node_modules/json5/test/parse-cases/comments/top-level-block-comment.txt

@@ -0,0 +1,4 @@
+/*
+    This should fail;
+    comments cannot be the top-level value.
+*/

react-app/node_modules/json5/test/parse-cases/comments/top-level-inline-comment.txt

@@ -0,0 +1 @@
+// This should fail; comments cannot be the top-level value.

react-app/node_modules/json5/test/parse-cases/comments/unterminated-block-comment.txt

@@ -0,0 +1,5 @@
+true
+/*
+    This block comment doesn't terminate.
+    There was a legitimate value before this,
+    but this is still invalid JS/JSON5.

react-app/node_modules/json5/test/parse-cases/misc/npm-package.json

@@ -0,0 +1,106 @@
+{
+  "name": "npm",
+  "publishConfig": {
+    "proprietary-attribs": false
+  },
+  "description": "A package manager for node",
+  "keywords": [
+    "package manager",
+    "modules",
+    "install",
+    "package.json"
+  ],
+  "version": "1.1.22",
+  "preferGlobal": true,
+  "config": {
+    "publishtest": false
+  },
+  "homepage": "http://npmjs.org/",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacs/npm"
+  },
+  "bugs": {
+    "email": "npm-@googlegroups.com",
+    "url": "http://github.com/isaacs/npm/issues"
+  },
+  "directories": {
+    "doc": "./doc",
+    "man": "./man",
+    "lib": "./lib",
+    "bin": "./bin"
+  },
+  "main": "./lib/npm.js",
+  "bin": "./bin/npm-cli.js",
+  "dependencies": {
+    "semver": "~1.0.14",
+    "ini": "1",
+    "slide": "1",
+    "abbrev": "1",
+    "graceful-fs": "~1.1.1",
+    "minimatch": "~0.2",
+    "nopt": "1",
+    "node-uuid": "~1.3",
+    "proto-list": "1",
+    "rimraf": "2",
+    "request": "~2.9",
+    "which": "1",
+    "tar": "~0.1.12",
+    "fstream": "~0.1.17",
+    "block-stream": "*",
+    "inherits": "1",
+    "mkdirp": "0.3",
+    "read": "0",
+    "lru-cache": "1",
+    "node-gyp": "~0.4.1",
+    "fstream-npm": "0 >=0.0.5",
+    "uid-number": "0",
+    "archy": "0",
+    "chownr": "0"
+  },
+  "bundleDependencies": [
+    "slide",
+    "ini",
+    "semver",
+    "abbrev",
+    "graceful-fs",
+    "minimatch",
+    "nopt",
+    "node-uuid",
+    "rimraf",
+    "request",
+    "proto-list",
+    "which",
+    "tar",
+    "fstream",
+    "block-stream",
+    "inherits",
+    "mkdirp",
+    "read",
+    "lru-cache",
+    "node-gyp",
+    "fstream-npm",
+    "uid-number",
+    "archy",
+    "chownr"
+  ],
+  "devDependencies": {
+    "ronn": "https://github.com/isaacs/ronnjs/tarball/master"
+  },
+  "engines": {
+    "node": "0.6 || 0.7 || 0.8",
+    "npm": "1"
+  },
+  "scripts": {
+    "test": "node ./test/run.js",
+    "prepublish": "npm prune; rm -rf node_modules/*/{test,example,bench}*; make -j4 doc",
+    "dumpconf": "env | grep npm | sort | uniq"
+  },
+  "licenses": [
+    {
+      "type": "MIT +no-false-attribs",
+      "url": "http://github.com/isaacs/npm/raw/master/LICENSE"
+    }
+  ]
+}

react-app/node_modules/json5/test/parse-cases/misc/npm-package.json5

@@ -0,0 +1,106 @@
+{
+  name: 'npm',
+  publishConfig: {
+    'proprietary-attribs': false,
+  },
+  description: 'A package manager for node',
+  keywords: [
+    'package manager',
+    'modules',
+    'install',
+    'package.json',
+  ],
+  version: '1.1.22',
+  preferGlobal: true,
+  config: {
+    publishtest: false,
+  },
+  homepage: 'http://npmjs.org/',
+  author: 'Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)',
+  repository: {
+    type: 'git',
+    url: 'https://github.com/isaacs/npm',
+  },
+  bugs: {
+    email: 'npm-@googlegroups.com',
+    url: 'http://github.com/isaacs/npm/issues',
+  },
+  directories: {
+    doc: './doc',
+    man: './man',
+    lib: './lib',
+    bin: './bin',
+  },
+  main: './lib/npm.js',
+  bin: './bin/npm-cli.js',
+  dependencies: {
+    semver: '~1.0.14',
+    ini: '1',
+    slide: '1',
+    abbrev: '1',
+    'graceful-fs': '~1.1.1',
+    minimatch: '~0.2',
+    nopt: '1',
+    'node-uuid': '~1.3',
+    'proto-list': '1',
+    rimraf: '2',
+    request: '~2.9',
+    which: '1',
+    tar: '~0.1.12',
+    fstream: '~0.1.17',
+    'block-stream': '*',
+    inherits: '1',
+    mkdirp: '0.3',
+    read: '0',
+    'lru-cache': '1',
+    'node-gyp': '~0.4.1',
+    'fstream-npm': '0 >=0.0.5',
+    'uid-number': '0',
+    archy: '0',
+    chownr: '0',
+  },
+  bundleDependencies: [
+    'slide',
+    'ini',
+    'semver',
+    'abbrev',
+    'graceful-fs',
+    'minimatch',
+    'nopt',
+    'node-uuid',
+    'rimraf',
+    'request',
+    'proto-list',
+    'which',
+    'tar',
+    'fstream',
+    'block-stream',
+    'inherits',
+    'mkdirp',
+    'read',
+    'lru-cache',
+    'node-gyp',
+    'fstream-npm',
+    'uid-number',
+    'archy',
+    'chownr',
+  ],
+  devDependencies: {
+    ronn: 'https://github.com/isaacs/ronnjs/tarball/master',
+  },
+  engines: {
+    node: '0.6 || 0.7 || 0.8',
+    npm: '1',
+  },
+  scripts: {
+    test: 'node ./test/run.js',
+    prepublish: 'npm prune; rm -rf node_modules/*/{test,example,bench}*; make -j4 doc',
+    dumpconf: 'env | grep npm | sort | uniq',
+  },
+  licenses: [
+    {
+      type: 'MIT +no-false-attribs',
+      url: 'http://github.com/isaacs/npm/raw/master/LICENSE',
+    },
+  ],
+}

react-app/node_modules/json5/test/parse-cases/misc/readme-example.json5

@@ -0,0 +1,25 @@
+{
+    foo: 'bar',
+    while: true,
+
+    this: 'is a \
+multi-line string',
+
+    // this is an inline comment
+    here: 'is another', // inline comment
+
+    /* this is a block comment
+       that continues on another line */
+
+    hex: 0xDEADbeef,
+    half: .5,
+    delta: +10,
+    to: Infinity,   // and beyond!
+
+    finally: 'a trailing comma',
+    oh: [
+        "we shouldn't forget",
+        'arrays can have',
+        'trailing commas too',
+    ],
+}

react-app/node_modules/json5/test/parse-cases/misc/valid-whitespace.json5

@@ -0,0 +1,5 @@
+{
+    // An invalid form feed character (\x0c) has been entered before this comment.
+    // Be careful not to delete it.
+  "a": true
+}

react-app/node_modules/json5/test/parse-cases/new-lines/.editorconfig

@@ -0,0 +1,13 @@
+# Since we're testing different representations of new lines,
+# make sure the editor doesn't mangle line endings.
+# Don't commit files in this directory unless you've checked
+# their escaped new lines.
+
+[*-lf.*]
+end_of_line = lf
+
+[*-cr.*]
+end_of_line = cr
+
+[*-crlf.*]
+end_of_line = crlf

react-app/node_modules/json5/test/parse-cases/new-lines/.gitattributes

@@ -0,0 +1,4 @@
+# Since we're testing different representations of new lines,
+# treat all tests in this folder as binary files.
+
+* binary

react-app/node_modules/json5/test/parse-cases/new-lines/comment-cr.json5

@@ -0,0 +1 @@
+{

react-app/node_modules/json5/test/parse-cases/new-lines/comment-crlf.json5

@@ -0,0 +1,3 @@
+{
+    // This comment is terminated with `\r\n`.
+}

react-app/node_modules/json5/test/parse-cases/new-lines/comment-lf.json5

@@ -0,0 +1,3 @@
+{
+    // This comment is terminated with `\n`.
+}

react-app/node_modules/json5/test/parse-cases/new-lines/escaped-cr.json5

@@ -0,0 +1 @@
+{

react-app/node_modules/json5/test/parse-cases/new-lines/escaped-crlf.json5

@@ -0,0 +1,5 @@
+{
+    // the following string contains an escaped `\r\n`
+    a: 'line 1 \
+line 2'
+}

react-app/node_modules/json5/test/parse-cases/new-lines/escaped-lf.json5

@@ -0,0 +1,5 @@
+{
+    // the following string contains an escaped `\n`
+    a: 'line 1 \
+line 2'
+}

react-app/node_modules/json5/test/parse-cases/numbers/binary-coffeescript.txt

@@ -0,0 +1 @@
+0b100

react-app/node_modules/json5/test/parse-cases/numbers/float-leading-decimal-point.json5

@@ -0,0 +1 @@
+.5

react-app/node_modules/json5/test/parse-cases/numbers/float-leading-zero.json

@@ -0,0 +1 @@
+0.5

react-app/node_modules/json5/test/parse-cases/numbers/float-trailing-decimal-point-with-integer-exponent.json5

@@ -0,0 +1 @@
+5.e4

react-app/node_modules/json5/test/parse-cases/numbers/float-trailing-decimal-point.json5

@@ -0,0 +1 @@
+5.

react-app/node_modules/json5/test/parse-cases/numbers/float-with-integer-exponent.json

@@ -0,0 +1 @@
+1.2e3

react-app/node_modules/json5/test/parse-cases/numbers/float.json

@@ -0,0 +1 @@
+1.2

react-app/node_modules/json5/test/parse-cases/numbers/hexadecimal-empty.txt

@@ -0,0 +1 @@
+0x

react-app/node_modules/json5/test/parse-cases/numbers/hexadecimal-lowercase-letter.json5

@@ -0,0 +1 @@
+0xc8

react-app/node_modules/json5/test/parse-cases/numbers/hexadecimal-uppercase-x.json5

@@ -0,0 +1 @@
+0XC8

react-app/node_modules/json5/test/parse-cases/numbers/hexadecimal-with-integer-exponent.json5

@@ -0,0 +1 @@
+0xc8e4

react-app/node_modules/json5/test/parse-cases/numbers/hexadecimal.json5

@@ -0,0 +1 @@
+0xC8

react-app/node_modules/json5/test/parse-cases/numbers/infinity.json5

@@ -0,0 +1 @@
+Infinity

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-float-exponent.txt

@@ -0,0 +1 @@
+1e2.3

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-hexadecimal-exponent.txt

@@ -0,0 +1 @@
+1e0x4

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-integer-exponent.json

@@ -0,0 +1 @@
+2e23

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-negative-float-exponent.txt

@@ -0,0 +1 @@
+1e-2.3

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-negative-hexadecimal-exponent.txt

@@ -0,0 +1 @@
+1e-0x4

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-negative-integer-exponent.json

@@ -0,0 +1 @@
+2e-23

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-negative-zero-integer-exponent.json

@@ -0,0 +1 @@
+5e-0

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-positive-float-exponent.txt

@@ -0,0 +1 @@
+1e+2.3

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-positive-hexadecimal-exponent.txt

@@ -0,0 +1 @@
+1e+0x4

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-positive-integer-exponent.json

@@ -0,0 +1 @@
+1e+2

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-positive-zero-integer-exponent.json

@@ -0,0 +1 @@
+5e+0

react-app/node_modules/json5/test/parse-cases/numbers/integer-with-zero-integer-exponent.json

@@ -0,0 +1 @@
+5e0

react-app/node_modules/json5/test/parse-cases/numbers/integer.json

@@ -0,0 +1 @@
+15

react-app/node_modules/json5/test/parse-cases/numbers/lone-decimal-point.txt

@@ -0,0 +1 @@
+.

react-app/node_modules/json5/test/parse-cases/numbers/nan.json5

@@ -0,0 +1 @@
+NaN

react-app/node_modules/json5/test/parse-cases/numbers/negative-binary-coffeescript.txt

@@ -0,0 +1 @@
+-0b10

react-app/node_modules/json5/test/parse-cases/numbers/negative-float-leading-decimal-point.json5

@@ -0,0 +1 @@
+-.5

react-app/node_modules/json5/test/parse-cases/numbers/negative-float-leading-zero.json

@@ -0,0 +1 @@
+-0.5

react-app/node_modules/json5/test/parse-cases/numbers/negative-float-trailing-decimal-point.json5

@@ -0,0 +1 @@
+-5.

react-app/node_modules/json5/test/parse-cases/numbers/negative-float.json

@@ -0,0 +1 @@
+-1.2

react-app/node_modules/json5/test/parse-cases/numbers/negative-hexadecimal.json5

@@ -0,0 +1 @@
+-0xC8

react-app/node_modules/json5/test/parse-cases/numbers/negative-infinity.json5

@@ -0,0 +1 @@
+-Infinity

react-app/node_modules/json5/test/parse-cases/numbers/negative-integer.json

@@ -0,0 +1 @@
+-15

react-app/node_modules/json5/test/parse-cases/numbers/negative-noctal.js

@@ -0,0 +1 @@
+-098

react-app/node_modules/json5/test/parse-cases/numbers/negative-octal-coffeescript.txt

@@ -0,0 +1 @@
+-0o123

react-app/node_modules/json5/test/parse-cases/numbers/negative-octal.txt

@@ -0,0 +1 @@
+-0123

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-binary-coffeescript.txt

@@ -0,0 +1 @@
+-0b0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-float-leading-decimal-point.json5

@@ -0,0 +1 @@
+-.0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-float-trailing-decimal-point.json5

@@ -0,0 +1 @@
+-0.

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-float.json

@@ -0,0 +1 @@
+-0.0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-hexadecimal.json5

@@ -0,0 +1 @@
+-0x0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-integer.json

@@ -0,0 +1 @@
+-0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-octal-coffeescript.txt

@@ -0,0 +1 @@
+-0o0

react-app/node_modules/json5/test/parse-cases/numbers/negative-zero-octal.txt

@@ -0,0 +1 @@
+-00

react-app/node_modules/json5/test/parse-cases/numbers/noctal-with-leading-octal-digit.js

@@ -0,0 +1 @@
+0780

react-app/node_modules/json5/test/parse-cases/numbers/noctal.js

@@ -0,0 +1 @@
+080

react-app/node_modules/json5/test/parse-cases/numbers/octal-coffeescript.txt

@@ -0,0 +1 @@
+0o200

react-app/node_modules/json5/test/parse-cases/numbers/octal.txt

@@ -0,0 +1 @@
+010

react-app/node_modules/json5/test/parse-cases/numbers/positive-binary-coffeescript.txt

@@ -0,0 +1 @@
++0b10

react-app/node_modules/json5/test/parse-cases/numbers/positive-float-leading-decimal-point.json5

@@ -0,0 +1 @@
++.5

react-app/node_modules/json5/test/parse-cases/numbers/positive-float-leading-zero.json5

@@ -0,0 +1 @@
++0.5

react-app/node_modules/json5/test/parse-cases/numbers/positive-float-trailing-decimal-point.json5

@@ -0,0 +1 @@
++5.

react-app/node_modules/json5/test/parse-cases/numbers/positive-float.json5

@@ -0,0 +1 @@
++1.2

react-app/node_modules/json5/test/parse-cases/numbers/positive-hexadecimal.json5

@@ -0,0 +1 @@
++0xC8

react-app/node_modules/json5/test/parse-cases/numbers/positive-infinity.json5

@@ -0,0 +1 @@
++Infinity

react-app/node_modules/json5/test/parse-cases/numbers/positive-integer.json5

@@ -0,0 +1 @@
++15