← Back to branch summary

~caneypuggies/reformedchurcheslocator/couchapp-backbone

« back to all changes in this revision

Viewing changes to _attachments/js/vendor/backbone/test/vendor/json2.js

  • Committer: Tim Black
  • Date: 2013-09-16 22:50:16 UTC
  • Revision ID: tim@alwaysreformed.com-20130916225016-zk8jiba25z33ew7h
Versioned Bower vendor directory

Show diffs side-by-side

added added

removed removed

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