Context Navigation

source: Dev/trunk/d3/lib/sizzle/sizzle.js @ 76

Last change on this file since 76 was 76, checked in by fpvanagthoven, 14 years ago
d3
File size: 31.0 KB

Line
1	/*!
2	* Sizzle CSS Selector Engine
3	* Copyright 2011, The Dojo Foundation
4	* Released under the MIT, BSD, and GPL Licenses.
5	* More information: http://sizzlejs.com/
6	*/
7	(function(){
8
9	var chunker = /((?:\((?:\([^()]+\)\|[^()]+)+\)\|\[(?:\[[^\[\]]\]\|['"][^'"]['"]\|[^\[\]'"]+)+\]\|\\.\|[^ >+~,(\[\\]+)+\|[>+~])(\s,\s)?((?:.\|\r\|\n)*)/g,
10	done = 0,
11	toString = Object.prototype.toString,
12	hasDuplicate = false,
13	baseHasDuplicate = true;
14
15	// Here we check if the JavaScript engine is using some sort of
16	// optimization where it does not always call our comparision
17	// function. If that is the case, discard the hasDuplicate value.
18	// Thus far that includes Google Chrome.
19	[0, 0].sort(function() {
20	baseHasDuplicate = false;
21	return 0;
22	});
23
24	var Sizzle = function( selector, context, results, seed ) {
25	results = results \|\| [];
26	context = context \|\| document;
27
28	var origContext = context;
29
30	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
31	return [];
32	}
33
34	if ( !selector \|\| typeof selector !== "string" ) {
35	return results;
36	}
37
38	var m, set, checkSet, extra, ret, cur, pop, i,
39	prune = true,
40	contextXML = Sizzle.isXML( context ),
41	parts = [],
42	soFar = selector;
43
44	// Reset the position of the chunker regexp (start from head)
45	do {
46	chunker.exec( "" );
47	m = chunker.exec( soFar );
48
49	if ( m ) {
50	soFar = m[3];
51
52	parts.push( m[1] );
53
54	if ( m[2] ) {
55	extra = m[3];
56	break;
57	}
58	}
59	} while ( m );
60
61	if ( parts.length > 1 && origPOS.exec( selector ) ) {
62
63	if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
64	set = posProcess( parts[0] + parts[1], context );
65
66	} else {
67	set = Expr.relative[ parts[0] ] ?
68	[ context ] :
69	Sizzle( parts.shift(), context );
70
71	while ( parts.length ) {
72	selector = parts.shift();
73
74	if ( Expr.relative[ selector ] ) {
75	selector += parts.shift();
76	}
77
78	set = posProcess( selector, set );
79	}
80	}
81
82	} else {
83	// Take a shortcut and set the context if the root selector is an ID
84	// (but not if it'll be faster if the inner selector is an ID)
85	if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
86	Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
87
88	ret = Sizzle.find( parts.shift(), context, contextXML );
89	context = ret.expr ?
90	Sizzle.filter( ret.expr, ret.set )[0] :
91	ret.set[0];
92	}
93
94	if ( context ) {
95	ret = seed ?
96	{ expr: parts.pop(), set: makeArray(seed) } :
97	Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" \|\| parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
98
99	set = ret.expr ?
100	Sizzle.filter( ret.expr, ret.set ) :
101	ret.set;
102
103	if ( parts.length > 0 ) {
104	checkSet = makeArray( set );
105
106	} else {
107	prune = false;
108	}
109
110	while ( parts.length ) {
111	cur = parts.pop();
112	pop = cur;
113
114	if ( !Expr.relative[ cur ] ) {
115	cur = "";
116	} else {
117	pop = parts.pop();
118	}
119
120	if ( pop == null ) {
121	pop = context;
122	}
123
124	Expr.relative[ cur ]( checkSet, pop, contextXML );
125	}
126
127	} else {
128	checkSet = parts = [];
129	}
130	}
131
132	if ( !checkSet ) {
133	checkSet = set;
134	}
135
136	if ( !checkSet ) {
137	Sizzle.error( cur \|\| selector );
138	}
139
140	if ( toString.call(checkSet) === "[object Array]" ) {
141	if ( !prune ) {
142	results.push.apply( results, checkSet );
143
144	} else if ( context && context.nodeType === 1 ) {
145	for ( i = 0; checkSet[i] != null; i++ ) {
146	if ( checkSet[i] && (checkSet[i] === true \|\| checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
147	results.push( set[i] );
148	}
149	}
150
151	} else {
152	for ( i = 0; checkSet[i] != null; i++ ) {
153	if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
154	results.push( set[i] );
155	}
156	}
157	}
158
159	} else {
160	makeArray( checkSet, results );
161	}
162
163	if ( extra ) {
164	Sizzle( extra, origContext, results, seed );
165	Sizzle.uniqueSort( results );
166	}
167
168	return results;
169	};
170
171	Sizzle.uniqueSort = function( results ) {
172	if ( sortOrder ) {
173	hasDuplicate = baseHasDuplicate;
174	results.sort( sortOrder );
175
176	if ( hasDuplicate ) {
177	for ( var i = 1; i < results.length; i++ ) {
178	if ( results[i] === results[ i - 1 ] ) {
179	results.splice( i--, 1 );
180	}
181	}
182	}
183	}
184
185	return results;
186	};
187
188	Sizzle.matches = function( expr, set ) {
189	return Sizzle( expr, null, null, set );
190	};
191
192	Sizzle.matchesSelector = function( node, expr ) {
193	return Sizzle( expr, null, null, [node] ).length > 0;
194	};
195
196	Sizzle.find = function( expr, context, isXML ) {
197	var set;
198
199	if ( !expr ) {
200	return [];
201	}
202
203	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
204	var match,
205	type = Expr.order[i];
206
207	if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
208	var left = match[1];
209	match.splice( 1, 1 );
210
211	if ( left.substr( left.length - 1 ) !== "\\" ) {
212	match[1] = (match[1] \|\| "").replace(/\\/g, "");
213	set = Expr.find[ type ]( match, context, isXML );
214
215	if ( set != null ) {
216	expr = expr.replace( Expr.match[ type ], "" );
217	break;
218	}
219	}
220	}
221	}
222
223	if ( !set ) {
224	set = typeof context.getElementsByTagName !== "undefined" ?
225	context.getElementsByTagName( "*" ) :
226	[];
227	}
228
229	return { set: set, expr: expr };
230	};
231
232	Sizzle.filter = function( expr, set, inplace, not ) {
233	var match, anyFound,
234	old = expr,
235	result = [],
236	curLoop = set,
237	isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
238
239	while ( expr && set.length ) {
240	for ( var type in Expr.filter ) {
241	if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
242	var found, item,
243	filter = Expr.filter[ type ],
244	left = match[1];
245
246	anyFound = false;
247
248	match.splice(1,1);
249
250	if ( left.substr( left.length - 1 ) === "\\" ) {
251	continue;
252	}
253
254	if ( curLoop === result ) {
255	result = [];
256	}
257
258	if ( Expr.preFilter[ type ] ) {
259	match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
260
261	if ( !match ) {
262	anyFound = found = true;
263
264	} else if ( match === true ) {
265	continue;
266	}
267	}
268
269	if ( match ) {
270	for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
271	if ( item ) {
272	found = filter( item, match, i, curLoop );
273	var pass = not ^ !!found;
274
275	if ( inplace && found != null ) {
276	if ( pass ) {
277	anyFound = true;
278
279	} else {
280	curLoop[i] = false;
281	}
282
283	} else if ( pass ) {
284	result.push( item );
285	anyFound = true;
286	}
287	}
288	}
289	}
290
291	if ( found !== undefined ) {
292	if ( !inplace ) {
293	curLoop = result;
294	}
295
296	expr = expr.replace( Expr.match[ type ], "" );
297
298	if ( !anyFound ) {
299	return [];
300	}
301
302	break;
303	}
304	}
305	}
306
307	// Improper expression
308	if ( expr === old ) {
309	if ( anyFound == null ) {
310	Sizzle.error( expr );
311
312	} else {
313	break;
314	}
315	}
316
317	old = expr;
318	}
319
320	return curLoop;
321	};
322
323	Sizzle.error = function( msg ) {
324	throw "Syntax error, unrecognized expression: " + msg;
325	};
326
327	var Expr = Sizzle.selectors = {
328	order: [ "ID", "NAME", "TAG" ],
329
330	match: {
331	ID: /#((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
332	CLASS: /\.((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
333	NAME: /\[name=['"]((?:[\w\u00c0-\uFFFF\-]\|\\.)+)['"]\]/,
334	ATTR: /\[\s((?:[\w\u00c0-\uFFFF\-]\|\\.)+)\s(?:(\S?=)\s(?:(['"])(.?)\3\|(#?(?:[\w\u00c0-\uFFFF\-]\|\\.))\|)\|)\s\]/,
335	TAG: /^((?:[\w\u00c0-\uFFFF\*\-]\|\\.)+)/,
336	CHILD: /:(only\|nth\|last\|first)-child(?:\(\s(even\|odd\|(?:[+\-]?\d+\|(?:[+\-]?\d)?n\s(?:[+\-]\s\d+)?))\s*\))?/,
337	POS: /:(nth\|eq\|gt\|lt\|first\|last\|even\|odd)(?:\((\d*)\))?(?=[^\-]\|$)/,
338	PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]\|\\.)+)(?:\((['"]?)((?:\([^\)]+\)\|[^\(\)]*)+)\2\))?/
339	},
340
341	leftMatch: {},
342
343	attrMap: {
344	"class": "className",
345	"for": "htmlFor"
346	},
347
348	attrHandle: {
349	href: function( elem ) {
350	return elem.getAttribute( "href" );
351	}
352	},
353
354	relative: {
355	"+": function(checkSet, part){
356	var isPartStr = typeof part === "string",
357	isTag = isPartStr && !/\W/.test( part ),
358	isPartStrNotTag = isPartStr && !isTag;
359
360	if ( isTag ) {
361	part = part.toLowerCase();
362	}
363
364	for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
365	if ( (elem = checkSet[i]) ) {
366	while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
367
368	checkSet[i] = isPartStrNotTag \|\| elem && elem.nodeName.toLowerCase() === part ?
369	elem \|\| false :
370	elem === part;
371	}
372	}
373
374	if ( isPartStrNotTag ) {
375	Sizzle.filter( part, checkSet, true );
376	}
377	},
378
379	">": function( checkSet, part ) {
380	var elem,
381	isPartStr = typeof part === "string",
382	i = 0,
383	l = checkSet.length;
384
385	if ( isPartStr && !/\W/.test( part ) ) {
386	part = part.toLowerCase();
387
388	for ( ; i < l; i++ ) {
389	elem = checkSet[i];
390
391	if ( elem ) {
392	var parent = elem.parentNode;
393	checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
394	}
395	}
396
397	} else {
398	for ( ; i < l; i++ ) {
399	elem = checkSet[i];
400
401	if ( elem ) {
402	checkSet[i] = isPartStr ?
403	elem.parentNode :
404	elem.parentNode === part;
405	}
406	}
407
408	if ( isPartStr ) {
409	Sizzle.filter( part, checkSet, true );
410	}
411	}
412	},
413
414	"": function(checkSet, part, isXML){
415	var nodeCheck,
416	doneName = done++,
417	checkFn = dirCheck;
418
419	if ( typeof part === "string" && !/\W/.test(part) ) {
420	part = part.toLowerCase();
421	nodeCheck = part;
422	checkFn = dirNodeCheck;
423	}
424
425	checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
426	},
427
428	"~": function( checkSet, part, isXML ) {
429	var nodeCheck,
430	doneName = done++,
431	checkFn = dirCheck;
432
433	if ( typeof part === "string" && !/\W/.test( part ) ) {
434	part = part.toLowerCase();
435	nodeCheck = part;
436	checkFn = dirNodeCheck;
437	}
438
439	checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
440	}
441	},
442
443	find: {
444	ID: function( match, context, isXML ) {
445	if ( typeof context.getElementById !== "undefined" && !isXML ) {
446	var m = context.getElementById(match[1]);
447	// Check parentNode to catch when Blackberry 4.6 returns
448	// nodes that are no longer in the document #6963
449	return m && m.parentNode ? [m] : [];
450	}
451	},
452
453	NAME: function( match, context ) {
454	if ( typeof context.getElementsByName !== "undefined" ) {
455	var ret = [],
456	results = context.getElementsByName( match[1] );
457
458	for ( var i = 0, l = results.length; i < l; i++ ) {
459	if ( results[i].getAttribute("name") === match[1] ) {
460	ret.push( results[i] );
461	}
462	}
463
464	return ret.length === 0 ? null : ret;
465	}
466	},
467
468	TAG: function( match, context ) {
469	if ( typeof context.getElementsByTagName !== "undefined" ) {
470	return context.getElementsByTagName( match[1] );
471	}
472	}
473	},
474	preFilter: {
475	CLASS: function( match, curLoop, inplace, result, not, isXML ) {
476	match = " " + match[1].replace(/\\/g, "") + " ";
477
478	if ( isXML ) {
479	return match;
480	}
481
482	for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
483	if ( elem ) {
484	if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
485	if ( !inplace ) {
486	result.push( elem );
487	}
488
489	} else if ( inplace ) {
490	curLoop[i] = false;
491	}
492	}
493	}
494
495	return false;
496	},
497
498	ID: function( match ) {
499	return match[1].replace(/\\/g, "");
500	},
501
502	TAG: function( match, curLoop ) {
503	return match[1].toLowerCase();
504	},
505
506	CHILD: function( match ) {
507	if ( match[1] === "nth" ) {
508	if ( !match[2] ) {
509	Sizzle.error( match[0] );
510	}
511
512	match[2] = match[2].replace(/^\+\|\s*/g, '');
513
514	// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
515	var test = /(-?)(\d)(?:n([+\-]?\d))?/.exec(
516	match[2] === "even" && "2n" \|\| match[2] === "odd" && "2n+1" \|\|
517	!/\D/.test( match[2] ) && "0n+" + match[2] \|\| match[2]);
518
519	// calculate the numbers (first)n+(last) including if they are negative
520	match[2] = (test[1] + (test[2] \|\| 1)) - 0;
521	match[3] = test[3] - 0;
522	}
523	else if ( match[2] ) {
524	Sizzle.error( match[0] );
525	}
526
527	// TODO: Move to normal caching system
528	match[0] = done++;
529
530	return match;
531	},
532
533	ATTR: function( match, curLoop, inplace, result, not, isXML ) {
534	var name = match[1] = match[1].replace(/\\/g, "");
535
536	if ( !isXML && Expr.attrMap[name] ) {
537	match[1] = Expr.attrMap[name];
538	}
539
540	// Handle if an un-quoted value was used
541	match[4] = ( match[4] \|\| match[5] \|\| "" ).replace(/\\/g, "");
542
543	if ( match[2] === "~=" ) {
544	match[4] = " " + match[4] + " ";
545	}
546
547	return match;
548	},
549
550	PSEUDO: function( match, curLoop, inplace, result, not ) {
551	if ( match[1] === "not" ) {
552	// If we're dealing with a complex expression, or a simple one
553	if ( ( chunker.exec(match[3]) \|\| "" ).length > 1 \|\| /^\w/.test(match[3]) ) {
554	match[3] = Sizzle(match[3], null, null, curLoop);
555
556	} else {
557	var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
558
559	if ( !inplace ) {
560	result.push.apply( result, ret );
561	}
562
563	return false;
564	}
565
566	} else if ( Expr.match.POS.test( match[0] ) \|\| Expr.match.CHILD.test( match[0] ) ) {
567	return true;
568	}
569
570	return match;
571	},
572
573	POS: function( match ) {
574	match.unshift( true );
575
576	return match;
577	}
578	},
579
580	filters: {
581	enabled: function( elem ) {
582	return elem.disabled === false && elem.type !== "hidden";
583	},
584
585	disabled: function( elem ) {
586	return elem.disabled === true;
587	},
588
589	checked: function( elem ) {
590	return elem.checked === true;
591	},
592
593	selected: function( elem ) {
594	// Accessing this property makes selected-by-default
595	// options in Safari work properly
596	elem.parentNode.selectedIndex;
597
598	return elem.selected === true;
599	},
600
601	parent: function( elem ) {
602	return !!elem.firstChild;
603	},
604
605	empty: function( elem ) {
606	return !elem.firstChild;
607	},
608
609	has: function( elem, i, match ) {
610	return !!Sizzle( match[3], elem ).length;
611	},
612
613	header: function( elem ) {
614	return (/h\d/i).test( elem.nodeName );
615	},
616
617	text: function( elem ) {
618	return "text" === elem.type;
619	},
620	radio: function( elem ) {
621	return "radio" === elem.type;
622	},
623
624	checkbox: function( elem ) {
625	return "checkbox" === elem.type;
626	},
627
628	file: function( elem ) {
629	return "file" === elem.type;
630	},
631	password: function( elem ) {
632	return "password" === elem.type;
633	},
634
635	submit: function( elem ) {
636	return "submit" === elem.type;
637	},
638
639	image: function( elem ) {
640	return "image" === elem.type;
641	},
642
643	reset: function( elem ) {
644	return "reset" === elem.type;
645	},
646
647	button: function( elem ) {
648	return "button" === elem.type \|\| elem.nodeName.toLowerCase() === "button";
649	},
650
651	input: function( elem ) {
652	return (/input\|select\|textarea\|button/i).test( elem.nodeName );
653	}
654	},
655	setFilters: {
656	first: function( elem, i ) {
657	return i === 0;
658	},
659
660	last: function( elem, i, match, array ) {
661	return i === array.length - 1;
662	},
663
664	even: function( elem, i ) {
665	return i % 2 === 0;
666	},
667
668	odd: function( elem, i ) {
669	return i % 2 === 1;
670	},
671
672	lt: function( elem, i, match ) {
673	return i < match[3] - 0;
674	},
675
676	gt: function( elem, i, match ) {
677	return i > match[3] - 0;
678	},
679
680	nth: function( elem, i, match ) {
681	return match[3] - 0 === i;
682	},
683
684	eq: function( elem, i, match ) {
685	return match[3] - 0 === i;
686	}
687	},
688	filter: {
689	PSEUDO: function( elem, match, i, array ) {
690	var name = match[1],
691	filter = Expr.filters[ name ];
692
693	if ( filter ) {
694	return filter( elem, i, match, array );
695
696	} else if ( name === "contains" ) {
697	return (elem.textContent \|\| elem.innerText \|\| Sizzle.getText([ elem ]) \|\| "").indexOf(match[3]) >= 0;
698
699	} else if ( name === "not" ) {
700	var not = match[3];
701
702	for ( var j = 0, l = not.length; j < l; j++ ) {
703	if ( not[j] === elem ) {
704	return false;
705	}
706	}
707
708	return true;
709
710	} else {
711	Sizzle.error( name );
712	}
713	},
714
715	CHILD: function( elem, match ) {
716	var type = match[1],
717	node = elem;
718
719	switch ( type ) {
720	case "only":
721	case "first":
722	while ( (node = node.previousSibling) ) {
723	if ( node.nodeType === 1 ) {
724	return false;
725	}
726	}
727
728	if ( type === "first" ) {
729	return true;
730	}
731
732	node = elem;
733
734	case "last":
735	while ( (node = node.nextSibling) ) {
736	if ( node.nodeType === 1 ) {
737	return false;
738	}
739	}
740
741	return true;
742
743	case "nth":
744	var first = match[2],
745	last = match[3];
746
747	if ( first === 1 && last === 0 ) {
748	return true;
749	}
750
751	var doneName = match[0],
752	parent = elem.parentNode;
753
754	if ( parent && (parent.sizcache !== doneName \|\| !elem.nodeIndex) ) {
755	var count = 0;
756
757	for ( node = parent.firstChild; node; node = node.nextSibling ) {
758	if ( node.nodeType === 1 ) {
759	node.nodeIndex = ++count;
760	}
761	}
762
763	parent.sizcache = doneName;
764	}
765
766	var diff = elem.nodeIndex - last;
767
768	if ( first === 0 ) {
769	return diff === 0;
770
771	} else {
772	return ( diff % first === 0 && diff / first >= 0 );
773	}
774	}
775	},
776
777	ID: function( elem, match ) {
778	return elem.nodeType === 1 && elem.getAttribute("id") === match;
779	},
780
781	TAG: function( elem, match ) {
782	return (match === "*" && elem.nodeType === 1) \|\| elem.nodeName.toLowerCase() === match;
783	},
784
785	CLASS: function( elem, match ) {
786	return (" " + (elem.className \|\| elem.getAttribute("class")) + " ")
787	.indexOf( match ) > -1;
788	},
789
790	ATTR: function( elem, match ) {
791	var name = match[1],
792	result = Expr.attrHandle[ name ] ?
793	Expr.attrHandle[ name ]( elem ) :
794	elem[ name ] != null ?
795	elem[ name ] :
796	elem.getAttribute( name ),
797	value = result + "",
798	type = match[2],
799	check = match[4];
800
801	return result == null ?
802	type === "!=" :
803	type === "=" ?
804	value === check :
805	type === "*=" ?
806	value.indexOf(check) >= 0 :
807	type === "~=" ?
808	(" " + value + " ").indexOf(check) >= 0 :
809	!check ?
810	value && result !== false :
811	type === "!=" ?
812	value !== check :
813	type === "^=" ?
814	value.indexOf(check) === 0 :
815	type === "$=" ?
816	value.substr(value.length - check.length) === check :
817	type === "\|=" ?
818	value === check \|\| value.substr(0, check.length + 1) === check + "-" :
819	false;
820	},
821
822	POS: function( elem, match, i, array ) {
823	var name = match[2],
824	filter = Expr.setFilters[ name ];
825
826	if ( filter ) {
827	return filter( elem, i, match, array );
828	}
829	}
830	}
831	};
832
833	var origPOS = Expr.match.POS,
834	fescape = function(all, num){
835	return "\\" + (num - 0 + 1);
836	};
837
838	for ( var type in Expr.match ) {
839	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]\])(?![^\(]\))/.source) );
840	Expr.leftMatch[ type ] = new RegExp( /(^(?:.\|\r\|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
841	}
842
843	var makeArray = function( array, results ) {
844	array = Array.prototype.slice.call( array, 0 );
845
846	if ( results ) {
847	results.push.apply( results, array );
848	return results;
849	}
850
851	return array;
852	};
853
854	// Perform a simple check to determine if the browser is capable of
855	// converting a NodeList to an array using builtin methods.
856	// Also verifies that the returned array holds DOM nodes
857	// (which is not the case in the Blackberry browser)
858	try {
859	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
860
861	// Provide a fallback method if it does not work
862	} catch( e ) {
863	makeArray = function( array, results ) {
864	var i = 0,
865	ret = results \|\| [];
866
867	if ( toString.call(array) === "[object Array]" ) {
868	Array.prototype.push.apply( ret, array );
869
870	} else {
871	if ( typeof array.length === "number" ) {
872	for ( var l = array.length; i < l; i++ ) {
873	ret.push( array[i] );
874	}
875
876	} else {
877	for ( ; array[i]; i++ ) {
878	ret.push( array[i] );
879	}
880	}
881	}
882
883	return ret;
884	};
885	}
886
887	var sortOrder, siblingCheck;
888
889	if ( document.documentElement.compareDocumentPosition ) {
890	sortOrder = function( a, b ) {
891	if ( a === b ) {
892	hasDuplicate = true;
893	return 0;
894	}
895
896	if ( !a.compareDocumentPosition \|\| !b.compareDocumentPosition ) {
897	return a.compareDocumentPosition ? -1 : 1;
898	}
899
900	return a.compareDocumentPosition(b) & 4 ? -1 : 1;
901	};
902
903	} else {
904	sortOrder = function( a, b ) {
905	var al, bl,
906	ap = [],
907	bp = [],
908	aup = a.parentNode,
909	bup = b.parentNode,
910	cur = aup;
911
912	// The nodes are identical, we can exit early
913	if ( a === b ) {
914	hasDuplicate = true;
915	return 0;
916
917	// If the nodes are siblings (or identical) we can do a quick check
918	} else if ( aup === bup ) {
919	return siblingCheck( a, b );
920
921	// If no parents were found then the nodes are disconnected
922	} else if ( !aup ) {
923	return -1;
924
925	} else if ( !bup ) {
926	return 1;
927	}
928
929	// Otherwise they're somewhere else in the tree so we need
930	// to build up a full list of the parentNodes for comparison
931	while ( cur ) {
932	ap.unshift( cur );
933	cur = cur.parentNode;
934	}
935
936	cur = bup;
937
938	while ( cur ) {
939	bp.unshift( cur );
940	cur = cur.parentNode;
941	}
942
943	al = ap.length;
944	bl = bp.length;
945
946	// Start walking down the tree looking for a discrepancy
947	for ( var i = 0; i < al && i < bl; i++ ) {
948	if ( ap[i] !== bp[i] ) {
949	return siblingCheck( ap[i], bp[i] );
950	}
951	}
952
953	// We ended someplace up the tree so do a sibling check
954	return i === al ?
955	siblingCheck( a, bp[i], -1 ) :
956	siblingCheck( ap[i], b, 1 );
957	};
958
959	siblingCheck = function( a, b, ret ) {
960	if ( a === b ) {
961	return ret;
962	}
963
964	var cur = a.nextSibling;
965
966	while ( cur ) {
967	if ( cur === b ) {
968	return -1;
969	}
970
971	cur = cur.nextSibling;
972	}
973
974	return 1;
975	};
976	}
977
978	// Utility function for retreiving the text value of an array of DOM nodes
979	Sizzle.getText = function( elems ) {
980	var ret = "", elem;
981
982	for ( var i = 0; elems[i]; i++ ) {
983	elem = elems[i];
984
985	// Get the text from text nodes and CDATA nodes
986	if ( elem.nodeType === 3 \|\| elem.nodeType === 4 ) {
987	ret += elem.nodeValue;
988
989	// Traverse everything else, except comment nodes
990	} else if ( elem.nodeType !== 8 ) {
991	ret += Sizzle.getText( elem.childNodes );
992	}
993	}
994
995	return ret;
996	};
997
998	// Check to see if the browser returns elements by name when
999	// querying by getElementById (and provide a workaround)
1000	(function(){
1001	// We're going to inject a fake input element with a specified name
1002	var form = document.createElement("div"),
1003	id = "script" + (new Date()).getTime(),
1004	root = document.documentElement;
1005
1006	form.innerHTML = "<a name='" + id + "'/>";
1007
1008	// Inject it into the root element, check its status, and remove it quickly
1009	root.insertBefore( form, root.firstChild );
1010
1011	// The workaround has to do additional checks after a getElementById
1012	// Which slows things down for other browsers (hence the branching)
1013	if ( document.getElementById( id ) ) {
1014	Expr.find.ID = function( match, context, isXML ) {
1015	if ( typeof context.getElementById !== "undefined" && !isXML ) {
1016	var m = context.getElementById(match[1]);
1017
1018	return m ?
1019	m.id === match[1] \|\| typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
1020	[m] :
1021	undefined :
1022	[];
1023	}
1024	};
1025
1026	Expr.filter.ID = function( elem, match ) {
1027	var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1028
1029	return elem.nodeType === 1 && node && node.nodeValue === match;
1030	};
1031	}
1032
1033	root.removeChild( form );
1034
1035	// release memory in IE
1036	root = form = null;
1037	})();
1038
1039	(function(){
1040	// Check to see if the browser returns only elements
1041	// when doing getElementsByTagName("*")
1042
1043	// Create a fake element
1044	var div = document.createElement("div");
1045	div.appendChild( document.createComment("") );
1046
1047	// Make sure no comments are found
1048	if ( div.getElementsByTagName("*").length > 0 ) {
1049	Expr.find.TAG = function( match, context ) {
1050	var results = context.getElementsByTagName( match[1] );
1051
1052	// Filter out possible comments
1053	if ( match[1] === "*" ) {
1054	var tmp = [];
1055
1056	for ( var i = 0; results[i]; i++ ) {
1057	if ( results[i].nodeType === 1 ) {
1058	tmp.push( results[i] );
1059	}
1060	}
1061
1062	results = tmp;
1063	}
1064
1065	return results;
1066	};
1067	}
1068
1069	// Check to see if an attribute returns normalized href attributes
1070	div.innerHTML = "<a href='#'></a>";
1071
1072	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
1073	div.firstChild.getAttribute("href") !== "#" ) {
1074
1075	Expr.attrHandle.href = function( elem ) {
1076	return elem.getAttribute( "href", 2 );
1077	};
1078	}
1079
1080	// release memory in IE
1081	div = null;
1082	})();
1083
1084	if ( document.querySelectorAll ) {
1085	(function(){
1086	var oldSizzle = Sizzle,
1087	div = document.createElement("div"),
1088	id = "__sizzle__";
1089
1090	div.innerHTML = "<p class='TEST'></p>";
1091
1092	// Safari can't handle uppercase or unicode characters when
1093	// in quirks mode.
1094	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
1095	return;
1096	}
1097
1098	Sizzle = function( query, context, extra, seed ) {
1099	context = context \|\| document;
1100
1101	// Only use querySelectorAll on non-XML documents
1102	// (ID selectors don't work in non-HTML documents)
1103	if ( !seed && !Sizzle.isXML(context) ) {
1104	// See if we find a selector to speed up
1105	var match = /^(\w+$)\|^\.([\w\-]+$)\|^#([\w\-]+$)/.exec( query );
1106
1107	if ( match && (context.nodeType === 1 \|\| context.nodeType === 9) ) {
1108	// Speed-up: Sizzle("TAG")
1109	if ( match[1] ) {
1110	return makeArray( context.getElementsByTagName( query ), extra );
1111
1112	// Speed-up: Sizzle(".CLASS")
1113	} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
1114	return makeArray( context.getElementsByClassName( match[2] ), extra );
1115	}
1116	}
1117
1118	if ( context.nodeType === 9 ) {
1119	// Speed-up: Sizzle("body")
1120	// The body element only exists once, optimize finding it
1121	if ( query === "body" && context.body ) {
1122	return makeArray( [ context.body ], extra );
1123
1124	// Speed-up: Sizzle("#ID")
1125	} else if ( match && match[3] ) {
1126	var elem = context.getElementById( match[3] );
1127
1128	// Check parentNode to catch when Blackberry 4.6 returns
1129	// nodes that are no longer in the document #6963
1130	if ( elem && elem.parentNode ) {
1131	// Handle the case where IE and Opera return items
1132	// by name instead of ID
1133	if ( elem.id === match[3] ) {
1134	return makeArray( [ elem ], extra );
1135	}
1136
1137	} else {
1138	return makeArray( [], extra );
1139	}
1140	}
1141
1142	try {
1143	return makeArray( context.querySelectorAll(query), extra );
1144	} catch(qsaError) {}
1145
1146	// qSA works strangely on Element-rooted queries
1147	// We can work around this by specifying an extra ID on the root
1148	// and working up from there (Thanks to Andrew Dupont for the technique)
1149	// IE 8 doesn't work on object elements
1150	} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1151	var old = context.getAttribute( "id" ),
1152	nid = old \|\| id,
1153	hasParent = context.parentNode,
1154	relativeHierarchySelector = /^\s*[+~]/.test( query );
1155
1156	if ( !old ) {
1157	context.setAttribute( "id", nid );
1158	} else {
1159	nid = nid.replace( /'/g, "\\$&" );
1160	}
1161	if ( relativeHierarchySelector && hasParent ) {
1162	context = context.parentNode;
1163	}
1164
1165	try {
1166	if ( !relativeHierarchySelector \|\| hasParent ) {
1167	return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
1168	}
1169
1170	} catch(pseudoError) {
1171	} finally {
1172	if ( !old ) {
1173	context.removeAttribute( "id" );
1174	}
1175	}
1176	}
1177	}
1178
1179	return oldSizzle(query, context, extra, seed);
1180	};
1181
1182	for ( var prop in oldSizzle ) {
1183	Sizzle[ prop ] = oldSizzle[ prop ];
1184	}
1185
1186	// release memory in IE
1187	div = null;
1188	})();
1189	}
1190
1191	(function(){
1192	var html = document.documentElement,
1193	matches = html.matchesSelector \|\| html.mozMatchesSelector \|\| html.webkitMatchesSelector \|\| html.msMatchesSelector,
1194	pseudoWorks = false;
1195
1196	try {
1197	// This should fail with an exception
1198	// Gecko does not error, returns false instead
1199	matches.call( document.documentElement, "[test!='']:sizzle" );
1200
1201	} catch( pseudoError ) {
1202	pseudoWorks = true;
1203	}
1204
1205	if ( matches ) {
1206	Sizzle.matchesSelector = function( node, expr ) {
1207	// Make sure that attribute selectors are quoted
1208	expr = expr.replace(/\=\s([^'"\]])\s*\]/g, "='$1']");
1209
1210	if ( !Sizzle.isXML( node ) ) {
1211	try {
1212	if ( pseudoWorks \|\| !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
1213	return matches.call( node, expr );
1214	}
1215	} catch(e) {}
1216	}
1217
1218	return Sizzle(expr, null, null, [node]).length > 0;
1219	};
1220	}
1221	})();
1222
1223	(function(){
1224	var div = document.createElement("div");
1225
1226	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
1227
1228	// Opera can't find a second classname (in 9.6)
1229	// Also, make sure that getElementsByClassName actually exists
1230	if ( !div.getElementsByClassName \|\| div.getElementsByClassName("e").length === 0 ) {
1231	return;
1232	}
1233
1234	// Safari caches class attributes, doesn't catch changes (in 3.2)
1235	div.lastChild.className = "e";
1236
1237	if ( div.getElementsByClassName("e").length === 1 ) {
1238	return;
1239	}
1240
1241	Expr.order.splice(1, 0, "CLASS");
1242	Expr.find.CLASS = function( match, context, isXML ) {
1243	if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
1244	return context.getElementsByClassName(match[1]);
1245	}
1246	};
1247
1248	// release memory in IE
1249	div = null;
1250	})();
1251
1252	function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
1253	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1254	var elem = checkSet[i];
1255
1256	if ( elem ) {
1257	var match = false;
1258
1259	elem = elem[dir];
1260
1261	while ( elem ) {
1262	if ( elem.sizcache === doneName ) {
1263	match = checkSet[elem.sizset];
1264	break;
1265	}
1266
1267	if ( elem.nodeType === 1 && !isXML ){
1268	elem.sizcache = doneName;
1269	elem.sizset = i;
1270	}
1271
1272	if ( elem.nodeName.toLowerCase() === cur ) {
1273	match = elem;
1274	break;
1275	}
1276
1277	elem = elem[dir];
1278	}
1279
1280	checkSet[i] = match;
1281	}
1282	}
1283	}
1284
1285	function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
1286	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1287	var elem = checkSet[i];
1288
1289	if ( elem ) {
1290	var match = false;
1291
1292	elem = elem[dir];
1293
1294	while ( elem ) {
1295	if ( elem.sizcache === doneName ) {
1296	match = checkSet[elem.sizset];
1297	break;
1298	}
1299
1300	if ( elem.nodeType === 1 ) {
1301	if ( !isXML ) {
1302	elem.sizcache = doneName;
1303	elem.sizset = i;
1304	}
1305
1306	if ( typeof cur !== "string" ) {
1307	if ( elem === cur ) {
1308	match = true;
1309	break;
1310	}
1311
1312	} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
1313	match = elem;
1314	break;
1315	}
1316	}
1317
1318	elem = elem[dir];
1319	}
1320
1321	checkSet[i] = match;
1322	}
1323	}
1324	}
1325
1326	if ( document.documentElement.contains ) {
1327	Sizzle.contains = function( a, b ) {
1328	return a !== b && (a.contains ? a.contains(b) : true);
1329	};
1330
1331	} else if ( document.documentElement.compareDocumentPosition ) {
1332	Sizzle.contains = function( a, b ) {
1333	return !!(a.compareDocumentPosition(b) & 16);
1334	};
1335
1336	} else {
1337	Sizzle.contains = function() {
1338	return false;
1339	};
1340	}
1341
1342	Sizzle.isXML = function( elem ) {
1343	// documentElement is verified for cases where it doesn't yet exist
1344	// (such as loading iframes in IE - #4833)
1345	var documentElement = (elem ? elem.ownerDocument \|\| elem : 0).documentElement;
1346
1347	return documentElement ? documentElement.nodeName !== "HTML" : false;
1348	};
1349
1350	var posProcess = function( selector, context ) {
1351	var match,
1352	tmpSet = [],
1353	later = "",
1354	root = context.nodeType ? [context] : context;
1355
1356	// Position selectors must be done after the filter
1357	// And so must :not(positional) so we move all PSEUDOs to the end
1358	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
1359	later += match[0];
1360	selector = selector.replace( Expr.match.PSEUDO, "" );
1361	}
1362
1363	selector = Expr.relative[selector] ? selector + "*" : selector;
1364
1365	for ( var i = 0, l = root.length; i < l; i++ ) {
1366	Sizzle( selector, root[i], tmpSet );
1367	}
1368
1369	return Sizzle.filter( later, tmpSet );
1370	};
1371
1372	// EXPOSE
1373
1374	window.Sizzle = Sizzle;
1375
1376	})();

Note: See TracBrowser for help on using the repository browser.

Download in other formats: