├── has-class.js
├── package.json
├── package.js
├── .jshintrc
├── load-css.js
├── css.js
├── README.md
├── load-imports.js
├── LICENSE
└── parser.js


/has-class.js:
--------------------------------------------------------------------------------
 1 | define(['dojo/has'], function(has){
 2 | 	var tested = {};
 3 | 	return function(){
 4 | 		var test, args = arguments;
 5 | 		for(var i = 0; i < args.length; i++){
 6 | 			var test = args[i];
 7 | 			if(!tested[test]){
 8 | 				tested[test] = true;
 9 | 				var parts = test.match(/^(no-)?(.+?)((-[\d\.]+)(-[\d\.]+)?)?$/), // parse the class name
10 | 					hasResult = has(parts[2]), // the actual has test
11 | 					lower = -parts[4]; // lower bound if it is in the form of test-4 or test-4-6 (would be 4)
12 | 				// if it has a range boundary, compare to see if we are in it
13 | 				if((lower > 0 ? lower <= hasResult && (-parts[5] || lower) >= hasResult :
14 | 						!!hasResult) == !parts[1]){ // parts[1] is the no- prefix that can negate the result
15 | 					document.documentElement.className += ' has-' + test;
16 | 				}
17 | 			}
18 | 		}
19 | 	};
20 | });


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "xstyle",
 3 |   "author": "Kris Zyp",
 4 |   "version": "0.3.1",
 5 |   "description": "CSS framework providing polyfills, extensions, dynamic loading, and selector based DOM manipulation",
 6 |   "licenses": [
 7 |     {
 8 |       "type": "AFLv2.1",
 9 |       "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
10 |     },
11 |     {
12 |       "type": "BSD",
13 |       "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
14 |     }
15 |   ],
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "http://github.com/kriszyp/xstyle"
19 |   },
20 |   "main": "./main",
21 |   "icon": "http://packages.dojofoundation.org/images/xstyle.jpg",
22 |   "dependencies": {
23 |     "dojo": "^1.7.0"
24 |   },
25 |   "dojoBuild": "package.js",
26 |   "volo": {
27 |     "type": "directory"
28 |   },
29 |   "devDependencies": {
30 |     "dojo": "^1.10.2"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/package.js:
--------------------------------------------------------------------------------
 1 | var miniExcludes = {
 2 | 		"xstyle/index.html": 1,
 3 | 		"xstyle/README.md": 1,
 4 | 		"xstyle/package": 1
 5 | 	},
 6 | 	copyOnlyRe = [
 7 | 		/\/build/, // contents of build folder and build.js
 8 | 		/\/core\/amdLoader/, // contents of core folder
 9 | 		/\/core\/put/, // contents of core folder
10 | 		/\/xstyle(\.min)?$/ // xstyle.min.*
11 | 	],
12 | 	isTestRe = /\/test\//;
13 | 
14 | var profile = {
15 | 	resourceTags: {
16 | 		test: function(filename, mid){
17 | 			return isTestRe.test(filename);
18 | 		},
19 | 
20 | 		miniExclude: function(filename, mid){
21 | 			return isTestRe.test(filename) || mid in miniExcludes;
22 | 		},
23 | 
24 | 		amd: function(filename, mid){
25 | 			return /\.js$/.test(filename);
26 | 		},
27 | 		
28 | 		copyOnly: function(filename, mid){
29 | 			for(var i = copyOnlyRe.length; i--;){
30 | 				if(copyOnlyRe[i].test(mid)){
31 | 					return true;
32 | 				}
33 | 			}
34 | 			return false;
35 | 		}
36 | 	}
37 | };


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"asi": false,
 3 | 	"bitwise": false,
 4 | 	"boss": false,
 5 | 	"browser": true,
 6 | 	"camelcase": true,
 7 | 	"couch": false,
 8 | 	"curly": true,
 9 | 	"debug": false,
10 | 	"devel": true,
11 | 	"dojo": false,
12 | 	"eqeqeq": false,
13 | 	"eqnull": true,
14 | 	"es3": true,
15 | 	"esnext": false,
16 | 	"evil": false,
17 | 	"expr": true,
18 | 	"forin": false,
19 | 	"funcscope": true,
20 | 	"gcl": false,
21 | 	"globalstrict": false,
22 | 	"immed": true,
23 | 	"iterator": false,
24 | 	"jquery": false,
25 | 	"lastsemic": false,
26 | 	"latedef": false,
27 | 	"laxbreak": true,
28 | 	"laxcomma": false,
29 | 	"loopfunc": true,
30 | 	"mootools": false,
31 | 	"moz": false,
32 | 	"multistr": false,
33 | 	"newcap": true,
34 | 	"noarg": true,
35 | 	"node": false,
36 | 	"noempty": false,
37 | 	"nonew": true,
38 | 	"nonstandard": false,
39 | 	"nomen": false,
40 | 	"onecase": false,
41 | 	"onevar": false,
42 | 	"passfail": false,
43 | 	"phantom": false,
44 | 	"plusplus": false,
45 | 	"proto": true,
46 | 	"prototypejs": false,
47 | 	"regexdash": true,
48 | 	"regexp": false,
49 | 	"rhino": false,
50 | 	"scripturl": true,
51 | 	"shadow": true,
52 | 	"shelljs": false,
53 | 	"smarttabs": true,
54 | 	"strict": false,
55 | 	"sub": false,
56 | 	"supernew": false,
57 | 	"trailing": true,
58 | 	"undef": true,
59 | 	"unused": true,
60 | 	"validthis": true,
61 | 	"withstmt": false,
62 | 	"worker": false,
63 | 	"wsh": false,
64 | 	"yui": false,
65 | 	"white": false,
66 | 
67 | 	"maxlen": 140,
68 | 	"indent": 4,
69 | 	"maxerr": 250,
70 | 	"predef": [ "require", "define" ],
71 | 	"quotmark": "single",
72 | 	"maxcomplexity": 20
73 | }


--------------------------------------------------------------------------------
/load-css.js:
--------------------------------------------------------------------------------
 1 | define([], function(){
 2 | 	'use strict';
 3 | 	// this module is responsible for doing the loading/insertion
 4 | 	// of stylesheets to get CSS loaded.
 5 | 
 6 | 	var cache = typeof _css_cache == 'undefined' ? {} : _css_cache;
 7 | 	var doc = document;
 8 | 
 9 | 	function has(){
10 | 		return !doc.createStyleSheet;
11 | 	}
12 | 	var head = doc.head;
13 | 	function insertCss(css){
14 | 		if(has("dom-create-style-element")){
15 | 			// we can use standard <style> element creation
16 | 			styleSheet = doc.createElement("style");
17 | 			styleSheet.setAttribute("type", "text/css");
18 | 			styleSheet.appendChild(doc.createTextNode(css));
19 | 			head.insertBefore(styleSheet, head.firstChild);
20 | 			return styleSheet;
21 | 		}
22 | 		else{
23 | 			// IE's stylesheet insertion
24 | 			var styleSheet = doc.createStyleSheet();
25 | 			styleSheet.cssText = css;
26 | 			return styleSheet.owningElement;
27 | 		}
28 | 	}
29 | 
30 | 	function load(resourceDef, callback, options){
31 | 		var cached = cache[resourceDef];
32 | 		if(cached){
33 | 			// if it is cached (from a build), we directly insert
34 | 			link = insertCss(cached);
35 | 			return callback(link);
36 | 		}
37 | 		// create a link element to load the stylesheet
38 | 		var link = doc.createElement('link');
39 | 		link.type = 'text/css';
40 | 		link.rel = 'stylesheet';
41 | 		link.href = resourceDef;
42 | 		var wait = !options || options.wait !== false;
43 | 		// old webkit's would claim to have onload, but didn't really support it
44 | 		var webkitVersion = navigator.userAgent.match(/AppleWebKit\/(\d+\.?\d*)/);
45 | 		webkitVersion = webkitVersion && +webkitVersion[1];
46 | 		if(link.onload === null && !(webkitVersion < 536)){
47 | 			// most browsers support this onload function now
48 | 			link.onload = function(){
49 | 				// cleanup
50 | 				link.onload = null;
51 | 				link.onerror = null;
52 | 				wait && callback(link);
53 | 			};
54 | 			// always add the error handler, so we can notify of any errors
55 | 			link.onerror = function(){
56 | 				// there isn't really any recourse in AMD for errors, so
57 | 				// we just output the error and continue on
58 | 				console.error('Error loading stylesheet ' + resourceDef);
59 | 				wait && callback(link);
60 | 			};
61 | 		}else if(wait){
62 | 			var interval = setInterval(function(){
63 | 				if(link.style){
64 | 					// loaded
65 | 					clearInterval(interval);
66 | 					callback(link);
67 | 				}
68 | 			}, 15);
69 | 		}
70 | 		// add it to the head to trigger loading
71 | 		(head || doc.getElementsByTagName('head')[0]).appendChild(link);
72 | 		if(!wait){
73 | 			// don't wait for the stylesheet to load, proceed
74 | 			callback(link);
75 | 		}
76 | 	}
77 | 	load.insertCss = insertCss;
78 | 	return load;
79 | });
80 | 


--------------------------------------------------------------------------------
/css.js:
--------------------------------------------------------------------------------
 1 | define(["require"], function(moduleRequire){
 2 | "use strict";
 3 | /*
 4 |  * AMD css! plugin
 5 |  * This plugin will load and wait for css files. This allows JavaScript resources to 
 6 |  * fully there dependencies on stylesheets. This can also be used when
 7 |  * loading css files as part of a layer or as a way to apply a run-time theme. This
 8 |  * module checks to see if the CSS is already loaded before incurring the cost
 9 |  * of loading the full CSS loader codebase
10 |  */
11 |  	function testElementStyle(tag, id, property){
12 |  		// test an element's style
13 | 		var docElement = document.documentElement;
14 | 		var testDiv = docElement.insertBefore(document.createElement(tag), docElement.firstChild);
15 | 		testDiv.id = id;
16 | 		var styleValue = (testDiv.currentStyle || getComputedStyle(testDiv, null))[property];
17 | 		docElement.removeChild(testDiv);
18 |  		return styleValue;
19 |  	} 
20 |  	return {
21 | 		load: function(resourceDef, require, callback, config) {
22 | 			var url = require.toUrl(resourceDef);
23 | 			var options;
24 | 			if(url.match(/!$/)){
25 | 				// a final ! can be used to indicate not to wait for the stylesheet to load
26 | 				options = {
27 | 					wait: false
28 | 				};
29 | 				url = url.slice(0, -1);
30 | 			}
31 | 			var cachedCss = require.cache && require.cache['url:' + url];
32 | 			if(cachedCss){
33 | 				// we have CSS cached inline in the build
34 | 				if(cachedCss.xCss){
35 | 					var parser = cachedCss.parser;
36 | 					var xCss =cachedCss.xCss;
37 | 					cachedCss = cachedCss.cssText;
38 | 				}
39 | 				moduleRequire(['./core/load-css'],function(load){
40 | 					checkForParser(load.insertCss(cachedCss));
41 | 				});
42 | 				if(xCss){
43 | 					//require([parsed], callback);
44 | 				}
45 | 				return;
46 | 			}
47 | 			function checkForParser(styleSheetElement){
48 | 				var parser = testElementStyle('x-parse', null, 'content');
49 | 				var sheet = styleSheetElement && 
50 | 					(styleSheetElement.sheet || styleSheetElement.styleSheet);
51 | 				if(parser && parser != 'none' && parser != 'normal'){
52 | 					// TODO: wait for parser to load
53 | 					require([eval(parser)], function(parser){
54 | 						if(styleSheetElement){
55 | 							parser.process(styleSheetElement, callback);
56 | 						}else{
57 | 							parser.processAll();
58 | 							callback(sheet);
59 | 						}
60 | 					});
61 | 				}else{
62 | 					callback(sheet);
63 | 				}
64 | 			}
65 | 			
66 | 			// if there is an id test available, see if the referenced rule is already loaded,
67 | 			// and if so we can completely avoid any dynamic CSS loading. If it is
68 | 			// not present, we need to use the dynamic CSS loader.
69 | 			var displayStyle = testElementStyle('div', resourceDef.replace(/\//g,'-').replace(/\..*/,'') + "-loaded", 'display');
70 | 			if(displayStyle == "none"){
71 | 				return checkForParser();
72 | 			}
73 | 			// use dynamic loader
74 | 			moduleRequire(["./core/load-css"], function(load){
75 | 				load(url, checkForParser, options);
76 | 			});
77 | 		}
78 | 	};
79 | });
80 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Cassius is an AMD CSS loader, along with a few CSS utilities, including a CSS parser, with extensibility hooks, feature-based document element application, and corresponding build tools.
  2 | 
  3 | # Build
  4 | 
  5 | This functionality is partially implemented.
  6 | 
  7 | cassius includes built tools that serve several purposes. First, they provide CSS aggregation,
  8 | combining @import'ed stylesheets into parent stylesheets to reduce requests. Second,
  9 | it will perform CSS minification, eliminating unnecessary whitespace and comments.
 10 | cassius will also isolate extensions into a special property that allows the cassius parser
 11 | to run signficantly faster with a built stylesheet. To run the build tool, run the build.js
 12 | with node, providing a path to a stylesheet or directory of stylesheets to process, and 
 13 | a target to save the stylesheet to. For example, if we want to build app.css, we could do:
 14 | 
 15 | 	node build.js app.css ../built/app.css
 16 | 
 17 | The cassius build tool is also capable of inline resources like images directly in the stylesheet
 18 | with data: URLs. This can be very useful for reducing the number of requests. To mark resources for inlining, simply append a hash of #inline to the URL of the resource.
 19 | For example, if we had a background image pointing back.png, we could write the following rule
 20 | 
 21 | 	.content {
 22 | 		background: url(back.png#inline);
 23 | 	}
 24 | 
 25 | When the build tool runs, this URL will be transformed to a data URL, and no extra request
 26 | will be necessary to fetch this background image. While this can reduce the number of
 27 | requests, this is best used for images that are small and very likely to be used. Since
 28 | the URL is inline in the stylesheet, it increases the load time of the stylesheet, and 
 29 | if the image might not be used or is large, this may be more detrimental than the 
 30 | improved overall load time afforded by the reduced requests.
 31 | 
 32 | # AMD Plugin Loader
 33 | 
 34 | You can also use cassius as a CSS loader plugin for AMD loaders like Dojo and RequireJS. 
 35 | To use the CSS loader, use the AMD plugin syntax, with cassius/css as the plugin loader
 36 | and the path to the stylesheet afterwards:
 37 | 
 38 | 	require(['cassius/css!path/to/stylesheet.css'], function(){
 39 | 		// after after css is loaded
 40 | 	});
 41 | 
 42 | Note, that simply using the plugin loader will not load cassius, and trigger parsing of the stylesheet,
 43 | so you will not be able to use the extensions, unless you have specifically included
 44 | the cassius module as well.
 45 | 
 46 | This functionality is implemented and has been well tested.
 47 | 
 48 | # Building with AMD Plugin
 49 | 
 50 | When used as an AMD plugin, cassius can also integrate with a Dojo build, automatically
 51 | including CSS dependencies of modules in a build. To run utilize cassius in a Dojo build,
 52 | you need to include the cassius AMD build plugin. This can be specified in your build profile:
 53 | 
 54 | 	plugins: {
 55 | 		"cassius/css": "cassius/build/amd-css"
 56 | 	},
 57 | 
 58 | After that, you can simply run a build as normal, and the CSS dependencies will 
 59 | automatically be inlined in the built layer.
 60 | 
 61 | While inlining CSS text in a JavaScript built layer is the easiest approach, and can also
 62 | help reduce the number of requests, it is generally preferable to keep CSS in stylesheets,
 63 | and leverage browser's optimized patterns for loading stylesheets. This can be accomplished
 64 | as well with the integrated Dojo build. You simply need to specify a target stylesheet
 65 | in the layer definition in the build profile:
 66 | 
 67 | 	layers: [
 68 | 	{
 69 | 		name: "path/to/targetModule.js",
 70 | 		targetStylesheet: "my-package/css/main-stylesheet.css",
 71 | 		...
 72 | 
 73 | When the build runs, any CSS dependencies that are encountered in modules will then
 74 | be added to main-stylesheet.css (which will be created if it does not already exist), rather 
 75 | than inlined in the JavaScript build layer. One
 76 | can still use the #inline URL directive to inline resources in combination with the AMD
 77 | build plugin.
 78 |  
 79 | # Additional Modules
 80 | 
 81 | ## has-class
 82 | 
 83 | The has-class module provides decoration of the root &lt;html> element with class names
 84 | based on feature detection. The has-class module works in conjunction with the has()
 85 | module in Dojo (dojo/has) to detect features, and adds a class name for matches with
 86 | a "has-" prefix. For example, if we wanted to create a CSS rule that was conditional on the detection of
 87 | the "quirks" feature, first we would need to register this feature detection with the has-class module:
 88 | 
 89 | 	define(['cassius/has-class'], function(hasClass){
 90 | 		hasClass("quirks");
 91 | 	}); 
 92 | 
 93 | And then we could create a rule that uses this conditional class name:
 94 | 
 95 | 	html.has-quirks .row {
 96 | 		/* rule only applied if in quirks mode */
 97 | 		height: auto;
 98 | 	}
 99 | 
100 | We can also base rules on the absence of a feature. In converse, we could create
101 | a rule for when quirks mode is not present:
102 | 
103 | 	hasClass("no-quirks");
104 | 
105 | And then use this in the selector:
106 | 	
107 | 	html.has-no-quirks .row {
108 | 		/* rule only applied if in quirks mode */
109 | 		width: auto;
110 | 	}
111 | 
112 | We can also base rules on a numerical feature values. We could create a rule that
113 | just matches IE7 with:
114 | 
115 | 	hasClass("ie-7");
116 | 
117 | Or version IE8 through IE10:
118 | 
119 | 	hasClass("ie-8-10");
120 | 
121 | ## License
122 | cassius is freely available under *either* the terms of the modified BSD license *or* the
123 | Academic Free License version 2.1. More details can be found in the [LICENSE](LICENSE).
124 | The cassius project follows the IP guidelines of Dojo foundation packages and all contributions require a Dojo CLA. 
125 | If you feel compelled to make a monetary contribution, consider some of the author's [favorite
126 | charities](http://thezyps.com/2012-giving-guide/) like [Innovations for Poverty Action](http://www.poverty-action.org/) or
127 | the [UNFPA](http://www.friendsofunfpa.org/).
128 | 


--------------------------------------------------------------------------------
/load-imports.js:
--------------------------------------------------------------------------------
  1 | // summary:
  2 | //		This script scans for stylesheets and flattens imports in IE (to fix the deep import bug),
  3 | //		and provides loading of the text of any sheets. This is intended to only be loaded as needed
  4 | // 		for development, ideally stylesheets should be flattened and inlined for finished/production
  5 | // 		applications, and this module won't be loaded.  
  6 | define([], function(){
  7 | 	var insertedSheets = {},
  8 | 		features = {
  9 | 			// essentially test to see if it is IE, inaccurate marker, maybe should use dom-addeventlistener?
 10 | 			'dom-deep-import': !document.createStyleSheet 
 11 | 		};
 12 | 	function has (feature) {
 13 | 		return features[feature];
 14 | 	}
 15 | 	// load any plugin modules when done parsing
 16 | 	function load(link, callback){
 17 | 		var sheet = link.sheet || link.styleSheet;
 18 | 		
 19 | 		var loadingCount = 1;
 20 | 		
 21 | 		function finishedModule(){
 22 | 			if(!--loadingCount){
 23 | 				aggregateSource(sheet);
 24 | 				callback && callback(sheet);
 25 | 			}
 26 | 		}
 27 | 		function aggregateSource(sheet){
 28 | 			var source = '';
 29 | 			var importRules = !sheet.disabled && (sheet.imports || sheet.rules || sheet.cssRules);
 30 | 			
 31 | 			for(var i = 0; i < importRules.length; i++){										
 32 | 				var rule = importRules[i];
 33 | 				if(rule.href){
 34 | 					source += aggregateSource(rule.styleSheet || rule);
 35 | 				}
 36 | 			}
 37 | 			return (sheet.source = source + sheet.localSource);
 38 | 		}
 39 | 		if(false && !has('dom-deep-import')){
 40 | 			// in IE, so we flatten the imports due to IE's lack of support for deeply nested @imports
 41 | 			// and fix the computation of URLs (IE calculates them wrong)
 42 | 			var computeImportUrls = function(sheet, baseUrl){
 43 | 				var computedUrls = [];
 44 | 				// IE miscalculates .href properties, so we calculate them by parsing
 45 | 				sheet.cssText.replace(/@import url\( ([^ ]+) \)/g, function(t, url){
 46 | 						// we have to actually parse the cssText because IE's href property is totally wrong
 47 | 						computedUrls.push(absoluteUrl(baseUrl, url));
 48 | 					});
 49 | 				return computedUrls;
 50 | 			},
 51 | 			flattenImports = function(){
 52 | 				// IE doesn't support deeply nested @imports, so we flatten them.
 53 | 				//	IE needs imports rearranged and then to go through on a later turn.
 54 | 				// This function is a big pile of IE fixes
 55 | 				var flatteningOccurred, sheet = link.styleSheet;
 56 | 				if(sheet.processed){
 57 | 					return;
 58 | 				}
 59 | 				var sheetHref = sheet.correctHref = absoluteUrl(location.toString(), sheet.href);
 60 | 				if(!sheet.computedUrls){
 61 | 					// we have to do in a pre-loop or else IE's messes up on it's ownerRule's order
 62 | 					sheet.computedUrls = computeImportUrls(sheet, sheetHref);
 63 | 				}
 64 | 				for(var i = 0; i < sheet.imports.length; i++){
 65 | 					var importedSheet = sheet.imports[i];
 66 | 					if(!importedSheet.cssText &&
 67 | 							// empty means it is not loaded yet, try again later
 68 | 							!importedSheet.imports.length){
 69 | 						setTimeout(flattenImports, 50);
 70 | 						return;
 71 | 					}
 72 | 				//	importedSheet.loaded = true;
 73 | 					var correctHref = importedSheet.correctHref = sheet.computedUrls[i];
 74 | 					
 75 | 					var childHrefs = computeImportUrls(importedSheet, correctHref);
 76 | 					// Deep in an IE stylesheet
 77 | 					for(var j = 0; j < importedSheet.imports.length; j++){
 78 | 						// TODO: Think we can just stay in place and remove
 79 | 						var subImport = importedSheet.imports[j];
 80 | 						if(!subImport.correctHref){
 81 | 							flatteningOccurred = true;
 82 | 							link.onload = flattenImports;
 83 | 							var childHref = childHrefs[j] || importedSheet.href;
 84 | 							sheet.computedUrls.splice(i, 0, childHref);
 85 | 							try{
 86 | 								sheet.addImport(childHref, i++);
 87 | 							}catch(e){
 88 | 								// this will fail if there are too many imports
 89 | 							}
 90 | 							subImport.correctHref = childHref; 
 91 | 						}
 92 | 					}
 93 | 				}
 94 | 				if(flatteningOccurred){
 95 | 					setTimeout(flattenImports, 50);
 96 | 				}else{
 97 | 					sheet.processed = true;
 98 | 					loadOnce(sheet);
 99 | 				}
100 | 			};
101 | 			flattenImports();
102 | 			return finishedModule();
103 | 		}
104 | 		
105 | 		loadOnce(sheet);
106 | 		finishedModule();
107 | 		function loadOnce(sheet, baseUrl){
108 | 			// This function is responsible for implementing the @import once
109 | 			// semantics, such extra @imports that resolve to the same
110 | 			// CSS file are eliminated, and only the first one is kept
111 | 			
112 | 			var href = absoluteUrl(baseUrl, sheet.correctHref || sheet.href);
113 | 			// do normalization
114 | 			// TODO: remove this normalization, it is done in xstyle 
115 | 			if(!sheet.addRule){
116 | 				// only FF doesn't have this
117 | 				sheet.addRule = function(selector, style, index){
118 | 					return this.insertRule(selector + '{' + style + '}', index >= 0 ? index : this.cssRules.length);
119 | 				};
120 | 			}
121 | 			if(!sheet.deleteRule){
122 | 				sheet.deleteRule = sheet.removeRule;
123 | 			}
124 | 			var existingSheet = href && insertedSheets[href]; 
125 | 			if(existingSheet){
126 | 				var sheetToDelete;
127 | 				if(existingSheet != sheet){
128 | 					var parentStyleSheet = sheet.parentStyleSheet;
129 | 					var existingElement = existingSheet.ownerElement;
130 | 					if(existingElement.compareDocumentPosition ? 
131 | 							existingElement.compareDocumentPosition(link) != 2 :
132 | 							existingElement.sourceIndex <= link.sourceIndex){
133 | 						// this new sheet is after (or current), so we kill this one
134 | 						sheetToDelete = sheet;
135 | 					}else{
136 | 						// the other sheet is after, so delete it
137 | 						sheetToDelete = existingSheet;
138 | 						existingSheet = insertedSheets[href] = sheet;
139 | 					}
140 | 					// need to delegate to sheet that we are going to preserve
141 | 					// TODO: might need to use a queue to store changes and delegate changes that
142 | 					// have already taken place on the sheetToDelete
143 | 					sheetToDelete.addRule = function(c,s,i){
144 | 						existingSheet.addRule(c,s,i > -1 ? i : -1);
145 | 					};
146 | 					sheetToDelete.deleteRule = function(i){
147 | 						existingSheet.deleteRule(i);
148 | 					};
149 | 					var owner = sheetToDelete.ownerNode || !parentStyleSheet && sheetToDelete.owningElement;
150 | 					if(owner){
151 | 						// it is top level <link>, remove the node (disabling doesn't work properly in IE,
152 | 						// but node removal works everywhere)
153 | 						owner.parentNode.removeChild(owner); 
154 | 					}else{
155 | 						// disabling is the only way to remove an imported stylesheet in firefox; it doesn't
156 | 						// work in IE and WebKit
157 | 						sheetToDelete.disabled = true; // this works in Opera
158 | 						if('cssText' in sheetToDelete){
159 | 							sheetToDelete.cssText =''; // this works in IE
160 | 						}else{
161 | 							// removing the rule is only way to remove an imported stylesheet in WebKit
162 | 							owner = sheetToDelete.ownerRule;
163 | 							if(owner){
164 | 								try{
165 | 									parentStyleSheet = owner.parentStyleSheet;
166 | 									var parentRules = parentStyleSheet.cssRules;
167 | 									for(var i = 0; i < parentRules.length; i++){
168 | 										// find the index of the owner rule that we want to delete
169 | 										if(parentRules[i] == owner){
170 | 											parentStyleSheet.deleteRule(i);
171 | 											break;
172 | 										}
173 | 									}
174 | 									return true;
175 | 								}catch(e){
176 | 									// opera fails on deleteRule for imports, but the disabled works, so we can continue
177 | 									console.log(e);
178 | 								}
179 | 							}
180 | 						}
181 | 					}
182 | 				}
183 | 			}
184 | 			if(sheetToDelete != sheet){
185 | 				if(href){
186 | 					if(/no-xstyle$/.test(href)){
187 | 						sheet.localSource = '';
188 | 						return;
189 | 					}else{
190 | 						// record the stylesheet in our hash
191 | 						insertedSheets[href] = sheet;
192 | 						sheet.ownerElement = link;
193 | 						var sourceSheet = sheet;
194 | 						loadingCount++;
195 | 						fetchText(href, function(text){
196 | 							sourceSheet.localSource = text;
197 | 							finishedModule();
198 | 						}, function(){
199 | 							sourceSheet.localSource = '';
200 | 							finishedModule();
201 | 						});
202 | 					}
203 | 				}else{
204 | 					sheet.localSource = link.innerHTML;
205 | 				}
206 | 				var cssRules = sheet.rules || sheet.cssRules || [];
207 | 				for(var i = 0; i < cssRules.length; i++){
208 | 					var rule = cssRules[i];
209 | 					if(rule.selectorText && rule.selectorText.substring(0,2) == 'x-'){
210 | 						sheet.needsParsing = true;
211 | 					}
212 | 				}
213 | 				
214 | 				// now recurse into @import's to check to make sure each of those is only loaded once 
215 | 				var importRules = sheet.imports || cssRules;
216 | 				
217 | 				for(var i = 0; i < importRules.length; i++){										
218 | 					var rule = importRules[i];
219 | 					if(rule.href){
220 | 						// it's an import (for non-IE browsers we are looking at all rules,
221 | 						// and need to exclude non-import rules
222 | 						var childSheet = rule.styleSheet || rule;
223 | 						if(loadOnce(childSheet, href)){
224 | 							i--; // deleted, so go back in index
225 | 						}
226 | 						if(childSheet.needsParsing){
227 | 							sheet.needsParsing = true;
228 | 						}
229 | 					}
230 | 				}
231 | 			}
232 | 			// sheetToDelete = null; // Don't entrap IE memory
233 | 		}
234 | 	}
235 | 	function absoluteUrl(base, url) {
236 | 		if(!url || url.indexOf(':') > 0 || url.charAt(0) == '/'){
237 | 			return url;
238 | 		}
239 | 		// in IE we do this trick to get the absolute URL
240 | 		var lastUrl;
241 | 		url = ((base || location.toString()).replace(/[^\/]*$/,'') + url).replace(/\/\.\//g,'/');
242 | 		while(lastUrl != url){
243 | 			lastUrl = url;
244 | 			url = url.replace(/\/[^\/]+\/\.\.\//g, '/');
245 | 		}
246 | 		return url;
247 | 	}
248 | 	return load;
249 | 	/***** xhr *****/
250 | 
251 | 	var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
252 | 
253 | 	function xhr () {
254 | 		if (typeof XMLHttpRequest !== 'undefined') {
255 | 			// rewrite the getXhr method to always return the native implementation
256 | 			xhr = function () { return new XMLHttpRequest(); };
257 | 		}
258 | 		else {
259 | 			// keep trying progIds until we find the correct one, then rewrite the getXhr method
260 | 			// to always return that one.
261 | 			var noXhr = xhr = function () {
262 | 					throw new Error('getXhr(): XMLHttpRequest not available');
263 | 				};
264 | 			while (progIds.length > 0 && xhr === noXhr) (function (id) {
265 | 				try {
266 | 					new ActiveXObject(id);
267 | 					xhr = function () { return new ActiveXObject(id); };
268 | 				}
269 | 				catch (ex) {}
270 | 			}(progIds.shift()));
271 | 		}
272 | 		return xhr();
273 | 	}
274 | 
275 | 	function fetchText (url, callback, errback) {
276 | 		var x = xhr();
277 | 		x.open('GET', url, true);
278 | 		x.onreadystatechange = function(){
279 | 			if (x.readyState === 4) {
280 | 				if (x.status < 400) {
281 | 					callback(x.responseText);
282 | 				}
283 | 				else {
284 | 					errback(new Error('fetchText() failed. status: ' + x.statusText));
285 | 				}
286 | 			}
287 | 		};
288 | 		x.send(null);
289 | 	}
290 | 	
291 | });
292 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | cassius is available under *either* the terms of the modified BSD license *or* the
  2 | Academic Free License version 2.1. As a recipient of cassius, you may choose which
  3 | license to receive this code under.
  4 | 
  5 | The text of the AFL and BSD licenses is reproduced below. 
  6 | 
  7 | -------------------------------------------------------------------------------
  8 | The "New" BSD License:
  9 | **********************
 10 | 
 11 | Copyright (c) 2010-2011, The Dojo Foundation
 12 | All rights reserved.
 13 | 
 14 | Redistribution and use in source and binary forms, with or without
 15 | modification, are permitted provided that the following conditions are met:
 16 | 
 17 |   * Redistributions of source code must retain the above copyright notice, this
 18 |     list of conditions and the following disclaimer.
 19 |   * Redistributions in binary form must reproduce the above copyright notice,
 20 |     this list of conditions and the following disclaimer in the documentation
 21 |     and/or other materials provided with the distribution.
 22 |   * Neither the name of the Dojo Foundation nor the names of its contributors
 23 |     may be used to endorse or promote products derived from this software
 24 |     without specific prior written permission.
 25 | 
 26 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 27 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 28 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 29 | DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 30 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 31 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 32 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 33 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 34 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 35 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 36 | 
 37 | -------------------------------------------------------------------------------
 38 | The Academic Free License, v. 2.1:
 39 | **********************************
 40 | 
 41 | This Academic Free License (the "License") applies to any original work of
 42 | authorship (the "Original Work") whose owner (the "Licensor") has placed the
 43 | following notice immediately following the copyright notice for the Original
 44 | Work:
 45 | 
 46 | Licensed under the Academic Free License version 2.1
 47 | 
 48 | 1) Grant of Copyright License. Licensor hereby grants You a world-wide,
 49 | royalty-free, non-exclusive, perpetual, sublicenseable license to do the
 50 | following:
 51 | 
 52 | a) to reproduce the Original Work in copies;
 53 | 
 54 | b) to prepare derivative works ("Derivative Works") based upon the Original
 55 | Work;
 56 | 
 57 | c) to distribute copies of the Original Work and Derivative Works to the
 58 | public;
 59 | 
 60 | d) to perform the Original Work publicly; and
 61 | 
 62 | e) to display the Original Work publicly.
 63 | 
 64 | 2) Grant of Patent License. Licensor hereby grants You a world-wide,
 65 | royalty-free, non-exclusive, perpetual, sublicenseable license, under patent
 66 | claims owned or controlled by the Licensor that are embodied in the Original
 67 | Work as furnished by the Licensor, to make, use, sell and offer for sale the
 68 | Original Work and Derivative Works.
 69 | 
 70 | 3) Grant of Source Code License. The term "Source Code" means the preferred
 71 | form of the Original Work for making modifications to it and all available
 72 | documentation describing how to modify the Original Work. Licensor hereby
 73 | agrees to provide a machine-readable copy of the Source Code of the Original
 74 | Work along with each copy of the Original Work that Licensor distributes.
 75 | Licensor reserves the right to satisfy this obligation by placing a
 76 | machine-readable copy of the Source Code in an information repository
 77 | reasonably calculated to permit inexpensive and convenient access by You for as
 78 | long as Licensor continues to distribute the Original Work, and by publishing
 79 | the address of that information repository in a notice immediately following
 80 | the copyright notice that applies to the Original Work.
 81 | 
 82 | 4) Exclusions From License Grant. Neither the names of Licensor, nor the names
 83 | of any contributors to the Original Work, nor any of their trademarks or
 84 | service marks, may be used to endorse or promote products derived from this
 85 | Original Work without express prior written permission of the Licensor. Nothing
 86 | in this License shall be deemed to grant any rights to trademarks, copyrights,
 87 | patents, trade secrets or any other intellectual property of Licensor except as
 88 | expressly stated herein. No patent license is granted to make, use, sell or
 89 | offer to sell embodiments of any patent claims other than the licensed claims
 90 | defined in Section 2. No right is granted to the trademarks of Licensor even if
 91 | such marks are included in the Original Work. Nothing in this License shall be
 92 | interpreted to prohibit Licensor from licensing under different terms from this
 93 | License any Original Work that Licensor otherwise would have a right to
 94 | license.
 95 | 
 96 | 5) This section intentionally omitted.
 97 | 
 98 | 6) Attribution Rights. You must retain, in the Source Code of any Derivative
 99 | Works that You create, all copyright, patent or trademark notices from the
100 | Source Code of the Original Work, as well as any notices of licensing and any
101 | descriptive text identified therein as an "Attribution Notice." You must cause
102 | the Source Code for any Derivative Works that You create to carry a prominent
103 | Attribution Notice reasonably calculated to inform recipients that You have
104 | modified the Original Work.
105 | 
106 | 7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
107 | the copyright in and to the Original Work and the patent rights granted herein
108 | by Licensor are owned by the Licensor or are sublicensed to You under the terms
109 | of this License with the permission of the contributor(s) of those copyrights
110 | and patent rights. Except as expressly stated in the immediately proceeding
111 | sentence, the Original Work is provided under this License on an "AS IS" BASIS
112 | and WITHOUT WARRANTY, either express or implied, including, without limitation,
113 | the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
114 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
115 | This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
116 | license to Original Work is granted hereunder except under this disclaimer.
117 | 
118 | 8) Limitation of Liability. Under no circumstances and under no legal theory,
119 | whether in tort (including negligence), contract, or otherwise, shall the
120 | Licensor be liable to any person for any direct, indirect, special, incidental,
121 | or consequential damages of any character arising as a result of this License
122 | or the use of the Original Work including, without limitation, damages for loss
123 | of goodwill, work stoppage, computer failure or malfunction, or any and all
124 | other commercial damages or losses. This limitation of liability shall not
125 | apply to liability for death or personal injury resulting from Licensor's
126 | negligence to the extent applicable law prohibits such limitation. Some
127 | jurisdictions do not allow the exclusion or limitation of incidental or
128 | consequential damages, so this exclusion and limitation may not apply to You.
129 | 
130 | 9) Acceptance and Termination. If You distribute copies of the Original Work or
131 | a Derivative Work, You must make a reasonable effort under the circumstances to
132 | obtain the express assent of recipients to the terms of this License. Nothing
133 | else but this License (or another written agreement between Licensor and You)
134 | grants You permission to create Derivative Works based upon the Original Work
135 | or to exercise any of the rights granted in Section 1 herein, and any attempt
136 | to do so except under the terms of this License (or another written agreement
137 | between Licensor and You) is expressly prohibited by U.S. copyright law, the
138 | equivalent laws of other countries, and by international treaty. Therefore, by
139 | exercising any of the rights granted to You in Section 1 herein, You indicate
140 | Your acceptance of this License and all of its terms and conditions.
141 | 
142 | 10) Termination for Patent Action. This License shall terminate automatically
143 | and You may no longer exercise any of the rights granted to You by this License
144 | as of the date You commence an action, including a cross-claim or counterclaim,
145 | against Licensor or any licensee alleging that the Original Work infringes a
146 | patent. This termination provision shall not apply for an action alleging
147 | patent infringement by combinations of the Original Work with other software or
148 | hardware.
149 | 
150 | 11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
151 | License may be brought only in the courts of a jurisdiction wherein the
152 | Licensor resides or in which Licensor conducts its primary business, and under
153 | the laws of that jurisdiction excluding its conflict-of-law provisions. The
154 | application of the United Nations Convention on Contracts for the International
155 | Sale of Goods is expressly excluded. Any use of the Original Work outside the
156 | scope of this License or after its termination shall be subject to the
157 | requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et
158 | seq., the equivalent laws of other countries, and international treaty. This
159 | section shall survive the termination of this License.
160 | 
161 | 12) Attorneys Fees. In any action to enforce the terms of this License or
162 | seeking damages relating thereto, the prevailing party shall be entitled to
163 | recover its costs and expenses, including, without limitation, reasonable
164 | attorneys' fees and costs incurred in connection with such action, including
165 | any appeal of such action. This section shall survive the termination of this
166 | License.
167 | 
168 | 13) Miscellaneous. This License represents the complete agreement concerning
169 | the subject matter hereof. If any provision of this License is held to be
170 | unenforceable, such provision shall be reformed only to the extent necessary to
171 | make it enforceable.
172 | 
173 | 14) Definition of "You" in This License. "You" throughout this License, whether
174 | in upper or lower case, means an individual or a legal entity exercising rights
175 | under, and complying with all of the terms of, this License. For legal
176 | entities, "You" includes any entity that controls, is controlled by, or is
177 | under common control with you. For purposes of this definition, "control" means
178 | (i) the power, direct or indirect, to cause the direction or management of such
179 | entity, whether by contract or otherwise, or (ii) ownership of fifty percent
180 | (50%) or more of the outstanding shares, or (iii) beneficial ownership of such
181 | entity.
182 | 
183 | 15) Right to Use. You may use the Original Work in all ways not otherwise
184 | restricted or conditioned by this License or by law, and Licensor promises not
185 | to interfere with or be responsible for such uses by You.
186 | 
187 | This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
188 | Permission is hereby granted to copy and distribute this license without
189 | modification. This license may not be modified without the express written
190 | permission of its copyright owner.
191 | 


--------------------------------------------------------------------------------
/parser.js:
--------------------------------------------------------------------------------
  1 | define([], function(){
  2 | 	// regular expressions used to parse CSS
  3 | 	var singleQuoteScan = /((?:\\.|[^'])*)'/g;
  4 | 	var doubleQuoteScan = /((?:\\.|[^"])*)"/g;
  5 | 	// preserve carriage returns to retain line numbering once we do line based error reporting 
  6 | 	var commentScan = /\/\*[\w\W]*?\*\//g;
  7 | 	var operatorMatch = {
  8 | 		'{': '}',
  9 | 		'[': ']',
 10 | 		'(': ')'
 11 | 	};
 12 | 	var nextId = 0;
 13 | 	var trim = ''.trim ? function (str){
 14 | 		return str.trim();
 15 | 	} : function(str){
 16 | 		return str.replace(/^\s+|\s+$/g, '');
 17 | 	};
 18 | 	
 19 | 	function Sequence(){
 20 | 		this.push.apply(this, arguments);
 21 | 	}
 22 | 	var SequencePrototype = Sequence.prototype = [];
 23 | 	SequencePrototype.toString = function(){
 24 | 		return this.join('');
 25 | 	};
 26 | 	SequencePrototype.isSequence = true;
 27 | 	function LiteralString(string){
 28 | 		this.value = string;
 29 | 	}
 30 | 	LiteralString.prototype.toString = function(){
 31 | 		return '"' + this.value.replace(/["\\\n\r]/g, '\\$&') + '"';
 32 | 	};
 33 | 	LiteralString.prototype.isLiteralString = true;
 34 | 
 35 | 	function parseArgs(){
 36 | 		var parsedArgs, sequence = this.args[0];
 37 | 		// parse the commas now, to separate into distint args
 38 | 		if(typeof sequence == 'string'){
 39 | 			// TODO: does this ever happen
 40 | 			// simple string split
 41 | 			parsedArgs = sequence.split(/\s*,\s*/);
 42 | 		}else if(sequence){
 43 | 			// need to go through the sequence to find comma splits
 44 | 			parsedArgs = [];
 45 | 			var lastPosition = 0;
 46 | 			for(var i = 0; i < sequence.length + 1; i++){ // go one past, so we can do cleanup
 47 | 				var arg = sequence[i];
 48 | 				if(typeof arg == 'string' || arg === undefined){
 49 | 					var parts = arg && arg.split(/\s*,\s*/);
 50 | 					if(parsedArgs.length > 1 || parts === undefined){
 51 | 						var nextSequence = sequence.slice(lastPosition, i);
 52 | 						if(lastPosition > 0){
 53 | 							nextSequence.unshift(parsedArgs.pop());
 54 | 						}
 55 | 						lastPosition = i + 1;
 56 | 						parsedArgs.push(nextSequence);
 57 | 						parts && parsedArgs.push.apply(parsedArgs, parts.slice(1));
 58 | 					}
 59 | 				}
 60 | 			}
 61 | 		}else{
 62 | 			return [];
 63 | 		}
 64 | 		return parsedArgs;
 65 | 	}
 66 | 	
 67 | 	function parse(model, textToParse, styleSheet){
 68 | 		styleSheet = styleSheet || {addRule: function(){}, cssRules: []};
 69 | 		var mainScan;
 70 | 		var cssScan = mainScan = /(\s*)((?:[^{\}\[\]\(\)\\'":=;]|\[(?:[^\]'"]|'(?:\\.|[^'])*'|"(?:\\.|[^"])*")\])*)([=:]\??\s*([^{\}\[\]\(\)\\'":;]*))?(?:([{\}\[\]\(\)\\'":;])(\/\d+)?|$)/g;
 71 | 		                   // whitespace          name          or attribute or  'string'    or  "string"          assignmentOperator  value                operator           build ref
 72 | 		// tracks the stack of rules as they get nested
 73 | 		var stack = [model];
 74 | 		model.parse = parseSheet;
 75 | 		parseSheet(textToParse, styleSheet);
 76 | 		function parseSheet(textToParse, styleSheet){
 77 | 			// parse the CSS, finding each rule
 78 | 			textToParse = textToParse.replace(commentScan, function(comment){
 79 | 				// keep the line returns for proper line attribution in errors
 80 | 				return comment.replace(/[^\n]/g, '');
 81 | 			});
 82 | 			function resumeOnComplete(promise){
 83 | 				continuing = false;
 84 | 				var lastIndex = cssScan.lastIndex;
 85 | 				promise.then(function(){
 86 | 					continuing = true;
 87 | 					if(nextTurn){
 88 | 						cssScan.lastIndex = lastIndex;
 89 | 						resume();
 90 | 					}
 91 | 				});
 92 | 				var nextTurn = true;
 93 | 			}
 94 | 			var target = model; // start at root
 95 | 			cssScan.lastIndex = 0; // start at zero
 96 | 			var continuing;
 97 | 			var ruleIndex = 0, browserUnderstoodRule = true, selector = '', assignNextName = true;
 98 | 			resume();
 99 | 			function resume(){
100 | 				function addInSequence(operand){
101 | 					if(operand && typeof operand == 'string' && whitespace){
102 | 						operand = whitespace + operand;
103 | 					}
104 | 					if(sequence){
105 | 						// we had a string so we are accumulated sequences now
106 | 						sequence.push ?
107 | 							typeof sequence[sequence.length - 1] == 'string' && typeof operand == 'string' ?
108 | 								sequence[sequence.length - 1] += operand : // just append the string to last segment
109 | 								operand && sequence.push(operand) : // add to the sequence
110 | 							typeof sequence == 'string' && typeof operand == 'string' ?
111 | 								sequence += operand : // keep appending to the string
112 | 								sequence = new Sequence(sequence, operand); // start a new sequence array
113 | 					}else{
114 | 						sequence = operand;
115 | 					}
116 | 				}
117 | 				continuing = true;
118 | 				while(continuing){
119 | 					// parse the next block in the CSS
120 | 					// we could perhaps use a simplified regex when we are in a property value 
121 | 					var match = cssScan.exec(textToParse);
122 | 					// the next block is parsed into several parts that comprise some operands and an operator
123 | 					if(!match){
124 | 						// done
125 | 						return;
126 | 					}
127 | 					var operator = match[5],
128 | 						whitespace = match[1],
129 | 						first = match[2],
130 | 						assignment = match[3],
131 | 						value = match[4],
132 | 						assignmentOperator, name, sequence,
133 | 						conditionalAssignment;
134 | 					value = value && trim(value);
135 | 					
136 | 					first = first && trim(first);
137 | 					if(assignNextName){
138 | 						// we are at the beginning of a new property
139 | 						if(assignment){
140 | 							// remember the name, so can assign to it
141 | 							name = first;
142 | 							//	selector = match[1] + assignment;
143 | 							// remember the operator (could be ':' for a property assignment or 
144 | 							// '=' for a property declaration)
145 | 							assignmentOperator = assignment.charAt(0);
146 | 							conditionalAssignment = assignment.charAt(1) == '?';
147 | 							if(assignment.indexOf('\n') > -1){
148 | 								// need to preserve whitespace if there is a return
149 | 								value = assignment.slice(1);
150 | 							}
151 | 						}else{
152 | 							value = first;
153 | 						}
154 | 						// store in the sequence, the sequence can contain values from multiple rounds of parsing
155 | 						sequence = value;
156 | 						// we have the assigned property name now, and don't need to assign again
157 | 						assignNextName = false;
158 | 					}else{
159 | 						// subsequent part of a property
160 | 						value = assignment ? first + assignment : first;
161 | 						// add to the current sequence
162 | 						addInSequence(value);
163 | 					}
164 | 					if(operator != '{'){
165 | 						selector += match[0];
166 | 					}
167 | 					switch(operator){
168 | 						case "'":
169 | 						case '"':
170 | 							// encountered a quoted string, parse through to the end of the string and
171 | 							// add to the current sequence
172 | 							var quoteScan = operator == "'" ? singleQuoteScan : doubleQuoteScan;
173 | 							quoteScan.lastIndex = cssScan.lastIndex; // find our current location in the parsing
174 | 							var parsed = quoteScan.exec(textToParse);
175 | 							if(!parsed){ // no match for the end of the string
176 | 								error('unterminated string');
177 | 							}
178 | 							// get the real contents of the string, parsing any backslashes
179 | 							var str = parsed[1].replace(/\\([a-fA-F\d]{0,5}[ a-fA-F\d]?)/g, function(full, unicode){
180 | 								if(unicode){
181 | 									return String.fromCharCode(parseInt(unicode, 16));
182 | 								}
183 | 							});
184 | 							// move the css parser up to the end of the string position
185 | 							cssScan.lastIndex = quoteScan.lastIndex;
186 | 							// push the string on the current value and keep parsing
187 | 							addInSequence(new LiteralString(str));
188 | 							selector += parsed[0];
189 | 							continue;
190 | 						case '\\':
191 | 							// escaping
192 | 							var lastIndex = quoteScan.lastIndex++;
193 | 							// add the escaped character to the sequence
194 | 							addInSequence(textToParse.charAt(lastIndex));
195 | 							continue;
196 | 						case '(':
197 | 						case '{':
198 | 						case '[':
199 | 							// encountered a new contents of a rule or a function call
200 | 							var newTarget;
201 | 							if(operator == '{'){
202 | 								// it's a rule
203 | 								assignNextName = true; // enter into the beginning of property mode
204 | 								// normalize the selector
205 | 								if(assignmentOperator == ':' && assignment){
206 | 									first += assignment;
207 | 								}
208 | 								selector = trim((selector + first).replace(/\s+/g, ' '));
209 | 								// check to see if it is a correlator rule, from the build process
210 | 								// add this new rule to the current parent rule
211 | 								addInSequence(newTarget = target.newRule(selector));
212 | 								
213 | 								// todo: check the type
214 | 								if(assignmentOperator == '='){
215 | 									browserUnderstoodRule = false;
216 | 									sequence.creating = true;
217 | 								}
218 | 								var cssRules, nextRule = null;
219 | 								var lastRuleIndex = ruleIndex;
220 | 								if(match[6]){
221 | 									// when we are using built stylesheets, we make numeric references
222 | 									// to the rules, by index
223 | 									cssRules = styleSheet.cssRules || styleSheet.rules;
224 | 									if((newTarget.cssRule = nextRule = cssRules[match[6].slice(1)])){
225 | 										selector = nextRule.selectorText;
226 | 									}
227 | 								}
228 | 								if(target.root && browserUnderstoodRule){
229 | 									// we track the native CSSOM rule that we are attached to so we can add
230 | 									// properties to the correct rule
231 | 									cssRules = styleSheet.cssRules || styleSheet.rules;
232 | 									while((nextRule = cssRules[ruleIndex++])){
233 | 										if((nextRule.selectorText == selector) ||
234 | 											// CSS3 pseudo-elements can be auto-converted from CSS2 psuedo by browsers
235 | 												(nextRule.selectorText &&
236 | 													nextRule.selectorText.replace(/::/g, ':').replace(/'/g, '"') ==
237 | 														selector.replace(/::/g, ':').replace(/'/g, '"'))){
238 | 											// found it
239 | 											newTarget.cssRule = nextRule;
240 | 											break;
241 | 										}
242 | 									}
243 | 								}
244 | 								if(!nextRule){
245 | 									// didn't find it
246 | 									newTarget.ruleIndex = ruleIndex = lastRuleIndex;
247 | 								}
248 | 								// TODO: this doesn't need to be done when there is a rule, except for old IE,
249 | 								// as most browsers, the style sheet can be retrieved the cssRule
250 | 								if(sequence.creating){
251 | 									// in generation, we auto-generate selectors so we can reference them
252 | 									newTarget.selector = '.' + (assignmentOperator == '=' ?
253 | 											first.match(/[\w-]*$/g,'')[0] : '') + '-x-' + nextId++;
254 | 									newTarget.creating = true;
255 | 								}else{
256 | 									if(/^@(?!font-face)(?!FONT-FACE)/.test(selector)){
257 | 										newTarget.setMediaSelector(selector);
258 | 									}else{
259 | 										newTarget.selector = target.root ? selector : target.selector + ' ' + selector;
260 | 									}
261 | 								}
262 | 								selector = '';
263 | 							}else{
264 | 								// it's a call, add it in the current sequence
265 | 								var callParts = value.match(/(.*?)([\w-]*)$/);
266 | 								addInSequence(newTarget = target.newCall(callParts[2], sequence, target));
267 | 								newTarget.ref = target.getDefinition(callParts[2]);
268 | 								newTarget.getArgs = parseArgs;
269 | 								(sequence.calls || (sequence.calls = [])).push(newTarget);
270 | 								doExtend = true;
271 | 								newTarget.selector = '.' + (assignmentOperator == '=' ?
272 | 										first.match(/[\w-]*$/g,'')[0] : '') + '-x-' + nextId++;
273 | 							}
274 | 							
275 | 							// store the current state information so we can restore it when exiting this rule or call
276 | 							target.currentName = name;
277 | 							target.currentSequence = sequence;
278 | 							target.assignmentOperator = assignmentOperator;
279 | 							var selectorTrigger;
280 | 							// if it has a pseudo or directive, call the handler
281 | 							if(operator == '{' && (selectorTrigger = newTarget.selector.match(/[@:]\w+/))){
282 | 								// TODO: use when()
283 | 								selectorTrigger = selectorTrigger[0];
284 | 								var selectorHandler = target.getDefinition(selectorTrigger);
285 | 								if(selectorHandler && selectorHandler.selector){
286 | 									selectorHandler.selector(newTarget);
287 | 								}
288 | 							}
289 | 	
290 | 							// add to the stack
291 | 							stack.push(target = newTarget);
292 | 							target.operator = operator;
293 | 							target.start = cssScan.lastIndex;
294 | 							name = null;
295 | 							sequence = null;
296 | 							continue;
297 | 					}
298 | 					if(sequence){
299 | 						// now see if we need to process an assignment or directive
300 | 						var first = typeof sequence == 'string' ? sequence : sequence[0];
301 | 						if(first.charAt && first.charAt(0) == '@'){
302 | 							// it's a directive
303 | 							var directive = first.match(/\w+/)[0];
304 | 							if(directive == 'import'){
305 | 								// get the stylesheet
306 | 								var importedSheet = parse.getStyleSheet((styleSheet.cssRules ||
307 | 									styleSheet.imports)[ruleIndex++], sequence, styleSheet);
308 | 								// preserve the current index, as we are using a single regex to be shared
309 | 								// by all parsing executions
310 | 								var currentIndex = cssScan.lastIndex;
311 | 								// parse the imported stylesheet
312 | 								parseSheet(importedSheet.localSource, importedSheet);
313 | 								// now restore our state
314 | 								cssScan.lastIndex = currentIndex;
315 | 							}else if(directive == 'xstyle'){
316 | 								if(first.slice(8,13) == 'start'){
317 | 									// start a new nested rule for the new scope
318 | 									var newTarget = target ? target.newRule('') : lastRootTarget;
319 | 									newTarget.root = target.root;
320 | 									stack.push(target = newTarget);
321 | 								}else{
322 | 									// end of scope, store the scope, and pop it
323 | 									var lastRootTarget = target || lastRootTarget;
324 | 									stack.pop();
325 | 									target = stack[stack.length - 1];
326 | 								}
327 | 								cssScan = target ? mainScan : /(@[\w\s])/g;
328 | 							}
329 | 							// TODO: implement this
330 | 							// else if(directive == 'supports'){
331 | 						}else if(assignmentOperator === '='){
332 | 							// need to do an assignment
333 | 							try{
334 | 								var result = target.declareDefinition(name, sequence, conditionalAssignment);
335 | 								if(result && result.then){
336 | 									resumeOnComplete(result);
337 | 								}
338 | 							}catch(e){
339 | 								error(e);
340 | 							}
341 | 						}
342 | 					}
343 | 					switch(operator){
344 | 						case ':':
345 | 							// assignment can happen after a property declaration
346 | 							if(assignmentOperator == '='){
347 | 								assignNextName = true;
348 | 								assignmentOperator = ':';
349 | 							}else{
350 | 								// a double pseudo
351 | 								addInSequence(':');
352 | 							}
353 | 							break;
354 | 						case '}':
355 | 							if(name && !(target.root || target.isMediaBlock)){
356 | 								// CSS ASI at the end of the inside of a rule
357 | 								try{
358 | 									target[assignmentOperator == ':' ? 'setValue' : 'declareDefinition']
359 | 										(name, sequence, conditionalAssignment);
360 | 								}catch(e){
361 | 									error(e);
362 | 								}
363 | 							}
364 | 							// fall through
365 | 						case ')':
366 | 						case ']':
367 | 							// end of a rule or function call
368 | 							// clear the name now
369 | 							if(operatorMatch[target.operator] != operator){
370 | 								error('Incorrect opening operator ' + target.operator +
371 | 									' with closing operator ' + operator);
372 | 							}
373 | 							name = null;
374 | 							// record the cssText
375 | 							var ruleCssText = textToParse.slice(target.start, cssScan.lastIndex - 1);
376 | 							target.cssText = target.cssText ?
377 | 								target.cssText + ';' + ruleCssText : ruleCssText;
378 | 								
379 | 							if(operator == '}'){
380 | 								if(lastOperator == '}'){
381 | 									var parentSelector = target.parent.selector;
382 | 									if(parentSelector && !parentSelector.charAt(0) == '@'){
383 | 										// we throw an error for this because it so catastrophically
384 | 										// messes up the browser's CSS parsing, not because we can't handle it fine
385 | 										error('A nested rule must end with a semicolon');
386 | 									}
387 | 								}
388 | 								if(target.root){
389 | 									error('Unmatched ' + operator);
390 | 								}else{
391 | 									// if it is rule, call the rule handler
392 | 									try{
393 | 										target.onRule(target.selector, target);
394 | 									}catch(e){
395 | 										error(e);
396 | 									}
397 | 									
398 | 									browserUnderstoodRule = true;
399 | 								}
400 | 								selector = '';
401 | 							}
402 | 							// now pop the call or rule off the stack and restore the state
403 | 							if(operator == ')' || operator == ']'){
404 | 								target.args = [sequence];
405 | 							}
406 | 							if(operator == ')' && !assignmentOperator){
407 | 								// call handler
408 | 								// immediately call this, since it isn't a part of a property
409 | 								try{
410 | 									var result = stack[stack.length - 2].onArguments(target);
411 | 								}catch(e){
412 | 									error(e);
413 | 								}
414 | 								if(result && result.then){
415 | 									resumeOnComplete(result);
416 | 								}
417 | 							}
418 | 							stack.pop();
419 | 							target = stack[stack.length - 1];
420 | 							sequence = target.currentSequence;
421 | 							name = target.currentName;
422 | 							assignmentOperator = target.assignmentOperator;
423 | 							if(target.root && operator == '}'){
424 | 								// CSS ASI between rules at the top level
425 | 								if(assignmentOperator){
426 | 									// may still need to do an assignment
427 | 									try{
428 | 										target[assignmentOperator == ':' ? 'setValue' : 'declareDefinition']
429 | 											(name, sequence, conditionalAssignment);
430 | 									}catch(e){
431 | 										error(e);
432 | 									}
433 | 								}
434 | 								assignNextName = true;
435 | 								assignmentOperator = false;
436 | 							}
437 | 							break;
438 | 						case '':
439 | 						case undefined:
440 | 							// no operator means we have reached the end of the text to parse
441 | 							return;
442 | 						case ';':
443 | 							// end of a property, end the sequence return to the beginning of propery mode
444 | 							// need to do an assignment
445 | 							if(target && name){
446 | 								try{
447 | 									var result = target[assignmentOperator == ':' ? 'setValue' : 'declareDefinition']
448 | 										(name, sequence, conditionalAssignment);
449 | 									if(result && result.then){
450 | 										resumeOnComplete(result);
451 | 									}
452 | 								}catch(e){
453 | 									error(e);
454 | 								} name
455 | 							}
456 | 							sequence = null;
457 | 							assignNextName = true;
458 | 							browserUnderstoodRule = false;
459 | 							assignmentOperator = false;
460 | 							selector = '';
461 | 					}
462 | 					var lastOperator = operator;
463 | 				}
464 | 			}
465 | 			function error(e){
466 | 				var lines = textToParse.slice(0, cssScan.lastIndex).split('\n');
467 | 				var lastLine = lines[lines.length - 1];
468 | 				// provide line and column details
469 | 				var detail = (styleSheet.href || 'in-page stylesheet') + ':' +
470 | 					lines.length + ':' + lastLine.length + ' near:\n' + lastLine.slice(-40);
471 | 				if(parseSheet.onerror){
472 | 					parseSheet.onerror(e, detail);
473 | 				}
474 | 				console.error(e.message || e, detail);
475 | 				if(e.stack){
476 | 					console.error(e.stack);
477 | 				}
478 | 			}
479 | 		}
480 | 	}
481 | 	return parse;
482 | });


--------------------------------------------------------------------------------