xonecas.io
1361
Xc

xonecas.com / commit cd833a6

cleanup of old code on experimental branch

sean2011-09-13 cd833a63f31571f45e10a54a3eca57d4a0d43453 parent 1918f5e

8 files changed

This diff is too big to show in full. The first 1000 lines are below, and every file is listed with its counts.

libs/all.js+0−11452
@@ -1,11452 +0,0 @@
1-/*
2- http://www.JSON.org/json2.js
3- 2011-02-23
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, regexp: 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-var JSON;
163-if (!JSON) {
164- JSON = {};
165-}
166-
167-(function () {
168- "use strict";
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) ? '"' + string.replace(escapable, function (a) {
220- var c = meta[a];
221- return typeof c === 'string' ? c :
222- '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
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 ? '[]' : gap ?
307- '[\n' + gap + partial.join(',\n' + gap) + '\n' + 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- if (typeof rep[i] === 'string') {
319- k = rep[i];
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.prototype.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 ? '{}' : gap ?
344- '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
345- '{' + 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-
356-// The stringify method takes a value and an optional replacer, and an optional
357-// space parameter, and returns a JSON text. The replacer can be a function
358-// that can replace values, or an array of strings that will select the keys.
359-// A default replacer method can be provided. Use of the space parameter can
360-// produce text that is more easily readable.
361-
362- var i;
363- gap = '';
364- indent = '';
365-
366-// If the space parameter is a number, make an indent string containing that
367-// many spaces.
368-
369- if (typeof space === 'number') {
370- for (i = 0; i < space; i += 1) {
371- indent += ' ';
372- }
373-
374-// If the space parameter is a string, it will be used as the indent string.
375-
376- } else if (typeof space === 'string') {
377- indent = space;
378- }
379-
380-// If there is a replacer, it must be a function or an array.
381-// Otherwise, throw an error.
382-
383- rep = replacer;
384- if (replacer && typeof replacer !== 'function' &&
385- (typeof replacer !== 'object' ||
386- typeof replacer.length !== 'number')) {
387- throw new Error('JSON.stringify');
388- }
389-
390-// Make a fake root object containing our value under the key of ''.
391-// Return the result of stringifying the value.
392-
393- return str('', {'': value});
394- };
395- }
396-
397-
398-// If the JSON object does not yet have a parse method, give it one.
399-
400- if (typeof JSON.parse !== 'function') {
401- JSON.parse = function (text, reviver) {
402-
403-// The parse method takes a text and an optional reviver function, and returns
404-// a JavaScript value if the text is a valid JSON text.
405-
406- var j;
407-
408- function walk(holder, key) {
409-
410-// The walk method is used to recursively walk the resulting structure so
411-// that modifications can be made.
412-
413- var k, v, value = holder[key];
414- if (value && typeof value === 'object') {
415- for (k in value) {
416- if (Object.prototype.hasOwnProperty.call(value, k)) {
417- v = walk(value, k);
418- if (v !== undefined) {
419- value[k] = v;
420- } else {
421- delete value[k];
422- }
423- }
424- }
425- }
426- return reviver.call(holder, key, value);
427- }
428-
429-
430-// Parsing happens in four stages. In the first stage, we replace certain
431-// Unicode characters with escape sequences. JavaScript handles many characters
432-// incorrectly, either silently deleting them, or treating them as line endings.
433-
434- text = String(text);
435- cx.lastIndex = 0;
436- if (cx.test(text)) {
437- text = text.replace(cx, function (a) {
438- return '\\u' +
439- ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
440- });
441- }
442-
443-// In the second stage, we run the text against regular expressions that look
444-// for non-JSON patterns. We are especially concerned with '()' and 'new'
445-// because they can cause invocation, and '=' because it can cause mutation.
446-// But just to be safe, we want to reject all unexpected forms.
447-
448-// We split the second stage into 4 regexp operations in order to work around
449-// crippling inefficiencies in IE's and Safari's regexp engines. First we
450-// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
451-// replace all simple value tokens with ']' characters. Third, we delete all
452-// open brackets that follow a colon or comma or that begin the text. Finally,
453-// we look to see that the remaining characters are only whitespace or ']' or
454-// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
455-
456- if (/^[\],:{}\s]*$/
457- .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
458- .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
459- .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
460-
461-// In the third stage we use the eval function to compile the text into a
462-// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
463-// in JavaScript: it can begin a block or an object literal. We wrap the text
464-// in parens to eliminate the ambiguity.
465-
466- j = eval('(' + text + ')');
467-
468-// In the optional fourth stage, we recursively walk the new structure, passing
469-// each name/value pair to a reviver function for possible transformation.
470-
471- return typeof reviver === 'function' ?
472- walk({'': j}, '') : j;
473- }
474-
475-// If the text is not JSON parseable, then a SyntaxError is thrown.
476-
477- throw new SyntaxError('JSON.parse');
478- };
479- }
480-}());
481-
482-/*!
483- * jQuery JavaScript Library v1.6.2
484- * http://jquery.com/
485- *
486- * Copyright 2011, John Resig
487- * Dual licensed under the MIT or GPL Version 2 licenses.
488- * http://jquery.org/license
489- *
490- * Includes Sizzle.js
491- * http://sizzlejs.com/
492- * Copyright 2011, The Dojo Foundation
493- * Released under the MIT, BSD, and GPL Licenses.
494- *
495- * Date: Thu Jun 30 14:16:56 2011 -0400
496- */
497-(function( window, undefined ) {
498-
499-// Use the correct document accordingly with window argument (sandbox)
500-var document = window.document,
501- navigator = window.navigator,
502- location = window.location;
503-var jQuery = (function() {
504-
505-// Define a local copy of jQuery
506-var jQuery = function( selector, context ) {
507- // The jQuery object is actually just the init constructor 'enhanced'
508- return new jQuery.fn.init( selector, context, rootjQuery );
509- },
510-
511- // Map over jQuery in case of overwrite
512- _jQuery = window.jQuery,
513-
514- // Map over the $ in case of overwrite
515- _$ = window.$,
516-
517- // A central reference to the root jQuery(document)
518- rootjQuery,
519-
520- // A simple way to check for HTML strings or ID strings
521- // (both of which we optimize for)
522- quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
523-
524- // Check if a string has a non-whitespace character in it
525- rnotwhite = /\S/,
526-
527- // Used for trimming whitespace
528- trimLeft = /^\s+/,
529- trimRight = /\s+$/,
530-
531- // Check for digits
532- rdigit = /\d/,
533-
534- // Match a standalone tag
535- rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
536-
537- // JSON RegExp
538- rvalidchars = /^[\],:{}\s]*$/,
539- rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
540- rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
541- rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
542-
543- // Useragent RegExp
544- rwebkit = /(webkit)[ \/]([\w.]+)/,
545- ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
546- rmsie = /(msie) ([\w.]+)/,
547- rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
548-
549- // Matches dashed string for camelizing
550- rdashAlpha = /-([a-z])/ig,
551-
552- // Used by jQuery.camelCase as callback to replace()
553- fcamelCase = function( all, letter ) {
554- return letter.toUpperCase();
555- },
556-
557- // Keep a UserAgent string for use with jQuery.browser
558- userAgent = navigator.userAgent,
559-
560- // For matching the engine and version of the browser
561- browserMatch,
562-
563- // The deferred used on DOM ready
564- readyList,
565-
566- // The ready event handler
567- DOMContentLoaded,
568-
569- // Save a reference to some core methods
570- toString = Object.prototype.toString,
571- hasOwn = Object.prototype.hasOwnProperty,
572- push = Array.prototype.push,
573- slice = Array.prototype.slice,
574- trim = String.prototype.trim,
575- indexOf = Array.prototype.indexOf,
576-
577- // [[Class]] -> type pairs
578- class2type = {};
579-
580-jQuery.fn = jQuery.prototype = {
581- constructor: jQuery,
582- init: function( selector, context, rootjQuery ) {
583- var match, elem, ret, doc;
584-
585- // Handle $(""), $(null), or $(undefined)
586- if ( !selector ) {
587- return this;
588- }
589-
590- // Handle $(DOMElement)
591- if ( selector.nodeType ) {
592- this.context = this[0] = selector;
593- this.length = 1;
594- return this;
595- }
596-
597- // The body element only exists once, optimize finding it
598- if ( selector === "body" && !context && document.body ) {
599- this.context = document;
600- this[0] = document.body;
601- this.selector = selector;
602- this.length = 1;
603- return this;
604- }
605-
606- // Handle HTML strings
607- if ( typeof selector === "string" ) {
608- // Are we dealing with HTML string or an ID?
609- if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
610- // Assume that strings that start and end with <> are HTML and skip the regex check
611- match = [ null, selector, null ];
612-
613- } else {
614- match = quickExpr.exec( selector );
615- }
616-
617- // Verify a match, and that no context was specified for #id
618- if ( match && (match[1] || !context) ) {
619-
620- // HANDLE: $(html) -> $(array)
621- if ( match[1] ) {
622- context = context instanceof jQuery ? context[0] : context;
623- doc = (context ? context.ownerDocument || context : document);
624-
625- // If a single string is passed in and it's a single tag
626- // just do a createElement and skip the rest
627- ret = rsingleTag.exec( selector );
628-
629- if ( ret ) {
630- if ( jQuery.isPlainObject( context ) ) {
631- selector = [ document.createElement( ret[1] ) ];
632- jQuery.fn.attr.call( selector, context, true );
633-
634- } else {
635- selector = [ doc.createElement( ret[1] ) ];
636- }
637-
638- } else {
639- ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
640- selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
641- }
642-
643- return jQuery.merge( this, selector );
644-
645- // HANDLE: $("#id")
646- } else {
647- elem = document.getElementById( match[2] );
648-
649- // Check parentNode to catch when Blackberry 4.6 returns
650- // nodes that are no longer in the document #6963
651- if ( elem && elem.parentNode ) {
652- // Handle the case where IE and Opera return items
653- // by name instead of ID
654- if ( elem.id !== match[2] ) {
655- return rootjQuery.find( selector );
656- }
657-
658- // Otherwise, we inject the element directly into the jQuery object
659- this.length = 1;
660- this[0] = elem;
661- }
662-
663- this.context = document;
664- this.selector = selector;
665- return this;
666- }
667-
668- // HANDLE: $(expr, $(...))
669- } else if ( !context || context.jquery ) {
670- return (context || rootjQuery).find( selector );
671-
672- // HANDLE: $(expr, context)
673- // (which is just equivalent to: $(context).find(expr)
674- } else {
675- return this.constructor( context ).find( selector );
676- }
677-
678- // HANDLE: $(function)
679- // Shortcut for document ready
680- } else if ( jQuery.isFunction( selector ) ) {
681- return rootjQuery.ready( selector );
682- }
683-
684- if (selector.selector !== undefined) {
685- this.selector = selector.selector;
686- this.context = selector.context;
687- }
688-
689- return jQuery.makeArray( selector, this );
690- },
691-
692- // Start with an empty selector
693- selector: "",
694-
695- // The current version of jQuery being used
696- jquery: "1.6.2",
697-
698- // The default length of a jQuery object is 0
699- length: 0,
700-
701- // The number of elements contained in the matched element set
702- size: function() {
703- return this.length;
704- },
705-
706- toArray: function() {
707- return slice.call( this, 0 );
708- },
709-
710- // Get the Nth element in the matched element set OR
711- // Get the whole matched element set as a clean array
712- get: function( num ) {
713- return num == null ?
714-
715- // Return a 'clean' array
716- this.toArray() :
717-
718- // Return just the object
719- ( num < 0 ? this[ this.length + num ] : this[ num ] );
720- },
721-
722- // Take an array of elements and push it onto the stack
723- // (returning the new matched element set)
724- pushStack: function( elems, name, selector ) {
725- // Build a new jQuery matched element set
726- var ret = this.constructor();
727-
728- if ( jQuery.isArray( elems ) ) {
729- push.apply( ret, elems );
730-
731- } else {
732- jQuery.merge( ret, elems );
733- }
734-
735- // Add the old object onto the stack (as a reference)
736- ret.prevObject = this;
737-
738- ret.context = this.context;
739-
740- if ( name === "find" ) {
741- ret.selector = this.selector + (this.selector ? " " : "") + selector;
742- } else if ( name ) {
743- ret.selector = this.selector + "." + name + "(" + selector + ")";
744- }
745-
746- // Return the newly-formed element set
747- return ret;
748- },
749-
750- // Execute a callback for every element in the matched set.
751- // (You can seed the arguments with an array of args, but this is
752- // only used internally.)
753- each: function( callback, args ) {
754- return jQuery.each( this, callback, args );
755- },
756-
757- ready: function( fn ) {
758- // Attach the listeners
759- jQuery.bindReady();
760-
761- // Add the callback
762- readyList.done( fn );
763-
764- return this;
765- },
766-
767- eq: function( i ) {
768- return i === -1 ?
769- this.slice( i ) :
770- this.slice( i, +i + 1 );
771- },
772-
773- first: function() {
774- return this.eq( 0 );
775- },
776-
777- last: function() {
778- return this.eq( -1 );
779- },
780-
781- slice: function() {
782- return this.pushStack( slice.apply( this, arguments ),
783- "slice", slice.call(arguments).join(",") );
784- },
785-
786- map: function( callback ) {
787- return this.pushStack( jQuery.map(this, function( elem, i ) {
788- return callback.call( elem, i, elem );
789- }));
790- },
791-
792- end: function() {
793- return this.prevObject || this.constructor(null);
794- },
795-
796- // For internal use only.
797- // Behaves like an Array's method, not like a jQuery method.
798- push: push,
799- sort: [].sort,
800- splice: [].splice
801-};
802-
803-// Give the init function the jQuery prototype for later instantiation
804-jQuery.fn.init.prototype = jQuery.fn;
805-
806-jQuery.extend = jQuery.fn.extend = function() {
807- var options, name, src, copy, copyIsArray, clone,
808- target = arguments[0] || {},
809- i = 1,
810- length = arguments.length,
811- deep = false;
812-
813- // Handle a deep copy situation
814- if ( typeof target === "boolean" ) {
815- deep = target;
816- target = arguments[1] || {};
817- // skip the boolean and the target
818- i = 2;
819- }
820-
821- // Handle case when target is a string or something (possible in deep copy)
822- if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
823- target = {};
824- }
825-
826- // extend jQuery itself if only one argument is passed
827- if ( length === i ) {
828- target = this;
829- --i;
830- }
831-
832- for ( ; i < length; i++ ) {
833- // Only deal with non-null/undefined values
834- if ( (options = arguments[ i ]) != null ) {
835- // Extend the base object
836- for ( name in options ) {
837- src = target[ name ];
838- copy = options[ name ];
839-
840- // Prevent never-ending loop
841- if ( target === copy ) {
842- continue;
843- }
844-
845- // Recurse if we're merging plain objects or arrays
846- if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
847- if ( copyIsArray ) {
848- copyIsArray = false;
849- clone = src && jQuery.isArray(src) ? src : [];
850-
851- } else {
852- clone = src && jQuery.isPlainObject(src) ? src : {};
853- }
854-
855- // Never move original objects, clone them
856- target[ name ] = jQuery.extend( deep, clone, copy );
857-
858- // Don't bring in undefined values
859- } else if ( copy !== undefined ) {
860- target[ name ] = copy;
861- }
862- }
863- }
864- }
865-
866- // Return the modified object
867- return target;
868-};
869-
870-jQuery.extend({
871- noConflict: function( deep ) {
872- if ( window.$ === jQuery ) {
873- window.$ = _$;
874- }
875-
876- if ( deep && window.jQuery === jQuery ) {
877- window.jQuery = _jQuery;
878- }
879-
880- return jQuery;
881- },
882-
883- // Is the DOM ready to be used? Set to true once it occurs.
884- isReady: false,
885-
886- // A counter to track how many items to wait for before
887- // the ready event fires. See #6781
888- readyWait: 1,
889-
890- // Hold (or release) the ready event
891- holdReady: function( hold ) {
892- if ( hold ) {
893- jQuery.readyWait++;
894- } else {
895- jQuery.ready( true );
896- }
897- },
898-
899- // Handle when the DOM is ready
900- ready: function( wait ) {
901- // Either a released hold or an DOMready/load event and not yet ready
902- if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
903- // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
904- if ( !document.body ) {
905- return setTimeout( jQuery.ready, 1 );
906- }
907-
908- // Remember that the DOM is ready
909- jQuery.isReady = true;
910-
911- // If a normal DOM Ready event fired, decrement, and wait if need be
912- if ( wait !== true && --jQuery.readyWait > 0 ) {
913- return;
914- }
915-
916- // If there are functions bound, to execute
917- readyList.resolveWith( document, [ jQuery ] );
918-
919- // Trigger any bound ready events
920- if ( jQuery.fn.trigger ) {
921- jQuery( document ).trigger( "ready" ).unbind( "ready" );
922- }
923- }
924- },
925-
926- bindReady: function() {
927- if ( readyList ) {
928- return;
929- }
930-
931- readyList = jQuery._Deferred();
932-
933- // Catch cases where $(document).ready() is called after the
934- // browser event has already occurred.
935- if ( document.readyState === "complete" ) {
936- // Handle it asynchronously to allow scripts the opportunity to delay ready
937- return setTimeout( jQuery.ready, 1 );
938- }
939-
940- // Mozilla, Opera and webkit nightlies currently support this event
941- if ( document.addEventListener ) {
942- // Use the handy event callback
943- document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
944-
945- // A fallback to window.onload, that will always work
946- window.addEventListener( "load", jQuery.ready, false );
947-
948- // If IE event model is used
949- } else if ( document.attachEvent ) {
950- // ensure firing before onload,
951- // maybe late but safe also for iframes
952- document.attachEvent( "onreadystatechange", DOMContentLoaded );
953-
954- // A fallback to window.onload, that will always work
955- window.attachEvent( "onload", jQuery.ready );
956-
957- // If IE and not a frame
958- // continually check to see if the document is ready
959- var toplevel = false;
960-
961- try {
962- toplevel = window.frameElement == null;
963- } catch(e) {}
964-
965- if ( document.documentElement.doScroll && toplevel ) {
966- doScrollCheck();
967- }
968- }
969- },
970-
971- // See test/unit/core.js for details concerning isFunction.
972- // Since version 1.3, DOM methods and functions like alert
973- // aren't supported. They return false on IE (#2968).
974- isFunction: function( obj ) {
975- return jQuery.type(obj) === "function";
976- },
977-
978- isArray: Array.isArray || function( obj ) {
979- return jQuery.type(obj) === "array";
980- },
981-
982- // A crude way of determining if an object is a window
983- isWindow: function( obj ) {
984- return obj && typeof obj === "object" && "setInterval" in obj;
985- },
986-
987- isNaN: function( obj ) {
988- return obj == null || !rdigit.test( obj ) || isNaN( obj );
989- },
990-
991- type: function( obj ) {
992- return obj == null ?
993- String( obj ) :
994- class2type[ toString.call(obj) ] || "object";
995- },
996-
997- isPlainObject: function( obj ) {
998- // Must be an Object.
999- // Because of IE, we also have to check the presence of the constructor property.
Cut short: this commit's diff is over 1000 lines.
libs/animationFrame.js+0−23
Cut short: this commit's diff is over 1000 lines.
libs/backbone.js+0−1149
Cut short: this commit's diff is over 1000 lines.
libs/jquery.js+0−8981
Cut short: this commit's diff is over 1000 lines.
libs/json2.js+0−480
Cut short: this commit's diff is over 1000 lines.
libs/modernizr.js+0−1116
Cut short: this commit's diff is over 1000 lines.
libs/three.js+0−534
Cut short: this commit's diff is over 1000 lines.
libs/underscore.js+0−839
Cut short: this commit's diff is over 1000 lines.