| /*! JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | http://kit.mit-license.org */ |
| ;(function () { |
| // Detect the `define` function exposed by asynchronous module loaders. The |
| // strict `define` check is necessary for compatibility with `r.js`. |
| var isLoader = typeof define === "function" && define.amd; |
| |
| // A set of types used to distinguish objects from primitives. |
| var objectTypes = { |
| "function": true, |
| "object": true |
| }; |
| |
| // Detect the `exports` object exposed by CommonJS implementations. |
| var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; |
| |
| // Use the `global` object exposed by Node (including Browserify via |
| // `insert-module-globals`), Narwhal, and Ringo as the default context, |
| // and the `window` object in browsers. Rhino exports a `global` function |
| // instead. |
| var root = objectTypes[typeof window] && window || this, |
| freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global; |
| |
| if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) { |
| root = freeGlobal; |
| } |
| |
| // Public: Initializes JSON 3 using the given `context` object, attaching the |
| // `stringify` and `parse` functions to the specified `exports` object. |
| function runInContext(context, exports) { |
| context || (context = root.Object()); |
| exports || (exports = root.Object()); |
| |
| // Native constructor aliases. |
| var Number = context.Number || root.Number, |
| String = context.String || root.String, |
| Object = context.Object || root.Object, |
| Date = context.Date || root.Date, |
| SyntaxError = context.SyntaxError || root.SyntaxError, |
| TypeError = context.TypeError || root.TypeError, |
| Math = context.Math || root.Math, |
| nativeJSON = context.JSON || root.JSON; |
| |
| // Delegate to the native `stringify` and `parse` implementations. |
| if (typeof nativeJSON == "object" && nativeJSON) { |
| exports.stringify = nativeJSON.stringify; |
| exports.parse = nativeJSON.parse; |
| } |
| |
| // Convenience aliases. |
| var objectProto = Object.prototype, |
| getClass = objectProto.toString, |
| isProperty = objectProto.hasOwnProperty, |
| undefined; |
| |
| // Internal: Contains `try...catch` logic used by other functions. |
| // This prevents other functions from being deoptimized. |
| function attempt(func, errorFunc) { |
| try { |
| func(); |
| } catch (exception) { |
| if (errorFunc) { |
| errorFunc(); |
| } |
| } |
| } |
| |
| // Test the `Date#getUTC*` methods. Based on work by @Yaffle. |
| var isExtended = new Date(-3509827334573292); |
| attempt(function () { |
| // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical |
| // results for certain dates in Opera >= 10.53. |
| isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 && |
| isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708; |
| }); |
| |
| // Internal: Determines whether the native `JSON.stringify` and `parse` |
| // implementations are spec-compliant. Based on work by Ken Snyder. |
| function has(name) { |
| if (has[name] != null) { |
| // Return cached feature test result. |
| return has[name]; |
| } |
| var isSupported; |
| if (name == "bug-string-char-index") { |
| // IE <= 7 doesn't support accessing string characters using square |
| // bracket notation. IE 8 only supports this for primitives. |
| isSupported = "a"[0] != "a"; |
| } else if (name == "json") { |
| // Indicates whether both `JSON.stringify` and `JSON.parse` are |
| // supported. |
| isSupported = has("json-stringify") && has("date-serialization") && has("json-parse"); |
| } else if (name == "date-serialization") { |
| // Indicates whether `Date`s can be serialized accurately by `JSON.stringify`. |
| isSupported = has("json-stringify") && isExtended; |
| if (isSupported) { |
| var stringify = exports.stringify; |
| attempt(function () { |
| isSupported = |
| // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly |
| // serialize extended years. |
| stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' && |
| // The milliseconds are optional in ES 5, but required in 5.1. |
| stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' && |
| // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative |
| // four-digit years instead of six-digit years. Credits: @Yaffle. |
| stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' && |
| // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond |
| // values less than 1000. Credits: @Yaffle. |
| stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"'; |
| }); |
| } |
| } else { |
| var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}'; |
| // Test `JSON.stringify`. |
| if (name == "json-stringify") { |
| var stringify = exports.stringify, stringifySupported = typeof stringify == "function"; |
| if (stringifySupported) { |
| // A test function object with a custom `toJSON` method. |
| (value = function () { |
| return 1; |
| }).toJSON = value; |
| attempt(function () { |
| stringifySupported = |
| // Firefox 3.1b1 and b2 serialize string, number, and boolean |
| // primitives as object literals. |
| stringify(0) === "0" && |
| // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object |
| // literals. |
| stringify(new Number()) === "0" && |
| stringify(new String()) == '""' && |
| // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or |
| // does not define a canonical JSON representation (this applies to |
| // objects with `toJSON` properties as well, *unless* they are nested |
| // within an object or array). |
| stringify(getClass) === undefined && |
| // IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and |
| // FF 3.1b3 pass this test. |
| stringify(undefined) === undefined && |
| // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s, |
| // respectively, if the value is omitted entirely. |
| stringify() === undefined && |
| // FF 3.1b1, 2 throw an error if the given value is not a number, |
| // string, array, object, Boolean, or `null` literal. This applies to |
| // objects with custom `toJSON` methods as well, unless they are nested |
| // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON` |
| // methods entirely. |
| stringify(value) === "1" && |
| stringify([value]) == "[1]" && |
| // Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of |
| // `"[null]"`. |
| stringify([undefined]) == "[null]" && |
| // YUI 3.0.0b1 fails to serialize `null` literals. |
| stringify(null) == "null" && |
| // FF 3.1b1, 2 halts serialization if an array contains a function: |
| // `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3 |
| // elides non-JSON values from objects and arrays, unless they |
| // define custom `toJSON` methods. |
| stringify([undefined, getClass, null]) == "[null,null,null]" && |
| // Simple serialization test. FF 3.1b1 uses Unicode escape sequences |
| // where character escape codes are expected (e.g., `\b` => `\u0008`). |
| stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized && |
| // FF 3.1b1 and b2 ignore the `filter` and `width` arguments. |
| stringify(null, value) === "1" && |
| stringify([1, 2], null, 1) == "[\n 1,\n 2\n]"; |
| }, function () { |
| stringifySupported = false; |
| }); |
| } |
| isSupported = stringifySupported; |
| } |
| // Test `JSON.parse`. |
| if (name == "json-parse") { |
| var parse = exports.parse, parseSupported; |
| if (typeof parse == "function") { |
| attempt(function () { |
| // FF 3.1b1, b2 will throw an exception if a bare literal is provided. |
| // Conforming implementations should also coerce the initial argument to |
| // a string prior to parsing. |
| if (parse("0") === 0 && !parse(false)) { |
| // Simple parsing test. |
| value = parse(serialized); |
| parseSupported = value["a"].length == 5 && value["a"][0] === 1; |
| if (parseSupported) { |
| attempt(function () { |
| // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings. |
| parseSupported = !parse('"\t"'); |
| }); |
| if (parseSupported) { |
| attempt(function () { |
| // FF 4.0 and 4.0.1 allow leading `+` signs and leading |
| // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow |
| // certain octal literals. |
| parseSupported = parse("01") !== 1; |
| }); |
| } |
| if (parseSupported) { |
| attempt(function () { |
| // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal |
| // points. These environments, along with FF 3.1b1 and 2, |
| // also allow trailing commas in JSON objects and arrays. |
| parseSupported = parse("1.") !== 1; |
| }); |
| } |
| } |
| } |
| }, function () { |
| parseSupported = false; |
| }); |
| } |
| isSupported = parseSupported; |
| } |
| } |
| return has[name] = !!isSupported; |
| } |
| has["bug-string-char-index"] = has["date-serialization"] = has["json"] = has["json-stringify"] = has["json-parse"] = null; |
| |
| if (!has("json")) { |
| // Common `[[Class]]` name aliases. |
| var functionClass = "[object Function]", |
| dateClass = "[object Date]", |
| numberClass = "[object Number]", |
| stringClass = "[object String]", |
| arrayClass = "[object Array]", |
| booleanClass = "[object Boolean]"; |
| |
| // Detect incomplete support for accessing string characters by index. |
| var charIndexBuggy = has("bug-string-char-index"); |
| |
| // Internal: Normalizes the `for...in` iteration algorithm across |
| // environments. Each enumerated key is yielded to a `callback` function. |
| var forOwn = function (object, callback) { |
| var size = 0, Properties, dontEnums, property; |
| |
| // Tests for bugs in the current environment's `for...in` algorithm. The |
| // `valueOf` property inherits the non-enumerable flag from |
| // `Object.prototype` in older versions of IE, Netscape, and Mozilla. |
| (Properties = function () { |
| this.valueOf = 0; |
| }).prototype.valueOf = 0; |
| |
| // Iterate over a new instance of the `Properties` class. |
| dontEnums = new Properties(); |
| for (property in dontEnums) { |
| // Ignore all properties inherited from `Object.prototype`. |
| if (isProperty.call(dontEnums, property)) { |
| size++; |
| } |
| } |
| Properties = dontEnums = null; |
| |
| // Normalize the iteration algorithm. |
| if (!size) { |
| // A list of non-enumerable properties inherited from `Object.prototype`. |
| dontEnums = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"]; |
| // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable |
| // properties. |
| forOwn = function (object, callback) { |
| var isFunction = getClass.call(object) == functionClass, property, length; |
| var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty; |
| for (property in object) { |
| // Gecko <= 1.0 enumerates the `prototype` property of functions under |
| // certain conditions; IE does not. |
| if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) { |
| callback(property); |
| } |
| } |
| // Manually invoke the callback for each non-enumerable property. |
| for (length = dontEnums.length; property = dontEnums[--length];) { |
| if (hasProperty.call(object, property)) { |
| callback(property); |
| } |
| } |
| }; |
| } else { |
| // No bugs detected; use the standard `for...in` algorithm. |
| forOwn = function (object, callback) { |
| var isFunction = getClass.call(object) == functionClass, property, isConstructor; |
| for (property in object) { |
| if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) { |
| callback(property); |
| } |
| } |
| // Manually invoke the callback for the `constructor` property due to |
| // cross-environment inconsistencies. |
| if (isConstructor || isProperty.call(object, (property = "constructor"))) { |
| callback(property); |
| } |
| }; |
| } |
| return forOwn(object, callback); |
| }; |
| |
| // Public: Serializes a JavaScript `value` as a JSON string. The optional |
| // `filter` argument may specify either a function that alters how object and |
| // array members are serialized, or an array of strings and numbers that |
| // indicates which properties should be serialized. The optional `width` |
| // argument may be either a string or number that specifies the indentation |
| // level of the output. |
| if (!has("json-stringify") && !has("date-serialization")) { |
| // Internal: A map of control characters and their escaped equivalents. |
| var Escapes = { |
| 92: "\\\\", |
| 34: '\\"', |
| 8: "\\b", |
| 12: "\\f", |
| 10: "\\n", |
| 13: "\\r", |
| 9: "\\t" |
| }; |
| |
| // Internal: Converts `value` into a zero-padded string such that its |
| // length is at least equal to `width`. The `width` must be <= 6. |
| var leadingZeroes = "000000"; |
| var toPaddedString = function (width, value) { |
| // The `|| 0` expression is necessary to work around a bug in |
| // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`. |
| return (leadingZeroes + (value || 0)).slice(-width); |
| }; |
| |
| // Internal: Serializes a date object. |
| var serializeDate = function (value) { |
| var getData, year, month, date, time, hours, minutes, seconds, milliseconds; |
| // Define additional utility methods if the `Date` methods are buggy. |
| if (!isExtended) { |
| var floor = Math.floor; |
| // A mapping between the months of the year and the number of days between |
| // January 1st and the first of the respective month. |
| var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; |
| // Internal: Calculates the number of days between the Unix epoch and the |
| // first day of the given month. |
| var getDay = function (year, month) { |
| return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400); |
| }; |
| getData = function (value) { |
| // Manually compute the year, month, date, hours, minutes, |
| // seconds, and milliseconds if the `getUTC*` methods are |
| // buggy. Adapted from @Yaffle's `date-shim` project. |
| date = floor(value / 864e5); |
| for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++); |
| for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++); |
| date = 1 + date - getDay(year, month); |
| // The `time` value specifies the time within the day (see ES |
| // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used |
| // to compute `A modulo B`, as the `%` operator does not |
| // correspond to the `modulo` operation for negative numbers. |
| time = (value % 864e5 + 864e5) % 864e5; |
| // The hours, minutes, seconds, and milliseconds are obtained by |
| // decomposing the time within the day. See section 15.9.1.10. |
| hours = floor(time / 36e5) % 24; |
| minutes = floor(time / 6e4) % 60; |
| seconds = floor(time / 1e3) % 60; |
| milliseconds = time % 1e3; |
| }; |
| } else { |
| getData = function (value) { |
| year = value.getUTCFullYear(); |
| month = value.getUTCMonth(); |
| date = value.getUTCDate(); |
| hours = value.getUTCHours(); |
| minutes = value.getUTCMinutes(); |
| seconds = value.getUTCSeconds(); |
| milliseconds = value.getUTCMilliseconds(); |
| }; |
| } |
| serializeDate = function (value) { |
| if (value > -1 / 0 && value < 1 / 0) { |
| // Dates are serialized according to the `Date#toJSON` method |
| // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15 |
| // for the ISO 8601 date time string format. |
| getData(value); |
| // Serialize extended years correctly. |
| value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) + |
| "-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) + |
| // Months, dates, hours, minutes, and seconds should have two |
| // digits; milliseconds should have three. |
| "T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) + |
| // Milliseconds are optional in ES 5.0, but required in 5.1. |
| "." + toPaddedString(3, milliseconds) + "Z"; |
| year = month = date = hours = minutes = seconds = milliseconds = null; |
| } else { |
| value = null; |
| } |
| return value; |
| }; |
| return serializeDate(value); |
| }; |
| |
| // For environments with `JSON.stringify` but buggy date serialization, |
| // we override the native `Date#toJSON` implementation with a |
| // spec-compliant one. |
| if (has("json-stringify") && !has("date-serialization")) { |
| // Internal: the `Date#toJSON` implementation used to override the native one. |
| function dateToJSON (key) { |
| return serializeDate(this); |
| } |
| |
| // Public: `JSON.stringify`. See ES 5.1 section 15.12.3. |
| var nativeStringify = exports.stringify; |
| exports.stringify = function (source, filter, width) { |
| var nativeToJSON = Date.prototype.toJSON; |
| Date.prototype.toJSON = dateToJSON; |
| var result = nativeStringify(source, filter, width); |
| Date.prototype.toJSON = nativeToJSON; |
| return result; |
| } |
| } else { |
| // Internal: Double-quotes a string `value`, replacing all ASCII control |
| // characters (characters with code unit values between 0 and 31) with |
| // their escaped equivalents. This is an implementation of the |
| // `Quote(value)` operation defined in ES 5.1 section 15.12.3. |
| var unicodePrefix = "\\u00"; |
| var escapeChar = function (character) { |
| var charCode = character.charCodeAt(0), escaped = Escapes[charCode]; |
| if (escaped) { |
| return escaped; |
| } |
| return unicodePrefix + toPaddedString(2, charCode.toString(16)); |
| }; |
| var reEscape = /[\x00-\x1f\x22\x5c]/g; |
| var quote = function (value) { |
| reEscape.lastIndex = 0; |
| return '"' + |
| ( |
| reEscape.test(value) |
| ? value.replace(reEscape, escapeChar) |
| : value |
| ) + |
| '"'; |
| }; |
| |
| // Internal: Recursively serializes an object. Implements the |
| // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations. |
| var serialize = function (property, object, callback, properties, whitespace, indentation, stack) { |
| var value, type, className, results, element, index, length, prefix, result; |
| attempt(function () { |
| // Necessary for host object support. |
| value = object[property]; |
| }); |
| if (typeof value == "object" && value) { |
| if (value.getUTCFullYear && getClass.call(value) == dateClass && value.toJSON === Date.prototype.toJSON) { |
| value = serializeDate(value); |
| } else if (typeof value.toJSON == "function") { |
| value = value.toJSON(property); |
| } |
| } |
| if (callback) { |
| // If a replacement function was provided, call it to obtain the value |
| // for serialization. |
| value = callback.call(object, property, value); |
| } |
| // Exit early if value is `undefined` or `null`. |
| if (value == undefined) { |
| return value === undefined ? value : "null"; |
| } |
| type = typeof value; |
| // Only call `getClass` if the value is an object. |
| if (type == "object") { |
| className = getClass.call(value); |
| } |
| switch (className || type) { |
| case "boolean": |
| case booleanClass: |
| // Booleans are represented literally. |
| return "" + value; |
| case "number": |
| case numberClass: |
| // JSON numbers must be finite. `Infinity` and `NaN` are serialized as |
| // `"null"`. |
| return value > -1 / 0 && value < 1 / 0 ? "" + value : "null"; |
| case "string": |
| case stringClass: |
| // Strings are double-quoted and escaped. |
| return quote("" + value); |
| } |
| // Recursively serialize objects and arrays. |
| if (typeof value == "object") { |
| // Check for cyclic structures. This is a linear search; performance |
| // is inversely proportional to the number of unique nested objects. |
| for (length = stack.length; length--;) { |
| if (stack[length] === value) { |
| // Cyclic structures cannot be serialized by `JSON.stringify`. |
| throw TypeError(); |
| } |
| } |
| // Add the object to the stack of traversed objects. |
| stack.push(value); |
| results = []; |
| // Save the current indentation level and indent one additional level. |
| prefix = indentation; |
| indentation += whitespace; |
| if (className == arrayClass) { |
| // Recursively serialize array elements. |
| for (index = 0, length = value.length; index < length; index++) { |
| element = serialize(index, value, callback, properties, whitespace, indentation, stack); |
| results.push(element === undefined ? "null" : element); |
| } |
| result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]"; |
| } else { |
| // Recursively serialize object members. Members are selected from |
| // either a user-specified list of property names, or the object |
| // itself. |
| forOwn(properties || value, function (property) { |
| var element = serialize(property, value, callback, properties, whitespace, indentation, stack); |
| if (element !== undefined) { |
| // According to ES 5.1 section 15.12.3: "If `gap` {whitespace} |
| // is not the empty string, let `member` {quote(property) + ":"} |
| // be the concatenation of `member` and the `space` character." |
| // The "`space` character" refers to the literal space |
| // character, not the `space` {width} argument provided to |
| // `JSON.stringify`. |
| results.push(quote(property) + ":" + (whitespace ? " " : "") + element); |
| } |
| }); |
| result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}"; |
| } |
| // Remove the object from the traversed object stack. |
| stack.pop(); |
| return result; |
| } |
| }; |
| |
| // Public: `JSON.stringify`. See ES 5.1 section 15.12.3. |
| exports.stringify = function (source, filter, width) { |
| var whitespace, callback, properties, className; |
| if (objectTypes[typeof filter] && filter) { |
| className = getClass.call(filter); |
| if (className == functionClass) { |
| callback = filter; |
| } else if (className == arrayClass) { |
| // Convert the property names array into a makeshift set. |
| properties = {}; |
| for (var index = 0, length = filter.length, value; index < length;) { |
| value = filter[index++]; |
| className = getClass.call(value); |
| if (className == "[object String]" || className == "[object Number]") { |
| properties[value] = 1; |
| } |
| } |
| } |
| } |
| if (width) { |
| className = getClass.call(width); |
| if (className == numberClass) { |
| // Convert the `width` to an integer and create a string containing |
| // `width` number of space characters. |
| if ((width -= width % 1) > 0) { |
| if (width > 10) { |
| width = 10; |
| } |
| for (whitespace = ""; whitespace.length < width;) { |
| whitespace += " "; |
| } |
| } |
| } else if (className == stringClass) { |
| whitespace = width.length <= 10 ? width : width.slice(0, 10); |
| } |
| } |
| // Opera <= 7.54u2 discards the values associated with empty string keys |
| // (`""`) only if they are used directly within an object member list |
| // (e.g., `!("" in { "": 1})`). |
| return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []); |
| }; |
| } |
| } |
| |
| // Public: Parses a JSON source string. |
| if (!has("json-parse")) { |
| var fromCharCode = String.fromCharCode; |
| |
| // Internal: A map of escaped control characters and their unescaped |
| // equivalents. |
| var Unescapes = { |
| 92: "\\", |
| 34: '"', |
| 47: "/", |
| 98: "\b", |
| 116: "\t", |
| 110: "\n", |
| 102: "\f", |
| 114: "\r" |
| }; |
| |
| // Internal: Stores the parser state. |
| var Index, Source; |
| |
| // Internal: Resets the parser state and throws a `SyntaxError`. |
| var abort = function () { |
| Index = Source = null; |
| throw SyntaxError(); |
| }; |
| |
| // Internal: Returns the next token, or `"$"` if the parser has reached |
| // the end of the source string. A token may be a string, number, `null` |
| // literal, or Boolean literal. |
| var lex = function () { |
| var source = Source, length = source.length, value, begin, position, isSigned, charCode; |
| while (Index < length) { |
| charCode = source.charCodeAt(Index); |
| switch (charCode) { |
| case 9: case 10: case 13: case 32: |
| // Skip whitespace tokens, including tabs, carriage returns, line |
| // feeds, and space characters. |
| Index++; |
| break; |
| case 123: case 125: case 91: case 93: case 58: case 44: |
| // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at |
| // the current position. |
| value = charIndexBuggy ? source.charAt(Index) : source[Index]; |
| Index++; |
| return value; |
| case 34: |
| // `"` delimits a JSON string; advance to the next character and |
| // begin parsing the string. String tokens are prefixed with the |
| // sentinel `@` character to distinguish them from punctuators and |
| // end-of-string tokens. |
| for (value = "@", Index++; Index < length;) { |
| charCode = source.charCodeAt(Index); |
| if (charCode < 32) { |
| // Unescaped ASCII control characters (those with a code unit |
| // less than the space character) are not permitted. |
| abort(); |
| } else if (charCode == 92) { |
| // A reverse solidus (`\`) marks the beginning of an escaped |
| // control character (including `"`, `\`, and `/`) or Unicode |
| // escape sequence. |
| charCode = source.charCodeAt(++Index); |
| switch (charCode) { |
| case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114: |
| // Revive escaped control characters. |
| value += Unescapes[charCode]; |
| Index++; |
| break; |
| case 117: |
| // `\u` marks the beginning of a Unicode escape sequence. |
| // Advance to the first character and validate the |
| // four-digit code point. |
| begin = ++Index; |
| for (position = Index + 4; Index < position; Index++) { |
| charCode = source.charCodeAt(Index); |
| // A valid sequence comprises four hexdigits (case- |
| // insensitive) that form a single hexadecimal value. |
| if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) { |
| // Invalid Unicode escape sequence. |
| abort(); |
| } |
| } |
| // Revive the escaped character. |
| value += fromCharCode("0x" + source.slice(begin, Index)); |
| break; |
| default: |
| // Invalid escape sequence. |
| abort(); |
| } |
| } else { |
| if (charCode == 34) { |
| // An unescaped double-quote character marks the end of the |
| // string. |
| break; |
| } |
| charCode = source.charCodeAt(Index); |
| begin = Index; |
| // Optimize for the common case where a string is valid. |
| while (charCode >= 32 && charCode != 92 && charCode != 34) { |
| charCode = source.charCodeAt(++Index); |
| } |
| // Append the string as-is. |
| value += source.slice(begin, Index); |
| } |
| } |
| if (source.charCodeAt(Index) == 34) { |
| // Advance to the next character and return the revived string. |
| Index++; |
| return value; |
| } |
| // Unterminated string. |
| abort(); |
| default: |
| // Parse numbers and literals. |
| begin = Index; |
| // Advance past the negative sign, if one is specified. |
| if (charCode == 45) { |
| isSigned = true; |
| charCode = source.charCodeAt(++Index); |
| } |
| // Parse an integer or floating-point value. |
| if (charCode >= 48 && charCode <= 57) { |
| // Leading zeroes are interpreted as octal literals. |
| if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) { |
| // Illegal octal literal. |
| abort(); |
| } |
| isSigned = false; |
| // Parse the integer component. |
| for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++); |
| // Floats cannot contain a leading decimal point; however, this |
| // case is already accounted for by the parser. |
| if (source.charCodeAt(Index) == 46) { |
| position = ++Index; |
| // Parse the decimal component. |
| for (; position < length; position++) { |
| charCode = source.charCodeAt(position); |
| if (charCode < 48 || charCode > 57) { |
| break; |
| } |
| } |
| if (position == Index) { |
| // Illegal trailing decimal. |
| abort(); |
| } |
| Index = position; |
| } |
| // Parse exponents. The `e` denoting the exponent is |
| // case-insensitive. |
| charCode = source.charCodeAt(Index); |
| if (charCode == 101 || charCode == 69) { |
| charCode = source.charCodeAt(++Index); |
| // Skip past the sign following the exponent, if one is |
| // specified. |
| if (charCode == 43 || charCode == 45) { |
| Index++; |
| } |
| // Parse the exponential component. |
| for (position = Index; position < length; position++) { |
| charCode = source.charCodeAt(position); |
| if (charCode < 48 || charCode > 57) { |
| break; |
| } |
| } |
| if (position == Index) { |
| // Illegal empty exponent. |
| abort(); |
| } |
| Index = position; |
| } |
| // Coerce the parsed value to a JavaScript number. |
| return +source.slice(begin, Index); |
| } |
| // A negative sign may only precede numbers. |
| if (isSigned) { |
| abort(); |
| } |
| // `true`, `false`, and `null` literals. |
| var temp = source.slice(Index, Index + 4); |
| if (temp == "true") { |
| Index += 4; |
| return true; |
| } else if (temp == "fals" && source.charCodeAt(Index + 4 ) == 101) { |
| Index += 5; |
| return false; |
| } else if (temp == "null") { |
| Index += 4; |
| return null; |
| } |
| // Unrecognized token. |
| abort(); |
| } |
| } |
| // Return the sentinel `$` character if the parser has reached the end |
| // of the source string. |
| return "$"; |
| }; |
| |
| // Internal: Parses a JSON `value` token. |
| var get = function (value) { |
| var results, hasMembers; |
| if (value == "$") { |
| // Unexpected end of input. |
| abort(); |
| } |
| if (typeof value == "string") { |
| if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") { |
| // Remove the sentinel `@` character. |
| return value.slice(1); |
| } |
| // Parse object and array literals. |
| if (value == "[") { |
| // Parses a JSON array, returning a new JavaScript array. |
| results = []; |
| for (;;) { |
| value = lex(); |
| // A closing square bracket marks the end of the array literal. |
| if (value == "]") { |
| break; |
| } |
| // If the array literal contains elements, the current token |
| // should be a comma separating the previous element from the |
| // next. |
| if (hasMembers) { |
| if (value == ",") { |
| value = lex(); |
| if (value == "]") { |
| // Unexpected trailing `,` in array literal. |
| abort(); |
| } |
| } else { |
| // A `,` must separate each array element. |
| abort(); |
| } |
| } else { |
| hasMembers = true; |
| } |
| // Elisions and leading commas are not permitted. |
| if (value == ",") { |
| abort(); |
| } |
| results.push(get(value)); |
| } |
| return results; |
| } else if (value == "{") { |
| // Parses a JSON object, returning a new JavaScript object. |
| results = {}; |
| for (;;) { |
| value = lex(); |
| // A closing curly brace marks the end of the object literal. |
| if (value == "}") { |
| break; |
| } |
| // If the object literal contains members, the current token |
| // should be a comma separator. |
| if (hasMembers) { |
| if (value == ",") { |
| value = lex(); |
| if (value == "}") { |
| // Unexpected trailing `,` in object literal. |
| abort(); |
| } |
| } else { |
| // A `,` must separate each object member. |
| abort(); |
| } |
| } else { |
| hasMembers = true; |
| } |
| // Leading commas are not permitted, object property names must be |
| // double-quoted strings, and a `:` must separate each property |
| // name and value. |
| if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") { |
| abort(); |
| } |
| results[value.slice(1)] = get(lex()); |
| } |
| return results; |
| } |
| // Unexpected token encountered. |
| abort(); |
| } |
| return value; |
| }; |
| |
| // Internal: Updates a traversed object member. |
| var update = function (source, property, callback) { |
| var element = walk(source, property, callback); |
| if (element === undefined) { |
| delete source[property]; |
| } else { |
| source[property] = element; |
| } |
| }; |
| |
| // Internal: Recursively traverses a parsed JSON object, invoking the |
| // `callback` function for each value. This is an implementation of the |
| // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2. |
| var walk = function (source, property, callback) { |
| var value = source[property], length; |
| if (typeof value == "object" && value) { |
| // `forOwn` can't be used to traverse an array in Opera <= 8.54 |
| // because its `Object#hasOwnProperty` implementation returns `false` |
| // for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`). |
| if (getClass.call(value) == arrayClass) { |
| for (length = value.length; length--;) { |
| update(getClass, forOwn, value, length, callback); |
| } |
| } else { |
| forOwn(value, function (property) { |
| update(value, property, callback); |
| }); |
| } |
| } |
| return callback.call(source, property, value); |
| }; |
| |
| // Public: `JSON.parse`. See ES 5.1 section 15.12.2. |
| exports.parse = function (source, callback) { |
| var result, value; |
| Index = 0; |
| Source = "" + source; |
| result = get(lex()); |
| // If a JSON string contains multiple tokens, it is invalid. |
| if (lex() != "$") { |
| abort(); |
| } |
| // Reset the parser state. |
| Index = Source = null; |
| return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result; |
| }; |
| } |
| } |
| |
| exports.runInContext = runInContext; |
| return exports; |
| } |
| |
| if (freeExports && !isLoader) { |
| // Export for CommonJS environments. |
| runInContext(root, freeExports); |
| } else { |
| // Export for web browsers and JavaScript engines. |
| var nativeJSON = root.JSON, |
| previousJSON = root.JSON3, |
| isRestored = false; |
| |
| var JSON3 = runInContext(root, (root.JSON3 = { |
| // Public: Restores the original value of the global `JSON` object and |
| // returns a reference to the `JSON3` object. |
| "noConflict": function () { |
| if (!isRestored) { |
| isRestored = true; |
| root.JSON = nativeJSON; |
| root.JSON3 = previousJSON; |
| nativeJSON = previousJSON = null; |
| } |
| return JSON3; |
| } |
| })); |
| |
| root.JSON = { |
| "parse": JSON3.parse, |
| "stringify": JSON3.stringify |
| }; |
| } |
| |
| // Export for asynchronous module loaders. |
| if (isLoader) { |
| define(function () { |
| return JSON3; |
| }); |
| } |
| }).call(this); |
