      1 /*
      2     http://www.JSON.org/json2.js
      3     2009-08-17
      4
      5     Public Domain.
      6
      7     NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
      8
      9     See http://www.JSON.org/js.html
     10
     11     This file creates a global JSON object containing two methods: stringify
     12     and parse.
     13
     14         JSON.stringify(value, replacer, space)
     15             value       any JavaScript value, usually an object or array.
     16
     17             replacer    an optional parameter that determines how object
     18                         values are stringified for objects. It can be a
     19                         function or an array of strings.
     20
     21             space       an optional parameter that specifies the indentation
     22                         of nested structures. If it is omitted, the text will
     23                         be packed without extra whitespace. If it is a number,
     24                         it will specify the number of spaces to indent at each
     25                         level. If it is a string (such as '\t' or ' '),
     26                         it contains the characters used to indent at each level.
     27
     28             This method produces a JSON text from a JavaScript value.
     29
     30             When an object value is found, if the object contains a toJSON
     31             method, its toJSON method will be called and the result will be
     32             stringified. A toJSON method does not serialize: it returns the
     33             value represented by the name/value pair that should be serialized,
     34             or undefined if nothing should be serialized. The toJSON method
     35             will be passed the key associated with the value, and this will be
     36             bound to the value
     37
     38             For example, this would serialize Dates as ISO strings.
     39
     40                 Date.prototype.toJSON = function (key) {
     41                     function f(n) {
     42                         // Format integers to have at least two digits.
     43                         return n < 10 ? '0' + n : n;
     44                     }
     45
     46                     return this.getUTCFullYear()   + '-' +
     47                          f(this.getUTCMonth() + 1) + '-' +
     48                          f(this.getUTCDate())      + 'T' +
     49                          f(this.getUTCHours())     + ':' +
     50                          f(this.getUTCMinutes())   + ':' +
     51                          f(this.getUTCSeconds())   + 'Z';
     52                 };
     53
     54             You can provide an optional replacer method. It will be passed the
     55             key and value of each member, with this bound to the containing
     56             object. The value that is returned from your method will be
     57             serialized. If your method returns undefined, then the member will
     58             be excluded from the serialization.
     59
     60             If the replacer parameter is an array of strings, then it will be
     61             used to select the members to be serialized. It filters the results
     62             such that only members with keys listed in the replacer array are
     63             stringified.
     64
     65             Values that do not have JSON representations, such as undefined or
     66             functions, will not be serialized. Such values in objects will be
     67             dropped; in arrays they will be replaced with null. You can use
     68             a replacer function to replace those with JSON values.
     69             JSON.stringify(undefined) returns undefined.
     70
     71             The optional space parameter produces a stringification of the
     72             value that is filled with line breaks and indentation to make it
     73             easier to read.
     74
     75             If the space parameter is a non-empty string, then that string will
     76             be used for indentation. If the space parameter is a number, then
     77             the indentation will be that many spaces.
     78
     79             Example:
     80
     81             text = JSON.stringify(['e', {pluribus: 'unum'}]);
     82             // text is '["e",{"pluribus":"unum"}]'
     83
     84
     85             text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
     86             // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
     87
     88             text = JSON.stringify([new Date()], function (key, value) {
     89                 return this[key] instanceof Date ?
     90                     'Date(' + this[key] + ')' : value;
     91             });
     92             // text is '["Date(---current time---)"]'
     93
     94
     95         JSON.parse(text, reviver)
     96             This method parses a JSON text to produce an object or array.
     97             It can throw a SyntaxError exception.
     98
     99             The optional reviver parameter is a function that can filter and
    100             transform the results. It receives each of the keys and values,
    101             and its return value is used instead of the original value.
    102             If it returns what it received, then the structure is not modified.
    103             If it returns undefined then the member is deleted.
    104
    105             Example:
    106
    107             // Parse the text. Values that look like ISO date strings will
    108             // be converted to Date objects.
    109
    110             myData = JSON.parse(text, function (key, value) {
    111                 var a;
    112                 if (typeof value === 'string') {
    113                     a =
    114 /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
    115                     if (a) {
    116                         return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
    117                             +a[5], +a[6]));
    118                     }
    119                 }
    120                 return value;
    121             });
    122
    123             myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
    124                 var d;
    125                 if (typeof value === 'string' &&
    126                         value.slice(0, 5) === 'Date(' &&
    127                         value.slice(-1) === ')') {
    128                     d = new Date(value.slice(5, -1));
    129                     if (d) {
    130                         return d;
    131                     }
    132                 }
    133                 return value;
    134             });
    135
    136
    137     This is a reference implementation. You are free to copy, modify, or
    138     redistribute.
    139
    140     This code should be minified before deployment.
    141     See http://javascript.crockford.com/jsmin.html
    142
    143     USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
    144     NOT CONTROL.
    145 */
    146
    147 /*jslint evil: true */
    148
    149 /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
    150     call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
    151     getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
    152     lastIndex, length, parse, prototype, push, replace, slice, stringify,
    153     test, toJSON, toString, valueOf
    154 */
    155
    156 "use strict";
    157
    158 // Create a JSON object only if one does not already exist. We create the
    159 // methods in a closure to avoid creating global variables.
    160
    161 if (!this.JSON) {
    162     this.JSON = {};
    163 }
    164
    165 (function () {
    166
    167     function f(n) {
    168         // Format integers to have at least two digits.
    169         return n < 10 ? '0' + n : n;
    170     }
    171
    172     if (typeof Date.prototype.toJSON !== 'function') {
    173
    174         Date.prototype.toJSON = function (key) {
    175
    176             return isFinite(this.valueOf()) ?
    177                    this.getUTCFullYear()   + '-' +
    178                  f(this.getUTCMonth() + 1) + '-' +
    179                  f(this.getUTCDate())      + 'T' +
    180                  f(this.getUTCHours())     + ':' +
    181                  f(this.getUTCMinutes())   + ':' +
    182                  f(this.getUTCSeconds())   + 'Z' : null;
    183         };
    184
    185         String.prototype.toJSON =
    186         Number.prototype.toJSON =
    187         Boolean.prototype.toJSON = function (key) {
    188             return this.valueOf();
    189         };
    190     }
    191
    192     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
    193         escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
    194         gap,
    195         indent,
    196         meta = {    // table of character substitutions
    197             '\b': '\\b',
    198             '\t': '\\t',
    199             '\n': '\\n',
    200             '\f': '\\f',
    201             '\r': '\\r',
    202             '"' : '\\"',
    203             '\\': '\\\\'
    204         },
    205         rep;
    206
    207
    208     function quote(string) {
    209
    210 // If the string contains no control characters, no quote characters, and no
    211 // backslash characters, then we can safely slap some quotes around it.
    212 // Otherwise we must also replace the offending characters with safe escape
    213 // sequences.
    214
    215         escapable.lastIndex = 0;
    216         return escapable.test(string) ?
    217             '"' + string.replace(escapable, function (a) {
    218                 var c = meta[a];
    219                 return typeof c === 'string' ? c :
    220                     '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
    221             }) + '"' :
    222             '"' + string + '"';
    223     }
    224
    225
    226     function str(key, holder) {
    227 // Produce a string from holder[key].
    228
    229         var i,          // The loop counter.
    230             k,          // The member key.
    231             v,          // The member value.
    232             length,
    233             mind = gap,
    234             partial,
    235             value = holder[key];
    236
    237 // If the value has a toJSON method, call it to obtain a replacement value.
    238
    239         if (value && typeof value === 'object' &&
    240                 typeof value.toJSON === 'function') {
    241             value = value.toJSON(key);
    242         }
    243
    244 // If we were called with a replacer function, then call the replacer to
    245 // obtain a replacement value.
    246
    247         if (typeof rep === 'function') {
    248             value = rep.call(holder, key, value);
    249         }
    250
    251 // What happens next depends on the value's type.
    252
    253         switch (typeof value) {
    254         case 'string':
    255             return quote(value);
    256
    257         case 'number':
    258
    259 // JSON numbers must be finite. Encode non-finite numbers as null.
    260
    261             return isFinite(value) ? String(value) : 'null';
    262
    263         case 'boolean':
    264         case 'null':
    265
    266 // If the value is a boolean or null, convert it to a string. Note:
    267 // typeof null does not produce 'null'. The case is included here in
    268 // the remote chance that this gets fixed someday.
    269
    270             return String(value);
    271
    272 // If the type is 'object', we might be dealing with an object or an array or
    273 // null.
    274
    275         case 'object':
    276
    277 // Due to a specification blunder in ECMAScript, typeof null is 'object',
    278 // so watch out for that case.
    279
    280             if (!value) {
    281                 return 'null';
    282             }
    283
    284 // Make an array to hold the partial results of stringifying this object value.
    285
    286             gap += indent;
    287             partial = [];
    288
    289 // Is the value an array?
    290
    291             if (Object.prototype.toString.apply(value) === '[object Array]') {
    292
    293 // The value is an array. Stringify every element. Use null as a placeholder
    294 // for non-JSON values.
    295
    296                 length = value.length;
    297                 for (i = 0; i < length; i += 1) {
    298                     partial[i] = str(i, value) || 'null';
    299                 }
    300
    301 // Join all of the elements together, separated with commas, and wrap them in
    302 // brackets.
    303
    304                 v = partial.length === 0 ? '[]' :
    305                     gap ? '[\n' + gap +
    306                             partial.join(',\n' + gap) + '\n' +
    307                                 mind + ']' :
    308                           '[' + partial.join(',') + ']';
    309                 gap = mind;
    310                 return v;
    311             }
    312
    313 // If the replacer is an array, use it to select the members to be stringified.
    314
    315             if (rep && typeof rep === 'object') {
    316                 length = rep.length;
    317                 for (i = 0; i < length; i += 1) {
    318                     k = rep[i];
    319                     if (typeof k === 'string') {
    320                         v = str(k, value);
    321                         if (v) {
    322                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
    323                         }
    324                     }
    325                 }
    326             } else {
    327
    328 // Otherwise, iterate through all of the keys in the object.
    329
    330                 for (k in value) {
    331                     if (Object.hasOwnProperty.call(value, k)) {
    332                         v = str(k, value);
    333                         if (v) {
    334                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
    335                         }
    336                     }
    337                 }
    338             }
    339
    340 // Join all of the member texts together, separated with commas,
    341 // and wrap them in braces.
    342
    343             v = partial.length === 0 ? '{}' :
    344                 gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
    345                         mind + '}' : '{' + partial.join(',') + '}';
    346             gap = mind;
    347             return v;
    348         }
    349     }
    350
    351 // If the JSON object does not yet have a stringify method, give it one.
    352
    353     if (typeof JSON.stringify !== 'function') {
    354         JSON.stringify = function (value, replacer, space) {
    355 // The stringify method takes a value and an optional replacer, and an optional
    356 // space parameter, and returns a JSON text. The replacer can be a function
    357 // that can replace values, or an array of strings that will select the keys.
    358 // A default replacer method can be provided. Use of the space parameter can
    359 // produce text that is more easily readable.
    360
    361             var i;
    362             gap = '';
    363             indent = '';
    364
    365 // If the space parameter is a number, make an indent string containing that
    366 // many spaces.
    367
    368             if (typeof space === 'number') {
    369                 for (i = 0; i < space; i += 1) {
    370                     indent += ' ';
    371                 }
    372
    373 // If the space parameter is a string, it will be used as the indent string.
    374
    375             } else if (typeof space === 'string') {
    376                 indent = space;
    377             }
    378
    379 // If there is a replacer, it must be a function or an array.
    380 // Otherwise, throw an error.
    381
    382             rep = replacer;
    383             if (replacer && typeof replacer !== 'function' &&
    384                     (typeof replacer !== 'object' ||
    385                      typeof replacer.length !== 'number')) {
    386                 throw new Error('JSON.stringify');
    387             }
    388
    389 // Make a fake root object containing our value under the key of ''.
    390 // Return the result of stringifying the value.
    391
    392             return str('', {'': value});
    393         };
    394     }
    395
    396
    397 // If the JSON object does not yet have a parse method, give it one.
    398
    399     if (typeof JSON.parse !== 'function') {
    400         JSON.parse = function (text, reviver) {
    401
    402 // The parse method takes a text and an optional reviver function, and returns
    403 // a JavaScript value if the text is a valid JSON text.
    404
    405             var j;
    406
    407             function walk(holder, key) {
    408
    409 // The walk method is used to recursively walk the resulting structure so
    410 // that modifications can be made.
    411
    412                 var k, v, value = holder[key];
    413                 if (value && typeof value === 'object') {
    414                     for (k in value) {
    415                         if (Object.hasOwnProperty.call(value, k)) {
    416                             v = walk(value, k);
    417                             if (v !== undefined) {
    418                                 value[k] = v;
    419                             } else {
    420                                 delete value[k];
    421                             }
    422                         }
    423                     }
    424                 }
    425                 return reviver.call(holder, key, value);
    426             }
    427
    428
    429 // Parsing happens in four stages. In the first stage, we replace certain
    430 // Unicode characters with escape sequences. JavaScript handles many characters
    431 // incorrectly, either silently deleting them, or treating them as line endings.
    432
    433             cx.lastIndex = 0;
    434             if (cx.test(text)) {
    435                 text = text.replace(cx, function (a) {
    436                     return '\\u' +
    437                         ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
    438                 });
    439             }
    440
    441 // In the second stage, we run the text against regular expressions that look
    442 // for non-JSON patterns. We are especially concerned with '()' and 'new'
    443 // because they can cause invocation, and '=' because it can cause mutation.
    444 // But just to be safe, we want to reject all unexpected forms.
    445
    446 // We split the second stage into 4 regexp operations in order to work around
    447 // crippling inefficiencies in IE's and Safari's regexp engines. First we
    448 // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
    449 // replace all simple value tokens with ']' characters. Third, we delete all
    450 // open brackets that follow a colon or comma or that begin the text. Finally,
    451 // we look to see that the remaining characters are only whitespace or ']' or
    452 // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
    453
    454             if (/^[\],:{}\s]*$/.
    455 test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
    456 replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
    457 replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
    458
    459 // In the third stage we use the eval function to compile the text into a
    460 // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
    461 // in JavaScript: it can begin a block or an object literal. We wrap the text
    462 // in parens to eliminate the ambiguity.
    463
    464                 j = eval('(' + text + ')');
    465
    466 // In the optional fourth stage, we recursively walk the new structure, passing
    467 // each name/value pair to a reviver function for possible transformation.
    468
    469                 return typeof reviver === 'function' ?
    470                     walk({'': j}, '') : j;
    471             }
    472
    473 // If the text is not JSON parseable, then a SyntaxError is thrown.
    474
    475             throw new SyntaxError('JSON.parse');
    476         };
    477     }
    478 }());
    479