envjs 0.1.7 → 0.2.0

data/src/cruft/element.js

@@ -0,0 +1,297 @@
+/*
+* HTMLElement - DOM Level 2
+*/
+$w.__defineGetter__("HTMLElement", function(){
+  return function(){
+    throw new Error("Object cannot be created in this context");
+  };
+});
+
+var Element = function(node){
+  var $dom = node, 
+      $id = createGUID();
+      
+$w.__defineGetter__("Element", function(){
+	var $dom, $id;
+	return function(elem){
+	  $dom = elem;
+	  $id = createGUID();
+	  __extend__(this, new DOMNode($dom));
+		
+		// A lot of the methods defined below belong in HTML specific
+		// subclasses.  This is already unwieldy since most of these
+		//methods are meant for general xml consumption
+		__extend__(this, {
+  		get nodeName(){
+  			return this.tagName;
+  		},
+  		get tagName(){
+  			return $dom.getTagName().toUpperCase();
+  		},
+  		toString: function(){
+  			return "<" + this.tagName + (this.id ? "#" + this.id : "" ) + ">";
+  		},
+  		get outerHTML(){
+  			var ret = "<" + this.tagName, attr = this.attributes;
+  			
+  			for ( var i in attr )
+  				ret += " " + i + "='" + attr[i] + "'";
+  				
+  			if ( this.childNodes.length || this.nodeName == "SCRIPT" )
+  				ret += ">" + this.childNodes.outerHTML + 
+  					"</" + this.tagName + ">";
+  			else
+  				ret += "/>";
+  			
+  			return ret;
+  		},
+  		
+  		get attributes(){
+  			var attr = {}, attrs = $dom.getAttributes();
+  			for ( var i = 0; i < attrs.getLength(); i++ ){
+  				attr[ attrs.item(i).nodeName ] = attrs.item(i).nodeValue;
+				}return attr;
+  		},
+  		
+  		get innerHTML(){
+  			return this.childNodes.outerHTML;	
+  		},
+  		set innerHTML(html){
+  			html = html.replace(/<\/?([A-Z]+)/g, function(m){
+  				return m.toLowerCase();
+  			}).replace(/&nbsp;/g, " ");
+  			
+  			var dom = new DOMParser().parseFromString("<wrap>" + html + "</wrap>");
+  			var nodes = this.ownerDocument.importNode( dom.documentElement,  true ).childNodes;
+  				
+  			while (this.firstChild){
+  				this.removeChild( this.firstChild );
+				}
+  			
+  			for ( var i = 0; i < nodes.length; i++ )
+  				this.appendChild( nodes[i] );
+  		},
+  		
+  		get textContent(){
+  			function nav(nodes){
+  				var str = "";
+  				for ( var i = 0; i < nodes.length; i++ ){
+  					if ( nodes[i].nodeType == 3 ){
+  						str += nodes[i].nodeValue;
+  					}else if ( nodes[i].nodeType == 1 ){
+  						str += nav(nodes[i].childNodes);
+  					}
+  				} return str;
+  			} return nav(this.childNodes);
+  		},
+  		set textContent(text){
+  			while (this.firstChild)
+  				this.removeChild( this.firstChild );
+  			this.appendChild( this.ownerDocument.createTextNode(text));
+  		},
+  		
+  		style: {},
+  		clientHeight: 0,
+  		clientWidth: 0,
+  		offsetHeight: 0,
+  		offsetWidth: 0,
+  		
+  		get disabled() {
+  			var val = this.getAttribute("disabled");
+  			return val != "false" && !!val;
+  		},
+  		set disabled(val) { return this.setAttribute("disabled",val); },
+  		
+  		get checked() {
+  			var val = this.getAttribute("checked");
+  			return val != "false" && !!val;
+  		},
+  		set checked(val) { return this.setAttribute("checked",val); },
+  		
+  		get selected() {
+  			if ( !this._selectDone ) {
+  				this._selectDone = true;
+  				
+  				if ( this.nodeName == "OPTION" && !this.parentNode.getAttribute("multiple") ) {
+  					var opt = this.parentNode.getElementsByTagName("option");
+  					
+  					if ( this == opt[0] ) {
+  						var select = true;
+  						
+  						for ( var i = 1; i < opt.length; i++ ){
+  							if ( opt[i].selected ) {
+  								select = false;
+  								break;
+  							}
+  						}
+  						if ( select ){ this.selected = true; }
+  					}
+  				}
+  			}
+  			
+  			var val = this.getAttribute("selected");
+  			return val != "false" && !!val;
+  		},
+  		set selected(val) { return this.setAttribute("selected",val); },
+  
+  		get className() { return this.getAttribute("class") || ""; },
+  		set className(val) {
+  			return this.setAttribute("class",
+  				val.replace(/(^\s*|\s*$)/g,""));
+  		},
+  		
+  		get type() { return this.getAttribute("type") || ""; },
+  		set type(val) { return this.setAttribute("type",val); },
+  
+  		get defaultValue() { return this.getAttribute("defaultValue") || ""; },
+  		set defaultValue(val) { return this.setAttribute("defaultValue",val); },
+  
+  		get value() { return this.getAttribute("value") || ""; },
+  		set value(val) { return this.setAttribute("value",val); },
+  		
+  		get src() { return this.getAttribute("src") || ""; },
+  		set src(val) { return this.setAttribute("src",val); },
+  		
+  		get id() { return this.getAttribute("id") || ""; },
+  		set id(val) { return this.setAttribute("id",val); },
+  		
+  		getAttribute: function(name){
+  			return $dom.hasAttribute(name) ?
+  				new String( $dom.getAttribute(name) ) :
+  				null;
+  		},
+  		setAttribute: function(name,value){
+  			$dom.setAttribute(name,value);
+  		},
+  		removeAttribute: function(name){
+  			$dom.removeAttribute(name);
+  		},
+  		
+  		get childNodes(){
+  			return new DOMNodeList( $dom.getChildNodes() );
+  		},
+  		get firstChild(){
+  			return makeNode( $dom.getFirstChild() );
+  		},
+  		get lastChild(){
+  			return makeNode( $dom.getLastChild() );
+  		},
+  		appendChild: function(node){
+  		  //Because the dom implementation is private in scope now,
+  		  //we will need to fix these to use some innerHtml etc
+  		  //if required
+  			$dom.appendChild( $nodeImplCache[node.__guid__] );
+  		},
+  		insertBefore: function(node,before){
+  			$dom.insertBefore( $nodeImplCache[node.__guid__], before ? $nodeImplCache[before.__guid__] : before );
+  			
+  			execScripts( node );
+  			
+  			function execScripts( node ) {
+  				if ( node.nodeName == "SCRIPT" ) {
+  					if ( !node.getAttribute("src") ) {
+  						eval.call( window, node.textContent );
+  					}
+  				} else {
+  					var scripts = node.getElementsByTagName("script");
+  					for ( var i = 0; i < scripts.length; i++ ) {
+  						execScripts( node );
+  					}
+  				}
+  			}
+  		},
+  		removeChild: function(node){
+  			$dom.removeChild( $nodeImplCache[node.__guid__] );
+  		},
+  
+  		getElementsByTagName: function(name){
+  		  // why can't we just do ?: 
+  			//var elems = $dom.getElementsByTagName(name), ret = [];
+  			var elems = $dom.getElementsByTagName("*"), ret = [];
+  			ret.item = function(i){ return this[i]; };
+  			ret.getLength = function(){ return this.length; };
+  			for ( var i = 0; i < elems.length; i++ ) {
+  				var elem = elems.item(i);
+  				if ( elem.getAttribute("name") == name )
+  					ret.push( elem );
+  			}return new DOMNodeList( ret );
+			},
+  		
+  		addEventListener: window.addEventListener,
+  		removeEventListener: window.removeEventListener,
+  		dispatchEvent: window.dispatchEvent,
+  		
+  		click: function(){
+  			var event = document.createEvent();
+  			event.initEvent("click");
+  			this.dispatchEvent(event);
+  		},
+  		submit: function(){
+  			var event = document.createEvent();
+  			event.initEvent("submit");
+  			this.dispatchEvent(event);
+  		},
+  		focus: function(){
+  			var event = document.createEvent();
+  			event.initEvent("focus");
+  			this.dispatchEvent(event);
+  		},
+  		blur: function(){
+  			var event = document.createEvent();
+  			event.initEvent("blur");
+  			this.dispatchEvent(event);
+  		},
+  		get contentWindow(){
+  			return this.nodeName == "IFRAME" ? {
+  				document: this.contentDocument
+  			} : null;
+  		},
+  		get contentDocument(){
+  			if ( this.nodeName == "IFRAME" ) {
+  				if ( !this._doc )
+  					this._doc = HTMLtoDOM("<html><head><title></title></head><body></body></html>");
+  				return this._doc;
+  			} else { return null; }
+    	},
+  		get __guid__(){return $id;}
+		});
+		
+	  //All this constructor stuff belond in the HTML subclasses
+	  //and even more generally in the HTML specific element
+	  //subclass otherwise its going to become a mess
+  	this.style = {
+  		get opacity(){ return this._opacity; },
+  		set opacity(val){ this._opacity = val + ""; }
+  	};
+		
+		// Load CSS info
+		var styles = (this.getAttribute("style") || "").split(/\s*;\s*/);
+		for ( var i = 0; i < styles.length; i++ ) {
+			var style = styles[i].split(/\s*:\s*/);
+			if ( style.length == 2 )
+				this.style[ style[0] ] = style[1];
+		}
+		
+		if ( this.nodeName == "FORM" ) {
+			this.__defineGetter__("elements", function(){
+				return this.getElementsByTagName("*");
+			});
+			this.__defineGetter__("length", function(){
+				var elems = this.elements;
+				for ( var i = 0; i < elems.length; i++ ) {
+					this[i] = elems[i];
+				}
+				return elems.length;
+			});
+		}
+
+		if ( this.nodeName == "SELECT" ) {
+			this.__defineGetter__("options", function(){
+				return this.getElementsByTagName("option");
+			});
+		}
+
+		this.defaultValue = this.value;
+		return this;
+	};
+});

data/src/cruft/good.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html lang="en" xml:lang='en' xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta name="generator" content=
+"HTML Tidy for Mac OS X (vers 1st July 2004), see www.w3.org" />
+<title>Hello World</title>
+<meta content="en-us" http-equiv="Content-Language" />
+<meta content="text/html; charset=us-ascii" http-equiv=
+"Content-Type" />
+<script type='text/javascript'>
+//<![CDATA[
+            document.write("<script>");       
+            document.write("var foo = \'hello world\'");
+            document.write("<\/script>");
+//]]>
+</script>
+</head>
+<body>
+<h1>hello world!</h1>
+<div><!-- note  div not closed properly -->
+<ul>
+<li>item 1</li>
+<li>item 2</li>
+<li>item 3 <a href='another/page.html'>link</a> to another
+page!</li>
+</ul>
+</div>
+</body>
+</html>

data/src/cruft/good.js

@@ -0,0 +1,32 @@
+{
+    "html":{
+      "$xmlns" : "http://www.w3.org/1999/xhtml", 
+      "$xmlns$xml": "http://www.w3.org/XML/1998/namespace",
+      "$lang" : "en",
+      "$xml$lang" : "en",
+      "head":{
+        "meta":{
+          "$name" : "generator",
+          "$content" : "HTML Tidy for Mac OS X (vers 1st July 2004), see www.w3.org"
+        },
+        "title":"Hello World",
+        "meta":[null,null],
+        "script":{
+          "$type" : "text/javascript",
+          '$':["// document.write(\"<script>\"); document.write(\"var foo = \\'hello world\\'\"); document.write(\"<\\/script>\"); //"]
+        }
+      },
+      "body":{
+        "h1":"hello world!",
+        "div":{
+          "ul":{
+            "li":["item 1","item 2",{
+              "a":{
+                "$href" : "another/page.html",
+                '$':["link"]
+              }
+            }]
+          }
+        }
+      }
+    }}

data/src/cruft/internal.js

@@ -0,0 +1,81 @@
+/**
+ * @author thatcher
+ */
+//html passed to env external filter 1 (html to xml)
+<html lang="en" xml:lang='en'>
+    <head>
+		<title>Hello World</title>
+		<meta 	content="en-us" 
+			    http-equiv="Content-Language"/>
+		<meta 	content="text/html; charset=utf-8" 
+				http-equiv="Content-Type"/>
+        <script type='text/javascript'>
+            document.write("<script>");                     
+            document.write("var foo = \'hello world\'");    
+            document.write("</script>");                    
+        </script>
+    </head>
+    <body>
+        <h1>hello world!</h1>
+        <div><!-- note  div not closed properly -->
+            <ul>
+                <li>item 1</li>
+                <li>item 2</li>
+                <li>item 3 <a href='another/page.html'>link</a> to another page!</li>
+            </ul>
+        <div>
+    </body>
+</html>
+
+//xml passed to env external filter 2 (xml to javascript)
+<html lang="en" xml:lang='en'>
+    <head>
+		<title>Hello World</title>
+		<meta 	content="en-us" 
+			    http-equiv="Content-Language"/>
+		<meta 	content="text/html; charset=utf-8" 
+				http-equiv="Content-Type"/>
+        <script type='text/javascript'>
+            document.write("<script>");                     
+            document.write("var foo = \'hello world\'");    
+            document.write("</script>");                    
+        </script>
+    </head>
+    <body>
+        <h1>hello world!</h1>
+        <div>
+            <ul>
+                <li>item 1</li>
+                <li>item 2</li>
+                <li>item 3 <a href='another/page.html'>link</a> to another page!</li>
+            </ul>
+        </div>
+    </body>
+</html>
+
+//Result passed to env internal parser
+_={html:{ lang:'en', xml$lang:'en', $:[
+    {head:{$:[
+        {title:{$:['Hello World']}},
+        {meta:{ content:'en-us', 'http-equiv':'Content-Language'}},
+        {meta:{ content:'text/html; charset=utf-8', 'http-equiv':'Content-Type'}},
+        {script:{ type:'text/javascript', $:['\
+            document.write("<script>");\
+            document.write("var foo = \'hello world\'");\
+            document.write("</script>");\
+        ']}},
+        {body:{$:[
+            {h1:{$:['hello world!']}},
+            {div:{ clazz:'abc def ghi', $:[
+                {p:{$:['my name is chris thatcher']}},
+                {ul:{$:[
+                    {li:{$:['item 1']}},
+                    {li:{$:['item 2']}},
+                    {li:{$:[
+                        'item 3 has ',{a:{href:'another/page.html', $:['link']}}, 'to another page!'
+                    ]}}
+                ]}}
+            ]}}
+        ]}}
+    ]}}
+]}};

data/src/cruft/parser.js

@@ -0,0 +1,458 @@
+/*
+originally from http://www.senocular.com/index.php?id=1.289
+
+SUPPORTED
+- ID selectors
+- Class selectors
+- Multiple class definitions (i.e. LI.red.level)
+- Tag selectors
+- Selector groups
+- Child selectors
+- descendants
+- Adjacent selectors
+- Attribute selectors
+LIMITED SUPPORT
+- Psuedo classes/elements (Must specify in element get properties method), only first pseudo identifier recognized
+NOT SUPPORTED
+- @import
+- Specificity / ! important (would need to check order of definition, determine doc location of LINK vs STYLE tags and parse in order)
+- - current order assumption: STYLE, LINK, INLINE (last with most precedence, parsed last)
+- Inherited properties (TODO? - if so, need to define those properties inherited)
+
+-------------------
+
+// TODO:
+// NEED TO CHECK COMBINATOR
+
+// TESTING
+
+// CHECK FOR NULL/EMPTY STRING PARSING
+		
+*/
+Object.prototype.toString = function(s, t){
+	var looped = false;
+	var str;
+	if (t == undefined) t = "\t";
+	else t += "\t";
+	if (s == undefined) s = "Object: {";
+	else s += "{";
+	for (var p in this){
+		if (!this.hasOwnProperty(p) || !this[p]) continue;
+		s += "\n"+t;
+		if (!looped) looped = true
+		if (this[p] instanceof Array)  s += p+": ["+this[p]+"]";
+		else if (typeof this[p] == "object") s += this[p].toString(p+": ", t);
+		else if (typeof this[p] == "function") s += p+": (function)";
+		else if (typeof this[p] == "string"){
+			str = String(this[p]);
+			str = str.replace(/\r/g,"\\r");
+			str = str.replace(/\n/g,"\\n");
+			str = str.replace(/\t/g,"\\t");
+			s += p+": \""+str+"\"";
+		}else s += p+": "+this[p];
+	}
+	return s+"\n"+t.slice(0,-1)+"}";
+};
+
+CSSParser.DELIM1 = "##DELIM1##";
+CSSParser.DELIM2 = "##DELIM2##";
+CSSParser.combine = function(target, copyFrom){
+	for(var p in copyFrom) target[p] = copyFrom[p];
+}
+CSSParser.trim = function(str){
+	return str.replace(/^\s*|\s*$/g,"");
+}
+CSSParser.whiteSpaceToSpaces = function(str){
+	return str.replace(/\s+/g," ");
+}
+CSSParser.removeComments = function(str){
+	str = str.replace(/<!--/g,"");
+	str = str.replace(/-->/g,"");
+	return str.replace(/\/\*(\r|\n|.)*\*\//g,"");
+}
+CSSParser.arrayContains = function(ary, value){
+	var i, len = ary.length;
+	for (i=0; i<len; i++){
+		if (ary[i] == value) return true;
+	}
+	return false;
+}
+CSSParser.arrayContains = function(ary, value){
+	var i, len = ary.length;
+	for (i=0; i<len; i++){
+		if (ary[i] == value) return true;
+	}
+	return false;
+}
+CSSParser.arrayContainsEach = function(haystack_ary, needles_ary){
+	var n, nlen = needles_ary.length;
+	var h, hlen = haystack_ary.length;
+	var match = false;
+	for (n=0; n<nlen; n++){
+		match = false;
+		for (h=0; h<hlen; h++){
+			if (haystack_ary[h] == needles_ary[n]) match = true;
+		}
+		if (!match) return false;
+	}
+	return true;
+}
+
+
+function CSSParser(style_str, dom){
+	this.data = "";
+	this.styles = new Array();
+	
+	if (style_str && typeof style_str == "object"){
+		dom = style_str;
+		style_str = "all";
+	}else if (!dom) dom = dw.getDocumentDOM();
+	switch(style_str){
+		case "*":
+		case "all":
+		case "document":
+			style_str = CSSParser.getEmbeddedCSSStyle(dom);
+			style_str += CSSParser.getLinkedCSSStyle(dom);
+			break;
+		case "styles":
+			style_str = CSSParser.getEmbeddedCSSStyle(dom);
+			break;
+		case "links":
+			style_str = CSSParser.getLinkedCSSStyle(dom);
+			break;
+	}
+	
+	this.parseData(style_str);
+}
+CSSParser.prototype.parseData = function(style_str){
+	if (!style_str) style_str = "";
+	this.data = style_str;
+	style_str = CSSParser.trim(CSSParser.removeComments(style_str));
+	// TODO: @import ?
+	var blocks = style_str.split("}");
+	blocks.pop();
+	var i, len = blocks.length;
+	var definition_block, properties;
+	for (i=0; i<len; i++){
+		definition_block = blocks[i].split("{");
+		this.styles.push(new CSSStyleGroup(definition_block[0], definition_block[1]));
+	}
+}
+function CSSStyleGroup(style_str, properties_str){
+	this.data = style_str;
+	this.selectors = new Array();
+	
+	this.parseData(style_str, properties_str);
+}
+CSSStyleGroup.prototype.parseData = function(style_str, properties_str){
+	this.selectors = style_str.split(",");
+	var i, len = this.selectors.length;
+	for (i=0; i<len; i++){
+		this.selectors[i] = new CSSSelectorDefinition(this.selectors[i], properties_str);
+	}	
+}
+CSSStyleGroup.prototype.match = function(elem, pseudo){
+	var i, len = this.selectors.length;
+	for (i=0; i<len; i++){
+		if (this.selectors[i].match(elem, pseudo)) return this.selectors[i].properties;
+	}
+	return false;
+}
+
+function CSSSelectorDefinition(selector_str, properties_str){
+	this.data = "";
+	this.singleSelectors = new Array();
+	this.properties = new CSSProperties(properties_str);
+	
+	if (selector_str) this.parseData(selector_str);
+}
+CSSSelectorDefinition.prototype.parseData = function(selector_str){
+	selector_str = CSSParser.trim(selector_str);
+	selector_str = CSSParser.whiteSpaceToSpaces(selector_str);
+	selector_str = selector_str.replace(/\s*\+\s*/g,"+");
+	selector_str = selector_str.replace(/\s*>\s*/g,">");
+	this.data = selector_str;
+	selector_str = selector_str.replace(/ /g,CSSParser.DELIM1 + " " + CSSParser.DELIM1);
+	selector_str = selector_str.replace(/\+/g,CSSParser.DELIM1 + "+" + CSSParser.DELIM1);
+	selector_str = selector_str.replace(/>/g,CSSParser.DELIM1 + ">" + CSSParser.DELIM1);
+	var sels = selector_str.split(CSSParser.DELIM1);
+	var i, len = sels.length;
+	var sel_comb = null;
+	for (i=0; i<len; i+=2){
+		if (i) sel_comb = sels[i-1];
+		this.singleSelectors.push(new CSSSingleSelector(sels[i], sel_comb));
+	}
+}
+CSSSelectorDefinition.prototype.match = function(element, pseudo){
+	// go backwards, starting from right of selector definition
+	var index = this.singleSelectors.length-1;
+	var compare_elem = element;
+	var selector = this.singleSelectors[index];
+	
+	if (!selector.match(compare_elem, pseudo)) return false;
+	while (compare_elem && index >= 0){
+		switch (selector.combinator){
+			case " ":
+				index--;
+				selector = this.singleSelectors[index];
+				do {
+					compare_elem = compare_elem.parentNode;
+				} while(compare_elem && !selector.match(compare_elem, pseudo));
+				if (!compare_elem) return false;
+				break;
+			case ">":
+				index--;
+				selector = this.singleSelectors[index];
+				compare_elem = compare_elem.parentNode;
+				if (!selector.match(compare_elem, pseudo)) return false;
+				break;
+			case "+":
+				index--;
+				selector = this.singleSelectors[index];
+				compare_elem = CSSParser.previousSibling(compare_elem);
+				if (!selector.match(compare_elem, pseudo)) return false;
+				break;
+			default:
+				// assume first selector in definition chain, therefore comparison complete
+				if (!index) return this.properties;
+				else return false;
+		}
+		if (pseudo) pseudo = null; // only used when compare_elem == element
+	}
+	return false;
+}
+
+/*
+CSSSelectorDefinition.prototype.match = function(elem, pseudo){
+	var i = this.singleSelectors.length;
+	// go backwards, starting from right of selector definition
+	var compare = elem;
+	while (i--){
+		// TODO:
+		// NEED TO CHECK COMBINATOR MATCHES HERE?
+		// ----------------------------------------------------------------------------------------------------------------------------------
+//		CSSParser.previousSibling
+		if (this.singleSelectors[i].match(elem, pseudo)) return this.properties;
+	}
+	return false;
+}
+*/
+
+function CSSSingleSelector(selector_str, selector_comb){
+	this.data = selector_str;
+	this.combinator = selector_comb; //:String; either " ", ">", or "+"; can be null/undefined
+	this.type = "*"; //:String; <E>
+	this.classes = "*"; //:Array; E.name
+	this.id =  "*"; //:String; E#name
+	this.pseudoclass = "*"; //:String; E:link
+	this.attributes = "*"; //:CSSAttributeSelector; E[attribute], E[attribute=value]
+	
+	this.parseData(selector_str);
+}
+CSSSingleSelector.prototype.parseData = function(selector_str){
+	var pcs;
+	if (selector_str.indexOf(":") != -1){
+		pcs = selector_str.split(":");
+		selector_str = pcs[0];
+		this.pseudoclass = pcs[1];
+	}
+	if (selector_str.indexOf("[") != -1){
+		pcs = [selector_str.indexOf("["), selector_str.lastIndexOf("]")];
+		this.attributes = new CSSAttributeSelector(selector_str.substring(pcs[0], pcs[1]+1));
+		selector_str = selector_str.substring(0, pcs[0]) + selector_str.substring(pcs[1]+1);
+	}
+	if (selector_str.indexOf("#") != -1){
+		pcs = selector_str.split("#");
+		selector_str = pcs[0];
+		this.id = pcs[1];
+	}
+	if (selector_str.indexOf(".") != -1){
+		pcs = selector_str.indexOf(".");
+		this.classes = new CSSClassSelector(selector_str.substring(pcs+1));
+		selector_str = selector_str.substring(0, pcs);
+	}
+	if (selector_str) this.type = selector_str.toLowerCase();
+}
+
+CSSSingleSelector.prototype.match = function(element, pseudo){
+	if (element.nodeType == Node.TEXT_NODE) element = element.parentNode;
+	if (!element || element.nodeType != Node.ELEMENT_NODE) return false;
+	if (this.type != "*" && element.tagName.toLowerCase() != this.type) return false;
+	if (this.id != "*" && element.getAttribute("id") != this.id) return false;
+	if (pseudo && pseudo != this.pseudoclass) return false;
+	if (this.classes != "*" && !CSSParser.arrayContainsEach(CSSParser.getElementAttributeList(element, "class"), this.classes)) return false;
+	if (this.attributes != "*" && !this.attributes.match(element)) return false;
+	return true;
+}
+
+function CSSAttributeSelector(attrib_str){
+	this.attributeNames = new Array();
+	this.attributeValues = new Array();
+	this.attributeContains = new Array();
+	this.attributeBegins = new Array();
+	
+	this.parseData(attrib_str);
+}
+CSSAttributeSelector.prototype.parseData = function(attrib_str){
+	var attr_ary = attrib_str.match(/\[[^\]]*\]/g);
+	var i, len = attr_ary.length;
+	var attr;
+	for (i=0; i<len; i++){
+		attr = attr_ary[i].slice(1,-1).split("=");
+		if (attr.length == 1){
+			this.attributeNames.push(new CSSAttribute(attr[0], null));
+		}else if (attr[0].charAt(attr[0].length-1) == "~"){
+			this.attributeContains.push(new CSSAttribute(attr[0].slice(0,-1), attr[1].slice(1,-1)));
+		}else if (attr[0].charAt(attr[0].length-1) == "|"){
+			this.attributeBegins.push(new CSSAttribute(attr[0].slice(0,-1), attr[1].slice(1,-1)));
+		}else{
+			this.attributeValues.push(new CSSAttribute(attr[0], attr[1].slice(1,-1)));
+		}
+	}
+}
+CSSAttributeSelector.prototype.match = function(elem){
+	if (this.attributeNames.length && !this.matchNames(elem)) return false;
+	if (this.attributeValues.length && !this.matchValues(elem)) return false;
+	if (this.attributeContains.length && !this.matchContains(elem)) return false;
+	if (this.attributeBegins.length && !this.matchBegins(elem)) return false;
+	return true;
+}
+CSSAttributeSelector.prototype.matchNames = function(elem){
+	var i, len = this.attributeNames.length;
+	for (i=0; i<len; i++){
+		if (elem.getAttribute(this.attributeNames[i].name) == undefined) return false;
+	}
+	return true;
+}
+CSSAttributeSelector.prototype.matchValues = function(elem){
+	var i, len = this.attributeValues.length;
+	for (i=0; i<len; i++){
+		alert([this.attributeValues[i].name, this.attributeValues[i].value])
+		if (elem.getAttribute(this.attributeValues[i].name) != this.attributeValues[i].value) return false;
+	}
+	return true;
+}
+CSSAttributeSelector.prototype.matchContains = function(elem){
+	var i, len = this.attributeContains.length;
+	var attrib, re;
+	for (i=0; i<len; i++){
+		attrib = elem.getAttribute(this.attributeContains[i].name);
+		if (attrib == undefined) return false;
+		re = new RegExp("(^| )"+this.attributeContains[i].value+"( |$)", "g");
+		if (!attrib.match(re)) return false;
+	}
+	return true;
+}
+CSSAttributeSelector.prototype.matchBegins = function(elem){
+	var i, len = this.attributeBegins.length;
+	var attrib;
+	for (i=0; i<len; i++){
+		attrib = elem.getAttribute(this.attributeBegins[i].name);
+		if (attrib == undefined) return false;
+		if (attrib == this.attributeBegins[i].value || attrib.indexOf(this.attributeBegins[i].value + "-") != 0){
+			// allows for exact match or exact match upto first "-" in separated list
+			return false;
+		}
+	}
+	return true;
+}
+
+function CSSAttribute(name, value){
+	this.name = name;
+	this.value = value;
+}
+function CSSClassSelector(class_str){
+	this.values = new Array();
+	
+	this.parseData(class_str);
+}
+CSSClassSelector.prototype.parseData = function(class_str){
+	this.values = class_str.split(".");
+}
+
+function CSSProperties(properties_str){
+	this.values = new Object();
+	
+	this.parseData(properties_str);
+}
+CSSProperties.prototype.parseData = function(properties_str){
+	if (!properties_str) return;
+	var property_block = properties_str.split(";");
+	var i, len = property_block.length;
+	var property, value_block;
+	for (i=0; i<len; i++){
+		property = CSSParser.trim(property_block[i]);
+		if (property){
+			value_block = property.split(":");
+			this.values[CSSParser.trim(value_block[0].toLowerCase())] = CSSParser.trim(value_block[1]);
+		}
+	}
+}
+
+
+CSSParser.getLinkedCSSStyle = function(dom){
+	var links = dom.getElementsByTagName("LINK");
+	var style_str = "";
+	if (links.length){
+		var contents;
+		var i, len = links.length;
+		for (i=0; i<len; i++){
+			if (links[i].rel == "stylesheet" && links[i].href){
+				contents = DWfile.read(dom.URL.substr(0, dom.URL.lastIndexOf("/")+1) + links[i].getAttribute("href"));
+				if (contents) style_str += contents;
+			}
+		}
+	}
+	return (style_str == "") ? "" : style_str;
+}
+CSSParser.getEmbeddedCSSStyle = function(dom){
+	var styles = dom.getElementsByTagName("STYLE");
+	var style_str = "";
+	if (styles.length){
+		var i, len = styles.length;
+		for (i=0; i<len; i++) style_str += styles[i].innerHTML;
+	}
+	return (style_str == "") ? "" : style_str;
+}
+CSSParser.getInlineCSSStyle = function(element){
+	return (element.style == undefined) ? "" : element.style;
+}
+
+CSSParser.previousSibling = function(element){
+	var par = element.parentNode;
+	if (!par || !par.hasChildNodes()) return false;
+	var sib = false;
+	var i, len = par.childNodes.length;
+	for (i=0; i<len; i++){
+		if (par.childNodes[i] == element) return sib;
+		sib = par.childNodes[i];
+	}
+	return false;
+}
+
+CSSParser.getElementAttributeList = function(elem, attrib){
+	var attrib_list = new Array();
+	var attrib = elem.getAttribute(attrib);
+	if (!attrib) return attrib_list;
+	attrib = CSSParser.whiteSpaceToSpaces(attrib);
+	attrib_list = attrib.split(" ");
+	return attrib_list;
+}
+
+
+// -------------------------------------------
+// PUBLIC INTERFACE
+// -------------------------------------------
+// new Parser(dom), new Parser("all" [, dom]), new Parser("style{prop:value;}" [, dom])
+CSSParser.prototype.getElementProperties = function(elem, pseudo){
+	var i, len = this.styles.length;
+	var properties = new CSSProperties(elem.getAttribute("style"));
+	var match_props;
+	for (i=0; i<len; i++){
+		match_props = this.styles[i].match(elem, pseudo);
+		if (match_props){
+			CSSParser.combine(properties.values, match_props.values);
+		}
+	}
+	return properties.values;
+}