smock 0.1.217 → 0.1.218

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/json5/.npmignore

@@ -0,0 +1,4 @@
+node_modules
+npm-debug.log
+
+package.json

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/json5/CHANGELOG.md

@@ -0,0 +1,56 @@
+### 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:
+
+- Support hexadecimal numbers. (Thanks [@MaxNanasy][].)
+
+- 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][].)
+
+- 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.
+
+- Throw proper `SyntaxError` instances on errors now.
+
+- Add Node.js `require()` hook. Require `json5/lib/require` to register it.
+
+- Add Node.js executable to compile JSON5 files to JSON. Run with `json5`.
+
+### 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
+
+[@MaxNanasy]: https://github.com/MaxNanasy

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/json5/Makefile

@@ -0,0 +1,27 @@
+all: install
+
+clean:
+	$(call clean)
+
+install: package
+	@npm install
+	$(call clean)
+
+link: package
+	@npm link
+	$(call clean)
+
+package:
+	@./lib/cli.js -c package.json5
+
+publish: package
+	@npm publish
+	$(call clean)
+
+test: package
+	@npm test || :	# don't fail on test errors; TODO still fail after clean?
+	$(call clean)
+
+# Helpers:
+
+clean = @rm -f package.json

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/json5/README.md

@@ -0,0 +1,173 @@
+# JSON5 – Modern JSON
+
+JSON isn't the friendliest to write and maintain by hand. Keys need to be
+quoted; objects and arrays can't have trailing commas; comments aren't
+supported — even though none of these is the case with regular JavaScript
+today.
+
+Restricting JSON to such a strict subset of "JavaScript object notation" made
+sense for making it a great data-exchange format, but JSON's usage has
+expanded [beyond][ex1] [machine-to-machine][ex2] [communication][ex3].
+
+[ex1]: http://plovr.com/docs.html
+[ex2]: http://npmjs.org/doc/json.html
+[ex3]: http://code.google.com/p/fuzztester/wiki/JSONFileFormat
+
+**JSON5 is a proposed extension to JSON** that brings ES5 enhancements to its
+syntax. It remains a **strict subset of JavaScript**, adds **no new data
+types**, and is a **strict superset of existing JSON**.
+
+JSON5 is not an official successor to JSON, and existing JSON parsers may not
+understand these new features. It's thus recommended that files use a new
+extension like `.json5` to be explicit. *[TODO: New MIME type too?]*
+
+This module provides a JavaScript implementation that works on all modern JS
+engines (even IE6). Its parser is based directly off of Douglas Crockford's
+eval-free [json_parse.js][], making it both secure and robust. Give it a try!
+
+## Features
+
+These are the new features of JSON5's syntax. All of these are optional, and
+all of these are part of ES5 JavaScript.
+
+- Object keys don't need to be quoted if they're valid [identifiers](
+  https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Core_Language_Features#Variables). Yes, even reserved keywords 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.]*
+
+- 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)]
+
+- Objects and arrays can have trailing commas.
+
+- Both inline (single-line) and block (multi-line) comments are allowed.
+
+- Numbers can be hexadecimal (base 16), and they can also begin with a leading
+  decimal (e.g. `.5`).
+
+## Example
+
+```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,
+       
+    finally: 'a trailing comma',
+    oh: [
+        "we shouldn't forget",
+        'arrays can have',
+        'trailing commas too',
+    ],
+}
+```
+
+## Installation
+
+Via npm on Node:
+
+```
+npm install json5
+```
+
+```js
+var JSON5 = require('json5');
+```
+
+Or in the browser (adds the `JSON5` object to the global namespace):
+
+```html
+<script src="json5.js"></script>
+```
+
+## Usage
+
+```js
+var obj = JSON5.parse('{unquoted:"key",trailing:"comma",}');
+var str = JSON5.stringify(obj);
+console.log(obj);
+console.log(str);
+```
+
+`JSON5.stringify()` is currently aliased to the native `JSON.stringify()` in
+order for the output to be fully compatible with all JSON parsers today.
+
+If you're running 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 sibling JSON files:
+
+```
+$ json5 -c path/to/foo.json5    # generates path/to/foo.json
+```
+
+## Development
+
+```
+git clone git://github.com/aseemk/json5.git
+cd json5
+make
+make test
+```
+
+If your system doesn't have Make, this should work in place of `make [test]`:
+
+```
+./lib/cli.js -c package.json5
+npm install
+npm test
+```
+
+Make is used to auto-generate the package.json file that npm requires from our
+package.json5 file. Just re-run `make` (or `./lib/cli.js -c package.json5`) on
+changes to package.json5.
+
+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 submit a pull request, please be sure to add or update corresponding
+test cases, and ensure that `make test` (or `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!

data/node_modules/imports-loader/node_modules/loader-utils/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');
+});

data/node_modules/imports-loader/node_modules/loader-utils/node_modules/json5/lib/json5.js

@@ -0,0 +1,462 @@
+// 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'
+        },
+        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;
+        },
+
+        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,
+                string = '',
+                base = 10;
+
+            if (ch === '-') {
+                string = '-';
+                next('-');
+            }
+            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 += '.';
+                    next('.');
+                    if (ch < '0' || ch > '9') {
+                        error('Trailing decimal point');
+                    }
+                    do {
+                        string += ch;
+                        next();
+                    } while (ch && ch >= '0' && ch <= '9');
+                }
+                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;
+            }
+            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 (typeof escapee[ch] === 'string') {
+                            string += escapee[ch];
+                        } else {
+                            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') {
+                    next('\n');
+                    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 (ch <= ' ') {
+                    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;
+            }
+            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(':');
+                    if (Object.hasOwnProperty.call(object, key)) {
+                        error('Duplicate key "' + key + '"');
+                    }
+                    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 '.':
+            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 = 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 = function (obj, replacer, space) {
+    // Since regular JSON is a strict subset of JSON5, we'll always output
+    // regular JSON to foster better interoperability. TODO Should we not?
+    return JSON.stringify.apply(JSON, arguments);
+};