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