<?xml version="1.0" encoding="UTF-8"?>
<commit>
  <added type="array"/>
  <modified type="array">
    <modified>
      <diff>@@ -12,7 +12,7 @@
 			originaljQuery = jQuery,
 			original$ = $;
 		function $$(selector, context){
-			return slick(context||document, selector);
+			return Slick(context||document, selector);
 		};
 		
 	&lt;/script&gt;</diff>
      <filename>3rd-party-tests/jquery.html</filename>
    </modified>
    <modified>
      <diff>@@ -98,7 +98,7 @@
         match: function(element, selector) {
           return !Object.isString(selector) &amp;&amp; Object.isFunction(selector.match) ?
             selector.match($(element)) :
-            slick.match(selector, element);
+            Slick.match(selector, element);
         }
       });
 
@@ -491,7 +491,7 @@
           new Selector('[id=myTD]').findElements(wrapper);
           this.assertNotNullOrUndefined(wrapper.select('[id=myTD]')[0], &quot;[id=myTD]&quot;);
           this.assertNotNullOrUndefined(wrapper.select('td')[0], &quot;td&quot;);
-          this.assertNotNullOrUndefined(slick.match('#myTD', wrapper)[0], &quot;#myTD&quot;);
+          this.assertNotNullOrUndefined(Slick.match('#myTD', wrapper)[0], &quot;#myTD&quot;);
         }
       });
     &lt;/script&gt;</diff>
      <filename>3rd-party-tests/prototype.html</filename>
    </modified>
    <modified>
      <diff>@@ -79,7 +79,7 @@ Authors:
 	var matchers = {
 		
 		node: function(node, selector){
-			var parsed = this.slick.parse(selector).expressions[0][0];
+			var parsed = this.Slick.parse(selector).expressions[0][0];
 			if (!parsed) return true;
 			return this['match:selector'](node, parsed.tag, parsed.id, parsed.parts);
 		},
@@ -312,9 +312,9 @@ Authors:
 	
 	for (var p in pseudos) local['pseudo:' + p] = pseudos[p];
 	
-	// slick
+	// Slick
 	
-	this.slick = function(context, expression, append){
+	this.Slick = function(context, expression, append){
 		
 		if (!append) append = [];
 		
@@ -323,8 +323,8 @@ Authors:
 		if (expression == null){
 			return append;
 		} else if (typeof expression == 'string'){
-			parsed = slick.parse(expression);
-		} else if (expression.slick){
+			parsed = Slick.parse(expression);
+		} else if (expression.Slick){
 			parsed = expression;
 		} else if (local.contains(context, expression)){
 			append.push(expression);
@@ -339,10 +339,10 @@ Authors:
 		
 		// querySelectorAll for simple selectors
 		
-		if (parsed.simple &amp;&amp; context.querySelectorAll &amp;&amp; !slick.disableQSA){
+		if (parsed.simple &amp;&amp; context.querySelectorAll &amp;&amp; !Slick.disableQSA){
 			var nodes;
 			try{ nodes = context.querySelectorAll(expression); }
-			catch(error){ if (slick.debug) slick.debug('QSA Fail ' + expression, error); };
+			catch(error){ if (Slick.debug) Slick.debug('QSA Fail ' + expression, error); };
 			
 			if (nodes &amp;&amp; nodes.length) {
 				for (var e = 0, l = nodes.length; e &lt; l; e++) append.push(nodes[e]);
@@ -388,7 +388,7 @@ Authors:
 					if (local[combinator])
 						for (var m = 0, n = items.length; m &lt; n; m++) local[combinator](items[m], tag, id, parts, classes, attributes, pseudos);
 					else
-						if (slick.debug) slick.debug(&quot;Tried calling non-existant combinator: '&quot;+currentBit.combinator+&quot;'&quot;, currentExpression);
+						if (Slick.debug) Slick.debug(&quot;Tried calling non-existant combinator: '&quot;+currentBit.combinator+&quot;'&quot;, currentExpression);
 				}
 				
 				current = local.found;
@@ -400,22 +400,22 @@ Authors:
 
 	};
 	
-	local.slick = slick;
+	local.Slick = Slick;
 	
-	// slick contains
+	// Slick contains
 	
-	slick.contains = local.contains;
+	Slick.contains = local.contains;
 	
 	// add pseudos
 	
-	slick.definePseudo = function(name, fn){
+	Slick.definePseudo = function(name, fn){
 		local['pseudo:' + name] = function(node, argument){
 			return fn.call(node, argument);
 		};
 		return this;
 	};
 	
-	slick.lookupPseudo = function(name){
+	Slick.lookupPseudo = function(name){
 		var pseudo = local['pseudo:' + name];
 		if (pseudo) return function(argument){
 			return pseudo.call(this, argument);
@@ -424,16 +424,16 @@ Authors:
 	
 	local.attributeMethods = {};
 	
-	slick.lookupAttribute = function(name){
+	Slick.lookupAttribute = function(name){
 		return local.attributeMethods[name] || null;
 	};
 	
-	slick.defineAttribute = function(name, fn){
+	Slick.defineAttribute = function(name, fn){
 		local.attributeMethods[name] = fn;
 		return this;
 	};
 	
-	slick.defineAttribute('class', function(){
+	Slick.defineAttribute('class', function(){
 		return this.className;
 	});
 	
@@ -444,20 +444,20 @@ Authors:
 	
 	// matcher
 	
-	slick.match = function(node, selector){
+	Slick.match = function(node, selector){
 		if (!selector || selector === node) return true;
 		local.positions = {};
 		return local['match:node'](node, selector);
 	};
 	
-	// slick.reverseMatch = function(node, selector){
+	// Slick.reverseMatch = function(node, selector){
 		
-		// var selector = slick.reverse(selector);
+		// var selector = Slick.reverse(selector);
 		
-		// return slick(node, );
+		// return Slick(node, );
 	// };
 	
-	slick.uniques = function(nodes, append){
+	Slick.uniques = function(nodes, append){
 		var uniques = {};
 		if (!append) append = [];
 		for (var i = 0, l = nodes.length; i &lt; l; i++){
@@ -476,11 +476,11 @@ Authors:
 
 (function(){
 	
-	slick.parse = function(expression){
+	Slick.parse = function(expression){
 		return parse(expression);
 	};
 	
-	slick.reverse = function(expression){
+	Slick.reverse = function(expression){
 		return parse((typeof expression == 'string') ? expression : expression.raw, true);
 	};
 	
@@ -491,7 +491,7 @@ Authors:
 		var currentCache = (reversed) ? reverseCache : cache;
 		if (currentCache[expression]) return currentCache[expression];
 		var exp = expression;
-		parsed = {slick: true, simple: true, expressions: [[]], raw: expression, reverse: function(){
+		parsed = {Slick: true, simple: true, expressions: [[]], raw: expression, reverse: function(){
 			return parse(this.raw, true);
 		}};
 		separatorIndex = -1;
@@ -529,13 +529,13 @@ Authors:
 		return string.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, &quot;\\$&amp;&quot;);
 	};
 	
-	slick.parse.escapeRegExp = escapeRegExp;
+	Slick.parse.escapeRegExp = escapeRegExp;
 	
-	slick.parse.getCombinators = function(){
+	Slick.parse.getCombinators = function(){
 		return combinatorChars.split('');
 	};
 	
-	slick.parse.setCombinators = function(combinators){
+	Slick.parse.setCombinators = function(combinators){
 		combinatorChars = escapeRegExp(combinators.join(''));
 		regexp = new RegExp((&quot;(?x)\
 			^(?:\n\
@@ -550,7 +550,7 @@ Authors:
 			|   :+ ( [a-z0-9_-]+       )(            \\( (?: \&quot;([^\&quot;]*)\&quot; | '([^']*)' | ([^\\)]*) ) \\) )?             # Pseudo    \n\
 		)&quot;).replace(/\(\?x\)|\s+#.*$|\s+/gim, ''), 'i');
 		
-		return slick.parse;
+		return Slick.parse;
 	};
 	
 	var qsaCombinators = (/^(\s|[~+&gt;])$/);
@@ -558,7 +558,7 @@ Authors:
 	var combinatorChars = &quot;&gt;+~&quot; + &quot;`!@$%^&amp;={}\\;&lt;/&quot;;
 	
 	var regexp;
-	slick.parse.setCombinators(combinatorChars.split(''));
+	Slick.parse.setCombinators(combinatorChars.split(''));
 	
 	var map = {
 		rawMatch: 0,
@@ -718,5 +718,5 @@ Authors:
 })();
 
 document.search = function(expression){
-	return slick(document, expression);
+	return Slick(document, expression);
 };</diff>
      <filename>slick.js</filename>
    </modified>
    <modified>
      <diff>@@ -4,7 +4,7 @@
 
 [Slick]
 	file = &quot;../../slick.js&quot;
-	function = &quot;slick(%2$s, %1$s)&quot;
+	function = &quot;Slick(%2$s, %1$s)&quot;
 
 ; [Prototype 1.6.0.3]
 ; 	file = &quot;prototype.js&quot;</diff>
      <filename>speed/config.ini</filename>
    </modified>
    <modified>
      <diff>@@ -2,7 +2,7 @@ String.escapeSingle = function escapeSingle(string){
 	return (''+string).replace(/(?=[\\\n'])/g,'\\');
 };
 
-slick.parse.attribValueToFn = function(operator, attribute){
+Slick.parse.attribValueToFn = function(operator, attribute){
 	var test, regexp;
 	
 	switch (operator){
@@ -15,10 +15,10 @@ slick.parse.attribValueToFn = function(operator, attribute){
 		case '*=': test = function(value){
 			return value.indexOf(attribute) &gt; -1;
 		}; break;
-		case '^=': regexp = new RegExp('^' + slick.parse.escapeRegExp(attribute)); break;
-		case '$=': regexp = new RegExp(slick.parse.escapeRegExp(attribute) + '$'); break;
-		case '~=': regexp = new RegExp('(^|\\s)' + slick.parse.escapeRegExp(attribute) + '(\\s|$)'); break;
-		case '|=': regexp = new RegExp('(^|\\|)' + slick.parse.escapeRegExp(attribute) + '(\\||$)'); break;
+		case '^=': regexp = new RegExp('^' + Slick.parse.escapeRegExp(attribute)); break;
+		case '$=': regexp = new RegExp(Slick.parse.escapeRegExp(attribute) + '$'); break;
+		case '~=': regexp = new RegExp('(^|\\s)' + Slick.parse.escapeRegExp(attribute) + '(\\s|$)'); break;
+		case '|=': regexp = new RegExp('(^|\\|)' + Slick.parse.escapeRegExp(attribute) + '(\\||$)'); break;
 		
 		default: test = function(value){
 			return !!value;
@@ -32,16 +32,16 @@ slick.parse.attribValueToFn = function(operator, attribute){
 	return regexp || { test:test, toString: function(){return String(test);} };
 };
 
-slick.debug = function(message){
+Slick.debug = function(message){
 	try{console.log(Array.prototype.slice.call(arguments));}catch(e){};
 	throw new Error(message);
 };
-// slick.debug = false;
+// Slick.debug = false;
 
 function makeSlickTestCombinator(tag, combinator, tag2) {
 	if (combinator.split('').length===3) combinator = combinator.split('')[2];
 	var functionString = '\n';
-	functionString += &quot;var s = slick.parse('&quot;+String.escapeSingle(tag + combinator + tag2)+&quot;');\n&quot;;
+	functionString += &quot;var s = Slick.parse('&quot;+String.escapeSingle(tag + combinator + tag2)+&quot;');\n&quot;;
 	
 	functionString+=&quot;value_of( s[0][0].tag ).should_be( '&quot;+String.escapeSingle(tag)+&quot;' );\n&quot; +
 					&quot;value_of( s[0][1].tag ).should_be( '&quot;+String.escapeSingle(tag2)+&quot;' );\n&quot; +
@@ -51,7 +51,7 @@ function makeSlickTestCombinator(tag, combinator, tag2) {
 
 function makeSlickTestAttrib(attr, op, val) {
 	var functionString = '\n';
-	functionString += &quot;var s = slick.parse('[&quot;+String.escapeSingle(attr + op + (op&amp;&amp;val))+&quot;]')[0][0];\n\
+	functionString += &quot;var s = Slick.parse('[&quot;+String.escapeSingle(attr + op + (op&amp;&amp;val))+&quot;]')[0][0];\n\
 	value_of( s.attributes.length ).should_be( 1 );\n\
 	value_of( s.attributes[0].name ).should_be( '&quot;+String.escapeSingle(attr)+&quot;' );\n\
 	&quot;;
@@ -65,7 +65,7 @@ function makeSlickTestAttrib(attr, op, val) {
 		functionString += &quot;\
 		value_of( s.attributes[0].operator ).should_be( '&quot;+String.escapeSingle( op )+&quot;' );\n\
 		value_of( s.attributes[0].value ).should_be( '&quot;+String.escapeSingle( val.replace(/^[\&quot;']|['\&quot;]$/g,'') )+&quot;' );\n\
-		value_of( s.attributes[0].regexp.toString() ).should_be( '&quot;+String.escapeSingle( slick.parse.attribValueToFn(op, op&amp;&amp;val.replace(/^[\&quot;']|['\&quot;]$/g,'')).toString() )+&quot;' );\n\
+		value_of( s.attributes[0].regexp.toString() ).should_be( '&quot;+String.escapeSingle( Slick.parse.attribValueToFn(op, op&amp;&amp;val.replace(/^[\&quot;']|['\&quot;]$/g,'')).toString() )+&quot;' );\n\
 		&quot;;
 	}
 	return new Function(functionString);
@@ -73,11 +73,11 @@ function makeSlickTestAttrib(attr, op, val) {
 
 function makeSlickTestSearch(selector, count, disableQSA) {
 	// if (document.querySelectorAll)
-	// return new Function(&quot; var count; try{ count = document.querySelectorAll('&quot;+String.escapeSingle(selector)+&quot;').length; console.log('&quot;+String.escapeSingle(selector)+&quot;', count); }catch(e){ \ncount=&quot;+count+&quot; }; value_of( slick(document, '&quot;+String.escapeSingle(selector)+&quot;').length ).should_be( count );&quot;);
-	return new Function(&quot;slick.disableQSA = &quot;+!!disableQSA+&quot;;\n value_of( slick(document, '&quot;+String.escapeSingle(selector)+&quot;').length ).should_be( &quot;+count+&quot; ); delete slick.disableQSA;&quot;);
+	// return new Function(&quot; var count; try{ count = document.querySelectorAll('&quot;+String.escapeSingle(selector)+&quot;').length; console.log('&quot;+String.escapeSingle(selector)+&quot;', count); }catch(e){ \ncount=&quot;+count+&quot; }; value_of( Slick(document, '&quot;+String.escapeSingle(selector)+&quot;').length ).should_be( count );&quot;);
+	return new Function(&quot;Slick.disableQSA = &quot;+!!disableQSA+&quot;;\n value_of( Slick(document, '&quot;+String.escapeSingle(selector)+&quot;').length ).should_be( &quot;+count+&quot; ); delete Slick.disableQSA;&quot;);
 }
 
-// slick.parse.debug = true;
+// Slick.parse.debug = true;
 
 var combinators = ' ,&gt;,+,~,   , &gt; , + , ~ '.split(',');
 // var tags = 'a abbr acronym address applet area b base basefont bdo big blockquote br button caption center cite code col colgroup dd del dfn dir div dl dt em fieldset font form frame frameset h1 h2 h3 h4 h5 h6 head hr html i iframe img input ins isindex kbd label legend li link map menu meta noframes noscript object ol optgroup option p param pre q s samp script select small span strike strong style sub sup table tbody td textarea tfoot th thead title tr tt u ul var'.split(' ');
@@ -92,20 +92,20 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 	
 	var combinatorsOld;
 	
-	var slick_parse_Specs = {
+	var Slick_parse_Specs = {
 		before_all: function(){
-			combinatorsOld = slick.parse.getCombinators(combinatorsSpecial);
-			slick.parse.setCombinators(combinatorsSpecial);
+			combinatorsOld = Slick.parse.getCombinators(combinatorsSpecial);
+			Slick.parse.setCombinators(combinatorsSpecial);
 		},
 		after_all: function(){
-			slick.parse.setCombinators(combinatorsOld);
+			Slick.parse.setCombinators(combinatorsOld);
 		},
 		
-		'Should exist slick.parse.setCombinators': function(){
-			value_of( slick.parse.setCombinators ).should_not_be_undefined();
-			combinatorsOld = slick.parse.getCombinators(combinatorsSpecial);
-			slick.parse.setCombinators(combinatorsSpecial);
-			slick.parse.setCombinators(combinatorsOld);
+		'Should exist Slick.parse.setCombinators': function(){
+			value_of( Slick.parse.setCombinators ).should_not_be_undefined();
+			combinatorsOld = Slick.parse.getCombinators(combinatorsSpecial);
+			Slick.parse.setCombinators(combinatorsSpecial);
+			Slick.parse.setCombinators(combinatorsOld);
 		}
 	};
 	
@@ -115,36 +115,36 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 		tag = tag2 = tags[0];
 		// for (var i=0; i &lt; tags.length; i++) {var tag = tags[i];
 			
-			slick_parse_Specs['should parse '+tag+' tags with &quot;'+combinator+'&quot; custom combinator' ] = makeSlickTestCombinator(tag, combinator, tag);
+			Slick_parse_Specs['should parse '+tag+' tags with &quot;'+combinator+'&quot; custom combinator' ] = makeSlickTestCombinator(tag, combinator, tag);
 		// }
 	}
 	
-	slick_parse_Specs = {
-		'Should exist slick.parse.setCombinators':slick_parse_Specs['Should exist slick.parse.setCombinators'],
+	Slick_parse_Specs = {
+		'Should exist Slick.parse.setCombinators':Slick_parse_Specs['Should exist Slick.parse.setCombinators'],
 		'Should finalize object format': function(){
 			throw new Error('uncomment all these tests once we finalize the object format');
 		}
 	};
-	describe('slick.parse Custom Combinators', slick_parse_Specs);
+	describe('Slick.parse Custom Combinators', Slick_parse_Specs);
 })();
 
 // Parsing
 (function(){
-	var slick_parse_Specs = {
+	var Slick_parse_Specs = {
 		
 		'should exist': function(){
-			value_of( slick.parse ).should_not_be_undefined();
+			value_of( Slick.parse ).should_not_be_undefined();
 		}
 		,
 		'should parse multiple selectors': function(){
-			var s = slick.parse('a, b, c');
+			var s = Slick.parse('a, b, c');
 			value_of( s[0][0].tag ).should_be( 'a' );
 			value_of( s[1][0].tag ).should_be( 'b' );
 			value_of( s[2][0].tag ).should_be( 'c' );
 		}
 		,
 		'should parse multiple selectors with class': function(){
-			var s = slick.parse('a.class, b.class, c.class');
+			var s = Slick.parse('a.class, b.class, c.class');
 			value_of( s[0][0].tag ).should_be( 'a' );
 			value_of( s[1][0].tag ).should_be( 'b' );
 			value_of( s[2][0].tag ).should_be( 'c' );
@@ -155,7 +155,7 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 		,
 		'should parse tag names': function(){
 			for (var i=0; i &lt; tags.length; i++) {var tag = tags[i];
-				value_of( slick.parse(tag)[0][0].tag ).should_be( tag );
+				value_of( Slick.parse(tag)[0][0].tag ).should_be( tag );
 			}
 		}
 		,
@@ -171,7 +171,7 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 				{raw:          &quot;:nth-child(n)&quot;, name:'nth-child', argument:&quot;n&quot;   }
 			];
 			for (var i=0,s, N; N = nths[i]; i++){
-				s = slick.parse(N.raw);
+				s = Slick.parse(N.raw);
 				value_of( s[0][0].pseudos[0].name ).should_be( N.name );
 				value_of( s[0][0].pseudos[0].argument ).should_be( N.argument );
 			}
@@ -189,40 +189,40 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 				{raw:&quot;:nth-child(n)&quot;   , name:'nth-child', argument:&quot;n&quot;  }
 			];
 			for (var i=0,s, N; N = nths[i]; i++){
-				s = slick.parse(N.raw);
+				s = Slick.parse(N.raw);
 				value_of( s[0][0].pseudos[0].name ).should_be( N.name );
 				value_of( s[0][0].pseudos[0].argument ).should_be( N.argument );
 			}
 		}
 		,
 		'should parse :not(with quoted innards)': function(){
-			var s = slick.parse(&quot;:not()&quot;)[0][0];
+			var s = Slick.parse(&quot;:not()&quot;)[0][0];
 			value_of( s.pseudos.length ).should_be(1);
 			value_of( s.pseudos[0].name ).should_be('not');
 			value_of( s.pseudos[0].argument ).should_be(&quot;&quot;);
 			
-			s = slick.parse(':not([attr])')[0][0];
+			s = Slick.parse(':not([attr])')[0][0];
 			value_of( s.pseudos[0].argument ).should_be('[attr]');
 			
-			s = slick.parse(':not([attr=])')[0][0];
+			s = Slick.parse(':not([attr=])')[0][0];
 			value_of( s.pseudos[0].argument ).should_be('[attr=]');
 			
-			s = slick.parse(&quot;:not([attr=''])&quot;)[0][0];
+			s = Slick.parse(&quot;:not([attr=''])&quot;)[0][0];
 			value_of( s.pseudos[0].argument ).should_be(&quot;[attr='']&quot;);
 			
-			s = slick.parse(':not([attr=&quot;&quot;])')[0][0];
+			s = Slick.parse(':not([attr=&quot;&quot;])')[0][0];
 			value_of( s.pseudos[0].argument ).should_be('[attr=&quot;&quot;]');
 		}
 		,
 		'should parse :pseudo arguments as null': function(){
-			var s = slick.parse(&quot;:pseudo&quot;)[0][0];
+			var s = Slick.parse(&quot;:pseudo&quot;)[0][0];
 			value_of( s.pseudos.length ).should_be(1);
 			value_of( s.pseudos[0].name ).should_be('pseudo');
 			value_of( s.pseudos[0].argument ).should_be_null();
 		}
 		,
 		'should parse :pseudo() arguments as &quot;&quot;': function(){
-			var s = slick.parse(&quot;:pseudo()&quot;)[0][0];
+			var s = Slick.parse(&quot;:pseudo()&quot;)[0][0];
 			value_of( s.pseudos.length ).should_be(1);
 			value_of( s.pseudos[0].name ).should_be('pseudo');
 			value_of( s.pseudos[0].argument ).should_not_be_null();
@@ -236,7 +236,7 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 	for (var C=0; C &lt; combinators.length; C++) {var combinator = combinators[C];
 		for (var i=0; i &lt; tags.length; i++) {var tag = tags[i];
 			
-			slick_parse_Specs['should parse '+tag+' tags with &quot;'+combinator+'&quot; combinator' ] = makeSlickTestCombinator(tag, combinator, tag);
+			Slick_parse_Specs['should parse '+tag+' tags with &quot;'+combinator+'&quot; combinator' ] = makeSlickTestCombinator(tag, combinator, tag);
 		}
 	}
 	
@@ -247,14 +247,14 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 			/*operators:*/ for (var oi=0; oi &lt; attribOperators.length; oi++) {
 				var op = attribOperators[oi];
 				
-				slick_parse_Specs['should parse attributes: '+ '['+ attr + op + (op&amp;&amp;val) +']'] = makeSlickTestAttrib(attr, op, val);
+				Slick_parse_Specs['should parse attributes: '+ '['+ attr + op + (op&amp;&amp;val) +']'] = makeSlickTestAttrib(attr, op, val);
 			}
 		}
 	}
 	
-	// describe('slick.parse', slick_parse_Specs);
-	describe('slick.parse', {
-		'should finalize the slick.parse object': function(){
+	// describe('Slick.parse', Slick_parse_Specs);
+	describe('Slick.parse', {
+		'should finalize the Slick.parse object': function(){
 			throw new Error('fix these tests!');
 		}
 	});
@@ -262,7 +262,7 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 
 // Verify attribute selector regex
 (function(){
-	var slick_parse_Specs = {
+	var Slick_parse_Specs = {
 		before_all: function(){
 			window.testNode = document.createElement('div');
 		},
@@ -273,13 +273,13 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 	function makeAttributeTest(operator, value, matchAgainst, shouldBeTrue) {
 		var code = [''];
 		code.push(&quot;testNode.setAttribute('attr', '&quot;+ String.escapeSingle(matchAgainst) +&quot;');&quot;)
-		code.push(&quot;value_of( slick.match(testNode, \&quot;[attr&quot;+ operator +&quot;'&quot;+ String.escapeSingle(value) +&quot;']\&quot;) ).should_be_&quot;+ (shouldBeTrue ? 'true' : 'false') +&quot;();&quot;);
+		code.push(&quot;value_of( Slick.match(testNode, \&quot;[attr&quot;+ operator +&quot;'&quot;+ String.escapeSingle(value) +&quot;']\&quot;) ).should_be_&quot;+ (shouldBeTrue ? 'true' : 'false') +&quot;();&quot;);
 		code.push(&quot;testNode.removeAttribute('attr');&quot;);
 		return Function(code.join(&quot;\n\t&quot;));
 	}
 	function makeAttributeRegexTest(operator, value, matchAgainst, shouldBeTrue) {
 		var code = [''];
-		code.push(&quot;value_of( slick.parse.attribValueToFn('&quot;+ String.escapeSingle(operator) +&quot;', '&quot;+ String.escapeSingle(value) +&quot;').test('&quot;+ String.escapeSingle(matchAgainst) +&quot;') ).should_be_&quot;+ (shouldBeTrue ? 'true' : 'false') +&quot;();&quot;);
+		code.push(&quot;value_of( Slick.parse.attribValueToFn('&quot;+ String.escapeSingle(operator) +&quot;', '&quot;+ String.escapeSingle(value) +&quot;').test('&quot;+ String.escapeSingle(matchAgainst) +&quot;') ).should_be_&quot;+ (shouldBeTrue ? 'true' : 'false') +&quot;();&quot;);
 		return Function(code.join(&quot;\n\t&quot;));
 	}
 	
@@ -298,17 +298,17 @@ var vals = 'myValueOfDoom;&quot;double&quot;;\'single\';&quot;dou\\&quot;ble&quot;;\'sin\\\'gle\';();{};\
 	];
 	
 	for (var t=0,J; J=junk[t]; t++){
-		slick_parse_Specs['RegExp: &quot;'+J.matchAgainst+'&quot; should '+ (J.shouldBeTrue?'':'NOT') +' match '+ slick.parse.attribValueToFn(J.operator, J.value)] =
+		Slick_parse_Specs['RegExp: &quot;'+J.matchAgainst+'&quot; should '+ (J.shouldBeTrue?'':'NOT') +' match '+ Slick.parse.attribValueToFn(J.operator, J.value)] =
 			makeAttributeRegexTest(J.operator, J.value, J.matchAgainst, J.shouldBeTrue);
-		slick_parse_Specs['&quot;'+J.matchAgainst+'&quot; should '+ (J.shouldBeTrue?'':'NOT') +&quot; match \&quot;[attr&quot;+ J.operator +&quot;'&quot;+ String.escapeSingle(J.matchAgainst) +&quot;']\&quot;&quot;] =
+		Slick_parse_Specs['&quot;'+J.matchAgainst+'&quot; should '+ (J.shouldBeTrue?'':'NOT') +&quot; match \&quot;[attr&quot;+ J.operator +&quot;'&quot;+ String.escapeSingle(J.matchAgainst) +&quot;']\&quot;&quot;] =
 			makeAttributeTest(J.operator, J.value, J.matchAgainst, J.shouldBeTrue);
 	}
 	
-	// console&amp;&amp;console.log&amp;&amp;console.log(slick_parse_Specs);
+	// console&amp;&amp;console.log&amp;&amp;console.log(Slick_parse_Specs);
 	
-	// slick_parse_Specs['should convert attribute selector to regex'] = makeAttributeRegexTest('=', 'shmoo', 'shmoo', true);
+	// Slick_parse_Specs['should convert attribute selector to regex'] = makeAttributeRegexTest('=', 'shmoo', 'shmoo', true);
 	
-	describe('slick.parse attribute regex', slick_parse_Specs);
+	describe('Slick.parse attribute regex', Slick_parse_Specs);
 })()
 
 var s,f,kid,template;
@@ -526,7 +526,7 @@ var s,f,kid,template;
 	
 })({
 	'should exist': function(){
-		value_of( slick ).should_not_be_undefined();
+		value_of( Slick ).should_not_be_undefined();
 	},
 	
 	before: function(){</diff>
      <filename>test/specs.js</filename>
    </modified>
  </modified>
  <removed type="array"/>
  <parents type="array">
    <parent>
      <id>b5d29bb71eb1bccbda588a2b3b278dc8cb56931d</id>
    </parent>
  </parents>
  <author>
    <name>Scott Kyle</name>
    <email>scott@appden.com</email>
  </author>
  <url>http://github.com/subtleGradient/slick/commit/6e87bc335221f0e439af40c43f04cc714a9903ef</url>
  <id>6e87bc335221f0e439af40c43f04cc714a9903ef</id>
  <committed-date>2009-08-17T14:12:32-07:00</committed-date>
  <authored-date>2009-08-17T14:12:32-07:00</authored-date>
  <message>slick =&gt; Slick</message>
  <tree>68b0e078eabbcc5b4839b5a1a327b2e507844cc4</tree>
  <committer>
    <name>Scott Kyle</name>
    <email>scott@appden.com</email>
  </committer>
</commit>
