diff --git a/planetstack/core/static/log4javascript-1.4.6/js/console.html b/planetstack/core/static/log4javascript-1.4.6/js/console.html
new file mode 100644
index 0000000..476d272
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/console.html
@@ -0,0 +1,263 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+<title>log4javascript</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->
+<meta http-equiv="X-UA-Compatible" content="IE=7" />
+<script type="text/javascript">var isIe = false, isIePre7 = false;</script>
+<!--[if IE]><script type="text/javascript">isIe = true</script><![endif]-->
+<!--[if lt IE 7]><script type="text/javascript">isIePre7 = true</script><![endif]-->
+<script type="text/javascript">
+//<![CDATA[
+var loggingEnabled=true;var logQueuedEventsTimer=null;var logEntries=[];var logEntriesAndSeparators=[];var logItems=[];var renderDelay=100;var unrenderedLogItemsExist=false;var rootGroup,currentGroup=null;var loaded=false;var currentLogItem=null;var logMainContainer;function copyProperties(obj,props){for(var i in props){obj[i]=props[i];}}
+function LogItem(){}
+LogItem.prototype={mainContainer:null,wrappedContainer:null,unwrappedContainer:null,group:null,appendToLog:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].appendToLog();}
+this.group.update();},doRemove:function(doUpdate,removeFromGroup){if(this.rendered){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].remove();}
+this.unwrappedElementContainer=null;this.wrappedElementContainer=null;this.mainElementContainer=null;}
+if(this.group&&removeFromGroup){this.group.removeChild(this,doUpdate);}
+if(this===currentLogItem){currentLogItem=null;}},remove:function(doUpdate,removeFromGroup){this.doRemove(doUpdate,removeFromGroup);},render:function(){},accept:function(visitor){visitor.visit(this);},getUnwrappedDomContainer:function(){return this.group.unwrappedElementContainer.contentDiv;},getWrappedDomContainer:function(){return this.group.wrappedElementContainer.contentDiv;},getMainDomContainer:function(){return this.group.mainElementContainer.contentDiv;}};LogItem.serializedItemKeys={LOG_ENTRY:0,GROUP_START:1,GROUP_END:2};function LogItemContainerElement(){}
+LogItemContainerElement.prototype={appendToLog:function(){var insertBeforeFirst=(newestAtTop&&this.containerDomNode.hasChildNodes());if(insertBeforeFirst){this.containerDomNode.insertBefore(this.mainDiv,this.containerDomNode.firstChild);}else{this.containerDomNode.appendChild(this.mainDiv);}}};function SeparatorElementContainer(containerDomNode){this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="separator";this.mainDiv.innerHTML="&nbsp;";}
+SeparatorElementContainer.prototype=new LogItemContainerElement();SeparatorElementContainer.prototype.remove=function(){this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;};function Separator(){this.rendered=false;}
+Separator.prototype=new LogItem();copyProperties(Separator.prototype,{render:function(){var containerDomNode=this.group.contentDiv;if(isIe){this.unwrappedElementContainer=new SeparatorElementContainer(this.getUnwrappedDomContainer());this.wrappedElementContainer=new SeparatorElementContainer(this.getWrappedDomContainer());this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{this.mainElementContainer=new SeparatorElementContainer(this.getMainDomContainer());this.elementContainers=[this.mainElementContainer];}
+this.content=this.formattedMessage;this.rendered=true;}});function GroupElementContainer(group,containerDomNode,isRoot,isWrapped){this.group=group;this.containerDomNode=containerDomNode;this.isRoot=isRoot;this.isWrapped=isWrapped;this.expandable=false;if(this.isRoot){if(isIe){this.contentDiv=logMainContainer.appendChild(document.createElement("div"));this.contentDiv.id=this.isWrapped?"log_wrapped":"log_unwrapped";}else{this.contentDiv=logMainContainer;}}else{var groupElementContainer=this;this.mainDiv=document.createElement("div");this.mainDiv.className="group";this.headingDiv=this.mainDiv.appendChild(document.createElement("div"));this.headingDiv.className="groupheading";this.expander=this.headingDiv.appendChild(document.createElement("span"));this.expander.className="expander unselectable greyedout";this.expander.unselectable=true;var expanderText=this.group.expanded?"-":"+";this.expanderTextNode=this.expander.appendChild(document.createTextNode(expanderText));this.headingDiv.appendChild(document.createTextNode(" "+this.group.name));this.contentDiv=this.mainDiv.appendChild(document.createElement("div"));var contentCssClass=this.group.expanded?"expanded":"collapsed";this.contentDiv.className="groupcontent "+contentCssClass;this.expander.onclick=function(){if(groupElementContainer.group.expandable){groupElementContainer.group.toggleExpanded();}};}}
+GroupElementContainer.prototype=new LogItemContainerElement();copyProperties(GroupElementContainer.prototype,{toggleExpanded:function(){if(!this.isRoot){var oldCssClass,newCssClass,expanderText;if(this.group.expanded){newCssClass="expanded";oldCssClass="collapsed";expanderText="-";}else{newCssClass="collapsed";oldCssClass="expanded";expanderText="+";}
+replaceClass(this.contentDiv,newCssClass,oldCssClass);this.expanderTextNode.nodeValue=expanderText;}},remove:function(){if(!this.isRoot){this.headingDiv=null;this.expander.onclick=null;this.expander=null;this.expanderTextNode=null;this.contentDiv=null;this.containerDomNode=null;this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;}},reverseChildren:function(){var node=null;var childDomNodes=[];while((node=this.contentDiv.firstChild)){this.contentDiv.removeChild(node);childDomNodes.push(node);}
+while((node=childDomNodes.pop())){this.contentDiv.appendChild(node);}},update:function(){if(!this.isRoot){if(this.group.expandable){removeClass(this.expander,"greyedout");}else{addClass(this.expander,"greyedout");}}},clear:function(){if(this.isRoot){this.contentDiv.innerHTML="";}}});function Group(name,isRoot,initiallyExpanded){this.name=name;this.group=null;this.isRoot=isRoot;this.initiallyExpanded=initiallyExpanded;this.elementContainers=[];this.children=[];this.expanded=initiallyExpanded;this.rendered=false;this.expandable=false;}
+Group.prototype=new LogItem();copyProperties(Group.prototype,{addChild:function(logItem){this.children.push(logItem);logItem.group=this;},render:function(){if(isIe){var unwrappedDomContainer,wrappedDomContainer;if(this.isRoot){unwrappedDomContainer=logMainContainer;wrappedDomContainer=logMainContainer;}else{unwrappedDomContainer=this.getUnwrappedDomContainer();wrappedDomContainer=this.getWrappedDomContainer();}
+this.unwrappedElementContainer=new GroupElementContainer(this,unwrappedDomContainer,this.isRoot,false);this.wrappedElementContainer=new GroupElementContainer(this,wrappedDomContainer,this.isRoot,true);this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{var mainDomContainer=this.isRoot?logMainContainer:this.getMainDomContainer();this.mainElementContainer=new GroupElementContainer(this,mainDomContainer,this.isRoot,false);this.elementContainers=[this.mainElementContainer];}
+this.rendered=true;},toggleExpanded:function(){this.expanded=!this.expanded;for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].toggleExpanded();}},expand:function(){if(!this.expanded){this.toggleExpanded();}},accept:function(visitor){visitor.visitGroup(this);},reverseChildren:function(){if(this.rendered){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].reverseChildren();}}},update:function(){var previouslyExpandable=this.expandable;this.expandable=(this.children.length!==0);if(this.expandable!==previouslyExpandable){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].update();}}},flatten:function(){var visitor=new GroupFlattener();this.accept(visitor);return visitor.logEntriesAndSeparators;},removeChild:function(child,doUpdate){array_remove(this.children,child);child.group=null;if(doUpdate){this.update();}},remove:function(doUpdate,removeFromGroup){for(var i=0,len=this.children.length;i<len;i++){this.children[i].remove(false,false);}
+this.children=[];this.update();if(this===currentGroup){currentGroup=this.group;}
+this.doRemove(doUpdate,removeFromGroup);},serialize:function(items){items.push([LogItem.serializedItemKeys.GROUP_START,this.name]);for(var i=0,len=this.children.length;i<len;i++){this.children[i].serialize(items);}
+if(this!==currentGroup){items.push([LogItem.serializedItemKeys.GROUP_END]);}},clear:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].clear();}}});function LogEntryElementContainer(){}
+LogEntryElementContainer.prototype=new LogItemContainerElement();copyProperties(LogEntryElementContainer.prototype,{remove:function(){this.doRemove();},doRemove:function(){this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;this.contentElement=null;this.containerDomNode=null;},setContent:function(content,wrappedContent){if(content===this.formattedMessage){this.contentElement.innerHTML="";this.contentElement.appendChild(document.createTextNode(this.formattedMessage));}else{this.contentElement.innerHTML=content;}},setSearchMatch:function(isMatch){var oldCssClass=isMatch?"searchnonmatch":"searchmatch";var newCssClass=isMatch?"searchmatch":"searchnonmatch";replaceClass(this.mainDiv,newCssClass,oldCssClass);},clearSearch:function(){removeClass(this.mainDiv,"searchmatch");removeClass(this.mainDiv,"searchnonmatch");}});function LogEntryWrappedElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.appendChild(document.createTextNode(this.logEntry.formattedMessage));this.mainDiv.className="logentry wrapped "+this.logEntry.level;this.contentElement=this.mainDiv;}
+LogEntryWrappedElementContainer.prototype=new LogEntryElementContainer();LogEntryWrappedElementContainer.prototype.setContent=function(content,wrappedContent){if(content===this.formattedMessage){this.contentElement.innerHTML="";this.contentElement.appendChild(document.createTextNode(this.formattedMessage));}else{this.contentElement.innerHTML=wrappedContent;}};function LogEntryUnwrappedElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="logentry unwrapped "+this.logEntry.level;this.pre=this.mainDiv.appendChild(document.createElement("pre"));this.pre.appendChild(document.createTextNode(this.logEntry.formattedMessage));this.pre.className="unwrapped";this.contentElement=this.pre;}
+LogEntryUnwrappedElementContainer.prototype=new LogEntryElementContainer();LogEntryUnwrappedElementContainer.prototype.remove=function(){this.doRemove();this.pre=null;};function LogEntryMainElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="logentry nonielogentry "+this.logEntry.level;this.contentElement=this.mainDiv.appendChild(document.createElement("span"));this.contentElement.appendChild(document.createTextNode(this.logEntry.formattedMessage));}
+LogEntryMainElementContainer.prototype=new LogEntryElementContainer();function LogEntry(level,formattedMessage){this.level=level;this.formattedMessage=formattedMessage;this.rendered=false;}
+LogEntry.prototype=new LogItem();copyProperties(LogEntry.prototype,{render:function(){var logEntry=this;var containerDomNode=this.group.contentDiv;if(isIe){this.formattedMessage=this.formattedMessage.replace(/\r\n/g,"\r");this.unwrappedElementContainer=new LogEntryUnwrappedElementContainer(this,this.getUnwrappedDomContainer());this.wrappedElementContainer=new LogEntryWrappedElementContainer(this,this.getWrappedDomContainer());this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{this.mainElementContainer=new LogEntryMainElementContainer(this,this.getMainDomContainer());this.elementContainers=[this.mainElementContainer];}
+this.content=this.formattedMessage;this.rendered=true;},setContent:function(content,wrappedContent){if(content!=this.content){if(isIe&&(content!==this.formattedMessage)){content=content.replace(/\r\n/g,"\r");}
+for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].setContent(content,wrappedContent);}
+this.content=content;}},getSearchMatches:function(){var matches=[];var i,len;if(isIe){var unwrappedEls=getElementsByClass(this.unwrappedElementContainer.mainDiv,"searchterm","span");var wrappedEls=getElementsByClass(this.wrappedElementContainer.mainDiv,"searchterm","span");for(i=0,len=unwrappedEls.length;i<len;i++){matches[i]=new Match(this.level,null,unwrappedEls[i],wrappedEls[i]);}}else{var els=getElementsByClass(this.mainElementContainer.mainDiv,"searchterm","span");for(i=0,len=els.length;i<len;i++){matches[i]=new Match(this.level,els[i]);}}
+return matches;},setSearchMatch:function(isMatch){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].setSearchMatch(isMatch);}},clearSearch:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].clearSearch();}},accept:function(visitor){visitor.visitLogEntry(this);},serialize:function(items){items.push([LogItem.serializedItemKeys.LOG_ENTRY,this.level,this.formattedMessage]);}});function LogItemVisitor(){}
+LogItemVisitor.prototype={visit:function(logItem){},visitParent:function(logItem){if(logItem.group){logItem.group.accept(this);}},visitChildren:function(logItem){for(var i=0,len=logItem.children.length;i<len;i++){logItem.children[i].accept(this);}},visitLogEntry:function(logEntry){this.visit(logEntry);},visitSeparator:function(separator){this.visit(separator);},visitGroup:function(group){this.visit(group);}};function GroupFlattener(){this.logEntriesAndSeparators=[];}
+GroupFlattener.prototype=new LogItemVisitor();GroupFlattener.prototype.visitGroup=function(group){this.visitChildren(group);};GroupFlattener.prototype.visitLogEntry=function(logEntry){this.logEntriesAndSeparators.push(logEntry);};GroupFlattener.prototype.visitSeparator=function(separator){this.logEntriesAndSeparators.push(separator);};window.onload=function(){if(location.search){var queryBits=unescape(location.search).substr(1).split("&"),nameValueBits;for(var i=0,len=queryBits.length;i<len;i++){nameValueBits=queryBits[i].split("=");if(nameValueBits[0]=="log4javascript_domain"){document.domain=nameValueBits[1];break;}}}
+logMainContainer=$("log");if(isIePre7){addClass(logMainContainer,"oldIe");}
+rootGroup=new Group("root",true);rootGroup.render();currentGroup=rootGroup;setCommandInputWidth();setLogContainerHeight();toggleLoggingEnabled();toggleSearchEnabled();toggleSearchFilter();toggleSearchHighlight();applyFilters();checkAllLevels();toggleWrap();toggleNewestAtTop();toggleScrollToLatest();renderQueuedLogItems();loaded=true;$("command").value="";$("command").autocomplete="off";$("command").onkeydown=function(evt){evt=getEvent(evt);if(evt.keyCode==10||evt.keyCode==13){evalCommandLine();stopPropagation(evt);}else if(evt.keyCode==27){this.value="";this.focus();}else if(evt.keyCode==38&&commandHistory.length>0){currentCommandIndex=Math.max(0,currentCommandIndex-1);this.value=commandHistory[currentCommandIndex];moveCaretToEnd(this);}else if(evt.keyCode==40&&commandHistory.length>0){currentCommandIndex=Math.min(commandHistory.length-1,currentCommandIndex+1);this.value=commandHistory[currentCommandIndex];moveCaretToEnd(this);}};$("command").onkeypress=function(evt){evt=getEvent(evt);if(evt.keyCode==38&&commandHistory.length>0&&evt.preventDefault){evt.preventDefault();}};$("command").onkeyup=function(evt){evt=getEvent(evt);if(evt.keyCode==27&&evt.preventDefault){evt.preventDefault();this.focus();}};document.onkeydown=function keyEventHandler(evt){evt=getEvent(evt);switch(evt.keyCode){case 69:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){evalLastCommand();cancelKeyEvent(evt);return false;}
+break;case 75:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){focusSearch();cancelKeyEvent(evt);return false;}
+break;case 40:case 76:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){focusCommandLine();cancelKeyEvent(evt);return false;}
+break;}};setTimeout(setLogContainerHeight,20);setShowCommandLine(showCommandLine);doSearch();};window.onunload=function(){if(mainWindowExists()){appender.unload();}
+appender=null;};function toggleLoggingEnabled(){setLoggingEnabled($("enableLogging").checked);}
+function setLoggingEnabled(enable){loggingEnabled=enable;}
+var appender=null;function setAppender(appenderParam){appender=appenderParam;}
+function setShowCloseButton(showCloseButton){$("closeButton").style.display=showCloseButton?"inline":"none";}
+function setShowHideButton(showHideButton){$("hideButton").style.display=showHideButton?"inline":"none";}
+var newestAtTop=false;function LogItemContentReverser(){}
+LogItemContentReverser.prototype=new LogItemVisitor();LogItemContentReverser.prototype.visitGroup=function(group){group.reverseChildren();this.visitChildren(group);};function setNewestAtTop(isNewestAtTop){var oldNewestAtTop=newestAtTop;var i,iLen,j,jLen;newestAtTop=Boolean(isNewestAtTop);if(oldNewestAtTop!=newestAtTop){var visitor=new LogItemContentReverser();rootGroup.accept(visitor);if(currentSearch){var currentMatch=currentSearch.matches[currentMatchIndex];var matchIndex=0;var matches=[];var actOnLogEntry=function(logEntry){var logEntryMatches=logEntry.getSearchMatches();for(j=0,jLen=logEntryMatches.length;j<jLen;j++){matches[matchIndex]=logEntryMatches[j];if(currentMatch&&logEntryMatches[j].equals(currentMatch)){currentMatchIndex=matchIndex;}
+matchIndex++;}};if(newestAtTop){for(i=logEntries.length-1;i>=0;i--){actOnLogEntry(logEntries[i]);}}else{for(i=0,iLen=logEntries.length;i<iLen;i++){actOnLogEntry(logEntries[i]);}}
+currentSearch.matches=matches;if(currentMatch){currentMatch.setCurrent();}}else if(scrollToLatest){doScrollToLatest();}}
+$("newestAtTop").checked=isNewestAtTop;}
+function toggleNewestAtTop(){var isNewestAtTop=$("newestAtTop").checked;setNewestAtTop(isNewestAtTop);}
+var scrollToLatest=true;function setScrollToLatest(isScrollToLatest){scrollToLatest=isScrollToLatest;if(scrollToLatest){doScrollToLatest();}
+$("scrollToLatest").checked=isScrollToLatest;}
+function toggleScrollToLatest(){var isScrollToLatest=$("scrollToLatest").checked;setScrollToLatest(isScrollToLatest);}
+function doScrollToLatest(){var l=logMainContainer;if(typeof l.scrollTop!="undefined"){if(newestAtTop){l.scrollTop=0;}else{var latestLogEntry=l.lastChild;if(latestLogEntry){l.scrollTop=l.scrollHeight;}}}}
+var closeIfOpenerCloses=true;function setCloseIfOpenerCloses(isCloseIfOpenerCloses){closeIfOpenerCloses=isCloseIfOpenerCloses;}
+var maxMessages=null;function setMaxMessages(max){maxMessages=max;pruneLogEntries();}
+var showCommandLine=false;function setShowCommandLine(isShowCommandLine){showCommandLine=isShowCommandLine;if(loaded){$("commandLine").style.display=showCommandLine?"block":"none";setCommandInputWidth();setLogContainerHeight();}}
+function focusCommandLine(){if(loaded){$("command").focus();}}
+function focusSearch(){if(loaded){$("searchBox").focus();}}
+function getLogItems(){var items=[];for(var i=0,len=logItems.length;i<len;i++){logItems[i].serialize(items);}
+return items;}
+function setLogItems(items){var loggingReallyEnabled=loggingEnabled;loggingEnabled=true;for(var i=0,len=items.length;i<len;i++){switch(items[i][0]){case LogItem.serializedItemKeys.LOG_ENTRY:log(items[i][1],items[i][2]);break;case LogItem.serializedItemKeys.GROUP_START:group(items[i][1]);break;case LogItem.serializedItemKeys.GROUP_END:groupEnd();break;}}
+loggingEnabled=loggingReallyEnabled;}
+function log(logLevel,formattedMessage){if(loggingEnabled){var logEntry=new LogEntry(logLevel,formattedMessage);logEntries.push(logEntry);logEntriesAndSeparators.push(logEntry);logItems.push(logEntry);currentGroup.addChild(logEntry);if(loaded){if(logQueuedEventsTimer!==null){clearTimeout(logQueuedEventsTimer);}
+logQueuedEventsTimer=setTimeout(renderQueuedLogItems,renderDelay);unrenderedLogItemsExist=true;}}}
+function renderQueuedLogItems(){logQueuedEventsTimer=null;var pruned=pruneLogEntries();var initiallyHasMatches=currentSearch?currentSearch.hasMatches():false;for(var i=0,len=logItems.length;i<len;i++){if(!logItems[i].rendered){logItems[i].render();logItems[i].appendToLog();if(currentSearch&&(logItems[i]instanceof LogEntry)){currentSearch.applyTo(logItems[i]);}}}
+if(currentSearch){if(pruned){if(currentSearch.hasVisibleMatches()){if(currentMatchIndex===null){setCurrentMatchIndex(0);}
+displayMatches();}else{displayNoMatches();}}else if(!initiallyHasMatches&&currentSearch.hasVisibleMatches()){setCurrentMatchIndex(0);displayMatches();}}
+if(scrollToLatest){doScrollToLatest();}
+unrenderedLogItemsExist=false;}
+function pruneLogEntries(){if((maxMessages!==null)&&(logEntriesAndSeparators.length>maxMessages)){var numberToDelete=logEntriesAndSeparators.length-maxMessages;var prunedLogEntries=logEntriesAndSeparators.slice(0,numberToDelete);if(currentSearch){currentSearch.removeMatches(prunedLogEntries);}
+var group;for(var i=0;i<numberToDelete;i++){group=logEntriesAndSeparators[i].group;array_remove(logItems,logEntriesAndSeparators[i]);array_remove(logEntries,logEntriesAndSeparators[i]);logEntriesAndSeparators[i].remove(true,true);if(group.children.length===0&&group!==currentGroup&&group!==rootGroup){array_remove(logItems,group);group.remove(true,true);}}
+logEntriesAndSeparators=array_removeFromStart(logEntriesAndSeparators,numberToDelete);return true;}
+return false;}
+function group(name,startExpanded){if(loggingEnabled){initiallyExpanded=(typeof startExpanded==="undefined")?true:Boolean(startExpanded);var newGroup=new Group(name,false,initiallyExpanded);currentGroup.addChild(newGroup);currentGroup=newGroup;logItems.push(newGroup);if(loaded){if(logQueuedEventsTimer!==null){clearTimeout(logQueuedEventsTimer);}
+logQueuedEventsTimer=setTimeout(renderQueuedLogItems,renderDelay);unrenderedLogItemsExist=true;}}}
+function groupEnd(){currentGroup=(currentGroup===rootGroup)?rootGroup:currentGroup.group;}
+function mainPageReloaded(){currentGroup=rootGroup;var separator=new Separator();logEntriesAndSeparators.push(separator);logItems.push(separator);currentGroup.addChild(separator);}
+function closeWindow(){if(appender&&mainWindowExists()){appender.close(true);}else{window.close();}}
+function hide(){if(appender&&mainWindowExists()){appender.hide();}}
+var mainWindow=window;var windowId="log4javascriptConsoleWindow_"+new Date().getTime()+"_"+(""+Math.random()).substr(2);function setMainWindow(win){mainWindow=win;mainWindow[windowId]=window;if(opener&&closeIfOpenerCloses){pollOpener();}}
+function pollOpener(){if(closeIfOpenerCloses){if(mainWindowExists()){setTimeout(pollOpener,500);}else{closeWindow();}}}
+function mainWindowExists(){try{return(mainWindow&&!mainWindow.closed&&mainWindow[windowId]==window);}catch(ex){}
+return false;}
+var logLevels=["TRACE","DEBUG","INFO","WARN","ERROR","FATAL"];function getCheckBox(logLevel){return $("switch_"+logLevel);}
+function getIeWrappedLogContainer(){return $("log_wrapped");}
+function getIeUnwrappedLogContainer(){return $("log_unwrapped");}
+function applyFilters(){for(var i=0;i<logLevels.length;i++){if(getCheckBox(logLevels[i]).checked){addClass(logMainContainer,logLevels[i]);}else{removeClass(logMainContainer,logLevels[i]);}}
+updateSearchFromFilters();}
+function toggleAllLevels(){var turnOn=$("switch_ALL").checked;for(var i=0;i<logLevels.length;i++){getCheckBox(logLevels[i]).checked=turnOn;if(turnOn){addClass(logMainContainer,logLevels[i]);}else{removeClass(logMainContainer,logLevels[i]);}}}
+function checkAllLevels(){for(var i=0;i<logLevels.length;i++){if(!getCheckBox(logLevels[i]).checked){getCheckBox("ALL").checked=false;return;}}
+getCheckBox("ALL").checked=true;}
+function clearLog(){rootGroup.clear();currentGroup=rootGroup;logEntries=[];logItems=[];logEntriesAndSeparators=[];doSearch();}
+function toggleWrap(){var enable=$("wrap").checked;if(enable){addClass(logMainContainer,"wrap");}else{removeClass(logMainContainer,"wrap");}
+refreshCurrentMatch();}
+var searchTimer=null;function scheduleSearch(){try{clearTimeout(searchTimer);}catch(ex){}
+searchTimer=setTimeout(doSearch,500);}
+function Search(searchTerm,isRegex,searchRegex,isCaseSensitive){this.searchTerm=searchTerm;this.isRegex=isRegex;this.searchRegex=searchRegex;this.isCaseSensitive=isCaseSensitive;this.matches=[];}
+Search.prototype={hasMatches:function(){return this.matches.length>0;},hasVisibleMatches:function(){if(this.hasMatches()){for(var i=0;i<this.matches.length;i++){if(this.matches[i].isVisible()){return true;}}}
+return false;},match:function(logEntry){var entryText=String(logEntry.formattedMessage);var matchesSearch=false;if(this.isRegex){matchesSearch=this.searchRegex.test(entryText);}else if(this.isCaseSensitive){matchesSearch=(entryText.indexOf(this.searchTerm)>-1);}else{matchesSearch=(entryText.toLowerCase().indexOf(this.searchTerm.toLowerCase())>-1);}
+return matchesSearch;},getNextVisibleMatchIndex:function(){for(var i=currentMatchIndex+1;i<this.matches.length;i++){if(this.matches[i].isVisible()){return i;}}
+for(i=0;i<=currentMatchIndex;i++){if(this.matches[i].isVisible()){return i;}}
+return-1;},getPreviousVisibleMatchIndex:function(){for(var i=currentMatchIndex-1;i>=0;i--){if(this.matches[i].isVisible()){return i;}}
+for(var i=this.matches.length-1;i>=currentMatchIndex;i--){if(this.matches[i].isVisible()){return i;}}
+return-1;},applyTo:function(logEntry){var doesMatch=this.match(logEntry);if(doesMatch){logEntry.group.expand();logEntry.setSearchMatch(true);var logEntryContent;var wrappedLogEntryContent;var searchTermReplacementStartTag="<span class=\"searchterm\">";var searchTermReplacementEndTag="<"+"/span>";var preTagName=isIe?"pre":"span";var preStartTag="<"+preTagName+" class=\"pre\">";var preEndTag="<"+"/"+preTagName+">";var startIndex=0;var searchIndex,matchedText,textBeforeMatch;if(this.isRegex){var flags=this.isCaseSensitive?"g":"gi";var capturingRegex=new RegExp("("+this.searchRegex.source+")",flags);var rnd=(""+Math.random()).substr(2);var startToken="%%s"+rnd+"%%";var endToken="%%e"+rnd+"%%";logEntryContent=logEntry.formattedMessage.replace(capturingRegex,startToken+"$1"+endToken);logEntryContent=escapeHtml(logEntryContent);var result;var searchString=logEntryContent;logEntryContent="";wrappedLogEntryContent="";while((searchIndex=searchString.indexOf(startToken,startIndex))>-1){var endTokenIndex=searchString.indexOf(endToken,searchIndex);matchedText=searchString.substring(searchIndex+startToken.length,endTokenIndex);textBeforeMatch=searchString.substring(startIndex,searchIndex);logEntryContent+=preStartTag+textBeforeMatch+preEndTag;logEntryContent+=searchTermReplacementStartTag+preStartTag+matchedText+
+preEndTag+searchTermReplacementEndTag;if(isIe){wrappedLogEntryContent+=textBeforeMatch+searchTermReplacementStartTag+
+matchedText+searchTermReplacementEndTag;}
+startIndex=endTokenIndex+endToken.length;}
+logEntryContent+=preStartTag+searchString.substr(startIndex)+preEndTag;if(isIe){wrappedLogEntryContent+=searchString.substr(startIndex);}}else{logEntryContent="";wrappedLogEntryContent="";var searchTermReplacementLength=searchTermReplacementStartTag.length+
+this.searchTerm.length+searchTermReplacementEndTag.length;var searchTermLength=this.searchTerm.length;var searchTermLowerCase=this.searchTerm.toLowerCase();var logTextLowerCase=logEntry.formattedMessage.toLowerCase();while((searchIndex=logTextLowerCase.indexOf(searchTermLowerCase,startIndex))>-1){matchedText=escapeHtml(logEntry.formattedMessage.substr(searchIndex,this.searchTerm.length));textBeforeMatch=escapeHtml(logEntry.formattedMessage.substring(startIndex,searchIndex));var searchTermReplacement=searchTermReplacementStartTag+
+preStartTag+matchedText+preEndTag+searchTermReplacementEndTag;logEntryContent+=preStartTag+textBeforeMatch+preEndTag+searchTermReplacement;if(isIe){wrappedLogEntryContent+=textBeforeMatch+searchTermReplacementStartTag+
+matchedText+searchTermReplacementEndTag;}
+startIndex=searchIndex+searchTermLength;}
+var textAfterLastMatch=escapeHtml(logEntry.formattedMessage.substr(startIndex));logEntryContent+=preStartTag+textAfterLastMatch+preEndTag;if(isIe){wrappedLogEntryContent+=textAfterLastMatch;}}
+logEntry.setContent(logEntryContent,wrappedLogEntryContent);var logEntryMatches=logEntry.getSearchMatches();this.matches=this.matches.concat(logEntryMatches);}else{logEntry.setSearchMatch(false);logEntry.setContent(logEntry.formattedMessage,logEntry.formattedMessage);}
+return doesMatch;},removeMatches:function(logEntries){var matchesToRemoveCount=0;var currentMatchRemoved=false;var matchesToRemove=[];var i,iLen,j,jLen;for(i=0,iLen=this.matches.length;i<iLen;i++){for(j=0,jLen=logEntries.length;j<jLen;j++){if(this.matches[i].belongsTo(logEntries[j])){matchesToRemove.push(this.matches[i]);if(i===currentMatchIndex){currentMatchRemoved=true;}}}}
+var newMatch=currentMatchRemoved?null:this.matches[currentMatchIndex];if(currentMatchRemoved){for(i=currentMatchIndex,iLen=this.matches.length;i<iLen;i++){if(this.matches[i].isVisible()&&!array_contains(matchesToRemove,this.matches[i])){newMatch=this.matches[i];break;}}}
+for(i=0,iLen=matchesToRemove.length;i<iLen;i++){array_remove(this.matches,matchesToRemove[i]);matchesToRemove[i].remove();}
+if(this.hasVisibleMatches()){if(newMatch===null){setCurrentMatchIndex(0);}else{var newMatchIndex=0;for(i=0,iLen=this.matches.length;i<iLen;i++){if(newMatch===this.matches[i]){newMatchIndex=i;break;}}
+setCurrentMatchIndex(newMatchIndex);}}else{currentMatchIndex=null;displayNoMatches();}}};function getPageOffsetTop(el,container){var currentEl=el;var y=0;while(currentEl&&currentEl!=container){y+=currentEl.offsetTop;currentEl=currentEl.offsetParent;}
+return y;}
+function scrollIntoView(el){var logContainer=logMainContainer;if(!$("wrap").checked){var logContainerLeft=logContainer.scrollLeft;var logContainerRight=logContainerLeft+logContainer.offsetWidth;var elLeft=el.offsetLeft;var elRight=elLeft+el.offsetWidth;if(elLeft<logContainerLeft||elRight>logContainerRight){logContainer.scrollLeft=elLeft-(logContainer.offsetWidth-el.offsetWidth)/2;}}
+var logContainerTop=logContainer.scrollTop;var logContainerBottom=logContainerTop+logContainer.offsetHeight;var elTop=getPageOffsetTop(el)-getToolBarsHeight();var elBottom=elTop+el.offsetHeight;if(elTop<logContainerTop||elBottom>logContainerBottom){logContainer.scrollTop=elTop-(logContainer.offsetHeight-el.offsetHeight)/2;}}
+function Match(logEntryLevel,spanInMainDiv,spanInUnwrappedPre,spanInWrappedDiv){this.logEntryLevel=logEntryLevel;this.spanInMainDiv=spanInMainDiv;if(isIe){this.spanInUnwrappedPre=spanInUnwrappedPre;this.spanInWrappedDiv=spanInWrappedDiv;}
+this.mainSpan=isIe?spanInUnwrappedPre:spanInMainDiv;}
+Match.prototype={equals:function(match){return this.mainSpan===match.mainSpan;},setCurrent:function(){if(isIe){addClass(this.spanInUnwrappedPre,"currentmatch");addClass(this.spanInWrappedDiv,"currentmatch");var elementToScroll=$("wrap").checked?this.spanInWrappedDiv:this.spanInUnwrappedPre;scrollIntoView(elementToScroll);}else{addClass(this.spanInMainDiv,"currentmatch");scrollIntoView(this.spanInMainDiv);}},belongsTo:function(logEntry){if(isIe){return isDescendant(this.spanInUnwrappedPre,logEntry.unwrappedPre);}else{return isDescendant(this.spanInMainDiv,logEntry.mainDiv);}},setNotCurrent:function(){if(isIe){removeClass(this.spanInUnwrappedPre,"currentmatch");removeClass(this.spanInWrappedDiv,"currentmatch");}else{removeClass(this.spanInMainDiv,"currentmatch");}},isOrphan:function(){return isOrphan(this.mainSpan);},isVisible:function(){return getCheckBox(this.logEntryLevel).checked;},remove:function(){if(isIe){this.spanInUnwrappedPre=null;this.spanInWrappedDiv=null;}else{this.spanInMainDiv=null;}}};var currentSearch=null;var currentMatchIndex=null;function doSearch(){var searchBox=$("searchBox");var searchTerm=searchBox.value;var isRegex=$("searchRegex").checked;var isCaseSensitive=$("searchCaseSensitive").checked;var i;if(searchTerm===""){$("searchReset").disabled=true;$("searchNav").style.display="none";removeClass(document.body,"searching");removeClass(searchBox,"hasmatches");removeClass(searchBox,"nomatches");for(i=0;i<logEntries.length;i++){logEntries[i].clearSearch();logEntries[i].setContent(logEntries[i].formattedMessage,logEntries[i].formattedMessage);}
+currentSearch=null;setLogContainerHeight();}else{$("searchReset").disabled=false;$("searchNav").style.display="block";var searchRegex;var regexValid;if(isRegex){try{searchRegex=isCaseSensitive?new RegExp(searchTerm,"g"):new RegExp(searchTerm,"gi");regexValid=true;replaceClass(searchBox,"validregex","invalidregex");searchBox.title="Valid regex";}catch(ex){regexValid=false;replaceClass(searchBox,"invalidregex","validregex");searchBox.title="Invalid regex: "+(ex.message?ex.message:(ex.description?ex.description:"unknown error"));return;}}else{searchBox.title="";removeClass(searchBox,"validregex");removeClass(searchBox,"invalidregex");}
+addClass(document.body,"searching");currentSearch=new Search(searchTerm,isRegex,searchRegex,isCaseSensitive);for(i=0;i<logEntries.length;i++){currentSearch.applyTo(logEntries[i]);}
+setLogContainerHeight();if(currentSearch.hasVisibleMatches()){setCurrentMatchIndex(0);displayMatches();}else{displayNoMatches();}}}
+function updateSearchFromFilters(){if(currentSearch){if(currentSearch.hasMatches()){if(currentMatchIndex===null){currentMatchIndex=0;}
+var currentMatch=currentSearch.matches[currentMatchIndex];if(currentMatch.isVisible()){displayMatches();setCurrentMatchIndex(currentMatchIndex);}else{currentMatch.setNotCurrent();var nextVisibleMatchIndex=currentSearch.getNextVisibleMatchIndex();if(nextVisibleMatchIndex>-1){setCurrentMatchIndex(nextVisibleMatchIndex);displayMatches();}else{displayNoMatches();}}}else{displayNoMatches();}}}
+function refreshCurrentMatch(){if(currentSearch&&currentSearch.hasVisibleMatches()){setCurrentMatchIndex(currentMatchIndex);}}
+function displayMatches(){replaceClass($("searchBox"),"hasmatches","nomatches");$("searchBox").title=""+currentSearch.matches.length+" matches found";$("searchNav").style.display="block";setLogContainerHeight();}
+function displayNoMatches(){replaceClass($("searchBox"),"nomatches","hasmatches");$("searchBox").title="No matches found";$("searchNav").style.display="none";setLogContainerHeight();}
+function toggleSearchEnabled(enable){enable=(typeof enable=="undefined")?!$("searchDisable").checked:enable;$("searchBox").disabled=!enable;$("searchReset").disabled=!enable;$("searchRegex").disabled=!enable;$("searchNext").disabled=!enable;$("searchPrevious").disabled=!enable;$("searchCaseSensitive").disabled=!enable;$("searchNav").style.display=(enable&&($("searchBox").value!=="")&&currentSearch&&currentSearch.hasVisibleMatches())?"block":"none";if(enable){removeClass($("search"),"greyedout");addClass(document.body,"searching");if($("searchHighlight").checked){addClass(logMainContainer,"searchhighlight");}else{removeClass(logMainContainer,"searchhighlight");}
+if($("searchFilter").checked){addClass(logMainContainer,"searchfilter");}else{removeClass(logMainContainer,"searchfilter");}
+$("searchDisable").checked=!enable;}else{addClass($("search"),"greyedout");removeClass(document.body,"searching");removeClass(logMainContainer,"searchhighlight");removeClass(logMainContainer,"searchfilter");}
+setLogContainerHeight();}
+function toggleSearchFilter(){var enable=$("searchFilter").checked;if(enable){addClass(logMainContainer,"searchfilter");}else{removeClass(logMainContainer,"searchfilter");}
+refreshCurrentMatch();}
+function toggleSearchHighlight(){var enable=$("searchHighlight").checked;if(enable){addClass(logMainContainer,"searchhighlight");}else{removeClass(logMainContainer,"searchhighlight");}}
+function clearSearch(){$("searchBox").value="";doSearch();}
+function searchNext(){if(currentSearch!==null&&currentMatchIndex!==null){currentSearch.matches[currentMatchIndex].setNotCurrent();var nextMatchIndex=currentSearch.getNextVisibleMatchIndex();if(nextMatchIndex>currentMatchIndex||confirm("Reached the end of the page. Start from the top?")){setCurrentMatchIndex(nextMatchIndex);}}}
+function searchPrevious(){if(currentSearch!==null&&currentMatchIndex!==null){currentSearch.matches[currentMatchIndex].setNotCurrent();var previousMatchIndex=currentSearch.getPreviousVisibleMatchIndex();if(previousMatchIndex<currentMatchIndex||confirm("Reached the start of the page. Continue from the bottom?")){setCurrentMatchIndex(previousMatchIndex);}}}
+function setCurrentMatchIndex(index){currentMatchIndex=index;currentSearch.matches[currentMatchIndex].setCurrent();}
+function addClass(el,cssClass){if(!hasClass(el,cssClass)){if(el.className){el.className+=" "+cssClass;}else{el.className=cssClass;}}}
+function hasClass(el,cssClass){if(el.className){var classNames=el.className.split(" ");return array_contains(classNames,cssClass);}
+return false;}
+function removeClass(el,cssClass){if(hasClass(el,cssClass)){var existingClasses=el.className.split(" ");var newClasses=[];for(var i=0,len=existingClasses.length;i<len;i++){if(existingClasses[i]!=cssClass){newClasses[newClasses.length]=existingClasses[i];}}
+el.className=newClasses.join(" ");}}
+function replaceClass(el,newCssClass,oldCssClass){removeClass(el,oldCssClass);addClass(el,newCssClass);}
+function getElementsByClass(el,cssClass,tagName){var elements=el.getElementsByTagName(tagName);var matches=[];for(var i=0,len=elements.length;i<len;i++){if(hasClass(elements[i],cssClass)){matches.push(elements[i]);}}
+return matches;}
+function $(id){return document.getElementById(id);}
+function isDescendant(node,ancestorNode){while(node!=null){if(node===ancestorNode){return true;}
+node=node.parentNode;}
+return false;}
+function isOrphan(node){var currentNode=node;while(currentNode){if(currentNode==document.body){return false;}
+currentNode=currentNode.parentNode;}
+return true;}
+function escapeHtml(str){return str.replace(/&/g,"&amp;").replace(/[<]/g,"&lt;").replace(/>/g,"&gt;");}
+function getWindowWidth(){if(window.innerWidth){return window.innerWidth;}else if(document.documentElement&&document.documentElement.clientWidth){return document.documentElement.clientWidth;}else if(document.body){return document.body.clientWidth;}
+return 0;}
+function getWindowHeight(){if(window.innerHeight){return window.innerHeight;}else if(document.documentElement&&document.documentElement.clientHeight){return document.documentElement.clientHeight;}else if(document.body){return document.body.clientHeight;}
+return 0;}
+function getToolBarsHeight(){return $("switches").offsetHeight;}
+function getChromeHeight(){var height=getToolBarsHeight();if(showCommandLine){height+=$("commandLine").offsetHeight;}
+return height;}
+function setLogContainerHeight(){if(logMainContainer){var windowHeight=getWindowHeight();$("body").style.height=getWindowHeight()+"px";logMainContainer.style.height=""+
+Math.max(0,windowHeight-getChromeHeight())+"px";}}
+function setCommandInputWidth(){if(showCommandLine){$("command").style.width=""+Math.max(0,$("commandLineContainer").offsetWidth-
+($("evaluateButton").offsetWidth+13))+"px";}}
+window.onresize=function(){setCommandInputWidth();setLogContainerHeight();};if(!Array.prototype.push){Array.prototype.push=function(){for(var i=0,len=arguments.length;i<len;i++){this[this.length]=arguments[i];}
+return this.length;};}
+if(!Array.prototype.pop){Array.prototype.pop=function(){if(this.length>0){var val=this[this.length-1];this.length=this.length-1;return val;}};}
+if(!Array.prototype.shift){Array.prototype.shift=function(){if(this.length>0){var firstItem=this[0];for(var i=0,len=this.length-1;i<len;i++){this[i]=this[i+1];}
+this.length=this.length-1;return firstItem;}};}
+if(!Array.prototype.splice){Array.prototype.splice=function(startIndex,deleteCount){var itemsAfterDeleted=this.slice(startIndex+deleteCount);var itemsDeleted=this.slice(startIndex,startIndex+deleteCount);this.length=startIndex;var argumentsArray=[];for(var i=0,len=arguments.length;i<len;i++){argumentsArray[i]=arguments[i];}
+var itemsToAppend=(argumentsArray.length>2)?itemsAfterDeleted=argumentsArray.slice(2).concat(itemsAfterDeleted):itemsAfterDeleted;for(i=0,len=itemsToAppend.length;i<len;i++){this.push(itemsToAppend[i]);}
+return itemsDeleted;};}
+function array_remove(arr,val){var index=-1;for(var i=0,len=arr.length;i<len;i++){if(arr[i]===val){index=i;break;}}
+if(index>=0){arr.splice(index,1);return index;}else{return false;}}
+function array_removeFromStart(array,numberToRemove){if(Array.prototype.splice){array.splice(0,numberToRemove);}else{for(var i=numberToRemove,len=array.length;i<len;i++){array[i-numberToRemove]=array[i];}
+array.length=array.length-numberToRemove;}
+return array;}
+function array_contains(arr,val){for(var i=0,len=arr.length;i<len;i++){if(arr[i]==val){return true;}}
+return false;}
+function getErrorMessage(ex){if(ex.message){return ex.message;}else if(ex.description){return ex.description;}
+return""+ex;}
+function moveCaretToEnd(input){if(input.setSelectionRange){input.focus();var length=input.value.length;input.setSelectionRange(length,length);}else if(input.createTextRange){var range=input.createTextRange();range.collapse(false);range.select();}
+input.focus();}
+function stopPropagation(evt){if(evt.stopPropagation){evt.stopPropagation();}else if(typeof evt.cancelBubble!="undefined"){evt.cancelBubble=true;}}
+function getEvent(evt){return evt?evt:event;}
+function getTarget(evt){return evt.target?evt.target:evt.srcElement;}
+function getRelatedTarget(evt){if(evt.relatedTarget){return evt.relatedTarget;}else if(evt.srcElement){switch(evt.type){case"mouseover":return evt.fromElement;case"mouseout":return evt.toElement;default:return evt.srcElement;}}}
+function cancelKeyEvent(evt){evt.returnValue=false;stopPropagation(evt);}
+function evalCommandLine(){var expr=$("command").value;evalCommand(expr);$("command").value="";}
+function evalLastCommand(){if(lastCommand!=null){evalCommand(lastCommand);}}
+var lastCommand=null;var commandHistory=[];var currentCommandIndex=0;function evalCommand(expr){if(appender){appender.evalCommandAndAppend(expr);}else{var prefix=">>> "+expr+"\r\n";try{log("INFO",prefix+eval(expr));}catch(ex){log("ERROR",prefix+"Error: "+getErrorMessage(ex));}}
+if(expr!=commandHistory[commandHistory.length-1]){commandHistory.push(expr);if(appender){appender.storeCommandHistory(commandHistory);}}
+currentCommandIndex=(expr==commandHistory[currentCommandIndex])?currentCommandIndex+1:commandHistory.length;lastCommand=expr;}
+//]]>
+</script>
+<style type="text/css">
+body{background-color:white;color:black;padding:0;margin:0;font-family:tahoma,verdana,arial,helvetica,sans-serif;overflow:hidden}div#switchesContainer input{margin-bottom:0}div.toolbar{border-top:solid #ffffff 1px;border-bottom:solid #aca899 1px;background-color:#f1efe7;padding:3px 5px;font-size:68.75%}div.toolbar,div#search input{font-family:tahoma,verdana,arial,helvetica,sans-serif}div.toolbar input.button{padding:0 5px;font-size:100%}div.toolbar input.hidden{display:none}div#switches input#clearButton{margin-left:20px}div#levels label{font-weight:bold}div#levels label,div#options label{margin-right:5px}div#levels label#wrapLabel{font-weight:normal}div#search label{margin-right:10px}div#search label.searchboxlabel{margin-right:0}div#search input{font-size:100%}div#search input.validregex{color:green}div#search input.invalidregex{color:red}div#search input.nomatches{color:white;background-color:#ff6666}div#search input.nomatches{color:white;background-color:#ff6666}div#searchNav{display:none}div#commandLine{display:none}div#commandLine input#command{font-size:100%;font-family:Courier New,Courier}div#commandLine input#evaluateButton{}*.greyedout{color:gray !important;border-color:gray !important}*.greyedout *.alwaysenabled{color:black}*.unselectable{-khtml-user-select:none;-moz-user-select:none;user-select:none}div#log{font-family:Courier New,Courier;font-size:75%;width:100%;overflow:auto;clear:both;position:relative}div.group{border-color:#cccccc;border-style:solid;border-width:1px 0 1px 1px;overflow:visible}div.oldIe div.group,div.oldIe div.group *,div.oldIe *.logentry{height:1%}div.group div.groupheading span.expander{border:solid black 1px;font-family:Courier New,Courier;font-size:0.833em;background-color:#eeeeee;position:relative;top:-1px;color:black;padding:0 2px;cursor:pointer;cursor:hand;height:1%}div.group div.groupcontent{margin-left:10px;padding-bottom:2px;overflow:visible}div.group div.expanded{display:block}div.group div.collapsed{display:none}*.logentry{overflow:visible;display:none;white-space:pre}span.pre{white-space:pre}pre.unwrapped{display:inline !important}pre.unwrapped pre.pre,div.wrapped pre.pre{display:inline}div.wrapped pre.pre{white-space:normal}div.wrapped{display:none}body.searching *.logentry span.currentmatch{color:white !important;background-color:green !important}body.searching div.searchhighlight *.logentry span.searchterm{color:black;background-color:yellow}div.wrap *.logentry{white-space:normal !important;border-width:0 0 1px 0;border-color:#dddddd;border-style:dotted}div.wrap #log_wrapped,#log_unwrapped{display:block}div.wrap #log_unwrapped,#log_wrapped{display:none}div.wrap *.logentry span.pre{overflow:visible;white-space:normal}div.wrap *.logentry pre.unwrapped{display:none}div.wrap *.logentry span.wrapped{display:inline}div.searchfilter *.searchnonmatch{display:none !important}div#log *.TRACE,label#label_TRACE{color:#666666}div#log *.DEBUG,label#label_DEBUG{color:green}div#log *.INFO,label#label_INFO{color:#000099}div#log *.WARN,label#label_WARN{color:#999900}div#log *.ERROR,label#label_ERROR{color:red}div#log *.FATAL,label#label_FATAL{color:#660066}div.TRACE#log *.TRACE,div.DEBUG#log *.DEBUG,div.INFO#log *.INFO,div.WARN#log *.WARN,div.ERROR#log *.ERROR,div.FATAL#log *.FATAL{display:block}div#log div.separator{background-color:#cccccc;margin:5px 0;line-height:1px}
+</style>
+</head>
+<body id="body">
+<div id="switchesContainer">
+<div id="switches">
+<div id="levels" class="toolbar">
+Filters:
+<input type="checkbox" id="switch_TRACE" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide trace messages" /><label for="switch_TRACE" id="label_TRACE">trace</label>
+<input type="checkbox" id="switch_DEBUG" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide debug messages" /><label for="switch_DEBUG" id="label_DEBUG">debug</label>
+<input type="checkbox" id="switch_INFO" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide info messages" /><label for="switch_INFO" id="label_INFO">info</label>
+<input type="checkbox" id="switch_WARN" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide warn messages" /><label for="switch_WARN" id="label_WARN">warn</label>
+<input type="checkbox" id="switch_ERROR" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide error messages" /><label for="switch_ERROR" id="label_ERROR">error</label>
+<input type="checkbox" id="switch_FATAL" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide fatal messages" /><label for="switch_FATAL" id="label_FATAL">fatal</label>
+<input type="checkbox" id="switch_ALL" onclick="toggleAllLevels(); applyFilters()" checked="checked" title="Show/hide all messages" /><label for="switch_ALL" id="label_ALL">all</label>
+</div>
+<div id="search" class="toolbar">
+<label for="searchBox" class="searchboxlabel">Search:</label> <input type="text" id="searchBox" onclick="toggleSearchEnabled(true)" onkeyup="scheduleSearch()" size="20" />
+<input type="button" id="searchReset" disabled="disabled" value="Reset" onclick="clearSearch()" class="button" title="Reset the search" />
+<input type="checkbox" id="searchRegex" onclick="doSearch()" title="If checked, search is treated as a regular expression" /><label for="searchRegex">Regex</label>
+<input type="checkbox" id="searchCaseSensitive" onclick="doSearch()" title="If checked, search is case sensitive" /><label for="searchCaseSensitive">Match case</label>
+<input type="checkbox" id="searchDisable" onclick="toggleSearchEnabled()" title="Enable/disable search" /><label for="searchDisable" class="alwaysenabled">Disable</label>
+<div id="searchNav">
+<input type="button" id="searchNext" disabled="disabled" value="Next" onclick="searchNext()" class="button" title="Go to the next matching log entry" />
+<input type="button" id="searchPrevious" disabled="disabled" value="Previous" onclick="searchPrevious()" class="button" title="Go to the previous matching log entry" />
+<input type="checkbox" id="searchFilter" onclick="toggleSearchFilter()" title="If checked, non-matching log entries are filtered out" /><label for="searchFilter">Filter</label>
+<input type="checkbox" id="searchHighlight" onclick="toggleSearchHighlight()" title="Highlight matched search terms" /><label for="searchHighlight" class="alwaysenabled">Highlight all</label>
+</div>
+</div>
+<div id="options" class="toolbar">
+Options:
+<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Log</label>
+<input type="checkbox" id="wrap" onclick="toggleWrap()" title="Enable / disable word wrap" /><label for="wrap" id="wrapLabel">Wrap</label>
+<input type="checkbox" id="newestAtTop" onclick="toggleNewestAtTop()" title="If checked, causes newest messages to appear at the top" /><label for="newestAtTop" id="newestAtTopLabel">Newest at the top</label>
+<input type="checkbox" id="scrollToLatest" onclick="toggleScrollToLatest()" checked="checked" title="If checked, window automatically scrolls to a new message when it is added" /><label for="scrollToLatest" id="scrollToLatestLabel">Scroll to latest</label>
+<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="button" title="Clear all log messages"  />
+<input type="button" id="hideButton" value="Hide" onclick="hide()" class="hidden button" title="Hide the console" />
+<input type="button" id="closeButton" value="Close" onclick="closeWindow()" class="hidden button" title="Close the window" />
+</div>
+</div>
+</div>
+<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>
+<div id="commandLine" class="toolbar">
+<div id="commandLineContainer">
+<input type="text" id="command" title="Enter a JavaScript command here and hit return or press 'Evaluate'" />
+<input type="button" id="evaluateButton" value="Evaluate" class="button" title="Evaluate the command" onclick="evalCommandLine()" />
+</div>
+</div>
+</body>
+</html>
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/console_uncompressed.html b/planetstack/core/static/log4javascript-1.4.6/js/console_uncompressed.html
new file mode 100644
index 0000000..55679f8
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/console_uncompressed.html
@@ -0,0 +1,2279 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+	<head>
+		<title>log4javascript</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+		<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->
+		<meta http-equiv="X-UA-Compatible" content="IE=7" />
+		<script type="text/javascript">var isIe = false, isIePre7 = false;</script>
+		<!--[if IE]><script type="text/javascript">isIe = true</script><![endif]-->
+		<!--[if lt IE 7]><script type="text/javascript">isIePre7 = true</script><![endif]-->
+		<script type="text/javascript">
+			//<![CDATA[
+			var loggingEnabled = true;
+			var logQueuedEventsTimer = null;
+			var logEntries = [];
+			var logEntriesAndSeparators = [];
+			var logItems = [];
+			var renderDelay = 100;
+			var unrenderedLogItemsExist = false;
+			var rootGroup, currentGroup = null;
+			var loaded = false;
+			var currentLogItem = null;
+			var logMainContainer;
+
+			function copyProperties(obj, props) {
+				for (var i in props) {
+					obj[i] = props[i];
+				}
+			}
+
+			/*----------------------------------------------------------------*/
+
+			function LogItem() {
+			}
+
+			LogItem.prototype = {
+				mainContainer: null,
+				wrappedContainer: null,
+				unwrappedContainer: null,
+				group: null,
+
+				appendToLog: function() {
+					for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+						this.elementContainers[i].appendToLog();
+					}
+					this.group.update();
+				},
+
+				doRemove: function(doUpdate, removeFromGroup) {
+					if (this.rendered) {
+						for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+							this.elementContainers[i].remove();
+						}
+						this.unwrappedElementContainer = null;
+						this.wrappedElementContainer = null;
+						this.mainElementContainer = null;
+					}
+					if (this.group && removeFromGroup) {
+						this.group.removeChild(this, doUpdate);
+					}
+					if (this === currentLogItem) {
+						currentLogItem = null;
+					}
+				},
+
+				remove: function(doUpdate, removeFromGroup) {
+					this.doRemove(doUpdate, removeFromGroup);
+				},
+
+				render: function() {},
+
+				accept: function(visitor) {
+					visitor.visit(this);
+				},
+
+				getUnwrappedDomContainer: function() {
+					return this.group.unwrappedElementContainer.contentDiv;
+				},
+
+				getWrappedDomContainer: function() {
+					return this.group.wrappedElementContainer.contentDiv;
+				},
+
+				getMainDomContainer: function() {
+					return this.group.mainElementContainer.contentDiv;
+				}
+			};
+
+			LogItem.serializedItemKeys = {LOG_ENTRY: 0, GROUP_START: 1, GROUP_END: 2};
+
+			/*----------------------------------------------------------------*/
+
+			function LogItemContainerElement() {
+			}
+
+			LogItemContainerElement.prototype = {
+				appendToLog: function() {
+					var insertBeforeFirst = (newestAtTop && this.containerDomNode.hasChildNodes());
+					if (insertBeforeFirst) {
+						this.containerDomNode.insertBefore(this.mainDiv, this.containerDomNode.firstChild);
+					} else {
+						this.containerDomNode.appendChild(this.mainDiv);
+					}
+				}
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function SeparatorElementContainer(containerDomNode) {
+				this.containerDomNode = containerDomNode;
+				this.mainDiv = document.createElement("div");
+				this.mainDiv.className = "separator";
+				this.mainDiv.innerHTML = "&nbsp;";
+			}
+
+			SeparatorElementContainer.prototype = new LogItemContainerElement();
+
+			SeparatorElementContainer.prototype.remove = function() {
+				this.mainDiv.parentNode.removeChild(this.mainDiv);
+				this.mainDiv = null;
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function Separator() {
+				this.rendered = false;
+			}
+
+			Separator.prototype = new LogItem();
+
+			copyProperties(Separator.prototype, {
+				render: function() {
+					var containerDomNode = this.group.contentDiv;
+					if (isIe) {
+						this.unwrappedElementContainer = new SeparatorElementContainer(this.getUnwrappedDomContainer());
+						this.wrappedElementContainer = new SeparatorElementContainer(this.getWrappedDomContainer());
+						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];
+					} else {
+						this.mainElementContainer = new SeparatorElementContainer(this.getMainDomContainer());
+						this.elementContainers = [this.mainElementContainer];
+					}
+					this.content = this.formattedMessage;
+					this.rendered = true;
+				}
+			});
+
+			/*----------------------------------------------------------------*/
+
+			function GroupElementContainer(group, containerDomNode, isRoot, isWrapped) {
+				this.group = group;
+				this.containerDomNode = containerDomNode;
+				this.isRoot = isRoot;
+				this.isWrapped = isWrapped;
+				this.expandable = false;
+
+				if (this.isRoot) {
+					if (isIe) {
+						this.contentDiv = logMainContainer.appendChild(document.createElement("div"));
+						this.contentDiv.id = this.isWrapped ? "log_wrapped" : "log_unwrapped";
+					} else {
+						this.contentDiv = logMainContainer;
+					}
+				} else {
+					var groupElementContainer = this;
+					
+					this.mainDiv = document.createElement("div");
+					this.mainDiv.className = "group";
+
+					this.headingDiv = this.mainDiv.appendChild(document.createElement("div"));
+					this.headingDiv.className = "groupheading";
+
+					this.expander = this.headingDiv.appendChild(document.createElement("span"));
+					this.expander.className = "expander unselectable greyedout";
+					this.expander.unselectable = true;
+					var expanderText = this.group.expanded ? "-" : "+";
+					this.expanderTextNode = this.expander.appendChild(document.createTextNode(expanderText));
+					
+					this.headingDiv.appendChild(document.createTextNode(" " + this.group.name));
+
+					this.contentDiv = this.mainDiv.appendChild(document.createElement("div"));
+					var contentCssClass = this.group.expanded ? "expanded" : "collapsed";
+					this.contentDiv.className = "groupcontent " + contentCssClass;
+
+					this.expander.onclick = function() {
+						if (groupElementContainer.group.expandable) {
+							groupElementContainer.group.toggleExpanded();
+						}
+					};
+				}
+			}
+
+			GroupElementContainer.prototype = new LogItemContainerElement();
+
+			copyProperties(GroupElementContainer.prototype, {
+				toggleExpanded: function() {
+					if (!this.isRoot) {
+						var oldCssClass, newCssClass, expanderText;
+						if (this.group.expanded) {
+							newCssClass = "expanded";
+							oldCssClass = "collapsed";
+							expanderText = "-";
+						} else {
+							newCssClass = "collapsed";
+							oldCssClass = "expanded";
+							expanderText = "+";
+						}
+						replaceClass(this.contentDiv, newCssClass, oldCssClass);
+						this.expanderTextNode.nodeValue = expanderText;
+					}
+				},
+
+				remove: function() {
+					if (!this.isRoot) {
+						this.headingDiv = null;
+						this.expander.onclick = null;
+						this.expander = null;
+						this.expanderTextNode = null;
+						this.contentDiv = null;
+						this.containerDomNode = null;
+						this.mainDiv.parentNode.removeChild(this.mainDiv);
+						this.mainDiv = null;
+					}
+				},
+
+				reverseChildren: function() {
+					// Invert the order of the log entries
+					var node = null;
+
+					// Remove all the log container nodes
+					var childDomNodes = [];
+					while ((node = this.contentDiv.firstChild)) {
+						this.contentDiv.removeChild(node);
+						childDomNodes.push(node);
+					}
+
+					// Put them all back in reverse order
+					while ((node = childDomNodes.pop())) {
+						this.contentDiv.appendChild(node);
+					}
+				},
+
+				update: function() {
+					if (!this.isRoot) {
+						if (this.group.expandable) {
+							removeClass(this.expander, "greyedout");
+						} else {
+							addClass(this.expander, "greyedout");
+						}
+					}
+				},
+
+				clear: function() {
+					if (this.isRoot) {
+						this.contentDiv.innerHTML = "";
+					}
+				}
+			});
+
+			/*----------------------------------------------------------------*/
+
+			function Group(name, isRoot, initiallyExpanded) {
+				this.name = name;
+				this.group = null;
+				this.isRoot = isRoot;
+				this.initiallyExpanded = initiallyExpanded;
+				this.elementContainers = [];
+				this.children = [];
+				this.expanded = initiallyExpanded;
+				this.rendered = false;
+				this.expandable = false;
+			}
+
+			Group.prototype = new LogItem();
+
+			copyProperties(Group.prototype, {
+				addChild: function(logItem) {
+					this.children.push(logItem);
+					logItem.group = this;
+				},
+
+				render: function() {
+					if (isIe) {
+						var unwrappedDomContainer, wrappedDomContainer;
+						if (this.isRoot) {
+							unwrappedDomContainer = logMainContainer;
+							wrappedDomContainer = logMainContainer;
+						} else {
+							unwrappedDomContainer = this.getUnwrappedDomContainer();
+							wrappedDomContainer = this.getWrappedDomContainer();
+						}
+						this.unwrappedElementContainer = new GroupElementContainer(this, unwrappedDomContainer, this.isRoot, false);
+						this.wrappedElementContainer = new GroupElementContainer(this, wrappedDomContainer, this.isRoot, true);
+						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];
+					} else {
+						var mainDomContainer = this.isRoot ? logMainContainer : this.getMainDomContainer();
+						this.mainElementContainer = new GroupElementContainer(this, mainDomContainer, this.isRoot, false);
+						this.elementContainers = [this.mainElementContainer];
+					}
+					this.rendered = true;
+				},
+
+				toggleExpanded: function() {
+					this.expanded = !this.expanded;
+					for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+						this.elementContainers[i].toggleExpanded();
+					}
+				},
+
+				expand: function() {
+					if (!this.expanded) {
+						this.toggleExpanded();
+					}
+				},
+
+				accept: function(visitor) {
+					visitor.visitGroup(this);
+				},
+
+				reverseChildren: function() {
+					if (this.rendered) {
+						for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+							this.elementContainers[i].reverseChildren();
+						}
+					}
+				},
+
+				update: function() {
+					var previouslyExpandable = this.expandable;
+					this.expandable = (this.children.length !== 0);
+					if (this.expandable !== previouslyExpandable) {
+						for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+							this.elementContainers[i].update();
+						}
+					}
+				},
+
+				flatten: function() {
+					var visitor = new GroupFlattener();
+					this.accept(visitor);
+					return visitor.logEntriesAndSeparators;
+				},
+
+				removeChild: function(child, doUpdate) {
+					array_remove(this.children, child);
+					child.group = null;
+					if (doUpdate) {
+						this.update();
+					}
+				},
+
+				remove: function(doUpdate, removeFromGroup) {
+					for (var i = 0, len = this.children.length; i < len; i++) {
+						this.children[i].remove(false, false);
+					}
+					this.children = [];
+					this.update();
+					if (this === currentGroup) {
+						currentGroup = this.group;
+					}
+					this.doRemove(doUpdate, removeFromGroup);
+				},
+
+				serialize: function(items) {
+					items.push([LogItem.serializedItemKeys.GROUP_START, this.name]);
+					for (var i = 0, len = this.children.length; i < len; i++) {
+						this.children[i].serialize(items);
+					}
+					if (this !== currentGroup) {
+						items.push([LogItem.serializedItemKeys.GROUP_END]);
+					}
+				},
+
+				clear: function() {
+					for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+						this.elementContainers[i].clear();
+					}
+				}
+			});
+
+			/*----------------------------------------------------------------*/
+
+			function LogEntryElementContainer() {
+			}
+
+			LogEntryElementContainer.prototype = new LogItemContainerElement();
+
+			copyProperties(LogEntryElementContainer.prototype, {
+				remove: function() {
+					this.doRemove();
+				},
+
+				doRemove: function() {
+					this.mainDiv.parentNode.removeChild(this.mainDiv);
+					this.mainDiv = null;
+					this.contentElement = null;
+					this.containerDomNode = null;
+				},
+
+				setContent: function(content, wrappedContent) {
+					if (content === this.formattedMessage) {
+						this.contentElement.innerHTML = "";
+						this.contentElement.appendChild(document.createTextNode(this.formattedMessage));
+					} else {
+						this.contentElement.innerHTML = content;
+					}
+				},
+
+				setSearchMatch: function(isMatch) {
+					var oldCssClass = isMatch ? "searchnonmatch" : "searchmatch";
+					var newCssClass = isMatch ? "searchmatch" : "searchnonmatch";
+					replaceClass(this.mainDiv, newCssClass, oldCssClass);
+				},
+
+				clearSearch: function() {
+					removeClass(this.mainDiv, "searchmatch");
+					removeClass(this.mainDiv, "searchnonmatch");
+				}
+			});
+
+			/*----------------------------------------------------------------*/
+
+			function LogEntryWrappedElementContainer(logEntry, containerDomNode) {
+				this.logEntry = logEntry;
+				this.containerDomNode = containerDomNode;
+				this.mainDiv = document.createElement("div");
+				this.mainDiv.appendChild(document.createTextNode(this.logEntry.formattedMessage));
+				this.mainDiv.className = "logentry wrapped " + this.logEntry.level;
+				this.contentElement = this.mainDiv;
+			}
+
+			LogEntryWrappedElementContainer.prototype = new LogEntryElementContainer();
+
+			LogEntryWrappedElementContainer.prototype.setContent = function(content, wrappedContent) {
+				if (content === this.formattedMessage) {
+					this.contentElement.innerHTML = "";
+					this.contentElement.appendChild(document.createTextNode(this.formattedMessage));
+				} else {
+					this.contentElement.innerHTML = wrappedContent;
+				}
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function LogEntryUnwrappedElementContainer(logEntry, containerDomNode) {
+				this.logEntry = logEntry;
+				this.containerDomNode = containerDomNode;
+				this.mainDiv = document.createElement("div");
+				this.mainDiv.className = "logentry unwrapped " + this.logEntry.level;
+				this.pre = this.mainDiv.appendChild(document.createElement("pre"));
+				this.pre.appendChild(document.createTextNode(this.logEntry.formattedMessage));
+				this.pre.className = "unwrapped";
+				this.contentElement = this.pre;
+			}
+
+			LogEntryUnwrappedElementContainer.prototype = new LogEntryElementContainer();
+
+			LogEntryUnwrappedElementContainer.prototype.remove = function() {
+				this.doRemove();
+				this.pre = null;
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function LogEntryMainElementContainer(logEntry, containerDomNode) {
+				this.logEntry = logEntry;
+				this.containerDomNode = containerDomNode;
+				this.mainDiv = document.createElement("div");
+				this.mainDiv.className = "logentry nonielogentry " + this.logEntry.level;
+				this.contentElement = this.mainDiv.appendChild(document.createElement("span"));
+				this.contentElement.appendChild(document.createTextNode(this.logEntry.formattedMessage));
+			}
+
+			LogEntryMainElementContainer.prototype = new LogEntryElementContainer();
+
+			/*----------------------------------------------------------------*/
+
+			function LogEntry(level, formattedMessage) {
+				this.level = level;
+				this.formattedMessage = formattedMessage;
+				this.rendered = false;
+			}
+
+			LogEntry.prototype = new LogItem();
+
+			copyProperties(LogEntry.prototype, {
+				render: function() {
+					var logEntry = this;
+					var containerDomNode = this.group.contentDiv;
+
+					// Support for the CSS attribute white-space in IE for Windows is
+					// non-existent pre version 6 and slightly odd in 6, so instead
+					// use two different HTML elements
+					if (isIe) {
+						this.formattedMessage = this.formattedMessage.replace(/\r\n/g, "\r"); // Workaround for IE's treatment of white space
+						this.unwrappedElementContainer = new LogEntryUnwrappedElementContainer(this, this.getUnwrappedDomContainer());
+						this.wrappedElementContainer = new LogEntryWrappedElementContainer(this, this.getWrappedDomContainer());
+						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];
+					} else {
+						this.mainElementContainer = new LogEntryMainElementContainer(this, this.getMainDomContainer());
+						this.elementContainers = [this.mainElementContainer];
+					}
+					this.content = this.formattedMessage;
+					this.rendered = true;
+				},
+
+				setContent: function(content, wrappedContent) {
+					if (content != this.content) {
+						if (isIe && (content !== this.formattedMessage)) {
+							content = content.replace(/\r\n/g, "\r"); // Workaround for IE's treatment of white space
+						}
+						for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+							this.elementContainers[i].setContent(content, wrappedContent);
+						}
+						this.content = content;
+					}
+				},
+
+				getSearchMatches: function() {
+					var matches = [];
+					var i, len;
+					if (isIe) {
+						var unwrappedEls = getElementsByClass(this.unwrappedElementContainer.mainDiv, "searchterm", "span");
+						var wrappedEls = getElementsByClass(this.wrappedElementContainer.mainDiv, "searchterm", "span");
+						for (i = 0, len = unwrappedEls.length; i < len; i++) {
+							matches[i] = new Match(this.level, null, unwrappedEls[i], wrappedEls[i]);
+						}
+					} else {
+						var els = getElementsByClass(this.mainElementContainer.mainDiv, "searchterm", "span");
+						for (i = 0, len = els.length; i < len; i++) {
+							matches[i] = new Match(this.level, els[i]);
+						}
+					}
+					return matches;
+				},
+
+				setSearchMatch: function(isMatch) {
+					for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+						this.elementContainers[i].setSearchMatch(isMatch);
+					}
+				},
+
+				clearSearch: function() {
+					for (var i = 0, len = this.elementContainers.length; i < len; i++) {
+						this.elementContainers[i].clearSearch();
+					}
+				},
+
+				accept: function(visitor) {
+					visitor.visitLogEntry(this);
+				},
+
+				serialize: function(items) {
+					items.push([LogItem.serializedItemKeys.LOG_ENTRY, this.level, this.formattedMessage]);
+				}
+			});
+
+			/*----------------------------------------------------------------*/
+
+			function LogItemVisitor() {
+			}
+
+			LogItemVisitor.prototype = {
+				visit: function(logItem) {
+				},
+
+				visitParent: function(logItem) {
+					if (logItem.group) {
+						logItem.group.accept(this);
+					}
+				},
+
+				visitChildren: function(logItem) {
+					for (var i = 0, len = logItem.children.length; i < len; i++) {
+						logItem.children[i].accept(this);
+					}
+				},
+
+				visitLogEntry: function(logEntry) {
+					this.visit(logEntry);
+				},
+
+				visitSeparator: function(separator) {
+					this.visit(separator);
+				},
+
+				visitGroup: function(group) {
+					this.visit(group);
+				}
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function GroupFlattener() {
+				this.logEntriesAndSeparators = [];
+			}
+
+			GroupFlattener.prototype = new LogItemVisitor();
+
+			GroupFlattener.prototype.visitGroup = function(group) {
+				this.visitChildren(group);
+			};
+
+			GroupFlattener.prototype.visitLogEntry = function(logEntry) {
+				this.logEntriesAndSeparators.push(logEntry);
+			};
+
+			GroupFlattener.prototype.visitSeparator = function(separator) {
+				this.logEntriesAndSeparators.push(separator);
+			};
+
+			/*----------------------------------------------------------------*/
+
+			window.onload = function() {
+				// Sort out document.domain
+				if (location.search) {
+					var queryBits = unescape(location.search).substr(1).split("&"), nameValueBits;
+					for (var i = 0, len = queryBits.length; i < len; i++) {
+						nameValueBits = queryBits[i].split("=");
+						if (nameValueBits[0] == "log4javascript_domain") {
+							document.domain = nameValueBits[1];
+							break;
+						}
+					}
+				}
+
+				// Create DOM objects
+				logMainContainer = $("log");
+				if (isIePre7) {
+					addClass(logMainContainer, "oldIe");
+				}
+
+				rootGroup = new Group("root", true);
+				rootGroup.render();
+				currentGroup = rootGroup;
+				
+				setCommandInputWidth();
+				setLogContainerHeight();
+				toggleLoggingEnabled();
+				toggleSearchEnabled();
+				toggleSearchFilter();
+				toggleSearchHighlight();
+				applyFilters();
+				checkAllLevels();
+				toggleWrap();
+				toggleNewestAtTop();
+				toggleScrollToLatest();
+				renderQueuedLogItems();
+				loaded = true;
+				$("command").value = "";
+				$("command").autocomplete = "off";
+				$("command").onkeydown = function(evt) {
+					evt = getEvent(evt);
+					if (evt.keyCode == 10 || evt.keyCode == 13) { // Return/Enter
+						evalCommandLine();
+						stopPropagation(evt);
+					} else if (evt.keyCode == 27) { // Escape
+						this.value = "";
+						this.focus();
+					} else if (evt.keyCode == 38 && commandHistory.length > 0) { // Up
+						currentCommandIndex = Math.max(0, currentCommandIndex - 1);
+						this.value = commandHistory[currentCommandIndex];
+						moveCaretToEnd(this);
+					} else if (evt.keyCode == 40 && commandHistory.length > 0) { // Down
+						currentCommandIndex = Math.min(commandHistory.length - 1, currentCommandIndex + 1);
+						this.value = commandHistory[currentCommandIndex];
+						moveCaretToEnd(this);
+					}
+				};
+
+				// Prevent the keypress moving the caret in Firefox
+				$("command").onkeypress = function(evt) {
+					evt = getEvent(evt);
+					if (evt.keyCode == 38 && commandHistory.length > 0 && evt.preventDefault) { // Up
+						evt.preventDefault();
+					}
+				};
+
+				// Prevent the keyup event blurring the input in Opera
+				$("command").onkeyup = function(evt) {
+					evt = getEvent(evt);
+					if (evt.keyCode == 27 && evt.preventDefault) { // Up
+						evt.preventDefault();
+						this.focus();
+					}
+				};
+
+				// Add document keyboard shortcuts
+				document.onkeydown = function keyEventHandler(evt) {
+					evt = getEvent(evt);
+					switch (evt.keyCode) {
+						case 69: // Ctrl + shift + E: re-execute last command
+							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {
+								evalLastCommand();
+								cancelKeyEvent(evt);
+								return false;
+							}
+							break;
+						case 75: // Ctrl + shift + K: focus search
+							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {
+								focusSearch();
+								cancelKeyEvent(evt);
+								return false;
+							}
+							break;
+						case 40: // Ctrl + shift + down arrow: focus command line
+						case 76: // Ctrl + shift + L: focus command line
+							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {
+								focusCommandLine();
+								cancelKeyEvent(evt);
+								return false;
+							}
+							break;
+					}
+				};
+
+				// Workaround to make sure log div starts at the correct size
+				setTimeout(setLogContainerHeight, 20);
+
+				setShowCommandLine(showCommandLine);
+				doSearch();
+			};
+
+			window.onunload = function() {
+				if (mainWindowExists()) {
+					appender.unload();
+				}
+				appender = null;
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function toggleLoggingEnabled() {
+				setLoggingEnabled($("enableLogging").checked);
+			}
+
+			function setLoggingEnabled(enable) {
+				loggingEnabled = enable;
+			}
+
+			var appender = null;
+
+			function setAppender(appenderParam) {
+				appender = appenderParam;
+			}
+
+			function setShowCloseButton(showCloseButton) {
+				$("closeButton").style.display = showCloseButton ? "inline" : "none";
+			}
+
+			function setShowHideButton(showHideButton) {
+				$("hideButton").style.display = showHideButton ? "inline" : "none";
+			}
+
+			var newestAtTop = false;
+
+			/*----------------------------------------------------------------*/
+
+			function LogItemContentReverser() {
+			}
+			
+			LogItemContentReverser.prototype = new LogItemVisitor();
+			
+			LogItemContentReverser.prototype.visitGroup = function(group) {
+				group.reverseChildren();
+				this.visitChildren(group);
+			};
+
+			/*----------------------------------------------------------------*/
+
+			function setNewestAtTop(isNewestAtTop) {
+				var oldNewestAtTop = newestAtTop;
+				var i, iLen, j, jLen;
+				newestAtTop = Boolean(isNewestAtTop);
+				if (oldNewestAtTop != newestAtTop) {
+					var visitor = new LogItemContentReverser();
+					rootGroup.accept(visitor);
+
+					// Reassemble the matches array
+					if (currentSearch) {
+						var currentMatch = currentSearch.matches[currentMatchIndex];
+						var matchIndex = 0;
+						var matches = [];
+						var actOnLogEntry = function(logEntry) {
+							var logEntryMatches = logEntry.getSearchMatches();
+							for (j = 0, jLen = logEntryMatches.length; j < jLen; j++) {
+								matches[matchIndex] = logEntryMatches[j];
+								if (currentMatch && logEntryMatches[j].equals(currentMatch)) {
+									currentMatchIndex = matchIndex;
+								}
+								matchIndex++;
+							}
+						};
+						if (newestAtTop) {
+							for (i = logEntries.length - 1; i >= 0; i--) {
+								actOnLogEntry(logEntries[i]);
+							}
+						} else {
+							for (i = 0, iLen = logEntries.length; i < iLen; i++) {
+								actOnLogEntry(logEntries[i]);
+							}
+						}
+						currentSearch.matches = matches;
+						if (currentMatch) {
+							currentMatch.setCurrent();
+						}
+					} else if (scrollToLatest) {
+						doScrollToLatest();
+					}
+				}
+				$("newestAtTop").checked = isNewestAtTop;
+			}
+
+			function toggleNewestAtTop() {
+				var isNewestAtTop = $("newestAtTop").checked;
+				setNewestAtTop(isNewestAtTop);
+			}
+
+			var scrollToLatest = true;
+
+			function setScrollToLatest(isScrollToLatest) {
+				scrollToLatest = isScrollToLatest;
+				if (scrollToLatest) {
+					doScrollToLatest();
+				}
+				$("scrollToLatest").checked = isScrollToLatest;
+			}
+
+			function toggleScrollToLatest() {
+				var isScrollToLatest = $("scrollToLatest").checked;
+				setScrollToLatest(isScrollToLatest);
+			}
+
+			function doScrollToLatest() {
+				var l = logMainContainer;
+				if (typeof l.scrollTop != "undefined") {
+					if (newestAtTop) {
+						l.scrollTop = 0;
+					} else {
+						var latestLogEntry = l.lastChild;
+						if (latestLogEntry) {
+							l.scrollTop = l.scrollHeight;
+						}
+					}
+				}
+			}
+
+			var closeIfOpenerCloses = true;
+
+			function setCloseIfOpenerCloses(isCloseIfOpenerCloses) {
+				closeIfOpenerCloses = isCloseIfOpenerCloses;
+			}
+
+			var maxMessages = null;
+
+			function setMaxMessages(max) {
+				maxMessages = max;
+				pruneLogEntries();
+			}
+
+			var showCommandLine = false;
+
+			function setShowCommandLine(isShowCommandLine) {
+				showCommandLine = isShowCommandLine;
+				if (loaded) {
+					$("commandLine").style.display = showCommandLine ? "block" : "none";
+					setCommandInputWidth();
+					setLogContainerHeight();
+				}
+			}
+
+			function focusCommandLine() {
+				if (loaded) {
+					$("command").focus();
+				}
+			}
+
+			function focusSearch() {
+				if (loaded) {
+					$("searchBox").focus();
+				}
+			}
+
+			function getLogItems() {
+				var items = [];
+				for (var i = 0, len = logItems.length; i < len; i++) {
+					logItems[i].serialize(items);
+				}
+				return items;
+			}
+
+			function setLogItems(items) {
+				var loggingReallyEnabled = loggingEnabled;
+				// Temporarily turn logging on
+				loggingEnabled = true;
+				for (var i = 0, len = items.length; i < len; i++) {
+					switch (items[i][0]) {
+						case LogItem.serializedItemKeys.LOG_ENTRY:
+							log(items[i][1], items[i][2]);
+							break;
+						case LogItem.serializedItemKeys.GROUP_START:
+							group(items[i][1]);
+							break;
+						case LogItem.serializedItemKeys.GROUP_END:
+							groupEnd();
+							break;
+					}
+				}
+				loggingEnabled = loggingReallyEnabled;
+			}
+
+			function log(logLevel, formattedMessage) {
+				if (loggingEnabled) {
+					var logEntry = new LogEntry(logLevel, formattedMessage);
+					logEntries.push(logEntry);
+					logEntriesAndSeparators.push(logEntry);
+					logItems.push(logEntry);
+					currentGroup.addChild(logEntry);
+					if (loaded) {
+						if (logQueuedEventsTimer !== null) {
+							clearTimeout(logQueuedEventsTimer);
+						}
+						logQueuedEventsTimer = setTimeout(renderQueuedLogItems, renderDelay);
+						unrenderedLogItemsExist = true;
+					}
+				}
+			}
+
+			function renderQueuedLogItems() {
+				logQueuedEventsTimer = null;
+				var pruned = pruneLogEntries();
+
+				// Render any unrendered log entries and apply the current search to them
+				var initiallyHasMatches = currentSearch ? currentSearch.hasMatches() : false;
+				for (var i = 0, len = logItems.length; i < len; i++) {
+					if (!logItems[i].rendered) {
+						logItems[i].render();
+						logItems[i].appendToLog();
+						if (currentSearch && (logItems[i] instanceof LogEntry)) {
+							currentSearch.applyTo(logItems[i]);
+						}
+					}
+				}
+				if (currentSearch) {
+					if (pruned) {
+						if (currentSearch.hasVisibleMatches()) {
+							if (currentMatchIndex === null) {
+								setCurrentMatchIndex(0);
+							}
+							displayMatches();
+						} else {
+							displayNoMatches();
+						}
+					} else if (!initiallyHasMatches && currentSearch.hasVisibleMatches()) {
+						setCurrentMatchIndex(0);
+						displayMatches();
+					}
+				}
+				if (scrollToLatest) {
+					doScrollToLatest();
+				}
+				unrenderedLogItemsExist = false;
+			}
+
+			function pruneLogEntries() {
+				if ((maxMessages !== null) && (logEntriesAndSeparators.length > maxMessages)) {
+					var numberToDelete = logEntriesAndSeparators.length - maxMessages;
+					var prunedLogEntries = logEntriesAndSeparators.slice(0, numberToDelete);
+					if (currentSearch) {
+						currentSearch.removeMatches(prunedLogEntries);
+					}
+					var group;
+					for (var i = 0; i < numberToDelete; i++) {
+						group = logEntriesAndSeparators[i].group;
+						array_remove(logItems, logEntriesAndSeparators[i]);
+						array_remove(logEntries, logEntriesAndSeparators[i]);
+						logEntriesAndSeparators[i].remove(true, true);
+						if (group.children.length === 0 && group !== currentGroup && group !== rootGroup) {
+							array_remove(logItems, group);
+							group.remove(true, true);
+						}
+					}
+					logEntriesAndSeparators = array_removeFromStart(logEntriesAndSeparators, numberToDelete);
+					return true;
+				}
+				return false;
+			}
+
+			function group(name, startExpanded) {
+				if (loggingEnabled) {
+					initiallyExpanded = (typeof startExpanded === "undefined") ? true : Boolean(startExpanded);
+					var newGroup = new Group(name, false, initiallyExpanded);
+					currentGroup.addChild(newGroup);
+					currentGroup = newGroup;
+					logItems.push(newGroup);
+					if (loaded) {
+						if (logQueuedEventsTimer !== null) {
+							clearTimeout(logQueuedEventsTimer);
+						}
+						logQueuedEventsTimer = setTimeout(renderQueuedLogItems, renderDelay);
+						unrenderedLogItemsExist = true;
+					}
+				}
+			}
+
+			function groupEnd() {
+				currentGroup = (currentGroup === rootGroup) ? rootGroup : currentGroup.group;
+			}
+
+			function mainPageReloaded() {
+				currentGroup = rootGroup;
+				var separator = new Separator();
+				logEntriesAndSeparators.push(separator);
+				logItems.push(separator);
+				currentGroup.addChild(separator);
+			}
+
+			function closeWindow() {
+				if (appender && mainWindowExists()) {
+					appender.close(true);
+				} else {
+					window.close();
+				}
+			}
+
+			function hide() {
+				if (appender && mainWindowExists()) {
+					appender.hide();
+				}
+			}
+
+			var mainWindow = window;
+			var windowId = "log4javascriptConsoleWindow_" + new Date().getTime() + "_" + ("" + Math.random()).substr(2);
+
+			function setMainWindow(win) {
+				mainWindow = win;
+				mainWindow[windowId] = window;
+				// If this is a pop-up, poll the opener to see if it's closed
+				if (opener && closeIfOpenerCloses) {
+					pollOpener();
+				}
+			}
+
+			function pollOpener() {
+				if (closeIfOpenerCloses) {
+					if (mainWindowExists()) {
+						setTimeout(pollOpener, 500);
+					} else {
+						closeWindow();
+					}
+				}
+			}
+
+			function mainWindowExists() {
+				try {
+					return (mainWindow && !mainWindow.closed &&
+						mainWindow[windowId] == window);
+				} catch (ex) {}
+				return false;
+			}
+
+			var logLevels = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"];
+
+			function getCheckBox(logLevel) {
+				return $("switch_" + logLevel);
+			}
+
+			function getIeWrappedLogContainer() {
+				return $("log_wrapped");
+			}
+
+			function getIeUnwrappedLogContainer() {
+				return $("log_unwrapped");
+			}
+
+			function applyFilters() {
+				for (var i = 0; i < logLevels.length; i++) {
+					if (getCheckBox(logLevels[i]).checked) {
+						addClass(logMainContainer, logLevels[i]);
+					} else {
+						removeClass(logMainContainer, logLevels[i]);
+					}
+				}
+				updateSearchFromFilters();
+			}
+
+			function toggleAllLevels() {
+				var turnOn = $("switch_ALL").checked;
+				for (var i = 0; i < logLevels.length; i++) {
+					getCheckBox(logLevels[i]).checked = turnOn;
+					if (turnOn) {
+						addClass(logMainContainer, logLevels[i]);
+					} else {
+						removeClass(logMainContainer, logLevels[i]);
+					}
+				}
+			}
+
+			function checkAllLevels() {
+				for (var i = 0; i < logLevels.length; i++) {
+					if (!getCheckBox(logLevels[i]).checked) {
+						getCheckBox("ALL").checked = false;
+						return;
+					}
+				}
+				getCheckBox("ALL").checked = true;
+			}
+
+			function clearLog() {
+				rootGroup.clear();
+				currentGroup = rootGroup;
+				logEntries = [];
+				logItems = [];
+				logEntriesAndSeparators = [];
+ 				doSearch();
+			}
+
+			function toggleWrap() {
+				var enable = $("wrap").checked;
+				if (enable) {
+					addClass(logMainContainer, "wrap");
+				} else {
+					removeClass(logMainContainer, "wrap");
+				}
+				refreshCurrentMatch();
+			}
+
+			/* ------------------------------------------------------------------- */
+
+			// Search
+
+			var searchTimer = null;
+
+			function scheduleSearch() {
+				try {
+					clearTimeout(searchTimer);
+				} catch (ex) {
+					// Do nothing
+				}
+				searchTimer = setTimeout(doSearch, 500);
+			}
+
+			function Search(searchTerm, isRegex, searchRegex, isCaseSensitive) {
+				this.searchTerm = searchTerm;
+				this.isRegex = isRegex;
+				this.searchRegex = searchRegex;
+				this.isCaseSensitive = isCaseSensitive;
+				this.matches = [];
+			}
+
+			Search.prototype = {
+				hasMatches: function() {
+					return this.matches.length > 0;
+				},
+
+				hasVisibleMatches: function() {
+					if (this.hasMatches()) {
+						for (var i = 0; i < this.matches.length; i++) {
+							if (this.matches[i].isVisible()) {
+								return true;
+							}
+						}
+					}
+					return false;
+				},
+
+				match: function(logEntry) {
+					var entryText = String(logEntry.formattedMessage);
+					var matchesSearch = false;
+					if (this.isRegex) {
+						matchesSearch = this.searchRegex.test(entryText);
+					} else if (this.isCaseSensitive) {
+						matchesSearch = (entryText.indexOf(this.searchTerm) > -1);
+					} else {
+						matchesSearch = (entryText.toLowerCase().indexOf(this.searchTerm.toLowerCase()) > -1);
+					}
+					return matchesSearch;
+				},
+
+				getNextVisibleMatchIndex: function() {
+					for (var i = currentMatchIndex + 1; i < this.matches.length; i++) {
+						if (this.matches[i].isVisible()) {
+							return i;
+						}
+					}
+					// Start again from the first match
+					for (i = 0; i <= currentMatchIndex; i++) {
+						if (this.matches[i].isVisible()) {
+							return i;
+						}
+					}
+					return -1;
+				},
+
+				getPreviousVisibleMatchIndex: function() {
+					for (var i = currentMatchIndex - 1; i >= 0; i--) {
+						if (this.matches[i].isVisible()) {
+							return i;
+						}
+					}
+					// Start again from the last match
+					for (var i = this.matches.length - 1; i >= currentMatchIndex; i--) {
+						if (this.matches[i].isVisible()) {
+							return i;
+						}
+					}
+					return -1;
+				},
+
+				applyTo: function(logEntry) {
+					var doesMatch = this.match(logEntry);
+					if (doesMatch) {
+						logEntry.group.expand();
+						logEntry.setSearchMatch(true);
+						var logEntryContent;
+						var wrappedLogEntryContent;
+						var searchTermReplacementStartTag = "<span class=\"searchterm\">";
+						var searchTermReplacementEndTag = "<" + "/span>";
+						var preTagName = isIe ? "pre" : "span";
+						var preStartTag = "<" + preTagName + " class=\"pre\">";
+						var preEndTag = "<" + "/" + preTagName + ">";
+						var startIndex = 0;
+						var searchIndex, matchedText, textBeforeMatch;
+						if (this.isRegex) {
+							var flags = this.isCaseSensitive ? "g" : "gi";
+							var capturingRegex = new RegExp("(" + this.searchRegex.source + ")", flags);
+
+							// Replace the search term with temporary tokens for the start and end tags
+							var rnd = ("" + Math.random()).substr(2);
+							var startToken = "%%s" + rnd + "%%";
+							var endToken = "%%e" + rnd + "%%";
+							logEntryContent = logEntry.formattedMessage.replace(capturingRegex, startToken + "$1" + endToken);
+
+							// Escape the HTML to get rid of angle brackets
+							logEntryContent = escapeHtml(logEntryContent);
+
+							// Substitute the proper HTML back in for the search match
+							var result;
+							var searchString = logEntryContent;
+							logEntryContent = "";
+							wrappedLogEntryContent = "";
+							while ((searchIndex = searchString.indexOf(startToken, startIndex)) > -1) {
+								var endTokenIndex = searchString.indexOf(endToken, searchIndex);
+								matchedText = searchString.substring(searchIndex + startToken.length, endTokenIndex);
+								textBeforeMatch = searchString.substring(startIndex, searchIndex);
+								logEntryContent += preStartTag + textBeforeMatch + preEndTag;
+								logEntryContent += searchTermReplacementStartTag + preStartTag + matchedText +
+									preEndTag + searchTermReplacementEndTag;
+								if (isIe) {
+									wrappedLogEntryContent += textBeforeMatch + searchTermReplacementStartTag +
+										matchedText + searchTermReplacementEndTag;
+								}
+								startIndex = endTokenIndex + endToken.length;
+							}
+							logEntryContent += preStartTag + searchString.substr(startIndex) + preEndTag;
+							if (isIe) {
+								wrappedLogEntryContent += searchString.substr(startIndex);
+							}
+						} else {
+							logEntryContent = "";
+							wrappedLogEntryContent = "";
+							var searchTermReplacementLength = searchTermReplacementStartTag.length +
+								this.searchTerm.length + searchTermReplacementEndTag.length;
+							var searchTermLength = this.searchTerm.length;
+							var searchTermLowerCase = this.searchTerm.toLowerCase();
+							var logTextLowerCase = logEntry.formattedMessage.toLowerCase();
+							while ((searchIndex = logTextLowerCase.indexOf(searchTermLowerCase, startIndex)) > -1) {
+								matchedText = escapeHtml(logEntry.formattedMessage.substr(searchIndex, this.searchTerm.length));
+								textBeforeMatch = escapeHtml(logEntry.formattedMessage.substring(startIndex, searchIndex));
+								var searchTermReplacement = searchTermReplacementStartTag +
+									preStartTag + matchedText + preEndTag + searchTermReplacementEndTag;
+								logEntryContent += preStartTag + textBeforeMatch + preEndTag + searchTermReplacement;
+								if (isIe) {
+									wrappedLogEntryContent += textBeforeMatch + searchTermReplacementStartTag +
+										matchedText + searchTermReplacementEndTag;
+								}
+								startIndex = searchIndex + searchTermLength;
+							}
+							var textAfterLastMatch = escapeHtml(logEntry.formattedMessage.substr(startIndex));
+							logEntryContent += preStartTag + textAfterLastMatch + preEndTag;
+							if (isIe) {
+								wrappedLogEntryContent += textAfterLastMatch;
+							}
+						}
+						logEntry.setContent(logEntryContent, wrappedLogEntryContent);
+						var logEntryMatches = logEntry.getSearchMatches();
+						this.matches = this.matches.concat(logEntryMatches);
+					} else {
+						logEntry.setSearchMatch(false);
+						logEntry.setContent(logEntry.formattedMessage, logEntry.formattedMessage);
+					}
+					return doesMatch;
+				},
+
+				removeMatches: function(logEntries) {
+					var matchesToRemoveCount = 0;
+					var currentMatchRemoved = false;
+					var matchesToRemove = [];
+					var i, iLen, j, jLen;
+
+					// Establish the list of matches to be removed
+					for (i = 0, iLen = this.matches.length; i < iLen; i++) {
+						for (j = 0, jLen = logEntries.length; j < jLen; j++) {
+							if (this.matches[i].belongsTo(logEntries[j])) {
+								matchesToRemove.push(this.matches[i]);
+								if (i === currentMatchIndex) {
+									currentMatchRemoved = true;
+								}
+							}
+						}
+					}
+
+					// Set the new current match index if the current match has been deleted
+					// This will be the first match that appears after the first log entry being
+					// deleted, if one exists; otherwise, it's the first match overall
+					var newMatch = currentMatchRemoved ? null : this.matches[currentMatchIndex];
+					if (currentMatchRemoved) {
+						for (i = currentMatchIndex, iLen = this.matches.length; i < iLen; i++) {
+							if (this.matches[i].isVisible() && !array_contains(matchesToRemove, this.matches[i])) {
+								newMatch = this.matches[i];
+								break;
+							}
+						}
+					}
+
+					// Remove the matches
+					for (i = 0, iLen = matchesToRemove.length; i < iLen; i++) {
+						array_remove(this.matches, matchesToRemove[i]);
+						matchesToRemove[i].remove();
+					}
+
+					// Set the new match, if one exists
+					if (this.hasVisibleMatches()) {
+						if (newMatch === null) {
+							setCurrentMatchIndex(0);
+						} else {
+							// Get the index of the new match
+							var newMatchIndex = 0;
+							for (i = 0, iLen = this.matches.length; i < iLen; i++) {
+								if (newMatch === this.matches[i]) {
+									newMatchIndex = i;
+									break;
+								}
+							}
+							setCurrentMatchIndex(newMatchIndex);
+						}
+					} else {
+						currentMatchIndex = null;
+						displayNoMatches();
+					}
+				}
+			};
+
+			function getPageOffsetTop(el, container) {
+				var currentEl = el;
+				var y = 0;
+				while (currentEl && currentEl != container) {
+					y += currentEl.offsetTop;
+					currentEl = currentEl.offsetParent;
+				}
+				return y;
+			}
+
+			function scrollIntoView(el) {
+				var logContainer = logMainContainer;
+				// Check if the whole width of the element is visible and centre if not
+				if (!$("wrap").checked) {
+					var logContainerLeft = logContainer.scrollLeft;
+					var logContainerRight = logContainerLeft  + logContainer.offsetWidth;
+					var elLeft = el.offsetLeft;
+					var elRight = elLeft + el.offsetWidth;
+					if (elLeft < logContainerLeft || elRight > logContainerRight) {
+						logContainer.scrollLeft = elLeft - (logContainer.offsetWidth - el.offsetWidth) / 2;
+					}
+				}
+				// Check if the whole height of the element is visible and centre if not
+				var logContainerTop = logContainer.scrollTop;
+				var logContainerBottom = logContainerTop  + logContainer.offsetHeight;
+				var elTop = getPageOffsetTop(el) - getToolBarsHeight();
+				var elBottom = elTop + el.offsetHeight;
+				if (elTop < logContainerTop || elBottom > logContainerBottom) {
+					logContainer.scrollTop = elTop - (logContainer.offsetHeight - el.offsetHeight) / 2;
+				}
+			}
+
+			function Match(logEntryLevel, spanInMainDiv, spanInUnwrappedPre, spanInWrappedDiv) {
+				this.logEntryLevel = logEntryLevel;
+				this.spanInMainDiv = spanInMainDiv;
+				if (isIe) {
+					this.spanInUnwrappedPre = spanInUnwrappedPre;
+					this.spanInWrappedDiv = spanInWrappedDiv;
+				}
+				this.mainSpan = isIe ? spanInUnwrappedPre : spanInMainDiv;
+			}
+
+			Match.prototype = {
+				equals: function(match) {
+					return this.mainSpan === match.mainSpan;
+				},
+
+				setCurrent: function() {
+					if (isIe) {
+						addClass(this.spanInUnwrappedPre, "currentmatch");
+						addClass(this.spanInWrappedDiv, "currentmatch");
+						// Scroll the visible one into view
+						var elementToScroll = $("wrap").checked ? this.spanInWrappedDiv : this.spanInUnwrappedPre;
+						scrollIntoView(elementToScroll);
+					} else {
+						addClass(this.spanInMainDiv, "currentmatch");
+						scrollIntoView(this.spanInMainDiv);
+					}
+				},
+
+				belongsTo: function(logEntry) {
+					if (isIe) {
+						return isDescendant(this.spanInUnwrappedPre, logEntry.unwrappedPre);
+					} else {
+						return isDescendant(this.spanInMainDiv, logEntry.mainDiv);
+					}
+				},
+
+				setNotCurrent: function() {
+					if (isIe) {
+						removeClass(this.spanInUnwrappedPre, "currentmatch");
+						removeClass(this.spanInWrappedDiv, "currentmatch");
+					} else {
+						removeClass(this.spanInMainDiv, "currentmatch");
+					}
+				},
+
+				isOrphan: function() {
+					return isOrphan(this.mainSpan);
+				},
+
+				isVisible: function() {
+					return getCheckBox(this.logEntryLevel).checked;
+				},
+
+				remove: function() {
+					if (isIe) {
+						this.spanInUnwrappedPre = null;
+						this.spanInWrappedDiv = null;
+					} else {
+						this.spanInMainDiv = null;
+					}
+				}
+			};
+
+			var currentSearch = null;
+			var currentMatchIndex = null;
+
+			function doSearch() {
+				var searchBox = $("searchBox");
+				var searchTerm = searchBox.value;
+				var isRegex = $("searchRegex").checked;
+				var isCaseSensitive = $("searchCaseSensitive").checked;
+				var i;
+
+				if (searchTerm === "") {
+					$("searchReset").disabled = true;
+					$("searchNav").style.display = "none";
+					removeClass(document.body, "searching");
+					removeClass(searchBox, "hasmatches");
+					removeClass(searchBox, "nomatches");
+					for (i = 0; i < logEntries.length; i++) {
+						logEntries[i].clearSearch();
+						logEntries[i].setContent(logEntries[i].formattedMessage, logEntries[i].formattedMessage);
+					}
+					currentSearch = null;
+					setLogContainerHeight();
+				} else {
+					$("searchReset").disabled = false;
+					$("searchNav").style.display = "block";
+					var searchRegex;
+					var regexValid;
+					if (isRegex) {
+						try {
+							searchRegex = isCaseSensitive ? new RegExp(searchTerm, "g") : new RegExp(searchTerm, "gi");
+							regexValid = true;
+							replaceClass(searchBox, "validregex", "invalidregex");
+							searchBox.title = "Valid regex";
+						} catch (ex) {
+							regexValid = false;
+							replaceClass(searchBox, "invalidregex", "validregex");
+							searchBox.title = "Invalid regex: " + (ex.message ? ex.message : (ex.description ? ex.description : "unknown error"));
+							return;
+						}
+					} else {
+						searchBox.title = "";
+						removeClass(searchBox, "validregex");
+						removeClass(searchBox, "invalidregex");
+					}
+					addClass(document.body, "searching");
+					currentSearch = new Search(searchTerm, isRegex, searchRegex, isCaseSensitive);
+					for (i = 0; i < logEntries.length; i++) {
+						currentSearch.applyTo(logEntries[i]);
+					}
+					setLogContainerHeight();
+
+					// Highlight the first search match
+					if (currentSearch.hasVisibleMatches()) {
+						setCurrentMatchIndex(0);
+						displayMatches();
+					} else {
+						displayNoMatches();
+					}
+				}
+			}
+
+			function updateSearchFromFilters() {
+				if (currentSearch) {
+					if (currentSearch.hasMatches()) {
+						if (currentMatchIndex === null) {
+							currentMatchIndex = 0;
+						}
+						var currentMatch = currentSearch.matches[currentMatchIndex];
+						if (currentMatch.isVisible()) {
+							displayMatches();
+							setCurrentMatchIndex(currentMatchIndex);
+						} else {
+							currentMatch.setNotCurrent();
+							// Find the next visible match, if one exists
+							var nextVisibleMatchIndex = currentSearch.getNextVisibleMatchIndex();
+							if (nextVisibleMatchIndex > -1) {
+								setCurrentMatchIndex(nextVisibleMatchIndex);
+								displayMatches();
+							} else {
+								displayNoMatches();
+							}
+						}
+					} else {
+						displayNoMatches();
+					}
+				}
+			}
+
+			function refreshCurrentMatch() {
+				if (currentSearch && currentSearch.hasVisibleMatches()) {
+					setCurrentMatchIndex(currentMatchIndex);
+				}
+			}
+
+			function displayMatches() {
+				replaceClass($("searchBox"), "hasmatches", "nomatches");
+				$("searchBox").title = "" + currentSearch.matches.length + " matches found";
+				$("searchNav").style.display = "block";
+				setLogContainerHeight();
+			}
+
+			function displayNoMatches() {
+				replaceClass($("searchBox"), "nomatches", "hasmatches");
+				$("searchBox").title = "No matches found";
+				$("searchNav").style.display = "none";
+				setLogContainerHeight();
+			}
+
+			function toggleSearchEnabled(enable) {
+				enable = (typeof enable == "undefined") ? !$("searchDisable").checked : enable;
+				$("searchBox").disabled = !enable;
+				$("searchReset").disabled = !enable;
+				$("searchRegex").disabled = !enable;
+				$("searchNext").disabled = !enable;
+				$("searchPrevious").disabled = !enable;
+				$("searchCaseSensitive").disabled = !enable;
+				$("searchNav").style.display = (enable && ($("searchBox").value !== "") &&
+						currentSearch && currentSearch.hasVisibleMatches()) ?
+					"block" : "none";
+				if (enable) {
+					removeClass($("search"), "greyedout");
+					addClass(document.body, "searching");
+					if ($("searchHighlight").checked) {
+						addClass(logMainContainer, "searchhighlight");
+					} else {
+						removeClass(logMainContainer, "searchhighlight");
+					}
+					if ($("searchFilter").checked) {
+						addClass(logMainContainer, "searchfilter");
+					} else {
+						removeClass(logMainContainer, "searchfilter");
+					}
+					$("searchDisable").checked = !enable;
+				} else {
+					addClass($("search"), "greyedout");
+					removeClass(document.body, "searching");
+					removeClass(logMainContainer, "searchhighlight");
+					removeClass(logMainContainer, "searchfilter");
+				}
+				setLogContainerHeight();
+			}
+
+			function toggleSearchFilter() {
+				var enable = $("searchFilter").checked;
+				if (enable) {
+					addClass(logMainContainer, "searchfilter");
+				} else {
+					removeClass(logMainContainer, "searchfilter");
+				}
+				refreshCurrentMatch();
+			}
+
+			function toggleSearchHighlight() {
+				var enable = $("searchHighlight").checked;
+				if (enable) {
+					addClass(logMainContainer, "searchhighlight");
+				} else {
+					removeClass(logMainContainer, "searchhighlight");
+				}
+			}
+
+			function clearSearch() {
+				$("searchBox").value = "";
+				doSearch();
+			}
+
+			function searchNext() {
+				if (currentSearch !== null && currentMatchIndex !== null) {
+					currentSearch.matches[currentMatchIndex].setNotCurrent();
+					var nextMatchIndex = currentSearch.getNextVisibleMatchIndex();
+					if (nextMatchIndex > currentMatchIndex || confirm("Reached the end of the page. Start from the top?")) {
+						setCurrentMatchIndex(nextMatchIndex);
+					}
+				}
+			}
+
+			function searchPrevious() {
+				if (currentSearch !== null && currentMatchIndex !== null) {
+					currentSearch.matches[currentMatchIndex].setNotCurrent();
+					var previousMatchIndex = currentSearch.getPreviousVisibleMatchIndex();
+					if (previousMatchIndex < currentMatchIndex || confirm("Reached the start of the page. Continue from the bottom?")) {
+						setCurrentMatchIndex(previousMatchIndex);
+					}
+				}
+			}
+
+			function setCurrentMatchIndex(index) {
+				currentMatchIndex = index;
+				currentSearch.matches[currentMatchIndex].setCurrent();
+			}
+
+			/* ------------------------------------------------------------------------- */
+
+			// CSS Utilities
+
+			function addClass(el, cssClass) {
+				if (!hasClass(el, cssClass)) {
+					if (el.className) {
+						el.className += " " + cssClass;
+					} else {
+						el.className = cssClass;
+					}
+				}
+			}
+
+			function hasClass(el, cssClass) {
+				if (el.className) {
+					var classNames = el.className.split(" ");
+					return array_contains(classNames, cssClass);
+				}
+				return false;
+			}
+
+			function removeClass(el, cssClass) {
+				if (hasClass(el, cssClass)) {
+					// Rebuild the className property
+					var existingClasses = el.className.split(" ");
+					var newClasses = [];
+					for (var i = 0, len = existingClasses.length; i < len; i++) {
+						if (existingClasses[i] != cssClass) {
+							newClasses[newClasses.length] = existingClasses[i];
+						}
+					}
+					el.className = newClasses.join(" ");
+				}
+			}
+
+			function replaceClass(el, newCssClass, oldCssClass) {
+				removeClass(el, oldCssClass);
+				addClass(el, newCssClass);
+			}
+
+			/* ------------------------------------------------------------------------- */
+
+			// Other utility functions
+
+			function getElementsByClass(el, cssClass, tagName) {
+				var elements = el.getElementsByTagName(tagName);
+				var matches = [];
+				for (var i = 0, len = elements.length; i < len; i++) {
+					if (hasClass(elements[i], cssClass)) {
+						matches.push(elements[i]);
+					}
+				}
+				return matches;
+			}
+
+			// Syntax borrowed from Prototype library
+			function $(id) {
+				return document.getElementById(id);
+			}
+
+			function isDescendant(node, ancestorNode) {
+				while (node != null) {
+					if (node === ancestorNode) {
+						return true;
+					}
+					node = node.parentNode;
+				}
+				return false;
+			}
+
+			function isOrphan(node) {
+				var currentNode = node;
+				while (currentNode) {
+					if (currentNode == document.body) {
+						return false;
+					}
+					currentNode = currentNode.parentNode;
+				}
+				return true;
+			}
+
+			function escapeHtml(str) {
+				return str.replace(/&/g, "&amp;").replace(/[<]/g, "&lt;").replace(/>/g, "&gt;");
+			}
+
+			function getWindowWidth() {
+				if (window.innerWidth) {
+					return window.innerWidth;
+				} else if (document.documentElement && document.documentElement.clientWidth) {
+					return document.documentElement.clientWidth;
+				} else if (document.body) {
+					return document.body.clientWidth;
+				}
+				return 0;
+			}
+
+			function getWindowHeight() {
+				if (window.innerHeight) {
+					return window.innerHeight;
+				} else if (document.documentElement && document.documentElement.clientHeight) {
+					return document.documentElement.clientHeight;
+				} else if (document.body) {
+					return document.body.clientHeight;
+				}
+				return 0;
+			}
+
+			function getToolBarsHeight() {
+				return $("switches").offsetHeight;
+			}
+
+			function getChromeHeight() {
+				var height = getToolBarsHeight();
+				if (showCommandLine) {
+					height += $("commandLine").offsetHeight;
+				}
+				return height;
+			}
+
+			function setLogContainerHeight() {
+				if (logMainContainer) {
+					var windowHeight = getWindowHeight();
+					$("body").style.height = getWindowHeight() + "px";
+					logMainContainer.style.height = "" +
+						Math.max(0, windowHeight - getChromeHeight()) + "px";
+				}
+			}
+
+			function setCommandInputWidth() {
+				if (showCommandLine) {
+					$("command").style.width = "" + Math.max(0, $("commandLineContainer").offsetWidth -
+						($("evaluateButton").offsetWidth + 13)) + "px";
+				}
+			}
+
+			window.onresize = function() {
+				setCommandInputWidth();
+				setLogContainerHeight();
+			};
+
+			if (!Array.prototype.push) {
+				Array.prototype.push = function() {
+			        for (var i = 0, len = arguments.length; i < len; i++){
+			            this[this.length] = arguments[i];
+			        }
+			        return this.length;
+				};
+			}
+
+			if (!Array.prototype.pop) {
+				Array.prototype.pop = function() {
+					if (this.length > 0) {
+						var val = this[this.length - 1];
+						this.length = this.length - 1;
+						return val;
+					}
+				};
+			}
+
+			if (!Array.prototype.shift) {
+				Array.prototype.shift = function() {
+					if (this.length > 0) {
+						var firstItem = this[0];
+						for (var i = 0, len = this.length - 1; i < len; i++) {
+							this[i] = this[i + 1];
+						}
+						this.length = this.length - 1;
+						return firstItem;
+					}
+				};
+			}
+
+			if (!Array.prototype.splice) {
+				Array.prototype.splice = function(startIndex, deleteCount) {
+					var itemsAfterDeleted = this.slice(startIndex + deleteCount);
+					var itemsDeleted = this.slice(startIndex, startIndex + deleteCount);
+					this.length = startIndex;
+					// Copy the arguments into a proper Array object
+					var argumentsArray = [];
+					for (var i = 0, len = arguments.length; i < len; i++) {
+						argumentsArray[i] = arguments[i];
+					}
+					var itemsToAppend = (argumentsArray.length > 2) ?
+						itemsAfterDeleted = argumentsArray.slice(2).concat(itemsAfterDeleted) : itemsAfterDeleted;
+					for (i = 0, len = itemsToAppend.length; i < len; i++) {
+						this.push(itemsToAppend[i]);
+					}
+					return itemsDeleted;
+				};
+			}
+
+			function array_remove(arr, val) {
+				var index = -1;
+				for (var i = 0, len = arr.length; i < len; i++) {
+					if (arr[i] === val) {
+						index = i;
+						break;
+					}
+				}
+				if (index >= 0) {
+					arr.splice(index, 1);
+					return index;
+				} else {
+					return false;
+				}
+			}
+
+			function array_removeFromStart(array, numberToRemove) {
+				if (Array.prototype.splice) {
+					array.splice(0, numberToRemove);
+				} else {
+					for (var i = numberToRemove, len = array.length; i < len; i++) {
+						array[i - numberToRemove] = array[i];
+					}
+					array.length = array.length - numberToRemove;
+				}
+				return array;
+			}
+
+			function array_contains(arr, val) {
+				for (var i = 0, len = arr.length; i < len; i++) {
+					if (arr[i] == val) {
+						return true;
+					}
+				}
+				return false;
+			}
+
+			function getErrorMessage(ex) {
+				if (ex.message) {
+					return ex.message;
+				} else if (ex.description) {
+					return ex.description;
+				}
+				return "" + ex;
+			}
+
+			function moveCaretToEnd(input) {
+				if (input.setSelectionRange) {
+					input.focus();
+					var length = input.value.length;
+					input.setSelectionRange(length, length);
+				} else if (input.createTextRange) {
+					var range = input.createTextRange();
+					range.collapse(false);
+					range.select();
+				}
+				input.focus();
+			}
+
+			function stopPropagation(evt) {
+				if (evt.stopPropagation) {
+					evt.stopPropagation();
+				} else if (typeof evt.cancelBubble != "undefined") {
+					evt.cancelBubble = true;
+				}
+			}
+
+			function getEvent(evt) {
+				return evt ? evt : event;
+			}
+
+			function getTarget(evt) {
+				return evt.target ? evt.target : evt.srcElement;
+			}
+
+			function getRelatedTarget(evt) {
+				if (evt.relatedTarget) {
+					return evt.relatedTarget;
+				} else if (evt.srcElement) {
+					switch(evt.type) {
+						case "mouseover":
+							return evt.fromElement;
+						case "mouseout":
+							return evt.toElement;
+						default:
+							return evt.srcElement;
+					}
+				}
+			}
+
+			function cancelKeyEvent(evt) {
+				evt.returnValue = false;
+				stopPropagation(evt);
+			}
+
+			function evalCommandLine() {
+				var expr = $("command").value;
+				evalCommand(expr);
+				$("command").value = "";
+			}
+
+			function evalLastCommand() {
+				if (lastCommand != null) {
+					evalCommand(lastCommand);
+				}
+			}
+
+			var lastCommand = null;
+			var commandHistory = [];
+			var currentCommandIndex = 0;
+
+			function evalCommand(expr) {
+				if (appender) {
+					appender.evalCommandAndAppend(expr);
+				} else {
+					var prefix = ">>> " + expr + "\r\n";
+					try {
+						log("INFO", prefix + eval(expr));
+					} catch (ex) {
+						log("ERROR", prefix + "Error: " + getErrorMessage(ex));
+					}
+				}
+				// Update command history
+				if (expr != commandHistory[commandHistory.length - 1]) {
+					commandHistory.push(expr);
+					// Update the appender
+					if (appender) {
+						appender.storeCommandHistory(commandHistory);
+					}
+				}
+				currentCommandIndex = (expr == commandHistory[currentCommandIndex]) ? currentCommandIndex + 1 : commandHistory.length;
+				lastCommand = expr;
+			}
+			//]]>
+		</script>
+		<style type="text/css">
+			body {
+				background-color: white;
+				color: black;
+				padding: 0;
+				margin: 0;
+				font-family: tahoma, verdana, arial, helvetica, sans-serif;
+				overflow: hidden;
+			}
+
+			div#switchesContainer input {
+				margin-bottom: 0;
+			}
+
+			div.toolbar {
+				border-top: solid #ffffff 1px;
+				border-bottom: solid #aca899 1px;
+				background-color: #f1efe7;
+				padding: 3px 5px;
+				font-size: 68.75%;
+			}
+
+			div.toolbar, div#search input {
+				font-family: tahoma, verdana, arial, helvetica, sans-serif;
+			}
+
+			div.toolbar input.button {
+				padding: 0 5px;
+				font-size: 100%;
+			}
+
+			div.toolbar input.hidden {
+				display: none;
+			}
+
+			div#switches input#clearButton {
+				margin-left: 20px;
+			}
+
+			div#levels label {
+				font-weight: bold;
+			}
+
+			div#levels label, div#options label {
+				margin-right: 5px;
+			}
+
+			div#levels label#wrapLabel {
+				font-weight: normal;
+			}
+
+			div#search label {
+				margin-right: 10px;
+			}
+
+			div#search label.searchboxlabel {
+				margin-right: 0;
+			}
+
+			div#search input {
+				font-size: 100%;
+			}
+
+			div#search input.validregex {
+				color: green;
+			}
+
+			div#search input.invalidregex {
+				color: red;
+			}
+
+			div#search input.nomatches {
+				color: white;
+				background-color: #ff6666;
+			}
+
+			div#search input.nomatches {
+				color: white;
+				background-color: #ff6666;
+			}
+
+			div#searchNav {
+				display: none;
+			}
+
+			div#commandLine {
+				display: none;
+			}
+
+			div#commandLine input#command {
+				font-size: 100%;
+				font-family: Courier New, Courier;
+			}
+
+			div#commandLine input#evaluateButton {
+			}
+
+			*.greyedout {
+				color: gray !important;
+				border-color: gray !important;
+			}
+
+			*.greyedout *.alwaysenabled { color: black; }
+
+			*.unselectable {
+				-khtml-user-select: none;
+				-moz-user-select: none;
+				user-select: none;
+			}
+
+			div#log {
+				font-family: Courier New, Courier;
+				font-size: 75%;
+				width: 100%;
+				overflow: auto;
+				clear: both;
+				position: relative;
+			}
+
+			div.group {
+				border-color: #cccccc;
+				border-style: solid;
+				border-width: 1px 0 1px 1px;
+				overflow: visible;
+			}
+
+			div.oldIe div.group, div.oldIe div.group *, div.oldIe *.logentry {
+				height: 1%;
+			}
+
+			div.group div.groupheading span.expander {
+				border: solid black 1px;
+				font-family: Courier New, Courier;
+				font-size: 0.833em;
+				background-color: #eeeeee;
+				position: relative;
+				top: -1px;
+				color: black;
+				padding: 0 2px;
+				cursor: pointer;
+				cursor: hand;
+				height: 1%;
+			}
+
+			div.group div.groupcontent {
+				margin-left: 10px;
+				padding-bottom: 2px;
+				overflow: visible;
+			}
+
+			div.group div.expanded {
+				display: block;
+			}
+
+			div.group div.collapsed {
+				display: none;
+			}
+
+			*.logentry {
+				overflow: visible;
+				display: none;
+				white-space: pre;
+			}
+
+			span.pre {
+				white-space: pre;
+			}
+			
+			pre.unwrapped {
+				display: inline !important;
+			}
+
+			pre.unwrapped pre.pre, div.wrapped pre.pre {
+				display: inline;
+			}
+
+			div.wrapped pre.pre {
+				white-space: normal;
+			}
+
+			div.wrapped {
+				display: none;
+			}
+
+			body.searching *.logentry span.currentmatch {
+				color: white !important;
+				background-color: green !important;
+			}
+
+			body.searching div.searchhighlight *.logentry span.searchterm {
+				color: black;
+				background-color: yellow;
+			}
+
+			div.wrap *.logentry {
+				white-space: normal !important;
+				border-width: 0 0 1px 0;
+				border-color: #dddddd;
+				border-style: dotted;
+			}
+
+			div.wrap #log_wrapped, #log_unwrapped {
+				display: block;
+			}
+
+			div.wrap #log_unwrapped, #log_wrapped {
+				display: none;
+			}
+
+			div.wrap *.logentry span.pre {
+				overflow: visible;
+				white-space: normal;
+			}
+
+			div.wrap *.logentry pre.unwrapped {
+				display: none;
+			}
+
+			div.wrap *.logentry span.wrapped {
+				display: inline;
+			}
+
+			div.searchfilter *.searchnonmatch {
+				display: none !important;
+			}
+
+			div#log *.TRACE, label#label_TRACE {
+				color: #666666;
+			}
+
+			div#log *.DEBUG, label#label_DEBUG {
+				color: green;
+			}
+
+			div#log *.INFO, label#label_INFO {
+				color: #000099;
+			}
+
+			div#log *.WARN, label#label_WARN {
+				color: #999900;
+			}
+
+			div#log *.ERROR, label#label_ERROR {
+				color: red;
+			}
+
+			div#log *.FATAL, label#label_FATAL {
+				color: #660066;
+			}
+
+			div.TRACE#log *.TRACE,
+			div.DEBUG#log *.DEBUG,
+			div.INFO#log *.INFO,
+			div.WARN#log *.WARN,
+			div.ERROR#log *.ERROR,
+			div.FATAL#log *.FATAL {
+				display: block;
+			}
+
+			div#log div.separator {
+				background-color: #cccccc;
+				margin: 5px 0;
+				line-height: 1px;
+			}
+		</style>
+	</head>
+
+	<body id="body">
+		<div id="switchesContainer">
+			<div id="switches">
+				<div id="levels" class="toolbar">
+					Filters:
+					<input type="checkbox" id="switch_TRACE" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide trace messages" /><label for="switch_TRACE" id="label_TRACE">trace</label>
+					<input type="checkbox" id="switch_DEBUG" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide debug messages" /><label for="switch_DEBUG" id="label_DEBUG">debug</label>
+					<input type="checkbox" id="switch_INFO" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide info messages" /><label for="switch_INFO" id="label_INFO">info</label>
+					<input type="checkbox" id="switch_WARN" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide warn messages" /><label for="switch_WARN" id="label_WARN">warn</label>
+					<input type="checkbox" id="switch_ERROR" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide error messages" /><label for="switch_ERROR" id="label_ERROR">error</label>
+					<input type="checkbox" id="switch_FATAL" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide fatal messages" /><label for="switch_FATAL" id="label_FATAL">fatal</label>
+					<input type="checkbox" id="switch_ALL" onclick="toggleAllLevels(); applyFilters()" checked="checked" title="Show/hide all messages" /><label for="switch_ALL" id="label_ALL">all</label>
+				</div>
+				<div id="search" class="toolbar">
+					<label for="searchBox" class="searchboxlabel">Search:</label> <input type="text" id="searchBox" onclick="toggleSearchEnabled(true)" onkeyup="scheduleSearch()" size="20" />
+					<input type="button" id="searchReset" disabled="disabled" value="Reset" onclick="clearSearch()" class="button" title="Reset the search" />
+					<input type="checkbox" id="searchRegex" onclick="doSearch()" title="If checked, search is treated as a regular expression" /><label for="searchRegex">Regex</label>
+					<input type="checkbox" id="searchCaseSensitive" onclick="doSearch()" title="If checked, search is case sensitive" /><label for="searchCaseSensitive">Match case</label>
+					<input type="checkbox" id="searchDisable" onclick="toggleSearchEnabled()" title="Enable/disable search" /><label for="searchDisable" class="alwaysenabled">Disable</label>
+					<div id="searchNav">
+						<input type="button" id="searchNext" disabled="disabled" value="Next" onclick="searchNext()" class="button" title="Go to the next matching log entry" />
+						<input type="button" id="searchPrevious" disabled="disabled" value="Previous" onclick="searchPrevious()" class="button" title="Go to the previous matching log entry" />
+						<input type="checkbox" id="searchFilter" onclick="toggleSearchFilter()" title="If checked, non-matching log entries are filtered out" /><label for="searchFilter">Filter</label>
+						<input type="checkbox" id="searchHighlight" onclick="toggleSearchHighlight()" title="Highlight matched search terms" /><label for="searchHighlight" class="alwaysenabled">Highlight all</label>
+					</div>
+				</div>
+				<div id="options" class="toolbar">
+					Options:
+					<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Log</label>
+					<input type="checkbox" id="wrap" onclick="toggleWrap()" title="Enable / disable word wrap" /><label for="wrap" id="wrapLabel">Wrap</label>
+					<input type="checkbox" id="newestAtTop" onclick="toggleNewestAtTop()" title="If checked, causes newest messages to appear at the top" /><label for="newestAtTop" id="newestAtTopLabel">Newest at the top</label>
+					<input type="checkbox" id="scrollToLatest" onclick="toggleScrollToLatest()" checked="checked" title="If checked, window automatically scrolls to a new message when it is added" /><label for="scrollToLatest" id="scrollToLatestLabel">Scroll to latest</label>
+					<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="button" title="Clear all log messages"  />
+					<input type="button" id="hideButton" value="Hide" onclick="hide()" class="hidden button" title="Hide the console" />
+					<input type="button" id="closeButton" value="Close" onclick="closeWindow()" class="hidden button" title="Close the window" />
+				</div>
+			</div>
+		</div>
+		<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>
+		<div id="commandLine" class="toolbar">
+			<div id="commandLineContainer">
+				<input type="text" id="command" title="Enter a JavaScript command here and hit return or press 'Evaluate'" />
+				<input type="button" id="evaluateButton" value="Evaluate" class="button" title="Evaluate the command" onclick="evalCommandLine()" />
+			</div>
+		</div>
+	</body>
+</html>
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/liteconsole.html b/planetstack/core/static/log4javascript-1.4.6/js/liteconsole.html
new file mode 100644
index 0000000..840a59b
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/liteconsole.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+<title>log4javascript</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->
+<meta http-equiv="X-UA-Compatible" content="IE=7" />
+<script type="text/javascript">
+//<![CDATA[
+var loggingEnabled=true;var messagesBeforeDocLoaded=[];function toggleLoggingEnabled(){setLoggingEnabled($("enableLogging").checked);}
+function setLoggingEnabled(enable){loggingEnabled=enable;}
+function scrollToLatestEntry(){var l=getLogContainer();if(typeof l.scrollTop!="undefined"){var latestLogEntry=l.lastChild;if(latestLogEntry){l.scrollTop=l.scrollHeight;}}}
+function log(logLevel,formattedMessage){if(loggingEnabled){if(loaded){doLog(logLevel,formattedMessage);}else{messagesBeforeDocLoaded.push([logLevel,formattedMessage]);}}}
+function doLog(logLevel,formattedMessage){var logEntry=document.createElement("div");logEntry.appendChild(document.createTextNode(formattedMessage));logEntry.className="logentry "+logLevel.name;getLogContainer().appendChild(logEntry);scrollToLatestEntry();}
+function mainPageReloaded(){var separator=document.createElement("div");separator.className="separator";separator.innerHTML="&nbsp;";getLogContainer().appendChild(separator);}
+var loaded=false;var logLevels=["DEBUG","INFO","WARN","ERROR","FATAL"];window.onload=function(){setLogContainerHeight();toggleLoggingEnabled();for(var i=0;i<messagesBeforeDocLoaded.length;i++){doLog(messagesBeforeDocLoaded[i][0],messagesBeforeDocLoaded[i][1]);}
+messagesBeforeDocLoaded=[];loaded=true;setTimeout(setLogContainerHeight,20);};function getLogContainer(){return $("log");}
+function clearLog(){getLogContainer().innerHTML="";}
+function $(id){return document.getElementById(id);}
+function getWindowHeight(){if(window.innerHeight){return window.innerHeight;}else if(document.documentElement&&document.documentElement.clientHeight){return document.documentElement.clientHeight;}else if(document.body){return document.body.clientHeight;}
+return 0;}
+function getChromeHeight(){return $("toolbar").offsetHeight;}
+function setLogContainerHeight(){var windowHeight=getWindowHeight();$("body").style.height=getWindowHeight()+"px";getLogContainer().style.height=""+
+Math.max(0,windowHeight-getChromeHeight())+"px";}
+window.onresize=function(){setLogContainerHeight();};
+//]]>
+</script>
+<style type="text/css">
+body{background-color:white;color:black;padding:0;margin:0;font-family:tahoma,verdana,arial,helvetica,sans-serif;overflow:hidden}div#toolbar{border-top:solid #ffffff 1px;border-bottom:solid #aca899 1px;background-color:#f1efe7;padding:3px 5px;font-size:68.75%}div#toolbar input.button{padding:0 5px;font-size:100%}div#log{font-family:Courier New,Courier;font-size:75%;width:100%;overflow:auto;clear:both}*.logentry{overflow:visible;white-space:pre}*.TRACE{color:#666666}*.DEBUG{color:green}*.INFO{color:#000099}*.WARN{color:#999900}*.ERROR{color:red}*.FATAL{color:#660066}div#log div.separator{background-color:#cccccc;margin:5px 0;line-height:1px}
+</style>
+</head>
+<body id="body">
+<div id="toolbar">
+Options:
+<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" class="stateful" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Enable logging</label>
+<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="stateful button" title="Clear all log messages"  />
+<input type="button" id="closeButton" value="Close" onclick="window.close()" class="stateful button" title="Close the window" />
+</div>
+<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>
+</body>
+</html>
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/liteconsole_uncompressed.html b/planetstack/core/static/log4javascript-1.4.6/js/liteconsole_uncompressed.html
new file mode 100644
index 0000000..df5275f
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/liteconsole_uncompressed.html
@@ -0,0 +1,194 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+	<head>
+		<title>log4javascript</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+		<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->
+		<meta http-equiv="X-UA-Compatible" content="IE=7" />
+		<script type="text/javascript">
+			//<![CDATA[
+			var loggingEnabled = true;
+			var messagesBeforeDocLoaded = [];
+
+			function toggleLoggingEnabled() {
+				setLoggingEnabled($("enableLogging").checked);
+			}
+
+			function setLoggingEnabled(enable) {
+				loggingEnabled = enable;
+			}
+
+			function scrollToLatestEntry() {
+				var l = getLogContainer();
+				if (typeof l.scrollTop != "undefined") {
+					var latestLogEntry = l.lastChild;
+					if (latestLogEntry) {
+						l.scrollTop = l.scrollHeight;
+					}
+				}
+			}
+
+			function log(logLevel, formattedMessage) {
+				if (loggingEnabled) {
+					if (loaded) {
+						doLog(logLevel, formattedMessage);
+					} else {
+						messagesBeforeDocLoaded.push([logLevel, formattedMessage]);
+					}
+				}
+			}
+
+			function doLog(logLevel, formattedMessage) {
+				var logEntry = document.createElement("div");
+				logEntry.appendChild(document.createTextNode(formattedMessage));
+				logEntry.className = "logentry " + logLevel.name;
+				getLogContainer().appendChild(logEntry);
+				scrollToLatestEntry();
+			}
+
+			function mainPageReloaded() {
+				var separator = document.createElement("div");
+				separator.className = "separator";
+				separator.innerHTML = "&nbsp;";
+				getLogContainer().appendChild(separator);
+			}
+
+			var loaded = false;
+			var logLevels = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"];
+
+			window.onload = function() {
+				setLogContainerHeight();
+				toggleLoggingEnabled();
+				for (var i = 0; i < messagesBeforeDocLoaded.length; i++) {
+					doLog(messagesBeforeDocLoaded[i][0], messagesBeforeDocLoaded[i][1]);
+				}
+				messagesBeforeDocLoaded = [];
+				loaded = true;
+
+				// Workaround to make sure log div starts at the correct size
+				setTimeout(setLogContainerHeight, 20);
+			};
+
+			function getLogContainer() {
+				return $("log");
+			}
+
+			function clearLog() {
+				getLogContainer().innerHTML = "";
+			}
+
+			/* ------------------------------------------------------------------------- */
+
+			// Other utility functions
+
+			// Syntax borrowed from Prototype library
+			function $(id) {
+				return document.getElementById(id);
+			}
+
+			function getWindowHeight() {
+				if (window.innerHeight) {
+					return window.innerHeight;
+				} else if (document.documentElement && document.documentElement.clientHeight) {
+					return document.documentElement.clientHeight;
+				} else if (document.body) {
+					return document.body.clientHeight;
+				}
+				return 0;
+			}
+
+			function getChromeHeight() {
+				return $("toolbar").offsetHeight;
+			}
+
+			function setLogContainerHeight() {
+				var windowHeight = getWindowHeight();
+				$("body").style.height = getWindowHeight() + "px";
+				getLogContainer().style.height = "" +
+					Math.max(0, windowHeight - getChromeHeight()) + "px";
+			}
+
+			window.onresize = function() {
+				setLogContainerHeight();
+			};
+
+			//]]>
+		</script>
+		<style type="text/css">
+			body {
+				background-color: white;
+				color: black;
+				padding: 0;
+				margin: 0;
+				font-family: tahoma, verdana, arial, helvetica, sans-serif;
+				overflow: hidden;
+			}
+			
+			div#toolbar {
+				border-top: solid #ffffff 1px;
+				border-bottom: solid #aca899 1px;
+				background-color: #f1efe7;
+				padding: 3px 5px;
+				font-size: 68.75%;
+			}
+
+			div#toolbar input.button {
+				padding: 0 5px;
+				font-size: 100%;
+			}
+
+			div#log {
+				font-family: Courier New, Courier;
+				font-size: 75%;
+				width: 100%;
+				overflow: auto;
+				clear: both;
+			}
+
+			*.logentry {
+				overflow: visible;
+				white-space: pre;
+			}
+
+			*.TRACE {
+				color: #666666;
+			}
+
+			*.DEBUG {
+				color: green;
+			}
+
+			*.INFO {
+				color: #000099;
+			}
+
+			*.WARN {
+				color: #999900;
+			}
+
+			*.ERROR {
+				color: red;
+			}
+
+			*.FATAL {
+				color: #660066;
+			}
+
+			div#log div.separator {
+				background-color: #cccccc;
+				margin: 5px 0;
+				line-height: 1px;
+			}
+		</style>
+	</head>
+
+	<body id="body">
+		<div id="toolbar">
+			Options:
+			<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" class="stateful" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Enable logging</label>
+			<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="stateful button" title="Clear all log messages"  />
+			<input type="button" id="closeButton" value="Close" onclick="window.close()" class="stateful button" title="Close the window" />
+		</div>
+		<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>
+	</body>
+</html>
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript.js
new file mode 100644
index 0000000..042daa9
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript.js
@@ -0,0 +1,274 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if(!Array.prototype.push){Array.prototype.push=function(){for(var i=0,len=arguments.length;i<len;i++){this[this.length]=arguments[i];}
+return this.length;};}
+if(!Array.prototype.shift){Array.prototype.shift=function(){if(this.length>0){var firstItem=this[0];for(var i=0,len=this.length-1;i<len;i++){this[i]=this[i+1];}
+this.length=this.length-1;return firstItem;}};}
+if(!Array.prototype.splice){Array.prototype.splice=function(startIndex,deleteCount){var itemsAfterDeleted=this.slice(startIndex+deleteCount);var itemsDeleted=this.slice(startIndex,startIndex+deleteCount);this.length=startIndex;var argumentsArray=[];for(var i=0,len=arguments.length;i<len;i++){argumentsArray[i]=arguments[i];}
+var itemsToAppend=(argumentsArray.length>2)?itemsAfterDeleted=argumentsArray.slice(2).concat(itemsAfterDeleted):itemsAfterDeleted;for(i=0,len=itemsToAppend.length;i<len;i++){this.push(itemsToAppend[i]);}
+return itemsDeleted;};}
+var log4javascript=(function(){function isUndefined(obj){return typeof obj=="undefined";}
+function EventSupport(){}
+EventSupport.prototype={eventTypes:[],eventListeners:{},setEventTypes:function(eventTypesParam){if(eventTypesParam instanceof Array){this.eventTypes=eventTypesParam;this.eventListeners={};for(var i=0,len=this.eventTypes.length;i<len;i++){this.eventListeners[this.eventTypes[i]]=[];}}else{handleError("log4javascript.EventSupport ["+this+"]: setEventTypes: eventTypes parameter must be an Array");}},addEventListener:function(eventType,listener){if(typeof listener=="function"){if(!array_contains(this.eventTypes,eventType)){handleError("log4javascript.EventSupport ["+this+"]: addEventListener: no event called '"+eventType+"'");}
+this.eventListeners[eventType].push(listener);}else{handleError("log4javascript.EventSupport ["+this+"]: addEventListener: listener must be a function");}},removeEventListener:function(eventType,listener){if(typeof listener=="function"){if(!array_contains(this.eventTypes,eventType)){handleError("log4javascript.EventSupport ["+this+"]: removeEventListener: no event called '"+eventType+"'");}
+array_remove(this.eventListeners[eventType],listener);}else{handleError("log4javascript.EventSupport ["+this+"]: removeEventListener: listener must be a function");}},dispatchEvent:function(eventType,eventArgs){if(array_contains(this.eventTypes,eventType)){var listeners=this.eventListeners[eventType];for(var i=0,len=listeners.length;i<len;i++){listeners[i](this,eventType,eventArgs);}}else{handleError("log4javascript.EventSupport ["+this+"]: dispatchEvent: no event called '"+eventType+"'");}}};var applicationStartDate=new Date();var uniqueId="log4javascript_"+applicationStartDate.getTime()+"_"+
+Math.floor(Math.random()*100000000);var emptyFunction=function(){};var newLine="\r\n";var pageLoaded=false;function Log4JavaScript(){}
+Log4JavaScript.prototype=new EventSupport();log4javascript=new Log4JavaScript();log4javascript.version="1.4.6";log4javascript.edition="log4javascript";function toStr(obj){if(obj&&obj.toString){return obj.toString();}else{return String(obj);}}
+function getExceptionMessage(ex){if(ex.message){return ex.message;}else if(ex.description){return ex.description;}else{return toStr(ex);}}
+function getUrlFileName(url){var lastSlashIndex=Math.max(url.lastIndexOf("/"),url.lastIndexOf("\\"));return url.substr(lastSlashIndex+1);}
+function getExceptionStringRep(ex){if(ex){var exStr="Exception: "+getExceptionMessage(ex);try{if(ex.lineNumber){exStr+=" on line number "+ex.lineNumber;}
+if(ex.fileName){exStr+=" in file "+getUrlFileName(ex.fileName);}}catch(localEx){logLog.warn("Unable to obtain file and line information for error");}
+if(showStackTraces&&ex.stack){exStr+=newLine+"Stack trace:"+newLine+ex.stack;}
+return exStr;}
+return null;}
+function bool(obj){return Boolean(obj);}
+function trim(str){return str.replace(/^\s+/,"").replace(/\s+$/,"");}
+function splitIntoLines(text){var text2=text.replace(/\r\n/g,"\n").replace(/\r/g,"\n");return text2.split("\n");}
+var urlEncode=(typeof window.encodeURIComponent!="undefined")?function(str){return encodeURIComponent(str);}:function(str){return escape(str).replace(/\+/g,"%2B").replace(/"/g,"%22").replace(/'/g,"%27").replace(/\//g,"%2F").replace(/=/g,"%3D");};var urlDecode=(typeof window.decodeURIComponent!="undefined")?function(str){return decodeURIComponent(str);}:function(str){return unescape(str).replace(/%2B/g,"+").replace(/%22/g,"\"").replace(/%27/g,"'").replace(/%2F/g,"/").replace(/%3D/g,"=");};function array_remove(arr,val){var index=-1;for(var i=0,len=arr.length;i<len;i++){if(arr[i]===val){index=i;break;}}
+if(index>=0){arr.splice(index,1);return true;}else{return false;}}
+function array_contains(arr,val){for(var i=0,len=arr.length;i<len;i++){if(arr[i]==val){return true;}}
+return false;}
+function extractBooleanFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{return bool(param);}}
+function extractStringFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{return String(param);}}
+function extractIntFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{try{var value=parseInt(param,10);return isNaN(value)?defaultValue:value;}catch(ex){logLog.warn("Invalid int param "+param,ex);return defaultValue;}}}
+function extractFunctionFromParam(param,defaultValue){if(typeof param=="function"){return param;}else{return defaultValue;}}
+function isError(err){return(err instanceof Error);}
+if(!Function.prototype.apply){Function.prototype.apply=function(obj,args){var methodName="__apply__";if(typeof obj[methodName]!="undefined"){methodName+=String(Math.random()).substr(2);}
+obj[methodName]=this;var argsStrings=[];for(var i=0,len=args.length;i<len;i++){argsStrings[i]="args["+i+"]";}
+var script="obj."+methodName+"("+argsStrings.join(",")+")";var returnValue=eval(script);delete obj[methodName];return returnValue;};}
+if(!Function.prototype.call){Function.prototype.call=function(obj){var args=[];for(var i=1,len=arguments.length;i<len;i++){args[i-1]=arguments[i];}
+return this.apply(obj,args);};}
+function getListenersPropertyName(eventName){return"__log4javascript_listeners__"+eventName;}
+function addEvent(node,eventName,listener,useCapture,win){win=win?win:window;if(node.addEventListener){node.addEventListener(eventName,listener,useCapture);}else if(node.attachEvent){node.attachEvent("on"+eventName,listener);}else{var propertyName=getListenersPropertyName(eventName);if(!node[propertyName]){node[propertyName]=[];node["on"+eventName]=function(evt){evt=getEvent(evt,win);var listenersPropertyName=getListenersPropertyName(eventName);var listeners=this[listenersPropertyName].concat([]);var currentListener;while((currentListener=listeners.shift())){currentListener.call(this,evt);}};}
+node[propertyName].push(listener);}}
+function removeEvent(node,eventName,listener,useCapture){if(node.removeEventListener){node.removeEventListener(eventName,listener,useCapture);}else if(node.detachEvent){node.detachEvent("on"+eventName,listener);}else{var propertyName=getListenersPropertyName(eventName);if(node[propertyName]){array_remove(node[propertyName],listener);}}}
+function getEvent(evt,win){win=win?win:window;return evt?evt:win.event;}
+function stopEventPropagation(evt){if(evt.stopPropagation){evt.stopPropagation();}else if(typeof evt.cancelBubble!="undefined"){evt.cancelBubble=true;}
+evt.returnValue=false;}
+var logLog={quietMode:false,debugMessages:[],setQuietMode:function(quietMode){this.quietMode=bool(quietMode);},numberOfErrors:0,alertAllErrors:false,setAlertAllErrors:function(alertAllErrors){this.alertAllErrors=alertAllErrors;},debug:function(message){this.debugMessages.push(message);},displayDebug:function(){alert(this.debugMessages.join(newLine));},warn:function(message,exception){},error:function(message,exception){if(++this.numberOfErrors==1||this.alertAllErrors){if(!this.quietMode){var alertMessage="log4javascript error: "+message;if(exception){alertMessage+=newLine+newLine+"Original error: "+getExceptionStringRep(exception);}
+alert(alertMessage);}}}};log4javascript.logLog=logLog;log4javascript.setEventTypes(["load","error"]);function handleError(message,exception){logLog.error(message,exception);log4javascript.dispatchEvent("error",{"message":message,"exception":exception});}
+log4javascript.handleError=handleError;var enabled=!((typeof log4javascript_disabled!="undefined")&&log4javascript_disabled);log4javascript.setEnabled=function(enable){enabled=bool(enable);};log4javascript.isEnabled=function(){return enabled;};var useTimeStampsInMilliseconds=true;log4javascript.setTimeStampsInMilliseconds=function(timeStampsInMilliseconds){useTimeStampsInMilliseconds=bool(timeStampsInMilliseconds);};log4javascript.isTimeStampsInMilliseconds=function(){return useTimeStampsInMilliseconds;};log4javascript.evalInScope=function(expr){return eval(expr);};var showStackTraces=false;log4javascript.setShowStackTraces=function(show){showStackTraces=bool(show);};var Level=function(level,name){this.level=level;this.name=name;};Level.prototype={toString:function(){return this.name;},equals:function(level){return this.level==level.level;},isGreaterOrEqual:function(level){return this.level>=level.level;}};Level.ALL=new Level(Number.MIN_VALUE,"ALL");Level.TRACE=new Level(10000,"TRACE");Level.DEBUG=new Level(20000,"DEBUG");Level.INFO=new Level(30000,"INFO");Level.WARN=new Level(40000,"WARN");Level.ERROR=new Level(50000,"ERROR");Level.FATAL=new Level(60000,"FATAL");Level.OFF=new Level(Number.MAX_VALUE,"OFF");log4javascript.Level=Level;function Timer(name,level){this.name=name;this.level=isUndefined(level)?Level.INFO:level;this.start=new Date();}
+Timer.prototype.getElapsedTime=function(){return new Date().getTime()-this.start.getTime();};var anonymousLoggerName="[anonymous]";var defaultLoggerName="[default]";var nullLoggerName="[null]";var rootLoggerName="root";function Logger(name){this.name=name;this.parent=null;this.children=[];var appenders=[];var loggerLevel=null;var isRoot=(this.name===rootLoggerName);var isNull=(this.name===nullLoggerName);var appenderCache=null;var appenderCacheInvalidated=false;this.addChild=function(childLogger){this.children.push(childLogger);childLogger.parent=this;childLogger.invalidateAppenderCache();};var additive=true;this.getAdditivity=function(){return additive;};this.setAdditivity=function(additivity){var valueChanged=(additive!=additivity);additive=additivity;if(valueChanged){this.invalidateAppenderCache();}};this.addAppender=function(appender){if(isNull){handleError("Logger.addAppender: you may not add an appender to the null logger");}else{if(appender instanceof log4javascript.Appender){if(!array_contains(appenders,appender)){appenders.push(appender);appender.setAddedToLogger(this);this.invalidateAppenderCache();}}else{handleError("Logger.addAppender: appender supplied ('"+
+toStr(appender)+"') is not a subclass of Appender");}}};this.removeAppender=function(appender){array_remove(appenders,appender);appender.setRemovedFromLogger(this);this.invalidateAppenderCache();};this.removeAllAppenders=function(){var appenderCount=appenders.length;if(appenderCount>0){for(var i=0;i<appenderCount;i++){appenders[i].setRemovedFromLogger(this);}
+appenders.length=0;this.invalidateAppenderCache();}};this.getEffectiveAppenders=function(){if(appenderCache===null||appenderCacheInvalidated){var parentEffectiveAppenders=(isRoot||!this.getAdditivity())?[]:this.parent.getEffectiveAppenders();appenderCache=parentEffectiveAppenders.concat(appenders);appenderCacheInvalidated=false;}
+return appenderCache;};this.invalidateAppenderCache=function(){appenderCacheInvalidated=true;for(var i=0,len=this.children.length;i<len;i++){this.children[i].invalidateAppenderCache();}};this.log=function(level,params){if(enabled&&level.isGreaterOrEqual(this.getEffectiveLevel())){var exception;var finalParamIndex=params.length-1;var lastParam=params[finalParamIndex];if(params.length>1&&isError(lastParam)){exception=lastParam;finalParamIndex--;}
+var messages=[];for(var i=0;i<=finalParamIndex;i++){messages[i]=params[i];}
+var loggingEvent=new LoggingEvent(this,new Date(),level,messages,exception);this.callAppenders(loggingEvent);}};this.callAppenders=function(loggingEvent){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].doAppend(loggingEvent);}};this.setLevel=function(level){if(isRoot&&level===null){handleError("Logger.setLevel: you cannot set the level of the root logger to null");}else if(level instanceof Level){loggerLevel=level;}else{handleError("Logger.setLevel: level supplied to logger "+
+this.name+" is not an instance of log4javascript.Level");}};this.getLevel=function(){return loggerLevel;};this.getEffectiveLevel=function(){for(var logger=this;logger!==null;logger=logger.parent){var level=logger.getLevel();if(level!==null){return level;}}};this.group=function(name,initiallyExpanded){if(enabled){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].group(name,initiallyExpanded);}}};this.groupEnd=function(){if(enabled){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].groupEnd();}}};var timers={};this.time=function(name,level){if(enabled){if(isUndefined(name)){handleError("Logger.time: a name for the timer must be supplied");}else if(level&&!(level instanceof Level)){handleError("Logger.time: level supplied to timer "+
+name+" is not an instance of log4javascript.Level");}else{timers[name]=new Timer(name,level);}}};this.timeEnd=function(name){if(enabled){if(isUndefined(name)){handleError("Logger.timeEnd: a name for the timer must be supplied");}else if(timers[name]){var timer=timers[name];var milliseconds=timer.getElapsedTime();this.log(timer.level,["Timer "+toStr(name)+" completed in "+milliseconds+"ms"]);delete timers[name];}else{logLog.warn("Logger.timeEnd: no timer found with name "+name);}}};this.assert=function(expr){if(enabled&&!expr){var args=[];for(var i=1,len=arguments.length;i<len;i++){args.push(arguments[i]);}
+args=(args.length>0)?args:["Assertion Failure"];args.push(newLine);args.push(expr);this.log(Level.ERROR,args);}};this.toString=function(){return"Logger["+this.name+"]";};}
+Logger.prototype={trace:function(){this.log(Level.TRACE,arguments);},debug:function(){this.log(Level.DEBUG,arguments);},info:function(){this.log(Level.INFO,arguments);},warn:function(){this.log(Level.WARN,arguments);},error:function(){this.log(Level.ERROR,arguments);},fatal:function(){this.log(Level.FATAL,arguments);},isEnabledFor:function(level){return level.isGreaterOrEqual(this.getEffectiveLevel());},isTraceEnabled:function(){return this.isEnabledFor(Level.TRACE);},isDebugEnabled:function(){return this.isEnabledFor(Level.DEBUG);},isInfoEnabled:function(){return this.isEnabledFor(Level.INFO);},isWarnEnabled:function(){return this.isEnabledFor(Level.WARN);},isErrorEnabled:function(){return this.isEnabledFor(Level.ERROR);},isFatalEnabled:function(){return this.isEnabledFor(Level.FATAL);}};Logger.prototype.trace.isEntryPoint=true;Logger.prototype.debug.isEntryPoint=true;Logger.prototype.info.isEntryPoint=true;Logger.prototype.warn.isEntryPoint=true;Logger.prototype.error.isEntryPoint=true;Logger.prototype.fatal.isEntryPoint=true;var loggers={};var loggerNames=[];var ROOT_LOGGER_DEFAULT_LEVEL=Level.DEBUG;var rootLogger=new Logger(rootLoggerName);rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);log4javascript.getRootLogger=function(){return rootLogger;};log4javascript.getLogger=function(loggerName){if(!(typeof loggerName=="string")){loggerName=anonymousLoggerName;logLog.warn("log4javascript.getLogger: non-string logger name "+
+toStr(loggerName)+" supplied, returning anonymous logger");}
+if(loggerName==rootLoggerName){handleError("log4javascript.getLogger: root logger may not be obtained by name");}
+if(!loggers[loggerName]){var logger=new Logger(loggerName);loggers[loggerName]=logger;loggerNames.push(loggerName);var lastDotIndex=loggerName.lastIndexOf(".");var parentLogger;if(lastDotIndex>-1){var parentLoggerName=loggerName.substring(0,lastDotIndex);parentLogger=log4javascript.getLogger(parentLoggerName);}else{parentLogger=rootLogger;}
+parentLogger.addChild(logger);}
+return loggers[loggerName];};var defaultLogger=null;log4javascript.getDefaultLogger=function(){if(!defaultLogger){defaultLogger=log4javascript.getLogger(defaultLoggerName);var a=new log4javascript.PopUpAppender();defaultLogger.addAppender(a);}
+return defaultLogger;};var nullLogger=null;log4javascript.getNullLogger=function(){if(!nullLogger){nullLogger=new Logger(nullLoggerName);nullLogger.setLevel(Level.OFF);}
+return nullLogger;};log4javascript.resetConfiguration=function(){rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);loggers={};};var LoggingEvent=function(logger,timeStamp,level,messages,exception){this.logger=logger;this.timeStamp=timeStamp;this.timeStampInMilliseconds=timeStamp.getTime();this.timeStampInSeconds=Math.floor(this.timeStampInMilliseconds/1000);this.milliseconds=this.timeStamp.getMilliseconds();this.level=level;this.messages=messages;this.exception=exception;};LoggingEvent.prototype={getThrowableStrRep:function(){return this.exception?getExceptionStringRep(this.exception):"";},getCombinedMessages:function(){return(this.messages.length==1)?this.messages[0]:this.messages.join(newLine);},toString:function(){return"LoggingEvent["+this.level+"]";}};log4javascript.LoggingEvent=LoggingEvent;var Layout=function(){};Layout.prototype={defaults:{loggerKey:"logger",timeStampKey:"timestamp",millisecondsKey:"milliseconds",levelKey:"level",messageKey:"message",exceptionKey:"exception",urlKey:"url"},loggerKey:"logger",timeStampKey:"timestamp",millisecondsKey:"milliseconds",levelKey:"level",messageKey:"message",exceptionKey:"exception",urlKey:"url",batchHeader:"",batchFooter:"",batchSeparator:"",returnsPostData:false,overrideTimeStampsSetting:false,useTimeStampsInMilliseconds:null,format:function(){handleError("Layout.format: layout supplied has no format() method");},ignoresThrowable:function(){handleError("Layout.ignoresThrowable: layout supplied has no ignoresThrowable() method");},getContentType:function(){return"text/plain";},allowBatching:function(){return true;},setTimeStampsInMilliseconds:function(timeStampsInMilliseconds){this.overrideTimeStampsSetting=true;this.useTimeStampsInMilliseconds=bool(timeStampsInMilliseconds);},isTimeStampsInMilliseconds:function(){return this.overrideTimeStampsSetting?this.useTimeStampsInMilliseconds:useTimeStampsInMilliseconds;},getTimeStampValue:function(loggingEvent){return this.isTimeStampsInMilliseconds()?loggingEvent.timeStampInMilliseconds:loggingEvent.timeStampInSeconds;},getDataValues:function(loggingEvent,combineMessages){var dataValues=[[this.loggerKey,loggingEvent.logger.name],[this.timeStampKey,this.getTimeStampValue(loggingEvent)],[this.levelKey,loggingEvent.level.name],[this.urlKey,window.location.href],[this.messageKey,combineMessages?loggingEvent.getCombinedMessages():loggingEvent.messages]];if(!this.isTimeStampsInMilliseconds()){dataValues.push([this.millisecondsKey,loggingEvent.milliseconds]);}
+if(loggingEvent.exception){dataValues.push([this.exceptionKey,getExceptionStringRep(loggingEvent.exception)]);}
+if(this.hasCustomFields()){for(var i=0,len=this.customFields.length;i<len;i++){var val=this.customFields[i].value;if(typeof val==="function"){val=val(this,loggingEvent);}
+dataValues.push([this.customFields[i].name,val]);}}
+return dataValues;},setKeys:function(loggerKey,timeStampKey,levelKey,messageKey,exceptionKey,urlKey,millisecondsKey){this.loggerKey=extractStringFromParam(loggerKey,this.defaults.loggerKey);this.timeStampKey=extractStringFromParam(timeStampKey,this.defaults.timeStampKey);this.levelKey=extractStringFromParam(levelKey,this.defaults.levelKey);this.messageKey=extractStringFromParam(messageKey,this.defaults.messageKey);this.exceptionKey=extractStringFromParam(exceptionKey,this.defaults.exceptionKey);this.urlKey=extractStringFromParam(urlKey,this.defaults.urlKey);this.millisecondsKey=extractStringFromParam(millisecondsKey,this.defaults.millisecondsKey);},setCustomField:function(name,value){var fieldUpdated=false;for(var i=0,len=this.customFields.length;i<len;i++){if(this.customFields[i].name===name){this.customFields[i].value=value;fieldUpdated=true;}}
+if(!fieldUpdated){this.customFields.push({"name":name,"value":value});}},hasCustomFields:function(){return(this.customFields.length>0);},toString:function(){handleError("Layout.toString: all layouts must override this method");}};log4javascript.Layout=Layout;var Appender=function(){};Appender.prototype=new EventSupport();Appender.prototype.layout=new PatternLayout();Appender.prototype.threshold=Level.ALL;Appender.prototype.loggers=[];Appender.prototype.doAppend=function(loggingEvent){if(enabled&&loggingEvent.level.level>=this.threshold.level){this.append(loggingEvent);}};Appender.prototype.append=function(loggingEvent){};Appender.prototype.setLayout=function(layout){if(layout instanceof Layout){this.layout=layout;}else{handleError("Appender.setLayout: layout supplied to "+
+this.toString()+" is not a subclass of Layout");}};Appender.prototype.getLayout=function(){return this.layout;};Appender.prototype.setThreshold=function(threshold){if(threshold instanceof Level){this.threshold=threshold;}else{handleError("Appender.setThreshold: threshold supplied to "+
+this.toString()+" is not a subclass of Level");}};Appender.prototype.getThreshold=function(){return this.threshold;};Appender.prototype.setAddedToLogger=function(logger){this.loggers.push(logger);};Appender.prototype.setRemovedFromLogger=function(logger){array_remove(this.loggers,logger);};Appender.prototype.group=emptyFunction;Appender.prototype.groupEnd=emptyFunction;Appender.prototype.toString=function(){handleError("Appender.toString: all appenders must override this method");};log4javascript.Appender=Appender;function SimpleLayout(){this.customFields=[];}
+SimpleLayout.prototype=new Layout();SimpleLayout.prototype.format=function(loggingEvent){return loggingEvent.level.name+" - "+loggingEvent.getCombinedMessages();};SimpleLayout.prototype.ignoresThrowable=function(){return true;};SimpleLayout.prototype.toString=function(){return"SimpleLayout";};log4javascript.SimpleLayout=SimpleLayout;function NullLayout(){this.customFields=[];}
+NullLayout.prototype=new Layout();NullLayout.prototype.format=function(loggingEvent){return loggingEvent.messages;};NullLayout.prototype.ignoresThrowable=function(){return true;};NullLayout.prototype.toString=function(){return"NullLayout";};log4javascript.NullLayout=NullLayout;function XmlLayout(combineMessages){this.combineMessages=extractBooleanFromParam(combineMessages,true);this.customFields=[];}
+XmlLayout.prototype=new Layout();XmlLayout.prototype.isCombinedMessages=function(){return this.combineMessages;};XmlLayout.prototype.getContentType=function(){return"text/xml";};XmlLayout.prototype.escapeCdata=function(str){return str.replace(/\]\]>/,"]]>]]&gt;<![CDATA[");};XmlLayout.prototype.format=function(loggingEvent){var layout=this;var i,len;function formatMessage(message){message=(typeof message==="string")?message:toStr(message);return"<log4javascript:message><![CDATA["+
+layout.escapeCdata(message)+"]]></log4javascript:message>";}
+var str="<log4javascript:event logger=\""+loggingEvent.logger.name+"\" timestamp=\""+this.getTimeStampValue(loggingEvent)+"\"";if(!this.isTimeStampsInMilliseconds()){str+=" milliseconds=\""+loggingEvent.milliseconds+"\"";}
+str+=" level=\""+loggingEvent.level.name+"\">"+newLine;if(this.combineMessages){str+=formatMessage(loggingEvent.getCombinedMessages());}else{str+="<log4javascript:messages>"+newLine;for(i=0,len=loggingEvent.messages.length;i<len;i++){str+=formatMessage(loggingEvent.messages[i])+newLine;}
+str+="</log4javascript:messages>"+newLine;}
+if(this.hasCustomFields()){for(i=0,len=this.customFields.length;i<len;i++){str+="<log4javascript:customfield name=\""+
+this.customFields[i].name+"\"><![CDATA["+
+this.customFields[i].value.toString()+"]]></log4javascript:customfield>"+newLine;}}
+if(loggingEvent.exception){str+="<log4javascript:exception><![CDATA["+
+getExceptionStringRep(loggingEvent.exception)+"]]></log4javascript:exception>"+newLine;}
+str+="</log4javascript:event>"+newLine+newLine;return str;};XmlLayout.prototype.ignoresThrowable=function(){return false;};XmlLayout.prototype.toString=function(){return"XmlLayout";};log4javascript.XmlLayout=XmlLayout;function escapeNewLines(str){return str.replace(/\r\n|\r|\n/g,"\\r\\n");}
+function JsonLayout(readable,combineMessages){this.readable=extractBooleanFromParam(readable,false);this.combineMessages=extractBooleanFromParam(combineMessages,true);this.batchHeader=this.readable?"["+newLine:"[";this.batchFooter=this.readable?"]"+newLine:"]";this.batchSeparator=this.readable?","+newLine:",";this.setKeys();this.colon=this.readable?": ":":";this.tab=this.readable?"\t":"";this.lineBreak=this.readable?newLine:"";this.customFields=[];}
+JsonLayout.prototype=new Layout();JsonLayout.prototype.isReadable=function(){return this.readable;};JsonLayout.prototype.isCombinedMessages=function(){return this.combineMessages;};JsonLayout.prototype.format=function(loggingEvent){var layout=this;var dataValues=this.getDataValues(loggingEvent,this.combineMessages);var str="{"+this.lineBreak;var i,len;function formatValue(val,prefix,expand){var formattedValue;var valType=typeof val;if(val instanceof Date){formattedValue=String(val.getTime());}else if(expand&&(val instanceof Array)){formattedValue="["+layout.lineBreak;for(var i=0,len=val.length;i<len;i++){var childPrefix=prefix+layout.tab;formattedValue+=childPrefix+formatValue(val[i],childPrefix,false);if(i<val.length-1){formattedValue+=",";}
+formattedValue+=layout.lineBreak;}
+formattedValue+=prefix+"]";}else if(valType!=="number"&&valType!=="boolean"){formattedValue="\""+escapeNewLines(toStr(val).replace(/\"/g,"\\\""))+"\"";}else{formattedValue=val;}
+return formattedValue;}
+for(i=0,len=dataValues.length-1;i<=len;i++){str+=this.tab+"\""+dataValues[i][0]+"\""+this.colon+formatValue(dataValues[i][1],this.tab,true);if(i<len){str+=",";}
+str+=this.lineBreak;}
+str+="}"+this.lineBreak;return str;};JsonLayout.prototype.ignoresThrowable=function(){return false;};JsonLayout.prototype.toString=function(){return"JsonLayout";};JsonLayout.prototype.getContentType=function(){return"application/json";};log4javascript.JsonLayout=JsonLayout;function HttpPostDataLayout(){this.setKeys();this.customFields=[];this.returnsPostData=true;}
+HttpPostDataLayout.prototype=new Layout();HttpPostDataLayout.prototype.allowBatching=function(){return false;};HttpPostDataLayout.prototype.format=function(loggingEvent){var dataValues=this.getDataValues(loggingEvent);var queryBits=[];for(var i=0,len=dataValues.length;i<len;i++){var val=(dataValues[i][1]instanceof Date)?String(dataValues[i][1].getTime()):dataValues[i][1];queryBits.push(urlEncode(dataValues[i][0])+"="+urlEncode(val));}
+return queryBits.join("&");};HttpPostDataLayout.prototype.ignoresThrowable=function(loggingEvent){return false;};HttpPostDataLayout.prototype.toString=function(){return"HttpPostDataLayout";};log4javascript.HttpPostDataLayout=HttpPostDataLayout;function formatObjectExpansion(obj,depth,indentation){var objectsExpanded=[];function doFormat(obj,depth,indentation){var i,j,len,childDepth,childIndentation,childLines,expansion,childExpansion;if(!indentation){indentation="";}
+function formatString(text){var lines=splitIntoLines(text);for(var j=1,jLen=lines.length;j<jLen;j++){lines[j]=indentation+lines[j];}
+return lines.join(newLine);}
+if(obj===null){return"null";}else if(typeof obj=="undefined"){return"undefined";}else if(typeof obj=="string"){return formatString(obj);}else if(typeof obj=="object"&&array_contains(objectsExpanded,obj)){try{expansion=toStr(obj);}catch(ex){expansion="Error formatting property. Details: "+getExceptionStringRep(ex);}
+return expansion+" [already expanded]";}else if((obj instanceof Array)&&depth>0){objectsExpanded.push(obj);expansion="["+newLine;childDepth=depth-1;childIndentation=indentation+"  ";childLines=[];for(i=0,len=obj.length;i<len;i++){try{childExpansion=doFormat(obj[i],childDepth,childIndentation);childLines.push(childIndentation+childExpansion);}catch(ex){childLines.push(childIndentation+"Error formatting array member. Details: "+
+getExceptionStringRep(ex)+"");}}
+expansion+=childLines.join(","+newLine)+newLine+indentation+"]";return expansion;}else if(Object.prototype.toString.call(obj)=="[object Date]"){return obj.toString();}else if(typeof obj=="object"&&depth>0){objectsExpanded.push(obj);expansion="{"+newLine;childDepth=depth-1;childIndentation=indentation+"  ";childLines=[];for(i in obj){try{childExpansion=doFormat(obj[i],childDepth,childIndentation);childLines.push(childIndentation+i+": "+childExpansion);}catch(ex){childLines.push(childIndentation+i+": Error formatting property. Details: "+
+getExceptionStringRep(ex));}}
+expansion+=childLines.join(","+newLine)+newLine+indentation+"}";return expansion;}else{return formatString(toStr(obj));}}
+return doFormat(obj,depth,indentation);}
+var SimpleDateFormat;(function(){var regex=/('[^']*')|(G+|y+|M+|w+|W+|D+|d+|F+|E+|a+|H+|k+|K+|h+|m+|s+|S+|Z+)|([a-zA-Z]+)|([^a-zA-Z']+)/;var monthNames=["January","February","March","April","May","June","July","August","September","October","November","December"];var dayNames=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var TEXT2=0,TEXT3=1,NUMBER=2,YEAR=3,MONTH=4,TIMEZONE=5;var types={G:TEXT2,y:YEAR,M:MONTH,w:NUMBER,W:NUMBER,D:NUMBER,d:NUMBER,F:NUMBER,E:TEXT3,a:TEXT2,H:NUMBER,k:NUMBER,K:NUMBER,h:NUMBER,m:NUMBER,s:NUMBER,S:NUMBER,Z:TIMEZONE};var ONE_DAY=24*60*60*1000;var ONE_WEEK=7*ONE_DAY;var DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK=1;var newDateAtMidnight=function(year,month,day){var d=new Date(year,month,day,0,0,0);d.setMilliseconds(0);return d;};Date.prototype.getDifference=function(date){return this.getTime()-date.getTime();};Date.prototype.isBefore=function(d){return this.getTime()<d.getTime();};Date.prototype.getUTCTime=function(){return Date.UTC(this.getFullYear(),this.getMonth(),this.getDate(),this.getHours(),this.getMinutes(),this.getSeconds(),this.getMilliseconds());};Date.prototype.getTimeSince=function(d){return this.getUTCTime()-d.getUTCTime();};Date.prototype.getPreviousSunday=function(){var midday=new Date(this.getFullYear(),this.getMonth(),this.getDate(),12,0,0);var previousSunday=new Date(midday.getTime()-this.getDay()*ONE_DAY);return newDateAtMidnight(previousSunday.getFullYear(),previousSunday.getMonth(),previousSunday.getDate());};Date.prototype.getWeekInYear=function(minimalDaysInFirstWeek){if(isUndefined(this.minimalDaysInFirstWeek)){minimalDaysInFirstWeek=DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;}
+var previousSunday=this.getPreviousSunday();var startOfYear=newDateAtMidnight(this.getFullYear(),0,1);var numberOfSundays=previousSunday.isBefore(startOfYear)?0:1+Math.floor(previousSunday.getTimeSince(startOfYear)/ONE_WEEK);var numberOfDaysInFirstWeek=7-startOfYear.getDay();var weekInYear=numberOfSundays;if(numberOfDaysInFirstWeek<minimalDaysInFirstWeek){weekInYear--;}
+return weekInYear;};Date.prototype.getWeekInMonth=function(minimalDaysInFirstWeek){if(isUndefined(this.minimalDaysInFirstWeek)){minimalDaysInFirstWeek=DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;}
+var previousSunday=this.getPreviousSunday();var startOfMonth=newDateAtMidnight(this.getFullYear(),this.getMonth(),1);var numberOfSundays=previousSunday.isBefore(startOfMonth)?0:1+Math.floor(previousSunday.getTimeSince(startOfMonth)/ONE_WEEK);var numberOfDaysInFirstWeek=7-startOfMonth.getDay();var weekInMonth=numberOfSundays;if(numberOfDaysInFirstWeek>=minimalDaysInFirstWeek){weekInMonth++;}
+return weekInMonth;};Date.prototype.getDayInYear=function(){var startOfYear=newDateAtMidnight(this.getFullYear(),0,1);return 1+Math.floor(this.getTimeSince(startOfYear)/ONE_DAY);};SimpleDateFormat=function(formatString){this.formatString=formatString;};SimpleDateFormat.prototype.setMinimalDaysInFirstWeek=function(days){this.minimalDaysInFirstWeek=days;};SimpleDateFormat.prototype.getMinimalDaysInFirstWeek=function(){return isUndefined(this.minimalDaysInFirstWeek)?DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK:this.minimalDaysInFirstWeek;};var padWithZeroes=function(str,len){while(str.length<len){str="0"+str;}
+return str;};var formatText=function(data,numberOfLetters,minLength){return(numberOfLetters>=4)?data:data.substr(0,Math.max(minLength,numberOfLetters));};var formatNumber=function(data,numberOfLetters){var dataString=""+data;return padWithZeroes(dataString,numberOfLetters);};SimpleDateFormat.prototype.format=function(date){var formattedString="";var result;var searchString=this.formatString;while((result=regex.exec(searchString))){var quotedString=result[1];var patternLetters=result[2];var otherLetters=result[3];var otherCharacters=result[4];if(quotedString){if(quotedString=="''"){formattedString+="'";}else{formattedString+=quotedString.substring(1,quotedString.length-1);}}else if(otherLetters){}else if(otherCharacters){formattedString+=otherCharacters;}else if(patternLetters){var patternLetter=patternLetters.charAt(0);var numberOfLetters=patternLetters.length;var rawData="";switch(patternLetter){case"G":rawData="AD";break;case"y":rawData=date.getFullYear();break;case"M":rawData=date.getMonth();break;case"w":rawData=date.getWeekInYear(this.getMinimalDaysInFirstWeek());break;case"W":rawData=date.getWeekInMonth(this.getMinimalDaysInFirstWeek());break;case"D":rawData=date.getDayInYear();break;case"d":rawData=date.getDate();break;case"F":rawData=1+Math.floor((date.getDate()-1)/7);break;case"E":rawData=dayNames[date.getDay()];break;case"a":rawData=(date.getHours()>=12)?"PM":"AM";break;case"H":rawData=date.getHours();break;case"k":rawData=date.getHours()||24;break;case"K":rawData=date.getHours()%12;break;case"h":rawData=(date.getHours()%12)||12;break;case"m":rawData=date.getMinutes();break;case"s":rawData=date.getSeconds();break;case"S":rawData=date.getMilliseconds();break;case"Z":rawData=date.getTimezoneOffset();break;}
+switch(types[patternLetter]){case TEXT2:formattedString+=formatText(rawData,numberOfLetters,2);break;case TEXT3:formattedString+=formatText(rawData,numberOfLetters,3);break;case NUMBER:formattedString+=formatNumber(rawData,numberOfLetters);break;case YEAR:if(numberOfLetters<=3){var dataString=""+rawData;formattedString+=dataString.substr(2,2);}else{formattedString+=formatNumber(rawData,numberOfLetters);}
+break;case MONTH:if(numberOfLetters>=3){formattedString+=formatText(monthNames[rawData],numberOfLetters,numberOfLetters);}else{formattedString+=formatNumber(rawData+1,numberOfLetters);}
+break;case TIMEZONE:var isPositive=(rawData>0);var prefix=isPositive?"-":"+";var absData=Math.abs(rawData);var hours=""+Math.floor(absData/60);hours=padWithZeroes(hours,2);var minutes=""+(absData%60);minutes=padWithZeroes(minutes,2);formattedString+=prefix+hours+minutes;break;}}
+searchString=searchString.substr(result.index+result[0].length);}
+return formattedString;};})();log4javascript.SimpleDateFormat=SimpleDateFormat;function PatternLayout(pattern){if(pattern){this.pattern=pattern;}else{this.pattern=PatternLayout.DEFAULT_CONVERSION_PATTERN;}
+this.customFields=[];}
+PatternLayout.TTCC_CONVERSION_PATTERN="%r %p %c - %m%n";PatternLayout.DEFAULT_CONVERSION_PATTERN="%m%n";PatternLayout.ISO8601_DATEFORMAT="yyyy-MM-dd HH:mm:ss,SSS";PatternLayout.DATETIME_DATEFORMAT="dd MMM yyyy HH:mm:ss,SSS";PatternLayout.ABSOLUTETIME_DATEFORMAT="HH:mm:ss,SSS";PatternLayout.prototype=new Layout();PatternLayout.prototype.format=function(loggingEvent){var regex=/%(-?[0-9]+)?(\.?[0-9]+)?([acdfmMnpr%])(\{([^\}]+)\})?|([^%]+)/;var formattedString="";var result;var searchString=this.pattern;while((result=regex.exec(searchString))){var matchedString=result[0];var padding=result[1];var truncation=result[2];var conversionCharacter=result[3];var specifier=result[5];var text=result[6];if(text){formattedString+=""+text;}else{var replacement="";switch(conversionCharacter){case"a":case"m":var depth=0;if(specifier){depth=parseInt(specifier,10);if(isNaN(depth)){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character '"+conversionCharacter+"' - should be a number");depth=0;}}
+var messages=(conversionCharacter==="a")?loggingEvent.messages[0]:loggingEvent.messages;for(var i=0,len=messages.length;i<len;i++){if(i>0&&(replacement.charAt(replacement.length-1)!==" ")){replacement+=" ";}
+if(depth===0){replacement+=messages[i];}else{replacement+=formatObjectExpansion(messages[i],depth);}}
+break;case"c":var loggerName=loggingEvent.logger.name;if(specifier){var precision=parseInt(specifier,10);var loggerNameBits=loggingEvent.logger.name.split(".");if(precision>=loggerNameBits.length){replacement=loggerName;}else{replacement=loggerNameBits.slice(loggerNameBits.length-precision).join(".");}}else{replacement=loggerName;}
+break;case"d":var dateFormat=PatternLayout.ISO8601_DATEFORMAT;if(specifier){dateFormat=specifier;if(dateFormat=="ISO8601"){dateFormat=PatternLayout.ISO8601_DATEFORMAT;}else if(dateFormat=="ABSOLUTE"){dateFormat=PatternLayout.ABSOLUTETIME_DATEFORMAT;}else if(dateFormat=="DATE"){dateFormat=PatternLayout.DATETIME_DATEFORMAT;}}
+replacement=(new SimpleDateFormat(dateFormat)).format(loggingEvent.timeStamp);break;case"f":if(this.hasCustomFields()){var fieldIndex=0;if(specifier){fieldIndex=parseInt(specifier,10);if(isNaN(fieldIndex)){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - should be a number");}else if(fieldIndex===0){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - must be greater than zero");}else if(fieldIndex>this.customFields.length){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - there aren't that many custom fields");}else{fieldIndex=fieldIndex-1;}}
+var val=this.customFields[fieldIndex].value;if(typeof val=="function"){val=val(this,loggingEvent);}
+replacement=val;}
+break;case"n":replacement=newLine;break;case"p":replacement=loggingEvent.level.name;break;case"r":replacement=""+loggingEvent.timeStamp.getDifference(applicationStartDate);break;case"%":replacement="%";break;default:replacement=matchedString;break;}
+var l;if(truncation){l=parseInt(truncation.substr(1),10);var strLen=replacement.length;if(l<strLen){replacement=replacement.substring(strLen-l,strLen);}}
+if(padding){if(padding.charAt(0)=="-"){l=parseInt(padding.substr(1),10);while(replacement.length<l){replacement+=" ";}}else{l=parseInt(padding,10);while(replacement.length<l){replacement=" "+replacement;}}}
+formattedString+=replacement;}
+searchString=searchString.substr(result.index+result[0].length);}
+return formattedString;};PatternLayout.prototype.ignoresThrowable=function(){return true;};PatternLayout.prototype.toString=function(){return"PatternLayout";};log4javascript.PatternLayout=PatternLayout;function AlertAppender(){}
+AlertAppender.prototype=new Appender();AlertAppender.prototype.layout=new SimpleLayout();AlertAppender.prototype.append=function(loggingEvent){var formattedMessage=this.getLayout().format(loggingEvent);if(this.getLayout().ignoresThrowable()){formattedMessage+=loggingEvent.getThrowableStrRep();}
+alert(formattedMessage);};AlertAppender.prototype.toString=function(){return"AlertAppender";};log4javascript.AlertAppender=AlertAppender;function BrowserConsoleAppender(){}
+BrowserConsoleAppender.prototype=new log4javascript.Appender();BrowserConsoleAppender.prototype.layout=new NullLayout();BrowserConsoleAppender.prototype.threshold=Level.DEBUG;BrowserConsoleAppender.prototype.append=function(loggingEvent){var appender=this;var getFormattedMessage=function(){var layout=appender.getLayout();var formattedMessage=layout.format(loggingEvent);if(layout.ignoresThrowable()&&loggingEvent.exception){formattedMessage+=loggingEvent.getThrowableStrRep();}
+return formattedMessage;};if((typeof opera!="undefined")&&opera.postError){opera.postError(getFormattedMessage());}else if(window.console&&window.console.log){var formattedMesage=getFormattedMessage();if(window.console.debug&&Level.DEBUG.isGreaterOrEqual(loggingEvent.level)){window.console.debug(formattedMesage);}else if(window.console.info&&Level.INFO.equals(loggingEvent.level)){window.console.info(formattedMesage);}else if(window.console.warn&&Level.WARN.equals(loggingEvent.level)){window.console.warn(formattedMesage);}else if(window.console.error&&loggingEvent.level.isGreaterOrEqual(Level.ERROR)){window.console.error(formattedMesage);}else{window.console.log(formattedMesage);}}};BrowserConsoleAppender.prototype.group=function(name){if(window.console&&window.console.group){window.console.group(name);}};BrowserConsoleAppender.prototype.groupEnd=function(){if(window.console&&window.console.groupEnd){window.console.groupEnd();}};BrowserConsoleAppender.prototype.toString=function(){return"BrowserConsoleAppender";};log4javascript.BrowserConsoleAppender=BrowserConsoleAppender;var xmlHttpFactories=[function(){return new XMLHttpRequest();},function(){return new ActiveXObject("Msxml2.XMLHTTP");},function(){return new ActiveXObject("Microsoft.XMLHTTP");}];var getXmlHttp=function(errorHandler){var xmlHttp=null,factory;for(var i=0,len=xmlHttpFactories.length;i<len;i++){factory=xmlHttpFactories[i];try{xmlHttp=factory();getXmlHttp=factory;return xmlHttp;}catch(e){}}
+if(errorHandler){errorHandler();}else{handleError("getXmlHttp: unable to obtain XMLHttpRequest object");}};function isHttpRequestSuccessful(xmlHttp){return isUndefined(xmlHttp.status)||xmlHttp.status===0||(xmlHttp.status>=200&&xmlHttp.status<300)||xmlHttp.status==1223;}
+function AjaxAppender(url){var appender=this;var isSupported=true;if(!url){handleError("AjaxAppender: URL must be specified in constructor");isSupported=false;}
+var timed=this.defaults.timed;var waitForResponse=this.defaults.waitForResponse;var batchSize=this.defaults.batchSize;var timerInterval=this.defaults.timerInterval;var requestSuccessCallback=this.defaults.requestSuccessCallback;var failCallback=this.defaults.failCallback;var postVarName=this.defaults.postVarName;var sendAllOnUnload=this.defaults.sendAllOnUnload;var contentType=this.defaults.contentType;var sessionId=null;var queuedLoggingEvents=[];var queuedRequests=[];var headers=[];var sending=false;var initialized=false;function checkCanConfigure(configOptionName){if(initialized){handleError("AjaxAppender: configuration option '"+
+configOptionName+"' may not be set after the appender has been initialized");return false;}
+return true;}
+this.getSessionId=function(){return sessionId;};this.setSessionId=function(sessionIdParam){sessionId=extractStringFromParam(sessionIdParam,null);this.layout.setCustomField("sessionid",sessionId);};this.setLayout=function(layoutParam){if(checkCanConfigure("layout")){this.layout=layoutParam;if(sessionId!==null){this.setSessionId(sessionId);}}};this.isTimed=function(){return timed;};this.setTimed=function(timedParam){if(checkCanConfigure("timed")){timed=bool(timedParam);}};this.getTimerInterval=function(){return timerInterval;};this.setTimerInterval=function(timerIntervalParam){if(checkCanConfigure("timerInterval")){timerInterval=extractIntFromParam(timerIntervalParam,timerInterval);}};this.isWaitForResponse=function(){return waitForResponse;};this.setWaitForResponse=function(waitForResponseParam){if(checkCanConfigure("waitForResponse")){waitForResponse=bool(waitForResponseParam);}};this.getBatchSize=function(){return batchSize;};this.setBatchSize=function(batchSizeParam){if(checkCanConfigure("batchSize")){batchSize=extractIntFromParam(batchSizeParam,batchSize);}};this.isSendAllOnUnload=function(){return sendAllOnUnload;};this.setSendAllOnUnload=function(sendAllOnUnloadParam){if(checkCanConfigure("sendAllOnUnload")){sendAllOnUnload=extractBooleanFromParam(sendAllOnUnloadParam,sendAllOnUnload);}};this.setRequestSuccessCallback=function(requestSuccessCallbackParam){requestSuccessCallback=extractFunctionFromParam(requestSuccessCallbackParam,requestSuccessCallback);};this.setFailCallback=function(failCallbackParam){failCallback=extractFunctionFromParam(failCallbackParam,failCallback);};this.getPostVarName=function(){return postVarName;};this.setPostVarName=function(postVarNameParam){if(checkCanConfigure("postVarName")){postVarName=extractStringFromParam(postVarNameParam,postVarName);}};this.getHeaders=function(){return headers;};this.addHeader=function(name,value){if(name.toLowerCase()=="content-type"){contentType=value;}else{headers.push({name:name,value:value});}};function sendAll(){if(isSupported&&enabled){sending=true;var currentRequestBatch;if(waitForResponse){if(queuedRequests.length>0){currentRequestBatch=queuedRequests.shift();sendRequest(preparePostData(currentRequestBatch),sendAll);}else{sending=false;if(timed){scheduleSending();}}}else{while((currentRequestBatch=queuedRequests.shift())){sendRequest(preparePostData(currentRequestBatch));}
+sending=false;if(timed){scheduleSending();}}}}
+this.sendAll=sendAll;function sendAllRemaining(){var sendingAnything=false;if(isSupported&&enabled){var actualBatchSize=appender.getLayout().allowBatching()?batchSize:1;var currentLoggingEvent;var batchedLoggingEvents=[];while((currentLoggingEvent=queuedLoggingEvents.shift())){batchedLoggingEvents.push(currentLoggingEvent);if(queuedLoggingEvents.length>=actualBatchSize){queuedRequests.push(batchedLoggingEvents);batchedLoggingEvents=[];}}
+if(batchedLoggingEvents.length>0){queuedRequests.push(batchedLoggingEvents);}
+sendingAnything=(queuedRequests.length>0);waitForResponse=false;timed=false;sendAll();}
+return sendingAnything;}
+this.sendAllRemaining=sendAllRemaining;function preparePostData(batchedLoggingEvents){var formattedMessages=[];var currentLoggingEvent;var postData="";while((currentLoggingEvent=batchedLoggingEvents.shift())){var currentFormattedMessage=appender.getLayout().format(currentLoggingEvent);if(appender.getLayout().ignoresThrowable()){currentFormattedMessage+=currentLoggingEvent.getThrowableStrRep();}
+formattedMessages.push(currentFormattedMessage);}
+if(batchedLoggingEvents.length==1){postData=formattedMessages.join("");}else{postData=appender.getLayout().batchHeader+
+formattedMessages.join(appender.getLayout().batchSeparator)+
+appender.getLayout().batchFooter;}
+if(contentType==appender.defaults.contentType){postData=appender.getLayout().returnsPostData?postData:urlEncode(postVarName)+"="+urlEncode(postData);if(postData.length>0){postData+="&";}
+postData+="layout="+urlEncode(appender.getLayout().toString());}
+return postData;}
+function scheduleSending(){window.setTimeout(sendAll,timerInterval);}
+function xmlHttpErrorHandler(){var msg="AjaxAppender: could not create XMLHttpRequest object. AjaxAppender disabled";handleError(msg);isSupported=false;if(failCallback){failCallback(msg);}}
+function sendRequest(postData,successCallback){try{var xmlHttp=getXmlHttp(xmlHttpErrorHandler);if(isSupported){if(xmlHttp.overrideMimeType){xmlHttp.overrideMimeType(appender.getLayout().getContentType());}
+xmlHttp.onreadystatechange=function(){if(xmlHttp.readyState==4){if(isHttpRequestSuccessful(xmlHttp)){if(requestSuccessCallback){requestSuccessCallback(xmlHttp);}
+if(successCallback){successCallback(xmlHttp);}}else{var msg="AjaxAppender.append: XMLHttpRequest request to URL "+
+url+" returned status code "+xmlHttp.status;handleError(msg);if(failCallback){failCallback(msg);}}
+xmlHttp.onreadystatechange=emptyFunction;xmlHttp=null;}};xmlHttp.open("POST",url,true);try{for(var i=0,header;header=headers[i++];){xmlHttp.setRequestHeader(header.name,header.value);}
+xmlHttp.setRequestHeader("Content-Type",contentType);}catch(headerEx){var msg="AjaxAppender.append: your browser's XMLHttpRequest implementation"+" does not support setRequestHeader, therefore cannot post data. AjaxAppender disabled";handleError(msg);isSupported=false;if(failCallback){failCallback(msg);}
+return;}
+xmlHttp.send(postData);}}catch(ex){var errMsg="AjaxAppender.append: error sending log message to "+url;handleError(errMsg,ex);isSupported=false;if(failCallback){failCallback(errMsg+". Details: "+getExceptionStringRep(ex));}}}
+this.append=function(loggingEvent){if(isSupported){if(!initialized){init();}
+queuedLoggingEvents.push(loggingEvent);var actualBatchSize=this.getLayout().allowBatching()?batchSize:1;if(queuedLoggingEvents.length>=actualBatchSize){var currentLoggingEvent;var batchedLoggingEvents=[];while((currentLoggingEvent=queuedLoggingEvents.shift())){batchedLoggingEvents.push(currentLoggingEvent);}
+queuedRequests.push(batchedLoggingEvents);if(!timed&&(!waitForResponse||(waitForResponse&&!sending))){sendAll();}}}};function init(){initialized=true;if(sendAllOnUnload){var oldBeforeUnload=window.onbeforeunload;window.onbeforeunload=function(){if(oldBeforeUnload){oldBeforeUnload();}
+if(sendAllRemaining()){return"Sending log messages";}};}
+if(timed){scheduleSending();}}}
+AjaxAppender.prototype=new Appender();AjaxAppender.prototype.defaults={waitForResponse:false,timed:false,timerInterval:1000,batchSize:1,sendAllOnUnload:false,requestSuccessCallback:null,failCallback:null,postVarName:"data",contentType:"application/x-www-form-urlencoded"};AjaxAppender.prototype.layout=new HttpPostDataLayout();AjaxAppender.prototype.toString=function(){return"AjaxAppender";};log4javascript.AjaxAppender=AjaxAppender;function setCookie(name,value,days,path){var expires;path=path?"; path="+path:"";if(days){var date=new Date();date.setTime(date.getTime()+(days*24*60*60*1000));expires="; expires="+date.toGMTString();}else{expires="";}
+document.cookie=escape(name)+"="+escape(value)+expires+path;}
+function getCookie(name){var nameEquals=escape(name)+"=";var ca=document.cookie.split(";");for(var i=0,len=ca.length;i<len;i++){var c=ca[i];while(c.charAt(0)===" "){c=c.substring(1,c.length);}
+if(c.indexOf(nameEquals)===0){return unescape(c.substring(nameEquals.length,c.length));}}
+return null;}
+function getBaseUrl(){var scripts=document.getElementsByTagName("script");for(var i=0,len=scripts.length;i<len;++i){if(scripts[i].src.indexOf("log4javascript")!=-1){var lastSlash=scripts[i].src.lastIndexOf("/");return(lastSlash==-1)?"":scripts[i].src.substr(0,lastSlash+1);}}
+return null;}
+function isLoaded(win){try{return bool(win.loaded);}catch(ex){return false;}}
+var ConsoleAppender;(function(){var getConsoleHtmlLines=function(){return['<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">','<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">','<head>','<title>log4javascript</title>','<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />','<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->','<meta http-equiv="X-UA-Compatible" content="IE=7" />','<script type="text/javascript">var isIe = false, isIePre7 = false;</script>','<!--[if IE]><script type="text/javascript">isIe = true</script><![endif]-->','<!--[if lt IE 7]><script type="text/javascript">isIePre7 = true</script><![endif]-->','<script type="text/javascript">','//<![CDATA[','var loggingEnabled=true;var logQueuedEventsTimer=null;var logEntries=[];var logEntriesAndSeparators=[];var logItems=[];var renderDelay=100;var unrenderedLogItemsExist=false;var rootGroup,currentGroup=null;var loaded=false;var currentLogItem=null;var logMainContainer;function copyProperties(obj,props){for(var i in props){obj[i]=props[i];}}','function LogItem(){}','LogItem.prototype={mainContainer:null,wrappedContainer:null,unwrappedContainer:null,group:null,appendToLog:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].appendToLog();}','this.group.update();},doRemove:function(doUpdate,removeFromGroup){if(this.rendered){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].remove();}','this.unwrappedElementContainer=null;this.wrappedElementContainer=null;this.mainElementContainer=null;}','if(this.group&&removeFromGroup){this.group.removeChild(this,doUpdate);}','if(this===currentLogItem){currentLogItem=null;}},remove:function(doUpdate,removeFromGroup){this.doRemove(doUpdate,removeFromGroup);},render:function(){},accept:function(visitor){visitor.visit(this);},getUnwrappedDomContainer:function(){return this.group.unwrappedElementContainer.contentDiv;},getWrappedDomContainer:function(){return this.group.wrappedElementContainer.contentDiv;},getMainDomContainer:function(){return this.group.mainElementContainer.contentDiv;}};LogItem.serializedItemKeys={LOG_ENTRY:0,GROUP_START:1,GROUP_END:2};function LogItemContainerElement(){}','LogItemContainerElement.prototype={appendToLog:function(){var insertBeforeFirst=(newestAtTop&&this.containerDomNode.hasChildNodes());if(insertBeforeFirst){this.containerDomNode.insertBefore(this.mainDiv,this.containerDomNode.firstChild);}else{this.containerDomNode.appendChild(this.mainDiv);}}};function SeparatorElementContainer(containerDomNode){this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="separator";this.mainDiv.innerHTML="&nbsp;";}','SeparatorElementContainer.prototype=new LogItemContainerElement();SeparatorElementContainer.prototype.remove=function(){this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;};function Separator(){this.rendered=false;}','Separator.prototype=new LogItem();copyProperties(Separator.prototype,{render:function(){var containerDomNode=this.group.contentDiv;if(isIe){this.unwrappedElementContainer=new SeparatorElementContainer(this.getUnwrappedDomContainer());this.wrappedElementContainer=new SeparatorElementContainer(this.getWrappedDomContainer());this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{this.mainElementContainer=new SeparatorElementContainer(this.getMainDomContainer());this.elementContainers=[this.mainElementContainer];}','this.content=this.formattedMessage;this.rendered=true;}});function GroupElementContainer(group,containerDomNode,isRoot,isWrapped){this.group=group;this.containerDomNode=containerDomNode;this.isRoot=isRoot;this.isWrapped=isWrapped;this.expandable=false;if(this.isRoot){if(isIe){this.contentDiv=logMainContainer.appendChild(document.createElement("div"));this.contentDiv.id=this.isWrapped?"log_wrapped":"log_unwrapped";}else{this.contentDiv=logMainContainer;}}else{var groupElementContainer=this;this.mainDiv=document.createElement("div");this.mainDiv.className="group";this.headingDiv=this.mainDiv.appendChild(document.createElement("div"));this.headingDiv.className="groupheading";this.expander=this.headingDiv.appendChild(document.createElement("span"));this.expander.className="expander unselectable greyedout";this.expander.unselectable=true;var expanderText=this.group.expanded?"-":"+";this.expanderTextNode=this.expander.appendChild(document.createTextNode(expanderText));this.headingDiv.appendChild(document.createTextNode(" "+this.group.name));this.contentDiv=this.mainDiv.appendChild(document.createElement("div"));var contentCssClass=this.group.expanded?"expanded":"collapsed";this.contentDiv.className="groupcontent "+contentCssClass;this.expander.onclick=function(){if(groupElementContainer.group.expandable){groupElementContainer.group.toggleExpanded();}};}}','GroupElementContainer.prototype=new LogItemContainerElement();copyProperties(GroupElementContainer.prototype,{toggleExpanded:function(){if(!this.isRoot){var oldCssClass,newCssClass,expanderText;if(this.group.expanded){newCssClass="expanded";oldCssClass="collapsed";expanderText="-";}else{newCssClass="collapsed";oldCssClass="expanded";expanderText="+";}','replaceClass(this.contentDiv,newCssClass,oldCssClass);this.expanderTextNode.nodeValue=expanderText;}},remove:function(){if(!this.isRoot){this.headingDiv=null;this.expander.onclick=null;this.expander=null;this.expanderTextNode=null;this.contentDiv=null;this.containerDomNode=null;this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;}},reverseChildren:function(){var node=null;var childDomNodes=[];while((node=this.contentDiv.firstChild)){this.contentDiv.removeChild(node);childDomNodes.push(node);}','while((node=childDomNodes.pop())){this.contentDiv.appendChild(node);}},update:function(){if(!this.isRoot){if(this.group.expandable){removeClass(this.expander,"greyedout");}else{addClass(this.expander,"greyedout");}}},clear:function(){if(this.isRoot){this.contentDiv.innerHTML="";}}});function Group(name,isRoot,initiallyExpanded){this.name=name;this.group=null;this.isRoot=isRoot;this.initiallyExpanded=initiallyExpanded;this.elementContainers=[];this.children=[];this.expanded=initiallyExpanded;this.rendered=false;this.expandable=false;}','Group.prototype=new LogItem();copyProperties(Group.prototype,{addChild:function(logItem){this.children.push(logItem);logItem.group=this;},render:function(){if(isIe){var unwrappedDomContainer,wrappedDomContainer;if(this.isRoot){unwrappedDomContainer=logMainContainer;wrappedDomContainer=logMainContainer;}else{unwrappedDomContainer=this.getUnwrappedDomContainer();wrappedDomContainer=this.getWrappedDomContainer();}','this.unwrappedElementContainer=new GroupElementContainer(this,unwrappedDomContainer,this.isRoot,false);this.wrappedElementContainer=new GroupElementContainer(this,wrappedDomContainer,this.isRoot,true);this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{var mainDomContainer=this.isRoot?logMainContainer:this.getMainDomContainer();this.mainElementContainer=new GroupElementContainer(this,mainDomContainer,this.isRoot,false);this.elementContainers=[this.mainElementContainer];}','this.rendered=true;},toggleExpanded:function(){this.expanded=!this.expanded;for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].toggleExpanded();}},expand:function(){if(!this.expanded){this.toggleExpanded();}},accept:function(visitor){visitor.visitGroup(this);},reverseChildren:function(){if(this.rendered){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].reverseChildren();}}},update:function(){var previouslyExpandable=this.expandable;this.expandable=(this.children.length!==0);if(this.expandable!==previouslyExpandable){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].update();}}},flatten:function(){var visitor=new GroupFlattener();this.accept(visitor);return visitor.logEntriesAndSeparators;},removeChild:function(child,doUpdate){array_remove(this.children,child);child.group=null;if(doUpdate){this.update();}},remove:function(doUpdate,removeFromGroup){for(var i=0,len=this.children.length;i<len;i++){this.children[i].remove(false,false);}','this.children=[];this.update();if(this===currentGroup){currentGroup=this.group;}','this.doRemove(doUpdate,removeFromGroup);},serialize:function(items){items.push([LogItem.serializedItemKeys.GROUP_START,this.name]);for(var i=0,len=this.children.length;i<len;i++){this.children[i].serialize(items);}','if(this!==currentGroup){items.push([LogItem.serializedItemKeys.GROUP_END]);}},clear:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].clear();}}});function LogEntryElementContainer(){}','LogEntryElementContainer.prototype=new LogItemContainerElement();copyProperties(LogEntryElementContainer.prototype,{remove:function(){this.doRemove();},doRemove:function(){this.mainDiv.parentNode.removeChild(this.mainDiv);this.mainDiv=null;this.contentElement=null;this.containerDomNode=null;},setContent:function(content,wrappedContent){if(content===this.formattedMessage){this.contentElement.innerHTML="";this.contentElement.appendChild(document.createTextNode(this.formattedMessage));}else{this.contentElement.innerHTML=content;}},setSearchMatch:function(isMatch){var oldCssClass=isMatch?"searchnonmatch":"searchmatch";var newCssClass=isMatch?"searchmatch":"searchnonmatch";replaceClass(this.mainDiv,newCssClass,oldCssClass);},clearSearch:function(){removeClass(this.mainDiv,"searchmatch");removeClass(this.mainDiv,"searchnonmatch");}});function LogEntryWrappedElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.appendChild(document.createTextNode(this.logEntry.formattedMessage));this.mainDiv.className="logentry wrapped "+this.logEntry.level;this.contentElement=this.mainDiv;}','LogEntryWrappedElementContainer.prototype=new LogEntryElementContainer();LogEntryWrappedElementContainer.prototype.setContent=function(content,wrappedContent){if(content===this.formattedMessage){this.contentElement.innerHTML="";this.contentElement.appendChild(document.createTextNode(this.formattedMessage));}else{this.contentElement.innerHTML=wrappedContent;}};function LogEntryUnwrappedElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="logentry unwrapped "+this.logEntry.level;this.pre=this.mainDiv.appendChild(document.createElement("pre"));this.pre.appendChild(document.createTextNode(this.logEntry.formattedMessage));this.pre.className="unwrapped";this.contentElement=this.pre;}','LogEntryUnwrappedElementContainer.prototype=new LogEntryElementContainer();LogEntryUnwrappedElementContainer.prototype.remove=function(){this.doRemove();this.pre=null;};function LogEntryMainElementContainer(logEntry,containerDomNode){this.logEntry=logEntry;this.containerDomNode=containerDomNode;this.mainDiv=document.createElement("div");this.mainDiv.className="logentry nonielogentry "+this.logEntry.level;this.contentElement=this.mainDiv.appendChild(document.createElement("span"));this.contentElement.appendChild(document.createTextNode(this.logEntry.formattedMessage));}','LogEntryMainElementContainer.prototype=new LogEntryElementContainer();function LogEntry(level,formattedMessage){this.level=level;this.formattedMessage=formattedMessage;this.rendered=false;}','LogEntry.prototype=new LogItem();copyProperties(LogEntry.prototype,{render:function(){var logEntry=this;var containerDomNode=this.group.contentDiv;if(isIe){this.formattedMessage=this.formattedMessage.replace(/\\r\\n/g,"\\r");this.unwrappedElementContainer=new LogEntryUnwrappedElementContainer(this,this.getUnwrappedDomContainer());this.wrappedElementContainer=new LogEntryWrappedElementContainer(this,this.getWrappedDomContainer());this.elementContainers=[this.unwrappedElementContainer,this.wrappedElementContainer];}else{this.mainElementContainer=new LogEntryMainElementContainer(this,this.getMainDomContainer());this.elementContainers=[this.mainElementContainer];}','this.content=this.formattedMessage;this.rendered=true;},setContent:function(content,wrappedContent){if(content!=this.content){if(isIe&&(content!==this.formattedMessage)){content=content.replace(/\\r\\n/g,"\\r");}','for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].setContent(content,wrappedContent);}','this.content=content;}},getSearchMatches:function(){var matches=[];var i,len;if(isIe){var unwrappedEls=getElementsByClass(this.unwrappedElementContainer.mainDiv,"searchterm","span");var wrappedEls=getElementsByClass(this.wrappedElementContainer.mainDiv,"searchterm","span");for(i=0,len=unwrappedEls.length;i<len;i++){matches[i]=new Match(this.level,null,unwrappedEls[i],wrappedEls[i]);}}else{var els=getElementsByClass(this.mainElementContainer.mainDiv,"searchterm","span");for(i=0,len=els.length;i<len;i++){matches[i]=new Match(this.level,els[i]);}}','return matches;},setSearchMatch:function(isMatch){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].setSearchMatch(isMatch);}},clearSearch:function(){for(var i=0,len=this.elementContainers.length;i<len;i++){this.elementContainers[i].clearSearch();}},accept:function(visitor){visitor.visitLogEntry(this);},serialize:function(items){items.push([LogItem.serializedItemKeys.LOG_ENTRY,this.level,this.formattedMessage]);}});function LogItemVisitor(){}','LogItemVisitor.prototype={visit:function(logItem){},visitParent:function(logItem){if(logItem.group){logItem.group.accept(this);}},visitChildren:function(logItem){for(var i=0,len=logItem.children.length;i<len;i++){logItem.children[i].accept(this);}},visitLogEntry:function(logEntry){this.visit(logEntry);},visitSeparator:function(separator){this.visit(separator);},visitGroup:function(group){this.visit(group);}};function GroupFlattener(){this.logEntriesAndSeparators=[];}','GroupFlattener.prototype=new LogItemVisitor();GroupFlattener.prototype.visitGroup=function(group){this.visitChildren(group);};GroupFlattener.prototype.visitLogEntry=function(logEntry){this.logEntriesAndSeparators.push(logEntry);};GroupFlattener.prototype.visitSeparator=function(separator){this.logEntriesAndSeparators.push(separator);};window.onload=function(){if(location.search){var queryBits=unescape(location.search).substr(1).split("&"),nameValueBits;for(var i=0,len=queryBits.length;i<len;i++){nameValueBits=queryBits[i].split("=");if(nameValueBits[0]=="log4javascript_domain"){document.domain=nameValueBits[1];break;}}}','logMainContainer=$("log");if(isIePre7){addClass(logMainContainer,"oldIe");}','rootGroup=new Group("root",true);rootGroup.render();currentGroup=rootGroup;setCommandInputWidth();setLogContainerHeight();toggleLoggingEnabled();toggleSearchEnabled();toggleSearchFilter();toggleSearchHighlight();applyFilters();checkAllLevels();toggleWrap();toggleNewestAtTop();toggleScrollToLatest();renderQueuedLogItems();loaded=true;$("command").value="";$("command").autocomplete="off";$("command").onkeydown=function(evt){evt=getEvent(evt);if(evt.keyCode==10||evt.keyCode==13){evalCommandLine();stopPropagation(evt);}else if(evt.keyCode==27){this.value="";this.focus();}else if(evt.keyCode==38&&commandHistory.length>0){currentCommandIndex=Math.max(0,currentCommandIndex-1);this.value=commandHistory[currentCommandIndex];moveCaretToEnd(this);}else if(evt.keyCode==40&&commandHistory.length>0){currentCommandIndex=Math.min(commandHistory.length-1,currentCommandIndex+1);this.value=commandHistory[currentCommandIndex];moveCaretToEnd(this);}};$("command").onkeypress=function(evt){evt=getEvent(evt);if(evt.keyCode==38&&commandHistory.length>0&&evt.preventDefault){evt.preventDefault();}};$("command").onkeyup=function(evt){evt=getEvent(evt);if(evt.keyCode==27&&evt.preventDefault){evt.preventDefault();this.focus();}};document.onkeydown=function keyEventHandler(evt){evt=getEvent(evt);switch(evt.keyCode){case 69:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){evalLastCommand();cancelKeyEvent(evt);return false;}','break;case 75:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){focusSearch();cancelKeyEvent(evt);return false;}','break;case 40:case 76:if(evt.shiftKey&&(evt.ctrlKey||evt.metaKey)){focusCommandLine();cancelKeyEvent(evt);return false;}','break;}};setTimeout(setLogContainerHeight,20);setShowCommandLine(showCommandLine);doSearch();};window.onunload=function(){if(mainWindowExists()){appender.unload();}','appender=null;};function toggleLoggingEnabled(){setLoggingEnabled($("enableLogging").checked);}','function setLoggingEnabled(enable){loggingEnabled=enable;}','var appender=null;function setAppender(appenderParam){appender=appenderParam;}','function setShowCloseButton(showCloseButton){$("closeButton").style.display=showCloseButton?"inline":"none";}','function setShowHideButton(showHideButton){$("hideButton").style.display=showHideButton?"inline":"none";}','var newestAtTop=false;function LogItemContentReverser(){}','LogItemContentReverser.prototype=new LogItemVisitor();LogItemContentReverser.prototype.visitGroup=function(group){group.reverseChildren();this.visitChildren(group);};function setNewestAtTop(isNewestAtTop){var oldNewestAtTop=newestAtTop;var i,iLen,j,jLen;newestAtTop=Boolean(isNewestAtTop);if(oldNewestAtTop!=newestAtTop){var visitor=new LogItemContentReverser();rootGroup.accept(visitor);if(currentSearch){var currentMatch=currentSearch.matches[currentMatchIndex];var matchIndex=0;var matches=[];var actOnLogEntry=function(logEntry){var logEntryMatches=logEntry.getSearchMatches();for(j=0,jLen=logEntryMatches.length;j<jLen;j++){matches[matchIndex]=logEntryMatches[j];if(currentMatch&&logEntryMatches[j].equals(currentMatch)){currentMatchIndex=matchIndex;}','matchIndex++;}};if(newestAtTop){for(i=logEntries.length-1;i>=0;i--){actOnLogEntry(logEntries[i]);}}else{for(i=0,iLen=logEntries.length;i<iLen;i++){actOnLogEntry(logEntries[i]);}}','currentSearch.matches=matches;if(currentMatch){currentMatch.setCurrent();}}else if(scrollToLatest){doScrollToLatest();}}','$("newestAtTop").checked=isNewestAtTop;}','function toggleNewestAtTop(){var isNewestAtTop=$("newestAtTop").checked;setNewestAtTop(isNewestAtTop);}','var scrollToLatest=true;function setScrollToLatest(isScrollToLatest){scrollToLatest=isScrollToLatest;if(scrollToLatest){doScrollToLatest();}','$("scrollToLatest").checked=isScrollToLatest;}','function toggleScrollToLatest(){var isScrollToLatest=$("scrollToLatest").checked;setScrollToLatest(isScrollToLatest);}','function doScrollToLatest(){var l=logMainContainer;if(typeof l.scrollTop!="undefined"){if(newestAtTop){l.scrollTop=0;}else{var latestLogEntry=l.lastChild;if(latestLogEntry){l.scrollTop=l.scrollHeight;}}}}','var closeIfOpenerCloses=true;function setCloseIfOpenerCloses(isCloseIfOpenerCloses){closeIfOpenerCloses=isCloseIfOpenerCloses;}','var maxMessages=null;function setMaxMessages(max){maxMessages=max;pruneLogEntries();}','var showCommandLine=false;function setShowCommandLine(isShowCommandLine){showCommandLine=isShowCommandLine;if(loaded){$("commandLine").style.display=showCommandLine?"block":"none";setCommandInputWidth();setLogContainerHeight();}}','function focusCommandLine(){if(loaded){$("command").focus();}}','function focusSearch(){if(loaded){$("searchBox").focus();}}','function getLogItems(){var items=[];for(var i=0,len=logItems.length;i<len;i++){logItems[i].serialize(items);}','return items;}','function setLogItems(items){var loggingReallyEnabled=loggingEnabled;loggingEnabled=true;for(var i=0,len=items.length;i<len;i++){switch(items[i][0]){case LogItem.serializedItemKeys.LOG_ENTRY:log(items[i][1],items[i][2]);break;case LogItem.serializedItemKeys.GROUP_START:group(items[i][1]);break;case LogItem.serializedItemKeys.GROUP_END:groupEnd();break;}}','loggingEnabled=loggingReallyEnabled;}','function log(logLevel,formattedMessage){if(loggingEnabled){var logEntry=new LogEntry(logLevel,formattedMessage);logEntries.push(logEntry);logEntriesAndSeparators.push(logEntry);logItems.push(logEntry);currentGroup.addChild(logEntry);if(loaded){if(logQueuedEventsTimer!==null){clearTimeout(logQueuedEventsTimer);}','logQueuedEventsTimer=setTimeout(renderQueuedLogItems,renderDelay);unrenderedLogItemsExist=true;}}}','function renderQueuedLogItems(){logQueuedEventsTimer=null;var pruned=pruneLogEntries();var initiallyHasMatches=currentSearch?currentSearch.hasMatches():false;for(var i=0,len=logItems.length;i<len;i++){if(!logItems[i].rendered){logItems[i].render();logItems[i].appendToLog();if(currentSearch&&(logItems[i]instanceof LogEntry)){currentSearch.applyTo(logItems[i]);}}}','if(currentSearch){if(pruned){if(currentSearch.hasVisibleMatches()){if(currentMatchIndex===null){setCurrentMatchIndex(0);}','displayMatches();}else{displayNoMatches();}}else if(!initiallyHasMatches&&currentSearch.hasVisibleMatches()){setCurrentMatchIndex(0);displayMatches();}}','if(scrollToLatest){doScrollToLatest();}','unrenderedLogItemsExist=false;}','function pruneLogEntries(){if((maxMessages!==null)&&(logEntriesAndSeparators.length>maxMessages)){var numberToDelete=logEntriesAndSeparators.length-maxMessages;var prunedLogEntries=logEntriesAndSeparators.slice(0,numberToDelete);if(currentSearch){currentSearch.removeMatches(prunedLogEntries);}','var group;for(var i=0;i<numberToDelete;i++){group=logEntriesAndSeparators[i].group;array_remove(logItems,logEntriesAndSeparators[i]);array_remove(logEntries,logEntriesAndSeparators[i]);logEntriesAndSeparators[i].remove(true,true);if(group.children.length===0&&group!==currentGroup&&group!==rootGroup){array_remove(logItems,group);group.remove(true,true);}}','logEntriesAndSeparators=array_removeFromStart(logEntriesAndSeparators,numberToDelete);return true;}','return false;}','function group(name,startExpanded){if(loggingEnabled){initiallyExpanded=(typeof startExpanded==="undefined")?true:Boolean(startExpanded);var newGroup=new Group(name,false,initiallyExpanded);currentGroup.addChild(newGroup);currentGroup=newGroup;logItems.push(newGroup);if(loaded){if(logQueuedEventsTimer!==null){clearTimeout(logQueuedEventsTimer);}','logQueuedEventsTimer=setTimeout(renderQueuedLogItems,renderDelay);unrenderedLogItemsExist=true;}}}','function groupEnd(){currentGroup=(currentGroup===rootGroup)?rootGroup:currentGroup.group;}','function mainPageReloaded(){currentGroup=rootGroup;var separator=new Separator();logEntriesAndSeparators.push(separator);logItems.push(separator);currentGroup.addChild(separator);}','function closeWindow(){if(appender&&mainWindowExists()){appender.close(true);}else{window.close();}}','function hide(){if(appender&&mainWindowExists()){appender.hide();}}','var mainWindow=window;var windowId="log4javascriptConsoleWindow_"+new Date().getTime()+"_"+(""+Math.random()).substr(2);function setMainWindow(win){mainWindow=win;mainWindow[windowId]=window;if(opener&&closeIfOpenerCloses){pollOpener();}}','function pollOpener(){if(closeIfOpenerCloses){if(mainWindowExists()){setTimeout(pollOpener,500);}else{closeWindow();}}}','function mainWindowExists(){try{return(mainWindow&&!mainWindow.closed&&mainWindow[windowId]==window);}catch(ex){}','return false;}','var logLevels=["TRACE","DEBUG","INFO","WARN","ERROR","FATAL"];function getCheckBox(logLevel){return $("switch_"+logLevel);}','function getIeWrappedLogContainer(){return $("log_wrapped");}','function getIeUnwrappedLogContainer(){return $("log_unwrapped");}','function applyFilters(){for(var i=0;i<logLevels.length;i++){if(getCheckBox(logLevels[i]).checked){addClass(logMainContainer,logLevels[i]);}else{removeClass(logMainContainer,logLevels[i]);}}','updateSearchFromFilters();}','function toggleAllLevels(){var turnOn=$("switch_ALL").checked;for(var i=0;i<logLevels.length;i++){getCheckBox(logLevels[i]).checked=turnOn;if(turnOn){addClass(logMainContainer,logLevels[i]);}else{removeClass(logMainContainer,logLevels[i]);}}}','function checkAllLevels(){for(var i=0;i<logLevels.length;i++){if(!getCheckBox(logLevels[i]).checked){getCheckBox("ALL").checked=false;return;}}','getCheckBox("ALL").checked=true;}','function clearLog(){rootGroup.clear();currentGroup=rootGroup;logEntries=[];logItems=[];logEntriesAndSeparators=[];doSearch();}','function toggleWrap(){var enable=$("wrap").checked;if(enable){addClass(logMainContainer,"wrap");}else{removeClass(logMainContainer,"wrap");}','refreshCurrentMatch();}','var searchTimer=null;function scheduleSearch(){try{clearTimeout(searchTimer);}catch(ex){}','searchTimer=setTimeout(doSearch,500);}','function Search(searchTerm,isRegex,searchRegex,isCaseSensitive){this.searchTerm=searchTerm;this.isRegex=isRegex;this.searchRegex=searchRegex;this.isCaseSensitive=isCaseSensitive;this.matches=[];}','Search.prototype={hasMatches:function(){return this.matches.length>0;},hasVisibleMatches:function(){if(this.hasMatches()){for(var i=0;i<this.matches.length;i++){if(this.matches[i].isVisible()){return true;}}}','return false;},match:function(logEntry){var entryText=String(logEntry.formattedMessage);var matchesSearch=false;if(this.isRegex){matchesSearch=this.searchRegex.test(entryText);}else if(this.isCaseSensitive){matchesSearch=(entryText.indexOf(this.searchTerm)>-1);}else{matchesSearch=(entryText.toLowerCase().indexOf(this.searchTerm.toLowerCase())>-1);}','return matchesSearch;},getNextVisibleMatchIndex:function(){for(var i=currentMatchIndex+1;i<this.matches.length;i++){if(this.matches[i].isVisible()){return i;}}','for(i=0;i<=currentMatchIndex;i++){if(this.matches[i].isVisible()){return i;}}','return-1;},getPreviousVisibleMatchIndex:function(){for(var i=currentMatchIndex-1;i>=0;i--){if(this.matches[i].isVisible()){return i;}}','for(var i=this.matches.length-1;i>=currentMatchIndex;i--){if(this.matches[i].isVisible()){return i;}}','return-1;},applyTo:function(logEntry){var doesMatch=this.match(logEntry);if(doesMatch){logEntry.group.expand();logEntry.setSearchMatch(true);var logEntryContent;var wrappedLogEntryContent;var searchTermReplacementStartTag="<span class=\\\"searchterm\\\">";var searchTermReplacementEndTag="<"+"/span>";var preTagName=isIe?"pre":"span";var preStartTag="<"+preTagName+" class=\\\"pre\\\">";var preEndTag="<"+"/"+preTagName+">";var startIndex=0;var searchIndex,matchedText,textBeforeMatch;if(this.isRegex){var flags=this.isCaseSensitive?"g":"gi";var capturingRegex=new RegExp("("+this.searchRegex.source+")",flags);var rnd=(""+Math.random()).substr(2);var startToken="%%s"+rnd+"%%";var endToken="%%e"+rnd+"%%";logEntryContent=logEntry.formattedMessage.replace(capturingRegex,startToken+"$1"+endToken);logEntryContent=escapeHtml(logEntryContent);var result;var searchString=logEntryContent;logEntryContent="";wrappedLogEntryContent="";while((searchIndex=searchString.indexOf(startToken,startIndex))>-1){var endTokenIndex=searchString.indexOf(endToken,searchIndex);matchedText=searchString.substring(searchIndex+startToken.length,endTokenIndex);textBeforeMatch=searchString.substring(startIndex,searchIndex);logEntryContent+=preStartTag+textBeforeMatch+preEndTag;logEntryContent+=searchTermReplacementStartTag+preStartTag+matchedText+','preEndTag+searchTermReplacementEndTag;if(isIe){wrappedLogEntryContent+=textBeforeMatch+searchTermReplacementStartTag+','matchedText+searchTermReplacementEndTag;}','startIndex=endTokenIndex+endToken.length;}','logEntryContent+=preStartTag+searchString.substr(startIndex)+preEndTag;if(isIe){wrappedLogEntryContent+=searchString.substr(startIndex);}}else{logEntryContent="";wrappedLogEntryContent="";var searchTermReplacementLength=searchTermReplacementStartTag.length+','this.searchTerm.length+searchTermReplacementEndTag.length;var searchTermLength=this.searchTerm.length;var searchTermLowerCase=this.searchTerm.toLowerCase();var logTextLowerCase=logEntry.formattedMessage.toLowerCase();while((searchIndex=logTextLowerCase.indexOf(searchTermLowerCase,startIndex))>-1){matchedText=escapeHtml(logEntry.formattedMessage.substr(searchIndex,this.searchTerm.length));textBeforeMatch=escapeHtml(logEntry.formattedMessage.substring(startIndex,searchIndex));var searchTermReplacement=searchTermReplacementStartTag+','preStartTag+matchedText+preEndTag+searchTermReplacementEndTag;logEntryContent+=preStartTag+textBeforeMatch+preEndTag+searchTermReplacement;if(isIe){wrappedLogEntryContent+=textBeforeMatch+searchTermReplacementStartTag+','matchedText+searchTermReplacementEndTag;}','startIndex=searchIndex+searchTermLength;}','var textAfterLastMatch=escapeHtml(logEntry.formattedMessage.substr(startIndex));logEntryContent+=preStartTag+textAfterLastMatch+preEndTag;if(isIe){wrappedLogEntryContent+=textAfterLastMatch;}}','logEntry.setContent(logEntryContent,wrappedLogEntryContent);var logEntryMatches=logEntry.getSearchMatches();this.matches=this.matches.concat(logEntryMatches);}else{logEntry.setSearchMatch(false);logEntry.setContent(logEntry.formattedMessage,logEntry.formattedMessage);}','return doesMatch;},removeMatches:function(logEntries){var matchesToRemoveCount=0;var currentMatchRemoved=false;var matchesToRemove=[];var i,iLen,j,jLen;for(i=0,iLen=this.matches.length;i<iLen;i++){for(j=0,jLen=logEntries.length;j<jLen;j++){if(this.matches[i].belongsTo(logEntries[j])){matchesToRemove.push(this.matches[i]);if(i===currentMatchIndex){currentMatchRemoved=true;}}}}','var newMatch=currentMatchRemoved?null:this.matches[currentMatchIndex];if(currentMatchRemoved){for(i=currentMatchIndex,iLen=this.matches.length;i<iLen;i++){if(this.matches[i].isVisible()&&!array_contains(matchesToRemove,this.matches[i])){newMatch=this.matches[i];break;}}}','for(i=0,iLen=matchesToRemove.length;i<iLen;i++){array_remove(this.matches,matchesToRemove[i]);matchesToRemove[i].remove();}','if(this.hasVisibleMatches()){if(newMatch===null){setCurrentMatchIndex(0);}else{var newMatchIndex=0;for(i=0,iLen=this.matches.length;i<iLen;i++){if(newMatch===this.matches[i]){newMatchIndex=i;break;}}','setCurrentMatchIndex(newMatchIndex);}}else{currentMatchIndex=null;displayNoMatches();}}};function getPageOffsetTop(el,container){var currentEl=el;var y=0;while(currentEl&&currentEl!=container){y+=currentEl.offsetTop;currentEl=currentEl.offsetParent;}','return y;}','function scrollIntoView(el){var logContainer=logMainContainer;if(!$("wrap").checked){var logContainerLeft=logContainer.scrollLeft;var logContainerRight=logContainerLeft+logContainer.offsetWidth;var elLeft=el.offsetLeft;var elRight=elLeft+el.offsetWidth;if(elLeft<logContainerLeft||elRight>logContainerRight){logContainer.scrollLeft=elLeft-(logContainer.offsetWidth-el.offsetWidth)/2;}}','var logContainerTop=logContainer.scrollTop;var logContainerBottom=logContainerTop+logContainer.offsetHeight;var elTop=getPageOffsetTop(el)-getToolBarsHeight();var elBottom=elTop+el.offsetHeight;if(elTop<logContainerTop||elBottom>logContainerBottom){logContainer.scrollTop=elTop-(logContainer.offsetHeight-el.offsetHeight)/2;}}','function Match(logEntryLevel,spanInMainDiv,spanInUnwrappedPre,spanInWrappedDiv){this.logEntryLevel=logEntryLevel;this.spanInMainDiv=spanInMainDiv;if(isIe){this.spanInUnwrappedPre=spanInUnwrappedPre;this.spanInWrappedDiv=spanInWrappedDiv;}','this.mainSpan=isIe?spanInUnwrappedPre:spanInMainDiv;}','Match.prototype={equals:function(match){return this.mainSpan===match.mainSpan;},setCurrent:function(){if(isIe){addClass(this.spanInUnwrappedPre,"currentmatch");addClass(this.spanInWrappedDiv,"currentmatch");var elementToScroll=$("wrap").checked?this.spanInWrappedDiv:this.spanInUnwrappedPre;scrollIntoView(elementToScroll);}else{addClass(this.spanInMainDiv,"currentmatch");scrollIntoView(this.spanInMainDiv);}},belongsTo:function(logEntry){if(isIe){return isDescendant(this.spanInUnwrappedPre,logEntry.unwrappedPre);}else{return isDescendant(this.spanInMainDiv,logEntry.mainDiv);}},setNotCurrent:function(){if(isIe){removeClass(this.spanInUnwrappedPre,"currentmatch");removeClass(this.spanInWrappedDiv,"currentmatch");}else{removeClass(this.spanInMainDiv,"currentmatch");}},isOrphan:function(){return isOrphan(this.mainSpan);},isVisible:function(){return getCheckBox(this.logEntryLevel).checked;},remove:function(){if(isIe){this.spanInUnwrappedPre=null;this.spanInWrappedDiv=null;}else{this.spanInMainDiv=null;}}};var currentSearch=null;var currentMatchIndex=null;function doSearch(){var searchBox=$("searchBox");var searchTerm=searchBox.value;var isRegex=$("searchRegex").checked;var isCaseSensitive=$("searchCaseSensitive").checked;var i;if(searchTerm===""){$("searchReset").disabled=true;$("searchNav").style.display="none";removeClass(document.body,"searching");removeClass(searchBox,"hasmatches");removeClass(searchBox,"nomatches");for(i=0;i<logEntries.length;i++){logEntries[i].clearSearch();logEntries[i].setContent(logEntries[i].formattedMessage,logEntries[i].formattedMessage);}','currentSearch=null;setLogContainerHeight();}else{$("searchReset").disabled=false;$("searchNav").style.display="block";var searchRegex;var regexValid;if(isRegex){try{searchRegex=isCaseSensitive?new RegExp(searchTerm,"g"):new RegExp(searchTerm,"gi");regexValid=true;replaceClass(searchBox,"validregex","invalidregex");searchBox.title="Valid regex";}catch(ex){regexValid=false;replaceClass(searchBox,"invalidregex","validregex");searchBox.title="Invalid regex: "+(ex.message?ex.message:(ex.description?ex.description:"unknown error"));return;}}else{searchBox.title="";removeClass(searchBox,"validregex");removeClass(searchBox,"invalidregex");}','addClass(document.body,"searching");currentSearch=new Search(searchTerm,isRegex,searchRegex,isCaseSensitive);for(i=0;i<logEntries.length;i++){currentSearch.applyTo(logEntries[i]);}','setLogContainerHeight();if(currentSearch.hasVisibleMatches()){setCurrentMatchIndex(0);displayMatches();}else{displayNoMatches();}}}','function updateSearchFromFilters(){if(currentSearch){if(currentSearch.hasMatches()){if(currentMatchIndex===null){currentMatchIndex=0;}','var currentMatch=currentSearch.matches[currentMatchIndex];if(currentMatch.isVisible()){displayMatches();setCurrentMatchIndex(currentMatchIndex);}else{currentMatch.setNotCurrent();var nextVisibleMatchIndex=currentSearch.getNextVisibleMatchIndex();if(nextVisibleMatchIndex>-1){setCurrentMatchIndex(nextVisibleMatchIndex);displayMatches();}else{displayNoMatches();}}}else{displayNoMatches();}}}','function refreshCurrentMatch(){if(currentSearch&&currentSearch.hasVisibleMatches()){setCurrentMatchIndex(currentMatchIndex);}}','function displayMatches(){replaceClass($("searchBox"),"hasmatches","nomatches");$("searchBox").title=""+currentSearch.matches.length+" matches found";$("searchNav").style.display="block";setLogContainerHeight();}','function displayNoMatches(){replaceClass($("searchBox"),"nomatches","hasmatches");$("searchBox").title="No matches found";$("searchNav").style.display="none";setLogContainerHeight();}','function toggleSearchEnabled(enable){enable=(typeof enable=="undefined")?!$("searchDisable").checked:enable;$("searchBox").disabled=!enable;$("searchReset").disabled=!enable;$("searchRegex").disabled=!enable;$("searchNext").disabled=!enable;$("searchPrevious").disabled=!enable;$("searchCaseSensitive").disabled=!enable;$("searchNav").style.display=(enable&&($("searchBox").value!=="")&&currentSearch&&currentSearch.hasVisibleMatches())?"block":"none";if(enable){removeClass($("search"),"greyedout");addClass(document.body,"searching");if($("searchHighlight").checked){addClass(logMainContainer,"searchhighlight");}else{removeClass(logMainContainer,"searchhighlight");}','if($("searchFilter").checked){addClass(logMainContainer,"searchfilter");}else{removeClass(logMainContainer,"searchfilter");}','$("searchDisable").checked=!enable;}else{addClass($("search"),"greyedout");removeClass(document.body,"searching");removeClass(logMainContainer,"searchhighlight");removeClass(logMainContainer,"searchfilter");}','setLogContainerHeight();}','function toggleSearchFilter(){var enable=$("searchFilter").checked;if(enable){addClass(logMainContainer,"searchfilter");}else{removeClass(logMainContainer,"searchfilter");}','refreshCurrentMatch();}','function toggleSearchHighlight(){var enable=$("searchHighlight").checked;if(enable){addClass(logMainContainer,"searchhighlight");}else{removeClass(logMainContainer,"searchhighlight");}}','function clearSearch(){$("searchBox").value="";doSearch();}','function searchNext(){if(currentSearch!==null&&currentMatchIndex!==null){currentSearch.matches[currentMatchIndex].setNotCurrent();var nextMatchIndex=currentSearch.getNextVisibleMatchIndex();if(nextMatchIndex>currentMatchIndex||confirm("Reached the end of the page. Start from the top?")){setCurrentMatchIndex(nextMatchIndex);}}}','function searchPrevious(){if(currentSearch!==null&&currentMatchIndex!==null){currentSearch.matches[currentMatchIndex].setNotCurrent();var previousMatchIndex=currentSearch.getPreviousVisibleMatchIndex();if(previousMatchIndex<currentMatchIndex||confirm("Reached the start of the page. Continue from the bottom?")){setCurrentMatchIndex(previousMatchIndex);}}}','function setCurrentMatchIndex(index){currentMatchIndex=index;currentSearch.matches[currentMatchIndex].setCurrent();}','function addClass(el,cssClass){if(!hasClass(el,cssClass)){if(el.className){el.className+=" "+cssClass;}else{el.className=cssClass;}}}','function hasClass(el,cssClass){if(el.className){var classNames=el.className.split(" ");return array_contains(classNames,cssClass);}','return false;}','function removeClass(el,cssClass){if(hasClass(el,cssClass)){var existingClasses=el.className.split(" ");var newClasses=[];for(var i=0,len=existingClasses.length;i<len;i++){if(existingClasses[i]!=cssClass){newClasses[newClasses.length]=existingClasses[i];}}','el.className=newClasses.join(" ");}}','function replaceClass(el,newCssClass,oldCssClass){removeClass(el,oldCssClass);addClass(el,newCssClass);}','function getElementsByClass(el,cssClass,tagName){var elements=el.getElementsByTagName(tagName);var matches=[];for(var i=0,len=elements.length;i<len;i++){if(hasClass(elements[i],cssClass)){matches.push(elements[i]);}}','return matches;}','function $(id){return document.getElementById(id);}','function isDescendant(node,ancestorNode){while(node!=null){if(node===ancestorNode){return true;}','node=node.parentNode;}','return false;}','function isOrphan(node){var currentNode=node;while(currentNode){if(currentNode==document.body){return false;}','currentNode=currentNode.parentNode;}','return true;}','function escapeHtml(str){return str.replace(/&/g,"&amp;").replace(/[<]/g,"&lt;").replace(/>/g,"&gt;");}','function getWindowWidth(){if(window.innerWidth){return window.innerWidth;}else if(document.documentElement&&document.documentElement.clientWidth){return document.documentElement.clientWidth;}else if(document.body){return document.body.clientWidth;}','return 0;}','function getWindowHeight(){if(window.innerHeight){return window.innerHeight;}else if(document.documentElement&&document.documentElement.clientHeight){return document.documentElement.clientHeight;}else if(document.body){return document.body.clientHeight;}','return 0;}','function getToolBarsHeight(){return $("switches").offsetHeight;}','function getChromeHeight(){var height=getToolBarsHeight();if(showCommandLine){height+=$("commandLine").offsetHeight;}','return height;}','function setLogContainerHeight(){if(logMainContainer){var windowHeight=getWindowHeight();$("body").style.height=getWindowHeight()+"px";logMainContainer.style.height=""+','Math.max(0,windowHeight-getChromeHeight())+"px";}}','function setCommandInputWidth(){if(showCommandLine){$("command").style.width=""+Math.max(0,$("commandLineContainer").offsetWidth-','($("evaluateButton").offsetWidth+13))+"px";}}','window.onresize=function(){setCommandInputWidth();setLogContainerHeight();};if(!Array.prototype.push){Array.prototype.push=function(){for(var i=0,len=arguments.length;i<len;i++){this[this.length]=arguments[i];}','return this.length;};}','if(!Array.prototype.pop){Array.prototype.pop=function(){if(this.length>0){var val=this[this.length-1];this.length=this.length-1;return val;}};}','if(!Array.prototype.shift){Array.prototype.shift=function(){if(this.length>0){var firstItem=this[0];for(var i=0,len=this.length-1;i<len;i++){this[i]=this[i+1];}','this.length=this.length-1;return firstItem;}};}','if(!Array.prototype.splice){Array.prototype.splice=function(startIndex,deleteCount){var itemsAfterDeleted=this.slice(startIndex+deleteCount);var itemsDeleted=this.slice(startIndex,startIndex+deleteCount);this.length=startIndex;var argumentsArray=[];for(var i=0,len=arguments.length;i<len;i++){argumentsArray[i]=arguments[i];}','var itemsToAppend=(argumentsArray.length>2)?itemsAfterDeleted=argumentsArray.slice(2).concat(itemsAfterDeleted):itemsAfterDeleted;for(i=0,len=itemsToAppend.length;i<len;i++){this.push(itemsToAppend[i]);}','return itemsDeleted;};}','function array_remove(arr,val){var index=-1;for(var i=0,len=arr.length;i<len;i++){if(arr[i]===val){index=i;break;}}','if(index>=0){arr.splice(index,1);return index;}else{return false;}}','function array_removeFromStart(array,numberToRemove){if(Array.prototype.splice){array.splice(0,numberToRemove);}else{for(var i=numberToRemove,len=array.length;i<len;i++){array[i-numberToRemove]=array[i];}','array.length=array.length-numberToRemove;}','return array;}','function array_contains(arr,val){for(var i=0,len=arr.length;i<len;i++){if(arr[i]==val){return true;}}','return false;}','function getErrorMessage(ex){if(ex.message){return ex.message;}else if(ex.description){return ex.description;}','return""+ex;}','function moveCaretToEnd(input){if(input.setSelectionRange){input.focus();var length=input.value.length;input.setSelectionRange(length,length);}else if(input.createTextRange){var range=input.createTextRange();range.collapse(false);range.select();}','input.focus();}','function stopPropagation(evt){if(evt.stopPropagation){evt.stopPropagation();}else if(typeof evt.cancelBubble!="undefined"){evt.cancelBubble=true;}}','function getEvent(evt){return evt?evt:event;}','function getTarget(evt){return evt.target?evt.target:evt.srcElement;}','function getRelatedTarget(evt){if(evt.relatedTarget){return evt.relatedTarget;}else if(evt.srcElement){switch(evt.type){case"mouseover":return evt.fromElement;case"mouseout":return evt.toElement;default:return evt.srcElement;}}}','function cancelKeyEvent(evt){evt.returnValue=false;stopPropagation(evt);}','function evalCommandLine(){var expr=$("command").value;evalCommand(expr);$("command").value="";}','function evalLastCommand(){if(lastCommand!=null){evalCommand(lastCommand);}}','var lastCommand=null;var commandHistory=[];var currentCommandIndex=0;function evalCommand(expr){if(appender){appender.evalCommandAndAppend(expr);}else{var prefix=">>> "+expr+"\\r\\n";try{log("INFO",prefix+eval(expr));}catch(ex){log("ERROR",prefix+"Error: "+getErrorMessage(ex));}}','if(expr!=commandHistory[commandHistory.length-1]){commandHistory.push(expr);if(appender){appender.storeCommandHistory(commandHistory);}}','currentCommandIndex=(expr==commandHistory[currentCommandIndex])?currentCommandIndex+1:commandHistory.length;lastCommand=expr;}','//]]>','</script>','<style type="text/css">','body{background-color:white;color:black;padding:0;margin:0;font-family:tahoma,verdana,arial,helvetica,sans-serif;overflow:hidden}div#switchesContainer input{margin-bottom:0}div.toolbar{border-top:solid #ffffff 1px;border-bottom:solid #aca899 1px;background-color:#f1efe7;padding:3px 5px;font-size:68.75%}div.toolbar,div#search input{font-family:tahoma,verdana,arial,helvetica,sans-serif}div.toolbar input.button{padding:0 5px;font-size:100%}div.toolbar input.hidden{display:none}div#switches input#clearButton{margin-left:20px}div#levels label{font-weight:bold}div#levels label,div#options label{margin-right:5px}div#levels label#wrapLabel{font-weight:normal}div#search label{margin-right:10px}div#search label.searchboxlabel{margin-right:0}div#search input{font-size:100%}div#search input.validregex{color:green}div#search input.invalidregex{color:red}div#search input.nomatches{color:white;background-color:#ff6666}div#search input.nomatches{color:white;background-color:#ff6666}div#searchNav{display:none}div#commandLine{display:none}div#commandLine input#command{font-size:100%;font-family:Courier New,Courier}div#commandLine input#evaluateButton{}*.greyedout{color:gray !important;border-color:gray !important}*.greyedout *.alwaysenabled{color:black}*.unselectable{-khtml-user-select:none;-moz-user-select:none;user-select:none}div#log{font-family:Courier New,Courier;font-size:75%;width:100%;overflow:auto;clear:both;position:relative}div.group{border-color:#cccccc;border-style:solid;border-width:1px 0 1px 1px;overflow:visible}div.oldIe div.group,div.oldIe div.group *,div.oldIe *.logentry{height:1%}div.group div.groupheading span.expander{border:solid black 1px;font-family:Courier New,Courier;font-size:0.833em;background-color:#eeeeee;position:relative;top:-1px;color:black;padding:0 2px;cursor:pointer;cursor:hand;height:1%}div.group div.groupcontent{margin-left:10px;padding-bottom:2px;overflow:visible}div.group div.expanded{display:block}div.group div.collapsed{display:none}*.logentry{overflow:visible;display:none;white-space:pre}span.pre{white-space:pre}pre.unwrapped{display:inline !important}pre.unwrapped pre.pre,div.wrapped pre.pre{display:inline}div.wrapped pre.pre{white-space:normal}div.wrapped{display:none}body.searching *.logentry span.currentmatch{color:white !important;background-color:green !important}body.searching div.searchhighlight *.logentry span.searchterm{color:black;background-color:yellow}div.wrap *.logentry{white-space:normal !important;border-width:0 0 1px 0;border-color:#dddddd;border-style:dotted}div.wrap #log_wrapped,#log_unwrapped{display:block}div.wrap #log_unwrapped,#log_wrapped{display:none}div.wrap *.logentry span.pre{overflow:visible;white-space:normal}div.wrap *.logentry pre.unwrapped{display:none}div.wrap *.logentry span.wrapped{display:inline}div.searchfilter *.searchnonmatch{display:none !important}div#log *.TRACE,label#label_TRACE{color:#666666}div#log *.DEBUG,label#label_DEBUG{color:green}div#log *.INFO,label#label_INFO{color:#000099}div#log *.WARN,label#label_WARN{color:#999900}div#log *.ERROR,label#label_ERROR{color:red}div#log *.FATAL,label#label_FATAL{color:#660066}div.TRACE#log *.TRACE,div.DEBUG#log *.DEBUG,div.INFO#log *.INFO,div.WARN#log *.WARN,div.ERROR#log *.ERROR,div.FATAL#log *.FATAL{display:block}div#log div.separator{background-color:#cccccc;margin:5px 0;line-height:1px}','</style>','</head>','<body id="body">','<div id="switchesContainer">','<div id="switches">','<div id="levels" class="toolbar">','Filters:','<input type="checkbox" id="switch_TRACE" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide trace messages" /><label for="switch_TRACE" id="label_TRACE">trace</label>','<input type="checkbox" id="switch_DEBUG" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide debug messages" /><label for="switch_DEBUG" id="label_DEBUG">debug</label>','<input type="checkbox" id="switch_INFO" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide info messages" /><label for="switch_INFO" id="label_INFO">info</label>','<input type="checkbox" id="switch_WARN" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide warn messages" /><label for="switch_WARN" id="label_WARN">warn</label>','<input type="checkbox" id="switch_ERROR" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide error messages" /><label for="switch_ERROR" id="label_ERROR">error</label>','<input type="checkbox" id="switch_FATAL" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide fatal messages" /><label for="switch_FATAL" id="label_FATAL">fatal</label>','<input type="checkbox" id="switch_ALL" onclick="toggleAllLevels(); applyFilters()" checked="checked" title="Show/hide all messages" /><label for="switch_ALL" id="label_ALL">all</label>','</div>','<div id="search" class="toolbar">','<label for="searchBox" class="searchboxlabel">Search:</label> <input type="text" id="searchBox" onclick="toggleSearchEnabled(true)" onkeyup="scheduleSearch()" size="20" />','<input type="button" id="searchReset" disabled="disabled" value="Reset" onclick="clearSearch()" class="button" title="Reset the search" />','<input type="checkbox" id="searchRegex" onclick="doSearch()" title="If checked, search is treated as a regular expression" /><label for="searchRegex">Regex</label>','<input type="checkbox" id="searchCaseSensitive" onclick="doSearch()" title="If checked, search is case sensitive" /><label for="searchCaseSensitive">Match case</label>','<input type="checkbox" id="searchDisable" onclick="toggleSearchEnabled()" title="Enable/disable search" /><label for="searchDisable" class="alwaysenabled">Disable</label>','<div id="searchNav">','<input type="button" id="searchNext" disabled="disabled" value="Next" onclick="searchNext()" class="button" title="Go to the next matching log entry" />','<input type="button" id="searchPrevious" disabled="disabled" value="Previous" onclick="searchPrevious()" class="button" title="Go to the previous matching log entry" />','<input type="checkbox" id="searchFilter" onclick="toggleSearchFilter()" title="If checked, non-matching log entries are filtered out" /><label for="searchFilter">Filter</label>','<input type="checkbox" id="searchHighlight" onclick="toggleSearchHighlight()" title="Highlight matched search terms" /><label for="searchHighlight" class="alwaysenabled">Highlight all</label>','</div>','</div>','<div id="options" class="toolbar">','Options:','<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Log</label>','<input type="checkbox" id="wrap" onclick="toggleWrap()" title="Enable / disable word wrap" /><label for="wrap" id="wrapLabel">Wrap</label>','<input type="checkbox" id="newestAtTop" onclick="toggleNewestAtTop()" title="If checked, causes newest messages to appear at the top" /><label for="newestAtTop" id="newestAtTopLabel">Newest at the top</label>','<input type="checkbox" id="scrollToLatest" onclick="toggleScrollToLatest()" checked="checked" title="If checked, window automatically scrolls to a new message when it is added" /><label for="scrollToLatest" id="scrollToLatestLabel">Scroll to latest</label>','<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="button" title="Clear all log messages"  />','<input type="button" id="hideButton" value="Hide" onclick="hide()" class="hidden button" title="Hide the console" />','<input type="button" id="closeButton" value="Close" onclick="closeWindow()" class="hidden button" title="Close the window" />','</div>','</div>','</div>','<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>','<div id="commandLine" class="toolbar">','<div id="commandLineContainer">','<input type="text" id="command" title="Enter a JavaScript command here and hit return or press \'Evaluate\'" />','<input type="button" id="evaluateButton" value="Evaluate" class="button" title="Evaluate the command" onclick="evalCommandLine()" />','</div>','</div>','</body>','</html>',''];};var defaultCommandLineFunctions=[];ConsoleAppender=function(){};var consoleAppenderIdCounter=1;ConsoleAppender.prototype=new Appender();ConsoleAppender.prototype.create=function(inPage,container,lazyInit,initiallyMinimized,useDocumentWrite,width,height,focusConsoleWindow){var appender=this;var initialized=false;var consoleWindowCreated=false;var consoleWindowLoaded=false;var consoleClosed=false;var queuedLoggingEvents=[];var isSupported=true;var consoleAppenderId=consoleAppenderIdCounter++;initiallyMinimized=extractBooleanFromParam(initiallyMinimized,this.defaults.initiallyMinimized);lazyInit=extractBooleanFromParam(lazyInit,this.defaults.lazyInit);useDocumentWrite=extractBooleanFromParam(useDocumentWrite,this.defaults.useDocumentWrite);var newestMessageAtTop=this.defaults.newestMessageAtTop;var scrollToLatestMessage=this.defaults.scrollToLatestMessage;width=width?width:this.defaults.width;height=height?height:this.defaults.height;var maxMessages=this.defaults.maxMessages;var showCommandLine=this.defaults.showCommandLine;var commandLineObjectExpansionDepth=this.defaults.commandLineObjectExpansionDepth;var showHideButton=this.defaults.showHideButton;var showCloseButton=this.defaults.showCloseButton;var showLogEntryDeleteButtons=this.defaults.showLogEntryDeleteButtons;this.setLayout(this.defaults.layout);var init,createWindow,safeToAppend,getConsoleWindow,open;var appenderName=inPage?"InPageAppender":"PopUpAppender";var checkCanConfigure=function(configOptionName){if(consoleWindowCreated){handleError(appenderName+": configuration option '"+configOptionName+"' may not be set after the appender has been initialized");return false;}
+return true;};var consoleWindowExists=function(){return(consoleWindowLoaded&&isSupported&&!consoleClosed);};this.isNewestMessageAtTop=function(){return newestMessageAtTop;};this.setNewestMessageAtTop=function(newestMessageAtTopParam){newestMessageAtTop=bool(newestMessageAtTopParam);if(consoleWindowExists()){getConsoleWindow().setNewestAtTop(newestMessageAtTop);}};this.isScrollToLatestMessage=function(){return scrollToLatestMessage;};this.setScrollToLatestMessage=function(scrollToLatestMessageParam){scrollToLatestMessage=bool(scrollToLatestMessageParam);if(consoleWindowExists()){getConsoleWindow().setScrollToLatest(scrollToLatestMessage);}};this.getWidth=function(){return width;};this.setWidth=function(widthParam){if(checkCanConfigure("width")){width=extractStringFromParam(widthParam,width);}};this.getHeight=function(){return height;};this.setHeight=function(heightParam){if(checkCanConfigure("height")){height=extractStringFromParam(heightParam,height);}};this.getMaxMessages=function(){return maxMessages;};this.setMaxMessages=function(maxMessagesParam){maxMessages=extractIntFromParam(maxMessagesParam,maxMessages);if(consoleWindowExists()){getConsoleWindow().setMaxMessages(maxMessages);}};this.isShowCommandLine=function(){return showCommandLine;};this.setShowCommandLine=function(showCommandLineParam){showCommandLine=bool(showCommandLineParam);if(consoleWindowExists()){getConsoleWindow().setShowCommandLine(showCommandLine);}};this.isShowHideButton=function(){return showHideButton;};this.setShowHideButton=function(showHideButtonParam){showHideButton=bool(showHideButtonParam);if(consoleWindowExists()){getConsoleWindow().setShowHideButton(showHideButton);}};this.isShowCloseButton=function(){return showCloseButton;};this.setShowCloseButton=function(showCloseButtonParam){showCloseButton=bool(showCloseButtonParam);if(consoleWindowExists()){getConsoleWindow().setShowCloseButton(showCloseButton);}};this.getCommandLineObjectExpansionDepth=function(){return commandLineObjectExpansionDepth;};this.setCommandLineObjectExpansionDepth=function(commandLineObjectExpansionDepthParam){commandLineObjectExpansionDepth=extractIntFromParam(commandLineObjectExpansionDepthParam,commandLineObjectExpansionDepth);};var minimized=initiallyMinimized;this.isInitiallyMinimized=function(){return initiallyMinimized;};this.setInitiallyMinimized=function(initiallyMinimizedParam){if(checkCanConfigure("initiallyMinimized")){initiallyMinimized=bool(initiallyMinimizedParam);minimized=initiallyMinimized;}};this.isUseDocumentWrite=function(){return useDocumentWrite;};this.setUseDocumentWrite=function(useDocumentWriteParam){if(checkCanConfigure("useDocumentWrite")){useDocumentWrite=bool(useDocumentWriteParam);}};function QueuedLoggingEvent(loggingEvent,formattedMessage){this.loggingEvent=loggingEvent;this.levelName=loggingEvent.level.name;this.formattedMessage=formattedMessage;}
+QueuedLoggingEvent.prototype.append=function(){getConsoleWindow().log(this.levelName,this.formattedMessage);};function QueuedGroup(name,initiallyExpanded){this.name=name;this.initiallyExpanded=initiallyExpanded;}
+QueuedGroup.prototype.append=function(){getConsoleWindow().group(this.name,this.initiallyExpanded);};function QueuedGroupEnd(){}
+QueuedGroupEnd.prototype.append=function(){getConsoleWindow().groupEnd();};var checkAndAppend=function(){safeToAppend();if(!initialized){init();}else if(consoleClosed&&reopenWhenClosed){createWindow();}
+if(safeToAppend()){appendQueuedLoggingEvents();}};this.append=function(loggingEvent){if(isSupported){var formattedMessage=appender.getLayout().format(loggingEvent);if(this.getLayout().ignoresThrowable()){formattedMessage+=loggingEvent.getThrowableStrRep();}
+queuedLoggingEvents.push(new QueuedLoggingEvent(loggingEvent,formattedMessage));checkAndAppend();}};this.group=function(name,initiallyExpanded){if(isSupported){queuedLoggingEvents.push(new QueuedGroup(name,initiallyExpanded));checkAndAppend();}};this.groupEnd=function(){if(isSupported){queuedLoggingEvents.push(new QueuedGroupEnd());checkAndAppend();}};var appendQueuedLoggingEvents=function(){var currentLoggingEvent;while(queuedLoggingEvents.length>0){queuedLoggingEvents.shift().append();}
+if(focusConsoleWindow){getConsoleWindow().focus();}};this.setAddedToLogger=function(logger){this.loggers.push(logger);if(enabled&&!lazyInit){init();}};this.clear=function(){if(consoleWindowExists()){getConsoleWindow().clearLog();}
+queuedLoggingEvents.length=0;};this.focus=function(){if(consoleWindowExists()){getConsoleWindow().focus();}};this.focusCommandLine=function(){if(consoleWindowExists()){getConsoleWindow().focusCommandLine();}};this.focusSearch=function(){if(consoleWindowExists()){getConsoleWindow().focusSearch();}};var commandWindow=window;this.getCommandWindow=function(){return commandWindow;};this.setCommandWindow=function(commandWindowParam){commandWindow=commandWindowParam;};this.executeLastCommand=function(){if(consoleWindowExists()){getConsoleWindow().evalLastCommand();}};var commandLayout=new PatternLayout("%m");this.getCommandLayout=function(){return commandLayout;};this.setCommandLayout=function(commandLayoutParam){commandLayout=commandLayoutParam;};this.evalCommandAndAppend=function(expr){var commandReturnValue={appendResult:true,isError:false};var commandOutput="";try{var result,i;if(!commandWindow.eval&&commandWindow.execScript){commandWindow.execScript("null");}
+var commandLineFunctionsHash={};for(i=0,len=commandLineFunctions.length;i<len;i++){commandLineFunctionsHash[commandLineFunctions[i][0]]=commandLineFunctions[i][1];}
+var objectsToRestore=[];var addObjectToRestore=function(name){objectsToRestore.push([name,commandWindow[name]]);};addObjectToRestore("appender");commandWindow.appender=appender;addObjectToRestore("commandReturnValue");commandWindow.commandReturnValue=commandReturnValue;addObjectToRestore("commandLineFunctionsHash");commandWindow.commandLineFunctionsHash=commandLineFunctionsHash;var addFunctionToWindow=function(name){addObjectToRestore(name);commandWindow[name]=function(){return this.commandLineFunctionsHash[name](appender,arguments,commandReturnValue);};};for(i=0,len=commandLineFunctions.length;i<len;i++){addFunctionToWindow(commandLineFunctions[i][0]);}
+if(commandWindow===window&&commandWindow.execScript){addObjectToRestore("evalExpr");addObjectToRestore("result");window.evalExpr=expr;commandWindow.execScript("window.result=eval(window.evalExpr);");result=window.result;}else{result=commandWindow.eval(expr);}
+commandOutput=isUndefined(result)?result:formatObjectExpansion(result,commandLineObjectExpansionDepth);for(i=0,len=objectsToRestore.length;i<len;i++){commandWindow[objectsToRestore[i][0]]=objectsToRestore[i][1];}}catch(ex){commandOutput="Error evaluating command: "+getExceptionStringRep(ex);commandReturnValue.isError=true;}
+if(commandReturnValue.appendResult){var message=">>> "+expr;if(!isUndefined(commandOutput)){message+=newLine+commandOutput;}
+var level=commandReturnValue.isError?Level.ERROR:Level.INFO;var loggingEvent=new LoggingEvent(null,new Date(),level,[message],null);var mainLayout=this.getLayout();this.setLayout(commandLayout);this.append(loggingEvent);this.setLayout(mainLayout);}};var commandLineFunctions=defaultCommandLineFunctions.concat([]);this.addCommandLineFunction=function(functionName,commandLineFunction){commandLineFunctions.push([functionName,commandLineFunction]);};var commandHistoryCookieName="log4javascriptCommandHistory";this.storeCommandHistory=function(commandHistory){setCookie(commandHistoryCookieName,commandHistory.join(","));};var writeHtml=function(doc){var lines=getConsoleHtmlLines();doc.open();for(var i=0,len=lines.length;i<len;i++){doc.writeln(lines[i]);}
+doc.close();};this.setEventTypes(["load","unload"]);var consoleWindowLoadHandler=function(){var win=getConsoleWindow();win.setAppender(appender);win.setNewestAtTop(newestMessageAtTop);win.setScrollToLatest(scrollToLatestMessage);win.setMaxMessages(maxMessages);win.setShowCommandLine(showCommandLine);win.setShowHideButton(showHideButton);win.setShowCloseButton(showCloseButton);win.setMainWindow(window);var storedValue=getCookie(commandHistoryCookieName);if(storedValue){win.commandHistory=storedValue.split(",");win.currentCommandIndex=win.commandHistory.length;}
+appender.dispatchEvent("load",{"win":win});};this.unload=function(){logLog.debug("unload "+this+", caller: "+this.unload.caller);if(!consoleClosed){logLog.debug("really doing unload "+this);consoleClosed=true;consoleWindowLoaded=false;consoleWindowCreated=false;appender.dispatchEvent("unload",{});}};var pollConsoleWindow=function(windowTest,interval,successCallback,errorMessage){function doPoll(){try{if(consoleClosed){clearInterval(poll);}
+if(windowTest(getConsoleWindow())){clearInterval(poll);successCallback();}}catch(ex){clearInterval(poll);isSupported=false;handleError(errorMessage,ex);}}
+var poll=setInterval(doPoll,interval);};var getConsoleUrl=function(){var documentDomainSet=(document.domain!=location.hostname);return useDocumentWrite?"":getBaseUrl()+"console.html"+
+(documentDomainSet?"?log4javascript_domain="+escape(document.domain):"");};if(inPage){var containerElement=null;var cssProperties=[];this.addCssProperty=function(name,value){if(checkCanConfigure("cssProperties")){cssProperties.push([name,value]);}};var windowCreationStarted=false;var iframeContainerDiv;var iframeId=uniqueId+"_InPageAppender_"+consoleAppenderId;this.hide=function(){if(initialized&&consoleWindowCreated){if(consoleWindowExists()){getConsoleWindow().$("command").blur();}
+iframeContainerDiv.style.display="none";minimized=true;}};this.show=function(){if(initialized){if(consoleWindowCreated){iframeContainerDiv.style.display="block";this.setShowCommandLine(showCommandLine);minimized=false;}else if(!windowCreationStarted){createWindow(true);}}};this.isVisible=function(){return!minimized&&!consoleClosed;};this.close=function(fromButton){if(!consoleClosed&&(!fromButton||confirm("This will permanently remove the console from the page. No more messages will be logged. Do you wish to continue?"))){iframeContainerDiv.parentNode.removeChild(iframeContainerDiv);this.unload();}};open=function(){var initErrorMessage="InPageAppender.open: unable to create console iframe";function finalInit(){try{if(!initiallyMinimized){appender.show();}
+consoleWindowLoadHandler();consoleWindowLoaded=true;appendQueuedLoggingEvents();}catch(ex){isSupported=false;handleError(initErrorMessage,ex);}}
+function writeToDocument(){try{var windowTest=function(win){return isLoaded(win);};if(useDocumentWrite){writeHtml(getConsoleWindow().document);}
+if(windowTest(getConsoleWindow())){finalInit();}else{pollConsoleWindow(windowTest,100,finalInit,initErrorMessage);}}catch(ex){isSupported=false;handleError(initErrorMessage,ex);}}
+minimized=false;iframeContainerDiv=containerElement.appendChild(document.createElement("div"));iframeContainerDiv.style.width=width;iframeContainerDiv.style.height=height;iframeContainerDiv.style.border="solid gray 1px";for(var i=0,len=cssProperties.length;i<len;i++){iframeContainerDiv.style[cssProperties[i][0]]=cssProperties[i][1];}
+var iframeSrc=useDocumentWrite?"":" src='"+getConsoleUrl()+"'";iframeContainerDiv.innerHTML="<iframe id='"+iframeId+"' name='"+iframeId+"' width='100%' height='100%' frameborder='0'"+iframeSrc+" scrolling='no'></iframe>";consoleClosed=false;var iframeDocumentExistsTest=function(win){try{return bool(win)&&bool(win.document);}catch(ex){return false;}};if(iframeDocumentExistsTest(getConsoleWindow())){writeToDocument();}else{pollConsoleWindow(iframeDocumentExistsTest,100,writeToDocument,initErrorMessage);}
+consoleWindowCreated=true;};createWindow=function(show){if(show||!initiallyMinimized){var pageLoadHandler=function(){if(!container){containerElement=document.createElement("div");containerElement.style.position="fixed";containerElement.style.left="0";containerElement.style.right="0";containerElement.style.bottom="0";document.body.appendChild(containerElement);appender.addCssProperty("borderWidth","1px 0 0 0");appender.addCssProperty("zIndex",1000000);open();}else{try{var el=document.getElementById(container);if(el.nodeType==1){containerElement=el;}
+open();}catch(ex){handleError("InPageAppender.init: invalid container element '"+container+"' supplied",ex);}}};if(pageLoaded&&container&&container.appendChild){containerElement=container;open();}else if(pageLoaded){pageLoadHandler();}else{log4javascript.addEventListener("load",pageLoadHandler);}
+windowCreationStarted=true;}};init=function(){createWindow();initialized=true;};getConsoleWindow=function(){var iframe=window.frames[iframeId];if(iframe){return iframe;}};safeToAppend=function(){if(isSupported&&!consoleClosed){if(consoleWindowCreated&&!consoleWindowLoaded&&getConsoleWindow()&&isLoaded(getConsoleWindow())){consoleWindowLoaded=true;}
+return consoleWindowLoaded;}
+return false;};}else{var useOldPopUp=appender.defaults.useOldPopUp;var complainAboutPopUpBlocking=appender.defaults.complainAboutPopUpBlocking;var reopenWhenClosed=this.defaults.reopenWhenClosed;this.isUseOldPopUp=function(){return useOldPopUp;};this.setUseOldPopUp=function(useOldPopUpParam){if(checkCanConfigure("useOldPopUp")){useOldPopUp=bool(useOldPopUpParam);}};this.isComplainAboutPopUpBlocking=function(){return complainAboutPopUpBlocking;};this.setComplainAboutPopUpBlocking=function(complainAboutPopUpBlockingParam){if(checkCanConfigure("complainAboutPopUpBlocking")){complainAboutPopUpBlocking=bool(complainAboutPopUpBlockingParam);}};this.isFocusPopUp=function(){return focusConsoleWindow;};this.setFocusPopUp=function(focusPopUpParam){focusConsoleWindow=bool(focusPopUpParam);};this.isReopenWhenClosed=function(){return reopenWhenClosed;};this.setReopenWhenClosed=function(reopenWhenClosedParam){reopenWhenClosed=bool(reopenWhenClosedParam);};this.close=function(){logLog.debug("close "+this);try{popUp.close();this.unload();}catch(ex){}};this.hide=function(){logLog.debug("hide "+this);if(consoleWindowExists()){this.close();}};this.show=function(){logLog.debug("show "+this);if(!consoleWindowCreated){open();}};this.isVisible=function(){return safeToAppend();};var popUp;open=function(){var windowProperties="width="+width+",height="+height+",status,resizable";var frameInfo="";try{var frameEl=window.frameElement;if(frameEl){frameInfo="_"+frameEl.tagName+"_"+(frameEl.name||frameEl.id||"");}}catch(e){frameInfo="_inaccessibleParentFrame";}
+var windowName="PopUp_"+location.host.replace(/[^a-z0-9]/gi,"_")+"_"+consoleAppenderId+frameInfo;if(!useOldPopUp||!useDocumentWrite){windowName=windowName+"_"+uniqueId;}
+var checkPopUpClosed=function(win){if(consoleClosed){return true;}else{try{return bool(win)&&win.closed;}catch(ex){}}
+return false;};var popUpClosedCallback=function(){if(!consoleClosed){appender.unload();}};function finalInit(){getConsoleWindow().setCloseIfOpenerCloses(!useOldPopUp||!useDocumentWrite);consoleWindowLoadHandler();consoleWindowLoaded=true;appendQueuedLoggingEvents();pollConsoleWindow(checkPopUpClosed,500,popUpClosedCallback,"PopUpAppender.checkPopUpClosed: error checking pop-up window");}
+try{popUp=window.open(getConsoleUrl(),windowName,windowProperties);consoleClosed=false;consoleWindowCreated=true;if(popUp&&popUp.document){if(useDocumentWrite&&useOldPopUp&&isLoaded(popUp)){popUp.mainPageReloaded();finalInit();}else{if(useDocumentWrite){writeHtml(popUp.document);}
+var popUpLoadedTest=function(win){return bool(win)&&isLoaded(win);};if(isLoaded(popUp)){finalInit();}else{pollConsoleWindow(popUpLoadedTest,100,finalInit,"PopUpAppender.init: unable to create console window");}}}else{isSupported=false;logLog.warn("PopUpAppender.init: pop-ups blocked, please unblock to use PopUpAppender");if(complainAboutPopUpBlocking){handleError("log4javascript: pop-up windows appear to be blocked. Please unblock them to use pop-up logging.");}}}catch(ex){handleError("PopUpAppender.init: error creating pop-up",ex);}};createWindow=function(){if(!initiallyMinimized){open();}};init=function(){createWindow();initialized=true;};getConsoleWindow=function(){return popUp;};safeToAppend=function(){if(isSupported&&!isUndefined(popUp)&&!consoleClosed){if(popUp.closed||(consoleWindowLoaded&&isUndefined(popUp.closed))){appender.unload();logLog.debug("PopUpAppender: pop-up closed");return false;}
+if(!consoleWindowLoaded&&isLoaded(popUp)){consoleWindowLoaded=true;}}
+return isSupported&&consoleWindowLoaded&&!consoleClosed;};}
+this.getConsoleWindow=getConsoleWindow;};ConsoleAppender.addGlobalCommandLineFunction=function(functionName,commandLineFunction){defaultCommandLineFunctions.push([functionName,commandLineFunction]);};function PopUpAppender(lazyInit,initiallyMinimized,useDocumentWrite,width,height){this.create(false,null,lazyInit,initiallyMinimized,useDocumentWrite,width,height,this.defaults.focusPopUp);}
+PopUpAppender.prototype=new ConsoleAppender();PopUpAppender.prototype.defaults={layout:new PatternLayout("%d{HH:mm:ss} %-5p - %m{1}%n"),initiallyMinimized:false,focusPopUp:false,lazyInit:true,useOldPopUp:true,complainAboutPopUpBlocking:true,newestMessageAtTop:false,scrollToLatestMessage:true,width:"600",height:"400",reopenWhenClosed:false,maxMessages:null,showCommandLine:true,commandLineObjectExpansionDepth:1,showHideButton:false,showCloseButton:true,showLogEntryDeleteButtons:true,useDocumentWrite:true};PopUpAppender.prototype.toString=function(){return"PopUpAppender";};log4javascript.PopUpAppender=PopUpAppender;function InPageAppender(container,lazyInit,initiallyMinimized,useDocumentWrite,width,height){this.create(true,container,lazyInit,initiallyMinimized,useDocumentWrite,width,height,false);}
+InPageAppender.prototype=new ConsoleAppender();InPageAppender.prototype.defaults={layout:new PatternLayout("%d{HH:mm:ss} %-5p - %m{1}%n"),initiallyMinimized:false,lazyInit:true,newestMessageAtTop:false,scrollToLatestMessage:true,width:"100%",height:"220px",maxMessages:null,showCommandLine:true,commandLineObjectExpansionDepth:1,showHideButton:false,showCloseButton:false,showLogEntryDeleteButtons:true,useDocumentWrite:true};InPageAppender.prototype.toString=function(){return"InPageAppender";};log4javascript.InPageAppender=InPageAppender;log4javascript.InlineAppender=InPageAppender;})();function padWithSpaces(str,len){if(str.length<len){var spaces=[];var numberOfSpaces=Math.max(0,len-str.length);for(var i=0;i<numberOfSpaces;i++){spaces[i]=" ";}
+str+=spaces.join("");}
+return str;}
+(function(){function dir(obj){var maxLen=0;for(var p in obj){maxLen=Math.max(toStr(p).length,maxLen);}
+var propList=[];for(p in obj){var propNameStr="  "+padWithSpaces(toStr(p),maxLen+2);var propVal;try{propVal=splitIntoLines(toStr(obj[p])).join(padWithSpaces(newLine,maxLen+6));}catch(ex){propVal="[Error obtaining property. Details: "+getExceptionMessage(ex)+"]";}
+propList.push(propNameStr+propVal);}
+return propList.join(newLine);}
+var nodeTypes={ELEMENT_NODE:1,ATTRIBUTE_NODE:2,TEXT_NODE:3,CDATA_SECTION_NODE:4,ENTITY_REFERENCE_NODE:5,ENTITY_NODE:6,PROCESSING_INSTRUCTION_NODE:7,COMMENT_NODE:8,DOCUMENT_NODE:9,DOCUMENT_TYPE_NODE:10,DOCUMENT_FRAGMENT_NODE:11,NOTATION_NODE:12};var preFormattedElements=["script","pre"];var emptyElements=["br","img","hr","param","link","area","input","col","base","meta"];var indentationUnit="  ";function getXhtml(rootNode,includeRootNode,indentation,startNewLine,preformatted){includeRootNode=(typeof includeRootNode=="undefined")?true:!!includeRootNode;if(typeof indentation!="string"){indentation="";}
+startNewLine=!!startNewLine;preformatted=!!preformatted;var xhtml;function isWhitespace(node){return((node.nodeType==nodeTypes.TEXT_NODE)&&/^[ \t\r\n]*$/.test(node.nodeValue));}
+function fixAttributeValue(attrValue){return attrValue.toString().replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/"/g,"&quot;");}
+function getStyleAttributeValue(el){var stylePairs=el.style.cssText.split(";");var styleValue="";var isFirst=true;for(var j=0,len=stylePairs.length;j<len;j++){var nameValueBits=stylePairs[j].split(":");var props=[];if(!/^\s*$/.test(nameValueBits[0])){props.push(trim(nameValueBits[0]).toLowerCase()+":"+trim(nameValueBits[1]));}
+styleValue=props.join(";");}
+return styleValue;}
+function getNamespace(el){if(el.prefix){return el.prefix;}else if(el.outerHTML){var regex=new RegExp("<([^:]+):"+el.tagName+"[^>]*>","i");if(regex.test(el.outerHTML)){return RegExp.$1.toLowerCase();}}
+return"";}
+var lt="<";var gt=">";if(includeRootNode&&rootNode.nodeType!=nodeTypes.DOCUMENT_FRAGMENT_NODE){switch(rootNode.nodeType){case nodeTypes.ELEMENT_NODE:var tagName=rootNode.tagName.toLowerCase();xhtml=startNewLine?newLine+indentation:"";xhtml+=lt;var prefix=getNamespace(rootNode);var hasPrefix=!!prefix;if(hasPrefix){xhtml+=prefix+":";}
+xhtml+=tagName;for(i=0,len=rootNode.attributes.length;i<len;i++){var currentAttr=rootNode.attributes[i];if(!currentAttr.specified||currentAttr.nodeValue===null||currentAttr.nodeName.toLowerCase()==="style"||typeof currentAttr.nodeValue!=="string"||currentAttr.nodeName.indexOf("_moz")===0){continue;}
+xhtml+=" "+currentAttr.nodeName.toLowerCase()+"=\"";xhtml+=fixAttributeValue(currentAttr.nodeValue);xhtml+="\"";}
+if(rootNode.style.cssText){var styleValue=getStyleAttributeValue(rootNode);if(styleValue!==""){xhtml+=" style=\""+getStyleAttributeValue(rootNode)+"\"";}}
+if(array_contains(emptyElements,tagName)||(hasPrefix&&!rootNode.hasChildNodes())){xhtml+="/"+gt;}else{xhtml+=gt;var childStartNewLine=!(rootNode.childNodes.length===1&&rootNode.childNodes[0].nodeType===nodeTypes.TEXT_NODE);var childPreformatted=array_contains(preFormattedElements,tagName);for(var i=0,len=rootNode.childNodes.length;i<len;i++){xhtml+=getXhtml(rootNode.childNodes[i],true,indentation+indentationUnit,childStartNewLine,childPreformatted);}
+var endTag=lt+"/"+tagName+gt;xhtml+=childStartNewLine?newLine+indentation+endTag:endTag;}
+return xhtml;case nodeTypes.TEXT_NODE:if(isWhitespace(rootNode)){xhtml="";}else{if(preformatted){xhtml=rootNode.nodeValue;}else{var lines=splitIntoLines(trim(rootNode.nodeValue));var trimmedLines=[];for(var i=0,len=lines.length;i<len;i++){trimmedLines[i]=trim(lines[i]);}
+xhtml=trimmedLines.join(newLine+indentation);}
+if(startNewLine){xhtml=newLine+indentation+xhtml;}}
+return xhtml;case nodeTypes.CDATA_SECTION_NODE:return"<![CDA"+"TA["+rootNode.nodeValue+"]"+"]>"+newLine;case nodeTypes.DOCUMENT_NODE:xhtml="";for(var i=0,len=rootNode.childNodes.length;i<len;i++){xhtml+=getXhtml(rootNode.childNodes[i],true,indentation);}
+return xhtml;default:return"";}}else{xhtml="";for(var i=0,len=rootNode.childNodes.length;i<len;i++){xhtml+=getXhtml(rootNode.childNodes[i],true,indentation+indentationUnit);}
+return xhtml;}}
+function createCommandLineFunctions(){ConsoleAppender.addGlobalCommandLineFunction("$",function(appender,args,returnValue){return document.getElementById(args[0]);});ConsoleAppender.addGlobalCommandLineFunction("dir",function(appender,args,returnValue){var lines=[];for(var i=0,len=args.length;i<len;i++){lines[i]=dir(args[i]);}
+return lines.join(newLine+newLine);});ConsoleAppender.addGlobalCommandLineFunction("dirxml",function(appender,args,returnValue){var lines=[];for(var i=0,len=args.length;i<len;i++){var win=appender.getCommandWindow();lines[i]=getXhtml(args[i]);}
+return lines.join(newLine+newLine);});ConsoleAppender.addGlobalCommandLineFunction("cd",function(appender,args,returnValue){var win,message;if(args.length===0||args[0]===""){win=window;message="Command line set to run in main window";}else{if(args[0].window==args[0]){win=args[0];message="Command line set to run in frame '"+args[0].name+"'";}else{win=window.frames[args[0]];if(win){message="Command line set to run in frame '"+args[0]+"'";}else{returnValue.isError=true;message="Frame '"+args[0]+"' does not exist";win=appender.getCommandWindow();}}}
+appender.setCommandWindow(win);return message;});ConsoleAppender.addGlobalCommandLineFunction("clear",function(appender,args,returnValue){returnValue.appendResult=false;appender.clear();});ConsoleAppender.addGlobalCommandLineFunction("keys",function(appender,args,returnValue){var keys=[];for(var k in args[0]){keys.push(k);}
+return keys;});ConsoleAppender.addGlobalCommandLineFunction("values",function(appender,args,returnValue){var values=[];for(var k in args[0]){try{values.push(args[0][k]);}catch(ex){logLog.warn("values(): Unable to obtain value for key "+k+". Details: "+getExceptionMessage(ex));}}
+return values;});ConsoleAppender.addGlobalCommandLineFunction("expansionDepth",function(appender,args,returnValue){var expansionDepth=parseInt(args[0],10);if(isNaN(expansionDepth)||expansionDepth<0){returnValue.isError=true;return""+args[0]+" is not a valid expansion depth";}else{appender.setCommandLineObjectExpansionDepth(expansionDepth);return"Object expansion depth set to "+expansionDepth;}});}
+function init(){createCommandLineFunctions();}
+init();})();log4javascript.setDocumentReady=function(){pageLoaded=true;log4javascript.dispatchEvent("load",{});};if(window.addEventListener){window.addEventListener("load",log4javascript.setDocumentReady,false);}else if(window.attachEvent){window.attachEvent("onload",log4javascript.setDocumentReady);}else{var oldOnload=window.onload;if(typeof window.onload!="function"){window.onload=log4javascript.setDocumentReady;}else{window.onload=function(evt){if(oldOnload){oldOnload(evt);}
+log4javascript.setDocumentReady();};}}
+window.log4javascript=log4javascript;return log4javascript;})();
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite.js
new file mode 100644
index 0000000..b04ce8e
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite.js
@@ -0,0 +1,55 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if(!Array.prototype.shift){Array.prototype.shift=function(){if(this.length>0){var firstItem=this[0];for(var i=0,len=this.length-1;i<len;i++){this[i]=this[i+1];}
+this.length--;return firstItem;}};}
+var log4javascript;(function(){var newLine="\r\n";function Log4JavaScript(){}
+log4javascript=new Log4JavaScript();log4javascript.version="1.4.6";log4javascript.edition="log4javascript_lite";function getExceptionMessage(ex){if(ex.message){return ex.message;}else if(ex.description){return ex.description;}else{return String(ex);}}
+function getUrlFileName(url){var lastSlashIndex=Math.max(url.lastIndexOf("/"),url.lastIndexOf("\\"));return url.substr(lastSlashIndex+1);}
+function getExceptionStringRep(ex){if(ex){var exStr="Exception: "+getExceptionMessage(ex);try{if(ex.lineNumber){exStr+=" on line number "+ex.lineNumber;}
+if(ex.fileName){exStr+=" in file "+getUrlFileName(ex.fileName);}}catch(localEx){}
+if(showStackTraces&&ex.stack){exStr+=newLine+"Stack trace:"+newLine+ex.stack;}
+return exStr;}
+return null;}
+function isError(err){return(err instanceof Error);}
+function bool(obj){return Boolean(obj);}
+var enabled=(typeof log4javascript_disabled!="undefined")&&log4javascript_disabled?false:true;log4javascript.setEnabled=function(enable){enabled=bool(enable);};log4javascript.isEnabled=function(){return enabled;};var showStackTraces=false;log4javascript.setShowStackTraces=function(show){showStackTraces=bool(show);};var Level=function(level,name){this.level=level;this.name=name;};Level.prototype={toString:function(){return this.name;},equals:function(level){return this.level==level.level;},isGreaterOrEqual:function(level){return this.level>=level.level;}};Level.ALL=new Level(Number.MIN_VALUE,"ALL");Level.TRACE=new Level(10000,"TRACE");Level.DEBUG=new Level(20000,"DEBUG");Level.INFO=new Level(30000,"INFO");Level.WARN=new Level(40000,"WARN");Level.ERROR=new Level(50000,"ERROR");Level.FATAL=new Level(60000,"FATAL");Level.OFF=new Level(Number.MAX_VALUE,"OFF");log4javascript.Level=Level;function Appender(){var getConsoleHtmlLines=function(){return['<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">','<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">','<head>','<title>log4javascript</title>','<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />','<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->','<meta http-equiv="X-UA-Compatible" content="IE=7" />','<script type="text/javascript">','//<![CDATA[','var loggingEnabled=true;var messagesBeforeDocLoaded=[];function toggleLoggingEnabled(){setLoggingEnabled($("enableLogging").checked);}','function setLoggingEnabled(enable){loggingEnabled=enable;}','function scrollToLatestEntry(){var l=getLogContainer();if(typeof l.scrollTop!="undefined"){var latestLogEntry=l.lastChild;if(latestLogEntry){l.scrollTop=l.scrollHeight;}}}','function log(logLevel,formattedMessage){if(loggingEnabled){if(loaded){doLog(logLevel,formattedMessage);}else{messagesBeforeDocLoaded.push([logLevel,formattedMessage]);}}}','function doLog(logLevel,formattedMessage){var logEntry=document.createElement("div");logEntry.appendChild(document.createTextNode(formattedMessage));logEntry.className="logentry "+logLevel.name;getLogContainer().appendChild(logEntry);scrollToLatestEntry();}','function mainPageReloaded(){var separator=document.createElement("div");separator.className="separator";separator.innerHTML="&nbsp;";getLogContainer().appendChild(separator);}','var loaded=false;var logLevels=["DEBUG","INFO","WARN","ERROR","FATAL"];window.onload=function(){setLogContainerHeight();toggleLoggingEnabled();for(var i=0;i<messagesBeforeDocLoaded.length;i++){doLog(messagesBeforeDocLoaded[i][0],messagesBeforeDocLoaded[i][1]);}','messagesBeforeDocLoaded=[];loaded=true;setTimeout(setLogContainerHeight,20);};function getLogContainer(){return $("log");}','function clearLog(){getLogContainer().innerHTML="";}','function $(id){return document.getElementById(id);}','function getWindowHeight(){if(window.innerHeight){return window.innerHeight;}else if(document.documentElement&&document.documentElement.clientHeight){return document.documentElement.clientHeight;}else if(document.body){return document.body.clientHeight;}','return 0;}','function getChromeHeight(){return $("toolbar").offsetHeight;}','function setLogContainerHeight(){var windowHeight=getWindowHeight();$("body").style.height=getWindowHeight()+"px";getLogContainer().style.height=""+','Math.max(0,windowHeight-getChromeHeight())+"px";}','window.onresize=function(){setLogContainerHeight();};','//]]>','</script>','<style type="text/css">','body{background-color:white;color:black;padding:0;margin:0;font-family:tahoma,verdana,arial,helvetica,sans-serif;overflow:hidden}div#toolbar{border-top:solid #ffffff 1px;border-bottom:solid #aca899 1px;background-color:#f1efe7;padding:3px 5px;font-size:68.75%}div#toolbar input.button{padding:0 5px;font-size:100%}div#log{font-family:Courier New,Courier;font-size:75%;width:100%;overflow:auto;clear:both}*.logentry{overflow:visible;white-space:pre}*.TRACE{color:#666666}*.DEBUG{color:green}*.INFO{color:#000099}*.WARN{color:#999900}*.ERROR{color:red}*.FATAL{color:#660066}div#log div.separator{background-color:#cccccc;margin:5px 0;line-height:1px}','</style>','</head>','<body id="body">','<div id="toolbar">','Options:','<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" class="stateful" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Enable logging</label>','<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="stateful button" title="Clear all log messages"  />','<input type="button" id="closeButton" value="Close" onclick="window.close()" class="stateful button" title="Close the window" />','</div>','<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>','</body>','</html>'];};var popUp=null;var popUpsBlocked=false;var popUpClosed=false;var popUpLoaded=false;var complainAboutPopUpBlocking=true;var initialized=false;var isSupported=true;var width=600;var height=400;var focusPopUp=false;var queuedLoggingEvents=new Array();function isLoaded(win){try{return bool(win.loaded);}catch(ex){return false;}}
+function finalInit(){popUpLoaded=true;appendQueuedLoggingEvents();}
+function writeHtml(doc){var lines=getConsoleHtmlLines();doc.open();for(var i=0,len=lines.length;i<len;i++){doc.writeln(lines[i]);}
+doc.close();}
+function pollConsoleWindow(){function pollConsoleWindowLoaded(){if(popUpLoaded){clearInterval(poll);}else if(bool(popUp)&&isLoaded(popUp)){clearInterval(poll);finalInit();}}
+var poll=setInterval(pollConsoleWindowLoaded,100);}
+function init(){var windowProperties="width="+width+",height="+height+",status,resizable";var windowName="log4javascriptLitePopUp"+location.host.replace(/[^a-z0-9]/gi,"_");popUp=window.open("",windowName,windowProperties);popUpClosed=false;if(popUp){if(isLoaded(popUp)){popUp.mainPageReloaded();finalInit();}else{writeHtml(popUp.document);if(isLoaded(popUp)){finalInit();}else{pollConsoleWindow();}}}else{isSupported=false;if(complainAboutPopUpBlocking){alert("log4javascript: pop-up windows appear to be blocked. Please unblock them to use pop-up logging.");}}
+initialized=true;}
+function safeToAppend(){if(!popUpsBlocked&&!popUpClosed){if(popUp.closed){popUpClosed=true;return false;}
+if(!popUpLoaded&&popUp.loaded){popUpLoaded=true;}}
+return!popUpsBlocked&&popUpLoaded&&!popUpClosed;}
+function padWithZeroes(num,len){var str=""+num;while(str.length<len){str="0"+str;}
+return str;}
+function padWithSpaces(str,len){while(str.length<len){str+=" ";}
+return str;}
+this.append=function(loggingEvent){if(!initialized){init();}
+queuedLoggingEvents.push(loggingEvent);if(safeToAppend()){appendQueuedLoggingEvents();}};function appendQueuedLoggingEvents(){if(safeToAppend()){while(queuedLoggingEvents.length>0){var currentLoggingEvent=queuedLoggingEvents.shift();var date=currentLoggingEvent.timeStamp;var formattedDate=padWithZeroes(date.getHours(),2)+":"+
+padWithZeroes(date.getMinutes(),2)+":"+padWithZeroes(date.getSeconds(),2);var formattedMessage=formattedDate+" "+padWithSpaces(currentLoggingEvent.level.name,5)+" - "+currentLoggingEvent.getCombinedMessages();var throwableStringRep=currentLoggingEvent.getThrowableStrRep();if(throwableStringRep){formattedMessage+=newLine+throwableStringRep;}
+popUp.log(currentLoggingEvent.level,formattedMessage);}
+if(focusPopUp){popUp.focus();}}}}
+log4javascript.Appender=Appender;function Logger(){var appender=new Appender();var loggerLevel=Level.ALL;this.log=function(level,params){if(enabled&&level.isGreaterOrEqual(this.getLevel())){var exception;var finalParamIndex=params.length-1;var lastParam=params[params.length-1];if(params.length>1&&isError(lastParam)){exception=lastParam;finalParamIndex--;}
+var messages=[];for(var i=0;i<=finalParamIndex;i++){messages[i]=params[i];}
+var loggingEvent=new LoggingEvent(this,new Date(),level,messages,exception);appender.append(loggingEvent);}};this.setLevel=function(level){loggerLevel=level;};this.getLevel=function(){return loggerLevel;};}
+Logger.prototype={trace:function(){this.log(Level.TRACE,arguments);},debug:function(){this.log(Level.DEBUG,arguments);},info:function(){this.log(Level.INFO,arguments);},warn:function(){this.log(Level.WARN,arguments);},error:function(){this.log(Level.ERROR,arguments);},fatal:function(){this.log(Level.FATAL,arguments);},isEnabledFor:function(level){return level.isGreaterOrEqual(this.getLevel());},isTraceEnabled:function(){return this.isEnabledFor(Level.TRACE);},isDebugEnabled:function(){return this.isEnabledFor(Level.DEBUG);},isInfoEnabled:function(){return this.isEnabledFor(Level.INFO);},isWarnEnabled:function(){return this.isEnabledFor(Level.WARN);},isErrorEnabled:function(){return this.isEnabledFor(Level.ERROR);},isFatalEnabled:function(){return this.isEnabledFor(Level.FATAL);}};var defaultLogger=null;log4javascript.getDefaultLogger=function(){if(!defaultLogger){defaultLogger=new Logger();}
+return defaultLogger;};log4javascript.getLogger=log4javascript.getDefaultLogger;var nullLogger=null;log4javascript.getNullLogger=function(){if(!nullLogger){nullLogger=new Logger();nullLogger.setLevel(Level.OFF);}
+return nullLogger;};var LoggingEvent=function(logger,timeStamp,level,messages,exception){this.logger=logger;this.timeStamp=timeStamp;this.level=level;this.messages=messages;this.exception=exception;};LoggingEvent.prototype={getThrowableStrRep:function(){return this.exception?getExceptionStringRep(this.exception):"";},getCombinedMessages:function(){return(this.messages.length===1)?this.messages[0]:this.messages.join(newLine);}};log4javascript.LoggingEvent=LoggingEvent;window.log4javascript=log4javascript;})();
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite_uncompressed.js
new file mode 100644
index 0000000..12e97d8
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_lite_uncompressed.js
@@ -0,0 +1,620 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!Array.prototype.shift) {
+	Array.prototype.shift = function() {
+		if (this.length > 0) {
+			var firstItem = this[0];
+			for (var i = 0, len = this.length - 1; i < len; i++) {
+				this[i] = this[i + 1];
+			}
+			this.length--;
+			return firstItem;
+		}
+	};
+}
+
+var log4javascript;
+
+(function() {
+	var newLine = "\r\n";
+	function Log4JavaScript() {}
+	log4javascript = new Log4JavaScript();
+	log4javascript.version = "1.4.6";
+	log4javascript.edition = "log4javascript_lite";
+
+	function getExceptionMessage(ex) {
+		if (ex.message) {
+			return ex.message;
+		} else if (ex.description) {
+			return ex.description;
+		} else {
+			return String(ex);
+		}
+	}
+
+	// Gets the portion of the URL after the last slash
+	function getUrlFileName(url) {
+		var lastSlashIndex = Math.max(url.lastIndexOf("/"), url.lastIndexOf("\\"));
+		return url.substr(lastSlashIndex + 1);
+	}
+
+	// Returns a nicely formatted representation of an error
+	function getExceptionStringRep(ex) {
+		if (ex) {
+			var exStr = "Exception: " + getExceptionMessage(ex);
+			try {
+				if (ex.lineNumber) {
+					exStr += " on line number " + ex.lineNumber;
+				}
+				if (ex.fileName) {
+					exStr += " in file " + getUrlFileName(ex.fileName);
+				}
+			} catch (localEx) {
+			}
+			if (showStackTraces && ex.stack) {
+				exStr += newLine + "Stack trace:" + newLine + ex.stack;
+			}
+			return exStr;
+		}
+		return null;
+	}
+
+	function isError(err) {
+		return (err instanceof Error);
+	}
+
+	function bool(obj) {
+		return Boolean(obj);
+	}
+
+	var enabled = (typeof log4javascript_disabled != "undefined") &&
+		log4javascript_disabled ? false : true;
+
+	log4javascript.setEnabled = function(enable) {
+		enabled = bool(enable);
+	};
+
+	log4javascript.isEnabled = function() {
+		return enabled;
+	};
+
+	var showStackTraces = false;
+
+	log4javascript.setShowStackTraces = function(show) {
+		showStackTraces = bool(show);
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Levels
+
+	var Level = function(level, name) {
+		this.level = level;
+		this.name = name;
+	};
+
+	Level.prototype = {
+		toString: function() {
+			return this.name;
+		},
+		equals: function(level) {
+			return this.level == level.level;
+		},
+		isGreaterOrEqual: function(level) {
+			return this.level >= level.level;
+		}
+	};
+
+	Level.ALL = new Level(Number.MIN_VALUE, "ALL");
+	Level.TRACE = new Level(10000, "TRACE");
+	Level.DEBUG = new Level(20000, "DEBUG");
+	Level.INFO = new Level(30000, "INFO");
+	Level.WARN = new Level(40000, "WARN");
+	Level.ERROR = new Level(50000, "ERROR");
+	Level.FATAL = new Level(60000, "FATAL");
+	Level.OFF = new Level(Number.MAX_VALUE, "OFF");
+
+	log4javascript.Level = Level;
+
+	/* ---------------------------------------------------------------------- */
+	// Appenders
+
+	function Appender() {
+		var getConsoleHtmlLines = function() {
+			return [
+'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+'<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">',
+'	<head>',
+'		<title>log4javascript</title>',
+'		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />',
+'		<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->',
+'		<meta http-equiv="X-UA-Compatible" content="IE=7" />',
+'		<script type="text/javascript">',
+'			//<![CDATA[',
+'			var loggingEnabled = true;',
+'			var messagesBeforeDocLoaded = [];',
+'',
+'			function toggleLoggingEnabled() {',
+'				setLoggingEnabled($("enableLogging").checked);',
+'			}',
+'',
+'			function setLoggingEnabled(enable) {',
+'				loggingEnabled = enable;',
+'			}',
+'',
+'			function scrollToLatestEntry() {',
+'				var l = getLogContainer();',
+'				if (typeof l.scrollTop != "undefined") {',
+'					var latestLogEntry = l.lastChild;',
+'					if (latestLogEntry) {',
+'						l.scrollTop = l.scrollHeight;',
+'					}',
+'				}',
+'			}',
+'',
+'			function log(logLevel, formattedMessage) {',
+'				if (loggingEnabled) {',
+'					if (loaded) {',
+'						doLog(logLevel, formattedMessage);',
+'					} else {',
+'						messagesBeforeDocLoaded.push([logLevel, formattedMessage]);',
+'					}',
+'				}',
+'			}',
+'',
+'			function doLog(logLevel, formattedMessage) {',
+'				var logEntry = document.createElement("div");',
+'				logEntry.appendChild(document.createTextNode(formattedMessage));',
+'				logEntry.className = "logentry " + logLevel.name;',
+'				getLogContainer().appendChild(logEntry);',
+'				scrollToLatestEntry();',
+'			}',
+'',
+'			function mainPageReloaded() {',
+'				var separator = document.createElement("div");',
+'				separator.className = "separator";',
+'				separator.innerHTML = "&nbsp;";',
+'				getLogContainer().appendChild(separator);',
+'			}',
+'',
+'			var loaded = false;',
+'			var logLevels = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"];',
+'',
+'			window.onload = function() {',
+'				setLogContainerHeight();',
+'				toggleLoggingEnabled();',
+'				for (var i = 0; i < messagesBeforeDocLoaded.length; i++) {',
+'					doLog(messagesBeforeDocLoaded[i][0], messagesBeforeDocLoaded[i][1]);',
+'				}',
+'				messagesBeforeDocLoaded = [];',
+'				loaded = true;',
+'',
+'				// Workaround to make sure log div starts at the correct size',
+'				setTimeout(setLogContainerHeight, 20);',
+'			};',
+'',
+'			function getLogContainer() {',
+'				return $("log");',
+'			}',
+'',
+'			function clearLog() {',
+'				getLogContainer().innerHTML = "";',
+'			}',
+'',
+'			/* ------------------------------------------------------------------------- */',
+'',
+'			// Other utility functions',
+'',
+'			// Syntax borrowed from Prototype library',
+'			function $(id) {',
+'				return document.getElementById(id);',
+'			}',
+'',
+'			function getWindowHeight() {',
+'				if (window.innerHeight) {',
+'					return window.innerHeight;',
+'				} else if (document.documentElement && document.documentElement.clientHeight) {',
+'					return document.documentElement.clientHeight;',
+'				} else if (document.body) {',
+'					return document.body.clientHeight;',
+'				}',
+'				return 0;',
+'			}',
+'',
+'			function getChromeHeight() {',
+'				return $("toolbar").offsetHeight;',
+'			}',
+'',
+'			function setLogContainerHeight() {',
+'				var windowHeight = getWindowHeight();',
+'				$("body").style.height = getWindowHeight() + "px";',
+'				getLogContainer().style.height = "" +',
+'					Math.max(0, windowHeight - getChromeHeight()) + "px";',
+'			}',
+'',
+'			window.onresize = function() {',
+'				setLogContainerHeight();',
+'			};',
+'',
+'			//]]>',
+'		</script>',
+'		<style type="text/css">',
+'			body {',
+'				background-color: white;',
+'				color: black;',
+'				padding: 0;',
+'				margin: 0;',
+'				font-family: tahoma, verdana, arial, helvetica, sans-serif;',
+'				overflow: hidden;',
+'			}',
+'			',
+'			div#toolbar {',
+'				border-top: solid #ffffff 1px;',
+'				border-bottom: solid #aca899 1px;',
+'				background-color: #f1efe7;',
+'				padding: 3px 5px;',
+'				font-size: 68.75%;',
+'			}',
+'',
+'			div#toolbar input.button {',
+'				padding: 0 5px;',
+'				font-size: 100%;',
+'			}',
+'',
+'			div#log {',
+'				font-family: Courier New, Courier;',
+'				font-size: 75%;',
+'				width: 100%;',
+'				overflow: auto;',
+'				clear: both;',
+'			}',
+'',
+'			*.logentry {',
+'				overflow: visible;',
+'				white-space: pre;',
+'			}',
+'',
+'			*.TRACE {',
+'				color: #666666;',
+'			}',
+'',
+'			*.DEBUG {',
+'				color: green;',
+'			}',
+'',
+'			*.INFO {',
+'				color: #000099;',
+'			}',
+'',
+'			*.WARN {',
+'				color: #999900;',
+'			}',
+'',
+'			*.ERROR {',
+'				color: red;',
+'			}',
+'',
+'			*.FATAL {',
+'				color: #660066;',
+'			}',
+'',
+'			div#log div.separator {',
+'				background-color: #cccccc;',
+'				margin: 5px 0;',
+'				line-height: 1px;',
+'			}',
+'		</style>',
+'	</head>',
+'',
+'	<body id="body">',
+'		<div id="toolbar">',
+'			Options:',
+'			<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" class="stateful" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Enable logging</label>',
+'			<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="stateful button" title="Clear all log messages"  />',
+'			<input type="button" id="closeButton" value="Close" onclick="window.close()" class="stateful button" title="Close the window" />',
+'		</div>',
+'		<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>',
+'	</body>',
+'</html>'
+];
+		};
+
+		var popUp = null;
+		var popUpsBlocked = false;
+		var popUpClosed = false;
+		var popUpLoaded = false;
+		var complainAboutPopUpBlocking = true;
+		var initialized = false;
+		var isSupported = true;
+		var width = 600;
+		var height = 400;
+		var focusPopUp = false;
+		var queuedLoggingEvents = new Array();
+
+		function isLoaded(win) {
+			try {
+				return bool(win.loaded);
+			} catch (ex) {
+				return false;
+			}
+		}
+
+		function finalInit() {
+			popUpLoaded = true;
+			appendQueuedLoggingEvents();
+		}
+
+		function writeHtml(doc) {
+			var lines = getConsoleHtmlLines();
+			doc.open();
+			for (var i = 0, len = lines.length; i < len; i++) {
+				doc.writeln(lines[i]);
+			}
+			doc.close();
+		}
+
+		function pollConsoleWindow() {
+			function pollConsoleWindowLoaded() {
+				if (popUpLoaded) {
+					clearInterval(poll);
+				} else if (bool(popUp) && isLoaded(popUp)) {
+					clearInterval(poll);
+					finalInit();
+				}
+			}
+
+			// Poll the pop-up since the onload event is not reliable
+			var poll = setInterval(pollConsoleWindowLoaded, 100);
+		}
+
+		function init() {
+			var windowProperties = "width=" + width + ",height=" + height + ",status,resizable";
+			var windowName = "log4javascriptLitePopUp" + location.host.replace(/[^a-z0-9]/gi, "_");
+
+			popUp = window.open("", windowName, windowProperties);
+			popUpClosed = false;
+			if (popUp) {
+				if (isLoaded(popUp)) {
+					popUp.mainPageReloaded();
+					finalInit();
+				} else {
+					writeHtml(popUp.document);
+
+					// Check if the pop-up window object is available
+					if (isLoaded(popUp)) {
+						finalInit();
+					} else {
+						pollConsoleWindow();
+					}
+				}
+			} else {
+				isSupported = false;
+				if (complainAboutPopUpBlocking) {
+					alert("log4javascript: pop-up windows appear to be blocked. Please unblock them to use pop-up logging.");
+				}
+			}
+			initialized = true;
+		}
+
+		function safeToAppend() {
+			if (!popUpsBlocked && !popUpClosed) {
+				if (popUp.closed) {
+					popUpClosed = true;
+					return false;
+				}
+				if (!popUpLoaded && popUp.loaded) {
+					popUpLoaded = true;
+				}
+			}
+			return !popUpsBlocked && popUpLoaded && !popUpClosed;
+		}
+
+		function padWithZeroes(num, len) {
+			var str = "" + num;
+			while (str.length < len) {
+				str = "0" + str;
+			}
+			return str;
+		}
+
+		function padWithSpaces(str, len) {
+			while (str.length < len) {
+				str += " ";
+			}
+			return str;
+		}
+
+		this.append = function(loggingEvent) {
+			if (!initialized) {
+				init();
+			}
+			queuedLoggingEvents.push(loggingEvent);
+			if (safeToAppend()) {
+				appendQueuedLoggingEvents();
+			}
+		};
+
+		function appendQueuedLoggingEvents() {
+			if (safeToAppend()) {
+				while (queuedLoggingEvents.length > 0) {
+					var currentLoggingEvent = queuedLoggingEvents.shift();
+					var date = currentLoggingEvent.timeStamp;
+					var formattedDate = padWithZeroes(date.getHours(), 2) + ":" +
+						padWithZeroes(date.getMinutes(), 2) + ":" + padWithZeroes(date.getSeconds(), 2);
+					var formattedMessage = formattedDate + " " + padWithSpaces(currentLoggingEvent.level.name, 5) +
+						" - " + currentLoggingEvent.getCombinedMessages();
+					var throwableStringRep = currentLoggingEvent.getThrowableStrRep();
+					if (throwableStringRep) {
+						formattedMessage += newLine + throwableStringRep;
+					}
+					popUp.log(currentLoggingEvent.level, formattedMessage);
+				}
+				if (focusPopUp) {
+					popUp.focus();
+				}
+			}
+		}
+	}
+
+	log4javascript.Appender = Appender;
+
+	/* ---------------------------------------------------------------------- */
+	// Loggers
+
+	function Logger() {
+		var appender = new Appender();
+		var loggerLevel = Level.ALL;
+
+		this.log = function(level, params) {
+			if (enabled && level.isGreaterOrEqual(this.getLevel())) {
+				// Check whether last param is an exception
+				var exception;
+				var finalParamIndex = params.length - 1;
+				var lastParam = params[params.length - 1];
+				if (params.length > 1 && isError(lastParam)) {
+					exception = lastParam;
+					finalParamIndex--;
+				}
+
+				// Construct genuine array for the params
+				var messages = [];
+				for (var i = 0; i <= finalParamIndex; i++) {
+					messages[i] = params[i];
+				}
+
+				var loggingEvent = new LoggingEvent(
+					this, new Date(), level, messages, exception);
+
+				appender.append(loggingEvent);
+			}
+		};
+
+		this.setLevel = function(level) {
+			loggerLevel = level;
+		};
+
+		this.getLevel = function() {
+			return loggerLevel;
+		};
+	}
+
+	Logger.prototype = {
+		trace: function() {
+			this.log(Level.TRACE, arguments);
+		},
+
+		debug: function() {
+			this.log(Level.DEBUG, arguments);
+		},
+
+		info: function() {
+			this.log(Level.INFO, arguments);
+		},
+
+		warn: function() {
+			this.log(Level.WARN, arguments);
+		},
+
+		error: function() {
+			this.log(Level.ERROR, arguments);
+		},
+
+		fatal: function() {
+			this.log(Level.FATAL, arguments);
+		},
+
+		isEnabledFor: function(level) {
+			return level.isGreaterOrEqual(this.getLevel());
+		},
+
+		isTraceEnabled: function() {
+			return this.isEnabledFor(Level.TRACE);
+		},
+
+		isDebugEnabled: function() {
+			return this.isEnabledFor(Level.DEBUG);
+		},
+
+		isInfoEnabled: function() {
+			return this.isEnabledFor(Level.INFO);
+		},
+
+		isWarnEnabled: function() {
+			return this.isEnabledFor(Level.WARN);
+		},
+
+		isErrorEnabled: function() {
+			return this.isEnabledFor(Level.ERROR);
+		},
+
+		isFatalEnabled: function() {
+			return this.isEnabledFor(Level.FATAL);
+		}
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Logger access methods
+
+	var defaultLogger = null;
+	log4javascript.getDefaultLogger = function() {
+		if (!defaultLogger) {
+			defaultLogger = new Logger();
+		}
+		return defaultLogger;
+	};
+
+	log4javascript.getLogger = log4javascript.getDefaultLogger;
+
+	var nullLogger = null;
+	log4javascript.getNullLogger = function() {
+		if (!nullLogger) {
+			nullLogger = new Logger();
+			nullLogger.setLevel(Level.OFF);
+		}
+		return nullLogger;
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Logging events
+
+	var LoggingEvent = function(logger, timeStamp, level, messages,
+			exception) {
+		this.logger = logger;
+		this.timeStamp = timeStamp;
+		this.level = level;
+		this.messages = messages;
+		this.exception = exception;
+	};
+
+	LoggingEvent.prototype = {
+		getThrowableStrRep: function() {
+			return this.exception ?
+				getExceptionStringRep(this.exception) : "";
+		},
+
+		getCombinedMessages: function() {
+			return (this.messages.length === 1) ? this.messages[0] :
+				   this.messages.join(newLine);
+		}
+	};
+
+	log4javascript.LoggingEvent = LoggingEvent;
+
+	// Ensure that the log4javascript object is available in the window. This
+	// is necessary for log4javascript to be available in IE if loaded using
+	// Dojo's module system
+	window.log4javascript = log4javascript;
+})();
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production.js
new file mode 100644
index 0000000..1a31299
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production.js
@@ -0,0 +1,188 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+if(!Array.prototype.push){Array.prototype.push=function(){for(var i=0,len=arguments.length;i<len;i++){this[this.length]=arguments[i];}
+return this.length;};}
+if(!Array.prototype.shift){Array.prototype.shift=function(){if(this.length>0){var firstItem=this[0];for(var i=0,len=this.length-1;i<len;i++){this[i]=this[i+1];}
+this.length=this.length-1;return firstItem;}};}
+if(!Array.prototype.splice){Array.prototype.splice=function(startIndex,deleteCount){var itemsAfterDeleted=this.slice(startIndex+deleteCount);var itemsDeleted=this.slice(startIndex,startIndex+deleteCount);this.length=startIndex;var argumentsArray=[];for(var i=0,len=arguments.length;i<len;i++){argumentsArray[i]=arguments[i];}
+var itemsToAppend=(argumentsArray.length>2)?itemsAfterDeleted=argumentsArray.slice(2).concat(itemsAfterDeleted):itemsAfterDeleted;for(i=0,len=itemsToAppend.length;i<len;i++){this.push(itemsToAppend[i]);}
+return itemsDeleted;};}
+var log4javascript=(function(){function isUndefined(obj){return typeof obj=="undefined";}
+function EventSupport(){}
+EventSupport.prototype={eventTypes:[],eventListeners:{},setEventTypes:function(eventTypesParam){if(eventTypesParam instanceof Array){this.eventTypes=eventTypesParam;this.eventListeners={};for(var i=0,len=this.eventTypes.length;i<len;i++){this.eventListeners[this.eventTypes[i]]=[];}}else{handleError("log4javascript.EventSupport ["+this+"]: setEventTypes: eventTypes parameter must be an Array");}},addEventListener:function(eventType,listener){if(typeof listener=="function"){if(!array_contains(this.eventTypes,eventType)){handleError("log4javascript.EventSupport ["+this+"]: addEventListener: no event called '"+eventType+"'");}
+this.eventListeners[eventType].push(listener);}else{handleError("log4javascript.EventSupport ["+this+"]: addEventListener: listener must be a function");}},removeEventListener:function(eventType,listener){if(typeof listener=="function"){if(!array_contains(this.eventTypes,eventType)){handleError("log4javascript.EventSupport ["+this+"]: removeEventListener: no event called '"+eventType+"'");}
+array_remove(this.eventListeners[eventType],listener);}else{handleError("log4javascript.EventSupport ["+this+"]: removeEventListener: listener must be a function");}},dispatchEvent:function(eventType,eventArgs){if(array_contains(this.eventTypes,eventType)){var listeners=this.eventListeners[eventType];for(var i=0,len=listeners.length;i<len;i++){listeners[i](this,eventType,eventArgs);}}else{handleError("log4javascript.EventSupport ["+this+"]: dispatchEvent: no event called '"+eventType+"'");}}};var applicationStartDate=new Date();var uniqueId="log4javascript_"+applicationStartDate.getTime()+"_"+
+Math.floor(Math.random()*100000000);var emptyFunction=function(){};var newLine="\r\n";var pageLoaded=false;function Log4JavaScript(){}
+Log4JavaScript.prototype=new EventSupport();log4javascript=new Log4JavaScript();log4javascript.version="1.4.6";log4javascript.edition="log4javascript_production";function toStr(obj){if(obj&&obj.toString){return obj.toString();}else{return String(obj);}}
+function getExceptionMessage(ex){if(ex.message){return ex.message;}else if(ex.description){return ex.description;}else{return toStr(ex);}}
+function getUrlFileName(url){var lastSlashIndex=Math.max(url.lastIndexOf("/"),url.lastIndexOf("\\"));return url.substr(lastSlashIndex+1);}
+function getExceptionStringRep(ex){if(ex){var exStr="Exception: "+getExceptionMessage(ex);try{if(ex.lineNumber){exStr+=" on line number "+ex.lineNumber;}
+if(ex.fileName){exStr+=" in file "+getUrlFileName(ex.fileName);}}catch(localEx){logLog.warn("Unable to obtain file and line information for error");}
+if(showStackTraces&&ex.stack){exStr+=newLine+"Stack trace:"+newLine+ex.stack;}
+return exStr;}
+return null;}
+function bool(obj){return Boolean(obj);}
+function trim(str){return str.replace(/^\s+/,"").replace(/\s+$/,"");}
+function splitIntoLines(text){var text2=text.replace(/\r\n/g,"\n").replace(/\r/g,"\n");return text2.split("\n");}
+var urlEncode=(typeof window.encodeURIComponent!="undefined")?function(str){return encodeURIComponent(str);}:function(str){return escape(str).replace(/\+/g,"%2B").replace(/"/g,"%22").replace(/'/g,"%27").replace(/\//g,"%2F").replace(/=/g,"%3D");};var urlDecode=(typeof window.decodeURIComponent!="undefined")?function(str){return decodeURIComponent(str);}:function(str){return unescape(str).replace(/%2B/g,"+").replace(/%22/g,"\"").replace(/%27/g,"'").replace(/%2F/g,"/").replace(/%3D/g,"=");};function array_remove(arr,val){var index=-1;for(var i=0,len=arr.length;i<len;i++){if(arr[i]===val){index=i;break;}}
+if(index>=0){arr.splice(index,1);return true;}else{return false;}}
+function array_contains(arr,val){for(var i=0,len=arr.length;i<len;i++){if(arr[i]==val){return true;}}
+return false;}
+function extractBooleanFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{return bool(param);}}
+function extractStringFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{return String(param);}}
+function extractIntFromParam(param,defaultValue){if(isUndefined(param)){return defaultValue;}else{try{var value=parseInt(param,10);return isNaN(value)?defaultValue:value;}catch(ex){logLog.warn("Invalid int param "+param,ex);return defaultValue;}}}
+function extractFunctionFromParam(param,defaultValue){if(typeof param=="function"){return param;}else{return defaultValue;}}
+function isError(err){return(err instanceof Error);}
+if(!Function.prototype.apply){Function.prototype.apply=function(obj,args){var methodName="__apply__";if(typeof obj[methodName]!="undefined"){methodName+=String(Math.random()).substr(2);}
+obj[methodName]=this;var argsStrings=[];for(var i=0,len=args.length;i<len;i++){argsStrings[i]="args["+i+"]";}
+var script="obj."+methodName+"("+argsStrings.join(",")+")";var returnValue=eval(script);delete obj[methodName];return returnValue;};}
+if(!Function.prototype.call){Function.prototype.call=function(obj){var args=[];for(var i=1,len=arguments.length;i<len;i++){args[i-1]=arguments[i];}
+return this.apply(obj,args);};}
+function getListenersPropertyName(eventName){return"__log4javascript_listeners__"+eventName;}
+function addEvent(node,eventName,listener,useCapture,win){win=win?win:window;if(node.addEventListener){node.addEventListener(eventName,listener,useCapture);}else if(node.attachEvent){node.attachEvent("on"+eventName,listener);}else{var propertyName=getListenersPropertyName(eventName);if(!node[propertyName]){node[propertyName]=[];node["on"+eventName]=function(evt){evt=getEvent(evt,win);var listenersPropertyName=getListenersPropertyName(eventName);var listeners=this[listenersPropertyName].concat([]);var currentListener;while((currentListener=listeners.shift())){currentListener.call(this,evt);}};}
+node[propertyName].push(listener);}}
+function removeEvent(node,eventName,listener,useCapture){if(node.removeEventListener){node.removeEventListener(eventName,listener,useCapture);}else if(node.detachEvent){node.detachEvent("on"+eventName,listener);}else{var propertyName=getListenersPropertyName(eventName);if(node[propertyName]){array_remove(node[propertyName],listener);}}}
+function getEvent(evt,win){win=win?win:window;return evt?evt:win.event;}
+function stopEventPropagation(evt){if(evt.stopPropagation){evt.stopPropagation();}else if(typeof evt.cancelBubble!="undefined"){evt.cancelBubble=true;}
+evt.returnValue=false;}
+var logLog={quietMode:false,debugMessages:[],setQuietMode:function(quietMode){this.quietMode=bool(quietMode);},numberOfErrors:0,alertAllErrors:false,setAlertAllErrors:function(alertAllErrors){this.alertAllErrors=alertAllErrors;},debug:function(message){this.debugMessages.push(message);},displayDebug:function(){alert(this.debugMessages.join(newLine));},warn:function(message,exception){},error:function(message,exception){if(++this.numberOfErrors==1||this.alertAllErrors){if(!this.quietMode){var alertMessage="log4javascript error: "+message;if(exception){alertMessage+=newLine+newLine+"Original error: "+getExceptionStringRep(exception);}
+alert(alertMessage);}}}};log4javascript.logLog=logLog;log4javascript.setEventTypes(["load","error"]);function handleError(message,exception){logLog.error(message,exception);log4javascript.dispatchEvent("error",{"message":message,"exception":exception});}
+log4javascript.handleError=handleError;var enabled=!((typeof log4javascript_disabled!="undefined")&&log4javascript_disabled);log4javascript.setEnabled=function(enable){enabled=bool(enable);};log4javascript.isEnabled=function(){return enabled;};var useTimeStampsInMilliseconds=true;log4javascript.setTimeStampsInMilliseconds=function(timeStampsInMilliseconds){useTimeStampsInMilliseconds=bool(timeStampsInMilliseconds);};log4javascript.isTimeStampsInMilliseconds=function(){return useTimeStampsInMilliseconds;};log4javascript.evalInScope=function(expr){return eval(expr);};var showStackTraces=false;log4javascript.setShowStackTraces=function(show){showStackTraces=bool(show);};var Level=function(level,name){this.level=level;this.name=name;};Level.prototype={toString:function(){return this.name;},equals:function(level){return this.level==level.level;},isGreaterOrEqual:function(level){return this.level>=level.level;}};Level.ALL=new Level(Number.MIN_VALUE,"ALL");Level.TRACE=new Level(10000,"TRACE");Level.DEBUG=new Level(20000,"DEBUG");Level.INFO=new Level(30000,"INFO");Level.WARN=new Level(40000,"WARN");Level.ERROR=new Level(50000,"ERROR");Level.FATAL=new Level(60000,"FATAL");Level.OFF=new Level(Number.MAX_VALUE,"OFF");log4javascript.Level=Level;function Timer(name,level){this.name=name;this.level=isUndefined(level)?Level.INFO:level;this.start=new Date();}
+Timer.prototype.getElapsedTime=function(){return new Date().getTime()-this.start.getTime();};var anonymousLoggerName="[anonymous]";var defaultLoggerName="[default]";var nullLoggerName="[null]";var rootLoggerName="root";function Logger(name){this.name=name;this.parent=null;this.children=[];var appenders=[];var loggerLevel=null;var isRoot=(this.name===rootLoggerName);var isNull=(this.name===nullLoggerName);var appenderCache=null;var appenderCacheInvalidated=false;this.addChild=function(childLogger){this.children.push(childLogger);childLogger.parent=this;childLogger.invalidateAppenderCache();};var additive=true;this.getAdditivity=function(){return additive;};this.setAdditivity=function(additivity){var valueChanged=(additive!=additivity);additive=additivity;if(valueChanged){this.invalidateAppenderCache();}};this.addAppender=function(appender){if(isNull){handleError("Logger.addAppender: you may not add an appender to the null logger");}else{if(appender instanceof log4javascript.Appender){if(!array_contains(appenders,appender)){appenders.push(appender);appender.setAddedToLogger(this);this.invalidateAppenderCache();}}else{handleError("Logger.addAppender: appender supplied ('"+
+toStr(appender)+"') is not a subclass of Appender");}}};this.removeAppender=function(appender){array_remove(appenders,appender);appender.setRemovedFromLogger(this);this.invalidateAppenderCache();};this.removeAllAppenders=function(){var appenderCount=appenders.length;if(appenderCount>0){for(var i=0;i<appenderCount;i++){appenders[i].setRemovedFromLogger(this);}
+appenders.length=0;this.invalidateAppenderCache();}};this.getEffectiveAppenders=function(){if(appenderCache===null||appenderCacheInvalidated){var parentEffectiveAppenders=(isRoot||!this.getAdditivity())?[]:this.parent.getEffectiveAppenders();appenderCache=parentEffectiveAppenders.concat(appenders);appenderCacheInvalidated=false;}
+return appenderCache;};this.invalidateAppenderCache=function(){appenderCacheInvalidated=true;for(var i=0,len=this.children.length;i<len;i++){this.children[i].invalidateAppenderCache();}};this.log=function(level,params){if(enabled&&level.isGreaterOrEqual(this.getEffectiveLevel())){var exception;var finalParamIndex=params.length-1;var lastParam=params[finalParamIndex];if(params.length>1&&isError(lastParam)){exception=lastParam;finalParamIndex--;}
+var messages=[];for(var i=0;i<=finalParamIndex;i++){messages[i]=params[i];}
+var loggingEvent=new LoggingEvent(this,new Date(),level,messages,exception);this.callAppenders(loggingEvent);}};this.callAppenders=function(loggingEvent){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].doAppend(loggingEvent);}};this.setLevel=function(level){if(isRoot&&level===null){handleError("Logger.setLevel: you cannot set the level of the root logger to null");}else if(level instanceof Level){loggerLevel=level;}else{handleError("Logger.setLevel: level supplied to logger "+
+this.name+" is not an instance of log4javascript.Level");}};this.getLevel=function(){return loggerLevel;};this.getEffectiveLevel=function(){for(var logger=this;logger!==null;logger=logger.parent){var level=logger.getLevel();if(level!==null){return level;}}};this.group=function(name,initiallyExpanded){if(enabled){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].group(name,initiallyExpanded);}}};this.groupEnd=function(){if(enabled){var effectiveAppenders=this.getEffectiveAppenders();for(var i=0,len=effectiveAppenders.length;i<len;i++){effectiveAppenders[i].groupEnd();}}};var timers={};this.time=function(name,level){if(enabled){if(isUndefined(name)){handleError("Logger.time: a name for the timer must be supplied");}else if(level&&!(level instanceof Level)){handleError("Logger.time: level supplied to timer "+
+name+" is not an instance of log4javascript.Level");}else{timers[name]=new Timer(name,level);}}};this.timeEnd=function(name){if(enabled){if(isUndefined(name)){handleError("Logger.timeEnd: a name for the timer must be supplied");}else if(timers[name]){var timer=timers[name];var milliseconds=timer.getElapsedTime();this.log(timer.level,["Timer "+toStr(name)+" completed in "+milliseconds+"ms"]);delete timers[name];}else{logLog.warn("Logger.timeEnd: no timer found with name "+name);}}};this.assert=function(expr){if(enabled&&!expr){var args=[];for(var i=1,len=arguments.length;i<len;i++){args.push(arguments[i]);}
+args=(args.length>0)?args:["Assertion Failure"];args.push(newLine);args.push(expr);this.log(Level.ERROR,args);}};this.toString=function(){return"Logger["+this.name+"]";};}
+Logger.prototype={trace:function(){this.log(Level.TRACE,arguments);},debug:function(){this.log(Level.DEBUG,arguments);},info:function(){this.log(Level.INFO,arguments);},warn:function(){this.log(Level.WARN,arguments);},error:function(){this.log(Level.ERROR,arguments);},fatal:function(){this.log(Level.FATAL,arguments);},isEnabledFor:function(level){return level.isGreaterOrEqual(this.getEffectiveLevel());},isTraceEnabled:function(){return this.isEnabledFor(Level.TRACE);},isDebugEnabled:function(){return this.isEnabledFor(Level.DEBUG);},isInfoEnabled:function(){return this.isEnabledFor(Level.INFO);},isWarnEnabled:function(){return this.isEnabledFor(Level.WARN);},isErrorEnabled:function(){return this.isEnabledFor(Level.ERROR);},isFatalEnabled:function(){return this.isEnabledFor(Level.FATAL);}};Logger.prototype.trace.isEntryPoint=true;Logger.prototype.debug.isEntryPoint=true;Logger.prototype.info.isEntryPoint=true;Logger.prototype.warn.isEntryPoint=true;Logger.prototype.error.isEntryPoint=true;Logger.prototype.fatal.isEntryPoint=true;var loggers={};var loggerNames=[];var ROOT_LOGGER_DEFAULT_LEVEL=Level.DEBUG;var rootLogger=new Logger(rootLoggerName);rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);log4javascript.getRootLogger=function(){return rootLogger;};log4javascript.getLogger=function(loggerName){if(!(typeof loggerName=="string")){loggerName=anonymousLoggerName;logLog.warn("log4javascript.getLogger: non-string logger name "+
+toStr(loggerName)+" supplied, returning anonymous logger");}
+if(loggerName==rootLoggerName){handleError("log4javascript.getLogger: root logger may not be obtained by name");}
+if(!loggers[loggerName]){var logger=new Logger(loggerName);loggers[loggerName]=logger;loggerNames.push(loggerName);var lastDotIndex=loggerName.lastIndexOf(".");var parentLogger;if(lastDotIndex>-1){var parentLoggerName=loggerName.substring(0,lastDotIndex);parentLogger=log4javascript.getLogger(parentLoggerName);}else{parentLogger=rootLogger;}
+parentLogger.addChild(logger);}
+return loggers[loggerName];};var defaultLogger=null;log4javascript.getDefaultLogger=function(){if(!defaultLogger){defaultLogger=log4javascript.getLogger(defaultLoggerName);var a=new log4javascript.PopUpAppender();defaultLogger.addAppender(a);}
+return defaultLogger;};var nullLogger=null;log4javascript.getNullLogger=function(){if(!nullLogger){nullLogger=new Logger(nullLoggerName);nullLogger.setLevel(Level.OFF);}
+return nullLogger;};log4javascript.resetConfiguration=function(){rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);loggers={};};var LoggingEvent=function(logger,timeStamp,level,messages,exception){this.logger=logger;this.timeStamp=timeStamp;this.timeStampInMilliseconds=timeStamp.getTime();this.timeStampInSeconds=Math.floor(this.timeStampInMilliseconds/1000);this.milliseconds=this.timeStamp.getMilliseconds();this.level=level;this.messages=messages;this.exception=exception;};LoggingEvent.prototype={getThrowableStrRep:function(){return this.exception?getExceptionStringRep(this.exception):"";},getCombinedMessages:function(){return(this.messages.length==1)?this.messages[0]:this.messages.join(newLine);},toString:function(){return"LoggingEvent["+this.level+"]";}};log4javascript.LoggingEvent=LoggingEvent;var Layout=function(){};Layout.prototype={defaults:{loggerKey:"logger",timeStampKey:"timestamp",millisecondsKey:"milliseconds",levelKey:"level",messageKey:"message",exceptionKey:"exception",urlKey:"url"},loggerKey:"logger",timeStampKey:"timestamp",millisecondsKey:"milliseconds",levelKey:"level",messageKey:"message",exceptionKey:"exception",urlKey:"url",batchHeader:"",batchFooter:"",batchSeparator:"",returnsPostData:false,overrideTimeStampsSetting:false,useTimeStampsInMilliseconds:null,format:function(){handleError("Layout.format: layout supplied has no format() method");},ignoresThrowable:function(){handleError("Layout.ignoresThrowable: layout supplied has no ignoresThrowable() method");},getContentType:function(){return"text/plain";},allowBatching:function(){return true;},setTimeStampsInMilliseconds:function(timeStampsInMilliseconds){this.overrideTimeStampsSetting=true;this.useTimeStampsInMilliseconds=bool(timeStampsInMilliseconds);},isTimeStampsInMilliseconds:function(){return this.overrideTimeStampsSetting?this.useTimeStampsInMilliseconds:useTimeStampsInMilliseconds;},getTimeStampValue:function(loggingEvent){return this.isTimeStampsInMilliseconds()?loggingEvent.timeStampInMilliseconds:loggingEvent.timeStampInSeconds;},getDataValues:function(loggingEvent,combineMessages){var dataValues=[[this.loggerKey,loggingEvent.logger.name],[this.timeStampKey,this.getTimeStampValue(loggingEvent)],[this.levelKey,loggingEvent.level.name],[this.urlKey,window.location.href],[this.messageKey,combineMessages?loggingEvent.getCombinedMessages():loggingEvent.messages]];if(!this.isTimeStampsInMilliseconds()){dataValues.push([this.millisecondsKey,loggingEvent.milliseconds]);}
+if(loggingEvent.exception){dataValues.push([this.exceptionKey,getExceptionStringRep(loggingEvent.exception)]);}
+if(this.hasCustomFields()){for(var i=0,len=this.customFields.length;i<len;i++){var val=this.customFields[i].value;if(typeof val==="function"){val=val(this,loggingEvent);}
+dataValues.push([this.customFields[i].name,val]);}}
+return dataValues;},setKeys:function(loggerKey,timeStampKey,levelKey,messageKey,exceptionKey,urlKey,millisecondsKey){this.loggerKey=extractStringFromParam(loggerKey,this.defaults.loggerKey);this.timeStampKey=extractStringFromParam(timeStampKey,this.defaults.timeStampKey);this.levelKey=extractStringFromParam(levelKey,this.defaults.levelKey);this.messageKey=extractStringFromParam(messageKey,this.defaults.messageKey);this.exceptionKey=extractStringFromParam(exceptionKey,this.defaults.exceptionKey);this.urlKey=extractStringFromParam(urlKey,this.defaults.urlKey);this.millisecondsKey=extractStringFromParam(millisecondsKey,this.defaults.millisecondsKey);},setCustomField:function(name,value){var fieldUpdated=false;for(var i=0,len=this.customFields.length;i<len;i++){if(this.customFields[i].name===name){this.customFields[i].value=value;fieldUpdated=true;}}
+if(!fieldUpdated){this.customFields.push({"name":name,"value":value});}},hasCustomFields:function(){return(this.customFields.length>0);},toString:function(){handleError("Layout.toString: all layouts must override this method");}};log4javascript.Layout=Layout;var Appender=function(){};Appender.prototype=new EventSupport();Appender.prototype.layout=new PatternLayout();Appender.prototype.threshold=Level.ALL;Appender.prototype.loggers=[];Appender.prototype.doAppend=function(loggingEvent){if(enabled&&loggingEvent.level.level>=this.threshold.level){this.append(loggingEvent);}};Appender.prototype.append=function(loggingEvent){};Appender.prototype.setLayout=function(layout){if(layout instanceof Layout){this.layout=layout;}else{handleError("Appender.setLayout: layout supplied to "+
+this.toString()+" is not a subclass of Layout");}};Appender.prototype.getLayout=function(){return this.layout;};Appender.prototype.setThreshold=function(threshold){if(threshold instanceof Level){this.threshold=threshold;}else{handleError("Appender.setThreshold: threshold supplied to "+
+this.toString()+" is not a subclass of Level");}};Appender.prototype.getThreshold=function(){return this.threshold;};Appender.prototype.setAddedToLogger=function(logger){this.loggers.push(logger);};Appender.prototype.setRemovedFromLogger=function(logger){array_remove(this.loggers,logger);};Appender.prototype.group=emptyFunction;Appender.prototype.groupEnd=emptyFunction;Appender.prototype.toString=function(){handleError("Appender.toString: all appenders must override this method");};log4javascript.Appender=Appender;function SimpleLayout(){this.customFields=[];}
+SimpleLayout.prototype=new Layout();SimpleLayout.prototype.format=function(loggingEvent){return loggingEvent.level.name+" - "+loggingEvent.getCombinedMessages();};SimpleLayout.prototype.ignoresThrowable=function(){return true;};SimpleLayout.prototype.toString=function(){return"SimpleLayout";};log4javascript.SimpleLayout=SimpleLayout;function NullLayout(){this.customFields=[];}
+NullLayout.prototype=new Layout();NullLayout.prototype.format=function(loggingEvent){return loggingEvent.messages;};NullLayout.prototype.ignoresThrowable=function(){return true;};NullLayout.prototype.toString=function(){return"NullLayout";};log4javascript.NullLayout=NullLayout;function XmlLayout(combineMessages){this.combineMessages=extractBooleanFromParam(combineMessages,true);this.customFields=[];}
+XmlLayout.prototype=new Layout();XmlLayout.prototype.isCombinedMessages=function(){return this.combineMessages;};XmlLayout.prototype.getContentType=function(){return"text/xml";};XmlLayout.prototype.escapeCdata=function(str){return str.replace(/\]\]>/,"]]>]]&gt;<![CDATA[");};XmlLayout.prototype.format=function(loggingEvent){var layout=this;var i,len;function formatMessage(message){message=(typeof message==="string")?message:toStr(message);return"<log4javascript:message><![CDATA["+
+layout.escapeCdata(message)+"]]></log4javascript:message>";}
+var str="<log4javascript:event logger=\""+loggingEvent.logger.name+"\" timestamp=\""+this.getTimeStampValue(loggingEvent)+"\"";if(!this.isTimeStampsInMilliseconds()){str+=" milliseconds=\""+loggingEvent.milliseconds+"\"";}
+str+=" level=\""+loggingEvent.level.name+"\">"+newLine;if(this.combineMessages){str+=formatMessage(loggingEvent.getCombinedMessages());}else{str+="<log4javascript:messages>"+newLine;for(i=0,len=loggingEvent.messages.length;i<len;i++){str+=formatMessage(loggingEvent.messages[i])+newLine;}
+str+="</log4javascript:messages>"+newLine;}
+if(this.hasCustomFields()){for(i=0,len=this.customFields.length;i<len;i++){str+="<log4javascript:customfield name=\""+
+this.customFields[i].name+"\"><![CDATA["+
+this.customFields[i].value.toString()+"]]></log4javascript:customfield>"+newLine;}}
+if(loggingEvent.exception){str+="<log4javascript:exception><![CDATA["+
+getExceptionStringRep(loggingEvent.exception)+"]]></log4javascript:exception>"+newLine;}
+str+="</log4javascript:event>"+newLine+newLine;return str;};XmlLayout.prototype.ignoresThrowable=function(){return false;};XmlLayout.prototype.toString=function(){return"XmlLayout";};log4javascript.XmlLayout=XmlLayout;function escapeNewLines(str){return str.replace(/\r\n|\r|\n/g,"\\r\\n");}
+function JsonLayout(readable,combineMessages){this.readable=extractBooleanFromParam(readable,false);this.combineMessages=extractBooleanFromParam(combineMessages,true);this.batchHeader=this.readable?"["+newLine:"[";this.batchFooter=this.readable?"]"+newLine:"]";this.batchSeparator=this.readable?","+newLine:",";this.setKeys();this.colon=this.readable?": ":":";this.tab=this.readable?"\t":"";this.lineBreak=this.readable?newLine:"";this.customFields=[];}
+JsonLayout.prototype=new Layout();JsonLayout.prototype.isReadable=function(){return this.readable;};JsonLayout.prototype.isCombinedMessages=function(){return this.combineMessages;};JsonLayout.prototype.format=function(loggingEvent){var layout=this;var dataValues=this.getDataValues(loggingEvent,this.combineMessages);var str="{"+this.lineBreak;var i,len;function formatValue(val,prefix,expand){var formattedValue;var valType=typeof val;if(val instanceof Date){formattedValue=String(val.getTime());}else if(expand&&(val instanceof Array)){formattedValue="["+layout.lineBreak;for(var i=0,len=val.length;i<len;i++){var childPrefix=prefix+layout.tab;formattedValue+=childPrefix+formatValue(val[i],childPrefix,false);if(i<val.length-1){formattedValue+=",";}
+formattedValue+=layout.lineBreak;}
+formattedValue+=prefix+"]";}else if(valType!=="number"&&valType!=="boolean"){formattedValue="\""+escapeNewLines(toStr(val).replace(/\"/g,"\\\""))+"\"";}else{formattedValue=val;}
+return formattedValue;}
+for(i=0,len=dataValues.length-1;i<=len;i++){str+=this.tab+"\""+dataValues[i][0]+"\""+this.colon+formatValue(dataValues[i][1],this.tab,true);if(i<len){str+=",";}
+str+=this.lineBreak;}
+str+="}"+this.lineBreak;return str;};JsonLayout.prototype.ignoresThrowable=function(){return false;};JsonLayout.prototype.toString=function(){return"JsonLayout";};JsonLayout.prototype.getContentType=function(){return"application/json";};log4javascript.JsonLayout=JsonLayout;function HttpPostDataLayout(){this.setKeys();this.customFields=[];this.returnsPostData=true;}
+HttpPostDataLayout.prototype=new Layout();HttpPostDataLayout.prototype.allowBatching=function(){return false;};HttpPostDataLayout.prototype.format=function(loggingEvent){var dataValues=this.getDataValues(loggingEvent);var queryBits=[];for(var i=0,len=dataValues.length;i<len;i++){var val=(dataValues[i][1]instanceof Date)?String(dataValues[i][1].getTime()):dataValues[i][1];queryBits.push(urlEncode(dataValues[i][0])+"="+urlEncode(val));}
+return queryBits.join("&");};HttpPostDataLayout.prototype.ignoresThrowable=function(loggingEvent){return false;};HttpPostDataLayout.prototype.toString=function(){return"HttpPostDataLayout";};log4javascript.HttpPostDataLayout=HttpPostDataLayout;function formatObjectExpansion(obj,depth,indentation){var objectsExpanded=[];function doFormat(obj,depth,indentation){var i,j,len,childDepth,childIndentation,childLines,expansion,childExpansion;if(!indentation){indentation="";}
+function formatString(text){var lines=splitIntoLines(text);for(var j=1,jLen=lines.length;j<jLen;j++){lines[j]=indentation+lines[j];}
+return lines.join(newLine);}
+if(obj===null){return"null";}else if(typeof obj=="undefined"){return"undefined";}else if(typeof obj=="string"){return formatString(obj);}else if(typeof obj=="object"&&array_contains(objectsExpanded,obj)){try{expansion=toStr(obj);}catch(ex){expansion="Error formatting property. Details: "+getExceptionStringRep(ex);}
+return expansion+" [already expanded]";}else if((obj instanceof Array)&&depth>0){objectsExpanded.push(obj);expansion="["+newLine;childDepth=depth-1;childIndentation=indentation+"  ";childLines=[];for(i=0,len=obj.length;i<len;i++){try{childExpansion=doFormat(obj[i],childDepth,childIndentation);childLines.push(childIndentation+childExpansion);}catch(ex){childLines.push(childIndentation+"Error formatting array member. Details: "+
+getExceptionStringRep(ex)+"");}}
+expansion+=childLines.join(","+newLine)+newLine+indentation+"]";return expansion;}else if(Object.prototype.toString.call(obj)=="[object Date]"){return obj.toString();}else if(typeof obj=="object"&&depth>0){objectsExpanded.push(obj);expansion="{"+newLine;childDepth=depth-1;childIndentation=indentation+"  ";childLines=[];for(i in obj){try{childExpansion=doFormat(obj[i],childDepth,childIndentation);childLines.push(childIndentation+i+": "+childExpansion);}catch(ex){childLines.push(childIndentation+i+": Error formatting property. Details: "+
+getExceptionStringRep(ex));}}
+expansion+=childLines.join(","+newLine)+newLine+indentation+"}";return expansion;}else{return formatString(toStr(obj));}}
+return doFormat(obj,depth,indentation);}
+var SimpleDateFormat;(function(){var regex=/('[^']*')|(G+|y+|M+|w+|W+|D+|d+|F+|E+|a+|H+|k+|K+|h+|m+|s+|S+|Z+)|([a-zA-Z]+)|([^a-zA-Z']+)/;var monthNames=["January","February","March","April","May","June","July","August","September","October","November","December"];var dayNames=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];var TEXT2=0,TEXT3=1,NUMBER=2,YEAR=3,MONTH=4,TIMEZONE=5;var types={G:TEXT2,y:YEAR,M:MONTH,w:NUMBER,W:NUMBER,D:NUMBER,d:NUMBER,F:NUMBER,E:TEXT3,a:TEXT2,H:NUMBER,k:NUMBER,K:NUMBER,h:NUMBER,m:NUMBER,s:NUMBER,S:NUMBER,Z:TIMEZONE};var ONE_DAY=24*60*60*1000;var ONE_WEEK=7*ONE_DAY;var DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK=1;var newDateAtMidnight=function(year,month,day){var d=new Date(year,month,day,0,0,0);d.setMilliseconds(0);return d;};Date.prototype.getDifference=function(date){return this.getTime()-date.getTime();};Date.prototype.isBefore=function(d){return this.getTime()<d.getTime();};Date.prototype.getUTCTime=function(){return Date.UTC(this.getFullYear(),this.getMonth(),this.getDate(),this.getHours(),this.getMinutes(),this.getSeconds(),this.getMilliseconds());};Date.prototype.getTimeSince=function(d){return this.getUTCTime()-d.getUTCTime();};Date.prototype.getPreviousSunday=function(){var midday=new Date(this.getFullYear(),this.getMonth(),this.getDate(),12,0,0);var previousSunday=new Date(midday.getTime()-this.getDay()*ONE_DAY);return newDateAtMidnight(previousSunday.getFullYear(),previousSunday.getMonth(),previousSunday.getDate());};Date.prototype.getWeekInYear=function(minimalDaysInFirstWeek){if(isUndefined(this.minimalDaysInFirstWeek)){minimalDaysInFirstWeek=DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;}
+var previousSunday=this.getPreviousSunday();var startOfYear=newDateAtMidnight(this.getFullYear(),0,1);var numberOfSundays=previousSunday.isBefore(startOfYear)?0:1+Math.floor(previousSunday.getTimeSince(startOfYear)/ONE_WEEK);var numberOfDaysInFirstWeek=7-startOfYear.getDay();var weekInYear=numberOfSundays;if(numberOfDaysInFirstWeek<minimalDaysInFirstWeek){weekInYear--;}
+return weekInYear;};Date.prototype.getWeekInMonth=function(minimalDaysInFirstWeek){if(isUndefined(this.minimalDaysInFirstWeek)){minimalDaysInFirstWeek=DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;}
+var previousSunday=this.getPreviousSunday();var startOfMonth=newDateAtMidnight(this.getFullYear(),this.getMonth(),1);var numberOfSundays=previousSunday.isBefore(startOfMonth)?0:1+Math.floor(previousSunday.getTimeSince(startOfMonth)/ONE_WEEK);var numberOfDaysInFirstWeek=7-startOfMonth.getDay();var weekInMonth=numberOfSundays;if(numberOfDaysInFirstWeek>=minimalDaysInFirstWeek){weekInMonth++;}
+return weekInMonth;};Date.prototype.getDayInYear=function(){var startOfYear=newDateAtMidnight(this.getFullYear(),0,1);return 1+Math.floor(this.getTimeSince(startOfYear)/ONE_DAY);};SimpleDateFormat=function(formatString){this.formatString=formatString;};SimpleDateFormat.prototype.setMinimalDaysInFirstWeek=function(days){this.minimalDaysInFirstWeek=days;};SimpleDateFormat.prototype.getMinimalDaysInFirstWeek=function(){return isUndefined(this.minimalDaysInFirstWeek)?DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK:this.minimalDaysInFirstWeek;};var padWithZeroes=function(str,len){while(str.length<len){str="0"+str;}
+return str;};var formatText=function(data,numberOfLetters,minLength){return(numberOfLetters>=4)?data:data.substr(0,Math.max(minLength,numberOfLetters));};var formatNumber=function(data,numberOfLetters){var dataString=""+data;return padWithZeroes(dataString,numberOfLetters);};SimpleDateFormat.prototype.format=function(date){var formattedString="";var result;var searchString=this.formatString;while((result=regex.exec(searchString))){var quotedString=result[1];var patternLetters=result[2];var otherLetters=result[3];var otherCharacters=result[4];if(quotedString){if(quotedString=="''"){formattedString+="'";}else{formattedString+=quotedString.substring(1,quotedString.length-1);}}else if(otherLetters){}else if(otherCharacters){formattedString+=otherCharacters;}else if(patternLetters){var patternLetter=patternLetters.charAt(0);var numberOfLetters=patternLetters.length;var rawData="";switch(patternLetter){case"G":rawData="AD";break;case"y":rawData=date.getFullYear();break;case"M":rawData=date.getMonth();break;case"w":rawData=date.getWeekInYear(this.getMinimalDaysInFirstWeek());break;case"W":rawData=date.getWeekInMonth(this.getMinimalDaysInFirstWeek());break;case"D":rawData=date.getDayInYear();break;case"d":rawData=date.getDate();break;case"F":rawData=1+Math.floor((date.getDate()-1)/7);break;case"E":rawData=dayNames[date.getDay()];break;case"a":rawData=(date.getHours()>=12)?"PM":"AM";break;case"H":rawData=date.getHours();break;case"k":rawData=date.getHours()||24;break;case"K":rawData=date.getHours()%12;break;case"h":rawData=(date.getHours()%12)||12;break;case"m":rawData=date.getMinutes();break;case"s":rawData=date.getSeconds();break;case"S":rawData=date.getMilliseconds();break;case"Z":rawData=date.getTimezoneOffset();break;}
+switch(types[patternLetter]){case TEXT2:formattedString+=formatText(rawData,numberOfLetters,2);break;case TEXT3:formattedString+=formatText(rawData,numberOfLetters,3);break;case NUMBER:formattedString+=formatNumber(rawData,numberOfLetters);break;case YEAR:if(numberOfLetters<=3){var dataString=""+rawData;formattedString+=dataString.substr(2,2);}else{formattedString+=formatNumber(rawData,numberOfLetters);}
+break;case MONTH:if(numberOfLetters>=3){formattedString+=formatText(monthNames[rawData],numberOfLetters,numberOfLetters);}else{formattedString+=formatNumber(rawData+1,numberOfLetters);}
+break;case TIMEZONE:var isPositive=(rawData>0);var prefix=isPositive?"-":"+";var absData=Math.abs(rawData);var hours=""+Math.floor(absData/60);hours=padWithZeroes(hours,2);var minutes=""+(absData%60);minutes=padWithZeroes(minutes,2);formattedString+=prefix+hours+minutes;break;}}
+searchString=searchString.substr(result.index+result[0].length);}
+return formattedString;};})();log4javascript.SimpleDateFormat=SimpleDateFormat;function PatternLayout(pattern){if(pattern){this.pattern=pattern;}else{this.pattern=PatternLayout.DEFAULT_CONVERSION_PATTERN;}
+this.customFields=[];}
+PatternLayout.TTCC_CONVERSION_PATTERN="%r %p %c - %m%n";PatternLayout.DEFAULT_CONVERSION_PATTERN="%m%n";PatternLayout.ISO8601_DATEFORMAT="yyyy-MM-dd HH:mm:ss,SSS";PatternLayout.DATETIME_DATEFORMAT="dd MMM yyyy HH:mm:ss,SSS";PatternLayout.ABSOLUTETIME_DATEFORMAT="HH:mm:ss,SSS";PatternLayout.prototype=new Layout();PatternLayout.prototype.format=function(loggingEvent){var regex=/%(-?[0-9]+)?(\.?[0-9]+)?([acdfmMnpr%])(\{([^\}]+)\})?|([^%]+)/;var formattedString="";var result;var searchString=this.pattern;while((result=regex.exec(searchString))){var matchedString=result[0];var padding=result[1];var truncation=result[2];var conversionCharacter=result[3];var specifier=result[5];var text=result[6];if(text){formattedString+=""+text;}else{var replacement="";switch(conversionCharacter){case"a":case"m":var depth=0;if(specifier){depth=parseInt(specifier,10);if(isNaN(depth)){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character '"+conversionCharacter+"' - should be a number");depth=0;}}
+var messages=(conversionCharacter==="a")?loggingEvent.messages[0]:loggingEvent.messages;for(var i=0,len=messages.length;i<len;i++){if(i>0&&(replacement.charAt(replacement.length-1)!==" ")){replacement+=" ";}
+if(depth===0){replacement+=messages[i];}else{replacement+=formatObjectExpansion(messages[i],depth);}}
+break;case"c":var loggerName=loggingEvent.logger.name;if(specifier){var precision=parseInt(specifier,10);var loggerNameBits=loggingEvent.logger.name.split(".");if(precision>=loggerNameBits.length){replacement=loggerName;}else{replacement=loggerNameBits.slice(loggerNameBits.length-precision).join(".");}}else{replacement=loggerName;}
+break;case"d":var dateFormat=PatternLayout.ISO8601_DATEFORMAT;if(specifier){dateFormat=specifier;if(dateFormat=="ISO8601"){dateFormat=PatternLayout.ISO8601_DATEFORMAT;}else if(dateFormat=="ABSOLUTE"){dateFormat=PatternLayout.ABSOLUTETIME_DATEFORMAT;}else if(dateFormat=="DATE"){dateFormat=PatternLayout.DATETIME_DATEFORMAT;}}
+replacement=(new SimpleDateFormat(dateFormat)).format(loggingEvent.timeStamp);break;case"f":if(this.hasCustomFields()){var fieldIndex=0;if(specifier){fieldIndex=parseInt(specifier,10);if(isNaN(fieldIndex)){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - should be a number");}else if(fieldIndex===0){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - must be greater than zero");}else if(fieldIndex>this.customFields.length){handleError("PatternLayout.format: invalid specifier '"+
+specifier+"' for conversion character 'f' - there aren't that many custom fields");}else{fieldIndex=fieldIndex-1;}}
+var val=this.customFields[fieldIndex].value;if(typeof val=="function"){val=val(this,loggingEvent);}
+replacement=val;}
+break;case"n":replacement=newLine;break;case"p":replacement=loggingEvent.level.name;break;case"r":replacement=""+loggingEvent.timeStamp.getDifference(applicationStartDate);break;case"%":replacement="%";break;default:replacement=matchedString;break;}
+var l;if(truncation){l=parseInt(truncation.substr(1),10);var strLen=replacement.length;if(l<strLen){replacement=replacement.substring(strLen-l,strLen);}}
+if(padding){if(padding.charAt(0)=="-"){l=parseInt(padding.substr(1),10);while(replacement.length<l){replacement+=" ";}}else{l=parseInt(padding,10);while(replacement.length<l){replacement=" "+replacement;}}}
+formattedString+=replacement;}
+searchString=searchString.substr(result.index+result[0].length);}
+return formattedString;};PatternLayout.prototype.ignoresThrowable=function(){return true;};PatternLayout.prototype.toString=function(){return"PatternLayout";};log4javascript.PatternLayout=PatternLayout;var xmlHttpFactories=[function(){return new XMLHttpRequest();},function(){return new ActiveXObject("Msxml2.XMLHTTP");},function(){return new ActiveXObject("Microsoft.XMLHTTP");}];var getXmlHttp=function(errorHandler){var xmlHttp=null,factory;for(var i=0,len=xmlHttpFactories.length;i<len;i++){factory=xmlHttpFactories[i];try{xmlHttp=factory();getXmlHttp=factory;return xmlHttp;}catch(e){}}
+if(errorHandler){errorHandler();}else{handleError("getXmlHttp: unable to obtain XMLHttpRequest object");}};function isHttpRequestSuccessful(xmlHttp){return isUndefined(xmlHttp.status)||xmlHttp.status===0||(xmlHttp.status>=200&&xmlHttp.status<300)||xmlHttp.status==1223;}
+function AjaxAppender(url){var appender=this;var isSupported=true;if(!url){handleError("AjaxAppender: URL must be specified in constructor");isSupported=false;}
+var timed=this.defaults.timed;var waitForResponse=this.defaults.waitForResponse;var batchSize=this.defaults.batchSize;var timerInterval=this.defaults.timerInterval;var requestSuccessCallback=this.defaults.requestSuccessCallback;var failCallback=this.defaults.failCallback;var postVarName=this.defaults.postVarName;var sendAllOnUnload=this.defaults.sendAllOnUnload;var contentType=this.defaults.contentType;var sessionId=null;var queuedLoggingEvents=[];var queuedRequests=[];var headers=[];var sending=false;var initialized=false;function checkCanConfigure(configOptionName){if(initialized){handleError("AjaxAppender: configuration option '"+
+configOptionName+"' may not be set after the appender has been initialized");return false;}
+return true;}
+this.getSessionId=function(){return sessionId;};this.setSessionId=function(sessionIdParam){sessionId=extractStringFromParam(sessionIdParam,null);this.layout.setCustomField("sessionid",sessionId);};this.setLayout=function(layoutParam){if(checkCanConfigure("layout")){this.layout=layoutParam;if(sessionId!==null){this.setSessionId(sessionId);}}};this.isTimed=function(){return timed;};this.setTimed=function(timedParam){if(checkCanConfigure("timed")){timed=bool(timedParam);}};this.getTimerInterval=function(){return timerInterval;};this.setTimerInterval=function(timerIntervalParam){if(checkCanConfigure("timerInterval")){timerInterval=extractIntFromParam(timerIntervalParam,timerInterval);}};this.isWaitForResponse=function(){return waitForResponse;};this.setWaitForResponse=function(waitForResponseParam){if(checkCanConfigure("waitForResponse")){waitForResponse=bool(waitForResponseParam);}};this.getBatchSize=function(){return batchSize;};this.setBatchSize=function(batchSizeParam){if(checkCanConfigure("batchSize")){batchSize=extractIntFromParam(batchSizeParam,batchSize);}};this.isSendAllOnUnload=function(){return sendAllOnUnload;};this.setSendAllOnUnload=function(sendAllOnUnloadParam){if(checkCanConfigure("sendAllOnUnload")){sendAllOnUnload=extractBooleanFromParam(sendAllOnUnloadParam,sendAllOnUnload);}};this.setRequestSuccessCallback=function(requestSuccessCallbackParam){requestSuccessCallback=extractFunctionFromParam(requestSuccessCallbackParam,requestSuccessCallback);};this.setFailCallback=function(failCallbackParam){failCallback=extractFunctionFromParam(failCallbackParam,failCallback);};this.getPostVarName=function(){return postVarName;};this.setPostVarName=function(postVarNameParam){if(checkCanConfigure("postVarName")){postVarName=extractStringFromParam(postVarNameParam,postVarName);}};this.getHeaders=function(){return headers;};this.addHeader=function(name,value){if(name.toLowerCase()=="content-type"){contentType=value;}else{headers.push({name:name,value:value});}};function sendAll(){if(isSupported&&enabled){sending=true;var currentRequestBatch;if(waitForResponse){if(queuedRequests.length>0){currentRequestBatch=queuedRequests.shift();sendRequest(preparePostData(currentRequestBatch),sendAll);}else{sending=false;if(timed){scheduleSending();}}}else{while((currentRequestBatch=queuedRequests.shift())){sendRequest(preparePostData(currentRequestBatch));}
+sending=false;if(timed){scheduleSending();}}}}
+this.sendAll=sendAll;function sendAllRemaining(){var sendingAnything=false;if(isSupported&&enabled){var actualBatchSize=appender.getLayout().allowBatching()?batchSize:1;var currentLoggingEvent;var batchedLoggingEvents=[];while((currentLoggingEvent=queuedLoggingEvents.shift())){batchedLoggingEvents.push(currentLoggingEvent);if(queuedLoggingEvents.length>=actualBatchSize){queuedRequests.push(batchedLoggingEvents);batchedLoggingEvents=[];}}
+if(batchedLoggingEvents.length>0){queuedRequests.push(batchedLoggingEvents);}
+sendingAnything=(queuedRequests.length>0);waitForResponse=false;timed=false;sendAll();}
+return sendingAnything;}
+this.sendAllRemaining=sendAllRemaining;function preparePostData(batchedLoggingEvents){var formattedMessages=[];var currentLoggingEvent;var postData="";while((currentLoggingEvent=batchedLoggingEvents.shift())){var currentFormattedMessage=appender.getLayout().format(currentLoggingEvent);if(appender.getLayout().ignoresThrowable()){currentFormattedMessage+=currentLoggingEvent.getThrowableStrRep();}
+formattedMessages.push(currentFormattedMessage);}
+if(batchedLoggingEvents.length==1){postData=formattedMessages.join("");}else{postData=appender.getLayout().batchHeader+
+formattedMessages.join(appender.getLayout().batchSeparator)+
+appender.getLayout().batchFooter;}
+if(contentType==appender.defaults.contentType){postData=appender.getLayout().returnsPostData?postData:urlEncode(postVarName)+"="+urlEncode(postData);if(postData.length>0){postData+="&";}
+postData+="layout="+urlEncode(appender.getLayout().toString());}
+return postData;}
+function scheduleSending(){window.setTimeout(sendAll,timerInterval);}
+function xmlHttpErrorHandler(){var msg="AjaxAppender: could not create XMLHttpRequest object. AjaxAppender disabled";handleError(msg);isSupported=false;if(failCallback){failCallback(msg);}}
+function sendRequest(postData,successCallback){try{var xmlHttp=getXmlHttp(xmlHttpErrorHandler);if(isSupported){if(xmlHttp.overrideMimeType){xmlHttp.overrideMimeType(appender.getLayout().getContentType());}
+xmlHttp.onreadystatechange=function(){if(xmlHttp.readyState==4){if(isHttpRequestSuccessful(xmlHttp)){if(requestSuccessCallback){requestSuccessCallback(xmlHttp);}
+if(successCallback){successCallback(xmlHttp);}}else{var msg="AjaxAppender.append: XMLHttpRequest request to URL "+
+url+" returned status code "+xmlHttp.status;handleError(msg);if(failCallback){failCallback(msg);}}
+xmlHttp.onreadystatechange=emptyFunction;xmlHttp=null;}};xmlHttp.open("POST",url,true);try{for(var i=0,header;header=headers[i++];){xmlHttp.setRequestHeader(header.name,header.value);}
+xmlHttp.setRequestHeader("Content-Type",contentType);}catch(headerEx){var msg="AjaxAppender.append: your browser's XMLHttpRequest implementation"+" does not support setRequestHeader, therefore cannot post data. AjaxAppender disabled";handleError(msg);isSupported=false;if(failCallback){failCallback(msg);}
+return;}
+xmlHttp.send(postData);}}catch(ex){var errMsg="AjaxAppender.append: error sending log message to "+url;handleError(errMsg,ex);isSupported=false;if(failCallback){failCallback(errMsg+". Details: "+getExceptionStringRep(ex));}}}
+this.append=function(loggingEvent){if(isSupported){if(!initialized){init();}
+queuedLoggingEvents.push(loggingEvent);var actualBatchSize=this.getLayout().allowBatching()?batchSize:1;if(queuedLoggingEvents.length>=actualBatchSize){var currentLoggingEvent;var batchedLoggingEvents=[];while((currentLoggingEvent=queuedLoggingEvents.shift())){batchedLoggingEvents.push(currentLoggingEvent);}
+queuedRequests.push(batchedLoggingEvents);if(!timed&&(!waitForResponse||(waitForResponse&&!sending))){sendAll();}}}};function init(){initialized=true;if(sendAllOnUnload){var oldBeforeUnload=window.onbeforeunload;window.onbeforeunload=function(){if(oldBeforeUnload){oldBeforeUnload();}
+if(sendAllRemaining()){return"Sending log messages";}};}
+if(timed){scheduleSending();}}}
+AjaxAppender.prototype=new Appender();AjaxAppender.prototype.defaults={waitForResponse:false,timed:false,timerInterval:1000,batchSize:1,sendAllOnUnload:false,requestSuccessCallback:null,failCallback:null,postVarName:"data",contentType:"application/x-www-form-urlencoded"};AjaxAppender.prototype.layout=new HttpPostDataLayout();AjaxAppender.prototype.toString=function(){return"AjaxAppender";};log4javascript.AjaxAppender=AjaxAppender;log4javascript.setDocumentReady=function(){pageLoaded=true;log4javascript.dispatchEvent("load",{});};if(window.addEventListener){window.addEventListener("load",log4javascript.setDocumentReady,false);}else if(window.attachEvent){window.attachEvent("onload",log4javascript.setDocumentReady);}else{var oldOnload=window.onload;if(typeof window.onload!="function"){window.onload=log4javascript.setDocumentReady;}else{window.onload=function(evt){if(oldOnload){oldOnload(evt);}
+log4javascript.setDocumentReady();};}}
+window.log4javascript=log4javascript;return log4javascript;})();
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production_uncompressed.js
new file mode 100644
index 0000000..1a29621
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_production_uncompressed.js
@@ -0,0 +1,2290 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * log4javascript
+ *
+ * log4javascript is a logging framework for JavaScript based on log4j
+ * for Java. This file contains all core log4javascript code and is the only
+ * file required to use log4javascript, unless you require support for
+ * document.domain, in which case you will also need console.html, which must be
+ * stored in the same directory as the main log4javascript.js file.
+ *
+ * Author: Tim Down <tim@log4javascript.org>
+ * Version: 1.4.6
+ * Edition: log4javascript_production
+ * Build date: 19 March 2013
+ * Website: http://log4javascript.org
+ */
+
+/* -------------------------------------------------------------------------- */
+// Array-related stuff
+
+// Next three methods are solely for IE5, which is missing them
+if (!Array.prototype.push) {
+	Array.prototype.push = function() {
+		for (var i = 0, len = arguments.length; i < len; i++){
+			this[this.length] = arguments[i];
+		}
+		return this.length;
+	};
+}
+
+if (!Array.prototype.shift) {
+	Array.prototype.shift = function() {
+		if (this.length > 0) {
+			var firstItem = this[0];
+			for (var i = 0, len = this.length - 1; i < len; i++) {
+				this[i] = this[i + 1];
+			}
+			this.length = this.length - 1;
+			return firstItem;
+		}
+	};
+}
+
+if (!Array.prototype.splice) {
+	Array.prototype.splice = function(startIndex, deleteCount) {
+		var itemsAfterDeleted = this.slice(startIndex + deleteCount);
+		var itemsDeleted = this.slice(startIndex, startIndex + deleteCount);
+		this.length = startIndex;
+		// Copy the arguments into a proper Array object
+		var argumentsArray = [];
+		for (var i = 0, len = arguments.length; i < len; i++) {
+			argumentsArray[i] = arguments[i];
+		}
+		var itemsToAppend = (argumentsArray.length > 2) ?
+			itemsAfterDeleted = argumentsArray.slice(2).concat(itemsAfterDeleted) : itemsAfterDeleted;
+		for (i = 0, len = itemsToAppend.length; i < len; i++) {
+			this.push(itemsToAppend[i]);
+		}
+		return itemsDeleted;
+	};
+}
+
+/* -------------------------------------------------------------------------- */
+
+var log4javascript = (function() {
+
+	function isUndefined(obj) {
+		return typeof obj == "undefined";
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// Custom event support
+
+	function EventSupport() {}
+
+	EventSupport.prototype = {
+		eventTypes: [],
+		eventListeners: {},
+		setEventTypes: function(eventTypesParam) {
+			if (eventTypesParam instanceof Array) {
+				this.eventTypes = eventTypesParam;
+				this.eventListeners = {};
+				for (var i = 0, len = this.eventTypes.length; i < len; i++) {
+					this.eventListeners[this.eventTypes[i]] = [];
+				}
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: setEventTypes: eventTypes parameter must be an Array");
+			}
+		},
+
+		addEventListener: function(eventType, listener) {
+			if (typeof listener == "function") {
+				if (!array_contains(this.eventTypes, eventType)) {
+					handleError("log4javascript.EventSupport [" + this + "]: addEventListener: no event called '" + eventType + "'");
+				}
+				this.eventListeners[eventType].push(listener);
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: addEventListener: listener must be a function");
+			}
+		},
+
+		removeEventListener: function(eventType, listener) {
+			if (typeof listener == "function") {
+				if (!array_contains(this.eventTypes, eventType)) {
+					handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: no event called '" + eventType + "'");
+				}
+				array_remove(this.eventListeners[eventType], listener);
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: listener must be a function");
+			}
+		},
+
+		dispatchEvent: function(eventType, eventArgs) {
+			if (array_contains(this.eventTypes, eventType)) {
+				var listeners = this.eventListeners[eventType];
+				for (var i = 0, len = listeners.length; i < len; i++) {
+					listeners[i](this, eventType, eventArgs);
+				}
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: dispatchEvent: no event called '" + eventType + "'");
+			}
+		}
+	};
+
+	/* -------------------------------------------------------------------------- */
+
+	var applicationStartDate = new Date();
+	var uniqueId = "log4javascript_" + applicationStartDate.getTime() + "_" +
+		Math.floor(Math.random() * 100000000);
+	var emptyFunction = function() {};
+	var newLine = "\r\n";
+	var pageLoaded = false;
+
+	// Create main log4javascript object; this will be assigned public properties
+	function Log4JavaScript() {}
+	Log4JavaScript.prototype = new EventSupport();
+
+	log4javascript = new Log4JavaScript();
+	log4javascript.version = "1.4.6";
+	log4javascript.edition = "log4javascript_production";
+
+	/* -------------------------------------------------------------------------- */
+	// Utility functions
+
+	function toStr(obj) {
+		if (obj && obj.toString) {
+			return obj.toString();
+		} else {
+			return String(obj);
+		}
+	}
+
+	function getExceptionMessage(ex) {
+		if (ex.message) {
+			return ex.message;
+		} else if (ex.description) {
+			return ex.description;
+		} else {
+			return toStr(ex);
+		}
+	}
+
+	// Gets the portion of the URL after the last slash
+	function getUrlFileName(url) {
+		var lastSlashIndex = Math.max(url.lastIndexOf("/"), url.lastIndexOf("\\"));
+		return url.substr(lastSlashIndex + 1);
+	}
+
+	// Returns a nicely formatted representation of an error
+	function getExceptionStringRep(ex) {
+		if (ex) {
+			var exStr = "Exception: " + getExceptionMessage(ex);
+			try {
+				if (ex.lineNumber) {
+					exStr += " on line number " + ex.lineNumber;
+				}
+				if (ex.fileName) {
+					exStr += " in file " + getUrlFileName(ex.fileName);
+				}
+			} catch (localEx) {
+				logLog.warn("Unable to obtain file and line information for error");
+			}
+			if (showStackTraces && ex.stack) {
+				exStr += newLine + "Stack trace:" + newLine + ex.stack;
+			}
+			return exStr;
+		}
+		return null;
+	}
+
+	function bool(obj) {
+		return Boolean(obj);
+	}
+
+	function trim(str) {
+		return str.replace(/^\s+/, "").replace(/\s+$/, "");
+	}
+
+	function splitIntoLines(text) {
+		// Ensure all line breaks are \n only
+		var text2 = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		return text2.split("\n");
+	}
+
+	var urlEncode = (typeof window.encodeURIComponent != "undefined") ?
+		function(str) {
+			return encodeURIComponent(str);
+		}: 
+		function(str) {
+			return escape(str).replace(/\+/g, "%2B").replace(/"/g, "%22").replace(/'/g, "%27").replace(/\//g, "%2F").replace(/=/g, "%3D");
+		};
+
+	var urlDecode = (typeof window.decodeURIComponent != "undefined") ?
+		function(str) {
+			return decodeURIComponent(str);
+		}: 
+		function(str) {
+			return unescape(str).replace(/%2B/g, "+").replace(/%22/g, "\"").replace(/%27/g, "'").replace(/%2F/g, "/").replace(/%3D/g, "=");
+		};
+
+	function array_remove(arr, val) {
+		var index = -1;
+		for (var i = 0, len = arr.length; i < len; i++) {
+			if (arr[i] === val) {
+				index = i;
+				break;
+			}
+		}
+		if (index >= 0) {
+			arr.splice(index, 1);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	function array_contains(arr, val) {
+		for(var i = 0, len = arr.length; i < len; i++) {
+			if (arr[i] == val) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	function extractBooleanFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			return bool(param);
+		}
+	}
+
+	function extractStringFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			return String(param);
+		}
+	}
+
+	function extractIntFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			try {
+				var value = parseInt(param, 10);
+				return isNaN(value) ? defaultValue : value;
+			} catch (ex) {
+				logLog.warn("Invalid int param " + param, ex);
+				return defaultValue;
+			}
+		}
+	}
+
+	function extractFunctionFromParam(param, defaultValue) {
+		if (typeof param == "function") {
+			return param;
+		} else {
+			return defaultValue;
+		}
+	}
+
+	function isError(err) {
+		return (err instanceof Error);
+	}
+
+	if (!Function.prototype.apply){
+		Function.prototype.apply = function(obj, args) {
+			var methodName = "__apply__";
+			if (typeof obj[methodName] != "undefined") {
+				methodName += String(Math.random()).substr(2);
+			}
+			obj[methodName] = this;
+
+			var argsStrings = [];
+			for (var i = 0, len = args.length; i < len; i++) {
+				argsStrings[i] = "args[" + i + "]";
+			}
+			var script = "obj." + methodName + "(" + argsStrings.join(",") + ")";
+			var returnValue = eval(script);
+			delete obj[methodName];
+			return returnValue;
+		};
+	}
+
+	if (!Function.prototype.call){
+		Function.prototype.call = function(obj) {
+			var args = [];
+			for (var i = 1, len = arguments.length; i < len; i++) {
+				args[i - 1] = arguments[i];
+			}
+			return this.apply(obj, args);
+		};
+	}
+
+	function getListenersPropertyName(eventName) {
+		return "__log4javascript_listeners__" + eventName;
+	}
+
+	function addEvent(node, eventName, listener, useCapture, win) {
+		win = win ? win : window;
+		if (node.addEventListener) {
+			node.addEventListener(eventName, listener, useCapture);
+		} else if (node.attachEvent) {
+			node.attachEvent("on" + eventName, listener);
+		} else {
+			var propertyName = getListenersPropertyName(eventName);
+			if (!node[propertyName]) {
+				node[propertyName] = [];
+				// Set event handler
+				node["on" + eventName] = function(evt) {
+					evt = getEvent(evt, win);
+					var listenersPropertyName = getListenersPropertyName(eventName);
+
+					// Clone the array of listeners to leave the original untouched
+					var listeners = this[listenersPropertyName].concat([]);
+					var currentListener;
+
+					// Call each listener in turn
+					while ((currentListener = listeners.shift())) {
+						currentListener.call(this, evt);
+					}
+				};
+			}
+			node[propertyName].push(listener);
+		}
+	}
+
+	function removeEvent(node, eventName, listener, useCapture) {
+		if (node.removeEventListener) {
+			node.removeEventListener(eventName, listener, useCapture);
+		} else if (node.detachEvent) {
+			node.detachEvent("on" + eventName, listener);
+		} else {
+			var propertyName = getListenersPropertyName(eventName);
+			if (node[propertyName]) {
+				array_remove(node[propertyName], listener);
+			}
+		}
+	}
+
+	function getEvent(evt, win) {
+		win = win ? win : window;
+		return evt ? evt : win.event;
+	}
+
+	function stopEventPropagation(evt) {
+		if (evt.stopPropagation) {
+			evt.stopPropagation();
+		} else if (typeof evt.cancelBubble != "undefined") {
+			evt.cancelBubble = true;
+		}
+		evt.returnValue = false;
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// Simple logging for log4javascript itself
+
+	var logLog = {
+		quietMode: false,
+
+		debugMessages: [],
+
+		setQuietMode: function(quietMode) {
+			this.quietMode = bool(quietMode);
+		},
+
+		numberOfErrors: 0,
+
+		alertAllErrors: false,
+
+		setAlertAllErrors: function(alertAllErrors) {
+			this.alertAllErrors = alertAllErrors;
+		},
+
+		debug: function(message) {
+			this.debugMessages.push(message);
+		},
+
+		displayDebug: function() {
+			alert(this.debugMessages.join(newLine));
+		},
+
+		warn: function(message, exception) {
+		},
+
+		error: function(message, exception) {
+			if (++this.numberOfErrors == 1 || this.alertAllErrors) {
+				if (!this.quietMode) {
+					var alertMessage = "log4javascript error: " + message;
+					if (exception) {
+						alertMessage += newLine + newLine + "Original error: " + getExceptionStringRep(exception);
+					}
+					alert(alertMessage);
+				}
+			}
+		}
+	};
+	log4javascript.logLog = logLog;
+
+	log4javascript.setEventTypes(["load", "error"]);
+
+	function handleError(message, exception) {
+		logLog.error(message, exception);
+		log4javascript.dispatchEvent("error", { "message": message, "exception": exception });
+	}
+
+	log4javascript.handleError = handleError;
+
+	/* ---------------------------------------------------------------------- */
+
+	var enabled = !((typeof log4javascript_disabled != "undefined") &&
+					log4javascript_disabled);
+
+	log4javascript.setEnabled = function(enable) {
+		enabled = bool(enable);
+	};
+
+	log4javascript.isEnabled = function() {
+		return enabled;
+	};
+
+	var useTimeStampsInMilliseconds = true;
+
+	log4javascript.setTimeStampsInMilliseconds = function(timeStampsInMilliseconds) {
+		useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
+	};
+
+	log4javascript.isTimeStampsInMilliseconds = function() {
+		return useTimeStampsInMilliseconds;
+	};
+	
+
+	// This evaluates the given expression in the current scope, thus allowing
+	// scripts to access private variables. Particularly useful for testing
+	log4javascript.evalInScope = function(expr) {
+		return eval(expr);
+	};
+
+	var showStackTraces = false;
+
+	log4javascript.setShowStackTraces = function(show) {
+		showStackTraces = bool(show);
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Levels
+
+	var Level = function(level, name) {
+		this.level = level;
+		this.name = name;
+	};
+
+	Level.prototype = {
+		toString: function() {
+			return this.name;
+		},
+		equals: function(level) {
+			return this.level == level.level;
+		},
+		isGreaterOrEqual: function(level) {
+			return this.level >= level.level;
+		}
+	};
+
+	Level.ALL = new Level(Number.MIN_VALUE, "ALL");
+	Level.TRACE = new Level(10000, "TRACE");
+	Level.DEBUG = new Level(20000, "DEBUG");
+	Level.INFO = new Level(30000, "INFO");
+	Level.WARN = new Level(40000, "WARN");
+	Level.ERROR = new Level(50000, "ERROR");
+	Level.FATAL = new Level(60000, "FATAL");
+	Level.OFF = new Level(Number.MAX_VALUE, "OFF");
+
+	log4javascript.Level = Level;
+
+	/* ---------------------------------------------------------------------- */
+	// Timers
+
+	function Timer(name, level) {
+		this.name = name;
+		this.level = isUndefined(level) ? Level.INFO : level;
+		this.start = new Date();
+	}
+
+	Timer.prototype.getElapsedTime = function() {
+		return new Date().getTime() - this.start.getTime();
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Loggers
+
+	var anonymousLoggerName = "[anonymous]";
+	var defaultLoggerName = "[default]";
+	var nullLoggerName = "[null]";
+	var rootLoggerName = "root";
+
+	function Logger(name) {
+		this.name = name;
+		this.parent = null;
+		this.children = [];
+
+		var appenders = [];
+		var loggerLevel = null;
+		var isRoot = (this.name === rootLoggerName);
+		var isNull = (this.name === nullLoggerName);
+
+		var appenderCache = null;
+		var appenderCacheInvalidated = false;
+		
+		this.addChild = function(childLogger) {
+			this.children.push(childLogger);
+			childLogger.parent = this;
+			childLogger.invalidateAppenderCache();
+		};
+
+		// Additivity
+		var additive = true;
+		this.getAdditivity = function() {
+			return additive;
+		};
+
+		this.setAdditivity = function(additivity) {
+			var valueChanged = (additive != additivity);
+			additive = additivity;
+			if (valueChanged) {
+				this.invalidateAppenderCache();
+			}
+		};
+
+		// Create methods that use the appenders variable in this scope
+		this.addAppender = function(appender) {
+			if (isNull) {
+				handleError("Logger.addAppender: you may not add an appender to the null logger");
+			} else {
+				if (appender instanceof log4javascript.Appender) {
+					if (!array_contains(appenders, appender)) {
+						appenders.push(appender);
+						appender.setAddedToLogger(this);
+						this.invalidateAppenderCache();
+					}
+				} else {
+					handleError("Logger.addAppender: appender supplied ('" +
+						toStr(appender) + "') is not a subclass of Appender");
+				}
+			}
+		};
+
+		this.removeAppender = function(appender) {
+			array_remove(appenders, appender);
+			appender.setRemovedFromLogger(this);
+			this.invalidateAppenderCache();
+		};
+
+		this.removeAllAppenders = function() {
+			var appenderCount = appenders.length;
+			if (appenderCount > 0) {
+				for (var i = 0; i < appenderCount; i++) {
+					appenders[i].setRemovedFromLogger(this);
+				}
+				appenders.length = 0;
+				this.invalidateAppenderCache();
+			}
+		};
+
+		this.getEffectiveAppenders = function() {
+			if (appenderCache === null || appenderCacheInvalidated) {
+				// Build appender cache
+				var parentEffectiveAppenders = (isRoot || !this.getAdditivity()) ?
+					[] : this.parent.getEffectiveAppenders();
+				appenderCache = parentEffectiveAppenders.concat(appenders);
+				appenderCacheInvalidated = false;
+			}
+			return appenderCache;
+		};
+		
+		this.invalidateAppenderCache = function() {
+			appenderCacheInvalidated = true;
+			for (var i = 0, len = this.children.length; i < len; i++) {
+				this.children[i].invalidateAppenderCache();
+			}
+		};
+
+		this.log = function(level, params) {
+			if (enabled && level.isGreaterOrEqual(this.getEffectiveLevel())) {
+				// Check whether last param is an exception
+				var exception;
+				var finalParamIndex = params.length - 1;
+				var lastParam = params[finalParamIndex];
+				if (params.length > 1 && isError(lastParam)) {
+					exception = lastParam;
+					finalParamIndex--;
+				}
+
+				// Construct genuine array for the params
+				var messages = [];
+				for (var i = 0; i <= finalParamIndex; i++) {
+					messages[i] = params[i];
+				}
+
+				var loggingEvent = new LoggingEvent(
+					this, new Date(), level, messages, exception);
+
+				this.callAppenders(loggingEvent);
+			}
+		};
+
+		this.callAppenders = function(loggingEvent) {
+			var effectiveAppenders = this.getEffectiveAppenders();
+			for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+				effectiveAppenders[i].doAppend(loggingEvent);
+			}
+		};
+
+		this.setLevel = function(level) {
+			// Having a level of null on the root logger would be very bad.
+			if (isRoot && level === null) {
+				handleError("Logger.setLevel: you cannot set the level of the root logger to null");
+			} else if (level instanceof Level) {
+				loggerLevel = level;
+			} else {
+				handleError("Logger.setLevel: level supplied to logger " +
+					this.name + " is not an instance of log4javascript.Level");
+			}
+		};
+
+		this.getLevel = function() {
+			return loggerLevel;
+		};
+
+		this.getEffectiveLevel = function() {
+			for (var logger = this; logger !== null; logger = logger.parent) {
+				var level = logger.getLevel();
+				if (level !== null) {
+					return level;
+				}
+			}
+		};
+
+		this.group = function(name, initiallyExpanded) {
+			if (enabled) {
+				var effectiveAppenders = this.getEffectiveAppenders();
+				for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+					effectiveAppenders[i].group(name, initiallyExpanded);
+				}
+			}
+		};
+
+		this.groupEnd = function() {
+			if (enabled) {
+				var effectiveAppenders = this.getEffectiveAppenders();
+				for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+					effectiveAppenders[i].groupEnd();
+				}
+			}
+		};
+
+		var timers = {};
+
+		this.time = function(name, level) {
+			if (enabled) {
+				if (isUndefined(name)) {
+					handleError("Logger.time: a name for the timer must be supplied");
+				} else if (level && !(level instanceof Level)) {
+					handleError("Logger.time: level supplied to timer " +
+						name + " is not an instance of log4javascript.Level");
+				} else {
+					timers[name] = new Timer(name, level);
+				}
+			}
+		};
+
+		this.timeEnd = function(name) {
+			if (enabled) {
+				if (isUndefined(name)) {
+					handleError("Logger.timeEnd: a name for the timer must be supplied");
+				} else if (timers[name]) {
+					var timer = timers[name];
+					var milliseconds = timer.getElapsedTime();
+					this.log(timer.level, ["Timer " + toStr(name) + " completed in " + milliseconds + "ms"]);
+					delete timers[name];
+				} else {
+					logLog.warn("Logger.timeEnd: no timer found with name " + name);
+				}
+			}
+		};
+
+		this.assert = function(expr) {
+			if (enabled && !expr) {
+				var args = [];
+				for (var i = 1, len = arguments.length; i < len; i++) {
+					args.push(arguments[i]);
+				}
+				args = (args.length > 0) ? args : ["Assertion Failure"];
+				args.push(newLine);
+				args.push(expr);
+				this.log(Level.ERROR, args);
+			}
+		};
+
+		this.toString = function() {
+			return "Logger[" + this.name + "]";
+		};
+	}
+
+	Logger.prototype = {
+		trace: function() {
+			this.log(Level.TRACE, arguments);
+		},
+
+		debug: function() {
+			this.log(Level.DEBUG, arguments);
+		},
+
+		info: function() {
+			this.log(Level.INFO, arguments);
+		},
+
+		warn: function() {
+			this.log(Level.WARN, arguments);
+		},
+
+		error: function() {
+			this.log(Level.ERROR, arguments);
+		},
+
+		fatal: function() {
+			this.log(Level.FATAL, arguments);
+		},
+
+		isEnabledFor: function(level) {
+			return level.isGreaterOrEqual(this.getEffectiveLevel());
+		},
+
+		isTraceEnabled: function() {
+			return this.isEnabledFor(Level.TRACE);
+		},
+
+		isDebugEnabled: function() {
+			return this.isEnabledFor(Level.DEBUG);
+		},
+
+		isInfoEnabled: function() {
+			return this.isEnabledFor(Level.INFO);
+		},
+
+		isWarnEnabled: function() {
+			return this.isEnabledFor(Level.WARN);
+		},
+
+		isErrorEnabled: function() {
+			return this.isEnabledFor(Level.ERROR);
+		},
+
+		isFatalEnabled: function() {
+			return this.isEnabledFor(Level.FATAL);
+		}
+	};
+
+	Logger.prototype.trace.isEntryPoint = true;
+	Logger.prototype.debug.isEntryPoint = true;
+	Logger.prototype.info.isEntryPoint = true;
+	Logger.prototype.warn.isEntryPoint = true;
+	Logger.prototype.error.isEntryPoint = true;
+	Logger.prototype.fatal.isEntryPoint = true;
+
+	/* ---------------------------------------------------------------------- */
+	// Logger access methods
+
+	// Hashtable of loggers keyed by logger name
+	var loggers = {};
+	var loggerNames = [];
+
+	var ROOT_LOGGER_DEFAULT_LEVEL = Level.DEBUG;
+	var rootLogger = new Logger(rootLoggerName);
+	rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
+
+	log4javascript.getRootLogger = function() {
+		return rootLogger;
+	};
+
+	log4javascript.getLogger = function(loggerName) {
+		// Use default logger if loggerName is not specified or invalid
+		if (!(typeof loggerName == "string")) {
+			loggerName = anonymousLoggerName;
+			logLog.warn("log4javascript.getLogger: non-string logger name "	+
+				toStr(loggerName) + " supplied, returning anonymous logger");
+		}
+
+		// Do not allow retrieval of the root logger by name
+		if (loggerName == rootLoggerName) {
+			handleError("log4javascript.getLogger: root logger may not be obtained by name");
+		}
+
+		// Create the logger for this name if it doesn't already exist
+		if (!loggers[loggerName]) {
+			var logger = new Logger(loggerName);
+			loggers[loggerName] = logger;
+			loggerNames.push(loggerName);
+
+			// Set up parent logger, if it doesn't exist
+			var lastDotIndex = loggerName.lastIndexOf(".");
+			var parentLogger;
+			if (lastDotIndex > -1) {
+				var parentLoggerName = loggerName.substring(0, lastDotIndex);
+				parentLogger = log4javascript.getLogger(parentLoggerName); // Recursively sets up grandparents etc.
+			} else {
+				parentLogger = rootLogger;
+			}
+			parentLogger.addChild(logger);
+		}
+		return loggers[loggerName];
+	};
+
+	var defaultLogger = null;
+	log4javascript.getDefaultLogger = function() {
+		if (!defaultLogger) {
+			defaultLogger = log4javascript.getLogger(defaultLoggerName);
+			var a = new log4javascript.PopUpAppender();
+			defaultLogger.addAppender(a);
+		}
+		return defaultLogger;
+	};
+
+	var nullLogger = null;
+	log4javascript.getNullLogger = function() {
+		if (!nullLogger) {
+			nullLogger = new Logger(nullLoggerName);
+			nullLogger.setLevel(Level.OFF);
+		}
+		return nullLogger;
+	};
+
+	// Destroys all loggers
+	log4javascript.resetConfiguration = function() {
+		rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
+		loggers = {};
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Logging events
+
+	var LoggingEvent = function(logger, timeStamp, level, messages,
+			exception) {
+		this.logger = logger;
+		this.timeStamp = timeStamp;
+		this.timeStampInMilliseconds = timeStamp.getTime();
+		this.timeStampInSeconds = Math.floor(this.timeStampInMilliseconds / 1000);
+		this.milliseconds = this.timeStamp.getMilliseconds();
+		this.level = level;
+		this.messages = messages;
+		this.exception = exception;
+	};
+
+	LoggingEvent.prototype = {
+		getThrowableStrRep: function() {
+			return this.exception ?
+				getExceptionStringRep(this.exception) : "";
+		},
+		getCombinedMessages: function() {
+			return (this.messages.length == 1) ? this.messages[0] :
+				   this.messages.join(newLine);
+		},
+		toString: function() {
+			return "LoggingEvent[" + this.level + "]";
+		}
+	};
+
+	log4javascript.LoggingEvent = LoggingEvent;
+
+	/* ---------------------------------------------------------------------- */
+	// Layout prototype
+
+	var Layout = function() {
+	};
+
+	Layout.prototype = {
+		defaults: {
+			loggerKey: "logger",
+			timeStampKey: "timestamp",
+			millisecondsKey: "milliseconds",
+			levelKey: "level",
+			messageKey: "message",
+			exceptionKey: "exception",
+			urlKey: "url"
+		},
+		loggerKey: "logger",
+		timeStampKey: "timestamp",
+		millisecondsKey: "milliseconds",
+		levelKey: "level",
+		messageKey: "message",
+		exceptionKey: "exception",
+		urlKey: "url",
+		batchHeader: "",
+		batchFooter: "",
+		batchSeparator: "",
+		returnsPostData: false,
+		overrideTimeStampsSetting: false,
+		useTimeStampsInMilliseconds: null,
+
+		format: function() {
+			handleError("Layout.format: layout supplied has no format() method");
+		},
+
+		ignoresThrowable: function() {
+			handleError("Layout.ignoresThrowable: layout supplied has no ignoresThrowable() method");
+		},
+
+		getContentType: function() {
+			return "text/plain";
+		},
+
+		allowBatching: function() {
+			return true;
+		},
+
+		setTimeStampsInMilliseconds: function(timeStampsInMilliseconds) {
+			this.overrideTimeStampsSetting = true;
+			this.useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
+		},
+
+		isTimeStampsInMilliseconds: function() {
+			return this.overrideTimeStampsSetting ?
+				this.useTimeStampsInMilliseconds : useTimeStampsInMilliseconds;
+		},
+
+		getTimeStampValue: function(loggingEvent) {
+			return this.isTimeStampsInMilliseconds() ?
+				loggingEvent.timeStampInMilliseconds : loggingEvent.timeStampInSeconds;
+		},
+
+		getDataValues: function(loggingEvent, combineMessages) {
+			var dataValues = [
+				[this.loggerKey, loggingEvent.logger.name],
+				[this.timeStampKey, this.getTimeStampValue(loggingEvent)],
+				[this.levelKey, loggingEvent.level.name],
+				[this.urlKey, window.location.href],
+				[this.messageKey, combineMessages ? loggingEvent.getCombinedMessages() : loggingEvent.messages]
+			];
+			if (!this.isTimeStampsInMilliseconds()) {
+				dataValues.push([this.millisecondsKey, loggingEvent.milliseconds]);
+			}
+			if (loggingEvent.exception) {
+				dataValues.push([this.exceptionKey, getExceptionStringRep(loggingEvent.exception)]);
+			}
+			if (this.hasCustomFields()) {
+				for (var i = 0, len = this.customFields.length; i < len; i++) {
+					var val = this.customFields[i].value;
+
+					// Check if the value is a function. If so, execute it, passing it the
+					// current layout and the logging event
+					if (typeof val === "function") {
+						val = val(this, loggingEvent);
+					}
+					dataValues.push([this.customFields[i].name, val]);
+				}
+			}
+			return dataValues;
+		},
+
+		setKeys: function(loggerKey, timeStampKey, levelKey, messageKey,
+				exceptionKey, urlKey, millisecondsKey) {
+			this.loggerKey = extractStringFromParam(loggerKey, this.defaults.loggerKey);
+			this.timeStampKey = extractStringFromParam(timeStampKey, this.defaults.timeStampKey);
+			this.levelKey = extractStringFromParam(levelKey, this.defaults.levelKey);
+			this.messageKey = extractStringFromParam(messageKey, this.defaults.messageKey);
+			this.exceptionKey = extractStringFromParam(exceptionKey, this.defaults.exceptionKey);
+			this.urlKey = extractStringFromParam(urlKey, this.defaults.urlKey);
+			this.millisecondsKey = extractStringFromParam(millisecondsKey, this.defaults.millisecondsKey);
+		},
+
+		setCustomField: function(name, value) {
+			var fieldUpdated = false;
+			for (var i = 0, len = this.customFields.length; i < len; i++) {
+				if (this.customFields[i].name === name) {
+					this.customFields[i].value = value;
+					fieldUpdated = true;
+				}
+			}
+			if (!fieldUpdated) {
+				this.customFields.push({"name": name, "value": value});
+			}
+		},
+
+		hasCustomFields: function() {
+			return (this.customFields.length > 0);
+		},
+
+		toString: function() {
+			handleError("Layout.toString: all layouts must override this method");
+		}
+	};
+
+	log4javascript.Layout = Layout;
+
+	/* ---------------------------------------------------------------------- */
+	// Appender prototype
+
+	var Appender = function() {};
+
+	Appender.prototype = new EventSupport();
+
+	Appender.prototype.layout = new PatternLayout();
+	Appender.prototype.threshold = Level.ALL;
+	Appender.prototype.loggers = [];
+
+	// Performs threshold checks before delegating actual logging to the
+	// subclass's specific append method.
+	Appender.prototype.doAppend = function(loggingEvent) {
+		if (enabled && loggingEvent.level.level >= this.threshold.level) {
+			this.append(loggingEvent);
+		}
+	};
+
+	Appender.prototype.append = function(loggingEvent) {};
+
+	Appender.prototype.setLayout = function(layout) {
+		if (layout instanceof Layout) {
+			this.layout = layout;
+		} else {
+			handleError("Appender.setLayout: layout supplied to " +
+				this.toString() + " is not a subclass of Layout");
+		}
+	};
+
+	Appender.prototype.getLayout = function() {
+		return this.layout;
+	};
+
+	Appender.prototype.setThreshold = function(threshold) {
+		if (threshold instanceof Level) {
+			this.threshold = threshold;
+		} else {
+			handleError("Appender.setThreshold: threshold supplied to " +
+				this.toString() + " is not a subclass of Level");
+		}
+	};
+
+	Appender.prototype.getThreshold = function() {
+		return this.threshold;
+	};
+
+	Appender.prototype.setAddedToLogger = function(logger) {
+		this.loggers.push(logger);
+	};
+
+	Appender.prototype.setRemovedFromLogger = function(logger) {
+		array_remove(this.loggers, logger);
+	};
+
+	Appender.prototype.group = emptyFunction;
+	Appender.prototype.groupEnd = emptyFunction;
+
+	Appender.prototype.toString = function() {
+		handleError("Appender.toString: all appenders must override this method");
+	};
+
+	log4javascript.Appender = Appender;
+
+	/* ---------------------------------------------------------------------- */
+	// SimpleLayout 
+
+	function SimpleLayout() {
+		this.customFields = [];
+	}
+
+	SimpleLayout.prototype = new Layout();
+
+	SimpleLayout.prototype.format = function(loggingEvent) {
+		return loggingEvent.level.name + " - " + loggingEvent.getCombinedMessages();
+	};
+
+	SimpleLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	SimpleLayout.prototype.toString = function() {
+	    return "SimpleLayout";
+	};
+
+	log4javascript.SimpleLayout = SimpleLayout;
+	/* ----------------------------------------------------------------------- */
+	// NullLayout 
+
+	function NullLayout() {
+		this.customFields = [];
+	}
+
+	NullLayout.prototype = new Layout();
+
+	NullLayout.prototype.format = function(loggingEvent) {
+		return loggingEvent.messages;
+	};
+
+	NullLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	NullLayout.prototype.toString = function() {
+	    return "NullLayout";
+	};
+
+	log4javascript.NullLayout = NullLayout;
+/* ---------------------------------------------------------------------- */
+	// XmlLayout
+
+	function XmlLayout(combineMessages) {
+		this.combineMessages = extractBooleanFromParam(combineMessages, true);
+		this.customFields = [];
+	}
+
+	XmlLayout.prototype = new Layout();
+
+	XmlLayout.prototype.isCombinedMessages = function() {
+		return this.combineMessages;
+	};
+
+	XmlLayout.prototype.getContentType = function() {
+		return "text/xml";
+	};
+
+	XmlLayout.prototype.escapeCdata = function(str) {
+		return str.replace(/\]\]>/, "]]>]]&gt;<![CDATA[");
+	};
+
+	XmlLayout.prototype.format = function(loggingEvent) {
+		var layout = this;
+		var i, len;
+		function formatMessage(message) {
+			message = (typeof message === "string") ? message : toStr(message);
+			return "<log4javascript:message><![CDATA[" +
+				layout.escapeCdata(message) + "]]></log4javascript:message>";
+		}
+
+		var str = "<log4javascript:event logger=\"" + loggingEvent.logger.name +
+			"\" timestamp=\"" + this.getTimeStampValue(loggingEvent) + "\"";
+		if (!this.isTimeStampsInMilliseconds()) {
+			str += " milliseconds=\"" + loggingEvent.milliseconds + "\"";
+		}
+		str += " level=\"" + loggingEvent.level.name + "\">" + newLine;
+		if (this.combineMessages) {
+			str += formatMessage(loggingEvent.getCombinedMessages());
+		} else {
+			str += "<log4javascript:messages>" + newLine;
+			for (i = 0, len = loggingEvent.messages.length; i < len; i++) {
+				str += formatMessage(loggingEvent.messages[i]) + newLine;
+			}
+			str += "</log4javascript:messages>" + newLine;
+		}
+		if (this.hasCustomFields()) {
+			for (i = 0, len = this.customFields.length; i < len; i++) {
+				str += "<log4javascript:customfield name=\"" +
+					this.customFields[i].name + "\"><![CDATA[" +
+					this.customFields[i].value.toString() +
+					"]]></log4javascript:customfield>" + newLine;
+			}
+		}
+		if (loggingEvent.exception) {
+			str += "<log4javascript:exception><![CDATA[" +
+				getExceptionStringRep(loggingEvent.exception) +
+				"]]></log4javascript:exception>" + newLine;
+		}
+		str += "</log4javascript:event>" + newLine + newLine;
+		return str;
+	};
+
+	XmlLayout.prototype.ignoresThrowable = function() {
+	    return false;
+	};
+
+	XmlLayout.prototype.toString = function() {
+	    return "XmlLayout";
+	};
+
+	log4javascript.XmlLayout = XmlLayout;
+	/* ---------------------------------------------------------------------- */
+	// JsonLayout related
+
+	function escapeNewLines(str) {
+		return str.replace(/\r\n|\r|\n/g, "\\r\\n");
+	}
+
+	function JsonLayout(readable, combineMessages) {
+		this.readable = extractBooleanFromParam(readable, false);
+		this.combineMessages = extractBooleanFromParam(combineMessages, true);
+		this.batchHeader = this.readable ? "[" + newLine : "[";
+		this.batchFooter = this.readable ? "]" + newLine : "]";
+		this.batchSeparator = this.readable ? "," + newLine : ",";
+		this.setKeys();
+		this.colon = this.readable ? ": " : ":";
+		this.tab = this.readable ? "\t" : "";
+		this.lineBreak = this.readable ? newLine : "";
+		this.customFields = [];
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// JsonLayout
+
+	JsonLayout.prototype = new Layout();
+
+	JsonLayout.prototype.isReadable = function() {
+		return this.readable;
+	};
+
+	JsonLayout.prototype.isCombinedMessages = function() {
+		return this.combineMessages;
+	};
+
+    JsonLayout.prototype.format = function(loggingEvent) {
+        var layout = this;
+        var dataValues = this.getDataValues(loggingEvent, this.combineMessages);
+        var str = "{" + this.lineBreak;
+        var i, len;
+
+        function formatValue(val, prefix, expand) {
+            // Check the type of the data value to decide whether quotation marks
+            // or expansion are required
+            var formattedValue;
+            var valType = typeof val;
+            if (val instanceof Date) {
+                formattedValue = String(val.getTime());
+            } else if (expand && (val instanceof Array)) {
+                formattedValue = "[" + layout.lineBreak;
+                for (var i = 0, len = val.length; i < len; i++) {
+                    var childPrefix = prefix + layout.tab;
+                    formattedValue += childPrefix + formatValue(val[i], childPrefix, false);
+                    if (i < val.length - 1) {
+                        formattedValue += ",";
+                    }
+                    formattedValue += layout.lineBreak;
+                }
+                formattedValue += prefix + "]";
+            } else if (valType !== "number" && valType !== "boolean") {
+                formattedValue = "\"" + escapeNewLines(toStr(val).replace(/\"/g, "\\\"")) + "\"";
+            } else {
+                formattedValue = val;
+            }
+            return formattedValue;
+        }
+
+        for (i = 0, len = dataValues.length - 1; i <= len; i++) {
+            str += this.tab + "\"" + dataValues[i][0] + "\"" + this.colon + formatValue(dataValues[i][1], this.tab, true);
+            if (i < len) {
+                str += ",";
+            }
+            str += this.lineBreak;
+        }
+
+        str += "}" + this.lineBreak;
+        return str;
+    };
+
+	JsonLayout.prototype.ignoresThrowable = function() {
+	    return false;
+	};
+
+	JsonLayout.prototype.toString = function() {
+	    return "JsonLayout";
+	};
+
+	JsonLayout.prototype.getContentType = function() {
+		return "application/json";
+	};
+
+	log4javascript.JsonLayout = JsonLayout;
+	/* ---------------------------------------------------------------------- */
+	// HttpPostDataLayout
+
+	function HttpPostDataLayout() {
+		this.setKeys();
+		this.customFields = [];
+		this.returnsPostData = true;
+	}
+
+	HttpPostDataLayout.prototype = new Layout();
+
+	// Disable batching
+	HttpPostDataLayout.prototype.allowBatching = function() {
+		return false;
+	};
+
+	HttpPostDataLayout.prototype.format = function(loggingEvent) {
+		var dataValues = this.getDataValues(loggingEvent);
+		var queryBits = [];
+		for (var i = 0, len = dataValues.length; i < len; i++) {
+			var val = (dataValues[i][1] instanceof Date) ?
+				String(dataValues[i][1].getTime()) : dataValues[i][1];
+			queryBits.push(urlEncode(dataValues[i][0]) + "=" + urlEncode(val));
+		}
+		return queryBits.join("&");
+	};
+
+	HttpPostDataLayout.prototype.ignoresThrowable = function(loggingEvent) {
+	    return false;
+	};
+
+	HttpPostDataLayout.prototype.toString = function() {
+	    return "HttpPostDataLayout";
+	};
+
+	log4javascript.HttpPostDataLayout = HttpPostDataLayout;
+	/* ---------------------------------------------------------------------- */
+	// formatObjectExpansion
+
+	function formatObjectExpansion(obj, depth, indentation) {
+		var objectsExpanded = [];
+
+		function doFormat(obj, depth, indentation) {
+			var i, j, len, childDepth, childIndentation, childLines, expansion,
+				childExpansion;
+
+			if (!indentation) {
+				indentation = "";
+			}
+
+			function formatString(text) {
+				var lines = splitIntoLines(text);
+				for (var j = 1, jLen = lines.length; j < jLen; j++) {
+					lines[j] = indentation + lines[j];
+				}
+				return lines.join(newLine);
+			}
+
+			if (obj === null) {
+				return "null";
+			} else if (typeof obj == "undefined") {
+				return "undefined";
+			} else if (typeof obj == "string") {
+				return formatString(obj);
+			} else if (typeof obj == "object" && array_contains(objectsExpanded, obj)) {
+				try {
+					expansion = toStr(obj);
+				} catch (ex) {
+					expansion = "Error formatting property. Details: " + getExceptionStringRep(ex);
+				}
+				return expansion + " [already expanded]";
+			} else if ((obj instanceof Array) && depth > 0) {
+				objectsExpanded.push(obj);
+				expansion = "[" + newLine;
+				childDepth = depth - 1;
+				childIndentation = indentation + "  ";
+				childLines = [];
+				for (i = 0, len = obj.length; i < len; i++) {
+					try {
+						childExpansion = doFormat(obj[i], childDepth, childIndentation);
+						childLines.push(childIndentation + childExpansion);
+					} catch (ex) {
+						childLines.push(childIndentation + "Error formatting array member. Details: " +
+							getExceptionStringRep(ex) + "");
+					}
+				}
+				expansion += childLines.join("," + newLine) + newLine + indentation + "]";
+				return expansion;
+            } else if (Object.prototype.toString.call(obj) == "[object Date]") {
+                return obj.toString();
+			} else if (typeof obj == "object" && depth > 0) {
+				objectsExpanded.push(obj);
+				expansion = "{" + newLine;
+				childDepth = depth - 1;
+				childIndentation = indentation + "  ";
+				childLines = [];
+				for (i in obj) {
+					try {
+						childExpansion = doFormat(obj[i], childDepth, childIndentation);
+						childLines.push(childIndentation + i + ": " + childExpansion);
+					} catch (ex) {
+						childLines.push(childIndentation + i + ": Error formatting property. Details: " +
+							getExceptionStringRep(ex));
+					}
+				}
+				expansion += childLines.join("," + newLine) + newLine + indentation + "}";
+				return expansion;
+			} else {
+				return formatString(toStr(obj));
+			}
+		}
+		return doFormat(obj, depth, indentation);
+	}
+	/* ---------------------------------------------------------------------- */
+	// Date-related stuff
+
+	var SimpleDateFormat;
+
+	(function() {
+		var regex = /('[^']*')|(G+|y+|M+|w+|W+|D+|d+|F+|E+|a+|H+|k+|K+|h+|m+|s+|S+|Z+)|([a-zA-Z]+)|([^a-zA-Z']+)/;
+		var monthNames = ["January", "February", "March", "April", "May", "June",
+			"July", "August", "September", "October", "November", "December"];
+		var dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+		var TEXT2 = 0, TEXT3 = 1, NUMBER = 2, YEAR = 3, MONTH = 4, TIMEZONE = 5;
+		var types = {
+			G : TEXT2,
+			y : YEAR,
+			M : MONTH,
+			w : NUMBER,
+			W : NUMBER,
+			D : NUMBER,
+			d : NUMBER,
+			F : NUMBER,
+			E : TEXT3,
+			a : TEXT2,
+			H : NUMBER,
+			k : NUMBER,
+			K : NUMBER,
+			h : NUMBER,
+			m : NUMBER,
+			s : NUMBER,
+			S : NUMBER,
+			Z : TIMEZONE
+		};
+		var ONE_DAY = 24 * 60 * 60 * 1000;
+		var ONE_WEEK = 7 * ONE_DAY;
+		var DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK = 1;
+
+		var newDateAtMidnight = function(year, month, day) {
+			var d = new Date(year, month, day, 0, 0, 0);
+			d.setMilliseconds(0);
+			return d;
+		};
+
+		Date.prototype.getDifference = function(date) {
+			return this.getTime() - date.getTime();
+		};
+
+		Date.prototype.isBefore = function(d) {
+			return this.getTime() < d.getTime();
+		};
+
+		Date.prototype.getUTCTime = function() {
+			return Date.UTC(this.getFullYear(), this.getMonth(), this.getDate(), this.getHours(), this.getMinutes(),
+					this.getSeconds(), this.getMilliseconds());
+		};
+
+		Date.prototype.getTimeSince = function(d) {
+			return this.getUTCTime() - d.getUTCTime();
+		};
+
+		Date.prototype.getPreviousSunday = function() {
+			// Using midday avoids any possibility of DST messing things up
+			var midday = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 12, 0, 0);
+			var previousSunday = new Date(midday.getTime() - this.getDay() * ONE_DAY);
+			return newDateAtMidnight(previousSunday.getFullYear(), previousSunday.getMonth(),
+					previousSunday.getDate());
+		};
+
+		Date.prototype.getWeekInYear = function(minimalDaysInFirstWeek) {
+			if (isUndefined(this.minimalDaysInFirstWeek)) {
+				minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
+			}
+			var previousSunday = this.getPreviousSunday();
+			var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
+			var numberOfSundays = previousSunday.isBefore(startOfYear) ?
+				0 : 1 + Math.floor(previousSunday.getTimeSince(startOfYear) / ONE_WEEK);
+			var numberOfDaysInFirstWeek =  7 - startOfYear.getDay();
+			var weekInYear = numberOfSundays;
+			if (numberOfDaysInFirstWeek < minimalDaysInFirstWeek) {
+				weekInYear--;
+			}
+			return weekInYear;
+		};
+
+		Date.prototype.getWeekInMonth = function(minimalDaysInFirstWeek) {
+			if (isUndefined(this.minimalDaysInFirstWeek)) {
+				minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
+			}
+			var previousSunday = this.getPreviousSunday();
+			var startOfMonth = newDateAtMidnight(this.getFullYear(), this.getMonth(), 1);
+			var numberOfSundays = previousSunday.isBefore(startOfMonth) ?
+				0 : 1 + Math.floor(previousSunday.getTimeSince(startOfMonth) / ONE_WEEK);
+			var numberOfDaysInFirstWeek =  7 - startOfMonth.getDay();
+			var weekInMonth = numberOfSundays;
+			if (numberOfDaysInFirstWeek >= minimalDaysInFirstWeek) {
+				weekInMonth++;
+			}
+			return weekInMonth;
+		};
+
+		Date.prototype.getDayInYear = function() {
+			var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
+			return 1 + Math.floor(this.getTimeSince(startOfYear) / ONE_DAY);
+		};
+
+		/* ------------------------------------------------------------------ */
+
+		SimpleDateFormat = function(formatString) {
+			this.formatString = formatString;
+		};
+
+		/**
+		 * Sets the minimum number of days in a week in order for that week to
+		 * be considered as belonging to a particular month or year
+		 */
+		SimpleDateFormat.prototype.setMinimalDaysInFirstWeek = function(days) {
+			this.minimalDaysInFirstWeek = days;
+		};
+
+		SimpleDateFormat.prototype.getMinimalDaysInFirstWeek = function() {
+			return isUndefined(this.minimalDaysInFirstWeek)	?
+				DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK : this.minimalDaysInFirstWeek;
+		};
+
+		var padWithZeroes = function(str, len) {
+			while (str.length < len) {
+				str = "0" + str;
+			}
+			return str;
+		};
+
+		var formatText = function(data, numberOfLetters, minLength) {
+			return (numberOfLetters >= 4) ? data : data.substr(0, Math.max(minLength, numberOfLetters));
+		};
+
+		var formatNumber = function(data, numberOfLetters) {
+			var dataString = "" + data;
+			// Pad with 0s as necessary
+			return padWithZeroes(dataString, numberOfLetters);
+		};
+
+		SimpleDateFormat.prototype.format = function(date) {
+			var formattedString = "";
+			var result;
+			var searchString = this.formatString;
+			while ((result = regex.exec(searchString))) {
+				var quotedString = result[1];
+				var patternLetters = result[2];
+				var otherLetters = result[3];
+				var otherCharacters = result[4];
+
+				// If the pattern matched is quoted string, output the text between the quotes
+				if (quotedString) {
+					if (quotedString == "''") {
+						formattedString += "'";
+					} else {
+						formattedString += quotedString.substring(1, quotedString.length - 1);
+					}
+				} else if (otherLetters) {
+					// Swallow non-pattern letters by doing nothing here
+				} else if (otherCharacters) {
+					// Simply output other characters
+					formattedString += otherCharacters;
+				} else if (patternLetters) {
+					// Replace pattern letters
+					var patternLetter = patternLetters.charAt(0);
+					var numberOfLetters = patternLetters.length;
+					var rawData = "";
+					switch(patternLetter) {
+						case "G":
+							rawData = "AD";
+							break;
+						case "y":
+							rawData = date.getFullYear();
+							break;
+						case "M":
+							rawData = date.getMonth();
+							break;
+						case "w":
+							rawData = date.getWeekInYear(this.getMinimalDaysInFirstWeek());
+							break;
+						case "W":
+							rawData = date.getWeekInMonth(this.getMinimalDaysInFirstWeek());
+							break;
+						case "D":
+							rawData = date.getDayInYear();
+							break;
+						case "d":
+							rawData = date.getDate();
+							break;
+						case "F":
+							rawData = 1 + Math.floor((date.getDate() - 1) / 7);
+							break;
+						case "E":
+							rawData = dayNames[date.getDay()];
+							break;
+						case "a":
+							rawData = (date.getHours() >= 12) ? "PM" : "AM";
+							break;
+						case "H":
+							rawData = date.getHours();
+							break;
+						case "k":
+							rawData = date.getHours() || 24;
+							break;
+						case "K":
+							rawData = date.getHours() % 12;
+							break;
+						case "h":
+							rawData = (date.getHours() % 12) || 12;
+							break;
+						case "m":
+							rawData = date.getMinutes();
+							break;
+						case "s":
+							rawData = date.getSeconds();
+							break;
+						case "S":
+							rawData = date.getMilliseconds();
+							break;
+						case "Z":
+							rawData = date.getTimezoneOffset(); // This returns the number of minutes since GMT was this time.
+							break;
+					}
+					// Format the raw data depending on the type
+					switch(types[patternLetter]) {
+						case TEXT2:
+							formattedString += formatText(rawData, numberOfLetters, 2);
+							break;
+						case TEXT3:
+							formattedString += formatText(rawData, numberOfLetters, 3);
+							break;
+						case NUMBER:
+							formattedString += formatNumber(rawData, numberOfLetters);
+							break;
+						case YEAR:
+							if (numberOfLetters <= 3) {
+								// Output a 2-digit year
+								var dataString = "" + rawData;
+								formattedString += dataString.substr(2, 2);
+							} else {
+								formattedString += formatNumber(rawData, numberOfLetters);
+							}
+							break;
+						case MONTH:
+							if (numberOfLetters >= 3) {
+								formattedString += formatText(monthNames[rawData], numberOfLetters, numberOfLetters);
+							} else {
+								// NB. Months returned by getMonth are zero-based
+								formattedString += formatNumber(rawData + 1, numberOfLetters);
+							}
+							break;
+						case TIMEZONE:
+							var isPositive = (rawData > 0);
+							// The following line looks like a mistake but isn't
+							// because of the way getTimezoneOffset measures.
+							var prefix = isPositive ? "-" : "+";
+							var absData = Math.abs(rawData);
+
+							// Hours
+							var hours = "" + Math.floor(absData / 60);
+							hours = padWithZeroes(hours, 2);
+							// Minutes
+							var minutes = "" + (absData % 60);
+							minutes = padWithZeroes(minutes, 2);
+
+							formattedString += prefix + hours + minutes;
+							break;
+					}
+				}
+				searchString = searchString.substr(result.index + result[0].length);
+			}
+			return formattedString;
+		};
+	})();
+
+	log4javascript.SimpleDateFormat = SimpleDateFormat;
+
+	/* ---------------------------------------------------------------------- */
+	// PatternLayout
+
+	function PatternLayout(pattern) {
+		if (pattern) {
+			this.pattern = pattern;
+		} else {
+			this.pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
+		}
+		this.customFields = [];
+	}
+
+	PatternLayout.TTCC_CONVERSION_PATTERN = "%r %p %c - %m%n";
+	PatternLayout.DEFAULT_CONVERSION_PATTERN = "%m%n";
+	PatternLayout.ISO8601_DATEFORMAT = "yyyy-MM-dd HH:mm:ss,SSS";
+	PatternLayout.DATETIME_DATEFORMAT = "dd MMM yyyy HH:mm:ss,SSS";
+	PatternLayout.ABSOLUTETIME_DATEFORMAT = "HH:mm:ss,SSS";
+
+	PatternLayout.prototype = new Layout();
+
+	PatternLayout.prototype.format = function(loggingEvent) {
+		var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([acdfmMnpr%])(\{([^\}]+)\})?|([^%]+)/;
+		var formattedString = "";
+		var result;
+		var searchString = this.pattern;
+
+		// Cannot use regex global flag since it doesn't work with exec in IE5
+		while ((result = regex.exec(searchString))) {
+			var matchedString = result[0];
+			var padding = result[1];
+			var truncation = result[2];
+			var conversionCharacter = result[3];
+			var specifier = result[5];
+			var text = result[6];
+
+			// Check if the pattern matched was just normal text
+			if (text) {
+				formattedString += "" + text;
+			} else {
+				// Create a raw replacement string based on the conversion
+				// character and specifier
+				var replacement = "";
+				switch(conversionCharacter) {
+					case "a": // Array of messages
+					case "m": // Message
+						var depth = 0;
+						if (specifier) {
+							depth = parseInt(specifier, 10);
+							if (isNaN(depth)) {
+								handleError("PatternLayout.format: invalid specifier '" +
+									specifier + "' for conversion character '" + conversionCharacter +
+									"' - should be a number");
+								depth = 0;
+							}
+						}
+						var messages = (conversionCharacter === "a") ? loggingEvent.messages[0] : loggingEvent.messages;
+						for (var i = 0, len = messages.length; i < len; i++) {
+							if (i > 0 && (replacement.charAt(replacement.length - 1) !== " ")) {
+								replacement += " ";
+							}
+							if (depth === 0) {
+								replacement += messages[i];
+							} else {
+								replacement += formatObjectExpansion(messages[i], depth);
+							}
+						}
+						break;
+					case "c": // Logger name
+						var loggerName = loggingEvent.logger.name;
+						if (specifier) {
+							var precision = parseInt(specifier, 10);
+							var loggerNameBits = loggingEvent.logger.name.split(".");
+							if (precision >= loggerNameBits.length) {
+								replacement = loggerName;
+							} else {
+								replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
+							}
+						} else {
+							replacement = loggerName;
+						}
+						break;
+					case "d": // Date
+						var dateFormat = PatternLayout.ISO8601_DATEFORMAT;
+						if (specifier) {
+							dateFormat = specifier;
+							// Pick up special cases
+							if (dateFormat == "ISO8601") {
+								dateFormat = PatternLayout.ISO8601_DATEFORMAT;
+							} else if (dateFormat == "ABSOLUTE") {
+								dateFormat = PatternLayout.ABSOLUTETIME_DATEFORMAT;
+							} else if (dateFormat == "DATE") {
+								dateFormat = PatternLayout.DATETIME_DATEFORMAT;
+							}
+						}
+						// Format the date
+						replacement = (new SimpleDateFormat(dateFormat)).format(loggingEvent.timeStamp);
+						break;
+					case "f": // Custom field
+						if (this.hasCustomFields()) {
+							var fieldIndex = 0;
+							if (specifier) {
+								fieldIndex = parseInt(specifier, 10);
+								if (isNaN(fieldIndex)) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - should be a number");
+								} else if (fieldIndex === 0) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - must be greater than zero");
+								} else if (fieldIndex > this.customFields.length) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - there aren't that many custom fields");
+								} else {
+									fieldIndex = fieldIndex - 1;
+								}
+							}
+                            var val = this.customFields[fieldIndex].value;
+                            if (typeof val == "function") {
+                                val = val(this, loggingEvent);
+                            }
+                            replacement = val;
+						}
+						break;
+					case "n": // New line
+						replacement = newLine;
+						break;
+					case "p": // Level
+						replacement = loggingEvent.level.name;
+						break;
+					case "r": // Milliseconds since log4javascript startup
+						replacement = "" + loggingEvent.timeStamp.getDifference(applicationStartDate);
+						break;
+					case "%": // Literal % sign
+						replacement = "%";
+						break;
+					default:
+						replacement = matchedString;
+						break;
+				}
+				// Format the replacement according to any padding or
+				// truncation specified
+				var l;
+
+				// First, truncation
+				if (truncation) {
+					l = parseInt(truncation.substr(1), 10);
+					var strLen = replacement.length;
+					if (l < strLen) {
+						replacement = replacement.substring(strLen - l, strLen);
+					}
+				}
+				// Next, padding
+				if (padding) {
+					if (padding.charAt(0) == "-") {
+						l = parseInt(padding.substr(1), 10);
+						// Right pad with spaces
+						while (replacement.length < l) {
+							replacement += " ";
+						}
+					} else {
+						l = parseInt(padding, 10);
+						// Left pad with spaces
+						while (replacement.length < l) {
+							replacement = " " + replacement;
+						}
+					}
+				}
+				formattedString += replacement;
+			}
+			searchString = searchString.substr(result.index + result[0].length);
+		}
+		return formattedString;
+	};
+
+	PatternLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	PatternLayout.prototype.toString = function() {
+	    return "PatternLayout";
+	};
+
+	log4javascript.PatternLayout = PatternLayout;
+	/* ---------------------------------------------------------------------- */
+	// AjaxAppender related
+
+	var xmlHttpFactories = [
+		function() { return new XMLHttpRequest(); },
+		function() { return new ActiveXObject("Msxml2.XMLHTTP"); },
+		function() { return new ActiveXObject("Microsoft.XMLHTTP"); }
+	];
+
+	var getXmlHttp = function(errorHandler) {
+		// This is only run the first time; the value of getXmlHttp gets
+		// replaced with the factory that succeeds on the first run
+		var xmlHttp = null, factory;
+		for (var i = 0, len = xmlHttpFactories.length; i < len; i++) {
+			factory = xmlHttpFactories[i];
+			try {
+				xmlHttp = factory();
+				getXmlHttp = factory;
+				return xmlHttp;
+			} catch (e) {
+			}
+		}
+		// If we're here, all factories have failed, so throw an error
+		if (errorHandler) {
+			errorHandler();
+		} else {
+			handleError("getXmlHttp: unable to obtain XMLHttpRequest object");
+		}
+	};
+
+	function isHttpRequestSuccessful(xmlHttp) {
+		return isUndefined(xmlHttp.status) || xmlHttp.status === 0 ||
+			(xmlHttp.status >= 200 && xmlHttp.status < 300) ||
+			xmlHttp.status == 1223 /* Fix for IE */;
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// AjaxAppender
+
+	function AjaxAppender(url) {
+		var appender = this;
+		var isSupported = true;
+		if (!url) {
+			handleError("AjaxAppender: URL must be specified in constructor");
+			isSupported = false;
+		}
+
+		var timed = this.defaults.timed;
+		var waitForResponse = this.defaults.waitForResponse;
+		var batchSize = this.defaults.batchSize;
+		var timerInterval = this.defaults.timerInterval;
+		var requestSuccessCallback = this.defaults.requestSuccessCallback;
+		var failCallback = this.defaults.failCallback;
+		var postVarName = this.defaults.postVarName;
+		var sendAllOnUnload = this.defaults.sendAllOnUnload;
+		var contentType = this.defaults.contentType;
+		var sessionId = null;
+
+		var queuedLoggingEvents = [];
+		var queuedRequests = [];
+		var headers = [];
+		var sending = false;
+		var initialized = false;
+
+		// Configuration methods. The function scope is used to prevent
+		// direct alteration to the appender configuration properties.
+		function checkCanConfigure(configOptionName) {
+			if (initialized) {
+				handleError("AjaxAppender: configuration option '" +
+					configOptionName +
+					"' may not be set after the appender has been initialized");
+				return false;
+			}
+			return true;
+		}
+
+		this.getSessionId = function() { return sessionId; };
+		this.setSessionId = function(sessionIdParam) {
+			sessionId = extractStringFromParam(sessionIdParam, null);
+			this.layout.setCustomField("sessionid", sessionId);
+		};
+
+		this.setLayout = function(layoutParam) {
+			if (checkCanConfigure("layout")) {
+				this.layout = layoutParam;
+				// Set the session id as a custom field on the layout, if not already present
+				if (sessionId !== null) {
+					this.setSessionId(sessionId);
+				}
+			}
+		};
+
+		this.isTimed = function() { return timed; };
+		this.setTimed = function(timedParam) {
+			if (checkCanConfigure("timed")) {
+				timed = bool(timedParam);
+			}
+		};
+
+		this.getTimerInterval = function() { return timerInterval; };
+		this.setTimerInterval = function(timerIntervalParam) {
+			if (checkCanConfigure("timerInterval")) {
+				timerInterval = extractIntFromParam(timerIntervalParam, timerInterval);
+			}
+		};
+
+		this.isWaitForResponse = function() { return waitForResponse; };
+		this.setWaitForResponse = function(waitForResponseParam) {
+			if (checkCanConfigure("waitForResponse")) {
+				waitForResponse = bool(waitForResponseParam);
+			}
+		};
+
+		this.getBatchSize = function() { return batchSize; };
+		this.setBatchSize = function(batchSizeParam) {
+			if (checkCanConfigure("batchSize")) {
+				batchSize = extractIntFromParam(batchSizeParam, batchSize);
+			}
+		};
+
+		this.isSendAllOnUnload = function() { return sendAllOnUnload; };
+		this.setSendAllOnUnload = function(sendAllOnUnloadParam) {
+			if (checkCanConfigure("sendAllOnUnload")) {
+				sendAllOnUnload = extractBooleanFromParam(sendAllOnUnloadParam, sendAllOnUnload);
+			}
+		};
+
+		this.setRequestSuccessCallback = function(requestSuccessCallbackParam) {
+			requestSuccessCallback = extractFunctionFromParam(requestSuccessCallbackParam, requestSuccessCallback);
+		};
+
+		this.setFailCallback = function(failCallbackParam) {
+			failCallback = extractFunctionFromParam(failCallbackParam, failCallback);
+		};
+
+		this.getPostVarName = function() { return postVarName; };
+		this.setPostVarName = function(postVarNameParam) {
+			if (checkCanConfigure("postVarName")) {
+				postVarName = extractStringFromParam(postVarNameParam, postVarName);
+			}
+		};
+
+		this.getHeaders = function() { return headers; };
+		this.addHeader = function(name, value) {
+			if (name.toLowerCase() == "content-type") {
+				contentType = value;
+			} else {
+				headers.push( { name: name, value: value } );
+			}
+		};
+
+		// Internal functions
+		function sendAll() {
+			if (isSupported && enabled) {
+				sending = true;
+				var currentRequestBatch;
+				if (waitForResponse) {
+					// Send the first request then use this function as the callback once
+					// the response comes back
+					if (queuedRequests.length > 0) {
+						currentRequestBatch = queuedRequests.shift();
+						sendRequest(preparePostData(currentRequestBatch), sendAll);
+					} else {
+						sending = false;
+						if (timed) {
+							scheduleSending();
+						}
+					}
+				} else {
+					// Rattle off all the requests without waiting to see the response
+					while ((currentRequestBatch = queuedRequests.shift())) {
+						sendRequest(preparePostData(currentRequestBatch));
+					}
+					sending = false;
+					if (timed) {
+						scheduleSending();
+					}
+				}
+			}
+		}
+
+		this.sendAll = sendAll;
+
+		// Called when the window unloads. At this point we're past caring about
+		// waiting for responses or timers or incomplete batches - everything
+		// must go, now
+		function sendAllRemaining() {
+			var sendingAnything = false;
+			if (isSupported && enabled) {
+				// Create requests for everything left over, batched as normal
+				var actualBatchSize = appender.getLayout().allowBatching() ? batchSize : 1;
+				var currentLoggingEvent;
+				var batchedLoggingEvents = [];
+				while ((currentLoggingEvent = queuedLoggingEvents.shift())) {
+					batchedLoggingEvents.push(currentLoggingEvent);
+					if (queuedLoggingEvents.length >= actualBatchSize) {
+						// Queue this batch of log entries
+						queuedRequests.push(batchedLoggingEvents);
+						batchedLoggingEvents = [];
+					}
+				}
+				// If there's a partially completed batch, add it
+				if (batchedLoggingEvents.length > 0) {
+					queuedRequests.push(batchedLoggingEvents);
+				}
+				sendingAnything = (queuedRequests.length > 0);
+				waitForResponse = false;
+				timed = false;
+				sendAll();
+			}
+			return sendingAnything;
+		}
+
+		this.sendAllRemaining = sendAllRemaining;
+
+		function preparePostData(batchedLoggingEvents) {
+			// Format the logging events
+			var formattedMessages = [];
+			var currentLoggingEvent;
+			var postData = "";
+			while ((currentLoggingEvent = batchedLoggingEvents.shift())) {
+				var currentFormattedMessage = appender.getLayout().format(currentLoggingEvent);
+				if (appender.getLayout().ignoresThrowable()) {
+					currentFormattedMessage += currentLoggingEvent.getThrowableStrRep();
+				}
+				formattedMessages.push(currentFormattedMessage);
+			}
+			// Create the post data string
+			if (batchedLoggingEvents.length == 1) {
+				postData = formattedMessages.join("");
+			} else {
+				postData = appender.getLayout().batchHeader +
+					formattedMessages.join(appender.getLayout().batchSeparator) +
+					appender.getLayout().batchFooter;
+			}
+			if (contentType == appender.defaults.contentType) {
+				postData = appender.getLayout().returnsPostData ? postData :
+					urlEncode(postVarName) + "=" + urlEncode(postData);
+				// Add the layout name to the post data
+				if (postData.length > 0) {
+					postData += "&";
+				}
+				postData += "layout=" + urlEncode(appender.getLayout().toString());
+			}
+			return postData;
+		}
+
+		function scheduleSending() {
+			window.setTimeout(sendAll, timerInterval);
+		}
+
+		function xmlHttpErrorHandler() {
+			var msg = "AjaxAppender: could not create XMLHttpRequest object. AjaxAppender disabled";
+			handleError(msg);
+			isSupported = false;
+			if (failCallback) {
+				failCallback(msg);
+			}
+		}
+
+		function sendRequest(postData, successCallback) {
+			try {
+				var xmlHttp = getXmlHttp(xmlHttpErrorHandler);
+				if (isSupported) {
+					if (xmlHttp.overrideMimeType) {
+						xmlHttp.overrideMimeType(appender.getLayout().getContentType());
+					}
+					xmlHttp.onreadystatechange = function() {
+						if (xmlHttp.readyState == 4) {
+							if (isHttpRequestSuccessful(xmlHttp)) {
+								if (requestSuccessCallback) {
+									requestSuccessCallback(xmlHttp);
+								}
+								if (successCallback) {
+									successCallback(xmlHttp);
+								}
+							} else {
+								var msg = "AjaxAppender.append: XMLHttpRequest request to URL " +
+									url + " returned status code " + xmlHttp.status;
+								handleError(msg);
+								if (failCallback) {
+									failCallback(msg);
+								}
+							}
+							xmlHttp.onreadystatechange = emptyFunction;
+							xmlHttp = null;
+						}
+					};
+					xmlHttp.open("POST", url, true);
+					try {
+						for (var i = 0, header; header = headers[i++]; ) {
+							xmlHttp.setRequestHeader(header.name, header.value);
+						}
+						xmlHttp.setRequestHeader("Content-Type", contentType);
+					} catch (headerEx) {
+						var msg = "AjaxAppender.append: your browser's XMLHttpRequest implementation" +
+							" does not support setRequestHeader, therefore cannot post data. AjaxAppender disabled";
+						handleError(msg);
+						isSupported = false;
+						if (failCallback) {
+							failCallback(msg);
+						}
+						return;
+					}
+					xmlHttp.send(postData);
+				}
+			} catch (ex) {
+				var errMsg = "AjaxAppender.append: error sending log message to " + url;
+				handleError(errMsg, ex);
+				isSupported = false;
+				if (failCallback) {
+					failCallback(errMsg + ". Details: " + getExceptionStringRep(ex));
+				}
+			}
+		}
+
+		this.append = function(loggingEvent) {
+			if (isSupported) {
+				if (!initialized) {
+					init();
+				}
+				queuedLoggingEvents.push(loggingEvent);
+				var actualBatchSize = this.getLayout().allowBatching() ? batchSize : 1;
+
+				if (queuedLoggingEvents.length >= actualBatchSize) {
+					var currentLoggingEvent;
+					var batchedLoggingEvents = [];
+					while ((currentLoggingEvent = queuedLoggingEvents.shift())) {
+						batchedLoggingEvents.push(currentLoggingEvent);
+					}
+					// Queue this batch of log entries
+					queuedRequests.push(batchedLoggingEvents);
+
+					// If using a timer, the queue of requests will be processed by the
+					// timer function, so nothing needs to be done here.
+					if (!timed && (!waitForResponse || (waitForResponse && !sending))) {
+						sendAll();
+					}
+				}
+			}
+		};
+
+		function init() {
+			initialized = true;
+			// Add unload event to send outstanding messages
+			if (sendAllOnUnload) {
+				var oldBeforeUnload = window.onbeforeunload;
+				window.onbeforeunload = function() {
+					if (oldBeforeUnload) {
+						oldBeforeUnload();
+					}
+					if (sendAllRemaining()) {
+						return "Sending log messages";
+					}
+				};
+			}
+			// Start timer
+			if (timed) {
+				scheduleSending();
+			}
+		}
+	}
+
+	AjaxAppender.prototype = new Appender();
+
+	AjaxAppender.prototype.defaults = {
+		waitForResponse: false,
+		timed: false,
+		timerInterval: 1000,
+		batchSize: 1,
+		sendAllOnUnload: false,
+		requestSuccessCallback: null,
+		failCallback: null,
+		postVarName: "data",
+		contentType: "application/x-www-form-urlencoded"
+	};
+
+	AjaxAppender.prototype.layout = new HttpPostDataLayout();
+
+	AjaxAppender.prototype.toString = function() {
+		return "AjaxAppender";
+	};
+
+	log4javascript.AjaxAppender = AjaxAppender;
+
+	/* ---------------------------------------------------------------------- */
+	// Main load
+
+   log4javascript.setDocumentReady = function() {
+       pageLoaded = true;
+       log4javascript.dispatchEvent("load", {});
+   };
+
+    if (window.addEventListener) {
+        window.addEventListener("load", log4javascript.setDocumentReady, false);
+    } else if (window.attachEvent) {
+        window.attachEvent("onload", log4javascript.setDocumentReady);
+    } else {
+        var oldOnload = window.onload;
+        if (typeof window.onload != "function") {
+            window.onload = log4javascript.setDocumentReady;
+        } else {
+            window.onload = function(evt) {
+                if (oldOnload) {
+                    oldOnload(evt);
+                }
+                log4javascript.setDocumentReady();
+            };
+        }
+    }
+
+    // Ensure that the log4javascript object is available in the window. This
+    // is necessary for log4javascript to be available in IE if loaded using
+    // Dojo's module system
+    window.log4javascript = log4javascript;
+
+    return log4javascript;
+})();
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_uncompressed.js
new file mode 100644
index 0000000..a644e3b
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/log4javascript_uncompressed.js
@@ -0,0 +1,5879 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * log4javascript
+ *
+ * log4javascript is a logging framework for JavaScript based on log4j
+ * for Java. This file contains all core log4javascript code and is the only
+ * file required to use log4javascript, unless you require support for
+ * document.domain, in which case you will also need console.html, which must be
+ * stored in the same directory as the main log4javascript.js file.
+ *
+ * Author: Tim Down <tim@log4javascript.org>
+ * Version: 1.4.6
+ * Edition: log4javascript
+ * Build date: 19 March 2013
+ * Website: http://log4javascript.org
+ */
+
+/* -------------------------------------------------------------------------- */
+// Array-related stuff
+
+// Next three methods are solely for IE5, which is missing them
+if (!Array.prototype.push) {
+	Array.prototype.push = function() {
+		for (var i = 0, len = arguments.length; i < len; i++){
+			this[this.length] = arguments[i];
+		}
+		return this.length;
+	};
+}
+
+if (!Array.prototype.shift) {
+	Array.prototype.shift = function() {
+		if (this.length > 0) {
+			var firstItem = this[0];
+			for (var i = 0, len = this.length - 1; i < len; i++) {
+				this[i] = this[i + 1];
+			}
+			this.length = this.length - 1;
+			return firstItem;
+		}
+	};
+}
+
+if (!Array.prototype.splice) {
+	Array.prototype.splice = function(startIndex, deleteCount) {
+		var itemsAfterDeleted = this.slice(startIndex + deleteCount);
+		var itemsDeleted = this.slice(startIndex, startIndex + deleteCount);
+		this.length = startIndex;
+		// Copy the arguments into a proper Array object
+		var argumentsArray = [];
+		for (var i = 0, len = arguments.length; i < len; i++) {
+			argumentsArray[i] = arguments[i];
+		}
+		var itemsToAppend = (argumentsArray.length > 2) ?
+			itemsAfterDeleted = argumentsArray.slice(2).concat(itemsAfterDeleted) : itemsAfterDeleted;
+		for (i = 0, len = itemsToAppend.length; i < len; i++) {
+			this.push(itemsToAppend[i]);
+		}
+		return itemsDeleted;
+	};
+}
+
+/* -------------------------------------------------------------------------- */
+
+var log4javascript = (function() {
+
+	function isUndefined(obj) {
+		return typeof obj == "undefined";
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// Custom event support
+
+	function EventSupport() {}
+
+	EventSupport.prototype = {
+		eventTypes: [],
+		eventListeners: {},
+		setEventTypes: function(eventTypesParam) {
+			if (eventTypesParam instanceof Array) {
+				this.eventTypes = eventTypesParam;
+				this.eventListeners = {};
+				for (var i = 0, len = this.eventTypes.length; i < len; i++) {
+					this.eventListeners[this.eventTypes[i]] = [];
+				}
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: setEventTypes: eventTypes parameter must be an Array");
+			}
+		},
+
+		addEventListener: function(eventType, listener) {
+			if (typeof listener == "function") {
+				if (!array_contains(this.eventTypes, eventType)) {
+					handleError("log4javascript.EventSupport [" + this + "]: addEventListener: no event called '" + eventType + "'");
+				}
+				this.eventListeners[eventType].push(listener);
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: addEventListener: listener must be a function");
+			}
+		},
+
+		removeEventListener: function(eventType, listener) {
+			if (typeof listener == "function") {
+				if (!array_contains(this.eventTypes, eventType)) {
+					handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: no event called '" + eventType + "'");
+				}
+				array_remove(this.eventListeners[eventType], listener);
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: removeEventListener: listener must be a function");
+			}
+		},
+
+		dispatchEvent: function(eventType, eventArgs) {
+			if (array_contains(this.eventTypes, eventType)) {
+				var listeners = this.eventListeners[eventType];
+				for (var i = 0, len = listeners.length; i < len; i++) {
+					listeners[i](this, eventType, eventArgs);
+				}
+			} else {
+				handleError("log4javascript.EventSupport [" + this + "]: dispatchEvent: no event called '" + eventType + "'");
+			}
+		}
+	};
+
+	/* -------------------------------------------------------------------------- */
+
+	var applicationStartDate = new Date();
+	var uniqueId = "log4javascript_" + applicationStartDate.getTime() + "_" +
+		Math.floor(Math.random() * 100000000);
+	var emptyFunction = function() {};
+	var newLine = "\r\n";
+	var pageLoaded = false;
+
+	// Create main log4javascript object; this will be assigned public properties
+	function Log4JavaScript() {}
+	Log4JavaScript.prototype = new EventSupport();
+
+	log4javascript = new Log4JavaScript();
+	log4javascript.version = "1.4.6";
+	log4javascript.edition = "log4javascript";
+
+	/* -------------------------------------------------------------------------- */
+	// Utility functions
+
+	function toStr(obj) {
+		if (obj && obj.toString) {
+			return obj.toString();
+		} else {
+			return String(obj);
+		}
+	}
+
+	function getExceptionMessage(ex) {
+		if (ex.message) {
+			return ex.message;
+		} else if (ex.description) {
+			return ex.description;
+		} else {
+			return toStr(ex);
+		}
+	}
+
+	// Gets the portion of the URL after the last slash
+	function getUrlFileName(url) {
+		var lastSlashIndex = Math.max(url.lastIndexOf("/"), url.lastIndexOf("\\"));
+		return url.substr(lastSlashIndex + 1);
+	}
+
+	// Returns a nicely formatted representation of an error
+	function getExceptionStringRep(ex) {
+		if (ex) {
+			var exStr = "Exception: " + getExceptionMessage(ex);
+			try {
+				if (ex.lineNumber) {
+					exStr += " on line number " + ex.lineNumber;
+				}
+				if (ex.fileName) {
+					exStr += " in file " + getUrlFileName(ex.fileName);
+				}
+			} catch (localEx) {
+				logLog.warn("Unable to obtain file and line information for error");
+			}
+			if (showStackTraces && ex.stack) {
+				exStr += newLine + "Stack trace:" + newLine + ex.stack;
+			}
+			return exStr;
+		}
+		return null;
+	}
+
+	function bool(obj) {
+		return Boolean(obj);
+	}
+
+	function trim(str) {
+		return str.replace(/^\s+/, "").replace(/\s+$/, "");
+	}
+
+	function splitIntoLines(text) {
+		// Ensure all line breaks are \n only
+		var text2 = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		return text2.split("\n");
+	}
+
+	var urlEncode = (typeof window.encodeURIComponent != "undefined") ?
+		function(str) {
+			return encodeURIComponent(str);
+		}: 
+		function(str) {
+			return escape(str).replace(/\+/g, "%2B").replace(/"/g, "%22").replace(/'/g, "%27").replace(/\//g, "%2F").replace(/=/g, "%3D");
+		};
+
+	var urlDecode = (typeof window.decodeURIComponent != "undefined") ?
+		function(str) {
+			return decodeURIComponent(str);
+		}: 
+		function(str) {
+			return unescape(str).replace(/%2B/g, "+").replace(/%22/g, "\"").replace(/%27/g, "'").replace(/%2F/g, "/").replace(/%3D/g, "=");
+		};
+
+	function array_remove(arr, val) {
+		var index = -1;
+		for (var i = 0, len = arr.length; i < len; i++) {
+			if (arr[i] === val) {
+				index = i;
+				break;
+			}
+		}
+		if (index >= 0) {
+			arr.splice(index, 1);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	function array_contains(arr, val) {
+		for(var i = 0, len = arr.length; i < len; i++) {
+			if (arr[i] == val) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	function extractBooleanFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			return bool(param);
+		}
+	}
+
+	function extractStringFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			return String(param);
+		}
+	}
+
+	function extractIntFromParam(param, defaultValue) {
+		if (isUndefined(param)) {
+			return defaultValue;
+		} else {
+			try {
+				var value = parseInt(param, 10);
+				return isNaN(value) ? defaultValue : value;
+			} catch (ex) {
+				logLog.warn("Invalid int param " + param, ex);
+				return defaultValue;
+			}
+		}
+	}
+
+	function extractFunctionFromParam(param, defaultValue) {
+		if (typeof param == "function") {
+			return param;
+		} else {
+			return defaultValue;
+		}
+	}
+
+	function isError(err) {
+		return (err instanceof Error);
+	}
+
+	if (!Function.prototype.apply){
+		Function.prototype.apply = function(obj, args) {
+			var methodName = "__apply__";
+			if (typeof obj[methodName] != "undefined") {
+				methodName += String(Math.random()).substr(2);
+			}
+			obj[methodName] = this;
+
+			var argsStrings = [];
+			for (var i = 0, len = args.length; i < len; i++) {
+				argsStrings[i] = "args[" + i + "]";
+			}
+			var script = "obj." + methodName + "(" + argsStrings.join(",") + ")";
+			var returnValue = eval(script);
+			delete obj[methodName];
+			return returnValue;
+		};
+	}
+
+	if (!Function.prototype.call){
+		Function.prototype.call = function(obj) {
+			var args = [];
+			for (var i = 1, len = arguments.length; i < len; i++) {
+				args[i - 1] = arguments[i];
+			}
+			return this.apply(obj, args);
+		};
+	}
+
+	function getListenersPropertyName(eventName) {
+		return "__log4javascript_listeners__" + eventName;
+	}
+
+	function addEvent(node, eventName, listener, useCapture, win) {
+		win = win ? win : window;
+		if (node.addEventListener) {
+			node.addEventListener(eventName, listener, useCapture);
+		} else if (node.attachEvent) {
+			node.attachEvent("on" + eventName, listener);
+		} else {
+			var propertyName = getListenersPropertyName(eventName);
+			if (!node[propertyName]) {
+				node[propertyName] = [];
+				// Set event handler
+				node["on" + eventName] = function(evt) {
+					evt = getEvent(evt, win);
+					var listenersPropertyName = getListenersPropertyName(eventName);
+
+					// Clone the array of listeners to leave the original untouched
+					var listeners = this[listenersPropertyName].concat([]);
+					var currentListener;
+
+					// Call each listener in turn
+					while ((currentListener = listeners.shift())) {
+						currentListener.call(this, evt);
+					}
+				};
+			}
+			node[propertyName].push(listener);
+		}
+	}
+
+	function removeEvent(node, eventName, listener, useCapture) {
+		if (node.removeEventListener) {
+			node.removeEventListener(eventName, listener, useCapture);
+		} else if (node.detachEvent) {
+			node.detachEvent("on" + eventName, listener);
+		} else {
+			var propertyName = getListenersPropertyName(eventName);
+			if (node[propertyName]) {
+				array_remove(node[propertyName], listener);
+			}
+		}
+	}
+
+	function getEvent(evt, win) {
+		win = win ? win : window;
+		return evt ? evt : win.event;
+	}
+
+	function stopEventPropagation(evt) {
+		if (evt.stopPropagation) {
+			evt.stopPropagation();
+		} else if (typeof evt.cancelBubble != "undefined") {
+			evt.cancelBubble = true;
+		}
+		evt.returnValue = false;
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// Simple logging for log4javascript itself
+
+	var logLog = {
+		quietMode: false,
+
+		debugMessages: [],
+
+		setQuietMode: function(quietMode) {
+			this.quietMode = bool(quietMode);
+		},
+
+		numberOfErrors: 0,
+
+		alertAllErrors: false,
+
+		setAlertAllErrors: function(alertAllErrors) {
+			this.alertAllErrors = alertAllErrors;
+		},
+
+		debug: function(message) {
+			this.debugMessages.push(message);
+		},
+
+		displayDebug: function() {
+			alert(this.debugMessages.join(newLine));
+		},
+
+		warn: function(message, exception) {
+		},
+
+		error: function(message, exception) {
+			if (++this.numberOfErrors == 1 || this.alertAllErrors) {
+				if (!this.quietMode) {
+					var alertMessage = "log4javascript error: " + message;
+					if (exception) {
+						alertMessage += newLine + newLine + "Original error: " + getExceptionStringRep(exception);
+					}
+					alert(alertMessage);
+				}
+			}
+		}
+	};
+	log4javascript.logLog = logLog;
+
+	log4javascript.setEventTypes(["load", "error"]);
+
+	function handleError(message, exception) {
+		logLog.error(message, exception);
+		log4javascript.dispatchEvent("error", { "message": message, "exception": exception });
+	}
+
+	log4javascript.handleError = handleError;
+
+	/* ---------------------------------------------------------------------- */
+
+	var enabled = !((typeof log4javascript_disabled != "undefined") &&
+					log4javascript_disabled);
+
+	log4javascript.setEnabled = function(enable) {
+		enabled = bool(enable);
+	};
+
+	log4javascript.isEnabled = function() {
+		return enabled;
+	};
+
+	var useTimeStampsInMilliseconds = true;
+
+	log4javascript.setTimeStampsInMilliseconds = function(timeStampsInMilliseconds) {
+		useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
+	};
+
+	log4javascript.isTimeStampsInMilliseconds = function() {
+		return useTimeStampsInMilliseconds;
+	};
+	
+
+	// This evaluates the given expression in the current scope, thus allowing
+	// scripts to access private variables. Particularly useful for testing
+	log4javascript.evalInScope = function(expr) {
+		return eval(expr);
+	};
+
+	var showStackTraces = false;
+
+	log4javascript.setShowStackTraces = function(show) {
+		showStackTraces = bool(show);
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Levels
+
+	var Level = function(level, name) {
+		this.level = level;
+		this.name = name;
+	};
+
+	Level.prototype = {
+		toString: function() {
+			return this.name;
+		},
+		equals: function(level) {
+			return this.level == level.level;
+		},
+		isGreaterOrEqual: function(level) {
+			return this.level >= level.level;
+		}
+	};
+
+	Level.ALL = new Level(Number.MIN_VALUE, "ALL");
+	Level.TRACE = new Level(10000, "TRACE");
+	Level.DEBUG = new Level(20000, "DEBUG");
+	Level.INFO = new Level(30000, "INFO");
+	Level.WARN = new Level(40000, "WARN");
+	Level.ERROR = new Level(50000, "ERROR");
+	Level.FATAL = new Level(60000, "FATAL");
+	Level.OFF = new Level(Number.MAX_VALUE, "OFF");
+
+	log4javascript.Level = Level;
+
+	/* ---------------------------------------------------------------------- */
+	// Timers
+
+	function Timer(name, level) {
+		this.name = name;
+		this.level = isUndefined(level) ? Level.INFO : level;
+		this.start = new Date();
+	}
+
+	Timer.prototype.getElapsedTime = function() {
+		return new Date().getTime() - this.start.getTime();
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Loggers
+
+	var anonymousLoggerName = "[anonymous]";
+	var defaultLoggerName = "[default]";
+	var nullLoggerName = "[null]";
+	var rootLoggerName = "root";
+
+	function Logger(name) {
+		this.name = name;
+		this.parent = null;
+		this.children = [];
+
+		var appenders = [];
+		var loggerLevel = null;
+		var isRoot = (this.name === rootLoggerName);
+		var isNull = (this.name === nullLoggerName);
+
+		var appenderCache = null;
+		var appenderCacheInvalidated = false;
+		
+		this.addChild = function(childLogger) {
+			this.children.push(childLogger);
+			childLogger.parent = this;
+			childLogger.invalidateAppenderCache();
+		};
+
+		// Additivity
+		var additive = true;
+		this.getAdditivity = function() {
+			return additive;
+		};
+
+		this.setAdditivity = function(additivity) {
+			var valueChanged = (additive != additivity);
+			additive = additivity;
+			if (valueChanged) {
+				this.invalidateAppenderCache();
+			}
+		};
+
+		// Create methods that use the appenders variable in this scope
+		this.addAppender = function(appender) {
+			if (isNull) {
+				handleError("Logger.addAppender: you may not add an appender to the null logger");
+			} else {
+				if (appender instanceof log4javascript.Appender) {
+					if (!array_contains(appenders, appender)) {
+						appenders.push(appender);
+						appender.setAddedToLogger(this);
+						this.invalidateAppenderCache();
+					}
+				} else {
+					handleError("Logger.addAppender: appender supplied ('" +
+						toStr(appender) + "') is not a subclass of Appender");
+				}
+			}
+		};
+
+		this.removeAppender = function(appender) {
+			array_remove(appenders, appender);
+			appender.setRemovedFromLogger(this);
+			this.invalidateAppenderCache();
+		};
+
+		this.removeAllAppenders = function() {
+			var appenderCount = appenders.length;
+			if (appenderCount > 0) {
+				for (var i = 0; i < appenderCount; i++) {
+					appenders[i].setRemovedFromLogger(this);
+				}
+				appenders.length = 0;
+				this.invalidateAppenderCache();
+			}
+		};
+
+		this.getEffectiveAppenders = function() {
+			if (appenderCache === null || appenderCacheInvalidated) {
+				// Build appender cache
+				var parentEffectiveAppenders = (isRoot || !this.getAdditivity()) ?
+					[] : this.parent.getEffectiveAppenders();
+				appenderCache = parentEffectiveAppenders.concat(appenders);
+				appenderCacheInvalidated = false;
+			}
+			return appenderCache;
+		};
+		
+		this.invalidateAppenderCache = function() {
+			appenderCacheInvalidated = true;
+			for (var i = 0, len = this.children.length; i < len; i++) {
+				this.children[i].invalidateAppenderCache();
+			}
+		};
+
+		this.log = function(level, params) {
+			if (enabled && level.isGreaterOrEqual(this.getEffectiveLevel())) {
+				// Check whether last param is an exception
+				var exception;
+				var finalParamIndex = params.length - 1;
+				var lastParam = params[finalParamIndex];
+				if (params.length > 1 && isError(lastParam)) {
+					exception = lastParam;
+					finalParamIndex--;
+				}
+
+				// Construct genuine array for the params
+				var messages = [];
+				for (var i = 0; i <= finalParamIndex; i++) {
+					messages[i] = params[i];
+				}
+
+				var loggingEvent = new LoggingEvent(
+					this, new Date(), level, messages, exception);
+
+				this.callAppenders(loggingEvent);
+			}
+		};
+
+		this.callAppenders = function(loggingEvent) {
+			var effectiveAppenders = this.getEffectiveAppenders();
+			for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+				effectiveAppenders[i].doAppend(loggingEvent);
+			}
+		};
+
+		this.setLevel = function(level) {
+			// Having a level of null on the root logger would be very bad.
+			if (isRoot && level === null) {
+				handleError("Logger.setLevel: you cannot set the level of the root logger to null");
+			} else if (level instanceof Level) {
+				loggerLevel = level;
+			} else {
+				handleError("Logger.setLevel: level supplied to logger " +
+					this.name + " is not an instance of log4javascript.Level");
+			}
+		};
+
+		this.getLevel = function() {
+			return loggerLevel;
+		};
+
+		this.getEffectiveLevel = function() {
+			for (var logger = this; logger !== null; logger = logger.parent) {
+				var level = logger.getLevel();
+				if (level !== null) {
+					return level;
+				}
+			}
+		};
+
+		this.group = function(name, initiallyExpanded) {
+			if (enabled) {
+				var effectiveAppenders = this.getEffectiveAppenders();
+				for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+					effectiveAppenders[i].group(name, initiallyExpanded);
+				}
+			}
+		};
+
+		this.groupEnd = function() {
+			if (enabled) {
+				var effectiveAppenders = this.getEffectiveAppenders();
+				for (var i = 0, len = effectiveAppenders.length; i < len; i++) {
+					effectiveAppenders[i].groupEnd();
+				}
+			}
+		};
+
+		var timers = {};
+
+		this.time = function(name, level) {
+			if (enabled) {
+				if (isUndefined(name)) {
+					handleError("Logger.time: a name for the timer must be supplied");
+				} else if (level && !(level instanceof Level)) {
+					handleError("Logger.time: level supplied to timer " +
+						name + " is not an instance of log4javascript.Level");
+				} else {
+					timers[name] = new Timer(name, level);
+				}
+			}
+		};
+
+		this.timeEnd = function(name) {
+			if (enabled) {
+				if (isUndefined(name)) {
+					handleError("Logger.timeEnd: a name for the timer must be supplied");
+				} else if (timers[name]) {
+					var timer = timers[name];
+					var milliseconds = timer.getElapsedTime();
+					this.log(timer.level, ["Timer " + toStr(name) + " completed in " + milliseconds + "ms"]);
+					delete timers[name];
+				} else {
+					logLog.warn("Logger.timeEnd: no timer found with name " + name);
+				}
+			}
+		};
+
+		this.assert = function(expr) {
+			if (enabled && !expr) {
+				var args = [];
+				for (var i = 1, len = arguments.length; i < len; i++) {
+					args.push(arguments[i]);
+				}
+				args = (args.length > 0) ? args : ["Assertion Failure"];
+				args.push(newLine);
+				args.push(expr);
+				this.log(Level.ERROR, args);
+			}
+		};
+
+		this.toString = function() {
+			return "Logger[" + this.name + "]";
+		};
+	}
+
+	Logger.prototype = {
+		trace: function() {
+			this.log(Level.TRACE, arguments);
+		},
+
+		debug: function() {
+			this.log(Level.DEBUG, arguments);
+		},
+
+		info: function() {
+			this.log(Level.INFO, arguments);
+		},
+
+		warn: function() {
+			this.log(Level.WARN, arguments);
+		},
+
+		error: function() {
+			this.log(Level.ERROR, arguments);
+		},
+
+		fatal: function() {
+			this.log(Level.FATAL, arguments);
+		},
+
+		isEnabledFor: function(level) {
+			return level.isGreaterOrEqual(this.getEffectiveLevel());
+		},
+
+		isTraceEnabled: function() {
+			return this.isEnabledFor(Level.TRACE);
+		},
+
+		isDebugEnabled: function() {
+			return this.isEnabledFor(Level.DEBUG);
+		},
+
+		isInfoEnabled: function() {
+			return this.isEnabledFor(Level.INFO);
+		},
+
+		isWarnEnabled: function() {
+			return this.isEnabledFor(Level.WARN);
+		},
+
+		isErrorEnabled: function() {
+			return this.isEnabledFor(Level.ERROR);
+		},
+
+		isFatalEnabled: function() {
+			return this.isEnabledFor(Level.FATAL);
+		}
+	};
+
+	Logger.prototype.trace.isEntryPoint = true;
+	Logger.prototype.debug.isEntryPoint = true;
+	Logger.prototype.info.isEntryPoint = true;
+	Logger.prototype.warn.isEntryPoint = true;
+	Logger.prototype.error.isEntryPoint = true;
+	Logger.prototype.fatal.isEntryPoint = true;
+
+	/* ---------------------------------------------------------------------- */
+	// Logger access methods
+
+	// Hashtable of loggers keyed by logger name
+	var loggers = {};
+	var loggerNames = [];
+
+	var ROOT_LOGGER_DEFAULT_LEVEL = Level.DEBUG;
+	var rootLogger = new Logger(rootLoggerName);
+	rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
+
+	log4javascript.getRootLogger = function() {
+		return rootLogger;
+	};
+
+	log4javascript.getLogger = function(loggerName) {
+		// Use default logger if loggerName is not specified or invalid
+		if (!(typeof loggerName == "string")) {
+			loggerName = anonymousLoggerName;
+			logLog.warn("log4javascript.getLogger: non-string logger name "	+
+				toStr(loggerName) + " supplied, returning anonymous logger");
+		}
+
+		// Do not allow retrieval of the root logger by name
+		if (loggerName == rootLoggerName) {
+			handleError("log4javascript.getLogger: root logger may not be obtained by name");
+		}
+
+		// Create the logger for this name if it doesn't already exist
+		if (!loggers[loggerName]) {
+			var logger = new Logger(loggerName);
+			loggers[loggerName] = logger;
+			loggerNames.push(loggerName);
+
+			// Set up parent logger, if it doesn't exist
+			var lastDotIndex = loggerName.lastIndexOf(".");
+			var parentLogger;
+			if (lastDotIndex > -1) {
+				var parentLoggerName = loggerName.substring(0, lastDotIndex);
+				parentLogger = log4javascript.getLogger(parentLoggerName); // Recursively sets up grandparents etc.
+			} else {
+				parentLogger = rootLogger;
+			}
+			parentLogger.addChild(logger);
+		}
+		return loggers[loggerName];
+	};
+
+	var defaultLogger = null;
+	log4javascript.getDefaultLogger = function() {
+		if (!defaultLogger) {
+			defaultLogger = log4javascript.getLogger(defaultLoggerName);
+			var a = new log4javascript.PopUpAppender();
+			defaultLogger.addAppender(a);
+		}
+		return defaultLogger;
+	};
+
+	var nullLogger = null;
+	log4javascript.getNullLogger = function() {
+		if (!nullLogger) {
+			nullLogger = new Logger(nullLoggerName);
+			nullLogger.setLevel(Level.OFF);
+		}
+		return nullLogger;
+	};
+
+	// Destroys all loggers
+	log4javascript.resetConfiguration = function() {
+		rootLogger.setLevel(ROOT_LOGGER_DEFAULT_LEVEL);
+		loggers = {};
+	};
+
+	/* ---------------------------------------------------------------------- */
+	// Logging events
+
+	var LoggingEvent = function(logger, timeStamp, level, messages,
+			exception) {
+		this.logger = logger;
+		this.timeStamp = timeStamp;
+		this.timeStampInMilliseconds = timeStamp.getTime();
+		this.timeStampInSeconds = Math.floor(this.timeStampInMilliseconds / 1000);
+		this.milliseconds = this.timeStamp.getMilliseconds();
+		this.level = level;
+		this.messages = messages;
+		this.exception = exception;
+	};
+
+	LoggingEvent.prototype = {
+		getThrowableStrRep: function() {
+			return this.exception ?
+				getExceptionStringRep(this.exception) : "";
+		},
+		getCombinedMessages: function() {
+			return (this.messages.length == 1) ? this.messages[0] :
+				   this.messages.join(newLine);
+		},
+		toString: function() {
+			return "LoggingEvent[" + this.level + "]";
+		}
+	};
+
+	log4javascript.LoggingEvent = LoggingEvent;
+
+	/* ---------------------------------------------------------------------- */
+	// Layout prototype
+
+	var Layout = function() {
+	};
+
+	Layout.prototype = {
+		defaults: {
+			loggerKey: "logger",
+			timeStampKey: "timestamp",
+			millisecondsKey: "milliseconds",
+			levelKey: "level",
+			messageKey: "message",
+			exceptionKey: "exception",
+			urlKey: "url"
+		},
+		loggerKey: "logger",
+		timeStampKey: "timestamp",
+		millisecondsKey: "milliseconds",
+		levelKey: "level",
+		messageKey: "message",
+		exceptionKey: "exception",
+		urlKey: "url",
+		batchHeader: "",
+		batchFooter: "",
+		batchSeparator: "",
+		returnsPostData: false,
+		overrideTimeStampsSetting: false,
+		useTimeStampsInMilliseconds: null,
+
+		format: function() {
+			handleError("Layout.format: layout supplied has no format() method");
+		},
+
+		ignoresThrowable: function() {
+			handleError("Layout.ignoresThrowable: layout supplied has no ignoresThrowable() method");
+		},
+
+		getContentType: function() {
+			return "text/plain";
+		},
+
+		allowBatching: function() {
+			return true;
+		},
+
+		setTimeStampsInMilliseconds: function(timeStampsInMilliseconds) {
+			this.overrideTimeStampsSetting = true;
+			this.useTimeStampsInMilliseconds = bool(timeStampsInMilliseconds);
+		},
+
+		isTimeStampsInMilliseconds: function() {
+			return this.overrideTimeStampsSetting ?
+				this.useTimeStampsInMilliseconds : useTimeStampsInMilliseconds;
+		},
+
+		getTimeStampValue: function(loggingEvent) {
+			return this.isTimeStampsInMilliseconds() ?
+				loggingEvent.timeStampInMilliseconds : loggingEvent.timeStampInSeconds;
+		},
+
+		getDataValues: function(loggingEvent, combineMessages) {
+			var dataValues = [
+				[this.loggerKey, loggingEvent.logger.name],
+				[this.timeStampKey, this.getTimeStampValue(loggingEvent)],
+				[this.levelKey, loggingEvent.level.name],
+				[this.urlKey, window.location.href],
+				[this.messageKey, combineMessages ? loggingEvent.getCombinedMessages() : loggingEvent.messages]
+			];
+			if (!this.isTimeStampsInMilliseconds()) {
+				dataValues.push([this.millisecondsKey, loggingEvent.milliseconds]);
+			}
+			if (loggingEvent.exception) {
+				dataValues.push([this.exceptionKey, getExceptionStringRep(loggingEvent.exception)]);
+			}
+			if (this.hasCustomFields()) {
+				for (var i = 0, len = this.customFields.length; i < len; i++) {
+					var val = this.customFields[i].value;
+
+					// Check if the value is a function. If so, execute it, passing it the
+					// current layout and the logging event
+					if (typeof val === "function") {
+						val = val(this, loggingEvent);
+					}
+					dataValues.push([this.customFields[i].name, val]);
+				}
+			}
+			return dataValues;
+		},
+
+		setKeys: function(loggerKey, timeStampKey, levelKey, messageKey,
+				exceptionKey, urlKey, millisecondsKey) {
+			this.loggerKey = extractStringFromParam(loggerKey, this.defaults.loggerKey);
+			this.timeStampKey = extractStringFromParam(timeStampKey, this.defaults.timeStampKey);
+			this.levelKey = extractStringFromParam(levelKey, this.defaults.levelKey);
+			this.messageKey = extractStringFromParam(messageKey, this.defaults.messageKey);
+			this.exceptionKey = extractStringFromParam(exceptionKey, this.defaults.exceptionKey);
+			this.urlKey = extractStringFromParam(urlKey, this.defaults.urlKey);
+			this.millisecondsKey = extractStringFromParam(millisecondsKey, this.defaults.millisecondsKey);
+		},
+
+		setCustomField: function(name, value) {
+			var fieldUpdated = false;
+			for (var i = 0, len = this.customFields.length; i < len; i++) {
+				if (this.customFields[i].name === name) {
+					this.customFields[i].value = value;
+					fieldUpdated = true;
+				}
+			}
+			if (!fieldUpdated) {
+				this.customFields.push({"name": name, "value": value});
+			}
+		},
+
+		hasCustomFields: function() {
+			return (this.customFields.length > 0);
+		},
+
+		toString: function() {
+			handleError("Layout.toString: all layouts must override this method");
+		}
+	};
+
+	log4javascript.Layout = Layout;
+
+	/* ---------------------------------------------------------------------- */
+	// Appender prototype
+
+	var Appender = function() {};
+
+	Appender.prototype = new EventSupport();
+
+	Appender.prototype.layout = new PatternLayout();
+	Appender.prototype.threshold = Level.ALL;
+	Appender.prototype.loggers = [];
+
+	// Performs threshold checks before delegating actual logging to the
+	// subclass's specific append method.
+	Appender.prototype.doAppend = function(loggingEvent) {
+		if (enabled && loggingEvent.level.level >= this.threshold.level) {
+			this.append(loggingEvent);
+		}
+	};
+
+	Appender.prototype.append = function(loggingEvent) {};
+
+	Appender.prototype.setLayout = function(layout) {
+		if (layout instanceof Layout) {
+			this.layout = layout;
+		} else {
+			handleError("Appender.setLayout: layout supplied to " +
+				this.toString() + " is not a subclass of Layout");
+		}
+	};
+
+	Appender.prototype.getLayout = function() {
+		return this.layout;
+	};
+
+	Appender.prototype.setThreshold = function(threshold) {
+		if (threshold instanceof Level) {
+			this.threshold = threshold;
+		} else {
+			handleError("Appender.setThreshold: threshold supplied to " +
+				this.toString() + " is not a subclass of Level");
+		}
+	};
+
+	Appender.prototype.getThreshold = function() {
+		return this.threshold;
+	};
+
+	Appender.prototype.setAddedToLogger = function(logger) {
+		this.loggers.push(logger);
+	};
+
+	Appender.prototype.setRemovedFromLogger = function(logger) {
+		array_remove(this.loggers, logger);
+	};
+
+	Appender.prototype.group = emptyFunction;
+	Appender.prototype.groupEnd = emptyFunction;
+
+	Appender.prototype.toString = function() {
+		handleError("Appender.toString: all appenders must override this method");
+	};
+
+	log4javascript.Appender = Appender;
+
+	/* ---------------------------------------------------------------------- */
+	// SimpleLayout 
+
+	function SimpleLayout() {
+		this.customFields = [];
+	}
+
+	SimpleLayout.prototype = new Layout();
+
+	SimpleLayout.prototype.format = function(loggingEvent) {
+		return loggingEvent.level.name + " - " + loggingEvent.getCombinedMessages();
+	};
+
+	SimpleLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	SimpleLayout.prototype.toString = function() {
+	    return "SimpleLayout";
+	};
+
+	log4javascript.SimpleLayout = SimpleLayout;
+	/* ----------------------------------------------------------------------- */
+	// NullLayout 
+
+	function NullLayout() {
+		this.customFields = [];
+	}
+
+	NullLayout.prototype = new Layout();
+
+	NullLayout.prototype.format = function(loggingEvent) {
+		return loggingEvent.messages;
+	};
+
+	NullLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	NullLayout.prototype.toString = function() {
+	    return "NullLayout";
+	};
+
+	log4javascript.NullLayout = NullLayout;
+/* ---------------------------------------------------------------------- */
+	// XmlLayout
+
+	function XmlLayout(combineMessages) {
+		this.combineMessages = extractBooleanFromParam(combineMessages, true);
+		this.customFields = [];
+	}
+
+	XmlLayout.prototype = new Layout();
+
+	XmlLayout.prototype.isCombinedMessages = function() {
+		return this.combineMessages;
+	};
+
+	XmlLayout.prototype.getContentType = function() {
+		return "text/xml";
+	};
+
+	XmlLayout.prototype.escapeCdata = function(str) {
+		return str.replace(/\]\]>/, "]]>]]&gt;<![CDATA[");
+	};
+
+	XmlLayout.prototype.format = function(loggingEvent) {
+		var layout = this;
+		var i, len;
+		function formatMessage(message) {
+			message = (typeof message === "string") ? message : toStr(message);
+			return "<log4javascript:message><![CDATA[" +
+				layout.escapeCdata(message) + "]]></log4javascript:message>";
+		}
+
+		var str = "<log4javascript:event logger=\"" + loggingEvent.logger.name +
+			"\" timestamp=\"" + this.getTimeStampValue(loggingEvent) + "\"";
+		if (!this.isTimeStampsInMilliseconds()) {
+			str += " milliseconds=\"" + loggingEvent.milliseconds + "\"";
+		}
+		str += " level=\"" + loggingEvent.level.name + "\">" + newLine;
+		if (this.combineMessages) {
+			str += formatMessage(loggingEvent.getCombinedMessages());
+		} else {
+			str += "<log4javascript:messages>" + newLine;
+			for (i = 0, len = loggingEvent.messages.length; i < len; i++) {
+				str += formatMessage(loggingEvent.messages[i]) + newLine;
+			}
+			str += "</log4javascript:messages>" + newLine;
+		}
+		if (this.hasCustomFields()) {
+			for (i = 0, len = this.customFields.length; i < len; i++) {
+				str += "<log4javascript:customfield name=\"" +
+					this.customFields[i].name + "\"><![CDATA[" +
+					this.customFields[i].value.toString() +
+					"]]></log4javascript:customfield>" + newLine;
+			}
+		}
+		if (loggingEvent.exception) {
+			str += "<log4javascript:exception><![CDATA[" +
+				getExceptionStringRep(loggingEvent.exception) +
+				"]]></log4javascript:exception>" + newLine;
+		}
+		str += "</log4javascript:event>" + newLine + newLine;
+		return str;
+	};
+
+	XmlLayout.prototype.ignoresThrowable = function() {
+	    return false;
+	};
+
+	XmlLayout.prototype.toString = function() {
+	    return "XmlLayout";
+	};
+
+	log4javascript.XmlLayout = XmlLayout;
+	/* ---------------------------------------------------------------------- */
+	// JsonLayout related
+
+	function escapeNewLines(str) {
+		return str.replace(/\r\n|\r|\n/g, "\\r\\n");
+	}
+
+	function JsonLayout(readable, combineMessages) {
+		this.readable = extractBooleanFromParam(readable, false);
+		this.combineMessages = extractBooleanFromParam(combineMessages, true);
+		this.batchHeader = this.readable ? "[" + newLine : "[";
+		this.batchFooter = this.readable ? "]" + newLine : "]";
+		this.batchSeparator = this.readable ? "," + newLine : ",";
+		this.setKeys();
+		this.colon = this.readable ? ": " : ":";
+		this.tab = this.readable ? "\t" : "";
+		this.lineBreak = this.readable ? newLine : "";
+		this.customFields = [];
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// JsonLayout
+
+	JsonLayout.prototype = new Layout();
+
+	JsonLayout.prototype.isReadable = function() {
+		return this.readable;
+	};
+
+	JsonLayout.prototype.isCombinedMessages = function() {
+		return this.combineMessages;
+	};
+
+    JsonLayout.prototype.format = function(loggingEvent) {
+        var layout = this;
+        var dataValues = this.getDataValues(loggingEvent, this.combineMessages);
+        var str = "{" + this.lineBreak;
+        var i, len;
+
+        function formatValue(val, prefix, expand) {
+            // Check the type of the data value to decide whether quotation marks
+            // or expansion are required
+            var formattedValue;
+            var valType = typeof val;
+            if (val instanceof Date) {
+                formattedValue = String(val.getTime());
+            } else if (expand && (val instanceof Array)) {
+                formattedValue = "[" + layout.lineBreak;
+                for (var i = 0, len = val.length; i < len; i++) {
+                    var childPrefix = prefix + layout.tab;
+                    formattedValue += childPrefix + formatValue(val[i], childPrefix, false);
+                    if (i < val.length - 1) {
+                        formattedValue += ",";
+                    }
+                    formattedValue += layout.lineBreak;
+                }
+                formattedValue += prefix + "]";
+            } else if (valType !== "number" && valType !== "boolean") {
+                formattedValue = "\"" + escapeNewLines(toStr(val).replace(/\"/g, "\\\"")) + "\"";
+            } else {
+                formattedValue = val;
+            }
+            return formattedValue;
+        }
+
+        for (i = 0, len = dataValues.length - 1; i <= len; i++) {
+            str += this.tab + "\"" + dataValues[i][0] + "\"" + this.colon + formatValue(dataValues[i][1], this.tab, true);
+            if (i < len) {
+                str += ",";
+            }
+            str += this.lineBreak;
+        }
+
+        str += "}" + this.lineBreak;
+        return str;
+    };
+
+	JsonLayout.prototype.ignoresThrowable = function() {
+	    return false;
+	};
+
+	JsonLayout.prototype.toString = function() {
+	    return "JsonLayout";
+	};
+
+	JsonLayout.prototype.getContentType = function() {
+		return "application/json";
+	};
+
+	log4javascript.JsonLayout = JsonLayout;
+	/* ---------------------------------------------------------------------- */
+	// HttpPostDataLayout
+
+	function HttpPostDataLayout() {
+		this.setKeys();
+		this.customFields = [];
+		this.returnsPostData = true;
+	}
+
+	HttpPostDataLayout.prototype = new Layout();
+
+	// Disable batching
+	HttpPostDataLayout.prototype.allowBatching = function() {
+		return false;
+	};
+
+	HttpPostDataLayout.prototype.format = function(loggingEvent) {
+		var dataValues = this.getDataValues(loggingEvent);
+		var queryBits = [];
+		for (var i = 0, len = dataValues.length; i < len; i++) {
+			var val = (dataValues[i][1] instanceof Date) ?
+				String(dataValues[i][1].getTime()) : dataValues[i][1];
+			queryBits.push(urlEncode(dataValues[i][0]) + "=" + urlEncode(val));
+		}
+		return queryBits.join("&");
+	};
+
+	HttpPostDataLayout.prototype.ignoresThrowable = function(loggingEvent) {
+	    return false;
+	};
+
+	HttpPostDataLayout.prototype.toString = function() {
+	    return "HttpPostDataLayout";
+	};
+
+	log4javascript.HttpPostDataLayout = HttpPostDataLayout;
+	/* ---------------------------------------------------------------------- */
+	// formatObjectExpansion
+
+	function formatObjectExpansion(obj, depth, indentation) {
+		var objectsExpanded = [];
+
+		function doFormat(obj, depth, indentation) {
+			var i, j, len, childDepth, childIndentation, childLines, expansion,
+				childExpansion;
+
+			if (!indentation) {
+				indentation = "";
+			}
+
+			function formatString(text) {
+				var lines = splitIntoLines(text);
+				for (var j = 1, jLen = lines.length; j < jLen; j++) {
+					lines[j] = indentation + lines[j];
+				}
+				return lines.join(newLine);
+			}
+
+			if (obj === null) {
+				return "null";
+			} else if (typeof obj == "undefined") {
+				return "undefined";
+			} else if (typeof obj == "string") {
+				return formatString(obj);
+			} else if (typeof obj == "object" && array_contains(objectsExpanded, obj)) {
+				try {
+					expansion = toStr(obj);
+				} catch (ex) {
+					expansion = "Error formatting property. Details: " + getExceptionStringRep(ex);
+				}
+				return expansion + " [already expanded]";
+			} else if ((obj instanceof Array) && depth > 0) {
+				objectsExpanded.push(obj);
+				expansion = "[" + newLine;
+				childDepth = depth - 1;
+				childIndentation = indentation + "  ";
+				childLines = [];
+				for (i = 0, len = obj.length; i < len; i++) {
+					try {
+						childExpansion = doFormat(obj[i], childDepth, childIndentation);
+						childLines.push(childIndentation + childExpansion);
+					} catch (ex) {
+						childLines.push(childIndentation + "Error formatting array member. Details: " +
+							getExceptionStringRep(ex) + "");
+					}
+				}
+				expansion += childLines.join("," + newLine) + newLine + indentation + "]";
+				return expansion;
+            } else if (Object.prototype.toString.call(obj) == "[object Date]") {
+                return obj.toString();
+			} else if (typeof obj == "object" && depth > 0) {
+				objectsExpanded.push(obj);
+				expansion = "{" + newLine;
+				childDepth = depth - 1;
+				childIndentation = indentation + "  ";
+				childLines = [];
+				for (i in obj) {
+					try {
+						childExpansion = doFormat(obj[i], childDepth, childIndentation);
+						childLines.push(childIndentation + i + ": " + childExpansion);
+					} catch (ex) {
+						childLines.push(childIndentation + i + ": Error formatting property. Details: " +
+							getExceptionStringRep(ex));
+					}
+				}
+				expansion += childLines.join("," + newLine) + newLine + indentation + "}";
+				return expansion;
+			} else {
+				return formatString(toStr(obj));
+			}
+		}
+		return doFormat(obj, depth, indentation);
+	}
+	/* ---------------------------------------------------------------------- */
+	// Date-related stuff
+
+	var SimpleDateFormat;
+
+	(function() {
+		var regex = /('[^']*')|(G+|y+|M+|w+|W+|D+|d+|F+|E+|a+|H+|k+|K+|h+|m+|s+|S+|Z+)|([a-zA-Z]+)|([^a-zA-Z']+)/;
+		var monthNames = ["January", "February", "March", "April", "May", "June",
+			"July", "August", "September", "October", "November", "December"];
+		var dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+		var TEXT2 = 0, TEXT3 = 1, NUMBER = 2, YEAR = 3, MONTH = 4, TIMEZONE = 5;
+		var types = {
+			G : TEXT2,
+			y : YEAR,
+			M : MONTH,
+			w : NUMBER,
+			W : NUMBER,
+			D : NUMBER,
+			d : NUMBER,
+			F : NUMBER,
+			E : TEXT3,
+			a : TEXT2,
+			H : NUMBER,
+			k : NUMBER,
+			K : NUMBER,
+			h : NUMBER,
+			m : NUMBER,
+			s : NUMBER,
+			S : NUMBER,
+			Z : TIMEZONE
+		};
+		var ONE_DAY = 24 * 60 * 60 * 1000;
+		var ONE_WEEK = 7 * ONE_DAY;
+		var DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK = 1;
+
+		var newDateAtMidnight = function(year, month, day) {
+			var d = new Date(year, month, day, 0, 0, 0);
+			d.setMilliseconds(0);
+			return d;
+		};
+
+		Date.prototype.getDifference = function(date) {
+			return this.getTime() - date.getTime();
+		};
+
+		Date.prototype.isBefore = function(d) {
+			return this.getTime() < d.getTime();
+		};
+
+		Date.prototype.getUTCTime = function() {
+			return Date.UTC(this.getFullYear(), this.getMonth(), this.getDate(), this.getHours(), this.getMinutes(),
+					this.getSeconds(), this.getMilliseconds());
+		};
+
+		Date.prototype.getTimeSince = function(d) {
+			return this.getUTCTime() - d.getUTCTime();
+		};
+
+		Date.prototype.getPreviousSunday = function() {
+			// Using midday avoids any possibility of DST messing things up
+			var midday = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 12, 0, 0);
+			var previousSunday = new Date(midday.getTime() - this.getDay() * ONE_DAY);
+			return newDateAtMidnight(previousSunday.getFullYear(), previousSunday.getMonth(),
+					previousSunday.getDate());
+		};
+
+		Date.prototype.getWeekInYear = function(minimalDaysInFirstWeek) {
+			if (isUndefined(this.minimalDaysInFirstWeek)) {
+				minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
+			}
+			var previousSunday = this.getPreviousSunday();
+			var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
+			var numberOfSundays = previousSunday.isBefore(startOfYear) ?
+				0 : 1 + Math.floor(previousSunday.getTimeSince(startOfYear) / ONE_WEEK);
+			var numberOfDaysInFirstWeek =  7 - startOfYear.getDay();
+			var weekInYear = numberOfSundays;
+			if (numberOfDaysInFirstWeek < minimalDaysInFirstWeek) {
+				weekInYear--;
+			}
+			return weekInYear;
+		};
+
+		Date.prototype.getWeekInMonth = function(minimalDaysInFirstWeek) {
+			if (isUndefined(this.minimalDaysInFirstWeek)) {
+				minimalDaysInFirstWeek = DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK;
+			}
+			var previousSunday = this.getPreviousSunday();
+			var startOfMonth = newDateAtMidnight(this.getFullYear(), this.getMonth(), 1);
+			var numberOfSundays = previousSunday.isBefore(startOfMonth) ?
+				0 : 1 + Math.floor(previousSunday.getTimeSince(startOfMonth) / ONE_WEEK);
+			var numberOfDaysInFirstWeek =  7 - startOfMonth.getDay();
+			var weekInMonth = numberOfSundays;
+			if (numberOfDaysInFirstWeek >= minimalDaysInFirstWeek) {
+				weekInMonth++;
+			}
+			return weekInMonth;
+		};
+
+		Date.prototype.getDayInYear = function() {
+			var startOfYear = newDateAtMidnight(this.getFullYear(), 0, 1);
+			return 1 + Math.floor(this.getTimeSince(startOfYear) / ONE_DAY);
+		};
+
+		/* ------------------------------------------------------------------ */
+
+		SimpleDateFormat = function(formatString) {
+			this.formatString = formatString;
+		};
+
+		/**
+		 * Sets the minimum number of days in a week in order for that week to
+		 * be considered as belonging to a particular month or year
+		 */
+		SimpleDateFormat.prototype.setMinimalDaysInFirstWeek = function(days) {
+			this.minimalDaysInFirstWeek = days;
+		};
+
+		SimpleDateFormat.prototype.getMinimalDaysInFirstWeek = function() {
+			return isUndefined(this.minimalDaysInFirstWeek)	?
+				DEFAULT_MINIMAL_DAYS_IN_FIRST_WEEK : this.minimalDaysInFirstWeek;
+		};
+
+		var padWithZeroes = function(str, len) {
+			while (str.length < len) {
+				str = "0" + str;
+			}
+			return str;
+		};
+
+		var formatText = function(data, numberOfLetters, minLength) {
+			return (numberOfLetters >= 4) ? data : data.substr(0, Math.max(minLength, numberOfLetters));
+		};
+
+		var formatNumber = function(data, numberOfLetters) {
+			var dataString = "" + data;
+			// Pad with 0s as necessary
+			return padWithZeroes(dataString, numberOfLetters);
+		};
+
+		SimpleDateFormat.prototype.format = function(date) {
+			var formattedString = "";
+			var result;
+			var searchString = this.formatString;
+			while ((result = regex.exec(searchString))) {
+				var quotedString = result[1];
+				var patternLetters = result[2];
+				var otherLetters = result[3];
+				var otherCharacters = result[4];
+
+				// If the pattern matched is quoted string, output the text between the quotes
+				if (quotedString) {
+					if (quotedString == "''") {
+						formattedString += "'";
+					} else {
+						formattedString += quotedString.substring(1, quotedString.length - 1);
+					}
+				} else if (otherLetters) {
+					// Swallow non-pattern letters by doing nothing here
+				} else if (otherCharacters) {
+					// Simply output other characters
+					formattedString += otherCharacters;
+				} else if (patternLetters) {
+					// Replace pattern letters
+					var patternLetter = patternLetters.charAt(0);
+					var numberOfLetters = patternLetters.length;
+					var rawData = "";
+					switch(patternLetter) {
+						case "G":
+							rawData = "AD";
+							break;
+						case "y":
+							rawData = date.getFullYear();
+							break;
+						case "M":
+							rawData = date.getMonth();
+							break;
+						case "w":
+							rawData = date.getWeekInYear(this.getMinimalDaysInFirstWeek());
+							break;
+						case "W":
+							rawData = date.getWeekInMonth(this.getMinimalDaysInFirstWeek());
+							break;
+						case "D":
+							rawData = date.getDayInYear();
+							break;
+						case "d":
+							rawData = date.getDate();
+							break;
+						case "F":
+							rawData = 1 + Math.floor((date.getDate() - 1) / 7);
+							break;
+						case "E":
+							rawData = dayNames[date.getDay()];
+							break;
+						case "a":
+							rawData = (date.getHours() >= 12) ? "PM" : "AM";
+							break;
+						case "H":
+							rawData = date.getHours();
+							break;
+						case "k":
+							rawData = date.getHours() || 24;
+							break;
+						case "K":
+							rawData = date.getHours() % 12;
+							break;
+						case "h":
+							rawData = (date.getHours() % 12) || 12;
+							break;
+						case "m":
+							rawData = date.getMinutes();
+							break;
+						case "s":
+							rawData = date.getSeconds();
+							break;
+						case "S":
+							rawData = date.getMilliseconds();
+							break;
+						case "Z":
+							rawData = date.getTimezoneOffset(); // This returns the number of minutes since GMT was this time.
+							break;
+					}
+					// Format the raw data depending on the type
+					switch(types[patternLetter]) {
+						case TEXT2:
+							formattedString += formatText(rawData, numberOfLetters, 2);
+							break;
+						case TEXT3:
+							formattedString += formatText(rawData, numberOfLetters, 3);
+							break;
+						case NUMBER:
+							formattedString += formatNumber(rawData, numberOfLetters);
+							break;
+						case YEAR:
+							if (numberOfLetters <= 3) {
+								// Output a 2-digit year
+								var dataString = "" + rawData;
+								formattedString += dataString.substr(2, 2);
+							} else {
+								formattedString += formatNumber(rawData, numberOfLetters);
+							}
+							break;
+						case MONTH:
+							if (numberOfLetters >= 3) {
+								formattedString += formatText(monthNames[rawData], numberOfLetters, numberOfLetters);
+							} else {
+								// NB. Months returned by getMonth are zero-based
+								formattedString += formatNumber(rawData + 1, numberOfLetters);
+							}
+							break;
+						case TIMEZONE:
+							var isPositive = (rawData > 0);
+							// The following line looks like a mistake but isn't
+							// because of the way getTimezoneOffset measures.
+							var prefix = isPositive ? "-" : "+";
+							var absData = Math.abs(rawData);
+
+							// Hours
+							var hours = "" + Math.floor(absData / 60);
+							hours = padWithZeroes(hours, 2);
+							// Minutes
+							var minutes = "" + (absData % 60);
+							minutes = padWithZeroes(minutes, 2);
+
+							formattedString += prefix + hours + minutes;
+							break;
+					}
+				}
+				searchString = searchString.substr(result.index + result[0].length);
+			}
+			return formattedString;
+		};
+	})();
+
+	log4javascript.SimpleDateFormat = SimpleDateFormat;
+
+	/* ---------------------------------------------------------------------- */
+	// PatternLayout
+
+	function PatternLayout(pattern) {
+		if (pattern) {
+			this.pattern = pattern;
+		} else {
+			this.pattern = PatternLayout.DEFAULT_CONVERSION_PATTERN;
+		}
+		this.customFields = [];
+	}
+
+	PatternLayout.TTCC_CONVERSION_PATTERN = "%r %p %c - %m%n";
+	PatternLayout.DEFAULT_CONVERSION_PATTERN = "%m%n";
+	PatternLayout.ISO8601_DATEFORMAT = "yyyy-MM-dd HH:mm:ss,SSS";
+	PatternLayout.DATETIME_DATEFORMAT = "dd MMM yyyy HH:mm:ss,SSS";
+	PatternLayout.ABSOLUTETIME_DATEFORMAT = "HH:mm:ss,SSS";
+
+	PatternLayout.prototype = new Layout();
+
+	PatternLayout.prototype.format = function(loggingEvent) {
+		var regex = /%(-?[0-9]+)?(\.?[0-9]+)?([acdfmMnpr%])(\{([^\}]+)\})?|([^%]+)/;
+		var formattedString = "";
+		var result;
+		var searchString = this.pattern;
+
+		// Cannot use regex global flag since it doesn't work with exec in IE5
+		while ((result = regex.exec(searchString))) {
+			var matchedString = result[0];
+			var padding = result[1];
+			var truncation = result[2];
+			var conversionCharacter = result[3];
+			var specifier = result[5];
+			var text = result[6];
+
+			// Check if the pattern matched was just normal text
+			if (text) {
+				formattedString += "" + text;
+			} else {
+				// Create a raw replacement string based on the conversion
+				// character and specifier
+				var replacement = "";
+				switch(conversionCharacter) {
+					case "a": // Array of messages
+					case "m": // Message
+						var depth = 0;
+						if (specifier) {
+							depth = parseInt(specifier, 10);
+							if (isNaN(depth)) {
+								handleError("PatternLayout.format: invalid specifier '" +
+									specifier + "' for conversion character '" + conversionCharacter +
+									"' - should be a number");
+								depth = 0;
+							}
+						}
+						var messages = (conversionCharacter === "a") ? loggingEvent.messages[0] : loggingEvent.messages;
+						for (var i = 0, len = messages.length; i < len; i++) {
+							if (i > 0 && (replacement.charAt(replacement.length - 1) !== " ")) {
+								replacement += " ";
+							}
+							if (depth === 0) {
+								replacement += messages[i];
+							} else {
+								replacement += formatObjectExpansion(messages[i], depth);
+							}
+						}
+						break;
+					case "c": // Logger name
+						var loggerName = loggingEvent.logger.name;
+						if (specifier) {
+							var precision = parseInt(specifier, 10);
+							var loggerNameBits = loggingEvent.logger.name.split(".");
+							if (precision >= loggerNameBits.length) {
+								replacement = loggerName;
+							} else {
+								replacement = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
+							}
+						} else {
+							replacement = loggerName;
+						}
+						break;
+					case "d": // Date
+						var dateFormat = PatternLayout.ISO8601_DATEFORMAT;
+						if (specifier) {
+							dateFormat = specifier;
+							// Pick up special cases
+							if (dateFormat == "ISO8601") {
+								dateFormat = PatternLayout.ISO8601_DATEFORMAT;
+							} else if (dateFormat == "ABSOLUTE") {
+								dateFormat = PatternLayout.ABSOLUTETIME_DATEFORMAT;
+							} else if (dateFormat == "DATE") {
+								dateFormat = PatternLayout.DATETIME_DATEFORMAT;
+							}
+						}
+						// Format the date
+						replacement = (new SimpleDateFormat(dateFormat)).format(loggingEvent.timeStamp);
+						break;
+					case "f": // Custom field
+						if (this.hasCustomFields()) {
+							var fieldIndex = 0;
+							if (specifier) {
+								fieldIndex = parseInt(specifier, 10);
+								if (isNaN(fieldIndex)) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - should be a number");
+								} else if (fieldIndex === 0) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - must be greater than zero");
+								} else if (fieldIndex > this.customFields.length) {
+									handleError("PatternLayout.format: invalid specifier '" +
+										specifier + "' for conversion character 'f' - there aren't that many custom fields");
+								} else {
+									fieldIndex = fieldIndex - 1;
+								}
+							}
+                            var val = this.customFields[fieldIndex].value;
+                            if (typeof val == "function") {
+                                val = val(this, loggingEvent);
+                            }
+                            replacement = val;
+						}
+						break;
+					case "n": // New line
+						replacement = newLine;
+						break;
+					case "p": // Level
+						replacement = loggingEvent.level.name;
+						break;
+					case "r": // Milliseconds since log4javascript startup
+						replacement = "" + loggingEvent.timeStamp.getDifference(applicationStartDate);
+						break;
+					case "%": // Literal % sign
+						replacement = "%";
+						break;
+					default:
+						replacement = matchedString;
+						break;
+				}
+				// Format the replacement according to any padding or
+				// truncation specified
+				var l;
+
+				// First, truncation
+				if (truncation) {
+					l = parseInt(truncation.substr(1), 10);
+					var strLen = replacement.length;
+					if (l < strLen) {
+						replacement = replacement.substring(strLen - l, strLen);
+					}
+				}
+				// Next, padding
+				if (padding) {
+					if (padding.charAt(0) == "-") {
+						l = parseInt(padding.substr(1), 10);
+						// Right pad with spaces
+						while (replacement.length < l) {
+							replacement += " ";
+						}
+					} else {
+						l = parseInt(padding, 10);
+						// Left pad with spaces
+						while (replacement.length < l) {
+							replacement = " " + replacement;
+						}
+					}
+				}
+				formattedString += replacement;
+			}
+			searchString = searchString.substr(result.index + result[0].length);
+		}
+		return formattedString;
+	};
+
+	PatternLayout.prototype.ignoresThrowable = function() {
+	    return true;
+	};
+
+	PatternLayout.prototype.toString = function() {
+	    return "PatternLayout";
+	};
+
+	log4javascript.PatternLayout = PatternLayout;
+	/* ---------------------------------------------------------------------- */
+	// AlertAppender
+
+	function AlertAppender() {}
+
+	AlertAppender.prototype = new Appender();
+
+	AlertAppender.prototype.layout = new SimpleLayout();
+
+	AlertAppender.prototype.append = function(loggingEvent) {
+		var formattedMessage = this.getLayout().format(loggingEvent);
+		if (this.getLayout().ignoresThrowable()) {
+			formattedMessage += loggingEvent.getThrowableStrRep();
+		}
+		alert(formattedMessage);
+	};
+
+	AlertAppender.prototype.toString = function() {
+		return "AlertAppender";
+	};
+
+	log4javascript.AlertAppender = AlertAppender;
+	/* ---------------------------------------------------------------------- */
+	// BrowserConsoleAppender (only works in Opera and Safari and Firefox with
+	// Firebug extension)
+
+	function BrowserConsoleAppender() {}
+
+	BrowserConsoleAppender.prototype = new log4javascript.Appender();
+	BrowserConsoleAppender.prototype.layout = new NullLayout();
+	BrowserConsoleAppender.prototype.threshold = Level.DEBUG;
+
+	BrowserConsoleAppender.prototype.append = function(loggingEvent) {
+		var appender = this;
+
+		var getFormattedMessage = function() {
+			var layout = appender.getLayout();
+			var formattedMessage = layout.format(loggingEvent);
+			if (layout.ignoresThrowable() && loggingEvent.exception) {
+				formattedMessage += loggingEvent.getThrowableStrRep();
+			}
+			return formattedMessage;
+		};
+
+		if ((typeof opera != "undefined") && opera.postError) { // Opera
+			opera.postError(getFormattedMessage());
+		} else if (window.console && window.console.log) { // Safari and Firebug
+			var formattedMesage = getFormattedMessage();
+			// Log to Firebug using its logging methods or revert to the console.log
+			// method in Safari
+			if (window.console.debug && Level.DEBUG.isGreaterOrEqual(loggingEvent.level)) {
+				window.console.debug(formattedMesage);
+			} else if (window.console.info && Level.INFO.equals(loggingEvent.level)) {
+				window.console.info(formattedMesage);
+			} else if (window.console.warn && Level.WARN.equals(loggingEvent.level)) {
+				window.console.warn(formattedMesage);
+			} else if (window.console.error && loggingEvent.level.isGreaterOrEqual(Level.ERROR)) {
+				window.console.error(formattedMesage);
+			} else {
+				window.console.log(formattedMesage);
+			}
+		}
+	};
+
+	BrowserConsoleAppender.prototype.group = function(name) {
+		if (window.console && window.console.group) {
+			window.console.group(name);
+		}
+	};
+
+	BrowserConsoleAppender.prototype.groupEnd = function() {
+		if (window.console && window.console.groupEnd) {
+			window.console.groupEnd();
+		}
+	};
+
+	BrowserConsoleAppender.prototype.toString = function() {
+		return "BrowserConsoleAppender";
+	};
+
+	log4javascript.BrowserConsoleAppender = BrowserConsoleAppender;
+	/* ---------------------------------------------------------------------- */
+	// AjaxAppender related
+
+	var xmlHttpFactories = [
+		function() { return new XMLHttpRequest(); },
+		function() { return new ActiveXObject("Msxml2.XMLHTTP"); },
+		function() { return new ActiveXObject("Microsoft.XMLHTTP"); }
+	];
+
+	var getXmlHttp = function(errorHandler) {
+		// This is only run the first time; the value of getXmlHttp gets
+		// replaced with the factory that succeeds on the first run
+		var xmlHttp = null, factory;
+		for (var i = 0, len = xmlHttpFactories.length; i < len; i++) {
+			factory = xmlHttpFactories[i];
+			try {
+				xmlHttp = factory();
+				getXmlHttp = factory;
+				return xmlHttp;
+			} catch (e) {
+			}
+		}
+		// If we're here, all factories have failed, so throw an error
+		if (errorHandler) {
+			errorHandler();
+		} else {
+			handleError("getXmlHttp: unable to obtain XMLHttpRequest object");
+		}
+	};
+
+	function isHttpRequestSuccessful(xmlHttp) {
+		return isUndefined(xmlHttp.status) || xmlHttp.status === 0 ||
+			(xmlHttp.status >= 200 && xmlHttp.status < 300) ||
+			xmlHttp.status == 1223 /* Fix for IE */;
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// AjaxAppender
+
+	function AjaxAppender(url) {
+		var appender = this;
+		var isSupported = true;
+		if (!url) {
+			handleError("AjaxAppender: URL must be specified in constructor");
+			isSupported = false;
+		}
+
+		var timed = this.defaults.timed;
+		var waitForResponse = this.defaults.waitForResponse;
+		var batchSize = this.defaults.batchSize;
+		var timerInterval = this.defaults.timerInterval;
+		var requestSuccessCallback = this.defaults.requestSuccessCallback;
+		var failCallback = this.defaults.failCallback;
+		var postVarName = this.defaults.postVarName;
+		var sendAllOnUnload = this.defaults.sendAllOnUnload;
+		var contentType = this.defaults.contentType;
+		var sessionId = null;
+
+		var queuedLoggingEvents = [];
+		var queuedRequests = [];
+		var headers = [];
+		var sending = false;
+		var initialized = false;
+
+		// Configuration methods. The function scope is used to prevent
+		// direct alteration to the appender configuration properties.
+		function checkCanConfigure(configOptionName) {
+			if (initialized) {
+				handleError("AjaxAppender: configuration option '" +
+					configOptionName +
+					"' may not be set after the appender has been initialized");
+				return false;
+			}
+			return true;
+		}
+
+		this.getSessionId = function() { return sessionId; };
+		this.setSessionId = function(sessionIdParam) {
+			sessionId = extractStringFromParam(sessionIdParam, null);
+			this.layout.setCustomField("sessionid", sessionId);
+		};
+
+		this.setLayout = function(layoutParam) {
+			if (checkCanConfigure("layout")) {
+				this.layout = layoutParam;
+				// Set the session id as a custom field on the layout, if not already present
+				if (sessionId !== null) {
+					this.setSessionId(sessionId);
+				}
+			}
+		};
+
+		this.isTimed = function() { return timed; };
+		this.setTimed = function(timedParam) {
+			if (checkCanConfigure("timed")) {
+				timed = bool(timedParam);
+			}
+		};
+
+		this.getTimerInterval = function() { return timerInterval; };
+		this.setTimerInterval = function(timerIntervalParam) {
+			if (checkCanConfigure("timerInterval")) {
+				timerInterval = extractIntFromParam(timerIntervalParam, timerInterval);
+			}
+		};
+
+		this.isWaitForResponse = function() { return waitForResponse; };
+		this.setWaitForResponse = function(waitForResponseParam) {
+			if (checkCanConfigure("waitForResponse")) {
+				waitForResponse = bool(waitForResponseParam);
+			}
+		};
+
+		this.getBatchSize = function() { return batchSize; };
+		this.setBatchSize = function(batchSizeParam) {
+			if (checkCanConfigure("batchSize")) {
+				batchSize = extractIntFromParam(batchSizeParam, batchSize);
+			}
+		};
+
+		this.isSendAllOnUnload = function() { return sendAllOnUnload; };
+		this.setSendAllOnUnload = function(sendAllOnUnloadParam) {
+			if (checkCanConfigure("sendAllOnUnload")) {
+				sendAllOnUnload = extractBooleanFromParam(sendAllOnUnloadParam, sendAllOnUnload);
+			}
+		};
+
+		this.setRequestSuccessCallback = function(requestSuccessCallbackParam) {
+			requestSuccessCallback = extractFunctionFromParam(requestSuccessCallbackParam, requestSuccessCallback);
+		};
+
+		this.setFailCallback = function(failCallbackParam) {
+			failCallback = extractFunctionFromParam(failCallbackParam, failCallback);
+		};
+
+		this.getPostVarName = function() { return postVarName; };
+		this.setPostVarName = function(postVarNameParam) {
+			if (checkCanConfigure("postVarName")) {
+				postVarName = extractStringFromParam(postVarNameParam, postVarName);
+			}
+		};
+
+		this.getHeaders = function() { return headers; };
+		this.addHeader = function(name, value) {
+			if (name.toLowerCase() == "content-type") {
+				contentType = value;
+			} else {
+				headers.push( { name: name, value: value } );
+			}
+		};
+
+		// Internal functions
+		function sendAll() {
+			if (isSupported && enabled) {
+				sending = true;
+				var currentRequestBatch;
+				if (waitForResponse) {
+					// Send the first request then use this function as the callback once
+					// the response comes back
+					if (queuedRequests.length > 0) {
+						currentRequestBatch = queuedRequests.shift();
+						sendRequest(preparePostData(currentRequestBatch), sendAll);
+					} else {
+						sending = false;
+						if (timed) {
+							scheduleSending();
+						}
+					}
+				} else {
+					// Rattle off all the requests without waiting to see the response
+					while ((currentRequestBatch = queuedRequests.shift())) {
+						sendRequest(preparePostData(currentRequestBatch));
+					}
+					sending = false;
+					if (timed) {
+						scheduleSending();
+					}
+				}
+			}
+		}
+
+		this.sendAll = sendAll;
+
+		// Called when the window unloads. At this point we're past caring about
+		// waiting for responses or timers or incomplete batches - everything
+		// must go, now
+		function sendAllRemaining() {
+			var sendingAnything = false;
+			if (isSupported && enabled) {
+				// Create requests for everything left over, batched as normal
+				var actualBatchSize = appender.getLayout().allowBatching() ? batchSize : 1;
+				var currentLoggingEvent;
+				var batchedLoggingEvents = [];
+				while ((currentLoggingEvent = queuedLoggingEvents.shift())) {
+					batchedLoggingEvents.push(currentLoggingEvent);
+					if (queuedLoggingEvents.length >= actualBatchSize) {
+						// Queue this batch of log entries
+						queuedRequests.push(batchedLoggingEvents);
+						batchedLoggingEvents = [];
+					}
+				}
+				// If there's a partially completed batch, add it
+				if (batchedLoggingEvents.length > 0) {
+					queuedRequests.push(batchedLoggingEvents);
+				}
+				sendingAnything = (queuedRequests.length > 0);
+				waitForResponse = false;
+				timed = false;
+				sendAll();
+			}
+			return sendingAnything;
+		}
+
+		this.sendAllRemaining = sendAllRemaining;
+
+		function preparePostData(batchedLoggingEvents) {
+			// Format the logging events
+			var formattedMessages = [];
+			var currentLoggingEvent;
+			var postData = "";
+			while ((currentLoggingEvent = batchedLoggingEvents.shift())) {
+				var currentFormattedMessage = appender.getLayout().format(currentLoggingEvent);
+				if (appender.getLayout().ignoresThrowable()) {
+					currentFormattedMessage += currentLoggingEvent.getThrowableStrRep();
+				}
+				formattedMessages.push(currentFormattedMessage);
+			}
+			// Create the post data string
+			if (batchedLoggingEvents.length == 1) {
+				postData = formattedMessages.join("");
+			} else {
+				postData = appender.getLayout().batchHeader +
+					formattedMessages.join(appender.getLayout().batchSeparator) +
+					appender.getLayout().batchFooter;
+			}
+			if (contentType == appender.defaults.contentType) {
+				postData = appender.getLayout().returnsPostData ? postData :
+					urlEncode(postVarName) + "=" + urlEncode(postData);
+				// Add the layout name to the post data
+				if (postData.length > 0) {
+					postData += "&";
+				}
+				postData += "layout=" + urlEncode(appender.getLayout().toString());
+			}
+			return postData;
+		}
+
+		function scheduleSending() {
+			window.setTimeout(sendAll, timerInterval);
+		}
+
+		function xmlHttpErrorHandler() {
+			var msg = "AjaxAppender: could not create XMLHttpRequest object. AjaxAppender disabled";
+			handleError(msg);
+			isSupported = false;
+			if (failCallback) {
+				failCallback(msg);
+			}
+		}
+
+		function sendRequest(postData, successCallback) {
+			try {
+				var xmlHttp = getXmlHttp(xmlHttpErrorHandler);
+				if (isSupported) {
+					if (xmlHttp.overrideMimeType) {
+						xmlHttp.overrideMimeType(appender.getLayout().getContentType());
+					}
+					xmlHttp.onreadystatechange = function() {
+						if (xmlHttp.readyState == 4) {
+							if (isHttpRequestSuccessful(xmlHttp)) {
+								if (requestSuccessCallback) {
+									requestSuccessCallback(xmlHttp);
+								}
+								if (successCallback) {
+									successCallback(xmlHttp);
+								}
+							} else {
+								var msg = "AjaxAppender.append: XMLHttpRequest request to URL " +
+									url + " returned status code " + xmlHttp.status;
+								handleError(msg);
+								if (failCallback) {
+									failCallback(msg);
+								}
+							}
+							xmlHttp.onreadystatechange = emptyFunction;
+							xmlHttp = null;
+						}
+					};
+					xmlHttp.open("POST", url, true);
+					try {
+						for (var i = 0, header; header = headers[i++]; ) {
+							xmlHttp.setRequestHeader(header.name, header.value);
+						}
+						xmlHttp.setRequestHeader("Content-Type", contentType);
+					} catch (headerEx) {
+						var msg = "AjaxAppender.append: your browser's XMLHttpRequest implementation" +
+							" does not support setRequestHeader, therefore cannot post data. AjaxAppender disabled";
+						handleError(msg);
+						isSupported = false;
+						if (failCallback) {
+							failCallback(msg);
+						}
+						return;
+					}
+					xmlHttp.send(postData);
+				}
+			} catch (ex) {
+				var errMsg = "AjaxAppender.append: error sending log message to " + url;
+				handleError(errMsg, ex);
+				isSupported = false;
+				if (failCallback) {
+					failCallback(errMsg + ". Details: " + getExceptionStringRep(ex));
+				}
+			}
+		}
+
+		this.append = function(loggingEvent) {
+			if (isSupported) {
+				if (!initialized) {
+					init();
+				}
+				queuedLoggingEvents.push(loggingEvent);
+				var actualBatchSize = this.getLayout().allowBatching() ? batchSize : 1;
+
+				if (queuedLoggingEvents.length >= actualBatchSize) {
+					var currentLoggingEvent;
+					var batchedLoggingEvents = [];
+					while ((currentLoggingEvent = queuedLoggingEvents.shift())) {
+						batchedLoggingEvents.push(currentLoggingEvent);
+					}
+					// Queue this batch of log entries
+					queuedRequests.push(batchedLoggingEvents);
+
+					// If using a timer, the queue of requests will be processed by the
+					// timer function, so nothing needs to be done here.
+					if (!timed && (!waitForResponse || (waitForResponse && !sending))) {
+						sendAll();
+					}
+				}
+			}
+		};
+
+		function init() {
+			initialized = true;
+			// Add unload event to send outstanding messages
+			if (sendAllOnUnload) {
+				var oldBeforeUnload = window.onbeforeunload;
+				window.onbeforeunload = function() {
+					if (oldBeforeUnload) {
+						oldBeforeUnload();
+					}
+					if (sendAllRemaining()) {
+						return "Sending log messages";
+					}
+				};
+			}
+			// Start timer
+			if (timed) {
+				scheduleSending();
+			}
+		}
+	}
+
+	AjaxAppender.prototype = new Appender();
+
+	AjaxAppender.prototype.defaults = {
+		waitForResponse: false,
+		timed: false,
+		timerInterval: 1000,
+		batchSize: 1,
+		sendAllOnUnload: false,
+		requestSuccessCallback: null,
+		failCallback: null,
+		postVarName: "data",
+		contentType: "application/x-www-form-urlencoded"
+	};
+
+	AjaxAppender.prototype.layout = new HttpPostDataLayout();
+
+	AjaxAppender.prototype.toString = function() {
+		return "AjaxAppender";
+	};
+
+	log4javascript.AjaxAppender = AjaxAppender;
+	/* ---------------------------------------------------------------------- */
+	// PopUpAppender and InPageAppender related
+
+	function setCookie(name, value, days, path) {
+	    var expires;
+	    path = path ? "; path=" + path : "";
+		if (days) {
+			var date = new Date();
+			date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+			expires = "; expires=" + date.toGMTString();
+		} else {
+		    expires = "";
+	    }
+		document.cookie = escape(name) + "=" + escape(value) + expires + path;
+	}
+
+	function getCookie(name) {
+		var nameEquals = escape(name) + "=";
+		var ca = document.cookie.split(";");
+		for (var i = 0, len = ca.length; i < len; i++) {
+			var c = ca[i];
+			while (c.charAt(0) === " ") {
+			    c = c.substring(1, c.length);
+			}
+			if (c.indexOf(nameEquals) === 0) {
+			    return unescape(c.substring(nameEquals.length, c.length));
+	        }
+		}
+		return null;
+	}
+
+	// Gets the base URL of the location of the log4javascript script.
+	// This is far from infallible.
+	function getBaseUrl() {
+		var scripts = document.getElementsByTagName("script");
+		for (var i = 0, len = scripts.length; i < len; ++i) {
+			if (scripts[i].src.indexOf("log4javascript") != -1) {
+				var lastSlash = scripts[i].src.lastIndexOf("/");
+				return (lastSlash == -1) ? "" : scripts[i].src.substr(0, lastSlash + 1);
+			}
+		}
+        return null;
+    }
+
+	function isLoaded(win) {
+		try {
+			return bool(win.loaded);
+		} catch (ex) {
+			return false;
+		}
+	}
+
+	/* ---------------------------------------------------------------------- */
+	// ConsoleAppender (prototype for PopUpAppender and InPageAppender)
+
+	var ConsoleAppender;
+
+	// Create an anonymous function to protect base console methods
+	(function() {
+		var getConsoleHtmlLines = function() {
+			return [
+'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+'<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">',
+'	<head>',
+'		<title>log4javascript</title>',
+'		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />',
+'		<!-- Make IE8 behave like IE7, having gone to all the trouble of making IE work -->',
+'		<meta http-equiv="X-UA-Compatible" content="IE=7" />',
+'		<script type="text/javascript">var isIe = false, isIePre7 = false;</script>',
+'		<!--[if IE]><script type="text/javascript">isIe = true</script><![endif]-->',
+'		<!--[if lt IE 7]><script type="text/javascript">isIePre7 = true</script><![endif]-->',
+'		<script type="text/javascript">',
+'			//<![CDATA[',
+'			var loggingEnabled = true;',
+'			var logQueuedEventsTimer = null;',
+'			var logEntries = [];',
+'			var logEntriesAndSeparators = [];',
+'			var logItems = [];',
+'			var renderDelay = 100;',
+'			var unrenderedLogItemsExist = false;',
+'			var rootGroup, currentGroup = null;',
+'			var loaded = false;',
+'			var currentLogItem = null;',
+'			var logMainContainer;',
+'',
+'			function copyProperties(obj, props) {',
+'				for (var i in props) {',
+'					obj[i] = props[i];',
+'				}',
+'			}',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogItem() {',
+'			}',
+'',
+'			LogItem.prototype = {',
+'				mainContainer: null,',
+'				wrappedContainer: null,',
+'				unwrappedContainer: null,',
+'				group: null,',
+'',
+'				appendToLog: function() {',
+'					for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'						this.elementContainers[i].appendToLog();',
+'					}',
+'					this.group.update();',
+'				},',
+'',
+'				doRemove: function(doUpdate, removeFromGroup) {',
+'					if (this.rendered) {',
+'						for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'							this.elementContainers[i].remove();',
+'						}',
+'						this.unwrappedElementContainer = null;',
+'						this.wrappedElementContainer = null;',
+'						this.mainElementContainer = null;',
+'					}',
+'					if (this.group && removeFromGroup) {',
+'						this.group.removeChild(this, doUpdate);',
+'					}',
+'					if (this === currentLogItem) {',
+'						currentLogItem = null;',
+'					}',
+'				},',
+'',
+'				remove: function(doUpdate, removeFromGroup) {',
+'					this.doRemove(doUpdate, removeFromGroup);',
+'				},',
+'',
+'				render: function() {},',
+'',
+'				accept: function(visitor) {',
+'					visitor.visit(this);',
+'				},',
+'',
+'				getUnwrappedDomContainer: function() {',
+'					return this.group.unwrappedElementContainer.contentDiv;',
+'				},',
+'',
+'				getWrappedDomContainer: function() {',
+'					return this.group.wrappedElementContainer.contentDiv;',
+'				},',
+'',
+'				getMainDomContainer: function() {',
+'					return this.group.mainElementContainer.contentDiv;',
+'				}',
+'			};',
+'',
+'			LogItem.serializedItemKeys = {LOG_ENTRY: 0, GROUP_START: 1, GROUP_END: 2};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogItemContainerElement() {',
+'			}',
+'',
+'			LogItemContainerElement.prototype = {',
+'				appendToLog: function() {',
+'					var insertBeforeFirst = (newestAtTop && this.containerDomNode.hasChildNodes());',
+'					if (insertBeforeFirst) {',
+'						this.containerDomNode.insertBefore(this.mainDiv, this.containerDomNode.firstChild);',
+'					} else {',
+'						this.containerDomNode.appendChild(this.mainDiv);',
+'					}',
+'				}',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function SeparatorElementContainer(containerDomNode) {',
+'				this.containerDomNode = containerDomNode;',
+'				this.mainDiv = document.createElement("div");',
+'				this.mainDiv.className = "separator";',
+'				this.mainDiv.innerHTML = "&nbsp;";',
+'			}',
+'',
+'			SeparatorElementContainer.prototype = new LogItemContainerElement();',
+'',
+'			SeparatorElementContainer.prototype.remove = function() {',
+'				this.mainDiv.parentNode.removeChild(this.mainDiv);',
+'				this.mainDiv = null;',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function Separator() {',
+'				this.rendered = false;',
+'			}',
+'',
+'			Separator.prototype = new LogItem();',
+'',
+'			copyProperties(Separator.prototype, {',
+'				render: function() {',
+'					var containerDomNode = this.group.contentDiv;',
+'					if (isIe) {',
+'						this.unwrappedElementContainer = new SeparatorElementContainer(this.getUnwrappedDomContainer());',
+'						this.wrappedElementContainer = new SeparatorElementContainer(this.getWrappedDomContainer());',
+'						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];',
+'					} else {',
+'						this.mainElementContainer = new SeparatorElementContainer(this.getMainDomContainer());',
+'						this.elementContainers = [this.mainElementContainer];',
+'					}',
+'					this.content = this.formattedMessage;',
+'					this.rendered = true;',
+'				}',
+'			});',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function GroupElementContainer(group, containerDomNode, isRoot, isWrapped) {',
+'				this.group = group;',
+'				this.containerDomNode = containerDomNode;',
+'				this.isRoot = isRoot;',
+'				this.isWrapped = isWrapped;',
+'				this.expandable = false;',
+'',
+'				if (this.isRoot) {',
+'					if (isIe) {',
+'						this.contentDiv = logMainContainer.appendChild(document.createElement("div"));',
+'						this.contentDiv.id = this.isWrapped ? "log_wrapped" : "log_unwrapped";',
+'					} else {',
+'						this.contentDiv = logMainContainer;',
+'					}',
+'				} else {',
+'					var groupElementContainer = this;',
+'					',
+'					this.mainDiv = document.createElement("div");',
+'					this.mainDiv.className = "group";',
+'',
+'					this.headingDiv = this.mainDiv.appendChild(document.createElement("div"));',
+'					this.headingDiv.className = "groupheading";',
+'',
+'					this.expander = this.headingDiv.appendChild(document.createElement("span"));',
+'					this.expander.className = "expander unselectable greyedout";',
+'					this.expander.unselectable = true;',
+'					var expanderText = this.group.expanded ? "-" : "+";',
+'					this.expanderTextNode = this.expander.appendChild(document.createTextNode(expanderText));',
+'					',
+'					this.headingDiv.appendChild(document.createTextNode(" " + this.group.name));',
+'',
+'					this.contentDiv = this.mainDiv.appendChild(document.createElement("div"));',
+'					var contentCssClass = this.group.expanded ? "expanded" : "collapsed";',
+'					this.contentDiv.className = "groupcontent " + contentCssClass;',
+'',
+'					this.expander.onclick = function() {',
+'						if (groupElementContainer.group.expandable) {',
+'							groupElementContainer.group.toggleExpanded();',
+'						}',
+'					};',
+'				}',
+'			}',
+'',
+'			GroupElementContainer.prototype = new LogItemContainerElement();',
+'',
+'			copyProperties(GroupElementContainer.prototype, {',
+'				toggleExpanded: function() {',
+'					if (!this.isRoot) {',
+'						var oldCssClass, newCssClass, expanderText;',
+'						if (this.group.expanded) {',
+'							newCssClass = "expanded";',
+'							oldCssClass = "collapsed";',
+'							expanderText = "-";',
+'						} else {',
+'							newCssClass = "collapsed";',
+'							oldCssClass = "expanded";',
+'							expanderText = "+";',
+'						}',
+'						replaceClass(this.contentDiv, newCssClass, oldCssClass);',
+'						this.expanderTextNode.nodeValue = expanderText;',
+'					}',
+'				},',
+'',
+'				remove: function() {',
+'					if (!this.isRoot) {',
+'						this.headingDiv = null;',
+'						this.expander.onclick = null;',
+'						this.expander = null;',
+'						this.expanderTextNode = null;',
+'						this.contentDiv = null;',
+'						this.containerDomNode = null;',
+'						this.mainDiv.parentNode.removeChild(this.mainDiv);',
+'						this.mainDiv = null;',
+'					}',
+'				},',
+'',
+'				reverseChildren: function() {',
+'					// Invert the order of the log entries',
+'					var node = null;',
+'',
+'					// Remove all the log container nodes',
+'					var childDomNodes = [];',
+'					while ((node = this.contentDiv.firstChild)) {',
+'						this.contentDiv.removeChild(node);',
+'						childDomNodes.push(node);',
+'					}',
+'',
+'					// Put them all back in reverse order',
+'					while ((node = childDomNodes.pop())) {',
+'						this.contentDiv.appendChild(node);',
+'					}',
+'				},',
+'',
+'				update: function() {',
+'					if (!this.isRoot) {',
+'						if (this.group.expandable) {',
+'							removeClass(this.expander, "greyedout");',
+'						} else {',
+'							addClass(this.expander, "greyedout");',
+'						}',
+'					}',
+'				},',
+'',
+'				clear: function() {',
+'					if (this.isRoot) {',
+'						this.contentDiv.innerHTML = "";',
+'					}',
+'				}',
+'			});',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function Group(name, isRoot, initiallyExpanded) {',
+'				this.name = name;',
+'				this.group = null;',
+'				this.isRoot = isRoot;',
+'				this.initiallyExpanded = initiallyExpanded;',
+'				this.elementContainers = [];',
+'				this.children = [];',
+'				this.expanded = initiallyExpanded;',
+'				this.rendered = false;',
+'				this.expandable = false;',
+'			}',
+'',
+'			Group.prototype = new LogItem();',
+'',
+'			copyProperties(Group.prototype, {',
+'				addChild: function(logItem) {',
+'					this.children.push(logItem);',
+'					logItem.group = this;',
+'				},',
+'',
+'				render: function() {',
+'					if (isIe) {',
+'						var unwrappedDomContainer, wrappedDomContainer;',
+'						if (this.isRoot) {',
+'							unwrappedDomContainer = logMainContainer;',
+'							wrappedDomContainer = logMainContainer;',
+'						} else {',
+'							unwrappedDomContainer = this.getUnwrappedDomContainer();',
+'							wrappedDomContainer = this.getWrappedDomContainer();',
+'						}',
+'						this.unwrappedElementContainer = new GroupElementContainer(this, unwrappedDomContainer, this.isRoot, false);',
+'						this.wrappedElementContainer = new GroupElementContainer(this, wrappedDomContainer, this.isRoot, true);',
+'						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];',
+'					} else {',
+'						var mainDomContainer = this.isRoot ? logMainContainer : this.getMainDomContainer();',
+'						this.mainElementContainer = new GroupElementContainer(this, mainDomContainer, this.isRoot, false);',
+'						this.elementContainers = [this.mainElementContainer];',
+'					}',
+'					this.rendered = true;',
+'				},',
+'',
+'				toggleExpanded: function() {',
+'					this.expanded = !this.expanded;',
+'					for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'						this.elementContainers[i].toggleExpanded();',
+'					}',
+'				},',
+'',
+'				expand: function() {',
+'					if (!this.expanded) {',
+'						this.toggleExpanded();',
+'					}',
+'				},',
+'',
+'				accept: function(visitor) {',
+'					visitor.visitGroup(this);',
+'				},',
+'',
+'				reverseChildren: function() {',
+'					if (this.rendered) {',
+'						for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'							this.elementContainers[i].reverseChildren();',
+'						}',
+'					}',
+'				},',
+'',
+'				update: function() {',
+'					var previouslyExpandable = this.expandable;',
+'					this.expandable = (this.children.length !== 0);',
+'					if (this.expandable !== previouslyExpandable) {',
+'						for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'							this.elementContainers[i].update();',
+'						}',
+'					}',
+'				},',
+'',
+'				flatten: function() {',
+'					var visitor = new GroupFlattener();',
+'					this.accept(visitor);',
+'					return visitor.logEntriesAndSeparators;',
+'				},',
+'',
+'				removeChild: function(child, doUpdate) {',
+'					array_remove(this.children, child);',
+'					child.group = null;',
+'					if (doUpdate) {',
+'						this.update();',
+'					}',
+'				},',
+'',
+'				remove: function(doUpdate, removeFromGroup) {',
+'					for (var i = 0, len = this.children.length; i < len; i++) {',
+'						this.children[i].remove(false, false);',
+'					}',
+'					this.children = [];',
+'					this.update();',
+'					if (this === currentGroup) {',
+'						currentGroup = this.group;',
+'					}',
+'					this.doRemove(doUpdate, removeFromGroup);',
+'				},',
+'',
+'				serialize: function(items) {',
+'					items.push([LogItem.serializedItemKeys.GROUP_START, this.name]);',
+'					for (var i = 0, len = this.children.length; i < len; i++) {',
+'						this.children[i].serialize(items);',
+'					}',
+'					if (this !== currentGroup) {',
+'						items.push([LogItem.serializedItemKeys.GROUP_END]);',
+'					}',
+'				},',
+'',
+'				clear: function() {',
+'					for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'						this.elementContainers[i].clear();',
+'					}',
+'				}',
+'			});',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogEntryElementContainer() {',
+'			}',
+'',
+'			LogEntryElementContainer.prototype = new LogItemContainerElement();',
+'',
+'			copyProperties(LogEntryElementContainer.prototype, {',
+'				remove: function() {',
+'					this.doRemove();',
+'				},',
+'',
+'				doRemove: function() {',
+'					this.mainDiv.parentNode.removeChild(this.mainDiv);',
+'					this.mainDiv = null;',
+'					this.contentElement = null;',
+'					this.containerDomNode = null;',
+'				},',
+'',
+'				setContent: function(content, wrappedContent) {',
+'					if (content === this.formattedMessage) {',
+'						this.contentElement.innerHTML = "";',
+'						this.contentElement.appendChild(document.createTextNode(this.formattedMessage));',
+'					} else {',
+'						this.contentElement.innerHTML = content;',
+'					}',
+'				},',
+'',
+'				setSearchMatch: function(isMatch) {',
+'					var oldCssClass = isMatch ? "searchnonmatch" : "searchmatch";',
+'					var newCssClass = isMatch ? "searchmatch" : "searchnonmatch";',
+'					replaceClass(this.mainDiv, newCssClass, oldCssClass);',
+'				},',
+'',
+'				clearSearch: function() {',
+'					removeClass(this.mainDiv, "searchmatch");',
+'					removeClass(this.mainDiv, "searchnonmatch");',
+'				}',
+'			});',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogEntryWrappedElementContainer(logEntry, containerDomNode) {',
+'				this.logEntry = logEntry;',
+'				this.containerDomNode = containerDomNode;',
+'				this.mainDiv = document.createElement("div");',
+'				this.mainDiv.appendChild(document.createTextNode(this.logEntry.formattedMessage));',
+'				this.mainDiv.className = "logentry wrapped " + this.logEntry.level;',
+'				this.contentElement = this.mainDiv;',
+'			}',
+'',
+'			LogEntryWrappedElementContainer.prototype = new LogEntryElementContainer();',
+'',
+'			LogEntryWrappedElementContainer.prototype.setContent = function(content, wrappedContent) {',
+'				if (content === this.formattedMessage) {',
+'					this.contentElement.innerHTML = "";',
+'					this.contentElement.appendChild(document.createTextNode(this.formattedMessage));',
+'				} else {',
+'					this.contentElement.innerHTML = wrappedContent;',
+'				}',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogEntryUnwrappedElementContainer(logEntry, containerDomNode) {',
+'				this.logEntry = logEntry;',
+'				this.containerDomNode = containerDomNode;',
+'				this.mainDiv = document.createElement("div");',
+'				this.mainDiv.className = "logentry unwrapped " + this.logEntry.level;',
+'				this.pre = this.mainDiv.appendChild(document.createElement("pre"));',
+'				this.pre.appendChild(document.createTextNode(this.logEntry.formattedMessage));',
+'				this.pre.className = "unwrapped";',
+'				this.contentElement = this.pre;',
+'			}',
+'',
+'			LogEntryUnwrappedElementContainer.prototype = new LogEntryElementContainer();',
+'',
+'			LogEntryUnwrappedElementContainer.prototype.remove = function() {',
+'				this.doRemove();',
+'				this.pre = null;',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogEntryMainElementContainer(logEntry, containerDomNode) {',
+'				this.logEntry = logEntry;',
+'				this.containerDomNode = containerDomNode;',
+'				this.mainDiv = document.createElement("div");',
+'				this.mainDiv.className = "logentry nonielogentry " + this.logEntry.level;',
+'				this.contentElement = this.mainDiv.appendChild(document.createElement("span"));',
+'				this.contentElement.appendChild(document.createTextNode(this.logEntry.formattedMessage));',
+'			}',
+'',
+'			LogEntryMainElementContainer.prototype = new LogEntryElementContainer();',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogEntry(level, formattedMessage) {',
+'				this.level = level;',
+'				this.formattedMessage = formattedMessage;',
+'				this.rendered = false;',
+'			}',
+'',
+'			LogEntry.prototype = new LogItem();',
+'',
+'			copyProperties(LogEntry.prototype, {',
+'				render: function() {',
+'					var logEntry = this;',
+'					var containerDomNode = this.group.contentDiv;',
+'',
+'					// Support for the CSS attribute white-space in IE for Windows is',
+'					// non-existent pre version 6 and slightly odd in 6, so instead',
+'					// use two different HTML elements',
+'					if (isIe) {',
+'						this.formattedMessage = this.formattedMessage.replace(/\\r\\n/g, "\\r"); // Workaround for IE\'s treatment of white space',
+'						this.unwrappedElementContainer = new LogEntryUnwrappedElementContainer(this, this.getUnwrappedDomContainer());',
+'						this.wrappedElementContainer = new LogEntryWrappedElementContainer(this, this.getWrappedDomContainer());',
+'						this.elementContainers = [this.unwrappedElementContainer, this.wrappedElementContainer];',
+'					} else {',
+'						this.mainElementContainer = new LogEntryMainElementContainer(this, this.getMainDomContainer());',
+'						this.elementContainers = [this.mainElementContainer];',
+'					}',
+'					this.content = this.formattedMessage;',
+'					this.rendered = true;',
+'				},',
+'',
+'				setContent: function(content, wrappedContent) {',
+'					if (content != this.content) {',
+'						if (isIe && (content !== this.formattedMessage)) {',
+'							content = content.replace(/\\r\\n/g, "\\r"); // Workaround for IE\'s treatment of white space',
+'						}',
+'						for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'							this.elementContainers[i].setContent(content, wrappedContent);',
+'						}',
+'						this.content = content;',
+'					}',
+'				},',
+'',
+'				getSearchMatches: function() {',
+'					var matches = [];',
+'					var i, len;',
+'					if (isIe) {',
+'						var unwrappedEls = getElementsByClass(this.unwrappedElementContainer.mainDiv, "searchterm", "span");',
+'						var wrappedEls = getElementsByClass(this.wrappedElementContainer.mainDiv, "searchterm", "span");',
+'						for (i = 0, len = unwrappedEls.length; i < len; i++) {',
+'							matches[i] = new Match(this.level, null, unwrappedEls[i], wrappedEls[i]);',
+'						}',
+'					} else {',
+'						var els = getElementsByClass(this.mainElementContainer.mainDiv, "searchterm", "span");',
+'						for (i = 0, len = els.length; i < len; i++) {',
+'							matches[i] = new Match(this.level, els[i]);',
+'						}',
+'					}',
+'					return matches;',
+'				},',
+'',
+'				setSearchMatch: function(isMatch) {',
+'					for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'						this.elementContainers[i].setSearchMatch(isMatch);',
+'					}',
+'				},',
+'',
+'				clearSearch: function() {',
+'					for (var i = 0, len = this.elementContainers.length; i < len; i++) {',
+'						this.elementContainers[i].clearSearch();',
+'					}',
+'				},',
+'',
+'				accept: function(visitor) {',
+'					visitor.visitLogEntry(this);',
+'				},',
+'',
+'				serialize: function(items) {',
+'					items.push([LogItem.serializedItemKeys.LOG_ENTRY, this.level, this.formattedMessage]);',
+'				}',
+'			});',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogItemVisitor() {',
+'			}',
+'',
+'			LogItemVisitor.prototype = {',
+'				visit: function(logItem) {',
+'				},',
+'',
+'				visitParent: function(logItem) {',
+'					if (logItem.group) {',
+'						logItem.group.accept(this);',
+'					}',
+'				},',
+'',
+'				visitChildren: function(logItem) {',
+'					for (var i = 0, len = logItem.children.length; i < len; i++) {',
+'						logItem.children[i].accept(this);',
+'					}',
+'				},',
+'',
+'				visitLogEntry: function(logEntry) {',
+'					this.visit(logEntry);',
+'				},',
+'',
+'				visitSeparator: function(separator) {',
+'					this.visit(separator);',
+'				},',
+'',
+'				visitGroup: function(group) {',
+'					this.visit(group);',
+'				}',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function GroupFlattener() {',
+'				this.logEntriesAndSeparators = [];',
+'			}',
+'',
+'			GroupFlattener.prototype = new LogItemVisitor();',
+'',
+'			GroupFlattener.prototype.visitGroup = function(group) {',
+'				this.visitChildren(group);',
+'			};',
+'',
+'			GroupFlattener.prototype.visitLogEntry = function(logEntry) {',
+'				this.logEntriesAndSeparators.push(logEntry);',
+'			};',
+'',
+'			GroupFlattener.prototype.visitSeparator = function(separator) {',
+'				this.logEntriesAndSeparators.push(separator);',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			window.onload = function() {',
+'				// Sort out document.domain',
+'				if (location.search) {',
+'					var queryBits = unescape(location.search).substr(1).split("&"), nameValueBits;',
+'					for (var i = 0, len = queryBits.length; i < len; i++) {',
+'						nameValueBits = queryBits[i].split("=");',
+'						if (nameValueBits[0] == "log4javascript_domain") {',
+'							document.domain = nameValueBits[1];',
+'							break;',
+'						}',
+'					}',
+'				}',
+'',
+'				// Create DOM objects',
+'				logMainContainer = $("log");',
+'				if (isIePre7) {',
+'					addClass(logMainContainer, "oldIe");',
+'				}',
+'',
+'				rootGroup = new Group("root", true);',
+'				rootGroup.render();',
+'				currentGroup = rootGroup;',
+'				',
+'				setCommandInputWidth();',
+'				setLogContainerHeight();',
+'				toggleLoggingEnabled();',
+'				toggleSearchEnabled();',
+'				toggleSearchFilter();',
+'				toggleSearchHighlight();',
+'				applyFilters();',
+'				checkAllLevels();',
+'				toggleWrap();',
+'				toggleNewestAtTop();',
+'				toggleScrollToLatest();',
+'				renderQueuedLogItems();',
+'				loaded = true;',
+'				$("command").value = "";',
+'				$("command").autocomplete = "off";',
+'				$("command").onkeydown = function(evt) {',
+'					evt = getEvent(evt);',
+'					if (evt.keyCode == 10 || evt.keyCode == 13) { // Return/Enter',
+'						evalCommandLine();',
+'						stopPropagation(evt);',
+'					} else if (evt.keyCode == 27) { // Escape',
+'						this.value = "";',
+'						this.focus();',
+'					} else if (evt.keyCode == 38 && commandHistory.length > 0) { // Up',
+'						currentCommandIndex = Math.max(0, currentCommandIndex - 1);',
+'						this.value = commandHistory[currentCommandIndex];',
+'						moveCaretToEnd(this);',
+'					} else if (evt.keyCode == 40 && commandHistory.length > 0) { // Down',
+'						currentCommandIndex = Math.min(commandHistory.length - 1, currentCommandIndex + 1);',
+'						this.value = commandHistory[currentCommandIndex];',
+'						moveCaretToEnd(this);',
+'					}',
+'				};',
+'',
+'				// Prevent the keypress moving the caret in Firefox',
+'				$("command").onkeypress = function(evt) {',
+'					evt = getEvent(evt);',
+'					if (evt.keyCode == 38 && commandHistory.length > 0 && evt.preventDefault) { // Up',
+'						evt.preventDefault();',
+'					}',
+'				};',
+'',
+'				// Prevent the keyup event blurring the input in Opera',
+'				$("command").onkeyup = function(evt) {',
+'					evt = getEvent(evt);',
+'					if (evt.keyCode == 27 && evt.preventDefault) { // Up',
+'						evt.preventDefault();',
+'						this.focus();',
+'					}',
+'				};',
+'',
+'				// Add document keyboard shortcuts',
+'				document.onkeydown = function keyEventHandler(evt) {',
+'					evt = getEvent(evt);',
+'					switch (evt.keyCode) {',
+'						case 69: // Ctrl + shift + E: re-execute last command',
+'							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {',
+'								evalLastCommand();',
+'								cancelKeyEvent(evt);',
+'								return false;',
+'							}',
+'							break;',
+'						case 75: // Ctrl + shift + K: focus search',
+'							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {',
+'								focusSearch();',
+'								cancelKeyEvent(evt);',
+'								return false;',
+'							}',
+'							break;',
+'						case 40: // Ctrl + shift + down arrow: focus command line',
+'						case 76: // Ctrl + shift + L: focus command line',
+'							if (evt.shiftKey && (evt.ctrlKey || evt.metaKey)) {',
+'								focusCommandLine();',
+'								cancelKeyEvent(evt);',
+'								return false;',
+'							}',
+'							break;',
+'					}',
+'				};',
+'',
+'				// Workaround to make sure log div starts at the correct size',
+'				setTimeout(setLogContainerHeight, 20);',
+'',
+'				setShowCommandLine(showCommandLine);',
+'				doSearch();',
+'			};',
+'',
+'			window.onunload = function() {',
+'				if (mainWindowExists()) {',
+'					appender.unload();',
+'				}',
+'				appender = null;',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function toggleLoggingEnabled() {',
+'				setLoggingEnabled($("enableLogging").checked);',
+'			}',
+'',
+'			function setLoggingEnabled(enable) {',
+'				loggingEnabled = enable;',
+'			}',
+'',
+'			var appender = null;',
+'',
+'			function setAppender(appenderParam) {',
+'				appender = appenderParam;',
+'			}',
+'',
+'			function setShowCloseButton(showCloseButton) {',
+'				$("closeButton").style.display = showCloseButton ? "inline" : "none";',
+'			}',
+'',
+'			function setShowHideButton(showHideButton) {',
+'				$("hideButton").style.display = showHideButton ? "inline" : "none";',
+'			}',
+'',
+'			var newestAtTop = false;',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function LogItemContentReverser() {',
+'			}',
+'			',
+'			LogItemContentReverser.prototype = new LogItemVisitor();',
+'			',
+'			LogItemContentReverser.prototype.visitGroup = function(group) {',
+'				group.reverseChildren();',
+'				this.visitChildren(group);',
+'			};',
+'',
+'			/*----------------------------------------------------------------*/',
+'',
+'			function setNewestAtTop(isNewestAtTop) {',
+'				var oldNewestAtTop = newestAtTop;',
+'				var i, iLen, j, jLen;',
+'				newestAtTop = Boolean(isNewestAtTop);',
+'				if (oldNewestAtTop != newestAtTop) {',
+'					var visitor = new LogItemContentReverser();',
+'					rootGroup.accept(visitor);',
+'',
+'					// Reassemble the matches array',
+'					if (currentSearch) {',
+'						var currentMatch = currentSearch.matches[currentMatchIndex];',
+'						var matchIndex = 0;',
+'						var matches = [];',
+'						var actOnLogEntry = function(logEntry) {',
+'							var logEntryMatches = logEntry.getSearchMatches();',
+'							for (j = 0, jLen = logEntryMatches.length; j < jLen; j++) {',
+'								matches[matchIndex] = logEntryMatches[j];',
+'								if (currentMatch && logEntryMatches[j].equals(currentMatch)) {',
+'									currentMatchIndex = matchIndex;',
+'								}',
+'								matchIndex++;',
+'							}',
+'						};',
+'						if (newestAtTop) {',
+'							for (i = logEntries.length - 1; i >= 0; i--) {',
+'								actOnLogEntry(logEntries[i]);',
+'							}',
+'						} else {',
+'							for (i = 0, iLen = logEntries.length; i < iLen; i++) {',
+'								actOnLogEntry(logEntries[i]);',
+'							}',
+'						}',
+'						currentSearch.matches = matches;',
+'						if (currentMatch) {',
+'							currentMatch.setCurrent();',
+'						}',
+'					} else if (scrollToLatest) {',
+'						doScrollToLatest();',
+'					}',
+'				}',
+'				$("newestAtTop").checked = isNewestAtTop;',
+'			}',
+'',
+'			function toggleNewestAtTop() {',
+'				var isNewestAtTop = $("newestAtTop").checked;',
+'				setNewestAtTop(isNewestAtTop);',
+'			}',
+'',
+'			var scrollToLatest = true;',
+'',
+'			function setScrollToLatest(isScrollToLatest) {',
+'				scrollToLatest = isScrollToLatest;',
+'				if (scrollToLatest) {',
+'					doScrollToLatest();',
+'				}',
+'				$("scrollToLatest").checked = isScrollToLatest;',
+'			}',
+'',
+'			function toggleScrollToLatest() {',
+'				var isScrollToLatest = $("scrollToLatest").checked;',
+'				setScrollToLatest(isScrollToLatest);',
+'			}',
+'',
+'			function doScrollToLatest() {',
+'				var l = logMainContainer;',
+'				if (typeof l.scrollTop != "undefined") {',
+'					if (newestAtTop) {',
+'						l.scrollTop = 0;',
+'					} else {',
+'						var latestLogEntry = l.lastChild;',
+'						if (latestLogEntry) {',
+'							l.scrollTop = l.scrollHeight;',
+'						}',
+'					}',
+'				}',
+'			}',
+'',
+'			var closeIfOpenerCloses = true;',
+'',
+'			function setCloseIfOpenerCloses(isCloseIfOpenerCloses) {',
+'				closeIfOpenerCloses = isCloseIfOpenerCloses;',
+'			}',
+'',
+'			var maxMessages = null;',
+'',
+'			function setMaxMessages(max) {',
+'				maxMessages = max;',
+'				pruneLogEntries();',
+'			}',
+'',
+'			var showCommandLine = false;',
+'',
+'			function setShowCommandLine(isShowCommandLine) {',
+'				showCommandLine = isShowCommandLine;',
+'				if (loaded) {',
+'					$("commandLine").style.display = showCommandLine ? "block" : "none";',
+'					setCommandInputWidth();',
+'					setLogContainerHeight();',
+'				}',
+'			}',
+'',
+'			function focusCommandLine() {',
+'				if (loaded) {',
+'					$("command").focus();',
+'				}',
+'			}',
+'',
+'			function focusSearch() {',
+'				if (loaded) {',
+'					$("searchBox").focus();',
+'				}',
+'			}',
+'',
+'			function getLogItems() {',
+'				var items = [];',
+'				for (var i = 0, len = logItems.length; i < len; i++) {',
+'					logItems[i].serialize(items);',
+'				}',
+'				return items;',
+'			}',
+'',
+'			function setLogItems(items) {',
+'				var loggingReallyEnabled = loggingEnabled;',
+'				// Temporarily turn logging on',
+'				loggingEnabled = true;',
+'				for (var i = 0, len = items.length; i < len; i++) {',
+'					switch (items[i][0]) {',
+'						case LogItem.serializedItemKeys.LOG_ENTRY:',
+'							log(items[i][1], items[i][2]);',
+'							break;',
+'						case LogItem.serializedItemKeys.GROUP_START:',
+'							group(items[i][1]);',
+'							break;',
+'						case LogItem.serializedItemKeys.GROUP_END:',
+'							groupEnd();',
+'							break;',
+'					}',
+'				}',
+'				loggingEnabled = loggingReallyEnabled;',
+'			}',
+'',
+'			function log(logLevel, formattedMessage) {',
+'				if (loggingEnabled) {',
+'					var logEntry = new LogEntry(logLevel, formattedMessage);',
+'					logEntries.push(logEntry);',
+'					logEntriesAndSeparators.push(logEntry);',
+'					logItems.push(logEntry);',
+'					currentGroup.addChild(logEntry);',
+'					if (loaded) {',
+'						if (logQueuedEventsTimer !== null) {',
+'							clearTimeout(logQueuedEventsTimer);',
+'						}',
+'						logQueuedEventsTimer = setTimeout(renderQueuedLogItems, renderDelay);',
+'						unrenderedLogItemsExist = true;',
+'					}',
+'				}',
+'			}',
+'',
+'			function renderQueuedLogItems() {',
+'				logQueuedEventsTimer = null;',
+'				var pruned = pruneLogEntries();',
+'',
+'				// Render any unrendered log entries and apply the current search to them',
+'				var initiallyHasMatches = currentSearch ? currentSearch.hasMatches() : false;',
+'				for (var i = 0, len = logItems.length; i < len; i++) {',
+'					if (!logItems[i].rendered) {',
+'						logItems[i].render();',
+'						logItems[i].appendToLog();',
+'						if (currentSearch && (logItems[i] instanceof LogEntry)) {',
+'							currentSearch.applyTo(logItems[i]);',
+'						}',
+'					}',
+'				}',
+'				if (currentSearch) {',
+'					if (pruned) {',
+'						if (currentSearch.hasVisibleMatches()) {',
+'							if (currentMatchIndex === null) {',
+'								setCurrentMatchIndex(0);',
+'							}',
+'							displayMatches();',
+'						} else {',
+'							displayNoMatches();',
+'						}',
+'					} else if (!initiallyHasMatches && currentSearch.hasVisibleMatches()) {',
+'						setCurrentMatchIndex(0);',
+'						displayMatches();',
+'					}',
+'				}',
+'				if (scrollToLatest) {',
+'					doScrollToLatest();',
+'				}',
+'				unrenderedLogItemsExist = false;',
+'			}',
+'',
+'			function pruneLogEntries() {',
+'				if ((maxMessages !== null) && (logEntriesAndSeparators.length > maxMessages)) {',
+'					var numberToDelete = logEntriesAndSeparators.length - maxMessages;',
+'					var prunedLogEntries = logEntriesAndSeparators.slice(0, numberToDelete);',
+'					if (currentSearch) {',
+'						currentSearch.removeMatches(prunedLogEntries);',
+'					}',
+'					var group;',
+'					for (var i = 0; i < numberToDelete; i++) {',
+'						group = logEntriesAndSeparators[i].group;',
+'						array_remove(logItems, logEntriesAndSeparators[i]);',
+'						array_remove(logEntries, logEntriesAndSeparators[i]);',
+'						logEntriesAndSeparators[i].remove(true, true);',
+'						if (group.children.length === 0 && group !== currentGroup && group !== rootGroup) {',
+'							array_remove(logItems, group);',
+'							group.remove(true, true);',
+'						}',
+'					}',
+'					logEntriesAndSeparators = array_removeFromStart(logEntriesAndSeparators, numberToDelete);',
+'					return true;',
+'				}',
+'				return false;',
+'			}',
+'',
+'			function group(name, startExpanded) {',
+'				if (loggingEnabled) {',
+'					initiallyExpanded = (typeof startExpanded === "undefined") ? true : Boolean(startExpanded);',
+'					var newGroup = new Group(name, false, initiallyExpanded);',
+'					currentGroup.addChild(newGroup);',
+'					currentGroup = newGroup;',
+'					logItems.push(newGroup);',
+'					if (loaded) {',
+'						if (logQueuedEventsTimer !== null) {',
+'							clearTimeout(logQueuedEventsTimer);',
+'						}',
+'						logQueuedEventsTimer = setTimeout(renderQueuedLogItems, renderDelay);',
+'						unrenderedLogItemsExist = true;',
+'					}',
+'				}',
+'			}',
+'',
+'			function groupEnd() {',
+'				currentGroup = (currentGroup === rootGroup) ? rootGroup : currentGroup.group;',
+'			}',
+'',
+'			function mainPageReloaded() {',
+'				currentGroup = rootGroup;',
+'				var separator = new Separator();',
+'				logEntriesAndSeparators.push(separator);',
+'				logItems.push(separator);',
+'				currentGroup.addChild(separator);',
+'			}',
+'',
+'			function closeWindow() {',
+'				if (appender && mainWindowExists()) {',
+'					appender.close(true);',
+'				} else {',
+'					window.close();',
+'				}',
+'			}',
+'',
+'			function hide() {',
+'				if (appender && mainWindowExists()) {',
+'					appender.hide();',
+'				}',
+'			}',
+'',
+'			var mainWindow = window;',
+'			var windowId = "log4javascriptConsoleWindow_" + new Date().getTime() + "_" + ("" + Math.random()).substr(2);',
+'',
+'			function setMainWindow(win) {',
+'				mainWindow = win;',
+'				mainWindow[windowId] = window;',
+'				// If this is a pop-up, poll the opener to see if it\'s closed',
+'				if (opener && closeIfOpenerCloses) {',
+'					pollOpener();',
+'				}',
+'			}',
+'',
+'			function pollOpener() {',
+'				if (closeIfOpenerCloses) {',
+'					if (mainWindowExists()) {',
+'						setTimeout(pollOpener, 500);',
+'					} else {',
+'						closeWindow();',
+'					}',
+'				}',
+'			}',
+'',
+'			function mainWindowExists() {',
+'				try {',
+'					return (mainWindow && !mainWindow.closed &&',
+'						mainWindow[windowId] == window);',
+'				} catch (ex) {}',
+'				return false;',
+'			}',
+'',
+'			var logLevels = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"];',
+'',
+'			function getCheckBox(logLevel) {',
+'				return $("switch_" + logLevel);',
+'			}',
+'',
+'			function getIeWrappedLogContainer() {',
+'				return $("log_wrapped");',
+'			}',
+'',
+'			function getIeUnwrappedLogContainer() {',
+'				return $("log_unwrapped");',
+'			}',
+'',
+'			function applyFilters() {',
+'				for (var i = 0; i < logLevels.length; i++) {',
+'					if (getCheckBox(logLevels[i]).checked) {',
+'						addClass(logMainContainer, logLevels[i]);',
+'					} else {',
+'						removeClass(logMainContainer, logLevels[i]);',
+'					}',
+'				}',
+'				updateSearchFromFilters();',
+'			}',
+'',
+'			function toggleAllLevels() {',
+'				var turnOn = $("switch_ALL").checked;',
+'				for (var i = 0; i < logLevels.length; i++) {',
+'					getCheckBox(logLevels[i]).checked = turnOn;',
+'					if (turnOn) {',
+'						addClass(logMainContainer, logLevels[i]);',
+'					} else {',
+'						removeClass(logMainContainer, logLevels[i]);',
+'					}',
+'				}',
+'			}',
+'',
+'			function checkAllLevels() {',
+'				for (var i = 0; i < logLevels.length; i++) {',
+'					if (!getCheckBox(logLevels[i]).checked) {',
+'						getCheckBox("ALL").checked = false;',
+'						return;',
+'					}',
+'				}',
+'				getCheckBox("ALL").checked = true;',
+'			}',
+'',
+'			function clearLog() {',
+'				rootGroup.clear();',
+'				currentGroup = rootGroup;',
+'				logEntries = [];',
+'				logItems = [];',
+'				logEntriesAndSeparators = [];',
+' 				doSearch();',
+'			}',
+'',
+'			function toggleWrap() {',
+'				var enable = $("wrap").checked;',
+'				if (enable) {',
+'					addClass(logMainContainer, "wrap");',
+'				} else {',
+'					removeClass(logMainContainer, "wrap");',
+'				}',
+'				refreshCurrentMatch();',
+'			}',
+'',
+'			/* ------------------------------------------------------------------- */',
+'',
+'			// Search',
+'',
+'			var searchTimer = null;',
+'',
+'			function scheduleSearch() {',
+'				try {',
+'					clearTimeout(searchTimer);',
+'				} catch (ex) {',
+'					// Do nothing',
+'				}',
+'				searchTimer = setTimeout(doSearch, 500);',
+'			}',
+'',
+'			function Search(searchTerm, isRegex, searchRegex, isCaseSensitive) {',
+'				this.searchTerm = searchTerm;',
+'				this.isRegex = isRegex;',
+'				this.searchRegex = searchRegex;',
+'				this.isCaseSensitive = isCaseSensitive;',
+'				this.matches = [];',
+'			}',
+'',
+'			Search.prototype = {',
+'				hasMatches: function() {',
+'					return this.matches.length > 0;',
+'				},',
+'',
+'				hasVisibleMatches: function() {',
+'					if (this.hasMatches()) {',
+'						for (var i = 0; i < this.matches.length; i++) {',
+'							if (this.matches[i].isVisible()) {',
+'								return true;',
+'							}',
+'						}',
+'					}',
+'					return false;',
+'				},',
+'',
+'				match: function(logEntry) {',
+'					var entryText = String(logEntry.formattedMessage);',
+'					var matchesSearch = false;',
+'					if (this.isRegex) {',
+'						matchesSearch = this.searchRegex.test(entryText);',
+'					} else if (this.isCaseSensitive) {',
+'						matchesSearch = (entryText.indexOf(this.searchTerm) > -1);',
+'					} else {',
+'						matchesSearch = (entryText.toLowerCase().indexOf(this.searchTerm.toLowerCase()) > -1);',
+'					}',
+'					return matchesSearch;',
+'				},',
+'',
+'				getNextVisibleMatchIndex: function() {',
+'					for (var i = currentMatchIndex + 1; i < this.matches.length; i++) {',
+'						if (this.matches[i].isVisible()) {',
+'							return i;',
+'						}',
+'					}',
+'					// Start again from the first match',
+'					for (i = 0; i <= currentMatchIndex; i++) {',
+'						if (this.matches[i].isVisible()) {',
+'							return i;',
+'						}',
+'					}',
+'					return -1;',
+'				},',
+'',
+'				getPreviousVisibleMatchIndex: function() {',
+'					for (var i = currentMatchIndex - 1; i >= 0; i--) {',
+'						if (this.matches[i].isVisible()) {',
+'							return i;',
+'						}',
+'					}',
+'					// Start again from the last match',
+'					for (var i = this.matches.length - 1; i >= currentMatchIndex; i--) {',
+'						if (this.matches[i].isVisible()) {',
+'							return i;',
+'						}',
+'					}',
+'					return -1;',
+'				},',
+'',
+'				applyTo: function(logEntry) {',
+'					var doesMatch = this.match(logEntry);',
+'					if (doesMatch) {',
+'						logEntry.group.expand();',
+'						logEntry.setSearchMatch(true);',
+'						var logEntryContent;',
+'						var wrappedLogEntryContent;',
+'						var searchTermReplacementStartTag = "<span class=\\\"searchterm\\\">";',
+'						var searchTermReplacementEndTag = "<" + "/span>";',
+'						var preTagName = isIe ? "pre" : "span";',
+'						var preStartTag = "<" + preTagName + " class=\\\"pre\\\">";',
+'						var preEndTag = "<" + "/" + preTagName + ">";',
+'						var startIndex = 0;',
+'						var searchIndex, matchedText, textBeforeMatch;',
+'						if (this.isRegex) {',
+'							var flags = this.isCaseSensitive ? "g" : "gi";',
+'							var capturingRegex = new RegExp("(" + this.searchRegex.source + ")", flags);',
+'',
+'							// Replace the search term with temporary tokens for the start and end tags',
+'							var rnd = ("" + Math.random()).substr(2);',
+'							var startToken = "%%s" + rnd + "%%";',
+'							var endToken = "%%e" + rnd + "%%";',
+'							logEntryContent = logEntry.formattedMessage.replace(capturingRegex, startToken + "$1" + endToken);',
+'',
+'							// Escape the HTML to get rid of angle brackets',
+'							logEntryContent = escapeHtml(logEntryContent);',
+'',
+'							// Substitute the proper HTML back in for the search match',
+'							var result;',
+'							var searchString = logEntryContent;',
+'							logEntryContent = "";',
+'							wrappedLogEntryContent = "";',
+'							while ((searchIndex = searchString.indexOf(startToken, startIndex)) > -1) {',
+'								var endTokenIndex = searchString.indexOf(endToken, searchIndex);',
+'								matchedText = searchString.substring(searchIndex + startToken.length, endTokenIndex);',
+'								textBeforeMatch = searchString.substring(startIndex, searchIndex);',
+'								logEntryContent += preStartTag + textBeforeMatch + preEndTag;',
+'								logEntryContent += searchTermReplacementStartTag + preStartTag + matchedText +',
+'									preEndTag + searchTermReplacementEndTag;',
+'								if (isIe) {',
+'									wrappedLogEntryContent += textBeforeMatch + searchTermReplacementStartTag +',
+'										matchedText + searchTermReplacementEndTag;',
+'								}',
+'								startIndex = endTokenIndex + endToken.length;',
+'							}',
+'							logEntryContent += preStartTag + searchString.substr(startIndex) + preEndTag;',
+'							if (isIe) {',
+'								wrappedLogEntryContent += searchString.substr(startIndex);',
+'							}',
+'						} else {',
+'							logEntryContent = "";',
+'							wrappedLogEntryContent = "";',
+'							var searchTermReplacementLength = searchTermReplacementStartTag.length +',
+'								this.searchTerm.length + searchTermReplacementEndTag.length;',
+'							var searchTermLength = this.searchTerm.length;',
+'							var searchTermLowerCase = this.searchTerm.toLowerCase();',
+'							var logTextLowerCase = logEntry.formattedMessage.toLowerCase();',
+'							while ((searchIndex = logTextLowerCase.indexOf(searchTermLowerCase, startIndex)) > -1) {',
+'								matchedText = escapeHtml(logEntry.formattedMessage.substr(searchIndex, this.searchTerm.length));',
+'								textBeforeMatch = escapeHtml(logEntry.formattedMessage.substring(startIndex, searchIndex));',
+'								var searchTermReplacement = searchTermReplacementStartTag +',
+'									preStartTag + matchedText + preEndTag + searchTermReplacementEndTag;',
+'								logEntryContent += preStartTag + textBeforeMatch + preEndTag + searchTermReplacement;',
+'								if (isIe) {',
+'									wrappedLogEntryContent += textBeforeMatch + searchTermReplacementStartTag +',
+'										matchedText + searchTermReplacementEndTag;',
+'								}',
+'								startIndex = searchIndex + searchTermLength;',
+'							}',
+'							var textAfterLastMatch = escapeHtml(logEntry.formattedMessage.substr(startIndex));',
+'							logEntryContent += preStartTag + textAfterLastMatch + preEndTag;',
+'							if (isIe) {',
+'								wrappedLogEntryContent += textAfterLastMatch;',
+'							}',
+'						}',
+'						logEntry.setContent(logEntryContent, wrappedLogEntryContent);',
+'						var logEntryMatches = logEntry.getSearchMatches();',
+'						this.matches = this.matches.concat(logEntryMatches);',
+'					} else {',
+'						logEntry.setSearchMatch(false);',
+'						logEntry.setContent(logEntry.formattedMessage, logEntry.formattedMessage);',
+'					}',
+'					return doesMatch;',
+'				},',
+'',
+'				removeMatches: function(logEntries) {',
+'					var matchesToRemoveCount = 0;',
+'					var currentMatchRemoved = false;',
+'					var matchesToRemove = [];',
+'					var i, iLen, j, jLen;',
+'',
+'					// Establish the list of matches to be removed',
+'					for (i = 0, iLen = this.matches.length; i < iLen; i++) {',
+'						for (j = 0, jLen = logEntries.length; j < jLen; j++) {',
+'							if (this.matches[i].belongsTo(logEntries[j])) {',
+'								matchesToRemove.push(this.matches[i]);',
+'								if (i === currentMatchIndex) {',
+'									currentMatchRemoved = true;',
+'								}',
+'							}',
+'						}',
+'					}',
+'',
+'					// Set the new current match index if the current match has been deleted',
+'					// This will be the first match that appears after the first log entry being',
+'					// deleted, if one exists; otherwise, it\'s the first match overall',
+'					var newMatch = currentMatchRemoved ? null : this.matches[currentMatchIndex];',
+'					if (currentMatchRemoved) {',
+'						for (i = currentMatchIndex, iLen = this.matches.length; i < iLen; i++) {',
+'							if (this.matches[i].isVisible() && !array_contains(matchesToRemove, this.matches[i])) {',
+'								newMatch = this.matches[i];',
+'								break;',
+'							}',
+'						}',
+'					}',
+'',
+'					// Remove the matches',
+'					for (i = 0, iLen = matchesToRemove.length; i < iLen; i++) {',
+'						array_remove(this.matches, matchesToRemove[i]);',
+'						matchesToRemove[i].remove();',
+'					}',
+'',
+'					// Set the new match, if one exists',
+'					if (this.hasVisibleMatches()) {',
+'						if (newMatch === null) {',
+'							setCurrentMatchIndex(0);',
+'						} else {',
+'							// Get the index of the new match',
+'							var newMatchIndex = 0;',
+'							for (i = 0, iLen = this.matches.length; i < iLen; i++) {',
+'								if (newMatch === this.matches[i]) {',
+'									newMatchIndex = i;',
+'									break;',
+'								}',
+'							}',
+'							setCurrentMatchIndex(newMatchIndex);',
+'						}',
+'					} else {',
+'						currentMatchIndex = null;',
+'						displayNoMatches();',
+'					}',
+'				}',
+'			};',
+'',
+'			function getPageOffsetTop(el, container) {',
+'				var currentEl = el;',
+'				var y = 0;',
+'				while (currentEl && currentEl != container) {',
+'					y += currentEl.offsetTop;',
+'					currentEl = currentEl.offsetParent;',
+'				}',
+'				return y;',
+'			}',
+'',
+'			function scrollIntoView(el) {',
+'				var logContainer = logMainContainer;',
+'				// Check if the whole width of the element is visible and centre if not',
+'				if (!$("wrap").checked) {',
+'					var logContainerLeft = logContainer.scrollLeft;',
+'					var logContainerRight = logContainerLeft  + logContainer.offsetWidth;',
+'					var elLeft = el.offsetLeft;',
+'					var elRight = elLeft + el.offsetWidth;',
+'					if (elLeft < logContainerLeft || elRight > logContainerRight) {',
+'						logContainer.scrollLeft = elLeft - (logContainer.offsetWidth - el.offsetWidth) / 2;',
+'					}',
+'				}',
+'				// Check if the whole height of the element is visible and centre if not',
+'				var logContainerTop = logContainer.scrollTop;',
+'				var logContainerBottom = logContainerTop  + logContainer.offsetHeight;',
+'				var elTop = getPageOffsetTop(el) - getToolBarsHeight();',
+'				var elBottom = elTop + el.offsetHeight;',
+'				if (elTop < logContainerTop || elBottom > logContainerBottom) {',
+'					logContainer.scrollTop = elTop - (logContainer.offsetHeight - el.offsetHeight) / 2;',
+'				}',
+'			}',
+'',
+'			function Match(logEntryLevel, spanInMainDiv, spanInUnwrappedPre, spanInWrappedDiv) {',
+'				this.logEntryLevel = logEntryLevel;',
+'				this.spanInMainDiv = spanInMainDiv;',
+'				if (isIe) {',
+'					this.spanInUnwrappedPre = spanInUnwrappedPre;',
+'					this.spanInWrappedDiv = spanInWrappedDiv;',
+'				}',
+'				this.mainSpan = isIe ? spanInUnwrappedPre : spanInMainDiv;',
+'			}',
+'',
+'			Match.prototype = {',
+'				equals: function(match) {',
+'					return this.mainSpan === match.mainSpan;',
+'				},',
+'',
+'				setCurrent: function() {',
+'					if (isIe) {',
+'						addClass(this.spanInUnwrappedPre, "currentmatch");',
+'						addClass(this.spanInWrappedDiv, "currentmatch");',
+'						// Scroll the visible one into view',
+'						var elementToScroll = $("wrap").checked ? this.spanInWrappedDiv : this.spanInUnwrappedPre;',
+'						scrollIntoView(elementToScroll);',
+'					} else {',
+'						addClass(this.spanInMainDiv, "currentmatch");',
+'						scrollIntoView(this.spanInMainDiv);',
+'					}',
+'				},',
+'',
+'				belongsTo: function(logEntry) {',
+'					if (isIe) {',
+'						return isDescendant(this.spanInUnwrappedPre, logEntry.unwrappedPre);',
+'					} else {',
+'						return isDescendant(this.spanInMainDiv, logEntry.mainDiv);',
+'					}',
+'				},',
+'',
+'				setNotCurrent: function() {',
+'					if (isIe) {',
+'						removeClass(this.spanInUnwrappedPre, "currentmatch");',
+'						removeClass(this.spanInWrappedDiv, "currentmatch");',
+'					} else {',
+'						removeClass(this.spanInMainDiv, "currentmatch");',
+'					}',
+'				},',
+'',
+'				isOrphan: function() {',
+'					return isOrphan(this.mainSpan);',
+'				},',
+'',
+'				isVisible: function() {',
+'					return getCheckBox(this.logEntryLevel).checked;',
+'				},',
+'',
+'				remove: function() {',
+'					if (isIe) {',
+'						this.spanInUnwrappedPre = null;',
+'						this.spanInWrappedDiv = null;',
+'					} else {',
+'						this.spanInMainDiv = null;',
+'					}',
+'				}',
+'			};',
+'',
+'			var currentSearch = null;',
+'			var currentMatchIndex = null;',
+'',
+'			function doSearch() {',
+'				var searchBox = $("searchBox");',
+'				var searchTerm = searchBox.value;',
+'				var isRegex = $("searchRegex").checked;',
+'				var isCaseSensitive = $("searchCaseSensitive").checked;',
+'				var i;',
+'',
+'				if (searchTerm === "") {',
+'					$("searchReset").disabled = true;',
+'					$("searchNav").style.display = "none";',
+'					removeClass(document.body, "searching");',
+'					removeClass(searchBox, "hasmatches");',
+'					removeClass(searchBox, "nomatches");',
+'					for (i = 0; i < logEntries.length; i++) {',
+'						logEntries[i].clearSearch();',
+'						logEntries[i].setContent(logEntries[i].formattedMessage, logEntries[i].formattedMessage);',
+'					}',
+'					currentSearch = null;',
+'					setLogContainerHeight();',
+'				} else {',
+'					$("searchReset").disabled = false;',
+'					$("searchNav").style.display = "block";',
+'					var searchRegex;',
+'					var regexValid;',
+'					if (isRegex) {',
+'						try {',
+'							searchRegex = isCaseSensitive ? new RegExp(searchTerm, "g") : new RegExp(searchTerm, "gi");',
+'							regexValid = true;',
+'							replaceClass(searchBox, "validregex", "invalidregex");',
+'							searchBox.title = "Valid regex";',
+'						} catch (ex) {',
+'							regexValid = false;',
+'							replaceClass(searchBox, "invalidregex", "validregex");',
+'							searchBox.title = "Invalid regex: " + (ex.message ? ex.message : (ex.description ? ex.description : "unknown error"));',
+'							return;',
+'						}',
+'					} else {',
+'						searchBox.title = "";',
+'						removeClass(searchBox, "validregex");',
+'						removeClass(searchBox, "invalidregex");',
+'					}',
+'					addClass(document.body, "searching");',
+'					currentSearch = new Search(searchTerm, isRegex, searchRegex, isCaseSensitive);',
+'					for (i = 0; i < logEntries.length; i++) {',
+'						currentSearch.applyTo(logEntries[i]);',
+'					}',
+'					setLogContainerHeight();',
+'',
+'					// Highlight the first search match',
+'					if (currentSearch.hasVisibleMatches()) {',
+'						setCurrentMatchIndex(0);',
+'						displayMatches();',
+'					} else {',
+'						displayNoMatches();',
+'					}',
+'				}',
+'			}',
+'',
+'			function updateSearchFromFilters() {',
+'				if (currentSearch) {',
+'					if (currentSearch.hasMatches()) {',
+'						if (currentMatchIndex === null) {',
+'							currentMatchIndex = 0;',
+'						}',
+'						var currentMatch = currentSearch.matches[currentMatchIndex];',
+'						if (currentMatch.isVisible()) {',
+'							displayMatches();',
+'							setCurrentMatchIndex(currentMatchIndex);',
+'						} else {',
+'							currentMatch.setNotCurrent();',
+'							// Find the next visible match, if one exists',
+'							var nextVisibleMatchIndex = currentSearch.getNextVisibleMatchIndex();',
+'							if (nextVisibleMatchIndex > -1) {',
+'								setCurrentMatchIndex(nextVisibleMatchIndex);',
+'								displayMatches();',
+'							} else {',
+'								displayNoMatches();',
+'							}',
+'						}',
+'					} else {',
+'						displayNoMatches();',
+'					}',
+'				}',
+'			}',
+'',
+'			function refreshCurrentMatch() {',
+'				if (currentSearch && currentSearch.hasVisibleMatches()) {',
+'					setCurrentMatchIndex(currentMatchIndex);',
+'				}',
+'			}',
+'',
+'			function displayMatches() {',
+'				replaceClass($("searchBox"), "hasmatches", "nomatches");',
+'				$("searchBox").title = "" + currentSearch.matches.length + " matches found";',
+'				$("searchNav").style.display = "block";',
+'				setLogContainerHeight();',
+'			}',
+'',
+'			function displayNoMatches() {',
+'				replaceClass($("searchBox"), "nomatches", "hasmatches");',
+'				$("searchBox").title = "No matches found";',
+'				$("searchNav").style.display = "none";',
+'				setLogContainerHeight();',
+'			}',
+'',
+'			function toggleSearchEnabled(enable) {',
+'				enable = (typeof enable == "undefined") ? !$("searchDisable").checked : enable;',
+'				$("searchBox").disabled = !enable;',
+'				$("searchReset").disabled = !enable;',
+'				$("searchRegex").disabled = !enable;',
+'				$("searchNext").disabled = !enable;',
+'				$("searchPrevious").disabled = !enable;',
+'				$("searchCaseSensitive").disabled = !enable;',
+'				$("searchNav").style.display = (enable && ($("searchBox").value !== "") &&',
+'						currentSearch && currentSearch.hasVisibleMatches()) ?',
+'					"block" : "none";',
+'				if (enable) {',
+'					removeClass($("search"), "greyedout");',
+'					addClass(document.body, "searching");',
+'					if ($("searchHighlight").checked) {',
+'						addClass(logMainContainer, "searchhighlight");',
+'					} else {',
+'						removeClass(logMainContainer, "searchhighlight");',
+'					}',
+'					if ($("searchFilter").checked) {',
+'						addClass(logMainContainer, "searchfilter");',
+'					} else {',
+'						removeClass(logMainContainer, "searchfilter");',
+'					}',
+'					$("searchDisable").checked = !enable;',
+'				} else {',
+'					addClass($("search"), "greyedout");',
+'					removeClass(document.body, "searching");',
+'					removeClass(logMainContainer, "searchhighlight");',
+'					removeClass(logMainContainer, "searchfilter");',
+'				}',
+'				setLogContainerHeight();',
+'			}',
+'',
+'			function toggleSearchFilter() {',
+'				var enable = $("searchFilter").checked;',
+'				if (enable) {',
+'					addClass(logMainContainer, "searchfilter");',
+'				} else {',
+'					removeClass(logMainContainer, "searchfilter");',
+'				}',
+'				refreshCurrentMatch();',
+'			}',
+'',
+'			function toggleSearchHighlight() {',
+'				var enable = $("searchHighlight").checked;',
+'				if (enable) {',
+'					addClass(logMainContainer, "searchhighlight");',
+'				} else {',
+'					removeClass(logMainContainer, "searchhighlight");',
+'				}',
+'			}',
+'',
+'			function clearSearch() {',
+'				$("searchBox").value = "";',
+'				doSearch();',
+'			}',
+'',
+'			function searchNext() {',
+'				if (currentSearch !== null && currentMatchIndex !== null) {',
+'					currentSearch.matches[currentMatchIndex].setNotCurrent();',
+'					var nextMatchIndex = currentSearch.getNextVisibleMatchIndex();',
+'					if (nextMatchIndex > currentMatchIndex || confirm("Reached the end of the page. Start from the top?")) {',
+'						setCurrentMatchIndex(nextMatchIndex);',
+'					}',
+'				}',
+'			}',
+'',
+'			function searchPrevious() {',
+'				if (currentSearch !== null && currentMatchIndex !== null) {',
+'					currentSearch.matches[currentMatchIndex].setNotCurrent();',
+'					var previousMatchIndex = currentSearch.getPreviousVisibleMatchIndex();',
+'					if (previousMatchIndex < currentMatchIndex || confirm("Reached the start of the page. Continue from the bottom?")) {',
+'						setCurrentMatchIndex(previousMatchIndex);',
+'					}',
+'				}',
+'			}',
+'',
+'			function setCurrentMatchIndex(index) {',
+'				currentMatchIndex = index;',
+'				currentSearch.matches[currentMatchIndex].setCurrent();',
+'			}',
+'',
+'			/* ------------------------------------------------------------------------- */',
+'',
+'			// CSS Utilities',
+'',
+'			function addClass(el, cssClass) {',
+'				if (!hasClass(el, cssClass)) {',
+'					if (el.className) {',
+'						el.className += " " + cssClass;',
+'					} else {',
+'						el.className = cssClass;',
+'					}',
+'				}',
+'			}',
+'',
+'			function hasClass(el, cssClass) {',
+'				if (el.className) {',
+'					var classNames = el.className.split(" ");',
+'					return array_contains(classNames, cssClass);',
+'				}',
+'				return false;',
+'			}',
+'',
+'			function removeClass(el, cssClass) {',
+'				if (hasClass(el, cssClass)) {',
+'					// Rebuild the className property',
+'					var existingClasses = el.className.split(" ");',
+'					var newClasses = [];',
+'					for (var i = 0, len = existingClasses.length; i < len; i++) {',
+'						if (existingClasses[i] != cssClass) {',
+'							newClasses[newClasses.length] = existingClasses[i];',
+'						}',
+'					}',
+'					el.className = newClasses.join(" ");',
+'				}',
+'			}',
+'',
+'			function replaceClass(el, newCssClass, oldCssClass) {',
+'				removeClass(el, oldCssClass);',
+'				addClass(el, newCssClass);',
+'			}',
+'',
+'			/* ------------------------------------------------------------------------- */',
+'',
+'			// Other utility functions',
+'',
+'			function getElementsByClass(el, cssClass, tagName) {',
+'				var elements = el.getElementsByTagName(tagName);',
+'				var matches = [];',
+'				for (var i = 0, len = elements.length; i < len; i++) {',
+'					if (hasClass(elements[i], cssClass)) {',
+'						matches.push(elements[i]);',
+'					}',
+'				}',
+'				return matches;',
+'			}',
+'',
+'			// Syntax borrowed from Prototype library',
+'			function $(id) {',
+'				return document.getElementById(id);',
+'			}',
+'',
+'			function isDescendant(node, ancestorNode) {',
+'				while (node != null) {',
+'					if (node === ancestorNode) {',
+'						return true;',
+'					}',
+'					node = node.parentNode;',
+'				}',
+'				return false;',
+'			}',
+'',
+'			function isOrphan(node) {',
+'				var currentNode = node;',
+'				while (currentNode) {',
+'					if (currentNode == document.body) {',
+'						return false;',
+'					}',
+'					currentNode = currentNode.parentNode;',
+'				}',
+'				return true;',
+'			}',
+'',
+'			function escapeHtml(str) {',
+'				return str.replace(/&/g, "&amp;").replace(/[<]/g, "&lt;").replace(/>/g, "&gt;");',
+'			}',
+'',
+'			function getWindowWidth() {',
+'				if (window.innerWidth) {',
+'					return window.innerWidth;',
+'				} else if (document.documentElement && document.documentElement.clientWidth) {',
+'					return document.documentElement.clientWidth;',
+'				} else if (document.body) {',
+'					return document.body.clientWidth;',
+'				}',
+'				return 0;',
+'			}',
+'',
+'			function getWindowHeight() {',
+'				if (window.innerHeight) {',
+'					return window.innerHeight;',
+'				} else if (document.documentElement && document.documentElement.clientHeight) {',
+'					return document.documentElement.clientHeight;',
+'				} else if (document.body) {',
+'					return document.body.clientHeight;',
+'				}',
+'				return 0;',
+'			}',
+'',
+'			function getToolBarsHeight() {',
+'				return $("switches").offsetHeight;',
+'			}',
+'',
+'			function getChromeHeight() {',
+'				var height = getToolBarsHeight();',
+'				if (showCommandLine) {',
+'					height += $("commandLine").offsetHeight;',
+'				}',
+'				return height;',
+'			}',
+'',
+'			function setLogContainerHeight() {',
+'				if (logMainContainer) {',
+'					var windowHeight = getWindowHeight();',
+'					$("body").style.height = getWindowHeight() + "px";',
+'					logMainContainer.style.height = "" +',
+'						Math.max(0, windowHeight - getChromeHeight()) + "px";',
+'				}',
+'			}',
+'',
+'			function setCommandInputWidth() {',
+'				if (showCommandLine) {',
+'					$("command").style.width = "" + Math.max(0, $("commandLineContainer").offsetWidth -',
+'						($("evaluateButton").offsetWidth + 13)) + "px";',
+'				}',
+'			}',
+'',
+'			window.onresize = function() {',
+'				setCommandInputWidth();',
+'				setLogContainerHeight();',
+'			};',
+'',
+'			if (!Array.prototype.push) {',
+'				Array.prototype.push = function() {',
+'			        for (var i = 0, len = arguments.length; i < len; i++){',
+'			            this[this.length] = arguments[i];',
+'			        }',
+'			        return this.length;',
+'				};',
+'			}',
+'',
+'			if (!Array.prototype.pop) {',
+'				Array.prototype.pop = function() {',
+'					if (this.length > 0) {',
+'						var val = this[this.length - 1];',
+'						this.length = this.length - 1;',
+'						return val;',
+'					}',
+'				};',
+'			}',
+'',
+'			if (!Array.prototype.shift) {',
+'				Array.prototype.shift = function() {',
+'					if (this.length > 0) {',
+'						var firstItem = this[0];',
+'						for (var i = 0, len = this.length - 1; i < len; i++) {',
+'							this[i] = this[i + 1];',
+'						}',
+'						this.length = this.length - 1;',
+'						return firstItem;',
+'					}',
+'				};',
+'			}',
+'',
+'			if (!Array.prototype.splice) {',
+'				Array.prototype.splice = function(startIndex, deleteCount) {',
+'					var itemsAfterDeleted = this.slice(startIndex + deleteCount);',
+'					var itemsDeleted = this.slice(startIndex, startIndex + deleteCount);',
+'					this.length = startIndex;',
+'					// Copy the arguments into a proper Array object',
+'					var argumentsArray = [];',
+'					for (var i = 0, len = arguments.length; i < len; i++) {',
+'						argumentsArray[i] = arguments[i];',
+'					}',
+'					var itemsToAppend = (argumentsArray.length > 2) ?',
+'						itemsAfterDeleted = argumentsArray.slice(2).concat(itemsAfterDeleted) : itemsAfterDeleted;',
+'					for (i = 0, len = itemsToAppend.length; i < len; i++) {',
+'						this.push(itemsToAppend[i]);',
+'					}',
+'					return itemsDeleted;',
+'				};',
+'			}',
+'',
+'			function array_remove(arr, val) {',
+'				var index = -1;',
+'				for (var i = 0, len = arr.length; i < len; i++) {',
+'					if (arr[i] === val) {',
+'						index = i;',
+'						break;',
+'					}',
+'				}',
+'				if (index >= 0) {',
+'					arr.splice(index, 1);',
+'					return index;',
+'				} else {',
+'					return false;',
+'				}',
+'			}',
+'',
+'			function array_removeFromStart(array, numberToRemove) {',
+'				if (Array.prototype.splice) {',
+'					array.splice(0, numberToRemove);',
+'				} else {',
+'					for (var i = numberToRemove, len = array.length; i < len; i++) {',
+'						array[i - numberToRemove] = array[i];',
+'					}',
+'					array.length = array.length - numberToRemove;',
+'				}',
+'				return array;',
+'			}',
+'',
+'			function array_contains(arr, val) {',
+'				for (var i = 0, len = arr.length; i < len; i++) {',
+'					if (arr[i] == val) {',
+'						return true;',
+'					}',
+'				}',
+'				return false;',
+'			}',
+'',
+'			function getErrorMessage(ex) {',
+'				if (ex.message) {',
+'					return ex.message;',
+'				} else if (ex.description) {',
+'					return ex.description;',
+'				}',
+'				return "" + ex;',
+'			}',
+'',
+'			function moveCaretToEnd(input) {',
+'				if (input.setSelectionRange) {',
+'					input.focus();',
+'					var length = input.value.length;',
+'					input.setSelectionRange(length, length);',
+'				} else if (input.createTextRange) {',
+'					var range = input.createTextRange();',
+'					range.collapse(false);',
+'					range.select();',
+'				}',
+'				input.focus();',
+'			}',
+'',
+'			function stopPropagation(evt) {',
+'				if (evt.stopPropagation) {',
+'					evt.stopPropagation();',
+'				} else if (typeof evt.cancelBubble != "undefined") {',
+'					evt.cancelBubble = true;',
+'				}',
+'			}',
+'',
+'			function getEvent(evt) {',
+'				return evt ? evt : event;',
+'			}',
+'',
+'			function getTarget(evt) {',
+'				return evt.target ? evt.target : evt.srcElement;',
+'			}',
+'',
+'			function getRelatedTarget(evt) {',
+'				if (evt.relatedTarget) {',
+'					return evt.relatedTarget;',
+'				} else if (evt.srcElement) {',
+'					switch(evt.type) {',
+'						case "mouseover":',
+'							return evt.fromElement;',
+'						case "mouseout":',
+'							return evt.toElement;',
+'						default:',
+'							return evt.srcElement;',
+'					}',
+'				}',
+'			}',
+'',
+'			function cancelKeyEvent(evt) {',
+'				evt.returnValue = false;',
+'				stopPropagation(evt);',
+'			}',
+'',
+'			function evalCommandLine() {',
+'				var expr = $("command").value;',
+'				evalCommand(expr);',
+'				$("command").value = "";',
+'			}',
+'',
+'			function evalLastCommand() {',
+'				if (lastCommand != null) {',
+'					evalCommand(lastCommand);',
+'				}',
+'			}',
+'',
+'			var lastCommand = null;',
+'			var commandHistory = [];',
+'			var currentCommandIndex = 0;',
+'',
+'			function evalCommand(expr) {',
+'				if (appender) {',
+'					appender.evalCommandAndAppend(expr);',
+'				} else {',
+'					var prefix = ">>> " + expr + "\\r\\n";',
+'					try {',
+'						log("INFO", prefix + eval(expr));',
+'					} catch (ex) {',
+'						log("ERROR", prefix + "Error: " + getErrorMessage(ex));',
+'					}',
+'				}',
+'				// Update command history',
+'				if (expr != commandHistory[commandHistory.length - 1]) {',
+'					commandHistory.push(expr);',
+'					// Update the appender',
+'					if (appender) {',
+'						appender.storeCommandHistory(commandHistory);',
+'					}',
+'				}',
+'				currentCommandIndex = (expr == commandHistory[currentCommandIndex]) ? currentCommandIndex + 1 : commandHistory.length;',
+'				lastCommand = expr;',
+'			}',
+'			//]]>',
+'		</script>',
+'		<style type="text/css">',
+'			body {',
+'				background-color: white;',
+'				color: black;',
+'				padding: 0;',
+'				margin: 0;',
+'				font-family: tahoma, verdana, arial, helvetica, sans-serif;',
+'				overflow: hidden;',
+'			}',
+'',
+'			div#switchesContainer input {',
+'				margin-bottom: 0;',
+'			}',
+'',
+'			div.toolbar {',
+'				border-top: solid #ffffff 1px;',
+'				border-bottom: solid #aca899 1px;',
+'				background-color: #f1efe7;',
+'				padding: 3px 5px;',
+'				font-size: 68.75%;',
+'			}',
+'',
+'			div.toolbar, div#search input {',
+'				font-family: tahoma, verdana, arial, helvetica, sans-serif;',
+'			}',
+'',
+'			div.toolbar input.button {',
+'				padding: 0 5px;',
+'				font-size: 100%;',
+'			}',
+'',
+'			div.toolbar input.hidden {',
+'				display: none;',
+'			}',
+'',
+'			div#switches input#clearButton {',
+'				margin-left: 20px;',
+'			}',
+'',
+'			div#levels label {',
+'				font-weight: bold;',
+'			}',
+'',
+'			div#levels label, div#options label {',
+'				margin-right: 5px;',
+'			}',
+'',
+'			div#levels label#wrapLabel {',
+'				font-weight: normal;',
+'			}',
+'',
+'			div#search label {',
+'				margin-right: 10px;',
+'			}',
+'',
+'			div#search label.searchboxlabel {',
+'				margin-right: 0;',
+'			}',
+'',
+'			div#search input {',
+'				font-size: 100%;',
+'			}',
+'',
+'			div#search input.validregex {',
+'				color: green;',
+'			}',
+'',
+'			div#search input.invalidregex {',
+'				color: red;',
+'			}',
+'',
+'			div#search input.nomatches {',
+'				color: white;',
+'				background-color: #ff6666;',
+'			}',
+'',
+'			div#search input.nomatches {',
+'				color: white;',
+'				background-color: #ff6666;',
+'			}',
+'',
+'			div#searchNav {',
+'				display: none;',
+'			}',
+'',
+'			div#commandLine {',
+'				display: none;',
+'			}',
+'',
+'			div#commandLine input#command {',
+'				font-size: 100%;',
+'				font-family: Courier New, Courier;',
+'			}',
+'',
+'			div#commandLine input#evaluateButton {',
+'			}',
+'',
+'			*.greyedout {',
+'				color: gray !important;',
+'				border-color: gray !important;',
+'			}',
+'',
+'			*.greyedout *.alwaysenabled { color: black; }',
+'',
+'			*.unselectable {',
+'				-khtml-user-select: none;',
+'				-moz-user-select: none;',
+'				user-select: none;',
+'			}',
+'',
+'			div#log {',
+'				font-family: Courier New, Courier;',
+'				font-size: 75%;',
+'				width: 100%;',
+'				overflow: auto;',
+'				clear: both;',
+'				position: relative;',
+'			}',
+'',
+'			div.group {',
+'				border-color: #cccccc;',
+'				border-style: solid;',
+'				border-width: 1px 0 1px 1px;',
+'				overflow: visible;',
+'			}',
+'',
+'			div.oldIe div.group, div.oldIe div.group *, div.oldIe *.logentry {',
+'				height: 1%;',
+'			}',
+'',
+'			div.group div.groupheading span.expander {',
+'				border: solid black 1px;',
+'				font-family: Courier New, Courier;',
+'				font-size: 0.833em;',
+'				background-color: #eeeeee;',
+'				position: relative;',
+'				top: -1px;',
+'				color: black;',
+'				padding: 0 2px;',
+'				cursor: pointer;',
+'				cursor: hand;',
+'				height: 1%;',
+'			}',
+'',
+'			div.group div.groupcontent {',
+'				margin-left: 10px;',
+'				padding-bottom: 2px;',
+'				overflow: visible;',
+'			}',
+'',
+'			div.group div.expanded {',
+'				display: block;',
+'			}',
+'',
+'			div.group div.collapsed {',
+'				display: none;',
+'			}',
+'',
+'			*.logentry {',
+'				overflow: visible;',
+'				display: none;',
+'				white-space: pre;',
+'			}',
+'',
+'			span.pre {',
+'				white-space: pre;',
+'			}',
+'			',
+'			pre.unwrapped {',
+'				display: inline !important;',
+'			}',
+'',
+'			pre.unwrapped pre.pre, div.wrapped pre.pre {',
+'				display: inline;',
+'			}',
+'',
+'			div.wrapped pre.pre {',
+'				white-space: normal;',
+'			}',
+'',
+'			div.wrapped {',
+'				display: none;',
+'			}',
+'',
+'			body.searching *.logentry span.currentmatch {',
+'				color: white !important;',
+'				background-color: green !important;',
+'			}',
+'',
+'			body.searching div.searchhighlight *.logentry span.searchterm {',
+'				color: black;',
+'				background-color: yellow;',
+'			}',
+'',
+'			div.wrap *.logentry {',
+'				white-space: normal !important;',
+'				border-width: 0 0 1px 0;',
+'				border-color: #dddddd;',
+'				border-style: dotted;',
+'			}',
+'',
+'			div.wrap #log_wrapped, #log_unwrapped {',
+'				display: block;',
+'			}',
+'',
+'			div.wrap #log_unwrapped, #log_wrapped {',
+'				display: none;',
+'			}',
+'',
+'			div.wrap *.logentry span.pre {',
+'				overflow: visible;',
+'				white-space: normal;',
+'			}',
+'',
+'			div.wrap *.logentry pre.unwrapped {',
+'				display: none;',
+'			}',
+'',
+'			div.wrap *.logentry span.wrapped {',
+'				display: inline;',
+'			}',
+'',
+'			div.searchfilter *.searchnonmatch {',
+'				display: none !important;',
+'			}',
+'',
+'			div#log *.TRACE, label#label_TRACE {',
+'				color: #666666;',
+'			}',
+'',
+'			div#log *.DEBUG, label#label_DEBUG {',
+'				color: green;',
+'			}',
+'',
+'			div#log *.INFO, label#label_INFO {',
+'				color: #000099;',
+'			}',
+'',
+'			div#log *.WARN, label#label_WARN {',
+'				color: #999900;',
+'			}',
+'',
+'			div#log *.ERROR, label#label_ERROR {',
+'				color: red;',
+'			}',
+'',
+'			div#log *.FATAL, label#label_FATAL {',
+'				color: #660066;',
+'			}',
+'',
+'			div.TRACE#log *.TRACE,',
+'			div.DEBUG#log *.DEBUG,',
+'			div.INFO#log *.INFO,',
+'			div.WARN#log *.WARN,',
+'			div.ERROR#log *.ERROR,',
+'			div.FATAL#log *.FATAL {',
+'				display: block;',
+'			}',
+'',
+'			div#log div.separator {',
+'				background-color: #cccccc;',
+'				margin: 5px 0;',
+'				line-height: 1px;',
+'			}',
+'		</style>',
+'	</head>',
+'',
+'	<body id="body">',
+'		<div id="switchesContainer">',
+'			<div id="switches">',
+'				<div id="levels" class="toolbar">',
+'					Filters:',
+'					<input type="checkbox" id="switch_TRACE" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide trace messages" /><label for="switch_TRACE" id="label_TRACE">trace</label>',
+'					<input type="checkbox" id="switch_DEBUG" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide debug messages" /><label for="switch_DEBUG" id="label_DEBUG">debug</label>',
+'					<input type="checkbox" id="switch_INFO" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide info messages" /><label for="switch_INFO" id="label_INFO">info</label>',
+'					<input type="checkbox" id="switch_WARN" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide warn messages" /><label for="switch_WARN" id="label_WARN">warn</label>',
+'					<input type="checkbox" id="switch_ERROR" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide error messages" /><label for="switch_ERROR" id="label_ERROR">error</label>',
+'					<input type="checkbox" id="switch_FATAL" onclick="applyFilters(); checkAllLevels()" checked="checked" title="Show/hide fatal messages" /><label for="switch_FATAL" id="label_FATAL">fatal</label>',
+'					<input type="checkbox" id="switch_ALL" onclick="toggleAllLevels(); applyFilters()" checked="checked" title="Show/hide all messages" /><label for="switch_ALL" id="label_ALL">all</label>',
+'				</div>',
+'				<div id="search" class="toolbar">',
+'					<label for="searchBox" class="searchboxlabel">Search:</label> <input type="text" id="searchBox" onclick="toggleSearchEnabled(true)" onkeyup="scheduleSearch()" size="20" />',
+'					<input type="button" id="searchReset" disabled="disabled" value="Reset" onclick="clearSearch()" class="button" title="Reset the search" />',
+'					<input type="checkbox" id="searchRegex" onclick="doSearch()" title="If checked, search is treated as a regular expression" /><label for="searchRegex">Regex</label>',
+'					<input type="checkbox" id="searchCaseSensitive" onclick="doSearch()" title="If checked, search is case sensitive" /><label for="searchCaseSensitive">Match case</label>',
+'					<input type="checkbox" id="searchDisable" onclick="toggleSearchEnabled()" title="Enable/disable search" /><label for="searchDisable" class="alwaysenabled">Disable</label>',
+'					<div id="searchNav">',
+'						<input type="button" id="searchNext" disabled="disabled" value="Next" onclick="searchNext()" class="button" title="Go to the next matching log entry" />',
+'						<input type="button" id="searchPrevious" disabled="disabled" value="Previous" onclick="searchPrevious()" class="button" title="Go to the previous matching log entry" />',
+'						<input type="checkbox" id="searchFilter" onclick="toggleSearchFilter()" title="If checked, non-matching log entries are filtered out" /><label for="searchFilter">Filter</label>',
+'						<input type="checkbox" id="searchHighlight" onclick="toggleSearchHighlight()" title="Highlight matched search terms" /><label for="searchHighlight" class="alwaysenabled">Highlight all</label>',
+'					</div>',
+'				</div>',
+'				<div id="options" class="toolbar">',
+'					Options:',
+'					<input type="checkbox" id="enableLogging" onclick="toggleLoggingEnabled()" checked="checked" title="Enable/disable logging" /><label for="enableLogging" id="enableLoggingLabel">Log</label>',
+'					<input type="checkbox" id="wrap" onclick="toggleWrap()" title="Enable / disable word wrap" /><label for="wrap" id="wrapLabel">Wrap</label>',
+'					<input type="checkbox" id="newestAtTop" onclick="toggleNewestAtTop()" title="If checked, causes newest messages to appear at the top" /><label for="newestAtTop" id="newestAtTopLabel">Newest at the top</label>',
+'					<input type="checkbox" id="scrollToLatest" onclick="toggleScrollToLatest()" checked="checked" title="If checked, window automatically scrolls to a new message when it is added" /><label for="scrollToLatest" id="scrollToLatestLabel">Scroll to latest</label>',
+'					<input type="button" id="clearButton" value="Clear" onclick="clearLog()" class="button" title="Clear all log messages"  />',
+'					<input type="button" id="hideButton" value="Hide" onclick="hide()" class="hidden button" title="Hide the console" />',
+'					<input type="button" id="closeButton" value="Close" onclick="closeWindow()" class="hidden button" title="Close the window" />',
+'				</div>',
+'			</div>',
+'		</div>',
+'		<div id="log" class="TRACE DEBUG INFO WARN ERROR FATAL"></div>',
+'		<div id="commandLine" class="toolbar">',
+'			<div id="commandLineContainer">',
+'				<input type="text" id="command" title="Enter a JavaScript command here and hit return or press \'Evaluate\'" />',
+'				<input type="button" id="evaluateButton" value="Evaluate" class="button" title="Evaluate the command" onclick="evalCommandLine()" />',
+'			</div>',
+'		</div>',
+'	</body>',
+'</html>',
+''
+];
+		};
+
+		var defaultCommandLineFunctions = [];
+
+		ConsoleAppender = function() {};
+
+		var consoleAppenderIdCounter = 1;
+		ConsoleAppender.prototype = new Appender();
+
+		ConsoleAppender.prototype.create = function(inPage, container,
+				lazyInit, initiallyMinimized, useDocumentWrite, width, height, focusConsoleWindow) {
+			var appender = this;
+
+			// Common properties
+			var initialized = false;
+			var consoleWindowCreated = false;
+			var consoleWindowLoaded = false;
+			var consoleClosed = false;
+
+			var queuedLoggingEvents = [];
+			var isSupported = true;
+			var consoleAppenderId = consoleAppenderIdCounter++;
+
+			// Local variables
+			initiallyMinimized = extractBooleanFromParam(initiallyMinimized, this.defaults.initiallyMinimized);
+			lazyInit = extractBooleanFromParam(lazyInit, this.defaults.lazyInit);
+			useDocumentWrite = extractBooleanFromParam(useDocumentWrite, this.defaults.useDocumentWrite);
+			var newestMessageAtTop = this.defaults.newestMessageAtTop;
+			var scrollToLatestMessage = this.defaults.scrollToLatestMessage;
+			width = width ? width : this.defaults.width;
+			height = height ? height : this.defaults.height;
+			var maxMessages = this.defaults.maxMessages;
+			var showCommandLine = this.defaults.showCommandLine;
+			var commandLineObjectExpansionDepth = this.defaults.commandLineObjectExpansionDepth;
+			var showHideButton = this.defaults.showHideButton;
+            var showCloseButton = this.defaults.showCloseButton;
+            var showLogEntryDeleteButtons = this.defaults.showLogEntryDeleteButtons;
+
+			this.setLayout(this.defaults.layout);
+
+			// Functions whose implementations vary between subclasses
+			var init, createWindow, safeToAppend, getConsoleWindow, open;
+
+			// Configuration methods. The function scope is used to prevent
+			// direct alteration to the appender configuration properties.
+			var appenderName = inPage ? "InPageAppender" : "PopUpAppender";
+			var checkCanConfigure = function(configOptionName) {
+				if (consoleWindowCreated) {
+					handleError(appenderName + ": configuration option '" + configOptionName + "' may not be set after the appender has been initialized");
+					return false;
+				}
+				return true;
+			};
+
+			var consoleWindowExists = function() {
+				return (consoleWindowLoaded && isSupported && !consoleClosed);
+			};
+
+			this.isNewestMessageAtTop = function() { return newestMessageAtTop; };
+			this.setNewestMessageAtTop = function(newestMessageAtTopParam) {
+				newestMessageAtTop = bool(newestMessageAtTopParam);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setNewestAtTop(newestMessageAtTop);
+				}
+			};
+
+			this.isScrollToLatestMessage = function() { return scrollToLatestMessage; };
+			this.setScrollToLatestMessage = function(scrollToLatestMessageParam) {
+				scrollToLatestMessage = bool(scrollToLatestMessageParam);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setScrollToLatest(scrollToLatestMessage);
+				}
+			};
+
+			this.getWidth = function() { return width; };
+			this.setWidth = function(widthParam) {
+				if (checkCanConfigure("width")) {
+					width = extractStringFromParam(widthParam, width);
+				}
+			};
+
+			this.getHeight = function() { return height; };
+			this.setHeight = function(heightParam) {
+				if (checkCanConfigure("height")) {
+					height = extractStringFromParam(heightParam, height);
+				}
+			};
+
+			this.getMaxMessages = function() { return maxMessages; };
+			this.setMaxMessages = function(maxMessagesParam) {
+				maxMessages = extractIntFromParam(maxMessagesParam, maxMessages);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setMaxMessages(maxMessages);
+				}
+			};
+
+			this.isShowCommandLine = function() { return showCommandLine; };
+			this.setShowCommandLine = function(showCommandLineParam) {
+				showCommandLine = bool(showCommandLineParam);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setShowCommandLine(showCommandLine);
+				}
+			};
+
+			this.isShowHideButton = function() { return showHideButton; };
+			this.setShowHideButton = function(showHideButtonParam) {
+				showHideButton = bool(showHideButtonParam);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setShowHideButton(showHideButton);
+				}
+			};
+
+			this.isShowCloseButton = function() { return showCloseButton; };
+			this.setShowCloseButton = function(showCloseButtonParam) {
+				showCloseButton = bool(showCloseButtonParam);
+				if (consoleWindowExists()) {
+					getConsoleWindow().setShowCloseButton(showCloseButton);
+				}
+			};
+
+			this.getCommandLineObjectExpansionDepth = function() { return commandLineObjectExpansionDepth; };
+			this.setCommandLineObjectExpansionDepth = function(commandLineObjectExpansionDepthParam) {
+				commandLineObjectExpansionDepth = extractIntFromParam(commandLineObjectExpansionDepthParam, commandLineObjectExpansionDepth);
+			};
+
+			var minimized = initiallyMinimized;
+			this.isInitiallyMinimized = function() { return initiallyMinimized; };
+			this.setInitiallyMinimized = function(initiallyMinimizedParam) {
+				if (checkCanConfigure("initiallyMinimized")) {
+					initiallyMinimized = bool(initiallyMinimizedParam);
+					minimized = initiallyMinimized;
+				}
+			};
+
+			this.isUseDocumentWrite = function() { return useDocumentWrite; };
+			this.setUseDocumentWrite = function(useDocumentWriteParam) {
+				if (checkCanConfigure("useDocumentWrite")) {
+					useDocumentWrite = bool(useDocumentWriteParam);
+				}
+			};
+
+			// Common methods
+			function QueuedLoggingEvent(loggingEvent, formattedMessage) {
+				this.loggingEvent = loggingEvent;
+				this.levelName = loggingEvent.level.name;
+				this.formattedMessage = formattedMessage;
+			}
+
+			QueuedLoggingEvent.prototype.append = function() {
+				getConsoleWindow().log(this.levelName, this.formattedMessage);
+			};
+
+			function QueuedGroup(name, initiallyExpanded) {
+				this.name = name;
+				this.initiallyExpanded = initiallyExpanded;
+			}
+
+			QueuedGroup.prototype.append = function() {
+				getConsoleWindow().group(this.name, this.initiallyExpanded);
+			};
+
+			function QueuedGroupEnd() {}
+
+			QueuedGroupEnd.prototype.append = function() {
+				getConsoleWindow().groupEnd();
+			};
+
+			var checkAndAppend = function() {
+				// Next line forces a check of whether the window has been closed
+				safeToAppend();
+				if (!initialized) {
+					init();
+				} else if (consoleClosed && reopenWhenClosed) {
+					createWindow();
+				}
+				if (safeToAppend()) {
+					appendQueuedLoggingEvents();
+				}
+			};
+
+			this.append = function(loggingEvent) {
+				if (isSupported) {
+					// Format the message
+					var formattedMessage = appender.getLayout().format(loggingEvent);
+					if (this.getLayout().ignoresThrowable()) {
+						formattedMessage += loggingEvent.getThrowableStrRep();
+					}
+					queuedLoggingEvents.push(new QueuedLoggingEvent(loggingEvent, formattedMessage));
+					checkAndAppend();
+				}
+			};
+
+            this.group = function(name, initiallyExpanded) {
+				if (isSupported) {
+					queuedLoggingEvents.push(new QueuedGroup(name, initiallyExpanded));
+					checkAndAppend();
+				}
+			};
+
+            this.groupEnd = function() {
+				if (isSupported) {
+					queuedLoggingEvents.push(new QueuedGroupEnd());
+					checkAndAppend();
+				}
+			};
+
+			var appendQueuedLoggingEvents = function() {
+				var currentLoggingEvent;
+				while (queuedLoggingEvents.length > 0) {
+					queuedLoggingEvents.shift().append();
+				}
+				if (focusConsoleWindow) {
+					getConsoleWindow().focus();
+				}
+			};
+
+			this.setAddedToLogger = function(logger) {
+				this.loggers.push(logger);
+				if (enabled && !lazyInit) {
+					init();
+				}
+			};
+
+			this.clear = function() {
+				if (consoleWindowExists()) {
+					getConsoleWindow().clearLog();
+				}
+				queuedLoggingEvents.length = 0;
+			};
+
+			this.focus = function() {
+				if (consoleWindowExists()) {
+					getConsoleWindow().focus();
+				}
+			};
+
+			this.focusCommandLine = function() {
+				if (consoleWindowExists()) {
+					getConsoleWindow().focusCommandLine();
+				}
+			};
+
+			this.focusSearch = function() {
+				if (consoleWindowExists()) {
+					getConsoleWindow().focusSearch();
+				}
+			};
+
+			var commandWindow = window;
+
+			this.getCommandWindow = function() { return commandWindow; };
+			this.setCommandWindow = function(commandWindowParam) {
+				commandWindow = commandWindowParam;
+			};
+
+			this.executeLastCommand = function() {
+				if (consoleWindowExists()) {
+					getConsoleWindow().evalLastCommand();
+				}
+			};
+
+			var commandLayout = new PatternLayout("%m");
+			this.getCommandLayout = function() { return commandLayout; };
+			this.setCommandLayout = function(commandLayoutParam) {
+				commandLayout = commandLayoutParam;
+			};
+
+			this.evalCommandAndAppend = function(expr) {
+				var commandReturnValue = { appendResult: true, isError: false };
+				var commandOutput = "";
+				// Evaluate the command
+				try {
+					var result, i;
+					// The next three lines constitute a workaround for IE. Bizarrely, iframes seem to have no
+					// eval method on the window object initially, but once execScript has been called on
+					// it once then the eval method magically appears. See http://www.thismuchiknow.co.uk/?p=25
+					if (!commandWindow.eval && commandWindow.execScript) {
+						commandWindow.execScript("null");
+					}
+
+					var commandLineFunctionsHash = {};
+					for (i = 0, len = commandLineFunctions.length; i < len; i++) {
+						commandLineFunctionsHash[commandLineFunctions[i][0]] = commandLineFunctions[i][1];
+					}
+
+					// Keep an array of variables that are being changed in the command window so that they
+					// can be restored to their original values afterwards
+					var objectsToRestore = [];
+					var addObjectToRestore = function(name) {
+						objectsToRestore.push([name, commandWindow[name]]);
+					};
+
+					addObjectToRestore("appender");
+					commandWindow.appender = appender;
+
+					addObjectToRestore("commandReturnValue");
+					commandWindow.commandReturnValue = commandReturnValue;
+
+					addObjectToRestore("commandLineFunctionsHash");
+					commandWindow.commandLineFunctionsHash = commandLineFunctionsHash;
+
+					var addFunctionToWindow = function(name) {
+						addObjectToRestore(name);
+						commandWindow[name] = function() {
+							return this.commandLineFunctionsHash[name](appender, arguments, commandReturnValue);
+						};
+					};
+
+					for (i = 0, len = commandLineFunctions.length; i < len; i++) {
+						addFunctionToWindow(commandLineFunctions[i][0]);
+					}
+
+					// Another bizarre workaround to get IE to eval in the global scope
+					if (commandWindow === window && commandWindow.execScript) {
+						addObjectToRestore("evalExpr");
+						addObjectToRestore("result");
+						window.evalExpr = expr;
+						commandWindow.execScript("window.result=eval(window.evalExpr);");
+						result = window.result;
+ 					} else {
+ 						result = commandWindow.eval(expr);
+ 					}
+					commandOutput = isUndefined(result) ? result : formatObjectExpansion(result, commandLineObjectExpansionDepth);
+
+					// Restore variables in the command window to their original state
+					for (i = 0, len = objectsToRestore.length; i < len; i++) {
+						commandWindow[objectsToRestore[i][0]] = objectsToRestore[i][1];
+					}
+				} catch (ex) {
+					commandOutput = "Error evaluating command: " + getExceptionStringRep(ex);
+					commandReturnValue.isError = true;
+				}
+				// Append command output
+				if (commandReturnValue.appendResult) {
+					var message = ">>> " + expr;
+					if (!isUndefined(commandOutput)) {
+						message += newLine + commandOutput;
+					}
+					var level = commandReturnValue.isError ? Level.ERROR : Level.INFO;
+					var loggingEvent = new LoggingEvent(null, new Date(), level, [message], null);
+					var mainLayout = this.getLayout();
+					this.setLayout(commandLayout);
+					this.append(loggingEvent);
+					this.setLayout(mainLayout);
+				}
+			};
+
+			var commandLineFunctions = defaultCommandLineFunctions.concat([]);
+
+			this.addCommandLineFunction = function(functionName, commandLineFunction) {
+				commandLineFunctions.push([functionName, commandLineFunction]);
+			};
+
+			var commandHistoryCookieName = "log4javascriptCommandHistory";
+			this.storeCommandHistory = function(commandHistory) {
+				setCookie(commandHistoryCookieName, commandHistory.join(","));
+			};
+
+			var writeHtml = function(doc) {
+				var lines = getConsoleHtmlLines();
+				doc.open();
+				for (var i = 0, len = lines.length; i < len; i++) {
+					doc.writeln(lines[i]);
+				}
+				doc.close();
+			};
+
+			// Set up event listeners
+			this.setEventTypes(["load", "unload"]);
+
+			var consoleWindowLoadHandler = function() {
+				var win = getConsoleWindow();
+				win.setAppender(appender);
+				win.setNewestAtTop(newestMessageAtTop);
+				win.setScrollToLatest(scrollToLatestMessage);
+				win.setMaxMessages(maxMessages);
+				win.setShowCommandLine(showCommandLine);
+				win.setShowHideButton(showHideButton);
+				win.setShowCloseButton(showCloseButton);
+				win.setMainWindow(window);
+
+				// Restore command history stored in cookie
+				var storedValue = getCookie(commandHistoryCookieName);
+				if (storedValue) {
+					win.commandHistory = storedValue.split(",");
+					win.currentCommandIndex = win.commandHistory.length;
+				}
+
+				appender.dispatchEvent("load", { "win" : win });
+			};
+
+			this.unload = function() {
+				logLog.debug("unload " + this + ", caller: " + this.unload.caller);
+				if (!consoleClosed) {
+					logLog.debug("really doing unload " + this);
+					consoleClosed = true;
+					consoleWindowLoaded = false;
+					consoleWindowCreated = false;
+					appender.dispatchEvent("unload", {});
+				}
+			};
+
+			var pollConsoleWindow = function(windowTest, interval, successCallback, errorMessage) {
+				function doPoll() {
+					try {
+						// Test if the console has been closed while polling
+						if (consoleClosed) {
+							clearInterval(poll);
+						}
+						if (windowTest(getConsoleWindow())) {
+							clearInterval(poll);
+							successCallback();
+						}
+					} catch (ex) {
+						clearInterval(poll);
+						isSupported = false;
+						handleError(errorMessage, ex);
+					}
+				}
+
+				// Poll the pop-up since the onload event is not reliable
+				var poll = setInterval(doPoll, interval);
+			};
+
+			var getConsoleUrl = function() {
+				var documentDomainSet = (document.domain != location.hostname);
+				return useDocumentWrite ? "" : getBaseUrl() + "console_uncompressed.html" +
+											   (documentDomainSet ? "?log4javascript_domain=" + escape(document.domain) : "");
+			};
+
+			// Define methods and properties that vary between subclasses
+			if (inPage) {
+				// InPageAppender
+
+				var containerElement = null;
+
+				// Configuration methods. The function scope is used to prevent
+				// direct alteration to the appender configuration properties.
+				var cssProperties = [];
+				this.addCssProperty = function(name, value) {
+					if (checkCanConfigure("cssProperties")) {
+						cssProperties.push([name, value]);
+					}
+				};
+
+				// Define useful variables
+				var windowCreationStarted = false;
+				var iframeContainerDiv;
+				var iframeId = uniqueId + "_InPageAppender_" + consoleAppenderId;
+
+				this.hide = function() {
+					if (initialized && consoleWindowCreated) {
+						if (consoleWindowExists()) {
+							getConsoleWindow().$("command").blur();
+						}
+						iframeContainerDiv.style.display = "none";
+						minimized = true;
+					}
+				};
+
+				this.show = function() {
+					if (initialized) {
+						if (consoleWindowCreated) {
+							iframeContainerDiv.style.display = "block";
+							this.setShowCommandLine(showCommandLine); // Force IE to update
+							minimized = false;
+						} else if (!windowCreationStarted) {
+							createWindow(true);
+						}
+					}
+				};
+
+				this.isVisible = function() {
+					return !minimized && !consoleClosed;
+				};
+
+				this.close = function(fromButton) {
+					if (!consoleClosed && (!fromButton || confirm("This will permanently remove the console from the page. No more messages will be logged. Do you wish to continue?"))) {
+						iframeContainerDiv.parentNode.removeChild(iframeContainerDiv);
+						this.unload();
+					}
+				};
+
+				// Create open, init, getConsoleWindow and safeToAppend functions
+				open = function() {
+					var initErrorMessage = "InPageAppender.open: unable to create console iframe";
+
+					function finalInit() {
+						try {
+							if (!initiallyMinimized) {
+								appender.show();
+							}
+							consoleWindowLoadHandler();
+							consoleWindowLoaded = true;
+							appendQueuedLoggingEvents();
+						} catch (ex) {
+							isSupported = false;
+							handleError(initErrorMessage, ex);
+						}
+					}
+
+					function writeToDocument() {
+						try {
+							var windowTest = function(win) { return isLoaded(win); };
+							if (useDocumentWrite) {
+								writeHtml(getConsoleWindow().document);
+							}
+							if (windowTest(getConsoleWindow())) {
+								finalInit();
+							} else {
+								pollConsoleWindow(windowTest, 100, finalInit, initErrorMessage);
+							}
+						} catch (ex) {
+							isSupported = false;
+							handleError(initErrorMessage, ex);
+						}
+					}
+
+					minimized = false;
+					iframeContainerDiv = containerElement.appendChild(document.createElement("div"));
+
+					iframeContainerDiv.style.width = width;
+					iframeContainerDiv.style.height = height;
+					iframeContainerDiv.style.border = "solid gray 1px";
+
+					for (var i = 0, len = cssProperties.length; i < len; i++) {
+						iframeContainerDiv.style[cssProperties[i][0]] = cssProperties[i][1];
+					}
+
+					var iframeSrc = useDocumentWrite ? "" : " src='" + getConsoleUrl() + "'";
+
+					// Adding an iframe using the DOM would be preferable, but it doesn't work
+					// in IE5 on Windows, or in Konqueror prior to version 3.5 - in Konqueror
+					// it creates the iframe fine but I haven't been able to find a way to obtain
+					// the iframe's window object
+					iframeContainerDiv.innerHTML = "<iframe id='" + iframeId + "' name='" + iframeId +
+						"' width='100%' height='100%' frameborder='0'" + iframeSrc +
+						" scrolling='no'></iframe>";
+					consoleClosed = false;
+
+					// Write the console HTML to the iframe
+					var iframeDocumentExistsTest = function(win) {
+						try {
+							return bool(win) && bool(win.document);
+						} catch (ex) {
+							return false;
+						}
+					};
+					if (iframeDocumentExistsTest(getConsoleWindow())) {
+						writeToDocument();
+					} else {
+						pollConsoleWindow(iframeDocumentExistsTest, 100, writeToDocument, initErrorMessage);
+					}
+					consoleWindowCreated = true;
+				};
+
+				createWindow = function(show) {
+					if (show || !initiallyMinimized) {
+						var pageLoadHandler = function() {
+							if (!container) {
+								// Set up default container element
+								containerElement = document.createElement("div");
+								containerElement.style.position = "fixed";
+								containerElement.style.left = "0";
+								containerElement.style.right = "0";
+								containerElement.style.bottom = "0";
+								document.body.appendChild(containerElement);
+								appender.addCssProperty("borderWidth", "1px 0 0 0");
+								appender.addCssProperty("zIndex", 1000000); // Can't find anything authoritative that says how big z-index can be
+								open();
+							} else {
+								try {
+									var el = document.getElementById(container);
+									if (el.nodeType == 1) {
+										containerElement = el;
+									}
+									open();
+								} catch (ex) {
+									handleError("InPageAppender.init: invalid container element '" + container + "' supplied", ex);
+								}
+							}
+						};
+
+						// Test the type of the container supplied. First, check if it's an element
+						if (pageLoaded && container && container.appendChild) {
+							containerElement = container;
+							open();
+						} else if (pageLoaded) {
+							pageLoadHandler();
+						} else {
+							log4javascript.addEventListener("load", pageLoadHandler);
+						}
+						windowCreationStarted = true;
+					}
+				};
+
+				init = function() {
+					createWindow();
+					initialized = true;
+				};
+
+				getConsoleWindow = function() {
+					var iframe = window.frames[iframeId];
+					if (iframe) {
+						return iframe;
+					}
+				};
+
+				safeToAppend = function() {
+					if (isSupported && !consoleClosed) {
+						if (consoleWindowCreated && !consoleWindowLoaded && getConsoleWindow() && isLoaded(getConsoleWindow())) {
+							consoleWindowLoaded = true;
+						}
+						return consoleWindowLoaded;
+					}
+					return false;
+				};
+			} else {
+				// PopUpAppender
+
+				// Extract params
+				var useOldPopUp = appender.defaults.useOldPopUp;
+				var complainAboutPopUpBlocking = appender.defaults.complainAboutPopUpBlocking;
+				var reopenWhenClosed = this.defaults.reopenWhenClosed;
+
+				// Configuration methods. The function scope is used to prevent
+				// direct alteration to the appender configuration properties.
+				this.isUseOldPopUp = function() { return useOldPopUp; };
+				this.setUseOldPopUp = function(useOldPopUpParam) {
+					if (checkCanConfigure("useOldPopUp")) {
+						useOldPopUp = bool(useOldPopUpParam);
+					}
+				};
+
+				this.isComplainAboutPopUpBlocking = function() { return complainAboutPopUpBlocking; };
+				this.setComplainAboutPopUpBlocking = function(complainAboutPopUpBlockingParam) {
+					if (checkCanConfigure("complainAboutPopUpBlocking")) {
+						complainAboutPopUpBlocking = bool(complainAboutPopUpBlockingParam);
+					}
+				};
+
+				this.isFocusPopUp = function() { return focusConsoleWindow; };
+				this.setFocusPopUp = function(focusPopUpParam) {
+					// This property can be safely altered after logging has started
+					focusConsoleWindow = bool(focusPopUpParam);
+				};
+
+				this.isReopenWhenClosed = function() { return reopenWhenClosed; };
+				this.setReopenWhenClosed = function(reopenWhenClosedParam) {
+					// This property can be safely altered after logging has started
+					reopenWhenClosed = bool(reopenWhenClosedParam);
+				};
+
+				this.close = function() {
+					logLog.debug("close " + this);
+					try {
+						popUp.close();
+						this.unload();
+					} catch (ex) {
+						// Do nothing
+					}
+				};
+
+				this.hide = function() {
+					logLog.debug("hide " + this);
+					if (consoleWindowExists()) {
+						this.close();
+					}
+				};
+
+				this.show = function() {
+					logLog.debug("show " + this);
+					if (!consoleWindowCreated) {
+						open();
+					}
+				};
+
+				this.isVisible = function() {
+					return safeToAppend();
+				};
+
+				// Define useful variables
+				var popUp;
+
+				// Create open, init, getConsoleWindow and safeToAppend functions
+				open = function() {
+					var windowProperties = "width=" + width + ",height=" + height + ",status,resizable";
+					var frameInfo = "";
+					try {
+						var frameEl = window.frameElement;
+						if (frameEl) {
+							frameInfo = "_" + frameEl.tagName + "_" + (frameEl.name || frameEl.id || "");
+						}
+					} catch (e) {
+						frameInfo = "_inaccessibleParentFrame";
+					}
+					var windowName = "PopUp_" + location.host.replace(/[^a-z0-9]/gi, "_") + "_" + consoleAppenderId + frameInfo;
+					if (!useOldPopUp || !useDocumentWrite) {
+						// Ensure a previous window isn't used by using a unique name
+						windowName = windowName + "_" + uniqueId;
+					}
+
+					var checkPopUpClosed = function(win) {
+						if (consoleClosed) {
+							return true;
+						} else {
+							try {
+								return bool(win) && win.closed;
+							} catch(ex) {}
+						}
+						return false;
+					};
+
+					var popUpClosedCallback = function() {
+						if (!consoleClosed) {
+							appender.unload();
+						}
+					};
+
+					function finalInit() {
+						getConsoleWindow().setCloseIfOpenerCloses(!useOldPopUp || !useDocumentWrite);
+						consoleWindowLoadHandler();
+						consoleWindowLoaded = true;
+						appendQueuedLoggingEvents();
+						pollConsoleWindow(checkPopUpClosed, 500, popUpClosedCallback,
+								"PopUpAppender.checkPopUpClosed: error checking pop-up window");
+					}
+
+					try {
+						popUp = window.open(getConsoleUrl(), windowName, windowProperties);
+						consoleClosed = false;
+						consoleWindowCreated = true;
+						if (popUp && popUp.document) {
+							if (useDocumentWrite && useOldPopUp && isLoaded(popUp)) {
+								popUp.mainPageReloaded();
+								finalInit();
+							} else {
+								if (useDocumentWrite) {
+									writeHtml(popUp.document);
+								}
+								// Check if the pop-up window object is available
+								var popUpLoadedTest = function(win) { return bool(win) && isLoaded(win); };
+								if (isLoaded(popUp)) {
+									finalInit();
+								} else {
+									pollConsoleWindow(popUpLoadedTest, 100, finalInit,
+											"PopUpAppender.init: unable to create console window");
+								}
+							}
+						} else {
+							isSupported = false;
+							logLog.warn("PopUpAppender.init: pop-ups blocked, please unblock to use PopUpAppender");
+							if (complainAboutPopUpBlocking) {
+								handleError("log4javascript: pop-up windows appear to be blocked. Please unblock them to use pop-up logging.");
+							}
+						}
+					} catch (ex) {
+						handleError("PopUpAppender.init: error creating pop-up", ex);
+					}
+				};
+
+				createWindow = function() {
+					if (!initiallyMinimized) {
+						open();
+					}
+				};
+
+				init = function() {
+					createWindow();
+					initialized = true;
+				};
+
+				getConsoleWindow = function() {
+					return popUp;
+				};
+
+				safeToAppend = function() {
+					if (isSupported && !isUndefined(popUp) && !consoleClosed) {
+						if (popUp.closed ||
+								(consoleWindowLoaded && isUndefined(popUp.closed))) { // Extra check for Opera
+							appender.unload();
+							logLog.debug("PopUpAppender: pop-up closed");
+							return false;
+						}
+						if (!consoleWindowLoaded && isLoaded(popUp)) {
+							consoleWindowLoaded = true;
+						}
+					}
+					return isSupported && consoleWindowLoaded && !consoleClosed;
+				};
+			}
+
+			// Expose getConsoleWindow so that automated tests can check the DOM
+			this.getConsoleWindow = getConsoleWindow;
+		};
+
+		ConsoleAppender.addGlobalCommandLineFunction = function(functionName, commandLineFunction) {
+			defaultCommandLineFunctions.push([functionName, commandLineFunction]);
+		};
+
+		/* ------------------------------------------------------------------ */
+
+		function PopUpAppender(lazyInit, initiallyMinimized, useDocumentWrite,
+							   width, height) {
+			this.create(false, null, lazyInit, initiallyMinimized,
+					useDocumentWrite, width, height, this.defaults.focusPopUp);
+		}
+
+		PopUpAppender.prototype = new ConsoleAppender();
+
+		PopUpAppender.prototype.defaults = {
+			layout: new PatternLayout("%d{HH:mm:ss} %-5p - %m{1}%n"),
+			initiallyMinimized: false,
+			focusPopUp: false,
+			lazyInit: true,
+			useOldPopUp: true,
+			complainAboutPopUpBlocking: true,
+			newestMessageAtTop: false,
+			scrollToLatestMessage: true,
+			width: "600",
+			height: "400",
+			reopenWhenClosed: false,
+			maxMessages: null,
+			showCommandLine: true,
+			commandLineObjectExpansionDepth: 1,
+			showHideButton: false,
+			showCloseButton: true,
+            showLogEntryDeleteButtons: true,
+            useDocumentWrite: true
+		};
+
+		PopUpAppender.prototype.toString = function() {
+			return "PopUpAppender";
+		};
+
+		log4javascript.PopUpAppender = PopUpAppender;
+
+		/* ------------------------------------------------------------------ */
+
+		function InPageAppender(container, lazyInit, initiallyMinimized,
+								useDocumentWrite, width, height) {
+			this.create(true, container, lazyInit, initiallyMinimized,
+					useDocumentWrite, width, height, false);
+		}
+
+		InPageAppender.prototype = new ConsoleAppender();
+
+		InPageAppender.prototype.defaults = {
+			layout: new PatternLayout("%d{HH:mm:ss} %-5p - %m{1}%n"),
+			initiallyMinimized: false,
+			lazyInit: true,
+			newestMessageAtTop: false,
+			scrollToLatestMessage: true,
+			width: "100%",
+			height: "220px",
+			maxMessages: null,
+			showCommandLine: true,
+			commandLineObjectExpansionDepth: 1,
+			showHideButton: false,
+			showCloseButton: false,
+            showLogEntryDeleteButtons: true,
+            useDocumentWrite: true
+		};
+
+		InPageAppender.prototype.toString = function() {
+			return "InPageAppender";
+		};
+
+		log4javascript.InPageAppender = InPageAppender;
+
+		// Next line for backwards compatibility
+		log4javascript.InlineAppender = InPageAppender;
+	})();
+	/* ---------------------------------------------------------------------- */
+	// Console extension functions
+
+	function padWithSpaces(str, len) {
+		if (str.length < len) {
+			var spaces = [];
+			var numberOfSpaces = Math.max(0, len - str.length);
+			for (var i = 0; i < numberOfSpaces; i++) {
+				spaces[i] = " ";
+			}
+			str += spaces.join("");
+		}
+		return str;
+	}
+
+	(function() {
+		function dir(obj) {
+			var maxLen = 0;
+			// Obtain the length of the longest property name
+			for (var p in obj) {
+				maxLen = Math.max(toStr(p).length, maxLen);
+			}
+			// Create the nicely formatted property list
+			var propList = [];
+			for (p in obj) {
+				var propNameStr = "  " + padWithSpaces(toStr(p), maxLen + 2);
+				var propVal;
+				try {
+					propVal = splitIntoLines(toStr(obj[p])).join(padWithSpaces(newLine, maxLen + 6));
+				} catch (ex) {
+					propVal = "[Error obtaining property. Details: " + getExceptionMessage(ex) + "]";
+				}
+				propList.push(propNameStr + propVal);
+			}
+			return propList.join(newLine);
+		}
+
+		var nodeTypes = {
+			ELEMENT_NODE: 1,
+			ATTRIBUTE_NODE: 2,
+			TEXT_NODE: 3,
+			CDATA_SECTION_NODE: 4,
+			ENTITY_REFERENCE_NODE: 5,
+			ENTITY_NODE: 6,
+			PROCESSING_INSTRUCTION_NODE: 7,
+			COMMENT_NODE: 8,
+			DOCUMENT_NODE: 9,
+			DOCUMENT_TYPE_NODE: 10,
+			DOCUMENT_FRAGMENT_NODE: 11,
+			NOTATION_NODE: 12
+		};
+
+		var preFormattedElements = ["script", "pre"];
+
+		// This should be the definitive list, as specified by the XHTML 1.0 Transitional DTD
+		var emptyElements = ["br", "img", "hr", "param", "link", "area", "input", "col", "base", "meta"];
+		var indentationUnit = "  ";
+
+		// Create and return an XHTML string from the node specified
+		function getXhtml(rootNode, includeRootNode, indentation, startNewLine, preformatted) {
+			includeRootNode = (typeof includeRootNode == "undefined") ? true : !!includeRootNode;
+			if (typeof indentation != "string") {
+				indentation = "";
+			}
+			startNewLine = !!startNewLine;
+			preformatted = !!preformatted;
+			var xhtml;
+
+			function isWhitespace(node) {
+				return ((node.nodeType == nodeTypes.TEXT_NODE) && /^[ \t\r\n]*$/.test(node.nodeValue));
+			}
+
+			function fixAttributeValue(attrValue) {
+				return attrValue.toString().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+			}
+
+			function getStyleAttributeValue(el) {
+				var stylePairs = el.style.cssText.split(";");
+				var styleValue = "";
+				var isFirst = true;
+				for (var j = 0, len = stylePairs.length; j < len; j++) {
+					var nameValueBits = stylePairs[j].split(":");
+					var props = [];
+					if (!/^\s*$/.test(nameValueBits[0])) {
+						props.push(trim(nameValueBits[0]).toLowerCase() + ":" + trim(nameValueBits[1]));
+					}
+					styleValue = props.join(";");
+				}
+				return styleValue;
+			}
+
+			function getNamespace(el) {
+				if (el.prefix) {
+					return el.prefix;
+				} else if (el.outerHTML) {
+					var regex = new RegExp("<([^:]+):" + el.tagName + "[^>]*>", "i");
+					if (regex.test(el.outerHTML)) {
+						return RegExp.$1.toLowerCase();
+					}
+				}
+                return "";
+			}
+
+			var lt = "<";
+			var gt = ">";
+
+			if (includeRootNode && rootNode.nodeType != nodeTypes.DOCUMENT_FRAGMENT_NODE) {
+				switch (rootNode.nodeType) {
+					case nodeTypes.ELEMENT_NODE:
+						var tagName = rootNode.tagName.toLowerCase();
+						xhtml = startNewLine ? newLine + indentation : "";
+						xhtml += lt;
+						// Allow for namespaces, where present
+						var prefix = getNamespace(rootNode);
+						var hasPrefix = !!prefix;
+						if (hasPrefix) {
+							xhtml += prefix + ":";
+						}
+						xhtml += tagName;
+						for (i = 0, len = rootNode.attributes.length; i < len; i++) {
+							var currentAttr = rootNode.attributes[i];
+							// Check the attribute is valid.
+							if (!	currentAttr.specified ||
+									currentAttr.nodeValue === null ||
+									currentAttr.nodeName.toLowerCase() === "style" ||
+									typeof currentAttr.nodeValue !== "string" ||
+									currentAttr.nodeName.indexOf("_moz") === 0) {
+								continue;
+							}
+							xhtml += " " + currentAttr.nodeName.toLowerCase() + "=\"";
+							xhtml += fixAttributeValue(currentAttr.nodeValue);
+							xhtml += "\"";
+						}
+						// Style needs to be done separately as it is not reported as an
+						// attribute in IE
+						if (rootNode.style.cssText) {
+							var styleValue = getStyleAttributeValue(rootNode);
+							if (styleValue !== "") {
+								xhtml += " style=\"" + getStyleAttributeValue(rootNode) + "\"";
+							}
+						}
+						if (array_contains(emptyElements, tagName) ||
+								(hasPrefix && !rootNode.hasChildNodes())) {
+							xhtml += "/" + gt;
+						} else {
+							xhtml += gt;
+							// Add output for childNodes collection (which doesn't include attribute nodes)
+							var childStartNewLine = !(rootNode.childNodes.length === 1 &&
+								rootNode.childNodes[0].nodeType === nodeTypes.TEXT_NODE);
+							var childPreformatted = array_contains(preFormattedElements, tagName);
+							for (var i = 0, len = rootNode.childNodes.length; i < len; i++) {
+								xhtml += getXhtml(rootNode.childNodes[i], true, indentation + indentationUnit,
+									childStartNewLine, childPreformatted);
+							}
+							// Add the end tag
+							var endTag = lt + "/" + tagName + gt;
+							xhtml += childStartNewLine ? newLine + indentation + endTag : endTag;
+						}
+						return xhtml;
+					case nodeTypes.TEXT_NODE:
+						if (isWhitespace(rootNode)) {
+							xhtml = "";
+						} else {
+							if (preformatted) {
+								xhtml = rootNode.nodeValue;
+							} else {
+								// Trim whitespace from each line of the text node
+								var lines = splitIntoLines(trim(rootNode.nodeValue));
+								var trimmedLines = [];
+								for (var i = 0, len = lines.length; i < len; i++) {
+									trimmedLines[i] = trim(lines[i]);
+								}
+								xhtml = trimmedLines.join(newLine + indentation);
+							}
+							if (startNewLine) {
+								xhtml = newLine + indentation + xhtml;
+							}
+						}
+						return xhtml;
+					case nodeTypes.CDATA_SECTION_NODE:
+						return "<![CDA" + "TA[" + rootNode.nodeValue + "]" + "]>" + newLine;
+					case nodeTypes.DOCUMENT_NODE:
+						xhtml = "";
+						// Add output for childNodes collection (which doesn't include attribute nodes)
+						for (var i = 0, len = rootNode.childNodes.length; i < len; i++) {
+							xhtml += getXhtml(rootNode.childNodes[i], true, indentation);
+						}
+						return xhtml;
+					default:
+						return "";
+				}
+			} else {
+				xhtml = "";
+				// Add output for childNodes collection (which doesn't include attribute nodes)
+				for (var i = 0, len = rootNode.childNodes.length; i < len; i++) {
+					xhtml += getXhtml(rootNode.childNodes[i], true, indentation + indentationUnit);
+				}
+				return xhtml;
+			}
+		}
+
+		function createCommandLineFunctions() {
+			ConsoleAppender.addGlobalCommandLineFunction("$", function(appender, args, returnValue) {
+				return document.getElementById(args[0]);
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("dir", function(appender, args, returnValue) {
+				var lines = [];
+				for (var i = 0, len = args.length; i < len; i++) {
+					lines[i] = dir(args[i]);
+				}
+				return lines.join(newLine + newLine);
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("dirxml", function(appender, args, returnValue) {
+				var lines = [];
+				for (var i = 0, len = args.length; i < len; i++) {
+					var win = appender.getCommandWindow();
+					lines[i] = getXhtml(args[i]);
+				}
+				return lines.join(newLine + newLine);
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("cd", function(appender, args, returnValue) {
+				var win, message;
+				if (args.length === 0 || args[0] === "") {
+					win = window;
+					message = "Command line set to run in main window";
+				} else {
+					if (args[0].window == args[0]) {
+						win = args[0];
+						message = "Command line set to run in frame '" + args[0].name + "'";
+					} else {
+						win = window.frames[args[0]];
+						if (win) {
+							message = "Command line set to run in frame '" + args[0] + "'";
+						} else {
+							returnValue.isError = true;
+							message = "Frame '" + args[0] + "' does not exist";
+							win = appender.getCommandWindow();
+						}
+					}
+				}
+				appender.setCommandWindow(win);
+				return message;
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("clear", function(appender, args, returnValue) {
+				returnValue.appendResult = false;
+				appender.clear();
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("keys", function(appender, args, returnValue) {
+				var keys = [];
+				for (var k in args[0]) {
+					keys.push(k);
+				}
+				return keys;
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("values", function(appender, args, returnValue) {
+				var values = [];
+				for (var k in args[0]) {
+					try {
+						values.push(args[0][k]);
+					} catch (ex) {
+						logLog.warn("values(): Unable to obtain value for key " + k + ". Details: " + getExceptionMessage(ex));
+					}
+				}
+				return values;
+			});
+
+			ConsoleAppender.addGlobalCommandLineFunction("expansionDepth", function(appender, args, returnValue) {
+				var expansionDepth = parseInt(args[0], 10);
+				if (isNaN(expansionDepth) || expansionDepth < 0) {
+					returnValue.isError = true;
+					return "" + args[0] + " is not a valid expansion depth";
+				} else {
+					appender.setCommandLineObjectExpansionDepth(expansionDepth);
+					return "Object expansion depth set to " + expansionDepth;
+				}
+			});
+		}
+
+		function init() {
+			// Add command line functions
+			createCommandLineFunctions();
+		}
+
+		/* ------------------------------------------------------------------ */
+
+		init();
+	})();
+
+	/* ---------------------------------------------------------------------- */
+	// Main load
+
+   log4javascript.setDocumentReady = function() {
+       pageLoaded = true;
+       log4javascript.dispatchEvent("load", {});
+   };
+
+    if (window.addEventListener) {
+        window.addEventListener("load", log4javascript.setDocumentReady, false);
+    } else if (window.attachEvent) {
+        window.attachEvent("onload", log4javascript.setDocumentReady);
+    } else {
+        var oldOnload = window.onload;
+        if (typeof window.onload != "function") {
+            window.onload = log4javascript.setDocumentReady;
+        } else {
+            window.onload = function(evt) {
+                if (oldOnload) {
+                    oldOnload(evt);
+                }
+                log4javascript.setDocumentReady();
+            };
+        }
+    }
+
+    // Ensure that the log4javascript object is available in the window. This
+    // is necessary for log4javascript to be available in IE if loaded using
+    // Dojo's module system
+    window.log4javascript = log4javascript;
+
+    return log4javascript;
+})();
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript.js
new file mode 100644
index 0000000..eae582b
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript.js
@@ -0,0 +1,23 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var log4javascript_stub=(function(){var log4javascript;function ff(){return function(){};}
+function copy(obj,props){for(var i in props){obj[i]=props[i];}}
+var f=ff();var Logger=ff();copy(Logger.prototype,{addChild:f,getEffectiveAppenders:f,invalidateAppenderCache:f,getAdditivity:f,setAdditivity:f,addAppender:f,removeAppender:f,removeAllAppenders:f,log:f,setLevel:f,getLevel:f,getEffectiveLevel:f,trace:f,debug:f,info:f,warn:f,error:f,fatal:f,isEnabledFor:f,isTraceEnabled:f,isDebugEnabled:f,isInfoEnabled:f,isWarnEnabled:f,isErrorEnabled:f,isFatalEnabled:f,callAppenders:f,group:f,groupEnd:f,time:f,timeEnd:f,assert:f,parent:new Logger()});var getLogger=function(){return new Logger();};function EventSupport(){}
+copy(EventSupport.prototype,{setEventTypes:f,addEventListener:f,removeEventListener:f,dispatchEvent:f,eventTypes:[],eventListeners:{}});function Log4JavaScript(){}
+Log4JavaScript.prototype=new EventSupport();log4javascript=new Log4JavaScript();log4javascript={isStub:true,version:"1.4.6",edition:"log4javascript",setDocumentReady:f,setEventTypes:f,addEventListener:f,removeEventListener:f,dispatchEvent:f,eventTypes:[],eventListeners:{},logLog:{setQuietMode:f,setAlertAllErrors:f,debug:f,displayDebug:f,warn:f,error:f},handleError:f,setEnabled:f,isEnabled:f,setTimeStampsInMilliseconds:f,isTimeStampsInMilliseconds:f,evalInScope:f,setShowStackTraces:f,getLogger:getLogger,getDefaultLogger:getLogger,getNullLogger:getLogger,getRootLogger:getLogger,resetConfiguration:f,Level:ff(),LoggingEvent:ff(),Layout:ff(),Appender:ff()};log4javascript.LoggingEvent.prototype={getThrowableStrRep:f,getCombinedMessages:f};log4javascript.Level.prototype={toString:f,equals:f,isGreaterOrEqual:f};var level=new log4javascript.Level();copy(log4javascript.Level,{ALL:level,TRACE:level,DEBUG:level,INFO:level,WARN:level,ERROR:level,FATAL:level,OFF:level});log4javascript.Layout.prototype={defaults:{},format:f,ignoresThrowable:f,getContentType:f,allowBatching:f,getDataValues:f,setKeys:f,setCustomField:f,hasCustomFields:f,setTimeStampsInMilliseconds:f,isTimeStampsInMilliseconds:f,getTimeStampValue:f,toString:f};log4javascript.SimpleDateFormat=ff();log4javascript.SimpleDateFormat.prototype={setMinimalDaysInFirstWeek:f,getMinimalDaysInFirstWeek:f,format:f};log4javascript.PatternLayout=ff();log4javascript.PatternLayout.prototype=new log4javascript.Layout();log4javascript.Appender=ff();log4javascript.Appender.prototype=new EventSupport();copy(log4javascript.Appender.prototype,{layout:new log4javascript.PatternLayout(),threshold:log4javascript.Level.ALL,loggers:[],doAppend:f,append:f,setLayout:f,getLayout:f,setThreshold:f,getThreshold:f,setAddedToLogger:f,setRemovedFromLogger:f,group:f,groupEnd:f,toString:f});log4javascript.SimpleLayout=ff();log4javascript.SimpleLayout.prototype=new log4javascript.Layout();log4javascript.NullLayout=ff();log4javascript.NullLayout.prototype=new log4javascript.Layout();log4javascript.XmlLayout=ff();log4javascript.XmlLayout.prototype=new log4javascript.Layout();copy(log4javascript.XmlLayout.prototype,{escapeCdata:f,isCombinedMessages:f});log4javascript.JsonLayout=ff();log4javascript.JsonLayout.prototype=new log4javascript.Layout();copy(log4javascript.JsonLayout.prototype,{isReadable:f,isCombinedMessages:f});log4javascript.HttpPostDataLayout=ff();log4javascript.HttpPostDataLayout.prototype=new log4javascript.Layout();log4javascript.PatternLayout=ff();log4javascript.PatternLayout.prototype=new log4javascript.Layout();log4javascript.AlertAppender=ff();log4javascript.AlertAppender.prototype=new log4javascript.Appender();log4javascript.BrowserConsoleAppender=ff();log4javascript.BrowserConsoleAppender.prototype=new log4javascript.Appender();log4javascript.AjaxAppender=ff();log4javascript.AjaxAppender.prototype=new log4javascript.Appender();copy(log4javascript.AjaxAppender.prototype,{getSessionId:f,setSessionId:f,isTimed:f,setTimed:f,getTimerInterval:f,setTimerInterval:f,isWaitForResponse:f,setWaitForResponse:f,getBatchSize:f,setBatchSize:f,isSendAllOnUnload:f,setSendAllOnUnload:f,setRequestSuccessCallback:f,setFailCallback:f,getPostVarName:f,setPostVarName:f,sendAll:f,sendAllRemaining:f,defaults:{requestSuccessCallback:null,failCallback:null}});function ConsoleAppender(){}
+ConsoleAppender.prototype=new log4javascript.Appender();copy(ConsoleAppender.prototype,{create:f,isNewestMessageAtTop:f,setNewestMessageAtTop:f,isScrollToLatestMessage:f,setScrollToLatestMessage:f,getWidth:f,setWidth:f,getHeight:f,setHeight:f,getMaxMessages:f,setMaxMessages:f,isShowCommandLine:f,setShowCommandLine:f,isShowHideButton:f,setShowHideButton:f,isShowCloseButton:f,setShowCloseButton:f,getCommandLineObjectExpansionDepth:f,setCommandLineObjectExpansionDepth:f,isInitiallyMinimized:f,setInitiallyMinimized:f,isUseDocumentWrite:f,setUseDocumentWrite:f,group:f,groupEnd:f,clear:f,focus:f,focusCommandLine:f,focusSearch:f,getCommandWindow:f,setCommandWindow:f,executeLastCommand:f,getCommandLayout:f,setCommandLayout:f,evalCommandAndAppend:f,addCommandLineFunction:f,storeCommandHistory:f,unload:f});ConsoleAppender.addGlobalCommandLineFunction=f;log4javascript.InPageAppender=ff();log4javascript.InPageAppender.prototype=new ConsoleAppender();copy(log4javascript.InPageAppender.prototype,{addCssProperty:f,hide:f,show:f,isVisible:f,close:f,defaults:{layout:new log4javascript.PatternLayout(),maxMessages:null}});log4javascript.InlineAppender=log4javascript.InPageAppender;log4javascript.PopUpAppender=ff();log4javascript.PopUpAppender.prototype=new ConsoleAppender();copy(log4javascript.PopUpAppender.prototype,{isUseOldPopUp:f,setUseOldPopUp:f,isComplainAboutPopUpBlocking:f,setComplainAboutPopUpBlocking:f,isFocusPopUp:f,setFocusPopUp:f,isReopenWhenClosed:f,setReopenWhenClosed:f,close:f,hide:f,show:f,defaults:{layout:new log4javascript.PatternLayout(),maxMessages:null}});return log4javascript;})();if(typeof window.log4javascript=="undefined"){var log4javascript=log4javascript_stub;}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite.js
new file mode 100644
index 0000000..7d2ea14
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite.js
@@ -0,0 +1,21 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var log4javascript_stub=(function(){var log4javascript;function ff(){return function(){};}
+function copy(obj,props){for(var i in props){obj[i]=props[i];}}
+var f=ff();var Logger=ff();copy(Logger.prototype,{setLevel:f,getLevel:f,trace:f,debug:f,info:f,warn:f,error:f,fatal:f,isEnabledFor:f,isTraceEnabled:f,isDebugEnabled:f,isInfoEnabled:f,isWarnEnabled:f,isErrorEnabled:f,isFatalEnabled:f});var getLogger=function(){return new Logger();};function Log4JavaScript(){}
+log4javascript=new Log4JavaScript();log4javascript={isStub:true,version:"1.4.6",edition:"log4javascript_lite",setEnabled:f,isEnabled:f,setShowStackTraces:f,getDefaultLogger:getLogger,getLogger:getLogger,getNullLogger:getLogger,Level:ff(),LoggingEvent:ff(),Appender:ff()};log4javascript.LoggingEvent.prototype={getThrowableStrRep:f,getCombinedMessages:f};log4javascript.Level.prototype={toString:f,equals:f,isGreaterOrEqual:f};var level=new log4javascript.Level();copy(log4javascript.Level,{ALL:level,TRACE:level,DEBUG:level,INFO:level,WARN:level,ERROR:level,FATAL:level,OFF:level});log4javascript.Appender.prototype.append=f;return log4javascript;})();if(typeof window.log4javascript=="undefined"){var log4javascript=log4javascript_stub;}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite_uncompressed.js
new file mode 100644
index 0000000..afb9ba7
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_lite_uncompressed.js
@@ -0,0 +1,102 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var log4javascript_stub = (function() {
+	var log4javascript;
+
+	function ff() {
+		return function() {};
+	}
+	function copy(obj, props) {
+		for (var i in props) {
+			obj[i] = props[i];
+		}
+	}
+	var f = ff();
+
+	// Loggers
+	var Logger = ff();
+	copy(Logger.prototype, {
+		setLevel: f,
+		getLevel: f,
+		trace: f,
+		debug: f,
+		info: f,
+		warn: f,
+		error: f,
+		fatal: f,
+		isEnabledFor: f,
+		isTraceEnabled: f,
+		isDebugEnabled: f,
+		isInfoEnabled: f,
+		isWarnEnabled: f,
+		isErrorEnabled: f,
+		isFatalEnabled: f
+	});
+
+	var getLogger = function() {
+		return new Logger();
+	};
+
+	function Log4JavaScript() {}
+	log4javascript = new Log4JavaScript();
+
+	log4javascript = {
+		isStub: true,
+		version: "1.4.6",
+		edition: "log4javascript_lite",
+		setEnabled: f,
+		isEnabled: f,
+		setShowStackTraces: f,
+		getDefaultLogger: getLogger,
+		getLogger: getLogger,
+		getNullLogger: getLogger,
+		Level: ff(),
+		LoggingEvent: ff(),
+		Appender: ff()
+	};
+
+	// LoggingEvents
+	log4javascript.LoggingEvent.prototype = {
+		getThrowableStrRep: f,
+		getCombinedMessages: f
+	};
+
+	// Levels
+	log4javascript.Level.prototype = {
+		toString: f,
+		equals: f,
+		isGreaterOrEqual: f
+	};
+	var level = new log4javascript.Level();
+	copy(log4javascript.Level, {
+		ALL: level,
+		TRACE: level,
+		DEBUG: level,
+		INFO: level,
+		WARN: level,
+		ERROR: level,
+		FATAL: level,
+		OFF: level
+	});
+	
+	log4javascript.Appender.prototype.append = f;
+
+	return log4javascript;
+})();
+if (typeof window.log4javascript == "undefined") {
+	var log4javascript = log4javascript_stub;
+}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production.js
new file mode 100644
index 0000000..69a90a8
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production.js
@@ -0,0 +1,22 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+var log4javascript_stub=(function(){var log4javascript;function ff(){return function(){};}
+function copy(obj,props){for(var i in props){obj[i]=props[i];}}
+var f=ff();var Logger=ff();copy(Logger.prototype,{addChild:f,getEffectiveAppenders:f,invalidateAppenderCache:f,getAdditivity:f,setAdditivity:f,addAppender:f,removeAppender:f,removeAllAppenders:f,log:f,setLevel:f,getLevel:f,getEffectiveLevel:f,trace:f,debug:f,info:f,warn:f,error:f,fatal:f,isEnabledFor:f,isTraceEnabled:f,isDebugEnabled:f,isInfoEnabled:f,isWarnEnabled:f,isErrorEnabled:f,isFatalEnabled:f,callAppenders:f,group:f,groupEnd:f,time:f,timeEnd:f,assert:f,parent:new Logger()});var getLogger=function(){return new Logger();};function EventSupport(){}
+copy(EventSupport.prototype,{setEventTypes:f,addEventListener:f,removeEventListener:f,dispatchEvent:f,eventTypes:[],eventListeners:{}});function Log4JavaScript(){}
+Log4JavaScript.prototype=new EventSupport();log4javascript=new Log4JavaScript();log4javascript={isStub:true,version:"1.4.6",edition:"log4javascript_production",setDocumentReady:f,setEventTypes:f,addEventListener:f,removeEventListener:f,dispatchEvent:f,eventTypes:[],eventListeners:{},logLog:{setQuietMode:f,setAlertAllErrors:f,debug:f,displayDebug:f,warn:f,error:f},handleError:f,setEnabled:f,isEnabled:f,setTimeStampsInMilliseconds:f,isTimeStampsInMilliseconds:f,evalInScope:f,setShowStackTraces:f,getLogger:getLogger,getDefaultLogger:getLogger,getNullLogger:getLogger,getRootLogger:getLogger,resetConfiguration:f,Level:ff(),LoggingEvent:ff(),Layout:ff(),Appender:ff()};log4javascript.LoggingEvent.prototype={getThrowableStrRep:f,getCombinedMessages:f};log4javascript.Level.prototype={toString:f,equals:f,isGreaterOrEqual:f};var level=new log4javascript.Level();copy(log4javascript.Level,{ALL:level,TRACE:level,DEBUG:level,INFO:level,WARN:level,ERROR:level,FATAL:level,OFF:level});log4javascript.Layout.prototype={defaults:{},format:f,ignoresThrowable:f,getContentType:f,allowBatching:f,getDataValues:f,setKeys:f,setCustomField:f,hasCustomFields:f,setTimeStampsInMilliseconds:f,isTimeStampsInMilliseconds:f,getTimeStampValue:f,toString:f};log4javascript.SimpleDateFormat=ff();log4javascript.SimpleDateFormat.prototype={setMinimalDaysInFirstWeek:f,getMinimalDaysInFirstWeek:f,format:f};log4javascript.PatternLayout=ff();log4javascript.PatternLayout.prototype=new log4javascript.Layout();log4javascript.Appender=ff();log4javascript.Appender.prototype=new EventSupport();copy(log4javascript.Appender.prototype,{layout:new log4javascript.PatternLayout(),threshold:log4javascript.Level.ALL,loggers:[],doAppend:f,append:f,setLayout:f,getLayout:f,setThreshold:f,getThreshold:f,setAddedToLogger:f,setRemovedFromLogger:f,group:f,groupEnd:f,toString:f});log4javascript.SimpleLayout=ff();log4javascript.SimpleLayout.prototype=new log4javascript.Layout();log4javascript.NullLayout=ff();log4javascript.NullLayout.prototype=new log4javascript.Layout();log4javascript.XmlLayout=ff();log4javascript.XmlLayout.prototype=new log4javascript.Layout();copy(log4javascript.XmlLayout.prototype,{escapeCdata:f,isCombinedMessages:f});log4javascript.JsonLayout=ff();log4javascript.JsonLayout.prototype=new log4javascript.Layout();copy(log4javascript.JsonLayout.prototype,{isReadable:f,isCombinedMessages:f});log4javascript.HttpPostDataLayout=ff();log4javascript.HttpPostDataLayout.prototype=new log4javascript.Layout();log4javascript.PatternLayout=ff();log4javascript.PatternLayout.prototype=new log4javascript.Layout();log4javascript.AjaxAppender=ff();log4javascript.AjaxAppender.prototype=new log4javascript.Appender();copy(log4javascript.AjaxAppender.prototype,{getSessionId:f,setSessionId:f,isTimed:f,setTimed:f,getTimerInterval:f,setTimerInterval:f,isWaitForResponse:f,setWaitForResponse:f,getBatchSize:f,setBatchSize:f,isSendAllOnUnload:f,setSendAllOnUnload:f,setRequestSuccessCallback:f,setFailCallback:f,getPostVarName:f,setPostVarName:f,sendAll:f,sendAllRemaining:f,defaults:{requestSuccessCallback:null,failCallback:null}});return log4javascript;})();if(typeof window.log4javascript=="undefined"){var log4javascript=log4javascript_stub;}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production_uncompressed.js
new file mode 100644
index 0000000..79eb7ca
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_production_uncompressed.js
@@ -0,0 +1,253 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var log4javascript_stub = (function() {
+	var log4javascript;
+
+	function ff() {
+		return function() {};
+	}
+	function copy(obj, props) {
+		for (var i in props) {
+			obj[i] = props[i];
+		}
+	}
+	var f = ff();
+
+	// Loggers
+	var Logger = ff();
+	copy(Logger.prototype, {
+		addChild: f,
+		getEffectiveAppenders: f,
+		invalidateAppenderCache: f,
+		getAdditivity: f,
+		setAdditivity: f,
+		addAppender: f,
+		removeAppender: f,
+		removeAllAppenders: f,
+		log: f,
+		setLevel: f,
+		getLevel: f,
+		getEffectiveLevel: f,
+		trace: f,
+		debug: f,
+		info: f,
+		warn: f,
+		error: f,
+		fatal: f,
+		isEnabledFor: f,
+		isTraceEnabled: f,
+		isDebugEnabled: f,
+		isInfoEnabled: f,
+		isWarnEnabled: f,
+		isErrorEnabled: f,
+		isFatalEnabled: f,
+		callAppenders: f,
+		group: f,
+		groupEnd: f,
+		time: f,
+		timeEnd: f,
+		assert: f,
+		parent: new Logger()
+	});
+
+	var getLogger = function() {
+		return new Logger();
+	};
+
+	function EventSupport() {}
+
+	copy(EventSupport.prototype, {
+		setEventTypes: f,
+		addEventListener: f,
+		removeEventListener: f,
+		dispatchEvent: f,
+		eventTypes: [],
+		eventListeners: {}
+	});
+
+	function Log4JavaScript() {}
+	Log4JavaScript.prototype = new EventSupport();
+	log4javascript = new Log4JavaScript();
+
+	log4javascript = {
+		isStub: true,
+		version: "1.4.6",
+		edition: "log4javascript_production",
+        setDocumentReady: f,
+		setEventTypes: f,
+		addEventListener: f,
+		removeEventListener: f,
+		dispatchEvent: f,
+		eventTypes: [],
+		eventListeners: {},
+		logLog: {
+			setQuietMode: f,
+			setAlertAllErrors: f,
+			debug: f,
+			displayDebug: f,
+			warn: f,
+			error: f
+		},
+		handleError: f,
+		setEnabled: f,
+		isEnabled: f,
+		setTimeStampsInMilliseconds: f,
+		isTimeStampsInMilliseconds: f,
+		evalInScope: f,
+		setShowStackTraces: f,
+		getLogger: getLogger,
+		getDefaultLogger: getLogger,
+		getNullLogger: getLogger,
+		getRootLogger: getLogger,
+		resetConfiguration: f,
+		Level: ff(),
+		LoggingEvent: ff(),
+		Layout: ff(),
+		Appender: ff()
+	};
+
+	// LoggingEvents
+	log4javascript.LoggingEvent.prototype = {
+		getThrowableStrRep: f,
+		getCombinedMessages: f
+	};
+
+	// Levels
+	log4javascript.Level.prototype = {
+		toString: f,
+		equals: f,
+		isGreaterOrEqual: f
+	};
+	var level = new log4javascript.Level();
+	copy(log4javascript.Level, {
+		ALL: level,
+		TRACE: level,
+		DEBUG: level,
+		INFO: level,
+		WARN: level,
+		ERROR: level,
+		FATAL: level,
+		OFF: level
+	});
+
+	// Layouts
+	log4javascript.Layout.prototype = {
+		defaults: {},
+		format: f,
+		ignoresThrowable: f,
+		getContentType: f,
+		allowBatching: f,
+		getDataValues: f,
+		setKeys: f,
+		setCustomField: f,
+		hasCustomFields: f,
+		setTimeStampsInMilliseconds: f,
+		isTimeStampsInMilliseconds: f,
+		getTimeStampValue: f,
+		toString: f
+	};
+
+	// PatternLayout related
+	log4javascript.SimpleDateFormat = ff();
+	log4javascript.SimpleDateFormat.prototype = {
+		setMinimalDaysInFirstWeek: f,
+		getMinimalDaysInFirstWeek: f,
+		format: f
+	};
+
+	// PatternLayout
+	log4javascript.PatternLayout = ff();
+	log4javascript.PatternLayout.prototype = new log4javascript.Layout();
+
+	// Appenders
+	log4javascript.Appender = ff();
+	log4javascript.Appender.prototype = new EventSupport();
+
+	copy(log4javascript.Appender.prototype, {
+		layout: new log4javascript.PatternLayout(),
+		threshold: log4javascript.Level.ALL,
+		loggers: [],
+		doAppend: f,
+		append: f,
+		setLayout: f,
+		getLayout: f,
+		setThreshold: f,
+		getThreshold: f,
+		setAddedToLogger: f,
+		setRemovedFromLogger: f,
+		group: f,
+		groupEnd: f,
+		toString: f
+	});
+	// SimpleLayout
+	log4javascript.SimpleLayout = ff();
+	log4javascript.SimpleLayout.prototype = new log4javascript.Layout();
+	// NullLayout
+	log4javascript.NullLayout = ff();
+	log4javascript.NullLayout.prototype = new log4javascript.Layout();
+	// ZmlLayout
+	log4javascript.XmlLayout = ff();
+	log4javascript.XmlLayout.prototype = new log4javascript.Layout();
+	copy(log4javascript.XmlLayout.prototype, {
+		escapeCdata: f,
+		isCombinedMessages: f
+	});
+	// JsonLayout
+	log4javascript.JsonLayout = ff();
+	log4javascript.JsonLayout.prototype = new log4javascript.Layout();
+	copy(log4javascript.JsonLayout.prototype, {
+		isReadable: f,
+		isCombinedMessages: f
+	});
+	// HttpPostDataLayout 
+	log4javascript.HttpPostDataLayout = ff();
+	log4javascript.HttpPostDataLayout.prototype = new log4javascript.Layout();
+	// PatternLayout
+	log4javascript.PatternLayout = ff();
+	log4javascript.PatternLayout.prototype = new log4javascript.Layout();
+	// AjaxAppender
+	log4javascript.AjaxAppender = ff();
+	log4javascript.AjaxAppender.prototype = new log4javascript.Appender();
+	copy(log4javascript.AjaxAppender.prototype, {
+		getSessionId: f,
+		setSessionId: f,
+		isTimed: f,
+		setTimed: f,
+		getTimerInterval: f,
+		setTimerInterval: f,
+		isWaitForResponse: f,
+		setWaitForResponse: f,
+		getBatchSize: f,
+		setBatchSize: f,
+		isSendAllOnUnload: f,
+		setSendAllOnUnload: f,
+		setRequestSuccessCallback: f,
+		setFailCallback: f,
+		getPostVarName: f,
+		setPostVarName: f,
+		sendAll: f,
+		sendAllRemaining: f,
+		defaults: {
+			requestSuccessCallback: null,
+			failCallback: null
+		}
+	});
+	return log4javascript;
+})();
+if (typeof window.log4javascript == "undefined") {
+	var log4javascript = log4javascript_stub;
+}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_uncompressed.js
new file mode 100644
index 0000000..1976fbc
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/stubs/log4javascript_uncompressed.js
@@ -0,0 +1,341 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var log4javascript_stub = (function() {
+	var log4javascript;
+
+	function ff() {
+		return function() {};
+	}
+	function copy(obj, props) {
+		for (var i in props) {
+			obj[i] = props[i];
+		}
+	}
+	var f = ff();
+
+	// Loggers
+	var Logger = ff();
+	copy(Logger.prototype, {
+		addChild: f,
+		getEffectiveAppenders: f,
+		invalidateAppenderCache: f,
+		getAdditivity: f,
+		setAdditivity: f,
+		addAppender: f,
+		removeAppender: f,
+		removeAllAppenders: f,
+		log: f,
+		setLevel: f,
+		getLevel: f,
+		getEffectiveLevel: f,
+		trace: f,
+		debug: f,
+		info: f,
+		warn: f,
+		error: f,
+		fatal: f,
+		isEnabledFor: f,
+		isTraceEnabled: f,
+		isDebugEnabled: f,
+		isInfoEnabled: f,
+		isWarnEnabled: f,
+		isErrorEnabled: f,
+		isFatalEnabled: f,
+		callAppenders: f,
+		group: f,
+		groupEnd: f,
+		time: f,
+		timeEnd: f,
+		assert: f,
+		parent: new Logger()
+	});
+
+	var getLogger = function() {
+		return new Logger();
+	};
+
+	function EventSupport() {}
+
+	copy(EventSupport.prototype, {
+		setEventTypes: f,
+		addEventListener: f,
+		removeEventListener: f,
+		dispatchEvent: f,
+		eventTypes: [],
+		eventListeners: {}
+	});
+
+	function Log4JavaScript() {}
+	Log4JavaScript.prototype = new EventSupport();
+	log4javascript = new Log4JavaScript();
+
+	log4javascript = {
+		isStub: true,
+		version: "1.4.6",
+		edition: "log4javascript",
+        setDocumentReady: f,
+		setEventTypes: f,
+		addEventListener: f,
+		removeEventListener: f,
+		dispatchEvent: f,
+		eventTypes: [],
+		eventListeners: {},
+		logLog: {
+			setQuietMode: f,
+			setAlertAllErrors: f,
+			debug: f,
+			displayDebug: f,
+			warn: f,
+			error: f
+		},
+		handleError: f,
+		setEnabled: f,
+		isEnabled: f,
+		setTimeStampsInMilliseconds: f,
+		isTimeStampsInMilliseconds: f,
+		evalInScope: f,
+		setShowStackTraces: f,
+		getLogger: getLogger,
+		getDefaultLogger: getLogger,
+		getNullLogger: getLogger,
+		getRootLogger: getLogger,
+		resetConfiguration: f,
+		Level: ff(),
+		LoggingEvent: ff(),
+		Layout: ff(),
+		Appender: ff()
+	};
+
+	// LoggingEvents
+	log4javascript.LoggingEvent.prototype = {
+		getThrowableStrRep: f,
+		getCombinedMessages: f
+	};
+
+	// Levels
+	log4javascript.Level.prototype = {
+		toString: f,
+		equals: f,
+		isGreaterOrEqual: f
+	};
+	var level = new log4javascript.Level();
+	copy(log4javascript.Level, {
+		ALL: level,
+		TRACE: level,
+		DEBUG: level,
+		INFO: level,
+		WARN: level,
+		ERROR: level,
+		FATAL: level,
+		OFF: level
+	});
+
+	// Layouts
+	log4javascript.Layout.prototype = {
+		defaults: {},
+		format: f,
+		ignoresThrowable: f,
+		getContentType: f,
+		allowBatching: f,
+		getDataValues: f,
+		setKeys: f,
+		setCustomField: f,
+		hasCustomFields: f,
+		setTimeStampsInMilliseconds: f,
+		isTimeStampsInMilliseconds: f,
+		getTimeStampValue: f,
+		toString: f
+	};
+
+	// PatternLayout related
+	log4javascript.SimpleDateFormat = ff();
+	log4javascript.SimpleDateFormat.prototype = {
+		setMinimalDaysInFirstWeek: f,
+		getMinimalDaysInFirstWeek: f,
+		format: f
+	};
+
+	// PatternLayout
+	log4javascript.PatternLayout = ff();
+	log4javascript.PatternLayout.prototype = new log4javascript.Layout();
+
+	// Appenders
+	log4javascript.Appender = ff();
+	log4javascript.Appender.prototype = new EventSupport();
+
+	copy(log4javascript.Appender.prototype, {
+		layout: new log4javascript.PatternLayout(),
+		threshold: log4javascript.Level.ALL,
+		loggers: [],
+		doAppend: f,
+		append: f,
+		setLayout: f,
+		getLayout: f,
+		setThreshold: f,
+		getThreshold: f,
+		setAddedToLogger: f,
+		setRemovedFromLogger: f,
+		group: f,
+		groupEnd: f,
+		toString: f
+	});
+	// SimpleLayout
+	log4javascript.SimpleLayout = ff();
+	log4javascript.SimpleLayout.prototype = new log4javascript.Layout();
+	// NullLayout
+	log4javascript.NullLayout = ff();
+	log4javascript.NullLayout.prototype = new log4javascript.Layout();
+	// ZmlLayout
+	log4javascript.XmlLayout = ff();
+	log4javascript.XmlLayout.prototype = new log4javascript.Layout();
+	copy(log4javascript.XmlLayout.prototype, {
+		escapeCdata: f,
+		isCombinedMessages: f
+	});
+	// JsonLayout
+	log4javascript.JsonLayout = ff();
+	log4javascript.JsonLayout.prototype = new log4javascript.Layout();
+	copy(log4javascript.JsonLayout.prototype, {
+		isReadable: f,
+		isCombinedMessages: f
+	});
+	// HttpPostDataLayout 
+	log4javascript.HttpPostDataLayout = ff();
+	log4javascript.HttpPostDataLayout.prototype = new log4javascript.Layout();
+	// PatternLayout
+	log4javascript.PatternLayout = ff();
+	log4javascript.PatternLayout.prototype = new log4javascript.Layout();
+	// AlertAppender
+	log4javascript.AlertAppender = ff();
+	log4javascript.AlertAppender.prototype = new log4javascript.Appender();
+	// BrowserConsoleAppender
+	log4javascript.BrowserConsoleAppender = ff();
+	log4javascript.BrowserConsoleAppender.prototype = new log4javascript.Appender();
+	// AjaxAppender
+	log4javascript.AjaxAppender = ff();
+	log4javascript.AjaxAppender.prototype = new log4javascript.Appender();
+	copy(log4javascript.AjaxAppender.prototype, {
+		getSessionId: f,
+		setSessionId: f,
+		isTimed: f,
+		setTimed: f,
+		getTimerInterval: f,
+		setTimerInterval: f,
+		isWaitForResponse: f,
+		setWaitForResponse: f,
+		getBatchSize: f,
+		setBatchSize: f,
+		isSendAllOnUnload: f,
+		setSendAllOnUnload: f,
+		setRequestSuccessCallback: f,
+		setFailCallback: f,
+		getPostVarName: f,
+		setPostVarName: f,
+		sendAll: f,
+		sendAllRemaining: f,
+		defaults: {
+			requestSuccessCallback: null,
+			failCallback: null
+		}
+	});
+	// ConsoleAppender
+	function ConsoleAppender() {}
+	ConsoleAppender.prototype = new log4javascript.Appender();
+	copy(ConsoleAppender.prototype, {
+		create: f,
+		isNewestMessageAtTop: f,
+		setNewestMessageAtTop: f,
+		isScrollToLatestMessage: f,
+		setScrollToLatestMessage: f,
+		getWidth: f,
+		setWidth: f,
+		getHeight: f,
+		setHeight: f,
+		getMaxMessages: f,
+		setMaxMessages: f,
+		isShowCommandLine: f,
+		setShowCommandLine: f,
+		isShowHideButton: f,
+		setShowHideButton: f,
+		isShowCloseButton: f,
+		setShowCloseButton: f,
+		getCommandLineObjectExpansionDepth: f,
+		setCommandLineObjectExpansionDepth: f,
+		isInitiallyMinimized: f,
+		setInitiallyMinimized: f,
+		isUseDocumentWrite: f,
+		setUseDocumentWrite: f,
+		group: f,
+		groupEnd: f,
+		clear: f,
+		focus: f,
+		focusCommandLine: f,
+		focusSearch: f,
+		getCommandWindow: f,
+		setCommandWindow: f,
+		executeLastCommand: f,
+		getCommandLayout: f,
+		setCommandLayout: f,
+		evalCommandAndAppend: f,
+		addCommandLineFunction: f,
+		storeCommandHistory: f,
+		unload: f
+	});
+
+	ConsoleAppender.addGlobalCommandLineFunction = f;
+
+	// InPageAppender
+	log4javascript.InPageAppender = ff();
+	log4javascript.InPageAppender.prototype = new ConsoleAppender();
+	copy(log4javascript.InPageAppender.prototype, {
+		addCssProperty: f,
+		hide: f,
+		show: f,
+		isVisible: f,
+		close: f,
+		defaults: {
+			layout: new log4javascript.PatternLayout(),
+			maxMessages: null
+		}
+	});
+	log4javascript.InlineAppender = log4javascript.InPageAppender;
+
+	// PopUpAppender
+	log4javascript.PopUpAppender = ff();
+	log4javascript.PopUpAppender.prototype = new ConsoleAppender();
+	copy(log4javascript.PopUpAppender.prototype, {
+		isUseOldPopUp: f,
+		setUseOldPopUp: f,
+		isComplainAboutPopUpBlocking: f,
+		setComplainAboutPopUpBlocking: f,
+		isFocusPopUp: f,
+		setFocusPopUp: f,
+		isReopenWhenClosed: f,
+		setReopenWhenClosed: f,
+		close: f,
+		hide: f,
+		show: f,
+		defaults: {
+			layout: new log4javascript.PatternLayout(),
+			maxMessages: null
+		}
+	});
+	return log4javascript;
+})();
+if (typeof window.log4javascript == "undefined") {
+	var log4javascript = log4javascript_stub;
+}
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript.js
new file mode 100644
index 0000000..89fd903
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript.js
@@ -0,0 +1,32 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function array_contains(arr,val){for(var i=0;i<arr.length;i++){if(arr[i]==val){return true;}}
+return false;}
+function compareObjectInterface(obj1,obj1_name,obj2,obj2_name,namePrefix){if(!namePrefix){namePrefix="";}
+var obj1PropertyNames=new Array();for(var i in obj1){if(i!="prototype"&&i!="arguments"){obj1PropertyNames.push(i);}}
+if(obj1&&obj1.prototype&&!array_contains(obj1PropertyNames,"prototype")){}
+for(var j=0;j<obj1PropertyNames.length;j++){var propertyName=obj1PropertyNames[j];if((typeof obj1[propertyName]=="function"||typeof obj1[propertyName]=="object")&&!(obj1[propertyName]instanceof Array)){var propertyFullyQualifiedName=(namePrefix=="")?propertyName:namePrefix+"."+propertyName;try{if(typeof obj2[propertyName]=="undefined"){throw new Error(obj2_name+" does not contain "+propertyFullyQualifiedName+" in "+obj1_name);}else if(typeof obj2[propertyName]!=typeof obj1[propertyName]){throw new Error(obj2_name+"'s "+propertyFullyQualifiedName+" is of the wrong type: "+typeof obj2[propertyName]+" when it is type "+typeof obj1[propertyName]+" in "+obj1_name);}else if(obj1[propertyName]!=Function.prototype.apply){if(!compareObjectInterface(obj1[propertyName],obj1_name,obj2[propertyName],obj2_name,propertyFullyQualifiedName)){throw new Error("Interfaces don't match");}}}catch(ex){throw new Error("Exception while checking property name "+propertyFullyQualifiedName+" in "+obj2_name+": "+ex.message);}}}
+return true;};var testLayoutWithVariables=function(layout,t){var emptyObject={};var emptyArray=[];var emptyString="";var localUndefined=emptyArray[0];var oneLevelObject={"name":"One-level object"};var twoLevelObject={"name":"Two-level object","data":oneLevelObject};var threeLevelObject={"name":"Three-level object","data":twoLevelObject};var anArray=[3,"stuff",true,false,0,null,localUndefined,3.14,function(p){return"I'm a function";},[1,"things"]];var arrayOfTestItems=[emptyObject,emptyString,emptyString,localUndefined,oneLevelObject,twoLevelObject,threeLevelObject,anArray];t.log("Testing layout "+layout)
+for(var i=0;i<arrayOfTestItems.length;i++){var ex=new Error("Test error");var loggingEvent=new log4javascript.LoggingEvent(t.logger,new Date(),log4javascript.Level.INFO,[arrayOfTestItems[i]],null);t.log("Formatting",arrayOfTestItems[i],result);var result=layout.format(loggingEvent);loggingEvent.exception=ex;t.log("Formatting with exception",arrayOfTestItems[i],result);result=layout.format(loggingEvent);}};xn.test.enableTestDebug=true;xn.test.enable_log4javascript=false;xn.test.suite("log4javascript tests",function(s){log4javascript.logLog.setQuietMode(true);var ArrayAppender=function(layout){if(layout){this.setLayout(layout);}
+this.logMessages=[];};ArrayAppender.prototype=new log4javascript.Appender();ArrayAppender.prototype.layout=new log4javascript.NullLayout();ArrayAppender.prototype.append=function(loggingEvent){var formattedMessage=this.getLayout().format(loggingEvent);if(this.getLayout().ignoresThrowable()){formattedMessage+=loggingEvent.getThrowableStrRep();}
+this.logMessages.push(formattedMessage);};ArrayAppender.prototype.toString=function(){return"[ArrayAppender]";};s.setUp=function(t){t.logger=log4javascript.getLogger("test");t.logger.removeAllAppenders();t.appender=new ArrayAppender();t.logger.addAppender(t.appender);};s.tearDown=function(t){t.logger.removeAppender(t.appender);log4javascript.resetConfiguration();};s.test("Stub script interface test",function(t){try{compareObjectInterface(log4javascript,"log4javascript",log4javascript_stub,"log4javascript_stub");}catch(ex){t.fail(ex);}});s.test("Disable log4javascript test",function(t){log4javascript.setEnabled(false);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,0);log4javascript.setEnabled(true);});s.test("Array.splice test 1",function(t){var a=["Marlon","Ashley","Darius","Lloyd"];var deletedItems=a.splice(1,2);t.assertEquals(a.join(","),"Marlon,Lloyd");t.assertEquals(deletedItems.join(","),"Ashley,Darius");});s.test("Array.splice test 2",function(t){var a=["Marlon","Ashley","Darius","Lloyd"];var deletedItems=a.splice(1,1,"Malky","Jay");t.assertEquals(a.join(","),"Marlon,Malky,Jay,Darius,Lloyd");t.assertEquals(deletedItems.join(","),"Ashley");});s.test("array_remove test",function(t){var array_remove=log4javascript.evalInScope("array_remove");var a=["Marlon","Ashley","Darius"];array_remove(a,"Darius");t.assertEquals(a.join(","),"Marlon,Ashley");});s.test("array_remove with empty array test",function(t){var array_remove=log4javascript.evalInScope("array_remove");var a=[];array_remove(a,"Darius");t.assertEquals(a.join(","),"");});s.test("Logger logging test",function(t){t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,1);});s.test("Logger levels test",function(t){var originalLevel=t.logger.getEffectiveLevel();t.logger.setLevel(log4javascript.Level.INFO);t.logger.debug("TEST");t.logger.setLevel(originalLevel);t.assertEquals(t.appender.logMessages.length,0);});s.test("Logger getEffectiveLevel inheritance test 1",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");parentLogger.setLevel(log4javascript.Level.ERROR);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.ERROR);});s.test("Logger getEffectiveLevel inheritance test 2",function(t){var grandParentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2.test3");grandParentLogger.setLevel(log4javascript.Level.ERROR);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.ERROR);});s.test("Logger getEffectiveLevel inheritance test 3",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");parentLogger.setLevel(log4javascript.Level.ERROR);childLogger.setLevel(log4javascript.Level.INFO);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.INFO);});s.test("Logger getEffectiveLevel root inheritance test",function(t){var rootLogger=log4javascript.getRootLogger();var childLogger=log4javascript.getLogger("test1.test2.test3");rootLogger.setLevel(log4javascript.Level.WARN);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.WARN);});s.test("Logger null level test",function(t){t.logger.setLevel(null);t.assertEquals(t.logger.getEffectiveLevel(),log4javascript.Level.DEBUG);});s.test("Logger appender additivity test 1",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");t.assertEquals(parentLoggerAppender.logMessages.length,2);t.assertEquals(childLoggerAppender.logMessages.length,1);});s.test("Logger appender additivity test 2",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);childLogger.setAdditivity(false);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");t.assertEquals(parentLoggerAppender.logMessages.length,1);t.assertEquals(childLoggerAppender.logMessages.length,1);});s.test("Logger appender additivity test 3",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);childLogger.setAdditivity(false);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");childLogger.setAdditivity(true);childLogger.info("Child logger test message 2");t.assertEquals(parentLoggerAppender.logMessages.length,2);t.assertEquals(childLoggerAppender.logMessages.length,2);});s.test("Appender threshold test",function(t){t.appender.setThreshold(log4javascript.Level.INFO);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,0);});s.test("Basic appender / layout test",function(t){t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST");});s.test("Appender uniqueness within logger test",function(t){t.logger.addAppender(t.appender);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,1);});s.test("Logger remove appender test",function(t){t.logger.debug("TEST");t.logger.removeAppender(t.appender);t.logger.debug("TEST AGAIN");t.assertEquals(t.appender.logMessages.length,1);});s.test("",function(t){t.logger.debug("TEST");t.logger.removeAppender(t.appender);t.logger.debug("TEST AGAIN");t.assertEquals(t.appender.logMessages.length,1);});s.test("SimpleLayout format test",function(t){var layout=new log4javascript.SimpleLayout();testLayoutWithVariables(layout,t);});s.test("SimpleLayout test",function(t){t.appender.setLayout(new log4javascript.SimpleLayout());t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"DEBUG - TEST");});s.test("NullLayout format test",function(t){var layout=new log4javascript.NullLayout();testLayoutWithVariables(layout,t);});s.test("NullLayout test",function(t){t.appender.setLayout(new log4javascript.NullLayout());t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST");});s.test("XmlLayout format test",function(t){var layout=new log4javascript.XmlLayout();testLayoutWithVariables(layout,t);});s.test("XmlLayout test",function(t){t.appender.setLayout(new log4javascript.XmlLayout());t.logger.debug("TEST");t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<\/log4javascript:event>\s*$/,t.appender.logMessages[0]);});s.test("XmlLayout with exception test",function(t){t.appender.setLayout(new log4javascript.XmlLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<log4javascript:exception>\s*<!\[CDATA\[.*\]\]><\/log4javascript:exception>\s*<\/log4javascript:event>\s*$/,t.appender.logMessages[0]);});var setUpXmlLayoutMillisecondsTest=function(t){t.date=new Date();t.timeInMilliseconds=t.date.getTime();t.timeInSeconds=Math.floor(t.timeInMilliseconds/1000);t.milliseconds=t.date.getMilliseconds();t.loggingEvent=new log4javascript.LoggingEvent(t.logger,t.date,log4javascript.Level.DEBUG,["TEST"],null);t.layout=new log4javascript.XmlLayout();}
+s.test("XmlLayout seconds/milliseconds test 1",function(t){setUpXmlLayoutMillisecondsTest(t);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInMilliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,t.layout.format(t.loggingEvent));});s.test("XmlLayout seconds/milliseconds test 2",function(t){setUpXmlLayoutMillisecondsTest(t);log4javascript.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);log4javascript.setTimeStampsInMilliseconds(true);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInSeconds+'" milliseconds="'+t.milliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,formatted);});s.test("XmlLayout seconds/milliseconds test 3",function(t){setUpXmlLayoutMillisecondsTest(t);t.layout.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInSeconds+'" milliseconds="'+t.milliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,formatted);});s.test("escapeNewLines test",function(t){var escapeNewLines=log4javascript.evalInScope("escapeNewLines");var str="1\r2\n3\n4\r\n5\r6\r\n7";t.assertEquals(escapeNewLines(str),"1\\r\\n2\\r\\n3\\r\\n4\\r\\n5\\r\\n6\\r\\n7");});s.test("JsonLayout format test",function(t){var layout=new log4javascript.JsonLayout();testLayoutWithVariables(layout,t);});s.test("JsonLayout test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST");t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST"}$/,t.appender.logMessages[0]);});s.test("JsonLayout JSON validity test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST");eval("var o = "+t.appender.logMessages[0]);t.assertEquals(o.message,"TEST");});s.test("JsonLayout with number type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug(15);t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":15}$/,t.appender.logMessages[0]);});s.test("JsonLayout with object type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug({});t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"\[object Object\]"}$/,t.appender.logMessages[0]);});s.test("JsonLayout with boolean type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug(false);t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":false}$/,t.appender.logMessages[0]);});s.test("JsonLayout with quote test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TE\"S\"T");t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TE\\"S\\"T"}$/,t.appender.logMessages[0]);});s.test("JsonLayout with exception test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST","exception":.*}$/,t.appender.logMessages[0]);});var setUpJsonLayoutMillisecondsTest=function(t){t.date=new Date();t.timeInMilliseconds=t.date.getTime();t.timeInSeconds=Math.floor(t.timeInMilliseconds/1000);t.milliseconds=t.date.getMilliseconds();t.loggingEvent=new log4javascript.LoggingEvent(t.logger,t.date,log4javascript.Level.DEBUG,["TEST"],null);t.layout=new log4javascript.JsonLayout();};s.test("JsonLayout seconds/milliseconds test 1",function(t){setUpJsonLayoutMillisecondsTest(t);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInMilliseconds+',"level":"DEBUG","url":".*","message":"TEST"}$');t.assertRegexMatches(regex,t.layout.format(t.loggingEvent));});s.test("JsonLayout seconds/milliseconds test 2",function(t){setUpJsonLayoutMillisecondsTest(t);log4javascript.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);log4javascript.setTimeStampsInMilliseconds(true);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInSeconds+',"level":"DEBUG","url":".*","message":"TEST","milliseconds":'+t.milliseconds+'}$');t.assertRegexMatches(regex,formatted);});s.test("JsonLayout seconds/milliseconds test 3",function(t){setUpJsonLayoutMillisecondsTest(t);t.layout.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInSeconds+',"level":"DEBUG","url":".*","message":"TEST","milliseconds":'+t.milliseconds+'}$');t.assertRegexMatches(regex,formatted);});s.test("HttpPostDataLayout format test",function(t){var layout=new log4javascript.HttpPostDataLayout();testLayoutWithVariables(layout,t);});s.test("HttpPostDataLayout test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST");t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST$/,t.appender.logMessages[0]);});s.test("HttpPostDataLayout URL encoding test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST +\"1\"");t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST%20%2B%221%22$/,t.appender.logMessages[0]);});s.test("HttpPostDataLayout with exception test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST&exception=.*$/,t.appender.logMessages[0]);});(function(){var formatObjectExpansion=log4javascript.evalInScope("formatObjectExpansion");var newLine=log4javascript.evalInScope("newLine");var arr=[null,undefined,1.2,"A string",[1,"test"],{a:{b:1}}];s.test("Basic formatObjectExpansion array test (depth: 1)",function(t){t.assertEquals(formatObjectExpansion(arr,1),"["+newLine+"  null,"+newLine+"  undefined,"+newLine+"  1.2,"+newLine+"  A string,"+newLine+"  1,test,"+newLine+"  [object Object]"+newLine+"]");});s.test("Basic formatObjectExpansion array test (depth: 2)",function(t){t.assertEquals(formatObjectExpansion(arr,2),"["+newLine+"  null,"+newLine+"  undefined,"+newLine+"  1.2,"+newLine+"  A string,"+newLine+"  ["+newLine+"    1,"+newLine+"    test"+newLine+"  ],"+newLine+"  {"+newLine+"    a: [object Object]"+newLine+"  }"+newLine+"]");});s.test("formatObjectExpansion simple object test",function(t){var obj={STRING:"A string"};t.assertEquals(formatObjectExpansion(obj,1),"{"+newLine+"  STRING: A string"+newLine+"}");});s.test("formatObjectExpansion simple circular object test",function(t){var obj={};obj.a=obj;t.assertEquals(formatObjectExpansion(obj,2),"{"+newLine+"  a: [object Object] [already expanded]"+newLine+"}");});})();var getSampleDate=function(){var date=new Date();date.setFullYear(2006);date.setMonth(7);date.setDate(30);date.setHours(15);date.setMinutes(38);date.setSeconds(45);return date;};s.test("String.replace test",function(t){t.assertEquals("Hello world".replace(/o/g,"Z"),"HellZ wZrld");});s.test("PatternLayout format test",function(t){var layout=new log4javascript.PatternLayout();testLayoutWithVariables(layout,t);});s.test("PatternLayout dates test",function(t){var layout=new log4javascript.PatternLayout("%d %d{DATE} %d{HH:ss}");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertRegexMatches(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2},\d{3} \d{2}:\d{2}$/,t.appender.logMessages[0]);});s.test("PatternLayout modifiers test",function(t){var layout=new log4javascript.PatternLayout("%m|%3m|%-3m|%6m|%-6m|%.2m|%1.2m|%6.8m|%-1.2m|%-6.8m|");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST|TEST|TEST|  TEST|TEST  |ST|ST|  TEST|ST|TEST  |");});s.test("PatternLayout conversion characters test",function(t){var layout=new log4javascript.PatternLayout("%c %n %p %r literal %%");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertRegexMatches(/^test \s+ DEBUG \d+ literal %$/,t.appender.logMessages[0]);});s.test("PatternLayout message test",function(t){var layout=new log4javascript.PatternLayout("%m{1} %m{2}");t.appender.setLayout(layout);var testObj={strikers:{quick:"Marlon"}};t.logger.debug(testObj);t.assertEquals("{\r\n  strikers: [object Object]\r\n} {\r\n\  strikers: {\r\n    quick: Marlon\r\n  }\r\n}",t.appender.logMessages[0]);});s.test("Logging/grouping test",function(t){var browserConsoleAppender=new log4javascript.BrowserConsoleAppender();t.logger.addAppender(browserConsoleAppender);t.logger.trace("TEST TRACE");t.logger.debug("TEST DEBUG");t.logger.info("TEST INFO");t.logger.warn("TEST WARN");t.logger.error("TEST ERROR");t.logger.fatal("TEST FATAL");t.logger.fatal("TEST FATAL",new Error("Fake error"));t.logger.info("TEST INFO","Second message",["a","b","c"]);t.logger.group("TEST GROUP");t.logger.info("TEST INFO");t.logger.groupEnd("TEST GROUP");t.logger.info("TEST INFO");t.logger.removeAppender(browserConsoleAppender);});var testConsoleAppender=function(t,appender){var timeoutCallback=function(){return(windowLoaded?"Timed out while waiting for messages to appear":"Timed out while waiting for window to load")+". Debug messages: "+
+log4javascript.logLog.debugMessages.join("\r\n");}
+t.async(60000,timeoutCallback);var windowLoaded=false;var domChecked=false;var onLoadHandler=function(){log4javascript.logLog.debug("onLoadHandler");windowLoaded=true;var win=appender.getConsoleWindow();if(win&&win.loaded){var checkDom=function(){log4javascript.logLog.debug("checkDom");domChecked=true;var logContainer=win.logMainContainer;if(logContainer.hasChildNodes()){if(logContainer.innerHTML.indexOf("TEST MESSAGE")==-1){appender.close();t.fail("Log message not correctly logged (log container innerHTML: "+logContainer.innerHTML+")");}else{t.assert(appender.isVisible());appender.close();t.assert(!appender.isVisible());t.succeed();}}else{appender.close();t.fail("Console has no log messages");}}
+window.setTimeout(checkDom,300);}else{appender.close();t.fail("Console mistakenly raised load event");}}
+appender.addEventListener("load",onLoadHandler);t.logger.addAppender(appender);t.logger.debug("TEST MESSAGE");};s.test("InlineAppender test",function(t){var inlineAppender=new log4javascript.InlineAppender();inlineAppender.setInitiallyMinimized(false);inlineAppender.setNewestMessageAtTop(false);inlineAppender.setScrollToLatestMessage(true);inlineAppender.setWidth(600);inlineAppender.setHeight(200);testConsoleAppender(t,inlineAppender);});s.test("InPageAppender with separate console HTML file test",function(t){var inPageAppender=new log4javascript.InPageAppender();inPageAppender.setInitiallyMinimized(false);inPageAppender.setNewestMessageAtTop(false);inPageAppender.setScrollToLatestMessage(true);inPageAppender.setUseDocumentWrite(false);inPageAppender.setWidth(600);inPageAppender.setHeight(200);testConsoleAppender(t,inPageAppender);});s.test("PopUpAppender test",function(t){var popUpAppender=new log4javascript.PopUpAppender();popUpAppender.setFocusPopUp(true);popUpAppender.setUseOldPopUp(false);popUpAppender.setNewestMessageAtTop(false);popUpAppender.setScrollToLatestMessage(true);popUpAppender.setComplainAboutPopUpBlocking(false);popUpAppender.setWidth(600);popUpAppender.setHeight(200);testConsoleAppender(t,popUpAppender);});s.test("PopUpAppender with separate console HTML file test",function(t){var popUpAppender=new log4javascript.PopUpAppender();popUpAppender.setFocusPopUp(true);popUpAppender.setUseOldPopUp(false);popUpAppender.setNewestMessageAtTop(false);popUpAppender.setScrollToLatestMessage(true);popUpAppender.setComplainAboutPopUpBlocking(false);popUpAppender.setUseDocumentWrite(false);popUpAppender.setWidth(600);popUpAppender.setHeight(200);testConsoleAppender(t,popUpAppender);});});
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite.js
new file mode 100644
index 0000000..b9eb6b7
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite.js
@@ -0,0 +1,16 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite_uncompressed.js
new file mode 100644
index 0000000..b9eb6b7
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_lite_uncompressed.js
@@ -0,0 +1,16 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production.js
new file mode 100644
index 0000000..f5d1090
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production.js
@@ -0,0 +1,28 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+function array_contains(arr,val){for(var i=0;i<arr.length;i++){if(arr[i]==val){return true;}}
+return false;}
+function compareObjectInterface(obj1,obj1_name,obj2,obj2_name,namePrefix){if(!namePrefix){namePrefix="";}
+var obj1PropertyNames=new Array();for(var i in obj1){if(i!="prototype"&&i!="arguments"){obj1PropertyNames.push(i);}}
+if(obj1&&obj1.prototype&&!array_contains(obj1PropertyNames,"prototype")){}
+for(var j=0;j<obj1PropertyNames.length;j++){var propertyName=obj1PropertyNames[j];if((typeof obj1[propertyName]=="function"||typeof obj1[propertyName]=="object")&&!(obj1[propertyName]instanceof Array)){var propertyFullyQualifiedName=(namePrefix=="")?propertyName:namePrefix+"."+propertyName;try{if(typeof obj2[propertyName]=="undefined"){throw new Error(obj2_name+" does not contain "+propertyFullyQualifiedName+" in "+obj1_name);}else if(typeof obj2[propertyName]!=typeof obj1[propertyName]){throw new Error(obj2_name+"'s "+propertyFullyQualifiedName+" is of the wrong type: "+typeof obj2[propertyName]+" when it is type "+typeof obj1[propertyName]+" in "+obj1_name);}else if(obj1[propertyName]!=Function.prototype.apply){if(!compareObjectInterface(obj1[propertyName],obj1_name,obj2[propertyName],obj2_name,propertyFullyQualifiedName)){throw new Error("Interfaces don't match");}}}catch(ex){throw new Error("Exception while checking property name "+propertyFullyQualifiedName+" in "+obj2_name+": "+ex.message);}}}
+return true;};var testLayoutWithVariables=function(layout,t){var emptyObject={};var emptyArray=[];var emptyString="";var localUndefined=emptyArray[0];var oneLevelObject={"name":"One-level object"};var twoLevelObject={"name":"Two-level object","data":oneLevelObject};var threeLevelObject={"name":"Three-level object","data":twoLevelObject};var anArray=[3,"stuff",true,false,0,null,localUndefined,3.14,function(p){return"I'm a function";},[1,"things"]];var arrayOfTestItems=[emptyObject,emptyString,emptyString,localUndefined,oneLevelObject,twoLevelObject,threeLevelObject,anArray];t.log("Testing layout "+layout)
+for(var i=0;i<arrayOfTestItems.length;i++){var ex=new Error("Test error");var loggingEvent=new log4javascript.LoggingEvent(t.logger,new Date(),log4javascript.Level.INFO,[arrayOfTestItems[i]],null);t.log("Formatting",arrayOfTestItems[i],result);var result=layout.format(loggingEvent);loggingEvent.exception=ex;t.log("Formatting with exception",arrayOfTestItems[i],result);result=layout.format(loggingEvent);}};xn.test.enableTestDebug=true;xn.test.enable_log4javascript=false;xn.test.suite("log4javascript tests",function(s){log4javascript.logLog.setQuietMode(true);var ArrayAppender=function(layout){if(layout){this.setLayout(layout);}
+this.logMessages=[];};ArrayAppender.prototype=new log4javascript.Appender();ArrayAppender.prototype.layout=new log4javascript.NullLayout();ArrayAppender.prototype.append=function(loggingEvent){var formattedMessage=this.getLayout().format(loggingEvent);if(this.getLayout().ignoresThrowable()){formattedMessage+=loggingEvent.getThrowableStrRep();}
+this.logMessages.push(formattedMessage);};ArrayAppender.prototype.toString=function(){return"[ArrayAppender]";};s.setUp=function(t){t.logger=log4javascript.getLogger("test");t.logger.removeAllAppenders();t.appender=new ArrayAppender();t.logger.addAppender(t.appender);};s.tearDown=function(t){t.logger.removeAppender(t.appender);log4javascript.resetConfiguration();};s.test("Stub script interface test",function(t){try{compareObjectInterface(log4javascript,"log4javascript",log4javascript_stub,"log4javascript_stub");}catch(ex){t.fail(ex);}});s.test("Disable log4javascript test",function(t){log4javascript.setEnabled(false);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,0);log4javascript.setEnabled(true);});s.test("Array.splice test 1",function(t){var a=["Marlon","Ashley","Darius","Lloyd"];var deletedItems=a.splice(1,2);t.assertEquals(a.join(","),"Marlon,Lloyd");t.assertEquals(deletedItems.join(","),"Ashley,Darius");});s.test("Array.splice test 2",function(t){var a=["Marlon","Ashley","Darius","Lloyd"];var deletedItems=a.splice(1,1,"Malky","Jay");t.assertEquals(a.join(","),"Marlon,Malky,Jay,Darius,Lloyd");t.assertEquals(deletedItems.join(","),"Ashley");});s.test("array_remove test",function(t){var array_remove=log4javascript.evalInScope("array_remove");var a=["Marlon","Ashley","Darius"];array_remove(a,"Darius");t.assertEquals(a.join(","),"Marlon,Ashley");});s.test("array_remove with empty array test",function(t){var array_remove=log4javascript.evalInScope("array_remove");var a=[];array_remove(a,"Darius");t.assertEquals(a.join(","),"");});s.test("Logger logging test",function(t){t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,1);});s.test("Logger levels test",function(t){var originalLevel=t.logger.getEffectiveLevel();t.logger.setLevel(log4javascript.Level.INFO);t.logger.debug("TEST");t.logger.setLevel(originalLevel);t.assertEquals(t.appender.logMessages.length,0);});s.test("Logger getEffectiveLevel inheritance test 1",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");parentLogger.setLevel(log4javascript.Level.ERROR);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.ERROR);});s.test("Logger getEffectiveLevel inheritance test 2",function(t){var grandParentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2.test3");grandParentLogger.setLevel(log4javascript.Level.ERROR);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.ERROR);});s.test("Logger getEffectiveLevel inheritance test 3",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");parentLogger.setLevel(log4javascript.Level.ERROR);childLogger.setLevel(log4javascript.Level.INFO);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.INFO);});s.test("Logger getEffectiveLevel root inheritance test",function(t){var rootLogger=log4javascript.getRootLogger();var childLogger=log4javascript.getLogger("test1.test2.test3");rootLogger.setLevel(log4javascript.Level.WARN);t.assertEquals(childLogger.getEffectiveLevel(),log4javascript.Level.WARN);});s.test("Logger null level test",function(t){t.logger.setLevel(null);t.assertEquals(t.logger.getEffectiveLevel(),log4javascript.Level.DEBUG);});s.test("Logger appender additivity test 1",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");t.assertEquals(parentLoggerAppender.logMessages.length,2);t.assertEquals(childLoggerAppender.logMessages.length,1);});s.test("Logger appender additivity test 2",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);childLogger.setAdditivity(false);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");t.assertEquals(parentLoggerAppender.logMessages.length,1);t.assertEquals(childLoggerAppender.logMessages.length,1);});s.test("Logger appender additivity test 3",function(t){var parentLogger=log4javascript.getLogger("test1");var childLogger=log4javascript.getLogger("test1.test2");var parentLoggerAppender=new ArrayAppender();var childLoggerAppender=new ArrayAppender();parentLogger.addAppender(parentLoggerAppender);childLogger.addAppender(childLoggerAppender);childLogger.setAdditivity(false);parentLogger.info("Parent logger test message");childLogger.info("Child logger test message");childLogger.setAdditivity(true);childLogger.info("Child logger test message 2");t.assertEquals(parentLoggerAppender.logMessages.length,2);t.assertEquals(childLoggerAppender.logMessages.length,2);});s.test("Appender threshold test",function(t){t.appender.setThreshold(log4javascript.Level.INFO);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,0);});s.test("Basic appender / layout test",function(t){t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST");});s.test("Appender uniqueness within logger test",function(t){t.logger.addAppender(t.appender);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages.length,1);});s.test("Logger remove appender test",function(t){t.logger.debug("TEST");t.logger.removeAppender(t.appender);t.logger.debug("TEST AGAIN");t.assertEquals(t.appender.logMessages.length,1);});s.test("",function(t){t.logger.debug("TEST");t.logger.removeAppender(t.appender);t.logger.debug("TEST AGAIN");t.assertEquals(t.appender.logMessages.length,1);});s.test("SimpleLayout format test",function(t){var layout=new log4javascript.SimpleLayout();testLayoutWithVariables(layout,t);});s.test("SimpleLayout test",function(t){t.appender.setLayout(new log4javascript.SimpleLayout());t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"DEBUG - TEST");});s.test("NullLayout format test",function(t){var layout=new log4javascript.NullLayout();testLayoutWithVariables(layout,t);});s.test("NullLayout test",function(t){t.appender.setLayout(new log4javascript.NullLayout());t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST");});s.test("XmlLayout format test",function(t){var layout=new log4javascript.XmlLayout();testLayoutWithVariables(layout,t);});s.test("XmlLayout test",function(t){t.appender.setLayout(new log4javascript.XmlLayout());t.logger.debug("TEST");t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<\/log4javascript:event>\s*$/,t.appender.logMessages[0]);});s.test("XmlLayout with exception test",function(t){t.appender.setLayout(new log4javascript.XmlLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<log4javascript:exception>\s*<!\[CDATA\[.*\]\]><\/log4javascript:exception>\s*<\/log4javascript:event>\s*$/,t.appender.logMessages[0]);});var setUpXmlLayoutMillisecondsTest=function(t){t.date=new Date();t.timeInMilliseconds=t.date.getTime();t.timeInSeconds=Math.floor(t.timeInMilliseconds/1000);t.milliseconds=t.date.getMilliseconds();t.loggingEvent=new log4javascript.LoggingEvent(t.logger,t.date,log4javascript.Level.DEBUG,["TEST"],null);t.layout=new log4javascript.XmlLayout();}
+s.test("XmlLayout seconds/milliseconds test 1",function(t){setUpXmlLayoutMillisecondsTest(t);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInMilliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,t.layout.format(t.loggingEvent));});s.test("XmlLayout seconds/milliseconds test 2",function(t){setUpXmlLayoutMillisecondsTest(t);log4javascript.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);log4javascript.setTimeStampsInMilliseconds(true);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInSeconds+'" milliseconds="'+t.milliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,formatted);});s.test("XmlLayout seconds/milliseconds test 3",function(t){setUpXmlLayoutMillisecondsTest(t);t.layout.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);var regex=new RegExp('^<log4javascript:event logger="test" timestamp="'+t.timeInSeconds+'" milliseconds="'+t.milliseconds+'" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');t.assertRegexMatches(regex,formatted);});s.test("escapeNewLines test",function(t){var escapeNewLines=log4javascript.evalInScope("escapeNewLines");var str="1\r2\n3\n4\r\n5\r6\r\n7";t.assertEquals(escapeNewLines(str),"1\\r\\n2\\r\\n3\\r\\n4\\r\\n5\\r\\n6\\r\\n7");});s.test("JsonLayout format test",function(t){var layout=new log4javascript.JsonLayout();testLayoutWithVariables(layout,t);});s.test("JsonLayout test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST");t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST"}$/,t.appender.logMessages[0]);});s.test("JsonLayout JSON validity test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST");eval("var o = "+t.appender.logMessages[0]);t.assertEquals(o.message,"TEST");});s.test("JsonLayout with number type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug(15);t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":15}$/,t.appender.logMessages[0]);});s.test("JsonLayout with object type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug({});t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"\[object Object\]"}$/,t.appender.logMessages[0]);});s.test("JsonLayout with boolean type message test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug(false);t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":false}$/,t.appender.logMessages[0]);});s.test("JsonLayout with quote test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TE\"S\"T");t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TE\\"S\\"T"}$/,t.appender.logMessages[0]);});s.test("JsonLayout with exception test",function(t){t.appender.setLayout(new log4javascript.JsonLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST","exception":.*}$/,t.appender.logMessages[0]);});var setUpJsonLayoutMillisecondsTest=function(t){t.date=new Date();t.timeInMilliseconds=t.date.getTime();t.timeInSeconds=Math.floor(t.timeInMilliseconds/1000);t.milliseconds=t.date.getMilliseconds();t.loggingEvent=new log4javascript.LoggingEvent(t.logger,t.date,log4javascript.Level.DEBUG,["TEST"],null);t.layout=new log4javascript.JsonLayout();};s.test("JsonLayout seconds/milliseconds test 1",function(t){setUpJsonLayoutMillisecondsTest(t);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInMilliseconds+',"level":"DEBUG","url":".*","message":"TEST"}$');t.assertRegexMatches(regex,t.layout.format(t.loggingEvent));});s.test("JsonLayout seconds/milliseconds test 2",function(t){setUpJsonLayoutMillisecondsTest(t);log4javascript.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);log4javascript.setTimeStampsInMilliseconds(true);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInSeconds+',"level":"DEBUG","url":".*","message":"TEST","milliseconds":'+t.milliseconds+'}$');t.assertRegexMatches(regex,formatted);});s.test("JsonLayout seconds/milliseconds test 3",function(t){setUpJsonLayoutMillisecondsTest(t);t.layout.setTimeStampsInMilliseconds(false);var formatted=t.layout.format(t.loggingEvent);var regex=new RegExp('^{"logger":"test","timestamp":'+t.timeInSeconds+',"level":"DEBUG","url":".*","message":"TEST","milliseconds":'+t.milliseconds+'}$');t.assertRegexMatches(regex,formatted);});s.test("HttpPostDataLayout format test",function(t){var layout=new log4javascript.HttpPostDataLayout();testLayoutWithVariables(layout,t);});s.test("HttpPostDataLayout test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST");t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST$/,t.appender.logMessages[0]);});s.test("HttpPostDataLayout URL encoding test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST +\"1\"");t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST%20%2B%221%22$/,t.appender.logMessages[0]);});s.test("HttpPostDataLayout with exception test",function(t){t.appender.setLayout(new log4javascript.HttpPostDataLayout());t.logger.debug("TEST",new Error("Test error"));t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST&exception=.*$/,t.appender.logMessages[0]);});(function(){var formatObjectExpansion=log4javascript.evalInScope("formatObjectExpansion");var newLine=log4javascript.evalInScope("newLine");var arr=[null,undefined,1.2,"A string",[1,"test"],{a:{b:1}}];s.test("Basic formatObjectExpansion array test (depth: 1)",function(t){t.assertEquals(formatObjectExpansion(arr,1),"["+newLine+"  null,"+newLine+"  undefined,"+newLine+"  1.2,"+newLine+"  A string,"+newLine+"  1,test,"+newLine+"  [object Object]"+newLine+"]");});s.test("Basic formatObjectExpansion array test (depth: 2)",function(t){t.assertEquals(formatObjectExpansion(arr,2),"["+newLine+"  null,"+newLine+"  undefined,"+newLine+"  1.2,"+newLine+"  A string,"+newLine+"  ["+newLine+"    1,"+newLine+"    test"+newLine+"  ],"+newLine+"  {"+newLine+"    a: [object Object]"+newLine+"  }"+newLine+"]");});s.test("formatObjectExpansion simple object test",function(t){var obj={STRING:"A string"};t.assertEquals(formatObjectExpansion(obj,1),"{"+newLine+"  STRING: A string"+newLine+"}");});s.test("formatObjectExpansion simple circular object test",function(t){var obj={};obj.a=obj;t.assertEquals(formatObjectExpansion(obj,2),"{"+newLine+"  a: [object Object] [already expanded]"+newLine+"}");});})();var getSampleDate=function(){var date=new Date();date.setFullYear(2006);date.setMonth(7);date.setDate(30);date.setHours(15);date.setMinutes(38);date.setSeconds(45);return date;};s.test("String.replace test",function(t){t.assertEquals("Hello world".replace(/o/g,"Z"),"HellZ wZrld");});s.test("PatternLayout format test",function(t){var layout=new log4javascript.PatternLayout();testLayoutWithVariables(layout,t);});s.test("PatternLayout dates test",function(t){var layout=new log4javascript.PatternLayout("%d %d{DATE} %d{HH:ss}");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertRegexMatches(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2},\d{3} \d{2}:\d{2}$/,t.appender.logMessages[0]);});s.test("PatternLayout modifiers test",function(t){var layout=new log4javascript.PatternLayout("%m|%3m|%-3m|%6m|%-6m|%.2m|%1.2m|%6.8m|%-1.2m|%-6.8m|");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertEquals(t.appender.logMessages[0],"TEST|TEST|TEST|  TEST|TEST  |ST|ST|  TEST|ST|TEST  |");});s.test("PatternLayout conversion characters test",function(t){var layout=new log4javascript.PatternLayout("%c %n %p %r literal %%");t.appender.setLayout(layout);t.logger.debug("TEST");t.assertRegexMatches(/^test \s+ DEBUG \d+ literal %$/,t.appender.logMessages[0]);});s.test("PatternLayout message test",function(t){var layout=new log4javascript.PatternLayout("%m{1} %m{2}");t.appender.setLayout(layout);var testObj={strikers:{quick:"Marlon"}};t.logger.debug(testObj);t.assertEquals("{\r\n  strikers: [object Object]\r\n} {\r\n\  strikers: {\r\n    quick: Marlon\r\n  }\r\n}",t.appender.logMessages[0]);});});
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production_uncompressed.js
new file mode 100644
index 0000000..e64990f
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_production_uncompressed.js
@@ -0,0 +1,728 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function array_contains(arr, val) {
+	for (var i = 0; i < arr.length; i++) {
+		if (arr[i] == val) {
+			return true;
+		}
+	}
+	return false;
+}
+
+// Recursively checks that obj2's interface contains all of obj1's
+// interface (functions and objects only)
+function compareObjectInterface(obj1, obj1_name, obj2, obj2_name, namePrefix) {
+	if (!namePrefix) {
+		namePrefix = "";
+	}
+	var obj1PropertyNames = new Array();
+	for (var i in obj1) {
+		if (i != "prototype" && i != "arguments") {
+			obj1PropertyNames.push(i);
+		}
+	}
+	if (obj1 && obj1.prototype && !array_contains(obj1PropertyNames, "prototype")) {
+		//obj1PropertyNames.push("prototype");
+	}
+	for (var j = 0; j < obj1PropertyNames.length; j++) {
+		var propertyName = obj1PropertyNames[j];
+		if ((typeof obj1[propertyName] == "function" || typeof obj1[propertyName] == "object") && !(obj1[propertyName] instanceof Array)) {
+			var propertyFullyQualifiedName = (namePrefix == "") ? propertyName : namePrefix + "." + propertyName;
+			try {
+				if (typeof obj2[propertyName] == "undefined") {
+					throw new Error(obj2_name + " does not contain " + propertyFullyQualifiedName + " in " + obj1_name);
+				} else if (typeof obj2[propertyName] != typeof obj1[propertyName]){
+					throw new Error(obj2_name + "'s " + propertyFullyQualifiedName + " is of the wrong type: " + typeof obj2[propertyName] + " when it is type " + typeof obj1[propertyName] + " in " + obj1_name);
+				} else if (obj1[propertyName] != Function.prototype.apply) {
+					if (!compareObjectInterface(obj1[propertyName], obj1_name, obj2[propertyName], obj2_name, propertyFullyQualifiedName)) {
+						throw new Error("Interfaces don't match");
+					}
+				}
+			} catch(ex) {
+				throw new Error("Exception while checking property name " + propertyFullyQualifiedName + " in " + obj2_name + ": " + ex.message);
+			}
+		}
+	}
+	return true;
+};
+
+// Simply tests a layout for exceptions when formatting
+var testLayoutWithVariables = function(layout, t) {
+	var emptyObject = {};
+	var emptyArray = [];
+	var emptyString = "";
+	var localUndefined = emptyArray[0];
+	var oneLevelObject = {
+		"name": "One-level object"
+	};
+	var twoLevelObject = {
+		"name": "Two-level object",
+		"data": oneLevelObject
+	};
+	var threeLevelObject = {
+		"name": "Three-level object",
+		"data": twoLevelObject
+	};
+	var anArray = [
+		3,
+		"stuff",
+		true,
+		false,
+		0,
+		null,
+		localUndefined,
+		3.14,
+		function(p) { return "I'm a function"; },
+		[1, "things"]
+	];
+	var arrayOfTestItems = [emptyObject, emptyString, emptyString, localUndefined, oneLevelObject,
+			twoLevelObject, threeLevelObject, anArray];
+
+	t.log("Testing layout " + layout)
+	for (var i = 0; i < arrayOfTestItems.length; i++) {
+		var ex = new Error("Test error");
+		var loggingEvent = new log4javascript.LoggingEvent(t.logger, new Date(), log4javascript.Level.INFO,
+				[arrayOfTestItems[i]], null);
+		t.log("Formatting", arrayOfTestItems[i], result);
+		var result = layout.format(loggingEvent);
+		// Now try with an exception
+		loggingEvent.exception = ex;
+		t.log("Formatting with exception", arrayOfTestItems[i], result);
+		result = layout.format(loggingEvent);
+	}
+};
+
+xn.test.enableTestDebug = true;
+xn.test.enable_log4javascript = false;
+
+xn.test.suite("log4javascript tests", function(s) {
+	log4javascript.logLog.setQuietMode(true);
+	var ArrayAppender = function(layout) {
+		if (layout) {
+			this.setLayout(layout);
+		}
+		this.logMessages = [];
+	};
+
+	ArrayAppender.prototype = new log4javascript.Appender();
+
+	ArrayAppender.prototype.layout = new log4javascript.NullLayout();
+
+	ArrayAppender.prototype.append = function(loggingEvent) {
+		var formattedMessage = this.getLayout().format(loggingEvent);
+		if (this.getLayout().ignoresThrowable()) {
+			formattedMessage += loggingEvent.getThrowableStrRep();
+		}
+		this.logMessages.push(formattedMessage);
+	};
+
+	ArrayAppender.prototype.toString = function() {
+		return "[ArrayAppender]";
+	};
+
+    s.setUp = function(t) {
+        t.logger = log4javascript.getLogger("test");
+		t.logger.removeAllAppenders();
+		t.appender = new ArrayAppender();
+        t.logger.addAppender(t.appender);
+    };
+
+    s.tearDown = function(t) {
+        t.logger.removeAppender(t.appender);
+		log4javascript.resetConfiguration();
+	};
+
+    s.test("Stub script interface test", function(t) {
+        try {
+            compareObjectInterface(log4javascript, "log4javascript", log4javascript_stub, "log4javascript_stub");
+        } catch (ex) {
+            t.fail(ex);
+        }
+    });
+
+	s.test("Disable log4javascript test", function(t) {
+		log4javascript.setEnabled(false);
+		t.logger.debug("TEST");
+		t.assertEquals(t.appender.logMessages.length, 0);
+		log4javascript.setEnabled(true);
+	});
+
+    s.test("Array.splice test 1", function(t) {
+        var a = ["Marlon", "Ashley", "Darius", "Lloyd"];
+        var deletedItems = a.splice(1, 2);
+        t.assertEquals(a.join(","), "Marlon,Lloyd");
+        t.assertEquals(deletedItems.join(","), "Ashley,Darius");
+    });
+
+    s.test("Array.splice test 2", function(t) {
+        var a = ["Marlon", "Ashley", "Darius", "Lloyd"];
+        var deletedItems = a.splice(1, 1, "Malky", "Jay");
+        t.assertEquals(a.join(","), "Marlon,Malky,Jay,Darius,Lloyd");
+        t.assertEquals(deletedItems.join(","), "Ashley");
+    });
+
+    s.test("array_remove test", function(t) {
+        var array_remove = log4javascript.evalInScope("array_remove");
+        var a = ["Marlon", "Ashley", "Darius"];
+        array_remove(a, "Darius");
+        t.assertEquals(a.join(","), "Marlon,Ashley");
+    });
+
+	s.test("array_remove with empty array test", function(t) {
+		var array_remove = log4javascript.evalInScope("array_remove");
+		var a = [];
+		array_remove(a, "Darius");
+		t.assertEquals(a.join(","), "");
+	});
+
+    s.test("Logger logging test", function(t) {
+        // Should log since the default level for loggers is DEBUG and
+        // the default threshold for appenders is ALL
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 1);
+    });
+
+    s.test("Logger levels test", function(t) {
+        var originalLevel = t.logger.getEffectiveLevel();
+        t.logger.setLevel(log4javascript.Level.INFO);
+        t.logger.debug("TEST");
+		t.logger.setLevel(originalLevel);
+        t.assertEquals(t.appender.logMessages.length, 0);
+    });
+
+	s.test("Logger getEffectiveLevel inheritance test 1", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		parentLogger.setLevel(log4javascript.Level.ERROR);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.ERROR);
+	});
+
+	s.test("Logger getEffectiveLevel inheritance test 2", function(t) {
+		var grandParentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2.test3");
+		grandParentLogger.setLevel(log4javascript.Level.ERROR);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.ERROR);
+	});
+
+	s.test("Logger getEffectiveLevel inheritance test 3", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		parentLogger.setLevel(log4javascript.Level.ERROR);
+		childLogger.setLevel(log4javascript.Level.INFO);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.INFO);
+	});
+
+	s.test("Logger getEffectiveLevel root inheritance test", function(t) {
+		var rootLogger = log4javascript.getRootLogger();
+		var childLogger = log4javascript.getLogger("test1.test2.test3");
+		rootLogger.setLevel(log4javascript.Level.WARN);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.WARN);
+	});
+
+	s.test("Logger null level test", function(t) {
+		t.logger.setLevel(null);
+		// Should default to root logger level, which is DEBUG
+		t.assertEquals(t.logger.getEffectiveLevel(), log4javascript.Level.DEBUG);
+	});
+
+	s.test("Logger appender additivity test 1", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 2);
+		t.assertEquals(childLoggerAppender.logMessages.length, 1);
+	});
+
+	s.test("Logger appender additivity test 2", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		childLogger.setAdditivity(false);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 1);
+		t.assertEquals(childLoggerAppender.logMessages.length, 1);
+	});
+
+	s.test("Logger appender additivity test 3", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		childLogger.setAdditivity(false);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		childLogger.setAdditivity(true);
+
+		childLogger.info("Child logger test message 2");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 2);
+		t.assertEquals(childLoggerAppender.logMessages.length, 2);
+	});
+
+	s.test("Appender threshold test", function(t) {
+        t.appender.setThreshold(log4javascript.Level.INFO);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 0);
+    });
+
+    s.test("Basic appender / layout test", function(t) {
+        t.logger.debug("TEST");
+		t.assertEquals(t.appender.logMessages[0], "TEST");
+    });
+
+	s.test("Appender uniqueness within logger test", function(t) {
+		// Add the same appender to the logger for a second time
+		t.logger.addAppender(t.appender);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 1);
+    });
+
+	s.test("Logger remove appender test", function(t) {
+		t.logger.debug("TEST");
+		t.logger.removeAppender(t.appender);
+		t.logger.debug("TEST AGAIN");
+		t.assertEquals(t.appender.logMessages.length, 1);
+	});
+
+	s.test("", function(t) {
+		t.logger.debug("TEST");
+		t.logger.removeAppender(t.appender);
+		t.logger.debug("TEST AGAIN");
+		t.assertEquals(t.appender.logMessages.length, 1);
+	});
+	s.test("SimpleLayout format test", function(t) {
+		var layout = new log4javascript.SimpleLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("SimpleLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.SimpleLayout());
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "DEBUG - TEST");
+    });
+	s.test("NullLayout format test", function(t) {
+		var layout = new log4javascript.NullLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("NullLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.NullLayout());
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "TEST");
+    });
+	s.test("XmlLayout format test", function(t) {
+		var layout = new log4javascript.XmlLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("XmlLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.XmlLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<\/log4javascript:event>\s*$/, t.appender.logMessages[0]);
+    });
+
+    s.test("XmlLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.XmlLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<log4javascript:exception>\s*<!\[CDATA\[.*\]\]><\/log4javascript:exception>\s*<\/log4javascript:event>\s*$/, t.appender.logMessages[0]);
+    });
+
+	var setUpXmlLayoutMillisecondsTest = function(t) {
+		t.date = new Date();
+		t.timeInMilliseconds = t.date.getTime();
+		t.timeInSeconds = Math.floor(t.timeInMilliseconds / 1000);
+		t.milliseconds = t.date.getMilliseconds();
+		
+		t.loggingEvent = new log4javascript.LoggingEvent(t.logger, t.date, log4javascript.Level.DEBUG, ["TEST"], null);
+		t.layout = new log4javascript.XmlLayout();
+	}
+
+	s.test("XmlLayout seconds/milliseconds test 1", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+		// Test default (i.e. timestamps in milliseconds) first
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInMilliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, t.layout.format(t.loggingEvent));
+	});
+	
+	s.test("XmlLayout seconds/milliseconds test 2", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+        // Change the global setting
+        log4javascript.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        log4javascript.setTimeStampsInMilliseconds(true);
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInSeconds + '" milliseconds="' + t.milliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, formatted);
+	});
+
+	s.test("XmlLayout seconds/milliseconds test 3", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+        // Change the layout setting
+        t.layout.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInSeconds + '" milliseconds="' + t.milliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, formatted);
+	});
+	s.test("escapeNewLines test", function(t) {
+		var escapeNewLines = log4javascript.evalInScope("escapeNewLines");
+		var str = "1\r2\n3\n4\r\n5\r6\r\n7";
+		t.assertEquals(escapeNewLines(str), "1\\r\\n2\\r\\n3\\r\\n4\\r\\n5\\r\\n6\\r\\n7");
+	});
+
+	s.test("JsonLayout format test", function(t) {
+		var layout = new log4javascript.JsonLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("JsonLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout JSON validity test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST");
+        eval("var o = " + t.appender.logMessages[0]);
+        t.assertEquals(o.message, "TEST");
+    });
+
+    s.test("JsonLayout with number type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug(15);
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":15}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with object type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug({});
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"\[object Object\]"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with boolean type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug(false);
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":false}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with quote test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TE\"S\"T");
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TE\\"S\\"T"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST","exception":.*}$/, t.appender.logMessages[0]);
+    });
+
+	var setUpJsonLayoutMillisecondsTest = function(t) {
+		t.date = new Date();
+		t.timeInMilliseconds = t.date.getTime();
+		t.timeInSeconds = Math.floor(t.timeInMilliseconds / 1000);
+		t.milliseconds = t.date.getMilliseconds();
+		
+		t.loggingEvent = new log4javascript.LoggingEvent(t.logger, t.date, log4javascript.Level.DEBUG, ["TEST"], null);
+		t.layout = new log4javascript.JsonLayout();
+	};
+
+	s.test("JsonLayout seconds/milliseconds test 1", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+		// Test default (i.e. timestamps in milliseconds) first
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInMilliseconds + ',"level":"DEBUG","url":".*","message":"TEST"}$');
+        t.assertRegexMatches(regex, t.layout.format(t.loggingEvent));
+	});
+	
+	s.test("JsonLayout seconds/milliseconds test 2", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+        // Change the global setting
+        log4javascript.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        log4javascript.setTimeStampsInMilliseconds(true);
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInSeconds + ',"level":"DEBUG","url":".*","message":"TEST","milliseconds":' + t.milliseconds + '}$');
+        t.assertRegexMatches(regex, formatted);
+	});
+
+	s.test("JsonLayout seconds/milliseconds test 3", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+        // Change the layout setting
+        t.layout.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInSeconds + ',"level":"DEBUG","url":".*","message":"TEST","milliseconds":' + t.milliseconds + '}$');
+        t.assertRegexMatches(regex, formatted);
+	});
+	s.test("HttpPostDataLayout format test", function(t) {
+		var layout = new log4javascript.HttpPostDataLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("HttpPostDataLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST$/, t.appender.logMessages[0]);
+    });
+
+    s.test("HttpPostDataLayout URL encoding test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST +\"1\"");
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST%20%2B%221%22$/, t.appender.logMessages[0]);
+    });
+
+    s.test("HttpPostDataLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST&exception=.*$/, t.appender.logMessages[0]);
+    });
+
+	(function() {
+		var formatObjectExpansion = log4javascript.evalInScope("formatObjectExpansion");
+		var newLine = log4javascript.evalInScope("newLine");
+		var arr = [
+			null,
+			undefined,
+			1.2,
+			"A string",
+			[1, "test"],
+			{
+				a: {
+					b: 1
+				}
+			}
+		];
+
+		s.test("Basic formatObjectExpansion array test (depth: 1)", function(t) {
+			t.assertEquals(formatObjectExpansion(arr, 1),
+				"[" + newLine +
+				"  null," + newLine +
+				"  undefined," + newLine +
+				"  1.2," + newLine +
+				"  A string," + newLine +
+				"  1,test," + newLine +
+				"  [object Object]" + newLine +
+				"]"
+			);
+		});
+
+		s.test("Basic formatObjectExpansion array test (depth: 2)", function(t) {
+			t.assertEquals(formatObjectExpansion(arr, 2),
+				"[" + newLine +
+				"  null," + newLine +
+				"  undefined," + newLine +
+				"  1.2," + newLine +
+				"  A string," + newLine +
+				"  [" + newLine +
+				"    1," + newLine +
+				"    test" + newLine +
+				"  ]," + newLine +
+				"  {" + newLine +
+				"    a: [object Object]" + newLine +
+				"  }" + newLine +
+				"]"
+			);
+		});
+
+		s.test("formatObjectExpansion simple object test", function(t) {
+			var obj = {
+				STRING: "A string"
+			};
+			t.assertEquals(formatObjectExpansion(obj, 1), 
+				"{" + newLine +
+				"  STRING: A string" + newLine +
+				"}"
+			);
+		});
+
+		s.test("formatObjectExpansion simple circular object test", function(t) {
+			var obj = {};
+			obj.a = obj;
+			
+			t.assertEquals(formatObjectExpansion(obj, 2), 
+				"{" + newLine +
+				"  a: [object Object] [already expanded]" + newLine +
+				"}"
+			);
+		});
+	})();    /* ---------------------------------------------------------- */
+
+    var getSampleDate = function() {
+        var date = new Date();
+        date.setFullYear(2006);
+        date.setMonth(7);
+        date.setDate(30);
+        date.setHours(15);
+        date.setMinutes(38);
+        date.setSeconds(45);
+        return date;
+    };
+
+    /* ---------------------------------------------------------- */
+
+    s.test("String.replace test", function(t) {
+        t.assertEquals("Hello world".replace(/o/g, "Z"), "HellZ wZrld");
+    });
+
+	s.test("PatternLayout format test", function(t) {
+		var layout = new log4javascript.PatternLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("PatternLayout dates test", function(t) {
+        var layout = new log4javascript.PatternLayout("%d %d{DATE} %d{HH:ss}");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2},\d{3} \d{2}:\d{2}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("PatternLayout modifiers test", function(t) {
+        var layout = new log4javascript.PatternLayout("%m|%3m|%-3m|%6m|%-6m|%.2m|%1.2m|%6.8m|%-1.2m|%-6.8m|");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "TEST|TEST|TEST|  TEST|TEST  |ST|ST|  TEST|ST|TEST  |");
+    });
+
+    s.test("PatternLayout conversion characters test", function(t) {
+        var layout = new log4javascript.PatternLayout("%c %n %p %r literal %%");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^test \s+ DEBUG \d+ literal %$/, t.appender.logMessages[0]);
+    });
+
+    s.test("PatternLayout message test", function(t) {
+        var layout = new log4javascript.PatternLayout("%m{1} %m{2}");
+        t.appender.setLayout(layout);
+        var testObj = {
+            strikers: {
+                quick: "Marlon"
+            }
+        };
+        t.logger.debug(testObj);
+        t.assertEquals("{\r\n  strikers: [object Object]\r\n} {\r\n\  strikers: {\r\n    quick: Marlon\r\n  }\r\n}", t.appender.logMessages[0]);
+    });
+/*
+	s.test("AjaxAppender JsonLayout single message test", function(t) {
+		t.async(10000);
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		ajaxAppender.setLayout(new log4javascript.JsonLayout());
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 1);
+				t.assertEquals(arr[0], "TEST");
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug("TEST");
+	});
+
+	s.test("AjaxAppender JsonLayout batched messages test", function(t) {
+		t.async(10000);
+		var message1 = "TEST 1";
+		var message2 = "String with \"lots of 'quotes'\" + plusses in";
+		var message3 = "A non-threatening string";
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		ajaxAppender.setLayout(new log4javascript.JsonLayout());
+		ajaxAppender.setBatchSize(3);
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 3);
+				t.assertEquals(arr[0], message1);
+				t.assertEquals(arr[1], message2);
+				t.assertEquals(arr[2], message3);
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug(message1);
+		t.logger.info(message2);
+		t.logger.warn(message3);
+	});
+
+	s.test("AjaxAppender HttpPostDataLayout single message test", function(t) {
+		t.async(10000);
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		var testMessage = "TEST +\"1\"";
+		ajaxAppender.setLayout(new log4javascript.HttpPostDataLayout());
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 1);
+				t.assertEquals(arr[0], testMessage);
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug(testMessage);
+	});
+*/
+});
\ No newline at end of file
diff --git a/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_uncompressed.js b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_uncompressed.js
new file mode 100644
index 0000000..55bd2ca
--- /dev/null
+++ b/planetstack/core/static/log4javascript-1.4.6/js/tests/log4javascript_uncompressed.js
@@ -0,0 +1,862 @@
+/**
+ * Copyright 2013 Tim Down.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function array_contains(arr, val) {
+	for (var i = 0; i < arr.length; i++) {
+		if (arr[i] == val) {
+			return true;
+		}
+	}
+	return false;
+}
+
+// Recursively checks that obj2's interface contains all of obj1's
+// interface (functions and objects only)
+function compareObjectInterface(obj1, obj1_name, obj2, obj2_name, namePrefix) {
+	if (!namePrefix) {
+		namePrefix = "";
+	}
+	var obj1PropertyNames = new Array();
+	for (var i in obj1) {
+		if (i != "prototype" && i != "arguments") {
+			obj1PropertyNames.push(i);
+		}
+	}
+	if (obj1 && obj1.prototype && !array_contains(obj1PropertyNames, "prototype")) {
+		//obj1PropertyNames.push("prototype");
+	}
+	for (var j = 0; j < obj1PropertyNames.length; j++) {
+		var propertyName = obj1PropertyNames[j];
+		if ((typeof obj1[propertyName] == "function" || typeof obj1[propertyName] == "object") && !(obj1[propertyName] instanceof Array)) {
+			var propertyFullyQualifiedName = (namePrefix == "") ? propertyName : namePrefix + "." + propertyName;
+			try {
+				if (typeof obj2[propertyName] == "undefined") {
+					throw new Error(obj2_name + " does not contain " + propertyFullyQualifiedName + " in " + obj1_name);
+				} else if (typeof obj2[propertyName] != typeof obj1[propertyName]){
+					throw new Error(obj2_name + "'s " + propertyFullyQualifiedName + " is of the wrong type: " + typeof obj2[propertyName] + " when it is type " + typeof obj1[propertyName] + " in " + obj1_name);
+				} else if (obj1[propertyName] != Function.prototype.apply) {
+					if (!compareObjectInterface(obj1[propertyName], obj1_name, obj2[propertyName], obj2_name, propertyFullyQualifiedName)) {
+						throw new Error("Interfaces don't match");
+					}
+				}
+			} catch(ex) {
+				throw new Error("Exception while checking property name " + propertyFullyQualifiedName + " in " + obj2_name + ": " + ex.message);
+			}
+		}
+	}
+	return true;
+};
+
+// Simply tests a layout for exceptions when formatting
+var testLayoutWithVariables = function(layout, t) {
+	var emptyObject = {};
+	var emptyArray = [];
+	var emptyString = "";
+	var localUndefined = emptyArray[0];
+	var oneLevelObject = {
+		"name": "One-level object"
+	};
+	var twoLevelObject = {
+		"name": "Two-level object",
+		"data": oneLevelObject
+	};
+	var threeLevelObject = {
+		"name": "Three-level object",
+		"data": twoLevelObject
+	};
+	var anArray = [
+		3,
+		"stuff",
+		true,
+		false,
+		0,
+		null,
+		localUndefined,
+		3.14,
+		function(p) { return "I'm a function"; },
+		[1, "things"]
+	];
+	var arrayOfTestItems = [emptyObject, emptyString, emptyString, localUndefined, oneLevelObject,
+			twoLevelObject, threeLevelObject, anArray];
+
+	t.log("Testing layout " + layout)
+	for (var i = 0; i < arrayOfTestItems.length; i++) {
+		var ex = new Error("Test error");
+		var loggingEvent = new log4javascript.LoggingEvent(t.logger, new Date(), log4javascript.Level.INFO,
+				[arrayOfTestItems[i]], null);
+		t.log("Formatting", arrayOfTestItems[i], result);
+		var result = layout.format(loggingEvent);
+		// Now try with an exception
+		loggingEvent.exception = ex;
+		t.log("Formatting with exception", arrayOfTestItems[i], result);
+		result = layout.format(loggingEvent);
+	}
+};
+
+xn.test.enableTestDebug = true;
+xn.test.enable_log4javascript = false;
+
+xn.test.suite("log4javascript tests", function(s) {
+	log4javascript.logLog.setQuietMode(true);
+	var ArrayAppender = function(layout) {
+		if (layout) {
+			this.setLayout(layout);
+		}
+		this.logMessages = [];
+	};
+
+	ArrayAppender.prototype = new log4javascript.Appender();
+
+	ArrayAppender.prototype.layout = new log4javascript.NullLayout();
+
+	ArrayAppender.prototype.append = function(loggingEvent) {
+		var formattedMessage = this.getLayout().format(loggingEvent);
+		if (this.getLayout().ignoresThrowable()) {
+			formattedMessage += loggingEvent.getThrowableStrRep();
+		}
+		this.logMessages.push(formattedMessage);
+	};
+
+	ArrayAppender.prototype.toString = function() {
+		return "[ArrayAppender]";
+	};
+
+    s.setUp = function(t) {
+        t.logger = log4javascript.getLogger("test");
+		t.logger.removeAllAppenders();
+		t.appender = new ArrayAppender();
+        t.logger.addAppender(t.appender);
+    };
+
+    s.tearDown = function(t) {
+        t.logger.removeAppender(t.appender);
+		log4javascript.resetConfiguration();
+	};
+
+    s.test("Stub script interface test", function(t) {
+        try {
+            compareObjectInterface(log4javascript, "log4javascript", log4javascript_stub, "log4javascript_stub");
+        } catch (ex) {
+            t.fail(ex);
+        }
+    });
+
+	s.test("Disable log4javascript test", function(t) {
+		log4javascript.setEnabled(false);
+		t.logger.debug("TEST");
+		t.assertEquals(t.appender.logMessages.length, 0);
+		log4javascript.setEnabled(true);
+	});
+
+    s.test("Array.splice test 1", function(t) {
+        var a = ["Marlon", "Ashley", "Darius", "Lloyd"];
+        var deletedItems = a.splice(1, 2);
+        t.assertEquals(a.join(","), "Marlon,Lloyd");
+        t.assertEquals(deletedItems.join(","), "Ashley,Darius");
+    });
+
+    s.test("Array.splice test 2", function(t) {
+        var a = ["Marlon", "Ashley", "Darius", "Lloyd"];
+        var deletedItems = a.splice(1, 1, "Malky", "Jay");
+        t.assertEquals(a.join(","), "Marlon,Malky,Jay,Darius,Lloyd");
+        t.assertEquals(deletedItems.join(","), "Ashley");
+    });
+
+    s.test("array_remove test", function(t) {
+        var array_remove = log4javascript.evalInScope("array_remove");
+        var a = ["Marlon", "Ashley", "Darius"];
+        array_remove(a, "Darius");
+        t.assertEquals(a.join(","), "Marlon,Ashley");
+    });
+
+	s.test("array_remove with empty array test", function(t) {
+		var array_remove = log4javascript.evalInScope("array_remove");
+		var a = [];
+		array_remove(a, "Darius");
+		t.assertEquals(a.join(","), "");
+	});
+
+    s.test("Logger logging test", function(t) {
+        // Should log since the default level for loggers is DEBUG and
+        // the default threshold for appenders is ALL
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 1);
+    });
+
+    s.test("Logger levels test", function(t) {
+        var originalLevel = t.logger.getEffectiveLevel();
+        t.logger.setLevel(log4javascript.Level.INFO);
+        t.logger.debug("TEST");
+		t.logger.setLevel(originalLevel);
+        t.assertEquals(t.appender.logMessages.length, 0);
+    });
+
+	s.test("Logger getEffectiveLevel inheritance test 1", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		parentLogger.setLevel(log4javascript.Level.ERROR);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.ERROR);
+	});
+
+	s.test("Logger getEffectiveLevel inheritance test 2", function(t) {
+		var grandParentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2.test3");
+		grandParentLogger.setLevel(log4javascript.Level.ERROR);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.ERROR);
+	});
+
+	s.test("Logger getEffectiveLevel inheritance test 3", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		parentLogger.setLevel(log4javascript.Level.ERROR);
+		childLogger.setLevel(log4javascript.Level.INFO);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.INFO);
+	});
+
+	s.test("Logger getEffectiveLevel root inheritance test", function(t) {
+		var rootLogger = log4javascript.getRootLogger();
+		var childLogger = log4javascript.getLogger("test1.test2.test3");
+		rootLogger.setLevel(log4javascript.Level.WARN);
+		t.assertEquals(childLogger.getEffectiveLevel(), log4javascript.Level.WARN);
+	});
+
+	s.test("Logger null level test", function(t) {
+		t.logger.setLevel(null);
+		// Should default to root logger level, which is DEBUG
+		t.assertEquals(t.logger.getEffectiveLevel(), log4javascript.Level.DEBUG);
+	});
+
+	s.test("Logger appender additivity test 1", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 2);
+		t.assertEquals(childLoggerAppender.logMessages.length, 1);
+	});
+
+	s.test("Logger appender additivity test 2", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		childLogger.setAdditivity(false);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 1);
+		t.assertEquals(childLoggerAppender.logMessages.length, 1);
+	});
+
+	s.test("Logger appender additivity test 3", function(t) {
+		var parentLogger = log4javascript.getLogger("test1");
+		var childLogger = log4javascript.getLogger("test1.test2");
+		var parentLoggerAppender = new ArrayAppender();
+		var childLoggerAppender = new ArrayAppender();
+
+		parentLogger.addAppender(parentLoggerAppender);
+		childLogger.addAppender(childLoggerAppender);
+
+		childLogger.setAdditivity(false);
+
+		parentLogger.info("Parent logger test message");
+		childLogger.info("Child logger test message");
+
+		childLogger.setAdditivity(true);
+
+		childLogger.info("Child logger test message 2");
+
+		t.assertEquals(parentLoggerAppender.logMessages.length, 2);
+		t.assertEquals(childLoggerAppender.logMessages.length, 2);
+	});
+
+	s.test("Appender threshold test", function(t) {
+        t.appender.setThreshold(log4javascript.Level.INFO);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 0);
+    });
+
+    s.test("Basic appender / layout test", function(t) {
+        t.logger.debug("TEST");
+		t.assertEquals(t.appender.logMessages[0], "TEST");
+    });
+
+	s.test("Appender uniqueness within logger test", function(t) {
+		// Add the same appender to the logger for a second time
+		t.logger.addAppender(t.appender);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages.length, 1);
+    });
+
+	s.test("Logger remove appender test", function(t) {
+		t.logger.debug("TEST");
+		t.logger.removeAppender(t.appender);
+		t.logger.debug("TEST AGAIN");
+		t.assertEquals(t.appender.logMessages.length, 1);
+	});
+
+	s.test("", function(t) {
+		t.logger.debug("TEST");
+		t.logger.removeAppender(t.appender);
+		t.logger.debug("TEST AGAIN");
+		t.assertEquals(t.appender.logMessages.length, 1);
+	});
+	s.test("SimpleLayout format test", function(t) {
+		var layout = new log4javascript.SimpleLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("SimpleLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.SimpleLayout());
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "DEBUG - TEST");
+    });
+	s.test("NullLayout format test", function(t) {
+		var layout = new log4javascript.NullLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("NullLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.NullLayout());
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "TEST");
+    });
+	s.test("XmlLayout format test", function(t) {
+		var layout = new log4javascript.XmlLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("XmlLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.XmlLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<\/log4javascript:event>\s*$/, t.appender.logMessages[0]);
+    });
+
+    s.test("XmlLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.XmlLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^<log4javascript:event logger="test" timestamp="\d+" level="DEBUG">\s*<log4javascript:message><!\[CDATA\[TEST\]\]><\/log4javascript:message>\s*<log4javascript:exception>\s*<!\[CDATA\[.*\]\]><\/log4javascript:exception>\s*<\/log4javascript:event>\s*$/, t.appender.logMessages[0]);
+    });
+
+	var setUpXmlLayoutMillisecondsTest = function(t) {
+		t.date = new Date();
+		t.timeInMilliseconds = t.date.getTime();
+		t.timeInSeconds = Math.floor(t.timeInMilliseconds / 1000);
+		t.milliseconds = t.date.getMilliseconds();
+		
+		t.loggingEvent = new log4javascript.LoggingEvent(t.logger, t.date, log4javascript.Level.DEBUG, ["TEST"], null);
+		t.layout = new log4javascript.XmlLayout();
+	}
+
+	s.test("XmlLayout seconds/milliseconds test 1", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+		// Test default (i.e. timestamps in milliseconds) first
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInMilliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, t.layout.format(t.loggingEvent));
+	});
+	
+	s.test("XmlLayout seconds/milliseconds test 2", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+        // Change the global setting
+        log4javascript.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        log4javascript.setTimeStampsInMilliseconds(true);
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInSeconds + '" milliseconds="' + t.milliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, formatted);
+	});
+
+	s.test("XmlLayout seconds/milliseconds test 3", function(t) {
+		setUpXmlLayoutMillisecondsTest(t);
+
+        // Change the layout setting
+        t.layout.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        var regex = new RegExp('^<log4javascript:event logger="test" timestamp="' + t.timeInSeconds + '" milliseconds="' + t.milliseconds + '" level="DEBUG">\\s*<log4javascript:message><!\\[CDATA\\[TEST\\]\\]></log4javascript:message>\\s*</log4javascript:event>\\s*$');
+        t.assertRegexMatches(regex, formatted);
+	});
+	s.test("escapeNewLines test", function(t) {
+		var escapeNewLines = log4javascript.evalInScope("escapeNewLines");
+		var str = "1\r2\n3\n4\r\n5\r6\r\n7";
+		t.assertEquals(escapeNewLines(str), "1\\r\\n2\\r\\n3\\r\\n4\\r\\n5\\r\\n6\\r\\n7");
+	});
+
+	s.test("JsonLayout format test", function(t) {
+		var layout = new log4javascript.JsonLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("JsonLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout JSON validity test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST");
+        eval("var o = " + t.appender.logMessages[0]);
+        t.assertEquals(o.message, "TEST");
+    });
+
+    s.test("JsonLayout with number type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug(15);
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":15}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with object type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug({});
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"\[object Object\]"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with boolean type message test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug(false);
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":false}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with quote test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TE\"S\"T");
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TE\\"S\\"T"}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("JsonLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.JsonLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^{"logger":"test","timestamp":\d+,"level":"DEBUG","url":".*","message":"TEST","exception":.*}$/, t.appender.logMessages[0]);
+    });
+
+	var setUpJsonLayoutMillisecondsTest = function(t) {
+		t.date = new Date();
+		t.timeInMilliseconds = t.date.getTime();
+		t.timeInSeconds = Math.floor(t.timeInMilliseconds / 1000);
+		t.milliseconds = t.date.getMilliseconds();
+		
+		t.loggingEvent = new log4javascript.LoggingEvent(t.logger, t.date, log4javascript.Level.DEBUG, ["TEST"], null);
+		t.layout = new log4javascript.JsonLayout();
+	};
+
+	s.test("JsonLayout seconds/milliseconds test 1", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+		// Test default (i.e. timestamps in milliseconds) first
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInMilliseconds + ',"level":"DEBUG","url":".*","message":"TEST"}$');
+        t.assertRegexMatches(regex, t.layout.format(t.loggingEvent));
+	});
+	
+	s.test("JsonLayout seconds/milliseconds test 2", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+        // Change the global setting
+        log4javascript.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        log4javascript.setTimeStampsInMilliseconds(true);
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInSeconds + ',"level":"DEBUG","url":".*","message":"TEST","milliseconds":' + t.milliseconds + '}$');
+        t.assertRegexMatches(regex, formatted);
+	});
+
+	s.test("JsonLayout seconds/milliseconds test 3", function(t) {
+		setUpJsonLayoutMillisecondsTest(t);
+
+        // Change the layout setting
+        t.layout.setTimeStampsInMilliseconds(false);
+        var formatted = t.layout.format(t.loggingEvent);
+        var regex = new RegExp('^{"logger":"test","timestamp":' + t.timeInSeconds + ',"level":"DEBUG","url":".*","message":"TEST","milliseconds":' + t.milliseconds + '}$');
+        t.assertRegexMatches(regex, formatted);
+	});
+	s.test("HttpPostDataLayout format test", function(t) {
+		var layout = new log4javascript.HttpPostDataLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("HttpPostDataLayout test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST$/, t.appender.logMessages[0]);
+    });
+
+    s.test("HttpPostDataLayout URL encoding test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST +\"1\"");
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST%20%2B%221%22$/, t.appender.logMessages[0]);
+    });
+
+    s.test("HttpPostDataLayout with exception test", function(t) {
+        t.appender.setLayout(new log4javascript.HttpPostDataLayout());
+        t.logger.debug("TEST", new Error("Test error"));
+        t.assertRegexMatches(/^logger=test&timestamp=\d+&level=DEBUG&url=.*&message=TEST&exception=.*$/, t.appender.logMessages[0]);
+    });
+
+	(function() {
+		var formatObjectExpansion = log4javascript.evalInScope("formatObjectExpansion");
+		var newLine = log4javascript.evalInScope("newLine");
+		var arr = [
+			null,
+			undefined,
+			1.2,
+			"A string",
+			[1, "test"],
+			{
+				a: {
+					b: 1
+				}
+			}
+		];
+
+		s.test("Basic formatObjectExpansion array test (depth: 1)", function(t) {
+			t.assertEquals(formatObjectExpansion(arr, 1),
+				"[" + newLine +
+				"  null," + newLine +
+				"  undefined," + newLine +
+				"  1.2," + newLine +
+				"  A string," + newLine +
+				"  1,test," + newLine +
+				"  [object Object]" + newLine +
+				"]"
+			);
+		});
+
+		s.test("Basic formatObjectExpansion array test (depth: 2)", function(t) {
+			t.assertEquals(formatObjectExpansion(arr, 2),
+				"[" + newLine +
+				"  null," + newLine +
+				"  undefined," + newLine +
+				"  1.2," + newLine +
+				"  A string," + newLine +
+				"  [" + newLine +
+				"    1," + newLine +
+				"    test" + newLine +
+				"  ]," + newLine +
+				"  {" + newLine +
+				"    a: [object Object]" + newLine +
+				"  }" + newLine +
+				"]"
+			);
+		});
+
+		s.test("formatObjectExpansion simple object test", function(t) {
+			var obj = {
+				STRING: "A string"
+			};
+			t.assertEquals(formatObjectExpansion(obj, 1), 
+				"{" + newLine +
+				"  STRING: A string" + newLine +
+				"}"
+			);
+		});
+
+		s.test("formatObjectExpansion simple circular object test", function(t) {
+			var obj = {};
+			obj.a = obj;
+			
+			t.assertEquals(formatObjectExpansion(obj, 2), 
+				"{" + newLine +
+				"  a: [object Object] [already expanded]" + newLine +
+				"}"
+			);
+		});
+	})();    /* ---------------------------------------------------------- */
+
+    var getSampleDate = function() {
+        var date = new Date();
+        date.setFullYear(2006);
+        date.setMonth(7);
+        date.setDate(30);
+        date.setHours(15);
+        date.setMinutes(38);
+        date.setSeconds(45);
+        return date;
+    };
+
+    /* ---------------------------------------------------------- */
+
+    s.test("String.replace test", function(t) {
+        t.assertEquals("Hello world".replace(/o/g, "Z"), "HellZ wZrld");
+    });
+
+	s.test("PatternLayout format test", function(t) {
+		var layout = new log4javascript.PatternLayout();
+		testLayoutWithVariables(layout, t);
+	});
+
+    s.test("PatternLayout dates test", function(t) {
+        var layout = new log4javascript.PatternLayout("%d %d{DATE} %d{HH:ss}");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2},\d{3} \d{2}:\d{2}$/, t.appender.logMessages[0]);
+    });
+
+    s.test("PatternLayout modifiers test", function(t) {
+        var layout = new log4javascript.PatternLayout("%m|%3m|%-3m|%6m|%-6m|%.2m|%1.2m|%6.8m|%-1.2m|%-6.8m|");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertEquals(t.appender.logMessages[0], "TEST|TEST|TEST|  TEST|TEST  |ST|ST|  TEST|ST|TEST  |");
+    });
+
+    s.test("PatternLayout conversion characters test", function(t) {
+        var layout = new log4javascript.PatternLayout("%c %n %p %r literal %%");
+        t.appender.setLayout(layout);
+        t.logger.debug("TEST");
+        t.assertRegexMatches(/^test \s+ DEBUG \d+ literal %$/, t.appender.logMessages[0]);
+    });
+
+    s.test("PatternLayout message test", function(t) {
+        var layout = new log4javascript.PatternLayout("%m{1} %m{2}");
+        t.appender.setLayout(layout);
+        var testObj = {
+            strikers: {
+                quick: "Marlon"
+            }
+        };
+        t.logger.debug(testObj);
+        t.assertEquals("{\r\n  strikers: [object Object]\r\n} {\r\n\  strikers: {\r\n    quick: Marlon\r\n  }\r\n}", t.appender.logMessages[0]);
+    });
+	// Tests for exceptions when logging
+	s.test("Logging/grouping test", function(t) {
+		var browserConsoleAppender = new log4javascript.BrowserConsoleAppender();
+		t.logger.addAppender(browserConsoleAppender);
+
+		// Test each level
+		t.logger.trace("TEST TRACE");
+		t.logger.debug("TEST DEBUG");
+		t.logger.info("TEST INFO");
+		t.logger.warn("TEST WARN");
+		t.logger.error("TEST ERROR");
+		t.logger.fatal("TEST FATAL");
+		
+		// Test with exception
+		t.logger.fatal("TEST FATAL", new Error("Fake error"));
+		
+		// Test multiple messages
+		t.logger.info("TEST INFO", "Second message", ["a", "b", "c"]);
+		
+		// Test groups
+		t.logger.group("TEST GROUP");
+		t.logger.info("TEST INFO");
+		t.logger.groupEnd("TEST GROUP");
+		t.logger.info("TEST INFO");
+		
+		t.logger.removeAppender(browserConsoleAppender);
+	});
+
+/*
+	s.test("AjaxAppender JsonLayout single message test", function(t) {
+		t.async(10000);
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		ajaxAppender.setLayout(new log4javascript.JsonLayout());
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 1);
+				t.assertEquals(arr[0], "TEST");
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug("TEST");
+	});
+
+	s.test("AjaxAppender JsonLayout batched messages test", function(t) {
+		t.async(10000);
+		var message1 = "TEST 1";
+		var message2 = "String with \"lots of 'quotes'\" + plusses in";
+		var message3 = "A non-threatening string";
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		ajaxAppender.setLayout(new log4javascript.JsonLayout());
+		ajaxAppender.setBatchSize(3);
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 3);
+				t.assertEquals(arr[0], message1);
+				t.assertEquals(arr[1], message2);
+				t.assertEquals(arr[2], message3);
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug(message1);
+		t.logger.info(message2);
+		t.logger.warn(message3);
+	});
+
+	s.test("AjaxAppender HttpPostDataLayout single message test", function(t) {
+		t.async(10000);
+		// Create and add an Ajax appender
+		var ajaxAppender = new log4javascript.AjaxAppender("../log4javascript.do");
+		var testMessage = "TEST +\"1\"";
+		ajaxAppender.setLayout(new log4javascript.HttpPostDataLayout());
+		ajaxAppender.setRequestSuccessCallback(
+			function(xmlHttp) {
+				// Response comes back as JSON array of messages logged
+				var jsonResponse = xmlHttp.responseText;
+				var arr = eval(jsonResponse);
+				t.assertEquals(arr.length, 1);
+				t.assertEquals(arr[0], testMessage);
+				t.succeed();
+			}
+		);
+		ajaxAppender.setFailCallback(
+			function(msg) {
+				t.fail(msg);
+				ajaxErrorMessage = msg;
+			}
+		);
+		t.logger.addAppender(ajaxAppender);
+		t.logger.debug(testMessage);
+	});
+*/
+	var testConsoleAppender = function(t, appender) {
+		var timeoutCallback = function() {
+			//alert("Failed. Debug messages follow.");
+			//log4javascript.logLog.displayDebug();
+			return (windowLoaded ? "Timed out while waiting for messages to appear" :
+				   "Timed out while waiting for window to load") + ". Debug messages: " +
+				   log4javascript.logLog.debugMessages.join("\r\n");
+		}
+
+		t.async(60000, timeoutCallback);
+
+		var windowLoaded = false;
+		var domChecked = false;
+
+		// Set a timeout to allow the pop-up to appear
+		var onLoadHandler = function() {
+			log4javascript.logLog.debug("onLoadHandler");
+			windowLoaded = true;
+			var win = appender.getConsoleWindow();
+
+			if (win && win.loaded) {
+				// Check that the log container element contains the log message. Since
+				// the console window waits 100 milliseconds before actually rendering the
+				// message as a DOM element, we need to use a timer
+				var checkDom = function() {
+					log4javascript.logLog.debug("checkDom");
+					domChecked = true;
+					var logContainer = win.logMainContainer;
+					if (logContainer.hasChildNodes()) {
+						if (logContainer.innerHTML.indexOf("TEST MESSAGE") == -1) {
+							appender.close();
+							t.fail("Log message not correctly logged (log container innerHTML: " + logContainer.innerHTML + ")");
+						} else {
+							t.assert(appender.isVisible());
+							appender.close();
+							t.assert(!appender.isVisible());
+							t.succeed();
+						}
+					} else {
+						appender.close();
+						t.fail("Console has no log messages");
+					}
+				}
+				window.setTimeout(checkDom, 300);
+			} else {
+				appender.close();
+				t.fail("Console mistakenly raised load event");
+			}
+		}
+
+		appender.addEventListener("load", onLoadHandler);
+		t.logger.addAppender(appender);
+		t.logger.debug("TEST MESSAGE");
+	};
+
+	s.test("InlineAppender test", function(t) {
+		var inlineAppender = new log4javascript.InlineAppender();
+		inlineAppender.setInitiallyMinimized(false);
+		inlineAppender.setNewestMessageAtTop(false);
+		inlineAppender.setScrollToLatestMessage(true);
+		inlineAppender.setWidth(600);
+		inlineAppender.setHeight(200);
+
+		testConsoleAppender(t, inlineAppender);
+	});
+
+	s.test("InPageAppender with separate console HTML file test", function(t) {
+		var inPageAppender = new log4javascript.InPageAppender();
+		inPageAppender.setInitiallyMinimized(false);
+		inPageAppender.setNewestMessageAtTop(false);
+		inPageAppender.setScrollToLatestMessage(true);
+		inPageAppender.setUseDocumentWrite(false);
+		inPageAppender.setWidth(600);
+		inPageAppender.setHeight(200);
+
+		testConsoleAppender(t, inPageAppender);
+	});
+
+	s.test("PopUpAppender test", function(t) {
+		var popUpAppender = new log4javascript.PopUpAppender();
+		popUpAppender.setFocusPopUp(true);
+		popUpAppender.setUseOldPopUp(false);
+		popUpAppender.setNewestMessageAtTop(false);
+		popUpAppender.setScrollToLatestMessage(true);
+		popUpAppender.setComplainAboutPopUpBlocking(false);
+		popUpAppender.setWidth(600);
+		popUpAppender.setHeight(200);
+
+		testConsoleAppender(t, popUpAppender);
+		
+		
+	});
+
+	s.test("PopUpAppender with separate console HTML file test", function(t) {
+		var popUpAppender = new log4javascript.PopUpAppender();
+		popUpAppender.setFocusPopUp(true);
+		popUpAppender.setUseOldPopUp(false);
+		popUpAppender.setNewestMessageAtTop(false);
+		popUpAppender.setScrollToLatestMessage(true);
+		popUpAppender.setComplainAboutPopUpBlocking(false);
+		popUpAppender.setUseDocumentWrite(false);
+		popUpAppender.setWidth(600);
+		popUpAppender.setHeight(200);
+
+		testConsoleAppender(t, popUpAppender);
+	});
+});
\ No newline at end of file
