envjs19 0.3.8.20101029121421

data/src/html/button.js

@@ -0,0 +1,21 @@
+$debug("Defining HTMLButtonElement");
+/*
+* HTMLButtonElement - DOM Level 2
+*/
+var HTMLButtonElement = function(ownerDocument) {
+    this.HTMLTypeValueInputs = HTMLTypeValueInputs;
+    this.HTMLTypeValueInputs(ownerDocument);
+};
+HTMLButtonElement.prototype = new HTMLTypeValueInputs;
+__extend__(HTMLButtonElement.prototype, inputElements_status);
+__extend__(HTMLButtonElement.prototype, {
+    get dataFormatAs(){
+        return this.getAttribute('dataFormatAs');
+    },
+    set dataFormatAs(value){
+        this.setAttribute('dataFormatAs',value);
+    }
+});
+
+// $w.HTMLButtonElement = HTMLButtonElement;
+

data/src/html/canvas.js

@@ -0,0 +1,14 @@
+$debug("Defining HTMLCanvasElement");
+/* 
+* HTMLCanvasElement - DOM Level 2
+*/
+var HTMLCanvasElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLCanvasElement.prototype = new HTMLElement;
+__extend__(HTMLCanvasElement.prototype, {
+});
+
+$w.HTMLCanvasElement = HTMLCanvasElement;
+	

data/src/html/col-colgroup.js

@@ -0,0 +1,49 @@
+$debug("Defining HTMLTableColElement");
+/* 
+* HTMLTableColElement - DOM Level 2
+*/
+var HTMLTableColElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLTableColElement.prototype = new HTMLElement;
+__extend__(HTMLTableColElement.prototype, {
+    get align(){
+        return this.getAttribute('align');
+    },
+    set align(value){
+        this.setAttribute('align', value);
+    },
+    get ch(){
+        return this.getAttribute('ch');
+    },
+    set ch(value){
+        this.setAttribute('ch', value);
+    },
+    get chOff(){
+        return this.getAttribute('ch');
+    },
+    set chOff(value){
+        this.setAttribute('ch', value);
+    },
+    get span(){
+        return this.getAttribute('span');
+    },
+    set span(value){
+        this.setAttribute('span', value);
+    },
+    get vAlign(){
+        return this.getAttribute('valign');
+    },
+    set vAlign(value){
+        this.setAttribute('valign', value);
+    },
+    get width(){
+        return this.getAttribute('width');
+    },
+    set width(value){
+        this.setAttribute('width', value);
+    }
+});
+
+// $w.HTMLTableColElement = HTMLTableColElement;

data/src/html/collection.js

@@ -0,0 +1,72 @@
+$debug("Defining HTMLCollection");
+/*
+* HTMLCollection - DOM Level 2
+* Implementation Provided by Steven Wood
+*/
+var HTMLCollection = function(nodelist, type){
+
+  __setArray__(this, []);
+  for (var i=0; i<nodelist.length; i++) {
+      this[i] = nodelist[i];
+  }
+  
+  this.length = nodelist.length;
+
+}
+
+HTMLCollection.prototype = {
+        
+    item : function (idx) {
+        var ret = null;
+        if ((idx >= 0) && (idx < this.length)) { 
+            ret = this[idx];                    
+        }
+    
+        return ret;   
+    },
+    
+    namedItem : function (name) {
+    }
+};
+
+// $w.HTMLCollection = HTMLCollection;
+
+/*var HTMLCollection = function(nodelist, type){
+  var $items = [], 
+      $item, i;
+  if(type === "Anchor" ){
+    for(i=0;i<nodelist.length;i++){ 
+      //The name property is required to be add to the collection
+      if(nodelist.item(i).name){
+        item = new nodelist.item(i);
+        $items.push(item);
+        this[nodelist.item(i).name] = item;
+      }
+    }
+  }else if(type === "Link"){
+    for(i=0;i<nodelist.length;i++){ 
+      //The name property is required to be add to the collection
+      if(nodelist.item(i).href){
+        item = new nodelist.item(i);
+        $items.push(item);
+        this[nodelist.item(i).name] = item;
+      }
+    }
+  }else if(type === "Form"){
+    for(i=0;i<nodelist.length;i++){ 
+      //The name property is required to be add to the collection
+      if(nodelist.item(i).href){
+        item = new nodelist.item(i);
+        $items.push(item);
+        this[nodelist.item(i).name] = item;
+      }
+    }
+  }
+  setArray(this, $items);
+  return __extend__(this, {
+    item : function(i){return this[i];},
+    namedItem : function(name){return this[name];}
+  });
+};*/
+
+	

data/src/html/cookie.js

@@ -0,0 +1,153 @@
+$debug("Defining document.cookie");
+/*
+*	cookie.js
+*   - requires env
+*/
+
+var $cookies = {
+	persistent:{
+		//domain - key on domain name {
+			//path - key on path {
+				//name - key on name {
+					 //value : cookie value
+					 //other cookie properties
+				//}
+			//}
+		//}
+		//expire - provides a timestamp for expiring the cookie
+		//cookie - the cookie!
+	},
+	temporary:{//transient is a reserved word :(
+		//like above
+	}
+};
+
+//HTMLDocument cookie
+__extend__(HTMLDocument.prototype, {
+set cookie(cookie){
+	var i,name,value,properties = {},attr,attrs = cookie.split(";");
+	//for now the strategy is to simply create a json object
+	//and post it to a file in the .cookies.js file.  I hate parsing
+	//dates so I decided not to implement support for 'expires' 
+	//(which is deprecated) and instead focus on the easier 'max-age'
+	//(which succeeds 'expires') 
+	cookie = {};//keyword properties of the cookie
+	for(i=0;i<attrs.length;i++){
+		var index = attrs[i].indexOf("=");
+        if(index > -1){
+            name = trim(attrs[i].slice(0,index));
+            value = trim(attrs[i].slice(index+1));
+            cookie['domain'] = "";
+            if(name=='max-age'){
+               //we'll have to set a timer to check these
+				//and garbage collect expired cookies
+				cookie[name] = parseInt(value, 10);
+			} else if(name=='domain'){
+				if(domainValid(value)){
+					cookie['domain']=value;
+				}else{
+					cookie['domain']=this._parentWindow.location.domain;
+				}
+			} else if(name=='path'){
+				//not sure of any special logic for path
+				cookie['path'] = value;
+			} else {
+				//its not a cookie keyword so store it in our array of properties
+				//and we'll serialize individually in a moment
+				properties[name] = value;
+			}
+		}else{
+			if(attrs[i] == 'secure'){
+                cookie[attrs[i]] = true;
+			}
+		}
+	}
+	if(!cookie['max-age']){
+		//it's a transient cookie so it only lasts as long as 
+		//the window.location remains the same
+		mergeCookie($cookies.temporary, cookie, properties);
+	}else if(cookie['max-age']===0){
+		//delete the cookies
+		//TODO
+	}else{
+		//the cookie is persistent
+		mergeCookie($cookies.persistent, cookie, properties);
+		persistCookies();
+	}
+},
+get cookie(c){
+	//The cookies that are returned must belong to the same domain
+	//and be at or below the current window.location.path.  Also
+	//we must check to see if the cookie was set to 'secure' in which
+	//case we must check our current location.protocol to make sure it's
+	//https:
+	var allcookies = [], i;
+        return cookieString.call(this, $cookies.temporary) +
+                cookieString.call(this, $cookies.persistent); 	
+}});
+
+var cookieString = function(cookies) {
+    var $w = this._parentWindow;
+    var cookieString = "";
+    for (var i in cookies) {
+        // check if the cookie is in the current domain (if domain is set)
+        if (i == "" || i == $w.location.domain) {
+            for (var j in cookies[i]) {
+                // make sure path is at or below the window location path
+                if (j == "/" || $w.location.pathname.indexOf(j) === 0) {
+                    for (var k in cookies[i][j]) {
+                        cookieString += k + "=" + cookies[i][j][k].value+";";
+                    }
+                }
+            }
+        }
+    }
+    return cookieString;
+}
+
+
+var domainValid = function(domain){
+	//make sure the domain
+	//TODO 	
+};
+
+var mergeCookie = function(target, cookie, properties){
+	var name, now;
+	if(!target[cookie.domain]){
+		target[cookie.domain] = {};
+	}
+	if(!target[cookie.domain][cookie.path]){
+		target[cookie.domain][cookie.path] = {};
+	}
+	for(name in properties){
+		now = new Date().getTime();
+		target[cookie.domain][cookie.path][name] = {
+			value:properties[name],
+			"@env:secure":cookie.secure,
+			"@env:max-age":cookie['max-age'],
+			"@env:date-created":now,
+			"@env:expiration":now + cookie['max-age']
+		};
+	}
+};
+
+var persistCookies = function(){
+	//TODO
+	//I think it should be done via $env so it can be customized
+};
+
+var loadCookies = function(){
+	//TODO
+	//should also be configurable via $env	
+};
+
+//We simply use the default ajax get to load the .cookies.js file
+//if it doesn't exist we create it with a post.  Cookies are maintained
+//in memory, but serialized with each set.
+try{
+	//TODO - load cookies
+	loadCookies();
+}catch(e){
+	//TODO - fail gracefully
+}	
+	

data/src/html/del-ins.js

@@ -0,0 +1,25 @@
+$debug("Defining HTMLModElement");
+/* 
+* HTMLModElement - DOM Level 2
+*/
+var HTMLModElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLModElement.prototype = new HTMLElement;
+__extend__(HTMLModElement.prototype, {
+    get cite(){
+        return this.getAttribute('cite');
+    },
+    set cite(value){
+        this.setAttribute('cite', value);
+    },
+    get dateTime(){
+        return this.getAttribute('datetime');
+    },
+    set dateTime(value){
+        this.setAttribute('datetime', value);
+    }
+});
+
+// $w.HTMLModElement = HTMLModElement;	

data/src/html/div.js

@@ -0,0 +1,28 @@
+/*
+ * This file is a component of env.js,
+ *     http://github.com/gleneivey/env-js/commits/master/README
+ * a Pure JavaScript Browser Environment
+ * Copyright 2009 John Resig, licensed under the MIT License
+ *     http://www.opensource.org/licenses/mit-license.php
+ */
+
+
+$debug("Defining HTMLDivElement");
+/*
+* HTMLDivElement - DOM Level 2
+*/
+var HTMLDivElement = function(ownerDocument) {
+    this.HTMLElement = HTMLElement;
+    this.HTMLElement(ownerDocument);
+};
+HTMLDivElement.prototype = new HTMLElement;
+__extend__(HTMLDivElement.prototype, {
+    get align(){
+        return this.getAttribute('align') || 'left';
+    },
+    set align(value){
+        this.setAttribute('align', value);
+    }
+});
+
+// $w.HTMLDivElement = HTMLDivElement;

data/src/html/document.js

@@ -0,0 +1,364 @@
+$debug("Defining HTMLDocument");
+/*
+* HTMLDocument - DOM Level 2
+*/
+/**
+ * @class  HTMLDocument - The Document interface represents the entire HTML or XML document.
+ *   Conceptually, it is the root of the document tree, and provides the primary access to the document's data.
+ *
+ * @extends DOMDocument
+ */
+var HTMLDocument = function(implementation, docParentWindow, docReferrer) {
+  this.DOMDocument = DOMDocument;
+  this.DOMDocument(implementation, docParentWindow);
+
+  this._referrer = docReferrer;
+  this._domain;
+  this._open = false;
+  this.$async = false;
+};
+HTMLDocument.prototype = new DOMDocument;
+__extend__(HTMLDocument.prototype, {
+    loadXML : function(xmlString, url) {
+        if (url) {
+            var $env =  this._parentWindow.$envx;
+            $env.__url(url);
+        }
+
+        // create DOM Document
+/*
+        if(this === $document){
+            $debug("Setting internal window.document");
+            $document = this;
+        }
+*/
+        // populate Document with Parsed Nodes
+        try {
+            // make sure thid document object is empty before we try to load ...
+            this.childNodes      = new DOMNodeList(this, this);
+            this.firstChild      = null;
+            this.lastChild       = null;
+            this.attributes      = new DOMNamedNodeMap(this, this);
+            this._namespaces     = new DOMNamespaceNodeMap(this, this);
+            this._readonly = false;
+            
+//          var now = Date.now();
+// print("begin parse");
+try{
+            this._parentWindow.parseHtmlDocument(xmlString, this, null, null);
+}catch(e){
+  print("oopsd",e);
+  throw e;
+}
+// print("end parse");
+//          print("parse time: "+(Date.now() - now)/1000.);
+//          print("parse: "+xmlString.substring(0,80));
+
+            
+        } catch (e) {
+            $error(e);
+        }
+
+        // set parseComplete flag, (Some validation Rules are relaxed if this is false)
+        this._parseComplete = true;
+        return this;
+    },
+    createElement: function(tagName){
+          var node;
+          //print('createElement :'+tagName);
+          // throw Exception if the tagName string contains an illegal character
+          if (__ownerDocument__(this).implementation.errorChecking && 
+                (!__isValidName__(tagName))) {
+              throw(new DOMException(DOMException.INVALID_CHARACTER_ERR));
+          }
+          var originalName = tagName;
+          tagName = tagName.toUpperCase();
+          // create DOMElement specifying 'this' as ownerDocument
+          //This is an html document so we need to use explicit interfaces per the 
+          if(     tagName.match(/^A$/))                 {node = new HTMLAnchorElement(this);}
+          else if(tagName.match(/^AREA$/))              {node = new HTMLAreaElement(this);}
+          else if(tagName.match(/BASE/))                {node = new HTMLBaseElement(this);}
+          else if(tagName.match(/BLOCKQUOTE|Q/))        {node = new HTMLQuoteElement(this);}
+          else if(tagName.match(/BODY/))                {node = new HTMLBodyElement(this);}
+          else if(tagName.match(/BR/))                  {node = new HTMLElement(this);}
+          else if(tagName.match(/BUTTON/))              {node = new HTMLButtonElement(this);}
+          else if(tagName.match(/CAPTION/))             {node = new HTMLElement(this);}
+          else if(tagName.match(/COL|COLGROUP/))        {node = new HTMLTableColElement(this);}
+          else if(tagName.match(/DEL|INS/))             {node = new HTMLModElement(this);}
+          else if(tagName.match(/DIV/))                 {node = new HTMLDivElement(this);}
+          else if(tagName.match(/DL/))                  {node = new HTMLElement(this);}
+          else if(tagName.match(/FIELDSET/))            {node = new HTMLFieldSetElement(this);}
+          else if(tagName.match(/FORM/))                {node = new HTMLFormElement(this);}
+          else if(tagName.match(/^FRAME$/))             {node = new HTMLFrameElement(this);}
+          else if(tagName.match(/FRAMESET/))            {node = new HTMLFrameSetElement(this);}
+          else if(tagName.match(/H1|H2|H3|H4|H5|H6/))   {node = new HTMLElement(this);}
+          else if(tagName.match(/HEAD/))                {node = new HTMLHeadElement(this);}
+          else if(tagName.match(/HR/))                  {node = new HTMLElement(this);}
+          else if(tagName.match(/HTML/))                {node = new HTMLElement(this);}
+          else if(tagName.match(/IFRAME/))              {node = new HTMLIFrameElement(this);}
+          else if(tagName.match(/IMG/))                 {node = new HTMLImageElement(this);}
+          else if(tagName.match(/INPUT/))               {node = new HTMLInputElement(this);}
+          else if(tagName.match(/LABEL/))               {node = new HTMLLabelElement(this);}
+          else if(tagName.match(/LEGEND/))              {node = new HTMLLegendElement(this);}
+          else if(tagName.match(/^LI$/))                {node = new HTMLElement(this);}
+          else if(tagName.match(/LINK/))                {node = new HTMLLinkElement(this);}
+          else if(tagName.match(/MAP/))                 {node = new HTMLMapElement(this);}
+          else if(tagName.match(/META/))                {node = new HTMLMetaElement(this);}
+          else if(tagName.match(/OBJECT/))              {node = new HTMLObjectElement(this);}
+          else if(tagName.match(/OL/))                  {node = new HTMLElement(this);}
+          else if(tagName.match(/OPTGROUP/))            {node = new HTMLOptGroupElement(this);}
+          else if(tagName.match(/OPTION/))              {node = new HTMLOptionElement(this);;}
+          else if(tagName.match(/^P$/))                 {node = new HTMLElement(this);}
+          else if(tagName.match(/PARAM/))               {node = new HTMLParamElement(this);}
+          else if(tagName.match(/PRE/))                 {node = new HTMLElement(this);}
+          else if(tagName.match(/SCRIPT/))              {node = new HTMLScriptElement(this);}
+          else if(tagName.match(/SELECT/))              {node = new HTMLSelectElement(this);}
+          else if(tagName.match(/STYLE/))               {node = new HTMLStyleElement(this);}
+          else if(tagName.match(/TABLE/))               {node = new HTMLTableElement(this);}
+          else if(tagName.match(/TBODY|TFOOT|THEAD/))   {node = new HTMLTableSectionElement(this);}
+          else if(tagName.match(/TD|TH/))               {node = new HTMLTableCellElement(this);}
+          else if(tagName.match(/TEXTAREA/))            {node = new HTMLTextAreaElement(this);}
+          else if(tagName.match(/TITLE/))               {node = new HTMLTitleElement(this);}
+          else if(tagName.match(/TR/))                  {node = new HTMLTableRowElement(this);}
+          else if(tagName.match(/UL/))                  {node = new HTMLElement(this);}
+          else{
+            node = new HTMLElement(this);
+          }
+        
+          // assign values to properties (and aliases)
+          node.tagName  = tagName; // originalName;
+          return node;
+    },
+    createElementNS : function (uri, local) {
+        //print('createElementNS :'+uri+" "+local);
+        if(!uri){
+            return this.createElement(local);
+        }else if ("http://www.w3.org/1999/xhtml" == uri) {
+             return this.createElement(local);
+        } else if ("http://www.w3.org/1998/Math/MathML" == uri) {
+          if (!this.mathplayerinitialized) {
+              var obj = this.createElement("object");
+              obj.setAttribute("id", "mathplayer");
+              obj.setAttribute("classid", "clsid:32F66A20-7614-11D4-BD11-00104BD3F987");
+              this.getElementsByTagName("head")[0].appendChild(obj);
+              this.namespaces.add("m", "http://www.w3.org/1998/Math/MathML", "#mathplayer");  
+              this.mathplayerinitialized = true;
+          }
+          return this.createElement("m:" + local);
+        } else {
+            return DOMDocument.prototype.createElementNS.apply(this,[uri, local]);
+        }
+    },
+    get anchors(){
+        return new HTMLCollection(this.getElementsByTagName('a'), 'Anchor');
+        
+    },
+    get applets(){
+        return new HTMLCollection(this.getElementsByTagName('applet'), 'Applet');
+        
+    },
+    get body(){ 
+        var nodelist = this.getElementsByTagName('body');
+        return nodelist.item(0);
+        
+    },
+    set body(html){
+        return this.replaceNode(this.body,html);
+        
+    },
+
+    get title(){
+        var titleArray = this.getElementsByTagName('title');
+        if (titleArray.length < 1)
+            return "";
+        return titleArray[0].text;
+    },
+    set title(titleStr){
+        titleArray = this.getElementsByTagName('title');
+        if (titleArray.length < 1){
+            // need to make a new element and add it to "head"
+            var titleElem = new HTMLTitleElement(this);
+            titleElem.text = titleStr;
+            var headArray = this.getElementsByTagName('head');
+	    if (headArray.length < 1)
+                return;  // ill-formed, just give up.....
+            headArray[0].appendChild(titleElem);
+        }
+        else {
+            titleArray[0].text = titleStr;
+        }
+    },
+
+    //set/get cookie see cookie.js
+    get domain(){
+        return this._domain||this._parentWindow.location.domain;
+        
+    },
+    set domain(){
+        /* TODO - requires a bit of thought to enforce domain restrictions */ 
+        return; 
+        
+    },
+    get forms(){
+      return new HTMLCollection(this.getElementsByTagName('form'), 'Form');
+    },
+    get images(){
+        return new HTMLCollection(this.getElementsByTagName('img'), 'Image');
+        
+    },
+    get lastModified(){ 
+        /* TODO */
+        return this._lastModified; 
+    
+    },
+    get links(){
+        return new HTMLCollection(this.getElementsByTagName('a'), 'Link');
+        
+    },
+    get location(){
+        return this._parentWindow.location
+    },
+    get referrer(){
+        return this._referrer;
+    },
+	close : function(){ 
+	    /* TODO */ 
+	    this._open = false;
+    },
+	getElementsByName : function(name){
+        //returns a real Array + the DOMNodeList
+        var retNodes = __extend__([],new DOMNodeList(this, this.documentElement)),
+          node;
+        // loop through all Elements in the 'all' collection
+        var all = this.all;
+        for (var i=0; i < all.length; i++) {
+            node = all[i];
+            if (node.nodeType == DOMNode.ELEMENT_NODE && node.getAttribute('name') == name) {
+                retNodes.push(node);
+            }
+        }
+        return retNodes;
+	},
+	open : function(){ 
+	    /* TODO */
+	    this._open = true;  
+    },
+	write: function(htmlstring){ 
+	    /* TODO */
+	    return; 
+	
+    },
+	writeln: function(htmlstring){ 
+	    this.write(htmlstring+'\n'); 
+    },
+	toString: function(){ 
+	    return "HTMLDocument" +  (typeof this._url == "string" ? ": " + this._url : ""); 
+    },
+	get innerHTML(){ 
+	    return this.documentElement.outerHTML; 
+	    
+    },
+	get __html__(){
+	    return true;
+	    
+    },
+    get async(){ return this.$async;},
+    set async(async){ this.$async = async; },
+    get baseURI(){
+      var $env =  this.ownerDocument._parentWindow.$envx;
+      return $env.location('./');
+    },
+    get URL(){ return this._parentWindow.location.href;  },
+    set URL(url){ this._parentWindow.location.href = url;  },
+});
+
+var __elementPopped__ = function(ns, name, node){
+try{
+    var $env =  __ownerDocument__(node)._parentWindow.$envx;
+    // $error('Element Popped: '+ns+" "+name+ " "+ node+" " +node.type+" "+node.nodeName);
+    var doc = __ownerDocument__(node);
+    // SMP: subtle issue here: we're currently getting two kinds of script nodes from the html5 parser.
+    // The "fake" nodes come with a type of undefined. The "real" nodes come with the type that's given,
+    // or null if not given. So the following check has the side-effect of ignoring the "fake" nodes. So
+    // something to watch for if this code changes.
+    var type = ( node.type === null ) ? "text/javascript" : node.type;
+    try{
+        if(node.nodeName.toLowerCase() == 'script' && type == "text/javascript"){
+            // print(node,doc.in_inner_html);
+            if (doc.in_inner_html) {
+                // this is a fib, but ...
+                // print("ignore",node);
+                // node.executed = true;
+            } else {
+                //$env.debug("element popped: script\n"+node.xml);
+                // unless we're parsing in a window context, don't execute scripts
+                // this probably doesn't do anything ...
+                if (true /*doc.parentWindow && !node.ownerDocument.is_innerHTML*/){
+                    //p.replaceEntities = true;
+                    var okay = $env.loadLocalScript(node, null);
+                    // only fire event if we actually had something to load
+                    if (node.src && node.src.length > 0){
+                            var event = doc.createEvent();
+                        event.initEvent( okay ? "load" : "error", false, false );
+                        node.dispatchEvent( event, false );
+                    }
+                }
+            }
+        }
+        else if (node.nodeName.toLowerCase() == 'frame' ||
+                 node.nodeName.toLowerCase() == 'iframe'   ){
+            
+            //$env.debug("element popped: iframe\n"+node.xml);
+            if (node.src && node.src.length > 0){
+                $debug("getting content document for (i)frame from " + node.src);
+    
+                // any JS here is DOM-instigated, so the JS scope is the window, not the first script
+
+              var $inner = node.ownerDocument._parentWindow["$inner"];
+
+              var save = $master.first_script_window;
+              $master.first_script_window = $inner;
+
+              $env.loadFrame(node, $env.location(node.src));
+    
+              $master.first_script_window = save;
+
+                var event = doc.createEvent();
+                event.initEvent("load", false, false);
+                node.dispatchEvent( event, false );
+            }
+        }
+        else if (node.nodeName.toLowerCase() == 'link'){
+            //$env.debug("element popped: link\n"+node.xml);
+            if (node.href && node.href.length > 0){
+                // don't actually load anything, so we're "done" immediately:
+                var event = doc.createEvent();
+                event.initEvent("load", false, false);
+                node.dispatchEvent( event, false );
+            }
+        }
+        else if (node.nodeName.toLowerCase() == 'img'){
+            //$env.debug("element popped: img \n"+node.xml);
+            if (node.src && node.src.length > 0){
+                // don't actually load anything, so we're "done" immediately:
+                var event = doc.createEvent();
+                event.initEvent("load", false, false);
+                node.dispatchEvent( event, false );
+            }
+        }
+    }catch(e){
+        $error('error loading html element', e);
+        $error(e);
+    }
+} catch(e) {
+  $error("arg",e);
+}
+};
+
+//$w.HTMLDocument = HTMLDocument;
+
+// Local Variables:
+// espresso-indent-level:4
+// c-basic-offset:4
+// tab-width:4
+// End: