metadataplayer: comparison src/js/libs/json2.js

Mercurial Mercurial > metadataplayer / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/js/libs/json2.js

changeset 1057	3f20f286d43e
parent 917	eb8677d3a663

equal deleted inserted replaced

-:3d19cbe56fcb
+:3f20f286d43e
 /*
 json2.js
-2011-10-19
+2015-05-03
 Public Domain.
 NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
 USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
 NOT CONTROL.
 This file creates a global JSON object containing two methods: stringify
-and parse.
+and parse. This file is provides the ES5 JSON capability to ES3 systems.
+If a project might run on IE8 or earlier, then this file should be included.
+This file does nothing on ES5 systems.
 JSON.stringify(value, replacer, space)
 value       any JavaScript value, usually an object or array.
 replacer    an optional parameter that determines how object
 For example, this would serialize Dates as ISO strings.
 Date.prototype.toJSON = function (key) {
 function f(n) {
 // Format integers to have at least two digits.
-return n < 10 ? '0' + n : n;
+return n < 10
+? '0' + n
+: n;
 }
 return this.getUTCFullYear()   + '-' +
 f(this.getUTCMonth() + 1) + '-' +
 f(this.getUTCDate())      + 'T' +
 text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
 // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
 text = JSON.stringify([new Date()], function (key, value) {
-return this[key] instanceof Date ?
+return this[key] instanceof Date
-'Date(' + this[key] + ')' : value;
+? 'Date(' + this[key] + ')'
+: value;
 });
 // text is '["Date(---current time---)"]'
 JSON.parse(text, reviver)
 This is a reference implementation. You are free to copy, modify, or
 redistribute.
 */
-/*jslint evil: true, regexp: true */
+/*jslint
+eval, for, this
-/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
+*/
-call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
+/*property
+JSON, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
 getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
 lastIndex, length, parse, prototype, push, replace, slice, stringify,
 test, toJSON, toString, valueOf
 */
 // Create a JSON object only if one does not already exist. We create the
 // methods in a closure to avoid creating global variables.
-var JSON;
+if (typeof JSON !== 'object') {
-if (!JSON) {
 JSON = {};
 }
 (function () {
 'use strict';
+var rx_one = /^[\],:{}\s]*$/,
+rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
+rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
+rx_four = /(?:^|:|,)(?:\s*\[)+/g,
+rx_escapable = /[\\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
 function f(n) {
 // Format integers to have at least two digits.
-return n < 10 ? '0' + n : n;
+return n < 10
+? '0' + n
+: n;
+}
+function this_value() {
+return this.valueOf();
 }
 if (typeof Date.prototype.toJSON !== 'function') {
-Date.prototype.toJSON = function (key) {
+Date.prototype.toJSON = function () {
 return isFinite(this.valueOf())
-? this.getUTCFullYear()     + '-' +
+? this.getUTCFullYear() + '-' +
 f(this.getUTCMonth() + 1) + '-' +
-f(this.getUTCDate())      + 'T' +
+f(this.getUTCDate()) + 'T' +
-f(this.getUTCHours())     + ':' +
+f(this.getUTCHours()) + ':' +
-f(this.getUTCMinutes())   + ':' +
+f(this.getUTCMinutes()) + ':' +
-f(this.getUTCSeconds())   + 'Z'
+f(this.getUTCSeconds()) + 'Z'
 : null;
 };
-String.prototype.toJSON      =
+Boolean.prototype.toJSON = this_value;
-Number.prototype.toJSON  =
+Number.prototype.toJSON = this_value;
-Boolean.prototype.toJSON = function (key) {
+String.prototype.toJSON = this_value;
-return this.valueOf();
+}
-};
-}
+var gap,
-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,
-gap,
 indent,
-meta = {    // table of character substitutions
+meta,
-'\b': '\\b',
-'\t': '\\t',
-'\n': '\\n',
-'\f': '\\f',
-'\r': '\\r',
-'"' : '\\"',
-'\\': '\\\\'
-},
 rep;
 function quote(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;
+rx_escapable.lastIndex = 0;
-return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+return rx_escapable.test(string)
-var c = meta[a];
+? '"' + string.replace(rx_escapable, function (a) {
-return typeof c === 'string'
+var c = meta[a];
-? c
+return typeof c === 'string'
-: '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+? c
-}) + '"' : '"' + string + '"';
+: '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+}) + '"'
+: '"' + string + '"';
 }
 function str(key, holder) {
 case 'number':
 // JSON numbers must be finite. Encode non-finite numbers as null.
-return isFinite(value) ? String(value) : 'null';
+return isFinite(value)
+? String(value)
+: 'null';
 case 'boolean':
 case 'null':
 // If the value is a boolean or null, convert it to a string. Note:
 // brackets.
 v = partial.length === 0
 ? '[]'
 : gap
 ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
 : '[' + partial.join(',') + ']';
 gap = mind;
 return v;
 }
 // If the replacer is an array, use it to select the members to be stringified.
 for (i = 0; i < length; i += 1) {
 if (typeof rep[i] === 'string') {
 k = rep[i];
 v = str(k, value);
 if (v) {
-partial.push(quote(k) + (gap ? ': ' : ':') + v);
+partial.push(quote(k) + (
+gap
+? ': '
+: ':'
+) + v);
 }
 }
 }
 } else {
 for (k in value) {
 if (Object.prototype.hasOwnProperty.call(value, k)) {
 v = str(k, value);
 if (v) {
-partial.push(quote(k) + (gap ? ': ' : ':') + v);
+partial.push(quote(k) + (
+gap
+? ': '
+: ':'
+) + v);
 }
 }
 }
 }
 // and wrap them in braces.
 v = partial.length === 0
 ? '{}'
 : gap
 ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
 : '{' + partial.join(',') + '}';
 gap = mind;
 return v;
 }
 }
 // If the JSON object does not yet have a stringify method, give it one.
 if (typeof JSON.stringify !== 'function') {
+meta = {    // table of character substitutions
+'\b': '\\b',
+'\t': '\\t',
+'\n': '\\n',
+'\f': '\\f',
+'\r': '\\r',
+'"': '\\"',
+'\\': '\\\\'
+};
 JSON.stringify = function (value, replacer, space) {
 // The stringify method takes a value and an optional replacer, and an optional
 // space parameter, and returns a JSON text. The replacer can be a function
 // that can replace values, or an array of strings that will select the keys.
 // Parsing happens in four stages. In the first stage, we replace certain
 // Unicode characters with escape sequences. JavaScript handles many characters
 // incorrectly, either silently deleting them, or treating them as line endings.
 text = String(text);
-cx.lastIndex = 0;
+rx_dangerous.lastIndex = 0;
-if (cx.test(text)) {
+if (rx_dangerous.test(text)) {
-text = text.replace(cx, function (a) {
+text = text.replace(rx_dangerous, function (a) {
 return '\\u' +
 ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
 });
 }
 // In the second stage, we run the text against regular expressions that look
 // for non-JSON patterns. We are especially concerned with '()' and 'new'
 // replace all simple value tokens with ']' characters. Third, we delete all
 // open brackets that follow a colon or comma or that begin the text. Finally,
 // we look to see that the remaining characters are only whitespace or ']' or
 // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
-if (/^[\],:{}\s]*$/
+if (
-.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+rx_one.test(
-.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+text
-.replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+.replace(rx_two, '@')
+.replace(rx_three, ']')
+.replace(rx_four, '')
+)
+) {
 // In the third stage we use the eval function to compile the text into a
 // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
 // in JavaScript: it can begin a block or an object literal. We wrap the text
 // in parens to eliminate the ambiguity.

metadataplayer