// 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
|
lineNumber, // The current line number
|
columnNumber, // The current column number
|
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,
|
|
renderChar = function (chr) {
|
return chr === '' ? 'EOF' : "'" + chr + "'";
|
},
|
|
error = function (m) {
|
|
// Call error when something is wrong.
|
|
var error = new SyntaxError();
|
// beginning of message suffix to agree with that provided by Gecko - see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse
|
error.message = m + " at line " + lineNumber + " column " + columnNumber + " of the JSON5 data. Still to read: " + JSON.stringify(text.substring(at - 1, at + 19));
|
error.at = at;
|
// These two property names have been chosen to agree with the ones in Gecko, the only popular
|
// environment which seems to supply this info on JSON.parse
|
error.lineNumber = lineNumber;
|
error.columnNumber = columnNumber;
|
throw error;
|
},
|
|
next = function (c) {
|
|
// If a c parameter is provided, verify that it matches the current character.
|
|
if (c && c !== ch) {
|
error("Expected " + renderChar(c) + " instead of " + renderChar(ch));
|
}
|
|
// Get the next character. When there are no more characters,
|
// return the empty string.
|
|
ch = text.charAt(at);
|
at++;
|
columnNumber++;
|
if (ch === '\n' || ch === '\r' && peek() !== '\n') {
|
lineNumber++;
|
columnNumber = 0;
|
}
|
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 as unquoted key");
|
}
|
|
// 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 " + renderChar(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;
|
lineNumber = 1;
|
columnNumber = 1;
|
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(c) {
|
return (c >= 'a' && c <= 'z') ||
|
(c >= 'A' && c <= 'Z') ||
|
(c >= '0' && c <= '9') ||
|
c === '_' || c === '$';
|
}
|
|
function isWordStart(c) {
|
return (c >= 'a' && c <= 'z') ||
|
(c >= 'A' && c <= 'Z') ||
|
c === '_' || c === '$';
|
}
|
|
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]';
|
}
|
|
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();
|
if (obj_part.length) {
|
buffer += makeIndent(indentStr, objStack.length, true)
|
}
|
buffer += "]";
|
} 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;
|
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);
|
};
|
