added jsdoc some files to project, added 'doc' task to build, started to annotate code with docs

bin/jsdoc/frame.js

@@ -0,0 +1,33 @@
+IO.include("frame/Opt.js");
+IO.include("frame/Chain.js");
+IO.include("frame/Link.js");
+IO.include("frame/String.js");
+IO.include("frame/Hash.js");
+IO.include("frame/Namespace.js");
+//IO.include("frame/Reflection.js");
+
+/** A few helper functions to make life a little easier. */
+
+function defined(o) {
+	return (o !== undefined);
+}
+
+function copy(o) { // todo check for circular refs
+	if (o == null || typeof(o) != 'object') return o;
+	var c = new o.constructor();
+	for(var p in o)	c[p] = copy(o[p]);
+	return c;
+}
+
+function isUnique(arr) {
+	var l = arr.length;
+	for(var i = 0; i < l; i++ ) {
+		if (arr.lastIndexOf(arr[i]) > i) return false;
+	}
+	return true;
+}
+
+/** Returns the given string with all regex meta characters backslashed. */
+RegExp.escapeMeta = function(str) {
+	return str.replace(/([$^\\\/()|?+*\[\]{}.-])/g, "\\$1");
+}

bin/jsdoc/frame/Chain.js

@@ -0,0 +1,102 @@
+/**@constructor*/
+function ChainNode(object, link) {
+	this.value = object;
+	this.link = link; // describes this node's relationship to the previous node
+}
+
+/**@constructor*/
+function Chain(valueLinks) {
+	this.nodes = [];
+	this.cursor = -1;
+	
+	if (valueLinks && valueLinks.length > 0) {
+		this.push(valueLinks[0], "//");
+		for (var i = 1, l = valueLinks.length; i < l; i+=2) {
+			this.push(valueLinks[i+1], valueLinks[i]);
+		}
+	}
+}
+
+Chain.prototype.push = function(o, link) {
+	if (this.nodes.length > 0 && link) this.nodes.push(new ChainNode(o, link));
+	else this.nodes.push(new ChainNode(o));
+}
+
+Chain.prototype.unshift = function(o, link) {
+	if (this.nodes.length > 0 && link) this.nodes[0].link = link;
+	this.nodes.unshift(new ChainNode(o));
+	this.cursor++;
+}
+
+Chain.prototype.get = function() {
+	if (this.cursor < 0 || this.cursor > this.nodes.length-1) return null;
+	return this.nodes[this.cursor];
+}
+
+Chain.prototype.first = function() {
+	this.cursor = 0;
+	return this.get();
+}
+
+Chain.prototype.last = function() {
+	this.cursor = this.nodes.length-1;
+	return this.get();
+}
+
+Chain.prototype.next = function() {
+	this.cursor++;
+	return this.get();
+}
+
+Chain.prototype.prev = function() {
+	this.cursor--;
+	return this.get();
+}
+
+Chain.prototype.toString = function() {
+	var string = "";
+	for (var i = 0, l = this.nodes.length; i < l; i++) {
+		if (this.nodes[i].link) string += " -("+this.nodes[i].link+")-> ";
+		string += this.nodes[i].value.toString();
+	}
+	return string;
+}
+
+Chain.prototype.joinLeft = function() {
+	var result = "";
+	for (var i = 0, l = this.cursor; i < l; i++) {
+		if (result && this.nodes[i].link) result += this.nodes[i].link;
+		result += this.nodes[i].value.toString();
+	}
+	return result;
+}
+
+
+/* USAGE:
+
+var path = "one/two/three.four/five-six";
+var pathChain = new Chain(path.split(/([\/.-])/));
+print(pathChain);
+
+var lineage = new Chain();
+lineage.push("Port");
+lineage.push("Les", "son");
+lineage.push("Dawn", "daughter");
+lineage.unshift("Purdie", "son");
+
+print(lineage);
+
+// walk left
+for (var node = lineage.last(); node !== null; node = lineage.prev()) {
+	print("< "+node.value);
+}
+
+// walk right
+var node = lineage.first()
+while (node !== null) {
+	print(node.value);
+	node = lineage.next();
+	if (node && node.link) print("had a "+node.link+" named");
+}
+
+*/

bin/jsdoc/frame/Dumper.js

@@ -0,0 +1,144 @@
+/**
+ * @class
+<pre>
+This is a lightly modified version of Kevin Jones' JavaScript
+library Data.Dump. To download the original visit:
+    <a href="http://openjsan.org/doc/k/ke/kevinj/Data/Dump/">http://openjsan.org/doc/k/ke/kevinj/Data/Dump/</a>
+
+AUTHORS
+
+The Data.Dump JavaScript module is written by Kevin Jones 
+(kevinj@cpan.org), based on Data::Dump by Gisle Aas (gisle@aas.no),
+based on Data::Dumper by Gurusamy Sarathy (gsar@umich.edu).
+
+COPYRIGHT
+
+Copyright 2007 Kevin Jones. Copyright 1998-2000,2003-2004 Gisle Aas.
+Copyright 1996-1998 Gurusamy Sarathy.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the Perl Artistic License
+
+See http://www.perl.com/perl/misc/Artistic.html
+</pre>
+ * @static
+ */
+Dumper = {
+	/** @param [...] The objects to dump. */
+	dump: function () {
+	    if (arguments.length > 1)
+	        return this._dump(arguments);
+	    else if (arguments.length == 1)
+	        return this._dump(arguments[0]);
+	    else
+	        return "()";
+	},
+	
+	_dump: function (obj) {
+		if (typeof obj == 'undefined') return 'undefined';
+		var out;
+		if (obj.serialize) { return obj.serialize(); }
+		var type = this._typeof(obj);
+		if (obj.circularReference) obj.circularReference++;
+		switch (type) {
+			case 'circular':
+				out = "{ //circularReference\n}";
+				break;
+			case 'object':
+				var pairs = new Array;
+				
+				for (var prop in obj) {
+					if (prop != "circularReference" && obj.hasOwnProperty(prop)) { //hide inherited properties
+						pairs.push(prop + ': ' + this._dump(obj[prop]));
+					}
+				}
+	
+				out = '{' + this._format_list(pairs) + '}';
+				break;
+	
+			case 'string':
+				for (var prop in Dumper.ESC) {
+					if (Dumper.ESC.hasOwnProperty(prop)) {
+						obj = obj.replace(prop, Dumper.ESC[prop]);
+					}
+				}
+	
+			// Escape UTF-8 Strings
+				if (obj.match(/^[\x00-\x7f]*$/)) {
+					out = '"' + obj.replace(/\"/g, "\\\"").replace(/([\n\r]+)/g, "\\$1") + '"';
+				}
+				else {
+					out = "unescape('"+escape(obj)+"')";
+				}
+				break;
+	
+			case 'array':
+				var elems = new Array;
+	
+				for (var i=0; i<obj.length; i++) {
+					elems.push( this._dump(obj[i]) );
+				}
+	
+				out = '[' + this._format_list(elems) + ']';
+				break;
+	
+			case 'date':
+			// firefox returns GMT strings from toUTCString()...
+			var utc_string = obj.toUTCString().replace(/GMT/,'UTC');
+				out = 'new Date("' + utc_string + '")';
+				break;
+	
+			case 'element':
+				// DOM element
+				out = this._dump_dom(obj);
+				break;
+		
+				default:
+					out = obj;
+		}
+	
+		out = String(out).replace(/\n/g, '\n    ');
+		out = out.replace(/\n    (.*)$/,"\n$1");
+	
+		return out;
+	},
+	
+	_format_list: function (list) {
+		if (!list.length) return '';
+		var nl = list.toString().length > 60 ? '\n' : ' ';
+		return nl + list.join(',' + nl) + nl;
+    },
+    
+    _typeof: function (obj) {
+    	if (obj && obj.circularReference && obj.circularReference > 1) return 'circular';
+		if (Array.prototype.isPrototypeOf(obj)) return 'array';
+		if (Date.prototype.isPrototypeOf(obj)) return 'date';
+		if (typeof obj.nodeType != 'undefined') return 'element';
+		return typeof(obj);
+	},
+	
+	_dump_dom: function (obj) {
+		return '"' + Dumper.nodeTypes[obj.nodeType] + '"';
+	}
+};
+
+Dumper.ESC = {
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f"
+};
+
+Dumper.nodeTypes = {
+    1: "ELEMENT_NODE",
+    2: "ATTRIBUTE_NODE",
+    3: "TEXT_NODE",
+    4: "CDATA_SECTION_NODE",
+    5: "ENTITY_REFERENCE_NODE",
+    6: "ENTITY_NODE",
+    7: "PROCESSING_INSTRUCTION_NODE",
+    8: "COMMENT_NODE",
+    9: "DOCUMENT_NODE",
+    10: "DOCUMENT_TYPE_NODE",
+    11: "DOCUMENT_FRAGMENT_NODE",
+    12: "NOTATION_NODE"
+};

bin/jsdoc/frame/Hash.js

@@ -0,0 +1,84 @@
+/**
+	@constructor
+	@example
+	var _index = new Hash();
+	_index.set("a", "apple");
+	_index.set("b", "blue");
+	_index.set("c", "coffee");
+
+	for (var p = _index.first(); p; p = _index.next()) {
+		print(p.key+" is for "+p.value);
+	}
+	
+ */
+var Hash = function() {
+	this._map = {};
+	this._keys = [];
+	this._vals = [];
+	this.reset();
+}
+
+Hash.prototype.set = function(k, v) {
+	if (k != "") {
+		this._keys.push(k);
+		this._map["="+k] = this._vals.length;
+		this._vals.push(v);
+	}
+}
+
+Hash.prototype.replace = function(k, k2, v) {
+	if (k == k2) return;
+
+	var offset = this._map["="+k];
+	this._keys[offset] = k2;
+	if (typeof v != "undefined") this._vals[offset] = v;
+	this._map["="+k2] = offset;
+	delete(this._map["="+k]);
+}
+
+Hash.prototype.drop = function(k) {
+	if (k != "") {
+		var offset = this._map["="+k];
+		this._keys.splice(offset, 1);
+		this._vals.splice(offset, 1);
+		delete(this._map["="+k]);
+		for (var p in this._map) {
+			if (this._map[p] >= offset) this._map[p]--;
+		}
+		if (this._cursor >= offset && this._cursor > 0) this._cursor--;
+	}
+}
+
+Hash.prototype.get = function(k) {
+	if (k != "") {
+		return this._vals[this._map["="+k]];
+	}
+}
+
+Hash.prototype.keys = function() {
+	return this._keys;
+}
+
+Hash.prototype.hasKey = function(k) {
+	if (k != "") {
+		return (typeof this._map["="+k] != "undefined");
+	}
+}
+
+Hash.prototype.values = function() {
+	return this._vals;
+}
+
+Hash.prototype.reset = function() {
+	this._cursor = 0;
+}
+
+Hash.prototype.first = function() {
+	this.reset();
+	return this.next();
+}
+
+Hash.prototype.next = function() {
+	if (this._cursor++ < this._keys.length)
+		return {key: this._keys[this._cursor-1], value: this._vals[this._cursor-1]};
+}

bin/jsdoc/frame/Link.js

@@ -0,0 +1,173 @@
+/** Handle the creation of HTML links to documented symbols.
+	@constructor
+*/
+function Link() {
+	this.alias = "";
+	this.src = "";
+	this.file = "";
+	this.text = "";
+	this.innerName = "";
+	this.classLink = false;
+	this.targetName = "";
+	
+	this.target = function(targetName) {
+		if (defined(targetName)) this.targetName = targetName;
+		return this;
+	}
+	this.inner = function(inner) {
+		if (defined(inner)) this.innerName = inner;
+		return this;
+	}
+	this.withText = function(text) {
+		if (defined(text)) this.text = text;
+		return this;
+	}
+	this.toSrc = function(filename) {
+		if (defined(filename)) this.src = filename;
+		return this;
+	}
+	this.toSymbol = function(alias) {
+		if (defined(alias)) this.alias = new String(alias);
+		return this;
+	}
+	this.toClass = function(alias) {
+		this.classLink = true;
+		return this.toSymbol(alias);
+	}
+	this.toFile = function(file) {
+		if (defined(file)) this.file = file;
+		return this;
+	}
+	
+	this.toString = function() {
+		var linkString;
+		var thisLink = this;
+
+		if (this.alias) {
+			linkString = this.alias.replace(/(^|[^a-z$0-9_#.:^-])([|a-z$0-9_#.:^-]+)($|[^a-z$0-9_#.:^-])/i,
+				function(match, prematch, symbolName, postmatch) {
+					var symbolNames = symbolName.split("|");
+					var links = [];
+					for (var i = 0, l = symbolNames.length; i < l; i++) {
+						thisLink.alias = symbolNames[i];
+						links.push(thisLink._makeSymbolLink(symbolNames[i]));
+					}
+					return prematch+links.join("|")+postmatch;
+				}
+			);
+		}
+		else if (this.src) {
+			linkString = thisLink._makeSrcLink(this.src);
+		}
+		else if (this.file) {
+			linkString = thisLink._makeFileLink(this.file);
+		}
+
+		return linkString;
+	}
+}
+
+/** prefixed for hashes */
+Link.hashPrefix = "";
+
+/** Appended to the front of relative link paths. */
+Link.base = "";
+
+Link.symbolNameToLinkName = function(symbol) {
+	var linker = "",
+		ns = "";
+	
+	if (symbol.isStatic) linker = ".";
+	else if (symbol.isInner) linker = "-";
+	
+	if (symbol.isEvent && !/^event:/.test(symbol.name)) {
+		ns = "event:";
+	}
+	return Link.hashPrefix+linker+ns+symbol.name;
+}
+
+Link.getSymbol= function(alias) {
+    var symbol= Link.symbolSet.getSymbol(alias);
+    
+    if (symbol)
+        return symbol;
+        
+    if ('#'!==alias.charAt(0) || !Link.currentSymbol)
+        return null;
+    
+    //  resolve relative name
+    var container= Link.currentSymbol;
+    
+    while (container)
+    {
+        symbol= Link.symbolSet.getSymbol(container.alias + alias);
+        if (symbol)
+            return symbol;
+        
+        //  No superclass
+        if (!container.augments.length)
+            return null;
+        
+        container= Link.symbolSet.getSymbol(container.augments[0].desc);
+    }
+    
+    return null;
+}
+
+/** Create a link to another symbol. */
+Link.prototype._makeSymbolLink = function(alias) {
+	var linkBase = Link.base+publish.conf.symbolsDir;
+	var linkTo = Link.getSymbol(alias);
+	var linkPath;
+	var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+
+	// if there is no symbol by that name just return the name unaltered
+	if (!linkTo)
+	    return this.text || alias;
+	
+	// it's a symbol in another file
+	else {
+		if (!linkTo.is("CONSTRUCTOR") && !linkTo.isNamespace) { // it's a method or property
+			linkPath= (Link.filemap) ? Link.filemap[linkTo.memberOf] :
+				      escape(linkTo.memberOf) || "_global_";
+				linkPath += publish.conf.ext + "#" + Link.symbolNameToLinkName(linkTo);
+		}
+		else {
+			linkPath = (Link.filemap)? Link.filemap[linkTo.alias] : escape(linkTo.alias);
+			linkPath += publish.conf.ext;// + (this.classLink? "":"#" + Link.hashPrefix + "constructor");
+		}
+		linkPath = linkBase + linkPath
+	}
+        
+	var linkText= this.text || alias;
+    
+	var link = {linkPath: linkPath, linkText: linkText, linkInner: (this.innerName? "#"+this.innerName : "")};
+	
+	if (typeof JSDOC.PluginManager != "undefined") {
+		JSDOC.PluginManager.run("onSymbolLink", link);
+	}
+	
+	return "<a href=\""+link.linkPath+link.linkInner+"\""+target+">"+link.linkText+"</a>";
+}
+
+/** Create a link to a source file. */
+Link.prototype._makeSrcLink = function(srcFilePath) {
+	var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+		
+	// transform filepath into a filename
+	var srcFile = srcFilePath.replace(/\.\.?[\\\/]/g, "").replace(/[:\\\/]/g, "_");
+	var outFilePath = Link.base + publish.conf.srcDir + srcFile + publish.conf.ext;
+
+	if (!this.text) this.text = FilePath.fileName(srcFilePath);
+	return "<a href=\""+outFilePath+"\""+target+">"+this.text+"</a>";
+}
+
+/** Create a link to a source file. */
+Link.prototype._makeFileLink = function(filePath) {
+	var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+		
+	var outFilePath =  Link.base + filePath;
+
+	if (!this.text) this.text = filePath;
+	return "<a href=\""+outFilePath+"\""+target+">"+this.text+"</a>";
+}

bin/jsdoc/frame/Namespace.js

@@ -0,0 +1,10 @@
+_global_ = this;
+
+function Namespace(name, f) {
+	var n = name.split(".");
+	for (var o = _global_, i = 0, l = n.length; i < l; i++) {
+		o = o[n[i]] = o[n[i]] || {};
+	}
+	
+	if (f) f();
+}

bin/jsdoc/frame/Opt.js

@@ -0,0 +1,134 @@
+/** @namespace */
+Opt = {
+	/**
+	 * Get commandline option values.
+	 * @param {Array} args Commandline arguments. Like ["-a=xml", "-b", "--class=new", "--debug"]
+	 * @param {object} optNames Map short names to long names. Like {a:"accept", b:"backtrace", c:"class", d:"debug"}.
+	 * @return {object} Short names and values. Like {a:"xml", b:true, c:"new", d:true}
+	 */
+	get: function(args, optNames) {
+		var opt = {"_": []}; // the unnamed option allows multiple values
+		for (var i = 0; i < args.length; i++) {
+			var arg = new String(args[i]);
+			var name;
+			var value;
+			if (arg.charAt(0) == "-") {
+				if (arg.charAt(1) == "-") { // it's a longname like --foo
+					arg = arg.substring(2);
+					var m = arg.split("=");
+					name = m.shift();
+					value = m.shift();
+					if (typeof value == "undefined") value = true;
+					
+					for (var n in optNames) { // convert it to a shortname
+						if (name == optNames[n]) {
+							name = n;
+						}
+					}
+				}
+				else { // it's a shortname like -f
+					arg = arg.substring(1);
+					var m = arg.split("=");
+					name = m.shift();
+					value = m.shift();
+					if (typeof value == "undefined") value = true;
+					
+					for (var n in optNames) { // find the matching key
+						if (name == n || name+'[]' == n) {
+							name = n;
+							break;
+						}
+					}
+				}
+				if (name.match(/(.+)\[\]$/)) { // it's an array type like n[]
+					name = RegExp.$1;
+					if (!opt[name]) opt[name] = [];
+				}
+				
+				if (opt[name] && opt[name].push) {
+					opt[name].push(value);
+				}
+				else {
+					opt[name] = value;
+				}
+			}
+			else { // not associated with any optname
+				opt._.push(args[i]);
+			}
+		}
+		return opt;
+	}
+}
+
+/*t:
+	plan(11, "Testing Opt.");
+	
+	is(
+		typeof Opt,
+		"object",
+		"Opt is an object."
+	);
+	
+	is(
+		typeof Opt.get,
+		"function",
+		"Opt.get is a function."
+	);
+	
+	var optNames = {a:"accept", b:"backtrace", c:"class", d:"debug", "e[]":"exceptions"};
+	var t_options = Opt.get(["-a=xml", "-b", "--class=new", "--debug", "-e=one", "-e=two", "foo", "bar"], optNames);
+	
+	is(
+		t_options.a,
+		"xml",
+		"an option defined with a short name can be accessed by its short name."
+	);
+	
+	is(
+		t_options.b,
+		true,
+		"an option defined with a short name and no value are true."
+	);
+	
+	is(
+		t_options.c,
+		"new",
+		"an option defined with a long name can be accessed by its short name."
+	);
+	
+	is(
+		t_options.d,
+		true,
+		"an option defined with a long name and no value are true."
+	);
+	
+	is(
+		typeof t_options.e,
+		"object",
+		"an option that can accept multiple values is defined."
+	);
+	
+	is(
+		t_options.e.length,
+		2,
+		"an option that can accept multiple values can have more than one value."
+	);
+	
+	is(
+		t_options.e[1],
+		"two",
+		"an option that can accept multiple values can be accessed as an array."
+	);
+	
+	is(
+		typeof t_options._,
+		"object",
+		"the property '_' is defined for unnamed options."
+	);
+	
+	is(
+		t_options._[0],
+		"foo",
+		"the property '_' can be accessed as an array."
+	);
+ */

bin/jsdoc/frame/Reflection.js

@@ -0,0 +1,26 @@
+/**@constructor*/
+function Reflection(obj) {
+	this.obj = obj;
+}
+
+Reflection.prototype.getConstructorName = function() {
+	if (this.obj.constructor.name) return this.obj.constructor.name;
+	var src = this.obj.constructor.toSource();
+	var name = src.substring(name.indexOf("function")+8, src.indexOf('(')).replace(/ /g,'');
+	return name;
+}
+
+Reflection.prototype.getMethod = function(name) {
+	for (var p in this.obj) {
+		if (p == name && typeof(this.obj[p]) == "function") return this.obj[p];
+	}
+	return null;
+}
+
+Reflection.prototype.getParameterNames = function() {
+	var src = this.obj.toSource();
+	src = src.substring(
+		src.indexOf("(", 8)+1, src.indexOf(")")
+	);
+	return src.split(/, ?/);
+}

bin/jsdoc/frame/String.js

@@ -0,0 +1,93 @@
+/**
+	@name String
+	@class Additions to the core string object.
+*/
+
+/** @author Steven Levithan, released as public domain. */
+String.prototype.trim = function() {
+	var str = this.replace(/^\s+/, '');
+	for (var i = str.length - 1; i >= 0; i--) {
+		if (/\S/.test(str.charAt(i))) {
+			str = str.substring(0, i + 1);
+			break;
+		}
+	}
+	return str;
+}
+/*t:
+	plan(6, "Testing String.prototype.trim.");
+	
+	var s = "   a bc   ".trim();
+	is(s, "a bc", "multiple spaces front and back are trimmed.");
+
+	s = "a bc\n\n".trim();
+	is(s, "a bc", "newlines only in back are trimmed.");
+	
+	s = "\ta bc".trim();
+	is(s, "a bc", "tabs only in front are trimmed.");
+	
+	s = "\n \t".trim();
+	is(s, "", "an all-space string is trimmed to empty.");
+	
+	s = "a b\nc".trim();
+	is(s, "a b\nc", "a string with no spaces in front or back is trimmed to itself.");
+	
+	s = "".trim();
+	is(s, "", "an empty string is trimmed to empty.");
+
+*/
+
+String.prototype.balance = function(open, close) {
+	var i = 0;
+	while (this.charAt(i) != open) {
+		if (i == this.length) return [-1, -1];
+		i++;
+	}
+	
+	var j = i+1;
+	var balance = 1;
+	while (j < this.length) {
+		if (this.charAt(j) == open) balance++;
+		if (this.charAt(j) == close) balance--;
+		if (balance == 0) break;
+		j++;
+		if (j == this.length) return [-1, -1];
+	}
+	
+	return [i, j];
+}
+/*t:
+	plan(16, "Testing String.prototype.balance.");
+	
+	var s = "{abc}".balance("{","}");
+	is(s[0], 0, "opener in first is found.");
+	is(s[1], 4, "closer in last is found.");
+	
+	s = "ab{c}de".balance("{","}");
+	is(s[0], 2, "opener in middle is found.");
+	is(s[1], 4, "closer in middle is found.");
+	
+	s = "a{b{c}de}f".balance("{","}");
+	is(s[0], 1, "nested opener is found.");
+	is(s[1], 8, "nested closer is found.");
+	
+	s = "{}".balance("{","}");
+	is(s[0], 0, "opener with no content is found.");
+	is(s[1], 1, "closer with no content is found.");
+	
+	s = "".balance("{","}");
+	is(s[0], -1, "empty string opener is -1.");
+	is(s[1], -1, "empty string closer is -1.");
+	
+	s = "{abc".balance("{","}");
+	is(s[0], -1, "opener with no closer returns -1.");
+	is(s[1], -1, "no closer returns -1.");
+	
+	s = "abc".balance("{","}");
+	is(s[0], -1, "no opener or closer returns -1 for opener.");
+	is(s[1], -1, "no opener or closer returns -1 for closer.");
+	
+	s = "a<bc}de".balance("<","}");
+	is(s[0], 1, "unmatching opener is found.");
+	is(s[1], 4, "unmatching closer is found.");
+*/

bin/jsdoc/frame/Testrun.js

@@ -0,0 +1,129 @@
+/**
+ * @fileOverview
+ * @name JsTestrun
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-2.4.0/jsdoc-toolkit/app/frame/Testrun.js $
+ * @revision $Id: Testrun.js 418 2008-01-15 21:40:33Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+ */
+ 
+/**
+	Yet another unit testing tool for JavaScript.
+	@author Michael Mathews <a href="mailto:micmath@gmail.com">micmath@gmail.com</a>
+	@param {object} testCases Properties are testcase names, values are functions to execute as tests.
+*/
+function testrun(testCases) {
+	var ran = 0;
+	for (t in testCases) {
+		var result = testCases[t]();
+		ran++;
+	}
+	
+	return testrun.reportOut+"-------------------------------\n"+((testrun.fails>0)? ":( Failed "+testrun.fails+"/" : ":) Passed all ")+testrun.count+" test"+((testrun.count == 1)? "":"s")+".\n";
+}
+
+
+testrun.count = 0;
+testrun.current = null;
+testrun.passes = 0;
+testrun.fails = 0;
+testrun.reportOut = "";
+
+/** @private */
+testrun.report = function(text) {
+	testrun.reportOut += text+"\n";
+}
+
+/**
+	Check if test evaluates to true.
+	@param {string} test To be evaluated.
+	@param {string} message Optional. To be displayed in the report.
+	@return {boolean} True if the string test evaluates to true.
+*/
+ok = function(test, message) {
+	testrun.count++;
+	
+	var result;
+	try {
+		result = eval(test);
+		
+		if (result) {
+			testrun.passes++;
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++;
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+
+	}
+}
+
+/**
+	Check if test is same as expected.
+	@param {string} test To be evaluated.
+	@param {string} expected
+	@param {string} message Optional. To be displayed in the report. 
+	@return {boolean} True if (test == expected). Note that the comparison is not a strict equality check.
+*/
+is = function(test, expected, message) {
+	testrun.count++;
+	
+	var result;
+	try {
+		result = eval(test);
+		
+		if (result == expected) {
+			testrun.passes++
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+			testrun.report("expected: "+expected);
+			testrun.report("     got: "+result);
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+		testrun.report("expected: "+expected);
+		testrun.report("     got: "+result);}
+}
+
+/**
+	Check if test matches pattern.
+	@param {string} test To be evaluated.
+	@param {string} pattern Used to create a RegExp.
+	@param {string} message Optional. To be displayed in the report.
+	@return {boolean} True if test matches pattern.
+*/
+like = function(test, pattern, message) {
+	testrun.count++;
+
+	var result;
+	try {
+		result = eval(test);
+		var rgx = new RegExp(pattern);
+		
+		if (rgx.test(result)) {
+			testrun.passes++
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+			testrun.report("       this: "+result);
+			testrun.report("is not like: "+pattern);
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+	}
+}

bin/jsdoc/handlers/FOODOC.js

@@ -0,0 +1,26 @@
+/**
+   This is the main container for the FOODOC handler.
+   @namespace
+*/
+FOODOC = {
+};
+
+/** The current version string of this application. */
+FOODOC.VERSION = "1.0";
+
+FOODOC.handle = function(srcFile, src) {
+	LOG.inform("Handling file '" + srcFile + "'");
+	
+	return [
+		new JSDOC.Symbol(
+			"foo",
+			[],
+			"VIRTUAL",
+			new JSDOC.DocComment("/** This is a foo. */")
+		)
+	];
+};
+
+FOODOC.publish = function(symbolgroup) {
+	LOG.inform("Publishing symbolgroup.");
+};

bin/jsdoc/handlers/XMLDOC.js

@@ -0,0 +1,26 @@
+/**
+ * This is the main container for the XMLDOC handler.
+ * @namespace
+ * @author Brett Fattori (bfattori@fry.com)
+ * @version $Revision: 498 $
+ */
+XMLDOC = {
+	
+};
+
+/** The current version string of this application. */
+XMLDOC.VERSION = "1.0";
+
+/** Include the library necessary to handle XML files */
+IO.includeDir("handlers/XMLDOC/");
+
+/**
+ * @type Symbol[]
+ */
+XMLDOC.handle = function(srcFile, src) {
+	
+};
+
+XMLDOC.publish = function(symbolgroup) {
+	
+}

bin/jsdoc/handlers/XMLDOC/DomReader.js

@@ -0,0 +1,159 @@
+LOG.inform("XMLDOC.DomReader loaded");
+
+XMLDOC.DomReader = function(root) {
+
+   this.dom = root;
+
+   /**
+    * The current node the reader is on
+    */
+   this.node = root;
+
+   /**
+    * Get the current node the reader is on
+    * @type XMLDOC.Parser.node
+    */
+   XMLDOC.DomReader.prototype.getNode = function() {
+      return this.node;
+   };
+
+   /**
+    * Set the node the reader should be positioned on.
+    * @param node {XMLDOC.Parser.node}
+    */
+   XMLDOC.DomReader.prototype.setNode = function(node) {
+      this.node = node;
+   };
+
+   /**
+    * A helper method to make sure the current node will
+    * never return null, unless null is passed as the root.
+    * @param step {String} An expression to evaluate - should return a node or null
+    */
+   XMLDOC.DomReader.prototype.navigate = function(step) {
+      var n;
+      if ((n = step) != null)
+      {
+         this.node = n;
+         return this.node;
+      }
+      return null;
+   };
+
+   /**
+    * Get the root node of the current node's document.
+    */
+   XMLDOC.DomReader.prototype.root = function() {
+      this.navigate(this.dom);
+   };
+
+   /**
+    * Get the parent of the current node.
+    */
+   XMLDOC.DomReader.prototype.parent = function() {
+      return this.navigate(this.node.parentNode());
+   };
+
+   /**
+    * Get the first child of the current node.
+    */
+   XMLDOC.DomReader.prototype.firstChild = function() {
+      return this.navigate(this.node.firstChild());
+   };
+
+   /**
+    * Get the last child of the current node.
+    */
+   XMLDOC.DomReader.prototype.lastChild = function() {
+      return this.navigate(this.node.lastChild());
+   };
+
+   /**
+    * Get the next sibling of the current node.
+    */
+   XMLDOC.DomReader.prototype.nextSibling = function() {
+      return this.navigate(this.node.nextSibling());
+   };
+
+   /**
+    * Get the previous sibling of the current node.
+    */
+   XMLDOC.DomReader.prototype.prevSibling = function() {
+      return this.navigate(this.node.prevSibling());
+   };
+
+   //===============================================================================================
+   // Support methods
+
+   /**
+    * Walk the tree starting with the current node, calling the plug-in for
+    * each node visited.  Each time the plug-in is called, the DomReader
+    * is passed as the only parameter.  Use the {@link XMLDOC.DomReader#getNode} method
+    * to access the current node.   <i>This method uses a depth first traversal pattern.</i>
+    *
+    * @param srcFile {String} The source file being evaluated
+    */
+   XMLDOC.DomReader.prototype.getSymbols = function(srcFile)
+   {
+      XMLDOC.DomReader.symbols = [];
+      XMLDOC.DomReader.currentFile = srcFile;
+      JSDOC.Symbol.srcFile = (srcFile || "");
+
+      if (defined(JSDOC.PluginManager)) {
+         JSDOC.PluginManager.run("onDomGetSymbols", this);
+      }
+
+      return XMLDOC.DomReader.symbols;
+   };
+
+   /**
+    * Find the node with the given name using a depth first traversal.
+    * Does not modify the DomReader's current node.
+    *
+    * @param name {String} The name of the node to find
+    * @return the node that was found, or null if not found
+    */
+   XMLDOC.DomReader.prototype.findNode = function(name)
+   {
+      var findNode = null;
+
+      // Start at the current node and move into the subtree,
+      // looking for the node with the given name
+      function deeper(node, find)
+      {
+         var look = null;
+
+         if (node) {
+            if (node.name == find)
+            {
+               return node;
+            }
+
+            if (node.firstChild())
+            {
+               look = deeper(node.firstChild(), find);
+            }
+
+            if (!look && node.nextSibling())
+            {
+               look = deeper(node.nextSibling(), find);
+            }
+         }
+
+         return look;
+      }
+
+      return deeper(this.getNode().firstChild(), name);
+   };
+
+   /**
+    * Find the next node with the given name using a depth first traversal.
+    *
+    * @param name {String} The name of the node to find
+    */
+   XMLDOC.DomReader.prototype.findPreviousNode = function(name)
+   {
+   };
+
+};
+

bin/jsdoc/handlers/XMLDOC/XMLDoc.js

@@ -0,0 +1,16 @@
+LOG.inform("XMLDOC.symbolize loaded");
+
+/**
+ * Convert the source file to a set of symbols
+ */
+XMLDOC.symbolize = function(srcFile, src) {
+
+   LOG.inform("Symbolizing file '" + srcFile + "'");
+
+   // XML files already have a defined structure, so we don't need to
+   // do anything but parse them.  The DOM reader can create a symbol
+   // table from the parsed XML.
+   var dr = new XMLDOC.DomReader(XMLDOC.Parser.parse(src));
+   return dr.getSymbols(srcFile);
+
+};

bin/jsdoc/handlers/XMLDOC/XMLParse.js

@@ -0,0 +1,292 @@
+LOG.inform("XMLDOC.Parser loaded");
+
+/**
+ * XML Parser object.  Returns an {@link #XMLDOC.Parser.node} which is
+ * the root element of the parsed document.
+ * <p/>
+ * By default, this parser will only handle well formed XML.  To
+ * allow the parser to handle HTML, set the <tt>XMLDOC.Parser.strictMode</tt>
+ * variable to <tt>false</tt> before calling <tt>XMLDOC.Parser.parse()</tt>.
+ * <p/>
+ * <i>Note: If you pass poorly formed XML, it will cause the parser to throw
+ * an exception.</i>
+ *
+ * @author Brett Fattori (bfattori@fry.com)
+ * @author $Author: micmath $
+ * @version $Revision: 497 $
+ */
+XMLDOC.Parser = {};
+
+/**
+ * Strict mode setting.  Setting this to false allows HTML-style source to
+ * be parsed.  Normally, well formed XML has defined end tags, or empty tags
+ * are properly formed.  Default: <tt>true</tt>
+ * @type Boolean
+ */
+XMLDOC.Parser.strictMode = true;
+
+/**
+ * A node in an XML Document.  Node types are ROOT, ELEMENT, COMMENT, PI, and TEXT.
+ * @param parent {XMLDOC.Parser.node} The parent node
+ * @param name {String} The node name
+ * @param type {String} One of the types
+ */
+XMLDOC.Parser.node = function(parent, name, type)
+{
+   this.name = name;
+   this.type = type || "ELEMENT";
+   this.parent = parent;
+   this.charData = "";
+   this.attrs = {};
+   this.nodes = [];
+   this.cPtr = 0;
+
+   XMLDOC.Parser.node.prototype.getAttributeNames = function() {
+      var a = [];
+      for (var o in this.attrs)
+      {
+         a.push(o);
+      }
+
+      return a;
+   };
+
+   XMLDOC.Parser.node.prototype.getAttribute = function(attr) {
+      return this.attrs[attr];
+   };
+
+   XMLDOC.Parser.node.prototype.setAttribute = function(attr, val) {
+      this.attrs[attr] = val;
+   };
+
+   XMLDOC.Parser.node.prototype.getChild = function(idx) {
+      return this.nodes[idx];
+   };
+
+   XMLDOC.Parser.node.prototype.parentNode = function() {
+      return this.parent;
+   };
+
+   XMLDOC.Parser.node.prototype.firstChild = function() {
+      return this.nodes[0];
+   };
+
+   XMLDOC.Parser.node.prototype.lastChild = function() {
+      return this.nodes[this.nodes.length - 1];
+   };
+
+   XMLDOC.Parser.node.prototype.nextSibling = function() {
+      var p = this.parent;
+      if (p && (p.nodes.indexOf(this) + 1 != p.nodes.length))
+      {
+         return p.getChild(p.nodes.indexOf(this) + 1);
+      }
+      return null;
+   };
+
+   XMLDOC.Parser.node.prototype.prevSibling = function() {
+      var p = this.parent;
+      if (p && (p.nodes.indexOf(this) - 1 >= 0))
+      {
+         return p.getChild(p.nodes.indexOf(this) - 1);
+      }
+      return null;
+   };
+};
+
+/**
+ * Parse an XML Document from the specified source.  The XML should be
+ * well formed, unless strict mode is disabled, then the parser will
+ * handle HTML-style XML documents.
+ * @param src {String} The source to parse
+ */
+XMLDOC.Parser.parse = function(src)
+{
+   var A = [];
+
+   // Normailize whitespace
+   A = src.split("\r\n");
+   src = A.join("\n");
+   A = src.split("\r");
+   src = A.join("\n");
+
+   // Remove XML and DOCTYPE specifier
+   src.replace(/<\?XML .*\?>/i, "");
+   src.replace(/<!DOCTYPE .*\>/i, "");
+
+   // The document is the root node and cannot be modified or removed
+   var doc = new XMLDOC.Parser.node(null, "ROOT", "DOCUMENT");
+
+   // Let's break it down
+   XMLDOC.Parser.eat(doc, src);
+
+   return doc;
+};
+
+/**
+ * The XML fragment processing routine.  This method is private and should not be called
+ * directly.
+ * @param parentNode {XMLDOC.Parser.node} The node which is the parent of this fragment
+ * @param src {String} The source within the fragment to process
+ * @private
+ */
+XMLDOC.Parser.eat = function(parentNode, src)
+{
+   // A simple tag def
+   var reTag = new RegExp("<(!|)(\\?|--|)((.|\\s)*?)\\2>","g");
+
+   // Special tag types
+   var reCommentTag = /<!--((.|\s)*?)-->/;
+   var rePITag = /<\?((.|\s)*?)\?>/;
+
+   // A start tag (with potential empty marker)
+   var reStartTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*)\4)*(\/)?>/;
+
+   // An empty HTML style tag (not proper XML, but we'll accept it so we can process HTML)
+   var reHTMLEmptyTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*)\4)*>/;
+
+   // Fully enclosing tag with nested tags
+   var reEnclosingTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*?)\4)*>((.|\s)*?)<\/\1>/;
+
+   // Breaks down attributes
+   var reAttributes = new RegExp(" +([\\w_\\-]*)=(\"|')(.*?)\\2","g");
+
+   // Find us a tag
+   var tag;
+   while ((tag = reTag.exec(src)) != null)
+   {
+      if (tag.index > 0)
+      {
+         // The next tag has some text before it
+         var text = src.substring(0, tag.index).replace(/^[ \t\n]+((.|\n)*?)[ \t\n]+$/, "$1");
+
+         if (text.length > 0 && (text != "\n"))
+         {
+            var txtnode = new XMLDOC.Parser.node(parentNode, "", "TEXT");
+            txtnode.charData = text;
+
+            // Append the new text node
+            parentNode.nodes.push(txtnode);
+         }
+
+         // Reset the lastIndex of reTag
+         reTag.lastIndex -= src.substring(0, tag.index).length;
+
+         // Eat the text
+         src = src.substring(tag.index);
+      }
+
+      if (reCommentTag.test(tag[0]))
+      {
+         // Is this a comment?
+         var comment = new XMLDOC.Parser.node(parentNode, "", "COMMENT");
+         comment.charData = reCommentTag.exec(tag[0])[1];
+
+         // Append the comment
+         parentNode.nodes.push(comment);
+
+         // Move the lastIndex of reTag
+         reTag.lastIndex -= tag[0].length;
+
+         // Eat the tag
+         src = src.replace(reCommentTag, "");
+      }
+      else if (rePITag.test(tag[0]))
+      {
+         // Is this a processing instruction?
+         var pi = new XMLDOC.Parser.node(parentNode, "", "PI");
+         pi.charData = rePITag.exec(tag[0])[1];
+
+         // Append the processing instruction
+         parentNode.nodes.push(pi);
+
+         // Move the lastIndex of reTag
+         reTag.lastIndex -= tag[0].length;
+
+         // Eat the tag
+         src = src.replace(rePITag, "");
+      }
+      else if (reStartTag.test(tag[0]))
+      {
+         // Break it down
+         var e = reStartTag.exec(tag[0]);
+         var elem = new XMLDOC.Parser.node(parentNode, e[1], "ELEMENT");
+
+         // Get attributes from the tag
+         var a;
+         while ((a = reAttributes.exec(e[2])) != null )
+         {
+            elem.attrs[a[1]] = a[3];
+         }
+
+         // Is this an empty XML-style tag?
+         if (e[6] == "/")
+         {
+            // Append the empty element
+            parentNode.nodes.push(elem);
+
+            // Move the lastIndex of reTag (include the start tag length)
+            reTag.lastIndex -= e[0].length;
+
+            // Eat the tag
+            src = src.replace(reStartTag, "");
+         }
+         else
+         {
+            // Check for malformed XML tags
+            var htmlParsed = false;
+            var htmlStartTag = reHTMLEmptyTag.exec(src);
+
+            // See if there isn't an end tag within this block
+            var reHTMLEndTag = new RegExp("</" + htmlStartTag[1] + ">");
+            var htmlEndTag = reHTMLEndTag.exec(src);
+
+            if (XMLDOC.Parser.strictMode && htmlEndTag == null)
+            {
+               // Poorly formed XML fails in strict mode
+               var err = new Error("Malformed XML passed to XMLDOC.Parser... Error contains malformed 'src'");
+               err.src = src;
+               throw err;
+            }
+            else if (htmlEndTag == null)
+            {
+               // This is an HTML-style empty tag, store the element for it in non-strict mode
+               parentNode.nodes.push(elem);
+
+               // Eat the tag
+               src = src.replace(reHTMLEmptyTag, "");
+               htmlParsed = true;
+            }
+
+            // If we didn't parse HTML-style, it must be an enclosing tag
+            if (!htmlParsed)
+            {
+               var enc = reEnclosingTag.exec(src);
+
+               // Go deeper into the document
+               XMLDOC.Parser.eat(elem, enc[6]);
+
+               // Append the new element node
+               parentNode.nodes.push(elem);
+
+               // Eat the tag
+               src = src.replace(reEnclosingTag, "");
+            }
+         }
+
+         // Reset the lastIndex of reTag
+         reTag.lastIndex = 0;
+      }
+   }
+
+   // No tag was found... append the text if there is any
+   src = src.replace(/^[ \t\n]+((.|\n)*?)[ \t\n]+$/, "$1");
+   if (src.length > 0 && (src != "\n"))
+   {
+      var txtNode = new XMLDOC.Parser.node(parentNode, "", "TEXT");
+      txtNode.charData = src;
+
+      // Append the new text node
+      parentNode.nodes.push(txtNode);
+   }
+};

bin/jsdoc/lib/JSDOC.js

@@ -0,0 +1,106 @@
+/**
+	@overview
+	@date $Date: 2010-06-13 22:02:44 +0100 (Sun, 13 Jun 2010) $
+	@version $Revision: 837 $ 
+	@location $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-2.4.0/jsdoc-toolkit/app/lib/JSDOC.js $
+	@name JSDOC.js
+ */
+
+/**
+	This is the main container for the JSDOC application.
+	@namespace
+*/
+JSDOC = {
+};
+
+/**
+	@requires Opt
+ */
+if (typeof arguments == "undefined") arguments = [];
+JSDOC.opt = Opt.get(
+	arguments, 
+	{
+		a: "allfunctions", 
+		c: "conf",
+		d: "directory",
+		"D[]": "define",
+		e: "encoding",
+		"E[]": "exclude",
+		h: "help",
+		m: "multiple",
+		n: "nocode",
+		o: "out",
+		p: "private",
+		q: "quiet",
+		r: "recurse",
+		S: "securemodules",
+		s: "suppress",
+		t: "template",
+		T: "testmode",
+		u: "unique",
+		v: "verbose",
+		x: "ext"
+	}
+);
+
+/** The current version string of this application. */
+JSDOC.VERSION = "2.4.0";
+
+/** Print out usage information and quit. */
+JSDOC.usage = function() {
+	print("USAGE: java -jar jsrun.jar app/run.js [OPTIONS] <SRC_DIR> <SRC_FILE> ...");
+	print("");
+	print("OPTIONS:");
+	print("  -a or --allfunctions\n          Include all functions, even undocumented ones.\n");
+	print("  -c or --conf\n          Load a configuration file.\n");
+	print("  -d=<PATH> or --directory=<PATH>\n          Output to this directory (defaults to \"out\").\n");
+	print("  -D=\"myVar:My value\" or --define=\"myVar:My value\"\n          Multiple. Define a variable, available in JsDoc as JSDOC.opt.D.myVar.\n");
+	print("  -e=<ENCODING> or --encoding=<ENCODING>\n          Use this encoding to read and write files.\n");
+	print("  -E=\"REGEX\" or --exclude=\"REGEX\"\n          Multiple. Exclude files based on the supplied regex.\n");
+	print("  -h or --help\n          Show this message and exit.\n");
+	print("  -m or --multiples\n          Don't warn about symbols being documented more than once.\n");
+	print("  -n or --nocode\n          Ignore all code, only document comments with @name tags.\n");
+	print("  -o=<PATH> or --out=<PATH>\n          Print log messages to a file (defaults to stdout).\n");
+	print("  -p or --private\n          Include symbols tagged as private, underscored and inner symbols.\n");
+	print("  -q or --quiet\n          Do not output any messages, not even warnings.\n");
+	print("  -r=<DEPTH> or --recurse=<DEPTH>\n          Descend into src directories.\n");
+	print("  -s or --suppress\n          Suppress source code output.\n");
+	print("  -S or --securemodules\n          Use Secure Modules mode to parse source code.\n");
+	print("  -t=<PATH> or --template=<PATH>\n          Required. Use this template to format the output.\n");
+	print("  -T or --test\n          Run all unit tests and exit.\n");
+	print("  -u or --unique\n          Force file names to be unique, but not based on symbol names.\n");
+	print("  -v or --verbose\n          Provide verbose feedback about what is happening.\n");
+	print("  -x=<EXT>[,EXT]... or --ext=<EXT>[,EXT]...\n          Scan source files with the given extension/s (defaults to js).\n");
+	
+	quit();
+}
+
+/*t:
+	plan(4, "Testing JSDOC namespace.");
+	
+	is(
+		typeof JSDOC,
+		"object",
+		"JSDOC.usage is a function."
+	);
+	
+	is(
+		typeof JSDOC.VERSION,
+		"string",
+		"JSDOC.VERSION is a string."
+	);
+	
+	is(
+		typeof JSDOC.usage,
+		"function",
+		"JSDOC.usage is a function."
+	);
+	
+	is(
+		typeof JSDOC.opt,
+		"object",
+		"JSDOC.opt is a object."
+	);
+ */
+
+if (this.IO) IO.includeDir("lib/JSDOC/");

bin/jsdoc/lib/JSDOC/DocComment.js

@@ -0,0 +1,204 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	Create a new DocComment. This takes a raw documentation comment,
+	and wraps it in useful accessors.
+	@class Represents a documentation comment object.
+ */ 
+JSDOC.DocComment = function(/**String*/comment) {
+	this.init();
+	if (typeof comment != "undefined") {
+		this.parse(comment);
+	}
+}
+
+JSDOC.DocComment.prototype.init = function() {
+	this.isUserComment = true;
+	this.src           = "";
+	this.meta          = "";
+	this.tagTexts      = [];
+	this.tags          = [];
+}
+
+/**
+	@requires JSDOC.DocTag
+ */
+JSDOC.DocComment.prototype.parse = function(/**String*/comment) {
+	if (comment == "") {
+		comment = "/** @desc */";
+		this.isUserComment = false;
+	}
+	
+	this.src = JSDOC.DocComment.unwrapComment(comment);
+	
+	this.meta = "";
+	if (this.src.indexOf("#") == 0) {
+		this.src.match(/#(.+[+-])([\s\S]*)$/);
+		if (RegExp.$1) this.meta = RegExp.$1;
+		if (RegExp.$2) this.src = RegExp.$2;
+	}
+	
+	if (typeof JSDOC.PluginManager != "undefined") {
+		JSDOC.PluginManager.run("onDocCommentSrc", this);
+	}
+	
+	this.fixDesc();
+
+	this.src = JSDOC.DocComment.shared+"\n"+this.src;
+	
+	this.tagTexts = 
+		this.src
+		.split(/(^|[\r\n])\s*@/)
+		.filter(function($){return $.match(/\S/)});
+	
+	/**
+		The tags found in the comment.
+		@type JSDOC.DocTag[]
+	 */
+	this.tags = this.tagTexts.map(function($){return new JSDOC.DocTag($)});
+	
+	if (typeof JSDOC.PluginManager != "undefined") {
+		JSDOC.PluginManager.run("onDocCommentTags", this);
+	}
+}
+
+/*t:
+	plan(5, "testing JSDOC.DocComment");
+	requires("../frame/String.js");
+	requires("../lib/JSDOC/DocTag.js");
+	
+	var com = new JSDOC.DocComment("/**@foo some\n* comment here*"+"/");
+	is(com.tagTexts[0], "foo some\ncomment here", "first tag text is found.");
+	is(com.tags[0].title, "foo", "the title is found in a comment with one tag.");
+	
+	var com = new JSDOC.DocComment("/** @foo first\n* @bar second*"+"/");
+	is(com.getTag("bar").length, 1, "getTag() returns one tag by that title.");
+	
+	JSDOC.DocComment.shared = "@author John Smith";
+	var com = new JSDOC.DocComment("/**@foo some\n* comment here*"+"/");
+	is(com.tags[0].title, "author", "shared comment is added.");
+	is(com.tags[1].title, "foo", "shared comment is added to existing tag.");
+*/
+
+/**
+	If no @desc tag is provided, this function will add it.
+ */
+JSDOC.DocComment.prototype.fixDesc = function() {
+	if (this.meta && this.meta != "@+") return;
+	if (/^\s*[^@\s]/.test(this.src)) {				
+		this.src = "@desc "+this.src;
+	}
+}
+
+/*t:
+	plan(5, "testing JSDOC.DocComment#fixDesc");
+	
+	var com = new JSDOC.DocComment();
+	
+	com.src = "this is a desc\n@author foo";
+	com.fixDesc();
+	is(com.src, "@desc this is a desc\n@author foo", "if no @desc tag is provided one is added.");
+
+	com.src = "x";
+	com.fixDesc();
+	is(com.src, "@desc x", "if no @desc tag is provided one is added to a single character.");
+
+	com.src = "\nx";
+	com.fixDesc();
+	is(com.src, "@desc \nx", "if no @desc tag is provided one is added to return and character.");
+	
+	com.src = " ";
+	com.fixDesc();
+	is(com.src, " ", "if no @desc tag is provided one is not added to just whitespace.");
+
+	com.src = "";
+	com.fixDesc();
+	is(com.src, "", "if no @desc tag is provided one is not added to empty.");
+*/
+
+/**
+	Remove slash-star comment wrapper from a raw comment string.
+	@type String
+ */
+JSDOC.DocComment.unwrapComment = function(/**String*/comment) {
+	if (!comment) return "";
+	var unwrapped = comment.replace(/(^\/\*\*|\*\/$)/g, "").replace(/^\s*\* ?/gm, "");
+	return unwrapped;
+}
+
+/*t:
+	plan(5, "testing JSDOC.DocComment.unwrapComment");
+	
+	var com = "/**x*"+"/";
+	var unwrapped = JSDOC.DocComment.unwrapComment(com);
+	is(unwrapped, "x", "a single character jsdoc is found.");
+	
+	com = "/***x*"+"/";
+	unwrapped = JSDOC.DocComment.unwrapComment(com);
+	is(unwrapped, "x", "three stars are allowed in the opener.");
+	
+	com = "/****x*"+"/";
+	unwrapped = JSDOC.DocComment.unwrapComment(com);
+	is(unwrapped, "*x", "fourth star in the opener is kept.");
+	
+	com = "/**x\n * y\n*"+"/";
+	unwrapped = JSDOC.DocComment.unwrapComment(com);
+	is(unwrapped, "x\ny\n", "leading stars and spaces are trimmed.");
+	
+	com = "/**x\n *   y\n*"+"/";
+	unwrapped = JSDOC.DocComment.unwrapComment(com);
+	is(unwrapped, "x\n  y\n", "only first space after leading stars are trimmed.");
+*/
+
+/**
+	Provides a printable version of the comment.
+	@type String
+ */
+JSDOC.DocComment.prototype.toString = function() {
+	return this.src;
+}
+
+/*t:
+	plan(1, "testing JSDOC.DocComment#fixDesc");
+	var com = new JSDOC.DocComment();
+	com.src = "foo";
+	is(""+com, "foo", "stringifying a comment returns the unwrapped src.");
+*/
+
+/**
+	Given the title of a tag, returns all tags that have that title.
+	@type JSDOC.DocTag[]
+ */
+JSDOC.DocComment.prototype.getTag = function(/**String*/tagTitle) {
+	return this.tags.filter(function($){return $.title == tagTitle});
+}
+
+JSDOC.DocComment.prototype.deleteTag = function(/**String*/tagTitle) {
+	this.tags = this.tags.filter(function($){return $.title != tagTitle})
+}
+
+/*t:
+	plan(1, "testing JSDOC.DocComment#getTag");
+	requires("../frame/String.js");
+	requires("../lib/JSDOC/DocTag.js");
+	
+	var com = new JSDOC.DocComment("/**@foo some\n* @bar\n* @bar*"+"/");
+	is(com.getTag("bar").length, 2, "getTag returns expected number of tags.");
+*/
+
+/**
+	Used to store the currently shared tag text.
+*/
+JSDOC.DocComment.shared = "";
+
+/*t:
+	plan(2, "testing JSDOC.DocComment.shared");
+	requires("../frame/String.js");
+	requires("../lib/JSDOC/DocTag.js");
+	
+	JSDOC.DocComment.shared = "@author Michael";
+	
+	var com = new JSDOC.DocComment("/**@foo\n* @foo*"+"/");
+	is(com.getTag("author").length, 1, "getTag returns shared tag.");
+	is(com.getTag("foo").length, 2, "getTag returns unshared tags too.");
+*/

bin/jsdoc/lib/JSDOC/DocTag.js

@@ -0,0 +1,294 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@constructor
+ */
+JSDOC.DocTag = function(src) {
+	this.init();
+	if (typeof src != "undefined") {
+		this.parse(src);
+	}
+}
+
+/**
+	Create and initialize the properties of this.
+ */
+JSDOC.DocTag.prototype.init = function() {
+	this.title        = "";
+	this.type         = "";
+	this.name         = "";
+	this.isOptional   = false;
+	this.defaultValue = "";
+	this.desc         = "";
+	
+	return this;
+}
+
+/**
+	Populate the properties of this from the given tag src.
+	@param {string} src
+ */
+JSDOC.DocTag.prototype.parse = function(src) {
+	if (typeof src != "string") throw "src must be a string not "+(typeof src);
+
+	try {
+		src = this.nibbleTitle(src);
+		if (JSDOC.PluginManager) {
+			JSDOC.PluginManager.run("onDocTagSynonym", this);
+		}
+		
+		src = this.nibbleType(src);
+		
+		// only some tags are allowed to have names.
+		if (this.title == "param" || this.title == "property" || this.title == "config") { // @config is deprecated
+			src = this.nibbleName(src);
+		}
+	}
+	catch(e) {
+		if (LOG) LOG.warn(e);
+		else throw e;
+	}
+	this.desc = src; // whatever is left
+	
+	// example tags need to have whitespace preserved
+	if (this.title != "example") this.desc = this.desc.trim();
+	
+	if (JSDOC.PluginManager) {
+		JSDOC.PluginManager.run("onDocTag", this);
+	}
+}
+
+/**
+	Automatically called when this is stringified.
+ */
+JSDOC.DocTag.prototype.toString = function() {
+	return this.desc;
+}
+
+/*t:
+	plan(1, "testing JSDOC.DocTag#toString");
+	
+	var tag = new JSDOC.DocTag("param {object} date A valid date.");
+	is(""+tag, "A valid date.", "stringifying a tag returns the desc.");
+ */
+
+/**
+	Find and shift off the title of a tag.
+	@param {string} src
+	@return src
+ */
+JSDOC.DocTag.prototype.nibbleTitle = function(src) {
+	if (typeof src != "string") throw "src must be a string not "+(typeof src);
+	
+	var parts = src.match(/^\s*(\S+)(?:\s([\s\S]*))?$/);
+
+	if (parts && parts[1]) this.title = parts[1];
+	if (parts && parts[2]) src = parts[2];
+	else src = "";
+	
+	return src;
+}
+
+/*t:
+	plan(8, "testing JSDOC.DocTag#nibbleTitle");
+	
+	var tag = new JSDOC.DocTag();
+	
+	tag.init().nibbleTitle("aTitleGoesHere");
+	is(tag.title, "aTitleGoesHere", "a title can be found in a single-word string.");
+	
+	var src = tag.init().nibbleTitle("aTitleGoesHere and the rest");
+	is(tag.title, "aTitleGoesHere", "a title can be found in a multi-word string.");
+	is(src, "and the rest", "the rest is returned when the title is nibbled off.");
+	
+	src = tag.init().nibbleTitle("");
+	is(tag.title, "", "given an empty string the title is empty.");
+	is(src, "", "the rest is empty when the tag is empty.");
+
+	var src = tag.init().nibbleTitle(" aTitleGoesHere\n  a description");
+	is(tag.title, "aTitleGoesHere", "leading and trailing spaces are not part of the title.");
+	is(src, "  a description", "leading spaces (less one) are part of the description.");
+
+	tag.init().nibbleTitle("a.Title::Goes_Here foo");
+	is(tag.title, "a.Title::Goes_Here", "titles with punctuation are allowed.");
+ */
+
+/**
+	Find and shift off the type of a tag.
+	@requires frame/String.js
+	@param {string} src
+	@return src
+ */
+JSDOC.DocTag.prototype.nibbleType = function(src) {
+	if (typeof src != "string") throw "src must be a string not "+(typeof src);
+	
+	if (src.match(/^\s*\{/)) {
+		var typeRange = src.balance("{", "}");
+		if (typeRange[1] == -1) {
+			throw "Malformed comment tag ignored. Tag type requires an opening { and a closing }: "+src;
+		}
+		this.type = src.substring(typeRange[0]+1, typeRange[1]).trim();
+		this.type = this.type.replace(/\s*,\s*/g, "|"); // multiples can be separated by , or |
+		src = src.substring(typeRange[1]+1);
+	}
+	
+	return src;
+}
+
+/*t:
+	plan(5, "testing JSDOC.DocTag.parser.nibbleType");
+	requires("../frame/String.js");
+	
+	var tag = new JSDOC.DocTag();
+	
+	tag.init().nibbleType("{String[]} aliases");
+	is(tag.type, "String[]", "type can have non-alpha characters.");
+	
+	tag.init().nibbleType("{ aTypeGoesHere  } etc etc");
+	is(tag.type, "aTypeGoesHere", "type is trimmed.");
+	
+	tag.init().nibbleType("{ oneType, twoType ,\n threeType  } etc etc");
+	is(tag.type, "oneType|twoType|threeType", "multiple types can be separated by commas.");
+	
+	var error;
+	try { tag.init().nibbleType("{widget foo"); }
+	catch(e) { error = e; }
+	is(typeof error, "string", "malformed tag type throws error.");
+	isnt(error.indexOf("Malformed"), -1, "error message tells tag is malformed.");
+ */
+
+/**
+	Find and shift off the name of a tag.
+	@requires frame/String.js
+	@param {string} src
+	@return src
+ */
+JSDOC.DocTag.prototype.nibbleName = function(src) {
+	if (typeof src != "string") throw "src must be a string not "+(typeof src);
+	
+	src = src.trim();
+	
+	// is optional?
+	if (src.charAt(0) == "[") {
+		var nameRange = src.balance("[", "]");
+		if (nameRange[1] == -1) {
+			throw "Malformed comment tag ignored. Tag optional name requires an opening [ and a closing ]: "+src;
+		}
+		this.name = src.substring(nameRange[0]+1, nameRange[1]).trim();
+		this.isOptional = true;
+		
+		src = src.substring(nameRange[1]+1);
+		
+		// has default value?
+		var nameAndValue = this.name.split("=");
+		if (nameAndValue.length) {
+			this.name = nameAndValue.shift().trim();
+			this.defaultValue = nameAndValue.join("=");
+		}
+	}
+	else {
+		var parts = src.match(/^(\S+)(?:\s([\s\S]*))?$/);
+		if (parts) {
+			if (parts[1]) this.name = parts[1];
+			if (parts[2]) src = parts[2].trim();
+			else src = "";
+		}
+	}	
+
+	return src;
+}
+
+/*t:
+	requires("../frame/String.js");
+	plan(9, "testing JSDOC.DocTag.parser.nibbleName");
+	
+	var tag = new JSDOC.DocTag();
+	
+	tag.init().nibbleName("[foo] This is a description.");
+	is(tag.isOptional, true, "isOptional syntax is detected.");
+	is(tag.name, "foo", "optional param name is found.");
+ 	
+	tag.init().nibbleName("[foo] This is a description.");
+	is(tag.isOptional, true, "isOptional syntax is detected when no type.");
+	is(tag.name, "foo", "optional param name is found when no type.");
+	
+	tag.init().nibbleName("[foo=7] This is a description.");
+ 	is(tag.name, "foo", "optional param name is found when default value.");
+ 	is(tag.defaultValue, 7, "optional param default value is found when default value.");
+ 	
+ 	//tag.init().nibbleName("[foo= a value] This is a description.");
+ 	//is(tag.defaultValue, " a value", "optional param default value is found when default value has spaces (issue #112).");
+ 	
+ 	tag.init().nibbleName("[foo=[]] This is a description.");
+ 	is(tag.defaultValue, "[]", "optional param default value is found when default value is [] (issue #95).");
+ 	
+ 	tag.init().nibbleName("[foo=a=b] This is a description.");
+ 	is(tag.name, "foo", "optional param name is found when default value is a=b.");
+ 	is(tag.defaultValue, "a=b", "optional param default value is found when default value is a=b.")
+ */
+
+/*t:
+	plan(32, "Testing JSDOC.DocTag.parser.");
+	requires("../frame/String.js");
+	
+ 	var tag = new JSDOC.DocTag();
+ 	
+ 	is(typeof tag, "object", "JSDOC.DocTag.parser with an empty string returns an object.");
+ 	is(typeof tag.title, "string", "returned object has a string property 'title'.");
+ 	is(typeof tag.type, "string", "returned object has a string property 'type'.");
+ 	is(typeof tag.name, "string", "returned object has a string property 'name'.");
+ 	is(typeof tag.defaultValue, "string", "returned object has a string property 'defaultValue'.");
+ 	is(typeof tag.isOptional, "boolean", "returned object has a boolean property 'isOptional'.");
+ 	is(typeof tag.desc, "string", "returned object has a string property 'desc'.");
+  
+  	tag = new JSDOC.DocTag("param {widget} foo");
+  	is(tag.title, "param", "param title is found.");
+  	is(tag.name, "foo", "param name is found when desc is missing.");
+ 	is(tag.desc, "", "param desc is empty when missing.");
+ 	
+ 	tag = new JSDOC.DocTag("param {object} date A valid date.");
+ 	is(tag.name, "date", "param name is found with a type.");
+ 	is(tag.type, "object", "param type is found.");
+ 	is(tag.desc, "A valid date.", "param desc is found with a type.");
+ 	
+  	tag = new JSDOC.DocTag("param aName a description goes\n    here.");
+	is(tag.name, "aName", "param name is found without a type.");
+ 	is(tag.desc, "a description goes\n    here.", "param desc is found without a type.");
+ 	
+ 	tag = new JSDOC.DocTag("param {widget}");
+ 	is(tag.name, "", "param name is empty when it is not given.");
+	
+	tag = new JSDOC.DocTag("param {widget} [foo] This is a description.");
+	is(tag.name, "foo", "optional param name is found.");
+	
+	tag = new JSDOC.DocTag("return {aType} This is a description.");
+	is(tag.type, "aType", "when return tag has no name, type is found.");
+	is(tag.desc, "This is a description.", "when return tag has no name, desc is found.");
+	
+	tag = new JSDOC.DocTag("author Joe Coder <jcoder@example.com>");
+	is(tag.title, "author", "author tag has a title.");
+	is(tag.type, "", "the author tag has no type.");
+	is(tag.name, "", "the author tag has no name.");
+	is(tag.desc, "Joe Coder <jcoder@example.com>", "author tag has desc.");
+	
+	tag = new JSDOC.DocTag("private \t\n  ");
+	is(tag.title, "private", "private tag has a title.");
+	is(tag.type, "", "the private tag has no type.");
+	is(tag.name, "", "the private tag has no name.");
+	is(tag.desc, "", "private tag has no desc.");
+
+	tag = new JSDOC.DocTag("example\n   example(code);\n   more();");
+	is(tag.desc, "   example(code);\n   more();", "leading whitespace (less one) in examples code is preserved.");
+	
+	tag = new JSDOC.DocTag("param theName  \n");
+	is(tag.name, "theName", "name only is found.");
+	
+	tag = new JSDOC.DocTag("type theDesc  \n");
+	is(tag.desc, "theDesc", "desc only is found.");
+	
+	tag = new JSDOC.DocTag("type {theType} \n");
+	is(tag.type, "theType", "type only is found.");
+	
+	tag = new JSDOC.DocTag("");
+	is(tag.title, "", "title is empty when tag is empty.");
+ */

bin/jsdoc/lib/JSDOC/JsDoc.js

@@ -0,0 +1,140 @@
+/**
+	@constructor
+	@param [opt] Used to override the commandline options. Useful for testing.
+	@version $Id: JsDoc.js 831 2010-03-09 14:24:56Z micmath $
+*/
+JSDOC.JsDoc = function(/**object*/ opt) {
+	if (opt) {
+		JSDOC.opt = opt;
+	}
+	
+	if (JSDOC.opt.h) {
+		JSDOC.usage();
+		quit();
+	}
+	
+	// defend against options that are not sane 
+	if (JSDOC.opt._.length == 0) {
+		LOG.warn("No source files to work on. Nothing to do.");
+		quit();
+	}
+	if (JSDOC.opt.t === true || JSDOC.opt.d === true) {
+		JSDOC.usage();
+	}
+	
+	if (typeof JSDOC.opt.d == "string") {
+		if (!JSDOC.opt.d.charAt(JSDOC.opt.d.length-1).match(/[\\\/]/)) {
+			JSDOC.opt.d = JSDOC.opt.d+"/";
+		}
+		LOG.inform("Output directory set to '"+JSDOC.opt.d+"'.");
+		IO.mkPath(JSDOC.opt.d);
+	}
+	if (JSDOC.opt.e) IO.setEncoding(JSDOC.opt.e);
+	
+	// the -r option: scan source directories recursively
+	if (typeof JSDOC.opt.r == "boolean") JSDOC.opt.r = 10;
+	else if (!isNaN(parseInt(JSDOC.opt.r))) JSDOC.opt.r = parseInt(JSDOC.opt.r);
+	else JSDOC.opt.r = 1;
+	
+	// the -D option: define user variables
+	var D = {};
+	if (JSDOC.opt.D) {
+		for (var i = 0; i < JSDOC.opt.D.length; i++) {
+			var param = JSDOC.opt.D[i];
+			// remove first and last character if both == "
+			if ( 
+				param.length > 1
+				&& param.charAt(0) == '"'
+				&& param.charAt(param.length-1) == '"'
+			) {
+				param = param.substr(1, param.length-2);
+			}
+			var defineParts = param.split(":");
+			if (defineParts && defineParts.length > 1) {
+				for ( var dpIdx = 2; dpIdx < defineParts.length; dpIdx++ ) {
+					defineParts[1] += ':' + defineParts[dpIdx];
+				}
+				D[defineParts[0]] = defineParts[1];
+			}
+		}
+	}
+	JSDOC.opt.D = D;
+	// combine any conf file D options with the commandline D options
+	if (defined(JSDOC.conf)) for (var c in JSDOC.conf.D) {
+ 		if (!defined(JSDOC.opt.D[c])) {
+ 			JSDOC.opt.D[c] = JSDOC.conf.D[c];
+ 		}
+ 	}
+	
+	// Give plugins a chance to initialize
+	if (defined(JSDOC.PluginManager)) {
+		JSDOC.PluginManager.run("onInit", JSDOC.opt);
+	}
+
+	JSDOC.opt.srcFiles = JSDOC.JsDoc._getSrcFiles();
+	JSDOC.JsDoc._parseSrcFiles();
+	JSDOC.JsDoc.symbolSet = JSDOC.Parser.symbols;
+}
+
+/**
+	Retrieve source file list.
+	@returns {String[]} The pathnames of the files to be parsed.
+ */
+JSDOC.JsDoc._getSrcFiles = function() {
+	JSDOC.JsDoc.srcFiles = [];
+	
+	var ext = ["js"];
+	if (JSDOC.opt.x) {
+		ext = JSDOC.opt.x.split(",").map(function($) {return $.toLowerCase()});
+	}
+	
+	for (var i = 0; i < JSDOC.opt._.length; i++) {
+		JSDOC.JsDoc.srcFiles = JSDOC.JsDoc.srcFiles.concat(
+			IO.ls(JSDOC.opt._[i], JSDOC.opt.r).filter(
+				function($) {
+					var thisExt = $.split(".").pop().toLowerCase();
+					
+					if (JSDOC.opt.E) {
+						for(var n = 0; n < JSDOC.opt.E.length; n++) {
+							if ($.match(new RegExp(JSDOC.opt.E[n]))) {
+								LOG.inform("Excluding " + $);
+								return false; // if the file matches the regex then it's excluded.
+							}
+						}
+					}
+					
+					return (ext.indexOf(thisExt) > -1); // we're only interested in files with certain extensions
+				}
+			)
+		);
+	}
+	
+	return JSDOC.JsDoc.srcFiles;
+}
+
+JSDOC.JsDoc._parseSrcFiles = function() {
+	JSDOC.Parser.init();
+	for (var i = 0, l = JSDOC.JsDoc.srcFiles.length; i < l; i++) {
+		var srcFile = JSDOC.JsDoc.srcFiles[i];
+		
+		if (JSDOC.opt.v) LOG.inform("Parsing file: " + srcFile);
+		
+		try {
+			var src = IO.readFile(srcFile);
+		}
+		catch(e) {
+			LOG.warn("Can't read source file '"+srcFile+"': "+e.message);
+		}
+
+		var tr = new JSDOC.TokenReader();
+		var ts = new JSDOC.TokenStream(tr.tokenize(new JSDOC.TextStream(src)));
+
+		JSDOC.Parser.parse(ts, srcFile);
+
+	}
+	JSDOC.Parser.finish();
+
+	if (JSDOC.PluginManager) {
+		JSDOC.PluginManager.run("onFinishedParsing", JSDOC.Parser.symbols);
+	}
+}

bin/jsdoc/lib/JSDOC/JsPlate.js

@@ -0,0 +1,109 @@
+/**
+	@constructor
+*/
+JSDOC.JsPlate = function(templateFile) {
+	if (templateFile) this.template = IO.readFile(templateFile);
+	
+	this.templateFile = templateFile;
+	this.code = "";
+	this.parse();
+}
+
+JSDOC.JsPlate.prototype.parse = function() {
+	this.template = this.template.replace(/\{#[\s\S]+?#\}/gi, "");
+	this.code = "var output=\u001e"+this.template;
+
+	this.code = this.code.replace(
+		/<for +each="(.+?)" +in="(.+?)" *>/gi, 
+		function (match, eachName, inName) {
+			return "\u001e;\rvar $"+eachName+"_keys = keys("+inName+");\rfor(var $"+eachName+"_i = 0; $"+eachName+"_i < $"+eachName+"_keys.length; $"+eachName+"_i++) {\rvar $"+eachName+"_last = ($"+eachName+"_i == $"+eachName+"_keys.length-1);\rvar $"+eachName+"_key = $"+eachName+"_keys[$"+eachName+"_i];\rvar "+eachName+" = "+inName+"[$"+eachName+"_key];\routput+=\u001e";
+		}
+	);	
+	this.code = this.code.replace(/<if test="(.+?)">/g, "\u001e;\rif ($1) { output+=\u001e");
+	this.code = this.code.replace(/<elseif test="(.+?)"\s*\/>/g, "\u001e;}\relse if ($1) { output+=\u001e");
+	this.code = this.code.replace(/<else\s*\/>/g, "\u001e;}\relse { output+=\u001e");
+	this.code = this.code.replace(/<\/(if|for)>/g, "\u001e;\r};\routput+=\u001e");
+	this.code = this.code.replace(
+		/\{\+\s*([\s\S]+?)\s*\+\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "\u001e"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\r?\n)/g, " ");
+			return "\u001e+ ("+code+") +\u001e";
+		}
+	);
+	this.code = this.code.replace(
+		/\{!\s*([\s\S]+?)\s*!\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "\u001e"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\n)/g, " ");
+			return "\u001e; "+code+";\routput+=\u001e";
+		}
+	);
+	this.code = this.code+"\u001e;";
+
+	this.code = this.code.replace(/(\r?\n)/g, "\\n");
+	this.code = this.code.replace(/"/g, "\\\"");
+	this.code = this.code.replace(/\u001e/g, "\"");
+}
+
+JSDOC.JsPlate.prototype.toCode = function() {
+	return this.code;
+}
+
+JSDOC.JsPlate.keys = function(obj) {
+	var keys = [];
+	if (obj.constructor.toString().indexOf("Array") > -1) {
+		for (var i = 0; i < obj.length; i++) {
+			keys.push(i);
+		}
+	}
+	else {
+		for (var i in obj) {
+			keys.push(i);
+		}
+	}
+	return keys;
+};
+
+JSDOC.JsPlate.values = function(obj) {
+	var values = [];
+	if (obj.constructor.toString().indexOf("Array") > -1) {
+		for (var i = 0; i < obj.length; i++) {
+			values.push(obj[i]);
+		}
+	}
+	else {
+		for (var i in obj) {
+			values.push(obj[i]);
+		}
+	}
+	return values;
+};
+
+JSDOC.JsPlate.prototype.process = function(data, compact) {
+	var keys = JSDOC.JsPlate.keys;
+	var values = JSDOC.JsPlate.values;
+	
+	try {
+		eval(this.code);
+	}
+	catch (e) {
+		print(">> There was an error evaluating the compiled code from template: "+this.templateFile);
+		print("   The error was on line "+e.lineNumber+" "+e.name+": "+e.message);
+		var lines = this.code.split("\r");
+		if (e.lineNumber-2 >= 0) print("line "+(e.lineNumber-1)+": "+lines[e.lineNumber-2]);
+		print("line "+e.lineNumber+": "+lines[e.lineNumber-1]);
+		print("");
+	}
+	
+	if (compact) { // patch by mcbain.asm
+ 		// Remove lines that contain only space-characters, usually left by lines in the template
+ 		// which originally only contained JSPlate tags or code. This makes it easier to write
+ 		// non-tricky templates which still put out nice code (not bloated with extra lines).
+ 		// Lines purposely left blank (just a line ending) are left alone.
+ 		output = output.replace(/\s+?(\r?)\n/g, "$1\n");
+ 	}
+ 	
+	/*debug*///print(this.code);
+	return output;
+}

bin/jsdoc/lib/JSDOC/Lang.js

@@ -0,0 +1,144 @@
+/**
+	@namespace
+*/
+JSDOC.Lang = {
+}
+
+JSDOC.Lang.isBuiltin = function(name) {
+	return (JSDOC.Lang.isBuiltin.coreObjects.indexOf(name) > -1);
+}
+JSDOC.Lang.isBuiltin.coreObjects = ['_global_', 'Array', 'Boolean', 'Date', 'Error', 'Function', 'Math', 'Number', 'Object', 'RegExp', 'String'];
+
+JSDOC.Lang.whitespace = function(ch) {
+	return JSDOC.Lang.whitespace.names[ch];
+}
+JSDOC.Lang.whitespace.names = {
+	" ":      "SPACE",
+	"\f":     "FORMFEED",
+	"\t":     "TAB",
+	"\u0009": "UNICODE_TAB",
+	"\u000A": "UNICODE_NBR",
+	"\u0008": "VERTICAL_TAB"
+};
+
+JSDOC.Lang.newline = function(ch) {
+	return JSDOC.Lang.newline.names[ch];
+}
+JSDOC.Lang.newline.names = {
+	"\n":     "NEWLINE",
+	"\r":     "RETURN",
+	"\u000A": "UNICODE_LF",
+	"\u000D": "UNICODE_CR",
+	"\u2029": "UNICODE_PS",
+	"\u2028": "UNICODE_LS"
+};
+
+JSDOC.Lang.keyword = function(word) {
+	return JSDOC.Lang.keyword.names["="+word];
+}
+JSDOC.Lang.keyword.names = {
+	"=break":      "BREAK",
+	"=case":       "CASE",
+	"=catch":      "CATCH",
+	"=const":      "VAR",
+	"=continue":   "CONTINUE",
+	"=default":    "DEFAULT",
+	"=delete":     "DELETE",
+	"=do":         "DO",
+	"=else":       "ELSE",
+	"=false":      "FALSE",
+	"=finally":    "FINALLY",
+	"=for":        "FOR",
+	"=function":   "FUNCTION",
+	"=if":         "IF",
+	"=in":         "IN",
+	"=instanceof": "INSTANCEOF",
+	"=new":        "NEW",
+	"=null":       "NULL",
+	"=return":     "RETURN",
+	"=switch":     "SWITCH",
+	"=this":       "THIS",
+	"=throw":      "THROW",
+	"=true":       "TRUE",
+	"=try":        "TRY",
+	"=typeof":     "TYPEOF",
+	"=void":       "VOID",
+	"=while":      "WHILE",
+	"=with":       "WITH",
+	"=var":        "VAR"
+};
+
+JSDOC.Lang.punc = function(ch) {
+	return JSDOC.Lang.punc.names[ch];
+}
+JSDOC.Lang.punc.names = {
+	";":   "SEMICOLON",
+	",":   "COMMA",
+	"?":   "HOOK",
+	":":   "COLON",
+	"||":  "OR", 
+	"&&":  "AND",
+	"|":   "BITWISE_OR",
+	"^":   "BITWISE_XOR",
+	"&":   "BITWISE_AND",
+	"===": "STRICT_EQ", 
+	"==":  "EQ",
+	"=":   "ASSIGN",
+	"!==": "STRICT_NE",
+	"!=":  "NE",
+	"<<":  "LSH",
+	"<=":  "LE", 
+	"<":   "LT",
+	">>>": "URSH",
+	">>":  "RSH",
+	">=":  "GE",
+	">":   "GT", 
+	"++":  "INCREMENT",
+	"--":  "DECREMENT",
+	"+":   "PLUS",
+	"-":   "MINUS",
+	"*":   "MUL",
+	"/":   "DIV", 
+	"%":   "MOD",
+	"!":   "NOT",
+	"~":   "BITWISE_NOT",
+	".":   "DOT",
+	"[":   "LEFT_BRACKET",
+	"]":   "RIGHT_BRACKET",
+	"{":   "LEFT_CURLY",
+	"}":   "RIGHT_CURLY",
+	"(":   "LEFT_PAREN",
+	")":   "RIGHT_PAREN"
+};
+
+JSDOC.Lang.matching = function(name) {
+	return JSDOC.Lang.matching.names[name];
+}
+JSDOC.Lang.matching.names = {
+	"LEFT_PAREN": "RIGHT_PAREN",
+	"RIGHT_PAREN": "LEFT_PAREN",
+	"LEFT_CURLY": "RIGHT_CURLY",
+	"RIGHT_CURLY": "LEFT_CURLY",
+	"LEFT_BRACE": "RIGHT_BRACE",
+	"RIGHT_BRACE": "LEFT_BRACE"
+}
+
+JSDOC.Lang.isNumber = function(str) {
+	return /^(\.[0-9]|[0-9]+\.|[0-9])[0-9]*([eE][+-][0-9]+)?$/i.test(str);
+}
+
+JSDOC.Lang.isHexDec = function(str) {
+	return /^0x[0-9A-F]+$/i.test(str);
+}
+
+JSDOC.Lang.isWordChar = function(str) {
+	return /^[a-zA-Z0-9$_.]+$/.test(str);
+}
+
+JSDOC.Lang.isSpace = function(str) {
+	return (typeof JSDOC.Lang.whitespace(str) != "undefined");
+}
+
+JSDOC.Lang.isNewline = function(str) {
+	return (typeof JSDOC.Lang.newline(str) != "undefined");
+}

bin/jsdoc/lib/JSDOC/Parser.js

@@ -0,0 +1,146 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@namespace
+	@requires JSDOC.Walker
+	@requires JSDOC.Symbol
+	@requires JSDOC.DocComment
+*/
+JSDOC.Parser = {
+	conf: {
+		ignoreCode:               JSDOC.opt.n,
+		ignoreAnonymous:           true, // factory: true
+		treatUnderscoredAsPrivate: true, // factory: true
+		explain:                   false // factory: false
+	},
+	
+	addSymbol: function(symbol) {
+
+		if (JSDOC.Parser.rename) {
+			for (var n in JSDOC.Parser.rename) {
+				if (symbol.alias.indexOf(n) == 0) {
+					if (symbol.name == symbol.alias) {
+						symbol.name = symbol.name.replace(n, JSDOC.Parser.rename[n]);
+					}
+					symbol.alias = symbol.alias.replace(n, JSDOC.Parser.rename[n]);
+				}
+			}
+		}
+		
+		if (JSDOC.opt.S) {
+			if (typeof JSDOC.Parser.secureModules == "undefined") JSDOC.Parser.secureModules = {};
+			if (/^exports\./.test(symbol.alias)) {
+				symbol.srcFile.match(/(^|[\\\/])([^\\\/]+)\.js/i);
+				var fileNS = RegExp.$2;
+				
+				// need to create the namespace associated with this file first
+				if (!JSDOC.Parser.secureModules[fileNS]) {
+					JSDOC.Parser.secureModules[fileNS] = 1;
+					var nsSymbol = new JSDOC.Symbol(fileNS, [], "GLOBAL", new JSDOC.DocComment(""));
+					nsSymbol.isNamespace = true;
+					nsSymbol.srcFile = "";
+					nsSymbol.isPrivate = false;
+					nsSymbol.srcFile = symbol.srcFile;
+					nsSymbol.desc = (JSDOC.Parser.symbols.getSymbol(symbol.srcFile) || {desc: ""}).desc;
+					JSDOC.Parser.addSymbol(nsSymbol);
+				}
+				
+				symbol.alias = symbol.alias.replace(/^exports\./, fileNS + '.');
+				symbol.name = symbol.name.replace(/^exports\./, '');
+				symbol.memberOf = fileNS;
+				symbol.isStatic = true;
+			}
+		}
+
+		// if a symbol alias is documented more than once the first one with the user docs wins
+		if (JSDOC.Parser.symbols.hasSymbol(symbol.alias)) {
+ 			var oldSymbol = JSDOC.Parser.symbols.getSymbol(symbol.alias);
+			if (oldSymbol.comment.isUserComment) {
+				if (JSDOC.opt.m) return;
+				if (symbol.comment.isUserComment) { // old and new are both documented
+					LOG.warn("The symbol '"+symbol.alias+"' is documented more than once.");
+					return;
+				}
+				else { // old is documented but new isn't
+					return;
+				}
+			}
+		}
+		
+		// we don't document anonymous things
+		if (JSDOC.Parser.conf.ignoreAnonymous && symbol.name.match(/\$anonymous\b/)) return;
+
+		// uderscored things may be treated as if they were marked private, this cascades
+		if (JSDOC.Parser.conf.treatUnderscoredAsPrivate && symbol.name.match(/[.#-]_[^.#-]+$/)) {
+			if (!symbol.comment.getTag("public").length > 0) symbol.isPrivate = true;
+		}
+		
+		// -p flag is required to document private things
+		if (!JSDOC.opt.p && symbol.isPrivate) return; // issue #161 fixed by mcbain.asm
+		
+		// ignored things are not documented, this doesn't cascade
+		if (symbol.isIgnored) return;
+		JSDOC.Parser.symbols.addSymbol(symbol);
+	},
+	
+	addBuiltin: function(name) {
+		var builtin = new JSDOC.Symbol(name, [], "CONSTRUCTOR", new JSDOC.DocComment(""));
+		builtin.isNamespace = true;
+		builtin.srcFile = "";
+		builtin.isPrivate = false;
+		JSDOC.Parser.addSymbol(builtin);
+		return builtin;
+	},
+	
+	init: function() {
+		JSDOC.Parser.symbols = new JSDOC.SymbolSet();
+		JSDOC.Parser.walker = new JSDOC.Walker();
+	},
+	
+	finish: function() {
+		JSDOC.Parser.symbols.relate();		
+		
+		// make a litle report about what was found
+		if (JSDOC.Parser.conf.explain) {
+			var symbols = JSDOC.Parser.symbols.toArray();
+			var srcFile = "";
+			for (var i = 0, l = symbols.length; i < l; i++) {
+				var symbol = symbols[i];
+				if (srcFile != symbol.srcFile) {
+					srcFile = symbol.srcFile;
+					print("\n"+srcFile+"\n-------------------");
+				}
+				print(i+":\n  alias => "+symbol.alias + "\n  name => "+symbol.name+ "\n  isa => "+symbol.isa + "\n  memberOf => " + symbol.memberOf + "\n  isStatic => " + symbol.isStatic + ",  isInner => " + symbol.isInner+ ",  isPrivate => " + symbol.isPrivate);
+			}
+			print("-------------------\n");
+		}
+	}
+}
+
+JSDOC.Parser.parse = function(/**JSDOC.TokenStream*/ts, /**String*/srcFile) {
+	JSDOC.Symbol.srcFile = (srcFile || "");
+	JSDOC.DocComment.shared = ""; // shared comments don't cross file boundaries
+	
+	if (!JSDOC.Parser.walker) JSDOC.Parser.init();
+	JSDOC.Parser.walker.walk(ts); // adds to our symbols
+	
+	// filter symbols by option
+	for (var p = JSDOC.Parser.symbols._index.first(); p; p = JSDOC.Parser.symbols._index.next()) {
+		var symbol = p.value;
+		
+		if (!symbol) continue;
+		
+		if (symbol.is("FILE") || symbol.is("GLOBAL")) {
+			continue;
+		}
+		else if (!JSDOC.opt.a && !symbol.comment.isUserComment) {
+			JSDOC.Parser.symbols.deleteSymbol(symbol.alias);
+		}
+		
+		if (/#$/.test(symbol.alias)) { // we don't document prototypes
+			JSDOC.Parser.symbols.deleteSymbol(symbol.alias);
+		}
+	}
+	
+	return JSDOC.Parser.symbols.toArray();
+}

bin/jsdoc/lib/JSDOC/PluginManager.js

@@ -0,0 +1,33 @@
+/**
+	@namespace Holds functionality related to running plugins.
+*/
+JSDOC.PluginManager = {
+}
+
+/**
+	@param name A unique name that identifies that plugin.
+	@param handlers A collection of named functions. The names correspond to hooks in the core code.
+*/
+JSDOC.PluginManager.registerPlugin = function(/**String*/name, /**Object*/handlers) {
+	if (!defined(JSDOC.PluginManager.plugins))
+		/** The collection of all plugins. Requires a unique name for each.
+		*/
+		JSDOC.PluginManager.plugins = {};
+	
+	
+	JSDOC.PluginManager.plugins[name] = handlers;
+}
+
+/**
+	@param hook The name of the hook that is being caught.
+	@param target Any object. This will be passed as the only argument to the handler whose
+	name matches the hook name. Handlers cannot return a value, so must modify the target
+	object to have an effect.
+*/
+JSDOC.PluginManager.run = function(/**String*/hook, /**Mixed*/target) {
+	for (var name in JSDOC.PluginManager.plugins) {
+		if (defined(JSDOC.PluginManager.plugins[name][hook])) {
+			JSDOC.PluginManager.plugins[name][hook](target);
+		}
+	}
+}

bin/jsdoc/lib/JSDOC/Symbol.js

@@ -0,0 +1,644 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	Create a new Symbol.
+	@class Represents a symbol in the source code.
+ */
+JSDOC.Symbol = function() {
+	this.init();
+	if (arguments.length) this.populate.apply(this, arguments);
+}
+
+JSDOC.Symbol.count = 0;
+
+JSDOC.Symbol.prototype.init = function() {
+	this._name = "";
+	this._params = [];
+	this.$args = [];
+	this.addOn = "";
+	this.alias = "";
+	this.augments = [];
+	this.author = "";
+	this.classDesc = "";
+	this.comment = {};
+	this.defaultValue = undefined;
+	this.deprecated = "";
+	this.desc = "";
+	this.example = [];
+	this.exceptions = [];
+	this.fires = [];
+	this.id = JSDOC.Symbol.count++;
+	this.inherits = [];
+	this.inheritsFrom = [];
+	this.isa = "OBJECT";
+	this.isConstant = false;
+	this.isEvent = false;
+	this.isIgnored = false;
+	this.isInner = false;
+	this.isNamespace = false;
+	this.isPrivate = false;
+	this.isStatic = false;
+	this.memberOf = "";
+	this.methods = [];
+	this.properties = [];
+	this.requires = [];
+	this.returns = [];
+	this.see = [];
+	this.since = "";
+	this.srcFile = {};
+	this.type = "";
+	this.version = "";
+}
+
+JSDOC.Symbol.prototype.serialize = function() {
+	var keys = [];
+	for (var p in this) {
+		keys.push (p);
+	}
+	keys = keys.sort();
+	
+	var out = "";
+	for (var i in keys) {
+		if (typeof this[keys[i]] == "function") continue;
+		out += keys[i]+" => "+Dumper.dump(this[keys[i]])+",\n";
+	}
+	return "\n{\n" + out + "}\n";
+}
+
+JSDOC.Symbol.prototype.clone = function() {
+	var clone = new JSDOC.Symbol();
+	clone.populate.apply(clone, this.$args); // repopulate using the original arguments
+	clone.srcFile = this.srcFile; // not the current srcFile, the one when the original was made
+	return clone;
+}
+
+JSDOC.Symbol.prototype.__defineSetter__("name",
+	function(n) { n = n.replace(/^_global_[.#-]/, ""); n = n.replace(/\.prototype\.?/g, '#'); this._name = n; }
+);
+JSDOC.Symbol.prototype.__defineGetter__("name",
+	function() { return this._name; }
+);
+JSDOC.Symbol.prototype.__defineSetter__("params", 
+	function(v) {
+		for (var i = 0, l = v.length; i < l; i++) {
+			if (v[i].constructor != JSDOC.DocTag) { // may be a generic object parsed from signature, like {type:..., name:...}
+				this._params[i] = new JSDOC.DocTag("param"+((v[i].type)?" {"+v[i].type+"}":"")+" "+v[i].name);
+			}
+			else {
+				this._params[i] = v[i];
+			}
+		}
+	}
+);
+JSDOC.Symbol.prototype.__defineGetter__("params",
+	function() { return this._params; }
+);
+
+JSDOC.Symbol.prototype.getEvents = function() {
+	var events = [];
+	for (var i = 0, l = this.methods.length; i < l; i++) {
+		if (this.methods[i].isEvent) {
+			this.methods[i].name = this.methods[i].name.replace("event:", "");
+			events.push(this.methods[i]);
+		}
+	}
+	return events;
+}
+
+JSDOC.Symbol.prototype.getMethods = function() {
+	var nonEvents = [];
+	for (var i = 0, l = this.methods.length; i < l; i++) {
+		if (!this.methods[i].isEvent) {
+			nonEvents.push(this.methods[i]);
+		}
+	}
+	return nonEvents;
+}
+
+
+JSDOC.Symbol.prototype.populate = function(
+		/** String */ name,
+		/** Object[] */ params,
+		/** String */ isa,
+		/** JSDOC.DocComment */ comment
+) {
+	this.$args = arguments;
+	
+	this.name = name;
+	this.alias = this.name;
+	
+	this.params = params;
+	this.isa = (isa == "VIRTUAL")? "OBJECT":isa;
+	this.comment = comment || new JSDOC.DocComment("");
+	this.srcFile = JSDOC.Symbol.srcFile;
+	
+	if (this.is("FILE") && !this.alias) this.alias = this.srcFile;
+
+	this.setTags();
+	
+	if (typeof JSDOC.PluginManager != "undefined") {
+		JSDOC.PluginManager.run("onSymbol", this);
+	}
+}
+
+JSDOC.Symbol.prototype.setTags = function() {
+	// @author
+	var authors = this.comment.getTag("author");
+	if (authors.length) {
+		this.author = authors.map(function($){return $.desc;}).join(", ");
+	}
+	
+	/*t:
+		plan(34, "testing JSDOC.Symbol");
+		
+		requires("../lib/JSDOC/DocComment.js");
+		requires("../frame/String.js");
+		requires("../lib/JSDOC/DocTag.js");
+
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@author Joe Smith*"+"/"));
+		is(sym.author, "Joe Smith", "@author tag, author is found.");
+	*/
+	
+	// @desc
+	var descs = this.comment.getTag("desc");
+	if (descs.length) {
+		this.desc = descs.map(function($){return $.desc;}).join("\n"); // multiple descriptions are concatenated into one
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@desc This is a description.*"+"/"));
+		is(sym.desc, "This is a description.", "@desc tag, description is found.");
+	*/
+	
+	// @overview
+	if (this.is("FILE")) {
+		if (!this.alias) this.alias = this.srcFile;
+		
+		var overviews = this.comment.getTag("overview");
+		if (overviews.length) {
+			this.desc = [this.desc].concat(overviews.map(function($){return $.desc;})).join("\n");
+		}
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@overview This is an overview.*"+"/"));
+		is(sym.desc, "\nThis is an overview.", "@overview tag, description is found.");
+	*/
+	
+	// @since
+	var sinces = this.comment.getTag("since");
+	if (sinces.length) {
+		this.since = sinces.map(function($){return $.desc;}).join(", ");
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@since 1.01*"+"/"));
+		is(sym.since, "1.01", "@since tag, description is found.");
+	*/
+	
+	// @constant
+	if (this.comment.getTag("constant").length) {
+		this.isConstant = true;
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@constant*"+"/"));
+		is(sym.isConstant, true, "@constant tag, isConstant set.");
+	*/
+	
+	// @version
+	var versions = this.comment.getTag("version");
+	if (versions.length) {
+		this.version = versions.map(function($){return $.desc;}).join(", ");
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@version 2.0x*"+"/"));
+		is(sym.version, "2.0x", "@version tag, version is found.");
+	*/
+	
+	// @deprecated
+	var deprecateds = this.comment.getTag("deprecated");
+	if (deprecateds.length) {
+		this.deprecated = deprecateds.map(function($){return $.desc;}).join("\n");
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@deprecated Use other method.*"+"/"));
+		is(sym.deprecated, "Use other method.", "@deprecated tag, desc is found.");
+	*/
+	
+	// @example
+	var examples = this.comment.getTag("example");
+	if (examples.length) {
+		this.example = examples.map(
+			// trim trailing whitespace
+			function($) {
+				$.desc = $.desc.replace(/\s+$/, "");
+				return $;
+			}
+		);
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@example This\n  is an example. \n*"+"/"));
+		isnt(typeof sym.example[0], "undefined", "@example tag, creates sym.example array.");
+		is(sym.example[0], "This\n  is an example.", "@example tag, desc is found.");
+	*/
+	
+	// @see
+	var sees = this.comment.getTag("see");
+	if (sees.length) {
+		var thisSee = this.see;
+		sees.map(function($){thisSee.push($.desc);});
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FILE", new JSDOC.DocComment("/**@see The other thing.*"+"/"));
+		is(sym.see, "The other thing.", "@see tag, desc is found.");
+	*/
+	
+	// @class
+	var classes = this.comment.getTag("class");
+	if (classes.length) {
+		this.isa = "CONSTRUCTOR";
+		this.classDesc = classes[0].desc; // desc can't apply to the constructor as there is none.
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@class This describes the class.*"+"/"));
+		is(sym.isa, "CONSTRUCTOR", "@class tag, makes symbol a constructor.");
+		is(sym.classDesc, "This describes the class.", "@class tag, class description is found.");
+	*/
+	
+	// @namespace
+	var namespaces = this.comment.getTag("namespace");
+	if (namespaces.length) {
+		this.classDesc = namespaces[0].desc;
+		this.isNamespace = true;
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@namespace This describes the namespace.*"+"/"));
+		is(sym.classDesc, "This describes the namespace.", "@namespace tag, class description is found.");
+	*/
+	
+	// @param
+	var params = this.comment.getTag("param");
+	if (params.length) {
+		// user-defined params overwrite those with same name defined by the parser
+		var thisParams = this.params;
+
+		if (thisParams.length == 0) { // none exist yet, so just bung all these user-defined params straight in
+			this.params = params;
+		}
+		else { // need to overlay these user-defined params on to existing parser-defined params
+			for (var i = 0, l = params.length; i < l; i++) {
+				if (thisParams[i]) {
+					if (params[i].type) thisParams[i].type = params[i].type;
+					thisParams[i].name = params[i].name;
+					thisParams[i].desc = params[i].desc;
+					thisParams[i].isOptional = params[i].isOptional;
+					thisParams[i].defaultValue = params[i].defaultValue;
+				}
+				else thisParams[i] = params[i];
+			}
+		}
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [{type: "array", name: "pages"}], "FUNCTION", new JSDOC.DocComment("/**Description.*"+"/"));
+		is(sym.params.length, 1, "parser defined param is found.");
+		
+		sym = new JSDOC.Symbol("foo", [], "FUNCTION", new JSDOC.DocComment("/**Description.\n@param {array} pages*"+"/"));
+		is(sym.params.length, 1, "user defined param is found.");
+		is(sym.params[0].type, "array", "user defined param type is found.");
+		is(sym.params[0].name, "pages", "user defined param name is found.");
+		
+		sym = new JSDOC.Symbol("foo", [{type: "array", name: "pages"}], "FUNCTION", new JSDOC.DocComment("/**Description.\n@param {string} uid*"+"/"));
+		is(sym.params.length, 1, "user defined param overwrites parser defined param.");
+		is(sym.params[0].type, "string", "user defined param type overwrites parser defined param type.");
+		is(sym.params[0].name, "uid", "user defined param name overwrites parser defined param name.");
+	
+		sym = new JSDOC.Symbol("foo", [{type: "array", name: "pages"}, {type: "number", name: "count"}], "FUNCTION", new JSDOC.DocComment("/**Description.\n@param {string} uid*"+"/"));
+		is(sym.params.length, 2, "user defined params  overlay parser defined params.");
+		is(sym.params[1].type, "number", "user defined param type overlays parser defined param type.");
+		is(sym.params[1].name, "count", "user defined param name overlays parser defined param name.");
+
+		sym = new JSDOC.Symbol("foo", [], "FUNCTION", new JSDOC.DocComment("/**Description.\n@param {array} pages The pages description.*"+"/"));
+		is(sym.params.length, 1, "user defined param with description is found.");
+		is(sym.params[0].desc, "The pages description.", "user defined param description is found.");
+	*/
+	
+	// @constructor
+	if (this.comment.getTag("constructor").length) {
+		this.isa = "CONSTRUCTOR";
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@constructor*"+"/"));
+		is(sym.isa, "CONSTRUCTOR", "@constructor tag, makes symbol a constructor.");
+	*/
+	
+	// @static
+	if (this.comment.getTag("static").length) {
+		this.isStatic = true;
+		if (this.isa == "CONSTRUCTOR") {
+			this.isNamespace = true;
+		}
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@static\n@constructor*"+"/"));
+		is(sym.isStatic, true, "@static tag, makes isStatic true.");
+		is(sym.isNamespace, true, "@static and @constructor tag, makes isNamespace true.");
+	*/
+	
+	// @inner
+	if (this.comment.getTag("inner").length) {
+		this.isInner = true;
+		this.isStatic = false;
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@inner*"+"/"));
+		is(sym.isStatic, false, "@inner tag, makes isStatic false.");
+		is(sym.isInner, true, "@inner makes isInner true.");
+	*/
+	
+	// @name
+	var names = this.comment.getTag("name");
+	if (names.length) {
+		this.name = names[0].desc;
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @field
+	if (this.comment.getTag("field").length) {
+		this.isa = "OBJECT";
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "FUNCTION", new JSDOC.DocComment("/**@field*"+"/"));
+		is(sym.isa, "OBJECT", "@field tag, makes symbol an object.");
+	*/
+	
+	// @function
+	if (this.comment.getTag("function").length) {
+		this.isa = "FUNCTION";
+		if (/event:/.test(this.alias)) this.isEvent = true;
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@function*"+"/"));
+		is(sym.isa, "FUNCTION", "@function tag, makes symbol a function.");
+	*/
+	
+	// @event
+	var events = this.comment.getTag("event");
+	if (events.length) {
+		this.isa = "FUNCTION";
+		this.isEvent = true;
+		if (!/event:/.test(this.alias))
+			this.alias = this.alias.replace(/^(.*[.#-])([^.#-]+)$/, "$1event:$2");
+	}
+	
+	/*t:
+		var sym = new JSDOC.Symbol("foo", [], "OBJECT", new JSDOC.DocComment("/**@event*"+"/"));
+		is(sym.isa, "FUNCTION", "@event tag, makes symbol a function.");
+		is(sym.isEvent, true, "@event makes isEvent true.");
+	*/
+	
+	// @fires
+	var fires = this.comment.getTag("fires");
+	if (fires.length) {
+		for (var i = 0; i < fires.length; i++) {
+			this.fires.push(fires[i].desc);
+		}
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @property
+	var properties = this.comment.getTag("property");
+	if (properties.length) {
+		thisProperties = this.properties;
+		for (var i = 0; i < properties.length; i++) {
+			var property = new JSDOC.Symbol(this.alias+"#"+properties[i].name, [], "OBJECT", new JSDOC.DocComment("/**"+properties[i].desc+"*/"));
+			// TODO: shouldn't the following happen in the addProperty method of Symbol?
+			if (properties[i].type) property.type = properties[i].type;
+			if (properties[i].defaultValue) property.defaultValue = properties[i].defaultValue;
+			this.addProperty(property);
+			if (!JSDOC.Parser.symbols.getSymbolByName(property.name))
+				JSDOC.Parser.addSymbol(property);
+		}
+	}
+	
+	/*t:
+		// todo
+	*/
+
+	// @return
+	var returns = this.comment.getTag("return");
+	if (returns.length) { // there can be many return tags in a single doclet
+		this.returns = returns;
+		this.type = returns.map(function($){return $.type}).join(", ");
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @exception
+	this.exceptions = this.comment.getTag("throws");
+	
+	/*t:
+		// todo
+	*/
+	
+	// @requires
+	var requires = this.comment.getTag("requires");
+	if (requires.length) {
+		this.requires = requires.map(function($){return $.desc});
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @type
+	var types = this.comment.getTag("type");
+	if (types.length) {
+		this.type = types[0].desc; //multiple type tags are ignored
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @private
+	if (this.comment.getTag("private").length || this.isInner) {
+		this.isPrivate = true;
+	}
+	
+	// @ignore
+	if (this.comment.getTag("ignore").length) {
+		this.isIgnored = true;
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @inherits ... as ...
+	var inherits = this.comment.getTag("inherits");
+	if (inherits.length) {
+		for (var i = 0; i < inherits.length; i++) {
+			if (/^\s*([a-z$0-9_.#:-]+)(?:\s+as\s+([a-z$0-9_.#:-]+))?/i.test(inherits[i].desc)) {
+				var inAlias = RegExp.$1;
+				var inAs = RegExp.$2 || inAlias;
+
+				if (inAlias) inAlias = inAlias.replace(/\.prototype\.?/g, "#");
+				
+				if (inAs) {
+					inAs = inAs.replace(/\.prototype\.?/g, "#");
+					inAs = inAs.replace(/^this\.?/, "#");
+				}
+
+				if (inAs.indexOf(inAlias) != 0) { //not a full namepath
+					var joiner = ".";
+					if (this.alias.charAt(this.alias.length-1) == "#" || inAs.charAt(0) == "#") {
+						joiner = "";
+					}
+					inAs = this.alias + joiner + inAs;
+				}
+			}
+			this.inherits.push({alias: inAlias, as: inAs});
+		}
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @augments
+	this.augments = this.comment.getTag("augments");
+	
+	// @default
+	var defaults = this.comment.getTag("default");
+	if (defaults.length) {
+		if (this.is("OBJECT")) {
+			this.defaultValue = defaults[0].desc;
+		}
+	}
+	
+	/*t:
+		// todo
+	*/
+	
+	// @memberOf
+	var memberOfs = this.comment.getTag("memberOf");
+	if (memberOfs.length) {
+		this.memberOf = memberOfs[0].desc;
+		this.memberOf = this.memberOf.replace(/\.prototype\.?/g, "#");
+	}
+
+	/*t:
+		// todo
+	*/
+	
+	// @public
+	if (this.comment.getTag("public").length) {
+		this.isPrivate = false;
+	}
+	
+	/*t:
+		// todo
+	*/
+		
+	if (JSDOC.PluginManager) {
+		JSDOC.PluginManager.run("onSetTags", this);
+	}
+}
+
+JSDOC.Symbol.prototype.is = function(what) {
+	return this.isa === what;
+}
+
+JSDOC.Symbol.prototype.isBuiltin = function() {
+	return JSDOC.Lang.isBuiltin(this.alias);
+}
+
+JSDOC.Symbol.prototype.setType = function(/**String*/comment, /**Boolean*/overwrite) {
+	if (!overwrite && this.type) return;
+	var typeComment = JSDOC.DocComment.unwrapComment(comment);
+	this.type = typeComment;
+}
+
+JSDOC.Symbol.prototype.inherit = function(symbol) {
+	if (!this.hasMember(symbol.name) && !symbol.isInner) {
+		if (symbol.is("FUNCTION"))
+			this.methods.push(symbol);
+		else if (symbol.is("OBJECT"))
+			this.properties.push(symbol);
+	}
+}
+
+JSDOC.Symbol.prototype.hasMember = function(name) {
+	return (this.hasMethod(name) || this.hasProperty(name));
+}
+
+JSDOC.Symbol.prototype.addMember = function(symbol) {
+	if (symbol.is("FUNCTION")) { this.addMethod(symbol); }
+	else if (symbol.is("OBJECT")) { this.addProperty(symbol); }
+}
+
+JSDOC.Symbol.prototype.hasMethod = function(name) {
+	var thisMethods = this.methods;
+	for (var i = 0, l = thisMethods.length; i < l; i++) {
+		if (thisMethods[i].name == name) return true;
+		if (thisMethods[i].alias == name) return true;
+	}
+	return false;
+}
+
+JSDOC.Symbol.prototype.addMethod = function(symbol) {
+	var methodAlias = symbol.alias;
+	var thisMethods = this.methods;
+	for (var i = 0, l = thisMethods.length; i < l; i++) {
+		if (thisMethods[i].alias == methodAlias) {
+			thisMethods[i] = symbol; // overwriting previous method
+			return;
+		}
+	}
+	thisMethods.push(symbol); // new method with this alias
+}
+
+JSDOC.Symbol.prototype.hasProperty = function(name) {
+	var thisProperties = this.properties;
+	for (var i = 0, l = thisProperties.length; i < l; i++) {
+		if (thisProperties[i].name == name) return true;
+		if (thisProperties[i].alias == name) return true;
+	}
+	return false;
+}
+
+JSDOC.Symbol.prototype.addProperty = function(symbol) {
+	var propertyAlias = symbol.alias;
+	var thisProperties = this.properties;
+	for (var i = 0, l = thisProperties.length; i < l; i++) {
+		if (thisProperties[i].alias == propertyAlias) {
+			thisProperties[i] = symbol; // overwriting previous property
+			return;
+		}
+	}
+
+	thisProperties.push(symbol); // new property with this alias
+}
+
+JSDOC.Symbol.srcFile = ""; //running reference to the current file being parsed

bin/jsdoc/lib/JSDOC/SymbolSet.js

@@ -0,0 +1,243 @@
+/** @constructor */
+JSDOC.SymbolSet = function() {
+	this.init();
+}
+
+JSDOC.SymbolSet.prototype.init = function() {
+	this._index = new Hash();
+}
+
+JSDOC.SymbolSet.prototype.keys = function() {
+	return this._index.keys();
+}
+
+JSDOC.SymbolSet.prototype.hasSymbol = function(alias) {
+	return this._index.hasKey(alias);
+}
+
+JSDOC.SymbolSet.prototype.addSymbol = function(symbol) {
+	if (JSDOC.opt.a && this.hasSymbol(symbol.alias)) {
+		LOG.warn("Overwriting symbol documentation for: " + symbol.alias + ".");
+		this.deleteSymbol(symbol.alias);
+	}
+	this._index.set(symbol.alias, symbol);
+}
+
+JSDOC.SymbolSet.prototype.getSymbol = function(alias) {
+	if (this.hasSymbol(alias)) return this._index.get(alias);
+}
+
+JSDOC.SymbolSet.prototype.getSymbolByName = function(name) {
+	for (var p = this._index.first(); p; p = this._index.next()) {
+		var symbol = p.value;
+		if (symbol.name == name) return symbol;
+	}
+}
+
+JSDOC.SymbolSet.prototype.toArray = function() {
+	return this._index.values();
+}
+
+JSDOC.SymbolSet.prototype.deleteSymbol = function(alias) {
+	if (!this.hasSymbol(alias)) return;
+	this._index.drop(alias);
+}
+
+JSDOC.SymbolSet.prototype.renameSymbol = function(oldName, newName) {
+	// todo: should check if oldname or newname already exist
+	this._index.replace(oldName, newName);
+	this._index.get(newName).alias = newName;
+	return newName;
+}
+
+JSDOC.SymbolSet.prototype.relate = function() {
+	this.resolveBorrows();
+	this.resolveMemberOf();
+	this.resolveAugments();
+}
+
+JSDOC.SymbolSet.prototype.resolveBorrows = function() {
+	for (var p = this._index.first(); p; p = this._index.next()) {
+		var symbol = p.value;
+		if (symbol.is("FILE") || symbol.is("GLOBAL")) continue;
+		
+		var borrows = symbol.inherits;
+		for (var i = 0; i < borrows.length; i++) {
+		
+if (/#$/.test(borrows[i].alias)) {
+	LOG.warn("Attempted to borrow entire instance of "+borrows[i].alias+" but that feature is not yet implemented.");
+	return;
+}
+			var borrowed = this.getSymbol(borrows[i].alias);
+			
+			if (!borrowed) {
+				LOG.warn("Can't borrow undocumented "+borrows[i].alias+".");
+				continue;
+			}
+
+			if (borrows[i].as == borrowed.alias) {
+				var assumedName = borrowed.name.split(/([#.-])/).pop();
+				borrows[i].as = symbol.name+RegExp.$1+assumedName;
+				LOG.inform("Assuming borrowed as name is "+borrows[i].as+" but that feature is experimental.");
+			}
+			
+			var borrowAsName = borrows[i].as;
+			var borrowAsAlias = borrowAsName;
+			if (!borrowAsName) {
+				LOG.warn("Malformed @borrow, 'as' is required.");
+				continue;
+			}
+			
+			if (borrowAsName.length > symbol.alias.length && borrowAsName.indexOf(symbol.alias) == 0) {
+				borrowAsName = borrowAsName.replace(borrowed.alias, "")
+			}
+			else {
+				var joiner = "";
+				if (borrowAsName.charAt(0) != "#") joiner = ".";
+				borrowAsAlias = borrowed.alias + joiner + borrowAsName;
+			}
+			
+			borrowAsName = borrowAsName.replace(/^[#.]/, "");
+					
+			if (this.hasSymbol(borrowAsAlias)) continue;
+
+			var clone = borrowed.clone();
+			clone.name = borrowAsName;
+			clone.alias = borrowAsAlias;
+			this.addSymbol(clone);
+		}
+	}
+}
+
+JSDOC.SymbolSet.prototype.resolveMemberOf = function() {
+	for (var p = this._index.first(); p; p = this._index.next()) {
+		var symbol = p.value;
+
+		if (symbol.is("FILE") || symbol.is("GLOBAL")) continue;
+		
+		// the memberOf value was provided in the @memberOf tag
+		else if (symbol.memberOf) {			
+			// like foo.bar is a memberOf foo
+			if (symbol.alias.indexOf(symbol.memberOf) == 0) {
+				var memberMatch = new RegExp("^("+symbol.memberOf+")[.#-]?(.+)$");
+				var aliasParts = symbol.alias.match(memberMatch);
+				
+				if (aliasParts) {
+					symbol.memberOf = aliasParts[1];
+					symbol.name = aliasParts[2];
+				}
+				
+				var nameParts = symbol.name.match(memberMatch);
+
+				if (nameParts) {
+					symbol.name = nameParts[2];
+				}
+			}
+			// like bar is a memberOf foo
+			else {
+				var joiner = symbol.memberOf.charAt(symbol.memberOf.length-1);
+				if (!/[.#-]/.test(joiner)) symbol.memberOf += ".";
+				this.renameSymbol(symbol.alias, symbol.memberOf + symbol.name);
+			}
+		}
+		// the memberOf must be calculated
+		else {
+			var parts = symbol.alias.match(/^(.*[.#-])([^.#-]+)$/);
+
+			if (parts) {
+				symbol.memberOf = parts[1];
+				symbol.name = parts[2];				
+			}
+		}
+
+		// set isStatic, isInner
+		if (symbol.memberOf) {
+			switch (symbol.memberOf.charAt(symbol.memberOf.length-1)) {
+				case '#' :
+					symbol.isStatic = false;
+					symbol.isInner = false;
+				break;
+				case '.' :
+					symbol.isStatic = true;
+					symbol.isInner = false;
+				break;
+				case '-' :
+					symbol.isStatic = false;
+					symbol.isInner = true;
+				break;
+				default: // memberOf ends in none of the above
+					symbol.isStatic = true;
+				break;
+			}
+		}
+		
+		// unowned methods and fields belong to the global object
+		if (!symbol.is("CONSTRUCTOR") && !symbol.isNamespace && symbol.memberOf == "") {
+			symbol.memberOf = "_global_";
+		}
+
+		// clean up
+		if (symbol.memberOf.match(/[.#-]$/)) {
+			symbol.memberOf = symbol.memberOf.substr(0, symbol.memberOf.length-1);
+		}
+		// add to parent's methods or properties list
+		if (symbol.memberOf) {
+
+			var container = this.getSymbol(symbol.memberOf);
+			if (!container) {
+				if (JSDOC.Lang.isBuiltin(symbol.memberOf)) container = JSDOC.Parser.addBuiltin(symbol.memberOf);
+				else {
+					LOG.warn("Trying to document "+symbol.name +" as a member of undocumented symbol "+symbol.memberOf+".");
+				}
+			}
+			
+			if (container) container.addMember(symbol);
+		}
+	}
+}
+
+JSDOC.SymbolSet.prototype.resolveAugments = function() {
+	for (var p = this._index.first(); p; p = this._index.next()) {
+		var symbol = p.value;
+		
+		if (symbol.alias == "_global_" || symbol.is("FILE")) continue;
+		JSDOC.SymbolSet.prototype.walk.apply(this, [symbol]);
+	}
+}
+
+JSDOC.SymbolSet.prototype.walk = function(symbol) {
+	var augments = symbol.augments;
+	for(var i = 0; i < augments.length; i++) {
+		var contributer = this.getSymbol(augments[i]);
+		if (!contributer && JSDOC.Lang.isBuiltin(''+augments[i])) {
+			contributer = new JSDOC.Symbol("_global_."+augments[i], [], augments[i], new JSDOC.DocComment("Built in."));
+			contributer.isNamespace = true;
+			contributer.srcFile = "";
+			contributer.isPrivate = false;
+			JSDOC.Parser.addSymbol(contributer);
+		}
+		
+		if (contributer) {			
+			if (contributer.augments.length) {
+				JSDOC.SymbolSet.prototype.walk.apply(this, [contributer]);
+			}
+			
+			symbol.inheritsFrom.push(contributer.alias);
+			//if (!isUnique(symbol.inheritsFrom)) {
+			//	LOG.warn("Can't resolve augments: Circular reference: "+symbol.alias+" inherits from "+contributer.alias+" more than once.");
+			//}
+			//else {
+				var cmethods = contributer.methods;
+				var cproperties = contributer.properties;
+				
+				for (var ci = 0, cl = cmethods.length; ci < cl; ci++) {
+					if (!cmethods[ci].isStatic) symbol.inherit(cmethods[ci]);
+				}
+				for (var ci = 0, cl = cproperties.length; ci < cl; ci++) {
+					if (!cproperties[ci].isStatic) symbol.inherit(cproperties[ci]);
+				}	
+			//}
+		}
+		else LOG.warn("Can't augment contributer: "+augments[i]+", not found.");
+	}
+}

bin/jsdoc/lib/JSDOC/TextStream.js

@@ -0,0 +1,41 @@
+
+/**
+	@constructor
+*/
+JSDOC.TextStream = function(text) {
+	if (typeof(text) == "undefined") text = "";
+	text = ""+text;
+	this.text = text;
+	this.cursor = 0;
+}
+
+JSDOC.TextStream.prototype.look = function(n) {
+	if (typeof n == "undefined") n = 0;
+	
+	if (this.cursor+n < 0 || this.cursor+n >= this.text.length) {
+		var result = new String("");
+		result.eof = true;
+		return result;
+	}
+	return this.text.charAt(this.cursor+n);
+}
+
+JSDOC.TextStream.prototype.next = function(n) {
+	if (typeof n == "undefined") n = 1;
+	if (n < 1) return null;
+	
+	var pulled = "";
+	for (var i = 0; i < n; i++) {
+		if (this.cursor+i < this.text.length) {
+			pulled += this.text.charAt(this.cursor+i);
+		}
+		else {
+			var result = new String("");
+			result.eof = true;
+			return result;
+		}
+	}
+
+	this.cursor += n;
+	return pulled;
+}

bin/jsdoc/lib/JSDOC/Token.js

@@ -0,0 +1,18 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@constructor
+*/
+JSDOC.Token = function(data, type, name) {
+	this.data = data;
+	this.type = type;
+	this.name = name;
+}
+
+JSDOC.Token.prototype.toString = function() { 
+	return "<"+this.type+" name=\""+this.name+"\">"+this.data+"</"+this.type+">";
+}
+
+JSDOC.Token.prototype.is = function(what) {
+	return this.name === what || this.type === what;
+}

bin/jsdoc/lib/JSDOC/TokenReader.js

@@ -0,0 +1,332 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@class Search a {@link JSDOC.TextStream} for language tokens.
+*/
+JSDOC.TokenReader = function() {
+	this.keepDocs = true;
+	this.keepWhite = false;
+	this.keepComments = false;
+}
+
+/**
+	@type {JSDOC.Token[]}
+ */
+JSDOC.TokenReader.prototype.tokenize = function(/**JSDOC.TextStream*/stream) {
+	var tokens = [];
+	/**@ignore*/ tokens.last    = function() { return tokens[tokens.length-1]; }
+	/**@ignore*/ tokens.lastSym = function() {
+		for (var i = tokens.length-1; i >= 0; i--) {
+			if (!(tokens[i].is("WHIT") || tokens[i].is("COMM"))) return tokens[i];
+		}
+	}
+
+	while (!stream.look().eof) {
+		if (this.read_mlcomment(stream, tokens)) continue;
+		if (this.read_slcomment(stream, tokens)) continue;
+		if (this.read_dbquote(stream, tokens))   continue;
+		if (this.read_snquote(stream, tokens))   continue;
+		if (this.read_regx(stream, tokens))      continue;
+		if (this.read_numb(stream, tokens))      continue;
+		if (this.read_punc(stream, tokens))      continue;
+		if (this.read_newline(stream, tokens))   continue;
+		if (this.read_space(stream, tokens))     continue;
+		if (this.read_word(stream, tokens))      continue;
+		
+		// if execution reaches here then an error has happened
+		tokens.push(new JSDOC.Token(stream.next(), "TOKN", "UNKNOWN_TOKEN"));
+	}
+	return tokens;
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_word = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found = "";
+	while (!stream.look().eof && JSDOC.Lang.isWordChar(stream.look())) {
+		found += stream.next();
+	}
+	
+	if (found === "") {
+		return false;
+	}
+	else {
+		var name;
+		if ((name = JSDOC.Lang.keyword(found))) tokens.push(new JSDOC.Token(found, "KEYW", name));
+		else tokens.push(new JSDOC.Token(found, "NAME", "NAME"));
+		return true;
+	}
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_punc = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found = "";
+	var name;
+	while (!stream.look().eof && JSDOC.Lang.punc(found+stream.look())) {
+		found += stream.next();
+	}
+	
+	if (found === "") {
+		return false;
+	}
+	else {
+		tokens.push(new JSDOC.Token(found, "PUNC", JSDOC.Lang.punc(found)));
+		return true;
+	}
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_space = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found = "";
+	
+	while (!stream.look().eof && JSDOC.Lang.isSpace(stream.look())) {
+		found += stream.next();
+	}
+	
+	if (found === "") {
+		return false;
+	}
+	else {
+		if (this.collapseWhite) found = " ";
+		if (this.keepWhite) tokens.push(new JSDOC.Token(found, "WHIT", "SPACE"));
+		return true;
+	}
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_newline = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found = "";
+	
+	while (!stream.look().eof && JSDOC.Lang.isNewline(stream.look())) {
+		found += stream.next();
+	}
+	
+	if (found === "") {
+		return false;
+	}
+	else {
+		if (this.collapseWhite) found = "\n";
+		if (this.keepWhite) tokens.push(new JSDOC.Token(found, "WHIT", "NEWLINE"));
+		return true;
+	}
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_mlcomment = function(/**JSDOC.TokenStream*/stream, tokens) {
+	if (stream.look() == "/" && stream.look(1) == "*") {
+		var found = stream.next(2);
+		
+		while (!stream.look().eof && !(stream.look(-1) == "/" && stream.look(-2) == "*")) {
+			found += stream.next();
+		}
+		
+		// to start doclet we allow /** or /*** but not /**/ or /****
+		if (/^\/\*\*([^\/]|\*[^*])/.test(found) && this.keepDocs) tokens.push(new JSDOC.Token(found, "COMM", "JSDOC"));
+		else if (this.keepComments) tokens.push(new JSDOC.Token(found, "COMM", "MULTI_LINE_COMM"));
+		return true;
+	}
+	return false;
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_slcomment = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found;
+	if (
+		(stream.look() == "/" && stream.look(1) == "/" && (found=stream.next(2)))
+		|| 
+		(stream.look() == "<" && stream.look(1) == "!" && stream.look(2) == "-" && stream.look(3) == "-" && (found=stream.next(4)))
+	) {
+		
+		while (!stream.look().eof && !JSDOC.Lang.isNewline(stream.look())) {
+			found += stream.next();
+		}
+		
+		if (this.keepComments) {
+			tokens.push(new JSDOC.Token(found, "COMM", "SINGLE_LINE_COMM"));
+		}
+		return true;
+	}
+	return false;
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_dbquote = function(/**JSDOC.TokenStream*/stream, tokens) {
+	if (stream.look() == "\"") {
+		// find terminator
+		var string = stream.next();
+		
+		while (!stream.look().eof) {
+			if (stream.look() == "\\") {
+				if (JSDOC.Lang.isNewline(stream.look(1))) {
+					do {
+						stream.next();
+					} while (!stream.look().eof && JSDOC.Lang.isNewline(stream.look()));
+					string += "\\\n";
+				}
+				else {
+					string += stream.next(2);
+				}
+			}
+			else if (stream.look() == "\"") {
+				string += stream.next();
+				tokens.push(new JSDOC.Token(string, "STRN", "DOUBLE_QUOTE"));
+				return true;
+			}
+			else {
+				string += stream.next();
+			}
+		}
+	}
+	return false; // error! unterminated string
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_snquote = function(/**JSDOC.TokenStream*/stream, tokens) {
+	if (stream.look() == "'") {
+		// find terminator
+		var string = stream.next();
+		
+		while (!stream.look().eof) {
+			if (stream.look() == "\\") { // escape sequence
+				string += stream.next(2);
+			}
+			else if (stream.look() == "'") {
+				string += stream.next();
+				tokens.push(new JSDOC.Token(string, "STRN", "SINGLE_QUOTE"));
+				return true;
+			}
+			else {
+				string += stream.next();
+			}
+		}
+	}
+	return false; // error! unterminated string
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_numb = function(/**JSDOC.TokenStream*/stream, tokens) {
+	if (stream.look() === "0" && stream.look(1) == "x") {
+		return this.read_hex(stream, tokens);
+	}
+	
+	var found = "";
+	
+	while (!stream.look().eof && JSDOC.Lang.isNumber(found+stream.look())){
+		found += stream.next();
+	}
+	
+	if (found === "") {
+		return false;
+	}
+	else {
+		if (/^0[0-7]/.test(found)) tokens.push(new JSDOC.Token(found, "NUMB", "OCTAL"));
+		else tokens.push(new JSDOC.Token(found, "NUMB", "DECIMAL"));
+		return true;
+	}
+}
+/*t:
+	requires("../lib/JSDOC/TextStream.js");
+	requires("../lib/JSDOC/Token.js");
+	requires("../lib/JSDOC/Lang.js");
+	
+	plan(3, "testing JSDOC.TokenReader.prototype.read_numb");
+	
+	//// setup
+	var src = "function foo(num){while (num+8.0 >= 0x20 && num < 0777){}}";
+	var tr = new JSDOC.TokenReader();
+	var tokens = tr.tokenize(new JSDOC.TextStream(src));
+	
+	var hexToken, octToken, decToken;
+	for (var i = 0; i < tokens.length; i++) {
+		if (tokens[i].name == "HEX_DEC") hexToken = tokens[i];
+		if (tokens[i].name == "OCTAL") octToken = tokens[i];
+		if (tokens[i].name == "DECIMAL") decToken = tokens[i];
+	}
+	////
+	
+	is(decToken.data, "8.0", "decimal number is found in source.");
+	is(hexToken.data, "0x20", "hexdec number is found in source (issue #99).");
+	is(octToken.data, "0777", "octal number is found in source.");
+*/
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_hex = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var found = stream.next(2);
+	
+	while (!stream.look().eof) {
+		if (JSDOC.Lang.isHexDec(found) && !JSDOC.Lang.isHexDec(found+stream.look())) { // done
+			tokens.push(new JSDOC.Token(found, "NUMB", "HEX_DEC"));
+			return true;
+		}
+		else {
+			found += stream.next();
+		}
+	}
+	return false;
+}
+
+/**
+	@returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_regx = function(/**JSDOC.TokenStream*/stream, tokens) {
+	var last;
+	if (
+		stream.look() == "/"
+		&& 
+		(
+			
+			(
+				!(last = tokens.lastSym()) // there is no last, the regex is the first symbol
+				|| 
+				(
+					   !last.is("NUMB")
+					&& !last.is("NAME")
+					&& !last.is("RIGHT_PAREN")
+					&& !last.is("RIGHT_BRACKET")
+				)
+			)
+		)
+	) {
+		var regex = stream.next();
+		
+		while (!stream.look().eof) {
+			if (stream.look() == "\\") { // escape sequence
+				regex += stream.next(2);
+			}
+			else if (stream.look() == "/") {
+				regex += stream.next();
+				
+				while (/[gmi]/.test(stream.look())) {
+					regex += stream.next();
+				}
+				
+				tokens.push(new JSDOC.Token(regex, "REGX", "REGX"));
+				return true;
+			}
+			else {
+				regex += stream.next();
+			}
+		}
+		// error: unterminated regex
+	}
+	return false;
+}

bin/jsdoc/lib/JSDOC/TokenStream.js

@@ -0,0 +1,133 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@constructor
+*/
+JSDOC.TokenStream = function(tokens) {
+	this.tokens = (tokens || []);
+	this.rewind();
+}
+
+/**
+	@constructor
+	@private
+*/
+function VoidToken(/**String*/type) {
+	this.toString = function() {return "<VOID type=\""+type+"\">"};
+	this.is = function(){return false;}
+}
+
+JSDOC.TokenStream.prototype.rewind = function() {
+	this.cursor = -1;
+}
+
+/**
+	@type JSDOC.Token
+*/
+JSDOC.TokenStream.prototype.look = function(/**Number*/n, /**Boolean*/considerWhitespace) {
+	if (typeof n == "undefined") n = 0;
+
+	if (considerWhitespace == true) {
+		if (this.cursor+n < 0 || this.cursor+n > this.tokens.length) return {};
+		return this.tokens[this.cursor+n];
+	}
+	else {
+		var count = 0;
+		var i = this.cursor;
+
+		while (true) {
+			if (i < 0) return new JSDOC.Token("", "VOID", "START_OF_STREAM");
+			else if (i > this.tokens.length) return new JSDOC.Token("", "VOID", "END_OF_STREAM");
+
+			if (i != this.cursor && (this.tokens[i] === undefined || this.tokens[i].is("WHIT"))) {
+				if (n < 0) i--; else i++;
+				continue;
+			}
+			
+			if (count == Math.abs(n)) {
+				return this.tokens[i];
+			}
+			count++;
+			(n < 0)? i-- : i++;
+		}
+
+		return new JSDOC.Token("", "VOID", "STREAM_ERROR"); // because null isn't an object and caller always expects an object
+	}
+}
+
+/**
+	@type JSDOC.Token|JSDOC.Token[]
+*/
+JSDOC.TokenStream.prototype.next = function(/**Number*/howMany) {
+	if (typeof howMany == "undefined") howMany = 1;
+	if (howMany < 1) return null;
+	var got = [];
+
+	for (var i = 1; i <= howMany; i++) {
+		if (this.cursor+i >= this.tokens.length) {
+			return null;
+		}
+		got.push(this.tokens[this.cursor+i]);
+	}
+	this.cursor += howMany;
+
+	if (howMany == 1) {
+		return got[0];
+	}
+	else return got;
+}
+
+/**
+	@type JSDOC.Token[]
+*/
+JSDOC.TokenStream.prototype.balance = function(/**String*/start, /**String*/stop) {
+	if (!stop) stop = JSDOC.Lang.matching(start);
+	
+	var depth = 0;
+	var got = [];
+	var started = false;
+	
+	while ((token = this.look())) {
+		if (token.is(start)) {
+			depth++;
+			started = true;
+		}
+		
+		if (started) {
+			got.push(token);
+		}
+		
+		if (token.is(stop)) {
+			depth--;
+			if (depth == 0) return got;
+		}
+		if (!this.next()) break;
+	}
+}
+
+JSDOC.TokenStream.prototype.getMatchingToken = function(/**String*/start, /**String*/stop) {
+	var depth = 0;
+	var cursor = this.cursor;
+	
+	if (!start) {
+		start = JSDOC.Lang.matching(stop);
+		depth = 1;
+	}
+	if (!stop) stop = JSDOC.Lang.matching(start);
+	
+	while ((token = this.tokens[cursor])) {
+		if (token.is(start)) {
+			depth++;
+		}
+		
+		if (token.is(stop) && cursor) {
+			depth--;
+			if (depth == 0) return this.tokens[cursor];
+		}
+		cursor++;
+	}
+}
+
+JSDOC.TokenStream.prototype.insertAhead = function(/**JSDOC.Token*/token) {
+	this.tokens.splice(this.cursor+1, 0, token);
+}

bin/jsdoc/lib/JSDOC/Util.js

@@ -0,0 +1,32 @@
+/**
+ * @namespace
+ * @deprecated Use {@link FilePath} instead.
+ */
+JSDOC.Util = {
+}
+
+/**
+ * @deprecated Use {@link FilePath.fileName} instead.
+ */
+JSDOC.Util.fileName = function(path) {
+	LOG.warn("JSDOC.Util.fileName is deprecated. Use FilePath.fileName instead.");
+	var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+	return path.substring(nameStart);
+}
+
+/**
+ * @deprecated Use {@link FilePath.fileExtension} instead.
+ */
+JSDOC.Util.fileExtension = function(filename) {
+	LOG.warn("JSDOC.Util.fileExtension is deprecated. Use FilePath.fileExtension instead.");
+	return filename.split(".").pop().toLowerCase();
+};
+
+/**
+ * @deprecated Use {@link FilePath.dir} instead.
+ */
+JSDOC.Util.dir = function(path) {
+	LOG.warn("JSDOC.Util.dir is deprecated. Use FilePath.dir instead.");
+	var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+	return path.substring(0, nameStart-1);
+}

bin/jsdoc/lib/JSDOC/Walker.js

@@ -0,0 +1,507 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/** @constructor */
+JSDOC.Walker = function(/**JSDOC.TokenStream*/ts) {
+	this.init();
+	if (typeof ts != "undefined") {
+		this.walk(ts);
+	}
+}
+
+JSDOC.Walker.prototype.init = function() {
+	this.ts = null;
+
+	var globalSymbol = new JSDOC.Symbol("_global_", [], "GLOBAL", new JSDOC.DocComment(""));
+	globalSymbol.isNamespace = true;
+	globalSymbol.srcFile = "";
+	globalSymbol.isPrivate = false;
+	JSDOC.Parser.addSymbol(globalSymbol);
+	this.lastDoc = null;
+	this.token = null;
+	
+	/**
+		The chain of symbols under which we are currently nested.
+		@type Array
+	*/
+	this.namescope = [globalSymbol];
+	this.namescope.last = function(n){ if (!n) n = 0; return this[this.length-(1+n)] || "" };
+}
+
+JSDOC.Walker.prototype.walk = function(/**JSDOC.TokenStream*/ts) {
+	this.ts = ts;
+	while (this.token = this.ts.look()) {
+		if (this.token.popNamescope) {
+			
+			var symbol = this.namescope.pop();
+			if (symbol.is("FUNCTION")) {
+				if (this.ts.look(1).is("LEFT_PAREN") && symbol.comment.getTag("function").length == 0) {
+					symbol.isa = "OBJECT";
+				}
+			}
+		}
+		this.step();
+		if (!this.ts.next()) break;
+	}
+}
+
+JSDOC.Walker.prototype.step = function() {
+	if (this.token.is("JSDOC")) { // it's a doc comment
+	
+		var doc = new JSDOC.DocComment(this.token.data);
+		
+				
+		if (doc.getTag("exports").length > 0) {
+			var exports = doc.getTag("exports")[0];
+
+			exports.desc.match(/(\S+) as (\S+)/i);
+			var n1 = RegExp.$1;
+			var n2 = RegExp.$2;
+			
+			if (!n1 && n2) throw "@exports tag requires a value like: 'name as ns.name'";
+			
+			JSDOC.Parser.rename = (JSDOC.Parser.rename || {});	
+			JSDOC.Parser.rename[n1] = n2
+		}
+		
+		if (doc.getTag("lends").length > 0) {
+			var lends = doc.getTag("lends")[0];
+
+			var name = lends.desc
+			if (!name) throw "@lends tag requires a value.";
+			
+			var symbol = new JSDOC.Symbol(name, [], "OBJECT", doc);
+			
+			this.namescope.push(symbol);
+			
+			var matching = this.ts.getMatchingToken("LEFT_CURLY");
+			if (matching) matching.popNamescope = name;
+			else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			
+			this.lastDoc = null;
+			return true;
+		}
+		else if (doc.getTag("name").length > 0 && doc.getTag("overview").length == 0) { // it's a virtual symbol
+			var virtualName = doc.getTag("name")[0].desc;
+			if (!virtualName) throw "@name tag requires a value.";
+			
+			if (doc.getTag("memberOf").length > 0) {
+				virtualName = (doc.getTag("memberOf")[0] + "." + virtualName)
+					.replace(/([#.])\./, "$1");
+				doc.deleteTag("memberOf");
+			}
+
+			var symbol = new JSDOC.Symbol(virtualName, [], "VIRTUAL", doc);
+			
+			JSDOC.Parser.addSymbol(symbol);
+			
+			this.lastDoc = null;
+			return true;
+		}
+		else if (doc.meta) { // it's a meta doclet
+			if (doc.meta == "@+") JSDOC.DocComment.shared = doc.src;
+			else if (doc.meta == "@-") JSDOC.DocComment.shared = "";
+			else if (doc.meta == "nocode+") JSDOC.Parser.conf.ignoreCode = true;
+			else if (doc.meta == "nocode-") JSDOC.Parser.conf.ignoreCode = JSDOC.opt.n;
+			else throw "Unrecognized meta comment: "+doc.meta;
+			
+			this.lastDoc = null;
+			return true;
+		}
+		else if (doc.getTag("overview").length > 0) { // it's a file overview
+			symbol = new JSDOC.Symbol("", [], "FILE", doc);
+			
+			JSDOC.Parser.addSymbol(symbol);
+			
+			this.lastDoc = null;
+			return true;
+		}
+		else {
+			this.lastDoc = doc;
+			return false;
+		}
+	}
+	else if (!JSDOC.Parser.conf.ignoreCode) { // it's code
+		if (this.token.is("NAME")) { // it's the name of something
+			var symbol;
+			var name = this.token.data;
+			var doc = null; if (this.lastDoc) doc = this.lastDoc;
+			var params = [];
+		
+			// it's inside an anonymous object
+			if (this.ts.look(1).is("COLON") && this.ts.look(-1).is("LEFT_CURLY") && !(this.ts.look(-2).is("JSDOC") || this.namescope.last().comment.getTag("lends").length || this.ts.look(-2).is("ASSIGN") || this.ts.look(-2).is("COLON"))) {
+				name = "$anonymous";
+				name = this.namescope.last().alias+"-"+name
+					
+				params = [];
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+
+				JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken(null, "RIGHT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// function foo() {}
+			else if (this.ts.look(-1).is("FUNCTION") && this.ts.look(1).is("LEFT_PAREN")) {
+				var isInner;
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				if (doc && doc.getTag("memberOf").length > 0) {
+					name = (doc.getTag("memberOf")[0]+"."+name).replace("#.", "#");
+					doc.deleteTag("memberOf");
+				}
+				else {
+					name = this.namescope.last().alias+"-"+name;
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				}
+				
+				if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				
+				params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+
+				symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+				if (isInner) symbol.isInner = true;
+
+				if (this.ts.look(1).is("JSDOC")) {
+					var inlineReturn = ""+this.ts.look(1).data;
+					inlineReturn = inlineReturn.replace(/(^\/\*\* *| *\*\/$)/g, "");
+					symbol.type = inlineReturn;
+				}
+				
+				JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// foo = function() {}
+			else if (this.ts.look(1).is("ASSIGN") && this.ts.look(2).is("FUNCTION")) {
+				var constructs;
+				var isConstructor = false;
+				if (doc && (constructs = doc.getTag("constructs")) && constructs.length) {
+					if (constructs[0].desc) {
+						name = constructs[0].desc;
+						isConstructor = true;
+					}
+				}
+					
+				var isInner;
+				if (this.ts.look(-1).is("VAR") || this.isInner) {
+					if (doc && doc.getTag("memberOf").length > 0) {
+						name = (doc.getTag("memberOf")[0]+"."+name).replace("#.", "#");
+						doc.deleteTag("memberOf");
+					}
+					else {
+						name = this.namescope.last().alias+"-"+name;
+						if (!this.namescope.last().is("GLOBAL")) isInner = true;
+					}
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				}
+				else if (name.indexOf("this.") == 0) {
+					name = this.resolveThis(name);
+				}
+
+				if (this.lastDoc) doc = this.lastDoc;
+				params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+				
+				symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+
+				if (isInner) symbol.isInner = true;
+				if (isConstructor) symbol.isa = "CONSTRUCTOR";
+				
+				if (this.ts.look(1).is("JSDOC")) {
+					var inlineReturn = ""+this.ts.look(1).data;
+					inlineReturn = inlineReturn.replace(/(^\/\*\* *| *\*\/$)/g, "");
+					symbol.type = inlineReturn;
+				}
+
+				JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// foo = new function() {} or foo = (function() {}
+			else if (this.ts.look(1).is("ASSIGN") && (this.ts.look(2).is("NEW") || this.ts.look(2).is("LEFT_PAREN")) && this.ts.look(3).is("FUNCTION")) {
+				var isInner;
+				if (this.ts.look(-1).is("VAR") || this.isInner) {
+					name = this.namescope.last().alias+"-"+name
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				}
+				else if (name.indexOf("this.") == 0) {
+					name = this.resolveThis(name);
+				}
+
+				this.ts.next(3); // advance past the "new" or "("
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+				if (isInner) symbol.isInner = true;
+				
+				if (this.ts.look(1).is("JSDOC")) {
+					var inlineReturn = ""+this.ts.look(1).data;
+					inlineReturn = inlineReturn.replace(/(^\/\*\* *| *\*\/$)/g, "");
+					symbol.type = inlineReturn;
+				}
+				
+				JSDOC.Parser.addSymbol(symbol);
+				
+				symbol.scopeType = "INSTANCE";
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// foo: function() {}
+			else if (this.ts.look(1).is("COLON") && this.ts.look(2).is("FUNCTION")) {
+				name = (this.namescope.last().alias+"."+name).replace("#.", "#");
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+				
+				if (doc && doc.getTag("constructs").length) {
+					name = name.replace(/\.prototype(\.|$)/, "#");
+					
+					if (name.indexOf("#") > -1) name = name.match(/(^[^#]+)/)[0];
+					else name = this.namescope.last().alias;
+
+					symbol = new JSDOC.Symbol(name, params, "CONSTRUCTOR", doc);
+				}
+				else {
+					symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+				}
+				
+				if (this.ts.look(1).is("JSDOC")) {
+					var inlineReturn = ""+this.ts.look(1).data;
+					inlineReturn = inlineReturn.replace(/(^\/\*\* *| *\*\/$)/g, "");
+					symbol.type = inlineReturn;
+				}
+				
+				JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// foo = {}
+			else if (this.ts.look(1).is("ASSIGN") && this.ts.look(2).is("LEFT_CURLY")) {
+				var isInner;
+				if (this.ts.look(-1).is("VAR") || this.isInner) {
+					name = this.namescope.last().alias+"-"+name
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				}
+				else if (name.indexOf("this.") == 0) {
+					name = this.resolveThis(name);
+				}
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+				if (isInner) symbol.isInner = true;
+				
+			
+				if (doc) JSDOC.Parser.addSymbol(symbol);
+
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// var foo;
+			else if (this.ts.look(1).is("SEMICOLON")) {
+				var isInner;
+
+				if (this.ts.look(-1).is("VAR") || this.isInner) {
+					name = this.namescope.last().alias+"-"+name
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+					
+					if (this.lastDoc) doc = this.lastDoc;
+				
+					symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+					if (isInner) symbol.isInner = true;
+					
+				
+					if (doc) JSDOC.Parser.addSymbol(symbol);
+				}
+			}
+			// foo = x
+			else if (this.ts.look(1).is("ASSIGN")) {				
+				var isInner;
+				if (this.ts.look(-1).is("VAR") || this.isInner) {
+					name = this.namescope.last().alias+"-"+name
+					if (!this.namescope.last().is("GLOBAL")) isInner = true;
+				}
+				else if (name.indexOf("this.") == 0) {
+					name = this.resolveThis(name);
+				}
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+				if (isInner) symbol.isInner = true;
+				
+			
+				if (doc) JSDOC.Parser.addSymbol(symbol);
+			}
+			// foo: {}
+			else if (this.ts.look(1).is("COLON") && this.ts.look(2).is("LEFT_CURLY")) {
+				name = (this.namescope.last().alias+"."+name).replace("#.", "#");
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+				
+			
+				if (doc) JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+			// foo: x
+			else if (this.ts.look(1).is("COLON")) {
+				name = (this.namescope.last().alias+"."+name).replace("#.", "#");;
+				
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+				
+			
+				if (doc) JSDOC.Parser.addSymbol(symbol);
+			}
+			// foo(...)
+			else if (this.ts.look(1).is("LEFT_PAREN")) {
+				if (typeof JSDOC.PluginManager != "undefined") {
+					var functionCall = {name: name};
+				
+					var cursor = this.ts.cursor;
+					params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+					this.ts.cursor = cursor;
+					
+					for (var i = 0; i < params.length; i++)
+						functionCall["arg" + (i + 1)] = params[i].name;
+				
+					JSDOC.PluginManager.run("onFunctionCall", functionCall);
+					if (functionCall.doc) {
+						this.ts.insertAhead(new JSDOC.Token(functionCall.doc, "COMM", "JSDOC"));
+					}
+				}
+			}
+			this.lastDoc = null;
+		}
+		else if (this.token.is("FUNCTION")) { // it's an anonymous function
+			if (
+				(!this.ts.look(-1).is("COLON") || !this.ts.look(-1).is("ASSIGN"))
+				&& !this.ts.look(1).is("NAME")
+			) {
+				if (this.lastDoc) doc = this.lastDoc;
+				
+				name = "$anonymous";
+				name = this.namescope.last().alias+"-"+name
+				
+				params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+				
+				symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+				
+				JSDOC.Parser.addSymbol(symbol);
+				
+				this.namescope.push(symbol);
+				
+				var matching = this.ts.getMatchingToken("LEFT_CURLY");
+				if (matching) matching.popNamescope = name;
+				else LOG.warn("Mismatched } character. Can't parse code in file " + symbol.srcFile + ".");
+			}
+		}
+	}
+	return true;
+}
+
+/**
+	Resolves what "this." means when it appears in a name.
+	@param name The name that starts with "this.".
+	@returns The name with "this." resolved.
+ */
+JSDOC.Walker.prototype.resolveThis = function(name) {
+	name.match(/^this\.(.+)$/)
+	var nameFragment = RegExp.$1;
+	if (!nameFragment) return name;
+	
+	var symbol = this.namescope.last();
+	var scopeType = symbol.scopeType || symbol.isa;
+
+	// if we are in a constructor function, `this` means the instance
+	if (scopeType == "CONSTRUCTOR") {
+		name = symbol.alias+"#"+nameFragment;
+	}
+	
+	// if we are in an anonymous constructor function, `this` means the instance
+	else if (scopeType == "INSTANCE") {
+		name = symbol.alias+"."+nameFragment;
+	}
+	
+	// if we are in a function, `this` means the container (possibly the global)
+	else if (scopeType == "FUNCTION") {
+		// in a method of a prototype, so `this` means the constructor
+		if (symbol.alias.match(/(^.*)[#.-][^#.-]+/)) {
+			var parentName = RegExp.$1;
+			var parent = JSDOC.Parser.symbols.getSymbol(parentName);
+
+			if (!parent) {
+				if (JSDOC.Lang.isBuiltin(parentName)) parent = JSDOC.Parser.addBuiltin(parentName);
+				else {
+					if (symbol.alias.indexOf("$anonymous") < 0) // these will be ignored eventually
+						LOG.warn("Trying to document "+symbol.alias+" without first documenting "+parentName+".");
+				}
+			}
+			if (parent) name = parentName+(parent.is("CONSTRUCTOR")?"#":".")+nameFragment;
+		}
+		else {
+			parent = this.namescope.last(1);
+			name = parent.alias+(parent.is("CONSTRUCTOR")?"#":".")+nameFragment;
+		}
+	}
+	// otherwise it means the global
+	else {
+		name = nameFragment;
+	}
+	
+	return name;
+}
+
+JSDOC.Walker.onParamList = function(/**Array*/paramTokens) {
+	if (!paramTokens) {
+		LOG.warn("Malformed parameter list. Can't parse code.");
+		return [];
+	}
+	var params = [];
+	for (var i = 0, l = paramTokens.length; i < l; i++) {
+		if (paramTokens[i].is("JSDOC")) {
+			var paramType = paramTokens[i].data.replace(/(^\/\*\* *| *\*\/$)/g, "");
+			
+			if (paramTokens[i+1] && paramTokens[i+1].is("NAME")) {
+				i++;
+				params.push({type: paramType, name: paramTokens[i].data});
+			}
+		}
+		else if (paramTokens[i].is("NAME")) {
+			params.push({name: paramTokens[i].data});
+		}
+	}
+	return params;
+}

bin/jsdoc/main.js

@@ -0,0 +1,111 @@
+/**
+ * @version $Id: main.js 818 2009-11-08 14:51:41Z micmath $
+ */
+
+function main() {
+	IO.include("lib/JSDOC.js");
+	IO.includeDir("plugins/");
+	
+	// process the options
+	
+	// the -c option: options are defined in a configuration file
+	if (JSDOC.opt.c) {
+		eval("JSDOC.conf = " + IO.readFile(JSDOC.opt.c));
+		
+		LOG.inform("Using configuration file at '"+JSDOC.opt.c+"'.");
+		
+		for (var c in JSDOC.conf) {
+			if (c !== "D" && !defined(JSDOC.opt[c])) { // commandline overrules config file
+				JSDOC.opt[c] = JSDOC.conf[c];
+			}
+		}
+		
+		if (typeof JSDOC.conf["_"] != "undefined") {
+			JSDOC.opt["_"] = JSDOC.opt["_"].concat(JSDOC.conf["_"]);
+		}
+		
+		LOG.inform("With configuration: ");
+		for (var o in JSDOC.opt) {
+			LOG.inform("    "+o+": "+JSDOC.opt[o]);
+		}
+	}
+	
+	// be verbose
+	if (JSDOC.opt.v) LOG.verbose = true;
+	
+	// send log messages to a file
+	if (JSDOC.opt.o) LOG.out = IO.open(JSDOC.opt.o);
+	
+	// run the unit tests
+	if (JSDOC.opt.T) {
+		LOG.inform("JsDoc Toolkit running in test mode at "+new Date()+".");
+		IO.include("frame/Testrun.js");
+		IO.include("test.js");
+	}
+	else {
+		// a template must be defined and must be a directory path
+		if (!JSDOC.opt.t && System.getProperty("jsdoc.template.dir")) {
+			JSDOC.opt.t = System.getProperty("jsdoc.template.dir");
+		}
+		if (JSDOC.opt.t && SYS.slash != JSDOC.opt.t.slice(-1)) {
+			JSDOC.opt.t += SYS.slash;
+		}
+		
+		// verbose messages about the options we were given
+		LOG.inform("JsDoc Toolkit main() running at "+new Date()+".");
+		LOG.inform("With options: ");
+		for (var o in JSDOC.opt) {
+			LOG.inform("    "+o+": "+JSDOC.opt[o]);
+		}
+		
+		// initialize and build a symbolSet from your code
+		JSDOC.JsDoc();
+		
+		// debugger's option: dump the entire symbolSet produced from your code
+		if (JSDOC.opt.Z) {
+			LOG.warn("So you want to see the data structure, eh? This might hang if you have circular refs...");
+			IO.include("frame/Dumper.js");
+			var symbols = JSDOC.JsDoc.symbolSet.toArray();
+			for (var i = 0, l = symbols.length; i < l; i++) {
+				var symbol = symbols[i];
+				print("// symbol: " + symbol.alias);
+				print(symbol.serialize());
+			}
+		}
+		else {
+			if (typeof JSDOC.opt.t != "undefined") {
+				try {
+					// a file named "publish.js" must exist in the template directory
+					load(JSDOC.opt.t+"publish.js");
+					
+					// and must define a function named "publish"
+					if (!publish) {
+						LOG.warn("No publish() function is defined in that template so nothing to do.");
+					}
+					else {
+						// which will be called with the symbolSet produced from your code
+						publish(JSDOC.JsDoc.symbolSet);
+					}
+				}
+				catch(e) {
+					LOG.warn("Sorry, that doesn't seem to be a valid template: "+JSDOC.opt.t+"publish.js : "+e);
+				}
+			}
+			else {
+				LOG.warn("No template given. Might as well read the usage notes.");
+				JSDOC.usage();
+			}
+		}
+	}
+	
+	// notify of any warnings
+	if (!JSDOC.opt.q && LOG.warnings.length) {
+		print(LOG.warnings.length+" warning"+(LOG.warnings.length != 1? "s":"")+".");
+	}
+	
+	// stop sending log messages to a file
+	if (LOG.out) {
+		LOG.out.flush();
+		LOG.out.close();
+	}
+}

bin/jsdoc/plugins/commentSrcJson.js

@@ -0,0 +1,20 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.commentSrcJson",
+	{
+		onDocCommentSrc: function(comment) {
+			var json;
+			if (/^\s*@json\b/.test(comment)) {
+				comment.src = new String(comment.src).replace("@json", "");
+
+				eval("json = "+comment.src);
+				var tagged = "";
+				for (var i in json) {
+					var tag = json[i];
+					// todo handle cases where tag is an object
+					tagged += "@"+i+" "+tag+"\n";
+				}
+				comment.src = tagged;
+			}
+		}
+	}
+);

bin/jsdoc/plugins/frameworkPrototype.js

@@ -0,0 +1,16 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.frameworkPrototype",
+	{
+		onPrototypeClassCreate: function(classCreator) {
+			var desc = "";
+			if (classCreator.comment) {
+				desc = classCreator.comment;
+			}
+			var insert = desc+"/** @name "+classCreator.name+"\n@constructor\n@scope "+classCreator.name+".prototype */"
+			
+			insert = insert.replace(/\*\/\/\*\*/g, "\n");
+			/*DEBUG*///print("insert is "+insert);
+			classCreator.addComment.data = insert;
+		}
+	}
+);

bin/jsdoc/plugins/functionCall.js

@@ -0,0 +1,10 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.functionCall",
+	{
+		onFunctionCall: function(functionCall) {
+			if (functionCall.name == "dojo.define" && functionCall.arg1) {
+				functionCall.doc = "/** @lends "+eval(functionCall.arg1)+".prototype */";
+			}
+		}
+	}
+);

bin/jsdoc/plugins/publishSrcHilite.js

@@ -0,0 +1,62 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.publishSrcHilite",
+	{
+		onPublishSrc: function(src) {
+			if (src.path in JsHilite.cache) {
+				return; // already generated src code
+			}
+			else JsHilite.cache[src.path] = true;
+		
+			try {
+				var sourceCode = IO.readFile(src.path);
+			}
+			catch(e) {
+				print(e.message);
+				quit();
+			}
+
+			var hiliter = new JsHilite(sourceCode, src.charset);
+			src.hilited = hiliter.hilite();
+		}
+	}
+);
+
+function JsHilite(src, charset) {
+
+	var tr = new JSDOC.TokenReader();
+	
+	tr.keepComments = true;
+	tr.keepDocs = true;
+	tr.keepWhite = true;
+	
+	this.tokens = tr.tokenize(new JSDOC.TextStream(src));
+	
+	// TODO is redefining toString() the best way?
+	JSDOC.Token.prototype.toString = function() { 
+		return "<span class=\""+this.type+"\">"+this.data.replace(/</g, "&lt;")+"</span>";
+	}
+	
+	if (!charset) charset = "utf-8";
+	
+	this.header = '<html><head><meta http-equiv="content-type" content="text/html; charset='+charset+'"> '+
+	"<style>\n\
+	.KEYW {color: #933;}\n\
+	.COMM {color: #bbb; font-style: italic;}\n\
+	.NUMB {color: #393;}\n\
+	.STRN {color: #393;}\n\
+	.REGX {color: #339;}\n\
+	.line {border-right: 1px dotted #666; color: #666; font-style: normal;}\n\
+	</style></head><body><pre>";
+	this.footer = "</pre></body></html>";
+	this.showLinenumbers = true;
+}
+
+JsHilite.cache = {};
+
+JsHilite.prototype.hilite = function() {
+	var hilited = this.tokens.join("");
+	var line = 1;
+	if (this.showLinenumbers) hilited = hilited.replace(/(^|\n)/g, function(m){return m+"<span class='line'>"+((line<10)? " ":"")+((line<100)? " ":"")+(line++)+"</span> "});
+	
+	return this.header+hilited+this.footer;
+}

bin/jsdoc/plugins/symbolLink.js

@@ -0,0 +1,10 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.symbolLink",
+	{
+		onSymbolLink: function(link) {
+			// modify link.linkPath (the href part of the link)
+			// or link.linkText (the text displayed)
+			// or link.linkInner (the #name part of the link)
+		}
+	}
+);

bin/jsdoc/plugins/tagParamConfig.js

@@ -0,0 +1,31 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.tagParamConfig",
+	{
+		onDocCommentTags: function(comment) {
+			var currentParam = null;
+			var tags = comment.tags;
+			for (var i = 0, l = tags.length; i < l; i++) {
+				
+				if (tags[i].title == "param") {
+					if (tags[i].name.indexOf(".") == -1) {
+						currentParam = i;
+					}
+				}
+				else if (tags[i].title == "config") {
+					tags[i].title = "param";
+					if (currentParam == null) {
+						tags[i].name = "arguments"+"."+tags[i].name;
+					}
+					else if (tags[i].name.indexOf(tags[currentParam].name+".") != 0) {
+						tags[i].name = tags[currentParam].name+"."+tags[i].name;
+					}
+					currentParam != null
+					//tags[currentParam].properties.push(tags[i]);
+				}
+				else {
+					currentParam = null;
+				}
+			}
+		}
+	}
+);

bin/jsdoc/plugins/tagSynonyms.js

@@ -0,0 +1,43 @@
+JSDOC.PluginManager.registerPlugin(
+	"JSDOC.tagSynonyms",
+	{
+		onDocCommentSrc: function(comment) {
+			comment.src = comment.src.replace(/@methodOf\b/i, "@function\n@memberOf");
+			comment.src = comment.src.replace(/@fieldOf\b/i, "@field\n@memberOf");
+		},
+		
+		onDocCommentTags: function(comment) {
+			for (var i = 0, l = comment.tags.length; i < l; i++) {
+				var title = comment.tags[i].title.toLowerCase();
+				var syn;
+				if ((syn = JSDOC.tagSynonyms.synonyms["="+title])) {
+					comment.tags[i].title = syn;
+				}
+			}
+		}
+	}
+);
+
+new Namespace(
+	"JSDOC.tagSynonyms",
+	function() {
+		JSDOC.tagSynonyms.synonyms = {
+			"=member":             "memberOf",
+			"=memberof":           "memberOf",
+			"=description":        "desc",
+			"=exception":          "throws",
+			"=argument":           "param",
+			"=returns":            "return",
+			"=classdescription":   "class",
+			"=fileoverview":       "overview",
+			"=extends":            "augments",
+			"=base":               "augments",
+			"=projectdescription": "overview",
+			"=classdescription":   "class",
+			"=link":               "see",
+			"=borrows":            "inherits",
+			"=scope":              "lends",
+			"=construct":          "constructor"
+		}
+	}
+);

bin/jsdoc/run.js

@@ -0,0 +1,348 @@
+/**
+ * @fileOverview
+ * A bootstrap script that creates some basic required objects
+ * for loading other scripts.
+ * @author Michael Mathews, micmath@gmail.com
+ * @version $Id: run.js 756 2009-01-07 21:32:58Z micmath $
+ */
+
+/**
+ * @namespace Keep track of any messages from the running script.
+ */
+LOG = {
+	warn: function(msg, e) {
+		if (JSDOC.opt.q) return;
+		if (e) msg = e.fileName+", line "+e.lineNumber+": "+msg;
+		
+		msg = ">> WARNING: "+msg;
+		LOG.warnings.push(msg);
+		if (LOG.out) LOG.out.write(msg+"\n");
+		else print(msg);
+	},
+
+	inform: function(msg) {
+		if (JSDOC.opt.q) return;
+		msg = " > "+msg;
+		if (LOG.out) LOG.out.write(msg+"\n");
+		else if (typeof LOG.verbose != "undefined" && LOG.verbose) print(msg);
+	}
+};
+LOG.warnings = [];
+LOG.verbose = false
+LOG.out = undefined;
+
+/**
+ *	@class Manipulate a filepath.
+ */
+function FilePath(absPath, separator) {
+	this.slash =  separator || "/"; 
+	this.root = this.slash;
+	this.path = [];
+	this.file = "";
+	
+	var parts = absPath.split(/[\\\/]/);
+	if (parts) {
+		if (parts.length) this.root = parts.shift() + this.slash;
+		if (parts.length) this.file =  parts.pop()
+		if (parts.length) this.path = parts;
+	}
+	
+	this.path = this.resolvePath();
+}
+
+/** Collapse any dot-dot or dot items in a filepath. */
+FilePath.prototype.resolvePath = function() {
+	var resolvedPath = [];
+	for (var i = 0; i < this.path.length; i++) {
+		if (this.path[i] == "..") resolvedPath.pop();
+		else if (this.path[i] != ".") resolvedPath.push(this.path[i]);
+	}
+	return resolvedPath;
+}
+
+/** Trim off the filename. */
+FilePath.prototype.toDir = function() {
+	if (this.file) this.file = "";
+	return this;
+}
+
+/** Go up a directory. */
+FilePath.prototype.upDir = function() {
+	this.toDir();
+	if (this.path.length) this.path.pop();
+	return this;
+}
+
+FilePath.prototype.toString = function() {
+	return this.root
+		+ this.path.join(this.slash)
+		+ ((this.path.length > 0)? this.slash : "")
+		+ this.file;
+}
+
+/**
+ * Turn a path into just the name of the file.
+ */
+FilePath.fileName = function(path) {
+	var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+	return path.substring(nameStart);
+}
+
+/**
+ * Get the extension of a filename
+ */
+FilePath.fileExtension = function(filename) {
+   return filename.split(".").pop().toLowerCase();
+};
+
+/**
+ * Turn a path into just the directory part.
+ */
+FilePath.dir = function(path) {
+	var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+	return path.substring(0, nameStart-1);
+}
+
+
+importClass(java.lang.System);
+
+/**
+ * @namespace A collection of information about your system.
+ */
+SYS = {
+	/**
+	 * Information about your operating system: arch, name, version.
+	 * @type string
+	 */
+	os: [
+		new String(System.getProperty("os.arch")),
+		new String(System.getProperty("os.name")),
+		new String(System.getProperty("os.version"))
+	].join(", "),
+	
+	/**
+	 * Which way does your slash lean.
+	 * @type string
+	 */
+	slash: System.getProperty("file.separator")||"/",
+	
+	/**
+	 * The path to the working directory where you ran java.
+	 * @type string
+	 */
+	userDir: new String(System.getProperty("user.dir")),
+	
+	/**
+	 * Where is Java's home folder.
+	 * @type string
+	 */
+	javaHome: new String(System.getProperty("java.home")),
+	
+	/**
+	 * The absolute path to the directory containing this script.
+	 * @type string
+	 */
+	pwd: undefined
+};
+
+// jsrun appends an argument, with the path to here.
+if (arguments[arguments.length-1].match(/^-j=(.+)/)) {
+	if (RegExp.$1.charAt(0) == SYS.slash || RegExp.$1.charAt(1) == ":") { // absolute path to here
+		SYS.pwd = new FilePath(RegExp.$1).toDir().toString();
+	}
+	else { // relative path to here
+		SYS.pwd = new FilePath(SYS.userDir + SYS.slash + RegExp.$1).toDir().toString();
+	}
+	arguments.pop();
+}
+else {
+	print("The run.js script requires you use jsrun.jar.");
+	quit();
+}
+
+// shortcut
+var File = Packages.java.io.File;
+
+/**
+ * @namespace A collection of functions that deal with reading a writing to disk.
+ */
+IO = {
+
+	/**
+	 * Create a new file in the given directory, with the given name and contents.
+	 */
+	saveFile: function(/**string*/ outDir, /**string*/ fileName, /**string*/ content) {
+		var out = new Packages.java.io.PrintWriter(
+			new Packages.java.io.OutputStreamWriter(
+				new Packages.java.io.FileOutputStream(outDir+SYS.slash+fileName),
+				IO.encoding
+			)
+		);
+		out.write(content);
+		out.flush();
+		out.close();
+	},
+	
+	/**
+	 * @type string
+	 */
+	readFile: function(/**string*/ path) {
+		if (!IO.exists(path)) {
+			throw "File doesn't exist there: "+path;
+		}
+		return readFile(path, IO.encoding);
+	},
+
+	/**
+	 * @param inFile 
+	 * @param outDir
+	 * @param [fileName=The original filename]
+	 */
+	copyFile: function(/**string*/ inFile, /**string*/ outDir, /**string*/ fileName) {
+		if (fileName == null) fileName = FilePath.fileName(inFile);
+	
+		var inFile = new File(inFile);
+		var outFile = new File(outDir+SYS.slash+fileName);
+		
+		var bis = new Packages.java.io.BufferedInputStream(new Packages.java.io.FileInputStream(inFile), 4096);
+		var bos = new Packages.java.io.BufferedOutputStream(new Packages.java.io.FileOutputStream(outFile), 4096);
+		var theChar;
+		while ((theChar = bis.read()) != -1) {
+			bos.write(theChar);
+		}
+		bos.close();
+		bis.close();
+	},
+
+	/**
+	 * Creates a series of nested directories.
+	 */
+	mkPath: function(/**Array*/ path) {
+		if (path.constructor != Array) path = path.split(/[\\\/]/);
+		var make = "";
+		for (var i = 0, l = path.length; i < l; i++) {
+			make += path[i] + SYS.slash;
+			if (! IO.exists(make)) {
+				IO.makeDir(make);
+			}
+		}
+	},
+	
+	/**
+	 * Creates a directory at the given path.
+	 */
+	makeDir: function(/**string*/ path) {
+		(new File(path)).mkdir();
+	},
+
+	/**
+	 * @type string[]
+	 * @param dir The starting directory to look in.
+	 * @param [recurse=1] How many levels deep to scan.
+	 * @returns An array of all the paths to files in the given dir.
+	 */
+	ls: function(/**string*/ dir, /**number*/ recurse, _allFiles, _path) {
+		if (_path === undefined) { // initially
+			var _allFiles = [];
+			var _path = [dir];
+		}
+		if (_path.length == 0) return _allFiles;
+		if (recurse === undefined) recurse = 1;
+		
+		dir = new File(dir);
+		if (!dir.directory) return [String(dir)];
+		var files = dir.list();
+		
+		for (var f = 0; f < files.length; f++) {
+			var file = String(files[f]);
+			if (file.match(/^\.[^\.\/\\]/)) continue; // skip dot files
+	
+			if ((new File(_path.join(SYS.slash)+SYS.slash+file)).list()) { // it's a directory
+				_path.push(file);
+				if (_path.length-1 < recurse) IO.ls(_path.join(SYS.slash), recurse, _allFiles, _path);
+				_path.pop();
+			}
+			else {
+				_allFiles.push((_path.join(SYS.slash)+SYS.slash+file).replace(SYS.slash+SYS.slash, SYS.slash));
+			}
+		}
+	
+		return _allFiles;
+	},
+
+	/**
+	 * @type boolean
+	 */
+	exists: function(/**string*/ path) {
+		file = new File(path);
+	
+		if (file.isDirectory()){
+			return true;
+		}
+		if (!file.exists()){
+			return false;
+		}
+		if (!file.canRead()){
+			return false;
+		}
+		return true;
+	},
+
+	/**
+	 * 
+	 */
+	open: function(/**string*/ path, /**string*/ append) {
+		var append = true;
+		var outFile = new File(path);
+		var out = new Packages.java.io.PrintWriter(
+			new Packages.java.io.OutputStreamWriter(
+				new Packages.java.io.FileOutputStream(outFile, append),
+				IO.encoding
+			)
+		);
+		return out;
+	},
+
+	/**
+	 * Sets {@link IO.encoding}.
+	 * Encoding is used when reading and writing text to files,
+	 * and in the meta tags of HTML output.
+	 */
+	setEncoding: function(/**string*/ encoding) {
+		if (/ISO-8859-([0-9]+)/i.test(encoding)) {
+			IO.encoding = "ISO8859_"+RegExp.$1;
+		}
+		else {
+			IO.encoding = encoding;
+		}
+	},
+
+	/**
+	 * @default "utf-8"
+	 * @private
+	 */
+	encoding: "utf-8",
+	
+	/**
+	 * Load the given script.
+	 */
+	include: function(relativePath) {
+		load(SYS.pwd+relativePath);
+	},
+	
+	/**
+	 * Loads all scripts from the given directory path.
+	 */
+	includeDir: function(path) {
+		if (!path) return;
+		
+		for (var lib = IO.ls(SYS.pwd+path), i = 0; i < lib.length; i++) 
+			if (/\.js$/i.test(lib[i])) load(lib[i]);
+	}
+}
+
+// now run the application
+IO.include("frame.js");
+IO.include("main.js");
+
+main();

bin/jsdoc/t/TestDoc.js

@@ -0,0 +1,144 @@
+var TestDoc = {
+	fails: 0,
+	plans: 0,
+	passes: 0,
+	results: []
+};
+
+TestDoc.record = function(result) {
+	TestDoc.results.push(result);
+	if (typeof result.verdict == "boolean") {
+		if (result.verdict === false) TestDoc.fails++;
+		if (result.verdict === true) TestDoc.passes++;
+	}
+}
+
+TestDoc.prove = function(filePath) {
+	if (typeof document != "undefined" && typeof document.write != "undefined") {
+		if (TestDoc.console) print = function(s) { TestDoc.console.appendChild(document.createTextNode(s+"\n")); }
+		else print = function(s) { document.write(s+"<br />"); }
+	}
+	TestDoc.run(TestDoc.readFile(filePath));
+}
+
+TestDoc.run = function(src) {
+	try { eval(src); } catch(e) { print("# ERROR! "+e); }
+	
+	var chunks = src.split(/\/\*t:/);
+	
+	var run = function(chunk) {
+		// local shortcuts
+		var is = TestDoc.assertEquals;
+		var isnt = TestDoc.assertNotEquals;
+		var plan = TestDoc.plan;
+		var requires = TestDoc.requires;
+		
+		try { eval(chunk); } catch(e) { print("# ERROR! "+e); }
+	}
+	for (var start = -1, end = 0; (start = src.indexOf("/*t:", end)) > end; start = end) {
+		run(
+			src.substring(
+				start+4,
+				(end = src.indexOf("*/", start))
+			)
+		);
+	}
+}
+
+TestDoc.Result = function(verdict, message) {
+	this.verdict = verdict;
+	this.message = message;
+}
+
+TestDoc.Result.prototype.toString = function() {
+	if (typeof this.verdict == "boolean") {
+		return (this.verdict? "ok" : "not ok") + " " + (++TestDoc.report.counter) + " - " + this.message;
+	}
+	
+	return "# " + this.message;
+}
+
+TestDoc.requires = function(file) {
+	if (!TestDoc.requires.loaded[file]) {
+		load(file);
+		TestDoc.requires.loaded[file] = true;
+	}
+}
+TestDoc.requires.loaded = {};
+
+TestDoc.report = function() {
+	TestDoc.report.counter = 0;
+	print("1.."+TestDoc.plans);
+	for (var i = 0; i < TestDoc.results.length; i++) {
+		print(TestDoc.results[i]);
+	}
+	print("----------------------------------------");
+	if (TestDoc.fails == 0 && TestDoc.passes == TestDoc.plans) {
+		print("All tests successful.");
+	}
+	else {
+		print("Failed " + TestDoc.fails + "/" + TestDoc.plans + " tests, "+((TestDoc.plans == 0)? 0 : Math.round(TestDoc.passes/(TestDoc.passes+TestDoc.fails)*10000)/100)+"% okay. Planned to run "+TestDoc.plans+", did run "+(TestDoc.passes+TestDoc.fails)+".")
+	}
+}
+
+TestDoc.plan = function(n, message) {
+	TestDoc.plans += n;
+	TestDoc.record(new TestDoc.Result(null, message+" ("+n+" tests)"));
+}
+
+TestDoc.assertEquals = function(a, b, message) {
+	var result = (a == b);
+	if (!result) message += "\n#\n# " + a + " does not equal " + b + "\n#";
+	TestDoc.record(new TestDoc.Result(result, message));
+}
+
+TestDoc.assertNotEquals = function(a, b, message) {
+	var result = (a != b);
+	if (!result) message += "\n#\n# " + a + " equals " + b + "\n#";
+	TestDoc.record(new TestDoc.Result(result, message));
+}
+
+TestDoc.readFile = (function(){
+	// rhino
+	if (typeof readFile == "function") {
+		return function(url) {
+			var text = readFile(url);
+			return text || "";
+		}
+	}
+
+	// a web browser
+	else {
+		return function(url) {
+			var httpRequest;
+		
+			if (window.XMLHttpRequest) { // Mozilla, Safari, etc
+				httpRequest = new XMLHttpRequest();
+			} 
+			else if (window.ActiveXObject) { // IE
+				try {
+					httpRequest = new ActiveXObject("Msxml2.XMLHTTP");
+				} 
+				catch (e) {
+				   try {
+						httpRequest = new ActiveXObject("Microsoft.XMLHTTP");
+					} 
+					catch (e) {
+					}
+				}
+			}
+		
+			if (!httpRequest) { throw "Cannot create HTTP Request."; }
+			
+			httpRequest.open('GET', url, false);
+			httpRequest.send('');
+			if (httpRequest.readyState == 4) {
+				if (httpRequest.status >= 400) {
+					throw "The HTTP Request returned an error code: "+httpRequest.status;
+				}
+			}
+			
+			return httpRequest.responseText || "";
+		}
+	}
+})();

bin/jsdoc/t/runner.js

@@ -0,0 +1,13 @@
+// try: java -jar ../../jsrun.jar runner.js
+
+load("TestDoc.js");
+
+TestDoc.prove("../frame/Opt.js");
+TestDoc.prove("../lib/JSDOC.js");
+TestDoc.prove("../frame/String.js");
+TestDoc.prove("../lib/JSDOC/DocTag.js");
+TestDoc.prove("../lib/JSDOC/DocComment.js");
+TestDoc.prove("../lib/JSDOC/TokenReader.js");
+TestDoc.prove("../lib/JSDOC/Symbol.js");
+
+TestDoc.report();

bin/jsdoc/templates/README.txt

@@ -0,0 +1,5 @@
+Codeview is a template for JSDoc Toolkit. With JSDoc Toolkit you can generate a documentation website.
+
+The Codeview template is, like JSDoc Toolkit itself, published under the X11/MIT License.
+
+Codeview is Copyright (c) 2010 Wouter Bos (www.thebrightlines.com)

bin/jsdoc/templates/allclasses.tmpl

@@ -0,0 +1,20 @@
+{! Link.base = ""; /* all generated links will be relative to this */ !}
+{+subtemplate("subtemplates/head.tmpl", {subtitle: "Class Index"})+}
+{+subtemplate("subtemplates/menu.tmpl")+}
+<div class="content">
+	<div class="innerContent">
+		<article>
+			<h1 class="classTitle"><span>Class Index</span></h1>
+			
+			<ul id="ClassList2">
+				<for each="thisClass" in="data">
+					<li>
+						<h2 class="classname">{+(new Link().toSymbol(thisClass.alias))+}</h2>
+						<p>{+resolveLinks(summarize(thisClass.classDesc))+}</p>
+					</li>
+				</for>
+			</ul>
+		</article>
+	</div>
+</div>
+{+subtemplate("subtemplates/foot.tmpl")+}

bin/jsdoc/templates/allfiles.tmpl

@@ -0,0 +1,41 @@
+{! Link.base = ""; /* all generated links will be relative to this */ !}
+{+subtemplate("subtemplates/head.tmpl", {subtitle: "File Index"})+}
+{+subtemplate("subtemplates/menu.tmpl")+}
+<div class="content">
+	<div class="innerContent">
+		<article>
+			<h1 class="classTitle"><span>File Index</span></h1>
+			
+			<ul class="fileList" id="FileList">
+				<for each="item" in="data">
+					<li>
+						<h2 class="filename">{+new Link().toSrc(item.alias).withText(item.name)+}</h2>
+						
+						<if test="item.desc">{+resolveLinks(item.desc)+}</if>
+						
+						<dl class="detailList">
+							<if test="item.author">
+								<dt class="heading">Author:</dt>
+								<dd>{+item.author+}</dd>
+							</if>
+							
+							<if test="item.version">
+								<dt class="heading">Version:</dt>
+								<dd>{+item.version+}</dd>
+							</if>
+							
+							{! var locations = item.comment.getTag('location').map(function($){return $.toString().replace(/(^\$ ?| ?\$$)/g, '').replace(/^HeadURL: https:/g, 'http:');}) !}
+							<if test="locations.length">
+								<dt class="heading">Location:</dt>
+								<for each="location" in="locations">
+									<dd><a href="{+location+}">{+location+}</a></dd>
+								</for>
+							</if>
+						</dl>
+					</li>
+				</for>
+			</ul>
+		</article>
+	</div>
+</div>
+{+subtemplate("subtemplates/foot.tmpl")+}

bin/jsdoc/templates/class.tmpl

@@ -0,0 +1,712 @@
+{! Link.base = "../"; /* all generated links will be relative to this */ !}
+{+subtemplate("subtemplates/head.tmpl", {subtitle: data.alias})+}
+{+subtemplate("subtemplates/menu.tmpl")+}
+<div class="content">
+	<div class="innerContent">
+		<article>
+			<header>
+				<h1 class="classTitle">
+					{!
+						var classType = "";
+						
+						if (data.isBuiltin()) {
+							classType += "Built-In ";
+						}
+						
+						if (data.isNamespace) {
+							if (data.is('FUNCTION')) {
+								classType += "Function ";
+							}
+							classType += "Namespace ";
+						} else {
+							classType += "Class ";
+						}
+					!}
+					{+classType+}<span>{+data.alias+}</span>
+				</h1>
+				
+				<div class="intro">
+					<p class="description summary">
+						{+resolveLinks(data.classDesc)+}
+					</p>
+						
+					<if test="data.version || !data.isBuiltin() || data.augments.length">
+						<ul class="summary">
+							<if test="data.version">
+								<li>Version {+ data.version +}</li>
+							</if>
+							
+							<if test="!data.isBuiltin()">{# isn't defined in any file #}
+								<li>Defined in: {+new Link().toSrc(data.srcFile)+}</li>
+							</if>
+							<if test="data.augments.length"><li>Extends <span class="fixedFont">
+								{+
+									data.augments
+									.sort()
+									.map(
+										function($) { return new Link().toSymbol($); }
+									)
+									.join(", ")
+								+}</span></li>
+							</if>
+						</ul>
+					</if>
+				</div>
+			</header>
+			
+			<if test="!data.isBuiltin() && (data.isNamespace || data.is('CONSTRUCTOR'))">
+				<section>
+					<div class="props">
+						<table class="summaryTable" cellspacing="0" summary="A summary of the constructor documented in the class {+data.alias+}.">
+							<caption class="sectionTitle">{+classType+}Summary</caption>
+							<thead>
+								<tr>
+									<th scope="col">Constructor Attributes</th>
+									<th scope="col">Constructor Name and Description</th>
+								</tr>
+							</thead>
+							<tbody>
+								<tr>
+									<td class="attributes">{!
+										if (data.isPrivate) output += "&lt;private&gt; ";
+										if (data.isInner) output += "&lt;inner&gt; ";
+									!}&nbsp;</td>
+									<td class="nameDescription" {!if (data.comment.getTag("hilited").length){output += 'style="color: red"'}!}>
+										<div class="fixedFont">
+											<b>{+ new Link().toSymbol(data.alias).inner('constructor')+}</b><if test="classType != 'Namespace '">{+ makeSignature(data.params) +}</if>
+										</div>
+										<div class="description">{+resolveLinks(summarize(data.desc))+}</div>
+									</td>
+								</tr>
+							</tbody>
+						</table>
+					</div>
+				</section>
+			</if>
+			
+			<if test="data.properties.length">
+				{! var ownProperties = data.properties.filter(function($){return $.memberOf == data.alias && !$.isNamespace}).sort(makeSortby("name")); !}
+				<section>
+					<if test="ownProperties.length">
+						<nav>
+							<div class="props">
+								<table class="summaryTable" cellspacing="0" summary="A summary of the fields documented in the class {+data.alias+}.">
+									<caption class="sectionTitle">Field Summary</caption>
+									
+									<thead>
+										<tr>
+											<th scope="col">Field Attributes</th>
+											<th scope="col">Field Name and Description</th>
+										</tr>
+									</thead>
+									
+									<tbody>
+										<for each="member" in="ownProperties">
+											<tr>
+												<td class="attributes">{!
+													if (member.isPrivate) output += "&lt;private&gt; ";
+													if (member.isInner) output += "&lt;inner&gt; ";
+													if (member.isStatic) output += "&lt;static&gt; ";
+													if (member.isConstant) output += "&lt;constant&gt; ";
+												!}&nbsp;</td>
+												<td class="nameDescription">
+													<div class="fixedFont">
+													<if test="member.isStatic && member.memberOf != '_global_'">{+member.memberOf+}.</if><b>{+new Link().toSymbol(member.alias).withText(member.name)+}</b>
+													</div>
+													<div class="description">{+resolveLinks(summarize(member.desc))+}</div>
+												</td>
+											</tr>
+										</for>
+									</tbody>
+								</table>
+							</div>
+						</nav>
+					</if>
+					
+					<if test="data.inheritsFrom.length">
+						<nav>
+							<dl class="inheritsList">
+							{!
+								var borrowedMembers = data.properties.filter(function($) {return $.memberOf != data.alias});
+								
+								var contributers = [];
+								borrowedMembers.map(function($) {if (contributers.indexOf($.memberOf) < 0) contributers.push($.memberOf)});
+								for (var i = 0, l = contributers.length; i < l; i++) {
+									output +=
+										"<dt>Fields borrowed from class "+new Link().toSymbol(contributers[i])+": </dt>"
+										+
+										"<dd>" +
+										borrowedMembers
+										.filter(
+											function($) { return $.memberOf == contributers[i] }
+										)
+										.sort(makeSortby("name"))
+										.map(
+											function($) { return new Link().toSymbol($.alias).withText($.name) }
+										)
+										.join(", ")
+										+
+										"</dd>";
+								}
+							!}
+							</dl>
+						</nav>
+					</if>
+				</section>
+			</if>
+	<!--
+	#### METHODS SUMMARY
+	-->
+			<if test="data.methods.length">
+				<section>
+					{! var ownMethods = data.methods.filter(function($){return $.memberOf == data.alias  && !$.isNamespace}).sort(makeSortby("name")); !}
+					
+					<div class="props">
+						<h2 class="sectionTitle">Method Summary</h2>
+						
+						<if test="ownMethods.length">
+							<nav>
+								<table class="summaryTable" id="MethodsList" cellspacing="0" summary="A summary of the methods documented in the class {+data.alias+}.">
+									<thead>
+										<tr>
+											<th scope="col">Method Attributes</th>
+											<th scope="col">Method Name and Description</th>
+										</tr>
+									</thead>
+									
+									<tbody>
+										{!
+											var methodSummaryCount = 0;
+										!}
+										<for each="member" in="ownMethods">
+											<tr
+												{!
+													output += " class='item"+ methodSummaryCount +"'";
+													methodSummaryCount++
+												!}
+											>
+												<td class="attributes">{!
+													if (member.isPrivate) output += "&lt;private&gt; ";
+													if (member.isInner) output += "&lt;inner&gt; ";
+													if (member.isStatic) output += "&lt;static&gt; ";
+												!}&nbsp;</td>
+												<td class="nameDescription">
+													<div class="fixedFont"><if test="member.isStatic && member.memberOf != '_global_'">{+member.memberOf+}.</if><b>{+new Link().toSymbol(member.alias).withText(member.name.replace(/\^\d+$/, ''))+}</b>{+makeSignature(member.params)+}
+													</div>
+													<div class="description">{+resolveLinks(summarize(member.desc))+}</div>
+												</td>
+											</tr>
+										</for>
+									</tbody>
+								</table>
+							</nav>
+						</if>
+					
+						<if test="data.inheritsFrom.length">
+							<nav>
+								<dl class="inheritsList" id="MethodsListInherited">
+								{!
+									var borrowedMembers = data.methods.filter(function($) {return $.memberOf != data.alias});
+									var contributers = [];
+									borrowedMembers.map(function($) {if (contributers.indexOf($.memberOf) < 0) contributers.push($.memberOf)});
+									for (var i = 0, l = contributers.length; i < l; i++) {
+										output +=
+											"<dt>Methods borrowed from class <span class='fixedFont'>"+new Link().toSymbol(contributers[i])+"</span>: </dt>"
+											+
+											borrowedMembers
+											.filter(
+												function($) { return $.memberOf == contributers[i] }
+											)
+											.sort(makeSortby("name"))
+											.map(
+												function($) {
+													var link = "";
+													link += "<dd><span class='fixedFont'>";
+													link += new Link().toSymbol($.alias).withText($.name);
+													link += "</span></dd>";
+													return link;
+												}
+											)
+											.join(" ");
+									}
+								!}
+								</dl>
+							</nav>
+						</if>
+					</div>
+				</section>
+			</if>
+			
+	<!--
+	#### EVENTS SUMMARY
+	-->
+			<if test="data.events.length">
+				{! var ownEvents = data.events.filter(function($){return $.memberOf == data.alias  && !$.isNamespace}).sort(makeSortby("name")); !}
+				<section>
+					<if test="ownEvents.length">
+						<nav>
+							<div class="props">
+								<table class="summaryTable" cellspacing="0" summary="A summary of the events documented in the class {+data.alias+}.">
+									<caption class="sectionTitle">Event Summary</caption>
+									
+									<thead>
+										<tr>
+											<th scope="col">Event Attributes</th>
+											<th scope="col">Event Name and Description</th>
+										</tr>
+									</thead>
+									
+									<tbody>
+										<for each="member" in="ownEvents">
+											<tr>
+												<td class="attributes">{!
+													if (member.isPrivate) output += "&lt;private&gt; ";
+													if (member.isInner) output += "&lt;inner&gt; ";
+													if (member.isStatic) output += "&lt;static&gt; ";
+												!}&nbsp;</td>
+												<td class="nameDescription">
+													<div class="fixedFont"><if test="member.isStatic && member.memberOf != '_global_'">{+member.memberOf+}.</if><b>{+new Link().toSymbol(member.alias).withText(member.name)+}</b>{+makeSignature(member.params)+}
+													</div>
+													<div class="description">{+resolveLinks(summarize(member.desc))+}</div>
+												</td>
+											</tr>
+										</for>
+									</tbody>
+								</table>
+							</div>
+						</nav>
+					</if>
+					
+					<if test="data.inheritsFrom.length">
+						<nav>
+							<dl class="inheritsList">
+							{!
+								var borrowedMembers = data.events.filter(function($) {return $.memberOf != data.alias});
+								var contributers = [];
+								borrowedMembers.map(function($) {if (contributers.indexOf($.memberOf) < 0) contributers.push($.memberOf)});
+								for (var i = 0, l = contributers.length; i < l; i++) {
+									output +=
+										"<dt>Events borrowed from class "+new Link().toSymbol(contributers[i])+": </dt>"
+										+
+										"<dd>" +
+										borrowedMembers
+										.filter(
+											function($) { return $.memberOf == contributers[i] }
+										)
+										.sort(makeSortby("name"))
+										.map(
+											function($) { return new Link().toSymbol($.alias).withText($.name) }
+										)
+										.join(", ")
+										+
+										"</dd>";
+								}
+							
+							!}
+							</dl>
+						</nav>
+					</if>
+				</section>
+			</if>
+	<!--
+	#### CONSTRUCTOR DETAILS
+	-->
+			<if test="!data.isBuiltin() && (data.isNamespace || data.is('CONSTRUCTOR'))">
+				<section>
+					<div class="details props">
+						<div class="innerProps">
+							<h2 class="sectionTitle" id="constructor">
+								{+classType+}Detail
+							</h2>
+							
+							<div class="fixedFont">{!
+								if (data.isPrivate) output += "&lt;private&gt; ";
+								if (data.isInner) output += "&lt;inner&gt; ";
+							!}
+								<b>{+ data.alias +}</b><if test="classType != 'Namespace '">{+ makeSignature(data.params) +}</if>
+							</div>
+							
+							<div class="description">
+								{+resolveLinks(data.desc)+}
+								<if test="data.author"><br /><i>Author: </i>{+data.author+}.</if>
+							</div>
+							
+							<if test="data.example.length">
+								<for each="example" in="data.example">
+									<pre class="code">{+example+}</pre>
+								</for>
+							</if>
+						
+							<if test="data.params.length">
+								<dl class="detailList params">
+									<dt class="heading">Parameters:</dt>
+									<for each="item" in="data.params">
+										<dt>
+											{+((item.type)?""+("<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type)+"}</span> ")) : "")+} <b>{+item.name+}</b>
+											<if test="item.isOptional"><i>Optional<if test="item.defaultValue">, Default: {+item.defaultValue+}</if></i></if>
+										</dt>
+										<dd>{+resolveLinks(item.desc)+}</dd>
+									</for>
+								</dl>
+							</if>
+							
+							<if test="data.deprecated || data.since || data.exceptions.length || data.returns.length || data.requires.length || data.see.length">
+								<dl class="detailList nomargin">
+									<if test="data.deprecated">
+										<dt>
+											{+resolveLinks(data.deprecated)+}
+										</dt>
+									</if>
+									
+									<if test="data.since">
+										<dt class="heading">Since:</dt>
+										<dd>{+ data.since +}</dd>
+									</if>
+									
+									<if test="data.exceptions.length">
+										<dt class="heading">Throws:</dt>
+										<for each="item" in="data.exceptions">
+											<dt>
+												{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+} <b>{+item.name+}</b>
+											</dt>
+												<dd>{+resolveLinks(item.desc)+}</dd>
+										</for>
+									</if>
+									
+									<if test="data.returns.length">
+										<dt class="heading">Returns:</dt>
+										<for each="item" in="data.returns">
+												<dd>{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+}{+resolveLinks(item.desc)+}</dd>
+										</for>
+									</if>
+									
+									<if test="data.requires.length">
+										<dt class="heading">Requires:</dt>
+										<for each="item" in="data.requires">
+											<dd>{+ resolveLinks(item) +}</dd>
+										</for>
+									</if>
+									
+									<if test="data.see.length">
+										<dt class="heading">See:</dt>
+										<for each="item" in="data.see">
+											<dd>{+ new Link().toSymbol(item) +}</dd>
+										</for>
+									</if>
+								</dl>
+							</if>
+						</div>
+					</div>
+				</section>
+			</if>
+	<!--
+	#### FIELD DETAILS
+	-->
+			<if test="defined(ownProperties) && ownProperties.length">
+				<section>
+					<div class="details props">
+						<div class="innerProps">
+							<h2 class="sectionTitle">
+								Field Detail
+							</h2>
+							
+							<for each="member" in="ownProperties">
+								<div class="fixedFont heading" id="{+Link.symbolNameToLinkName(member)+}">
+									<span class='lighter'>
+									{!
+										if (member.isPrivate) output += "&lt;private&gt; ";
+										if (member.isInner) output += "&lt;inner&gt; ";
+										if (member.isStatic) output += "&lt;static&gt; ";
+										if (member.isConstant) output += "&lt;constant&gt; ";
+									!}
+									</span>
+									
+									<if test="member.type"><span class="light">{{+new Link().toSymbol(member.type)+}}</span></if>
+									
+									<if test="member.isStatic && member.memberOf != '_global_'"><span class="light">{+member.memberOf+}.</span></if><b>{+member.name+}</b>							
+								</div>
+								
+								<div class="description">
+									{+resolveLinks(member.desc)+}
+									<if test="member.srcFile != data.srcFile">
+										<br />
+										<i>Defined in: </i> {+new Link().toSrc(member.srcFile)+}.
+									</if>
+									
+									<if test="member.author"><br /><i>Author: </i>{+member.author+}.</if>
+								</div>
+								
+								<if test="member.example.length">
+									<for each="example" in="member.example">
+										<pre class="code">{+example+}</pre>
+									</for>
+								</if>
+									<if test="member.deprecated || member.since || member.see.length || member.defaultValue">
+									<dl class="detailList nomargin">
+									
+										<if test="member.deprecated">
+											<dt class="heading">Deprecated:</dt>
+											<dt>
+												{+ resolveLinks(member.deprecated) +}
+											</dt>
+										</if>
+										<if test="member.since">
+											<dt class="heading">Since:</dt>
+											<dd>{+ member.since +}</dd>
+										</if>
+										<if test="member.see.length">
+											<dt class="heading">See:</dt>
+											<for each="item" in="member.see">
+												<dd>{+ new Link().toSymbol(item) +}</dd>
+											</for>
+										</if>
+										<if test="member.defaultValue">
+											<dt class="heading">Default Value:</dt>
+											<dd>
+												{+resolveLinks(member.defaultValue)+}
+											</dd>
+										</if>
+									</dl>
+								</if>
+								
+								<if test="!$member_last"><div class="hr"></div></if>
+							</for>
+						</div>
+					</div>
+				</section>
+			</if>
+	<!--
+	#### METHOD DETAILS
+	-->		
+			<if test="defined(ownMethods) && ownMethods.length">
+				<section>
+					<div class="details props">
+						<div class="innerProps">
+							<h2 class="sectionTitle">
+								Method Detail
+							</h2>
+							
+							<ul class="methodDetail" id="MethodDetail">
+								{!
+									var methodDetailCount = 0;
+								!}
+								<for each="member" in="ownMethods">
+									<li 
+										{!
+											output += " class='item"+ methodDetailCount +"'";
+											methodDetailCount++
+										!}
+									>
+										<div class="fixedFont heading" id="{+Link.symbolNameToLinkName(member)+}">
+											<span class='lighter'>
+											{!
+												if (member.isPrivate) output += "&lt;private&gt; ";
+												if (member.isInner) output += "&lt;inner&gt; ";
+												if (member.isStatic) output += "&lt;static&gt; ";
+											!}
+											</span>
+											
+											<if test="member.type"><span class="light">{{+new Link().toSymbol(member.type)+}}</span></if>
+											
+											<if test="member.isStatic && member.memberOf != '_global_'"><span class="light">{+member.memberOf+}.</span></if><b>{+member.name.replace(/\^\d+$/, '')+}</b>{+makeSignature(member.params)+}
+										</div>
+										
+										<div class="description">
+											{+resolveLinks(member.desc)+}
+											
+											<if test="member.srcFile != data.srcFile">
+												<br />
+												<i>Defined in: </i> {+new Link().toSrc(member.srcFile)+}.
+											</if>
+											
+											<if test="member.author"><br /><i>Author: </i>{+member.author+}.</if>
+										</div>
+										
+										<if test="member.example.length">
+											<for each="example" in="member.example">
+												<pre class="code">{+example+}</pre>
+											</for>
+										</if>
+										
+										<if test="member.params.length">
+											<dl class="detailList params">
+												<dt class="heading">Parameters:</dt>
+												<for each="item" in="member.params">
+													<dt>
+														{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+}<b>{+item.name+}</b>
+														<if test="item.isOptional"><i>Optional<if test="item.defaultValue">, Default: {+item.defaultValue+}</if></i></if>
+													</dt>
+													<dd>{+resolveLinks(item.desc)+}</dd>
+												</for>
+											</dl>
+										</if>
+										
+										<if test="member.deprecated || member.since || member.exceptions.length || member.returns.length || member.requires.length || member.see.length">
+											<dl class="detailList nomargin">
+											
+												<if test="member.deprecated">
+													<dt class="heading">Deprecated:</dt>
+													<dt>
+														{+ resolveLinks(member.deprecated) +}
+													</dt>
+												</if>
+												
+												<if test="member.since">
+													<dt class="heading">Since:</dt>
+													<dd>{+ member.since +}</dd>
+												</if>
+												
+												<if test="member.exceptions.length">
+													<dt class="heading">Throws:</dt>
+													<for each="item" in="member.exceptions">
+														<dt>
+															{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+} <b>{+item.name+}</b>
+														</dt>
+														<dd>{+resolveLinks(item.desc)+}</dd>
+													</for>
+												</if>
+												
+												<if test="member.returns.length">
+													<dt class="heading">Returns:</dt>
+													<for each="item" in="member.returns">
+														<dd>{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+}{+resolveLinks(item.desc)+}</dd>
+													</for>
+												</if>
+												
+												<if test="member.requires.length">
+													<dt class="heading">Requires:</dt>
+													<for each="item" in="member.requires">
+														<dd>{+ resolveLinks(item) +}</dd>
+													</for>
+												</if>
+												
+												<if test="member.see.length">
+													<dt class="heading">See:</dt>
+													<for each="item" in="member.see">
+														<dd>{+ new Link().toSymbol(item) +}</dd>
+													</for>
+												</if>
+											
+											</dl>
+										</if>
+										<if test="!$member_last"><div class="hr"></div></if>
+									</li>
+								</for>
+							</ul>
+						</div>
+					</div>
+				</section>
+			</if>
+			
+	<!--
+	#### EVENT DETAILS
+	-->		
+			<if test="defined(ownEvents) && ownEvents.length">
+				<section>
+					<div class="details props">
+						<div class="innerProps">
+							<h2 class="sectionTitle">
+								Event Detail
+							</h2>
+							
+							<for each="member" in="ownEvents">
+								<div class="fixedFont heading" id="event:{+Link.symbolNameToLinkName(member)+}">
+									<span class='lighter'>
+									{!
+										if (member.isPrivate) output += "&lt;private&gt; ";
+										if (member.isInner) output += "&lt;inner&gt; ";
+										if (member.isStatic) output += "&lt;static&gt; ";
+									!}
+									</span>
+									
+									<if test="member.type"><span class="light">{{+new Link().toSymbol(member.type)+}}</span></if>
+									
+									<if test="member.isStatic && member.memberOf != '_global_'"><span class="light">{+member.memberOf+}.</span></if><b>{+member.name+}</b>{+makeSignature(member.params)+}
+								</div>
+								
+								<div class="description">
+									{+resolveLinks(member.desc)+}
+									
+									<if test="member.srcFile != data.srcFile">
+										<br />
+										<i>Defined in: </i> {+new Link().toSrc(member.srcFile)+}.
+									</if>
+									
+									<if test="member.author"><br /><i>Author: </i>{+member.author+}.</if>
+								</div>
+								
+								<if test="member.example.length">
+									<for each="example" in="member.example">
+										<pre class="code">{+example+}</pre>
+									</for>
+								</if>
+								
+								<if test="member.params.length">
+									<dl class="detailList params">
+										<dt class="heading">Parameters:</dt>
+										<for each="item" in="member.params">
+											<dt>
+												{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+}<b>{+item.name+}</b>
+												<if test="item.isOptional"><i>Optional<if test="item.defaultValue">, Default: {+item.defaultValue+}</if></i></if>
+											</dt>
+											<dd>{+ resolveLinks(item.desc) +}</dd>
+										</for>
+									</dl>
+								</if>
+								
+								<if test="member.deprecated || member.since || member.exceptions.length || member.returns.length || member.see.length">
+									<dl class="detailList nomargin">
+										<if test="member.deprecated">
+											<dt class="heading">Deprecated:</dt>
+											<dt>{+ resolveLinks(member.deprecated) +}</dt>
+										</if>
+										
+										<if test="member.since">
+											<dt class="heading">Since:</dt>
+											<dd>{+ member.since +}</dd>
+										</if>
+										
+										<if test="member.exceptions.length">
+											<dt class="heading">Throws:</dt>
+											<for each="item" in="member.exceptions">
+												<dt>
+													{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+} <b>{+item.name+}</b>
+												</dt>
+												<dd>{+ resolveLinks(item.desc) +}</dd>
+											</for>
+										</if>
+										
+										<if test="member.returns.length">
+											<dt class="heading">Returns:</dt>
+											<for each="item" in="member.returns">
+												<dd>{+((item.type)?"<span class=\"light fixedFont\">{"+(new Link().toSymbol(item.type))+"}</span> " : "")+}{+resolveLinks(item.desc)+}</dd>
+											</for>
+										</if>
+										
+										<if test="member.requires.length">
+											<dt class="heading">Requires:</dt>
+											<for each="item" in="member.requires">
+												<dd>{+ resolveLinks(item) +}</dd>
+											</for>
+										</if>
+										
+										<if test="member.see.length">
+											<dt class="heading">See:</dt>
+											<for each="item" in="member.see">
+												<dd>{+ new Link().toSymbol(item) +}</dd>
+											</for>
+										</if>
+									</dl>
+								</if>
+								
+								<if test="!$member_last"><div class="hr"></div></if>
+							</for>
+						</div>
+					</div>
+				</section>
+			</if>
+		</article>
+	</div>
+</div>
+
+{+subtemplate("subtemplates/foot.tmpl")+}

bin/jsdoc/templates/css/all.css

@@ -0,0 +1,358 @@
+/* TABLE OF CONTENTS:
+ * - Browser reset
+ * - HTML elements
+ * - JsDoc styling
+ */
+
+
+
+
+
+
+/*
+ * BEGIN BROWSER RESET
+ */
+
+body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,p,pre,form,fieldset,input,textarea,p,blockquote,th,td {
+	margin:0;
+	padding:0
+}
+html {
+	height:100%;
+	overflow:-moz-scrollbars-vertical;
+	overflow-x:auto
+}
+table {
+	border:0;
+	border-collapse:collapse;
+	border-spacing:0
+}
+fieldset,img {
+	border:0
+}
+address,caption,cite,code,dfn,em,strong,th,var {
+	font-style:normal;
+	font-weight:normal
+}
+em,cite {
+	font-style:italic
+}
+strong {
+	font-weight:bold
+}
+ol,ul {
+	list-style:none
+}
+caption,th {
+	text-align:left
+}
+h1,h2,h3,h4,h5,h6 {
+	font-size:100%;
+	font-weight:normal;
+	margin:0;
+	padding:0
+}
+q:before,q:after {
+	content:''
+}
+abbr,acronym {
+	border:0
+}
+section,article,header,footer,nav,aside,hgroup {
+	display:block
+}
+
+/*
+ * END BROWSER RESET
+ */
+
+
+
+
+
+
+/*
+ * HTML ELEMENTS
+ */
+
+@font-face {
+	font-family: 'M1m';
+	src: url('fonts/mplus-1m-regular-webfont.eot');
+	src: local('☺'), url('fonts/mplus-1m-regular-webfont.woff') format('woff'), url('fonts/mplus-1m-regular-webfont.ttf') format('truetype'), url('fonts/mplus-1m-regular-webfont.svg#webfontVd14f4NN') format('svg');
+	font-weight: normal;
+	font-style: normal;
+}
+
+@font-face {
+	font-family: 'M1m';
+	src: url('fonts/mplus-1m-bold-webfont.eot');
+	src: local('☺'), url('fonts/mplus-1m-bold-webfont.woff') format('woff'), url('fonts/mplus-1m-bold-webfont.ttf') format('truetype'), url('fonts/mplus-1m-bold-webfont.svg#webfontIjI5mZqE') format('svg');
+	font-weight: bold;
+	font-style: normal;
+}
+
+
+
+* {
+	line-height: 1.4em;
+}
+
+html {
+	font-size: 100%;
+}
+
+body {
+	font-size: 0.75em;
+	padding: 15px 0;
+	background: #eee;
+	background-image: -moz-linear-gradient(left, #dddddd, #f9f9f9) fixed;
+	background-image: -webkit-gradient(linear,left bottom,right bottom,color-stop(0, #dddddd),color-stop(1, #f9f9f9)) fixed;
+  }
+
+body,
+input,
+select,
+textarea {
+	color: #000;
+	font-family: Arial, Geneva, sans-serif;
+}
+
+a:link,
+a:hover,
+a:active,
+a:visited {
+	color: #19199e;
+}
+a:hover,
+a:focus {
+	color: #00f;
+	text-decoration: none;
+}
+
+p {
+	margin: 0 0 1.5em 0;
+}
+
+/*
+ * END HTML ELEMENTS
+ */
+
+
+ 
+/*
+ * BEGIN HACK
+ */
+
+div.containerMain:after,
+div.safeBox:after {
+	content:"";
+	display:block;
+	height:0;
+	clear:both;
+}
+
+/*
+ * END HACK
+ */
+
+
+
+/*
+ * BEGIN JSDOC
+ */
+
+/* Start menu */
+div.index *.heading1 {
+	margin-bottom: 0.5em;
+	border-bottom: 1px solid #999999;
+	font-family: M1m, Arial, sans-serif;
+	font-size: 1.6em;
+	letter-spacing: 1px;
+	line-height: 1.3em;
+}
+ 
+div.index div.menu {
+	background-color: #FFFFFF;
+}
+*+html div.index div.menu {
+	background-color: #FFFFFF;
+}
+* html div.index div.menu {
+	background-color: #FFFFFF;
+}
+
+div.index div.menu div {
+	text-align: left;
+}
+
+div.index div.menu a {
+	text-decoration: none;
+}
+div.index div.menu a:hover {
+	text-decoration: underline;
+}
+
+div.index ul.classList {
+	padding-left: 0;
+}
+
+div.index ul.classList a {
+	display: block;
+	margin: 1px 0;
+	padding: 4px 0 2px 10px;
+	text-indent: -10px;
+}
+
+div.index div.fineprint {
+	color: #777;
+	font-size: 0.9em;
+}
+div.index div.fineprint a {
+	color: #777;
+}
+/* End menu */
+
+
+
+/* Start content */
+div.content ul {
+	padding-left: 0;
+}
+
+div.content *.classTitle {
+	font-size: 1.2em;
+	font-weight: bold;
+	line-height: 1em;
+}
+
+div.content *.classTitle span {
+	display: block;
+	font-size: 2em;
+	letter-spacing: 2px;
+	line-height: 1em;
+	padding-top: 5px;
+	text-shadow: 1px 1px 1px #999999;
+	word-wrap: break-word;
+}
+
+div.content p.summary {
+	font-size: 1.25em;
+}
+
+div.content ul *.classname a,
+div.content ul *.filename a {
+	font-family: Consolas, "Courier New", Courier, monospace;
+	text-decoration: none;
+	font-weight: bold;
+}
+div.content ul *.classname a:hover,
+div.content ul *.filename a:hover {
+	text-decoration: underline;
+}
+
+div.content div.props {
+	-moz-border-radius: 5px;
+	-webkit-border-radius: 5px;
+	border-radius: 5px;
+	background: #fff;
+	background: -moz-linear-gradient(top, rgba(255, 255, 255, 0.7), rgba(255, 255, 255, 0.2)); /* FF3.6 */
+	background: -webkit-gradient(linear,left top,left bottom,color-stop(0, rgba(255, 255, 255, 0.7)),color-stop(1, rgba(255, 255, 255, 0.2)));
+	-moz-box-shadow: 0px 0px 10px #ccc;
+	-webkit-box-shadow: 0px 0px 5px #bbb;
+	box-shadow: 0px 0px 5px #bbb;
+}
+
+
+
+*.sectionTitle {
+	font-family: M1m, sans-serif;
+	font-size: 1.6em;
+	letter-spacing: 1px;
+}
+
+table.summaryTable td,
+table.summaryTable th {
+	vertical-align: top;
+}
+table.summaryTable tr:last-child td {
+	padding-bottom: 0;
+}
+
+table.summaryTable th {
+	font-weight: bold;
+}
+
+table.summaryTable td.attributes {
+	font-family: Consolas, "Courier New", Courier, monospace;
+	color: #666;
+}
+
+table.summaryTable td.nameDescription div.fixedFont {
+	font-weight: bold;
+}
+
+table.summaryTable div.description {
+	color: #333;
+}
+
+
+
+dl.detailList dt {
+	font-weight: bold;
+}
+
+dl.inheritsList dd + dt {
+	margin-top: 10px;
+}
+
+dl.inheritsList dd {
+	display: inline;
+}
+
+
+
+.fixedFont {
+	font-family: Consolas, "Courier New", Courier, monospace;
+}
+
+.fixedFont.heading {
+	font-size: 1.25em;
+	line-height: 1.1em
+}
+
+.fixedFont.heading + .description {
+	font-size: 1.2em;
+}
+
+.fixedFont.heading .light,
+.fixedFont.heading .lighter {
+	font-weight: bold;
+}
+
+pre.code {
+	overflow: auto;
+	font-family: Consolas, "Courier New", Courier, monospace;
+	background: #eee;
+}
+/* Start content */
+
+
+
+/* Start general styles */
+.light {
+	color: #666;
+}
+
+.lighter {
+	color: #999;
+}
+
+span.break {
+	font-size: 1px;
+	line-height:  1px;
+}
+/* End general styles */
+
+/*
+ * END JSDOC
+ */

bin/jsdoc/templates/css/fonts/mplus-1m-bold-webfont.svg

@@ -0,0 +1,134 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>
+This is a custom SVG webfont generated by Font Squirrel.
+Foundry URL : http://mplus-fonts.sourceforge.jp
+</metadata>
+<defs>
+<font id="webfontIjI5mZqE" horiz-adv-x="500" >
+<font-face units-per-em="1000" ascent="860" descent="-140" />
+<missing-glyph horiz-adv-x="500" />
+<glyph unicode=" " />
+<glyph unicode="!" d="M165 730h170l-20 -495h-130zM170 0v150h160v-150h-160z" />
+<glyph unicode="&#x22;" d="M270 780h160l-30 -320h-100zM70 780h160l-30 -320h-100z" />
+<glyph unicode="#" d="M20 165v120h62l24 185h-51v120h67l18 140h135l-18 -140h45l18 140h135l-18 -140h43v-120h-59l-24 -185h48v-120h-64l-21 -165h-135l21 165h-45l-21 -165h-135l21 165h-46zM217 285h45l24 185h-45z" />
+<glyph unicode="$" d="M357 397q55 -32 76.5 -74t21.5 -108q0 -190 -192 -199v-101h-110v112q-51 16 -88 43v140q38 -35 88 -55v191q-53 33 -75.5 75.5t-22.5 103.5q0 89 50 138.5t142 51.5v100h110v-112q42 -12 78 -33v-135q-32 25 -78 42v-180zM247 445v149q-54 -9 -54 -69q0 -55 54 -80z M263 295v-157q52 13 52 77q0 55 -52 80z" />
+<glyph unicode="%" d="M40 310l420 220v-110l-420 -220v110zM160 740q70 0 110 -41t40 -119t-40 -119t-110 -41t-110 41t-40 119t40 119t110 41zM340 310q70 0 110 -41t40 -119t-40 -119t-110 -41t-110 41t-40 119t40 119t110 41zM160 518q38 0 38 62t-38 62t-38 -62t38 -62zM340 88q38 0 38 62 t-38 62t-38 -62t38 -62z" />
+<glyph unicode="&#x26;" d="M235 615q-23 0 -36.5 -14.5t-13.5 -40.5q0 -18 7.5 -37.5t33.5 -65.5q35 30 47 52.5t12 50.5q0 26 -13.5 40.5t-36.5 14.5zM118 368q-47 77 -62.5 116t-15.5 76q0 80 51.5 130t138.5 50t141 -50.5t54 -129.5q0 -114 -130 -220l55 -94v2v132h125v-225q-16 -25 -41 -52 l61 -103h-150l-15 24q-66 -34 -130 -34q-88 0 -136.5 45.5t-48.5 134.5q0 99 103 198zM269 124l-77 125q-27 -37 -27 -74q0 -60 65 -60q20 0 39 9z" />
+<glyph unicode="'" d="M160 780h180l-35 -320h-110z" />
+<glyph unicode="(" d="M100 300q0 136 50 256.5t144 213.5h126q-196 -194 -196 -470t196 -470h-126q-94 93 -144 213.5t-50 256.5z" />
+<glyph unicode=")" d="M400 300q0 -136 -50 -256.5t-144 -213.5h-126q196 194 196 470t-196 470h126q94 -93 144 -213.5t50 -256.5z" />
+<glyph unicode="*" d="M193 750h114l-4 -144l136 48l35 -109l-138 -40l88 -115l-93 -67l-81 119l-81 -119l-93 67l88 115l-138 40l35 109l136 -48z" />
+<glyph unicode="+" d="M315 545v-195h135v-110h-135v-195h-130v195h-135v110h135v195h130z" />
+<glyph unicode="," d="M180 190h190l-130 -320h-120z" />
+<glyph unicode="-" d="M90 240v110h320v-110h-320z" />
+<glyph unicode="." d="M155 0v190h190v-190h-190z" />
+<glyph unicode="/" d="M465 730l-310 -770h-120l310 770h120z" />
+<glyph unicode="0" d="M250 740q73 0 117.5 -32.5t68.5 -116t24 -226.5t-24 -226.5t-68.5 -116t-117.5 -32.5t-117.5 32.5t-68.5 116t-24 226.5t24 226.5t68.5 116t117.5 32.5zM171 317l142 248q-9 34 -24.5 47t-38.5 13q-28 0 -44.5 -19.5t-26 -77.5t-9.5 -163q0 -33 1 -48zM183 179 q9 -41 25.5 -57.5t41.5 -16.5q28 0 44.5 19.5t26 77.5t9.5 163q0 47 -1 67z" />
+<glyph unicode="1" d="M240 592l-2 1l-173 -91v128l175 100h140v-730h-140v592z" />
+<glyph unicode="2" d="M220 122v-2h220v-120h-380v120q127 141 181 237t54 173q0 43 -21 66.5t-59 23.5q-31 0 -74 -22t-81 -58v130q78 70 185 70q90 0 140 -51t50 -149q0 -180 -215 -418z" />
+<glyph unicode="3" d="M290 608v2h-230v120h385v-120l-170 -178v-2h10q79 0 122 -51.5t43 -153.5q0 -121 -54 -178t-166 -57q-51 0 -81.5 6.5t-78.5 28.5v130q80 -45 150 -45q46 0 68 27t22 88q0 58 -26 76.5t-114 18.5h-40v120z" />
+<glyph unicode="4" d="M400 150v-150h-135v150h-245v120l230 460h150v-460h80v-120h-80zM265 270v255h-2l-127 -253v-2h129z" />
+<glyph unicode="5" d="M202 455q36 19 82 19q161 0 161 -239q0 -245 -230 -245q-76 0 -150 35v130q80 -45 140 -45q51 0 75.5 29t24.5 96t-14.5 93t-46.5 26q-34 0 -64 -34h-110l10 410h345v-120h-220l-5 -155h2z" />
+<glyph unicode="6" d="M295 625q-54 0 -76.5 -34.5t-28.5 -135.5h2q45 35 98 35q92 0 133.5 -54.5t41.5 -185.5q0 -141 -51 -200.5t-159 -59.5q-75 0 -119 28.5t-67.5 101t-23.5 200.5q0 162 25 254t75 129t135 37q66 0 135 -20v-125q-57 30 -120 30zM255 107q39 0 55.5 29.5t16.5 113.5 q0 79 -14 104.5t-53 25.5q-38 0 -56.5 -29.5t-18.5 -100.5q0 -81 17 -112t53 -31z" />
+<glyph unicode="7" d="M55 730h390v-120q-113 -273 -200 -610h-146q92 325 216 608v2h-260v120z" />
+<glyph unicode="8" d="M258 625q-41 0 -59.5 -20.5t-18.5 -64.5q0 -74 75 -105q33 16 51.5 43.5t18.5 61.5q0 40 -18 62.5t-49 22.5zM250 -10q-105 0 -162.5 52t-57.5 148q0 116 105 179v2q-42 31 -66 80t-24 104q0 87 53.5 136t151.5 49t151.5 -48.5t53.5 -136.5q0 -98 -100 -164v-2 q115 -62 115 -199q0 -96 -58 -148t-162 -52zM242 105q93 0 93 100q0 75 -103 115q-33 -17 -52.5 -48.5t-19.5 -66.5q0 -48 22.5 -74t59.5 -26z" />
+<glyph unicode="9" d="M205 110q55 0 77 32.5t28 132.5h-2q-45 -35 -98 -35q-89 0 -132 57.5t-43 192.5q0 131 51 190.5t159 59.5q79 0 123 -27.5t65.5 -99.5t21.5 -203q0 -162 -25 -254t-75 -129t-135 -37q-66 0 -135 20v130q57 -30 120 -30zM245 623q-39 0 -55.5 -28t-16.5 -105 q0 -83 15.5 -111.5t51.5 -28.5q75 0 75 140q0 73 -17 103t-53 30z" />
+<glyph unicode=":" d="M160 390v190h180v-190h-180zM160 0v190h180v-190h-180z" />
+<glyph unicode=";" d="M170 190h190l-130 -320h-120zM170 390v190h180v-190h-180z" />
+<glyph unicode="&#x3c;" d="M445 470l-320 -174v-2l320 -174v-120l-400 225v140l400 225v-120z" />
+<glyph unicode="=" d="M50 125v110h400v-110h-400zM50 362v103h400v-103h-400z" />
+<glyph unicode="&#x3e;" d="M55 470v120l400 -225v-140l-400 -225v120l320 174v2z" />
+<glyph unicode="?" d="M460 575q0 -36 -12.5 -69t-25 -51t-38.5 -49q-25 -30 -38 -48.5t-27.5 -52.5t-18.5 -70h-130q0 49 17 94.5t32 66.5t44 57q21 25 30.5 38t19 33.5t9.5 40.5q0 58 -82 58t-180 -53v130q95 40 200 40q95 0 147.5 -44t52.5 -121zM155 0v150h160v-150h-160z" />
+<glyph unicode="@" d="M285 635q-72 0 -108.5 -62.5t-36.5 -207.5q0 -265 160 -265q58 0 125 30v-115q-70 -25 -150 -25q-260 0 -260 375q0 194 64 284.5t191 90.5q99 0 152 -51.5t53 -148.5v-325q-28 -28 -76 -46.5t-94 -18.5q-69 0 -102 49t-33 166q0 114 31.5 164.5t93.5 50.5q36 0 68 -25h2 v15q0 26 -23.5 45.5t-56.5 19.5zM290 365q0 -72 8 -93.5t29 -21.5q20 0 28 18v147q0 41 -6 53t-25 12t-26.5 -22t-7.5 -93z" />
+<glyph unicode="A" d="M249 620h-2l-55 -335h112zM323 170h-150l-28 -170h-140l165 730h160l165 -730h-144z" />
+<glyph unicode="B" d="M190 445h15q59 0 85 20.5t26 64.5q0 49 -23 71t-73 22q-17 0 -30 -5v-173zM190 330v-218q20 -5 45 -5q51 0 75 27.5t24 90.5q0 57 -25.5 81t-88.5 24h-30zM470 210q0 -220 -240 -220q-93 0 -180 15v720q92 15 190 15q210 0 210 -185q0 -62 -32 -105t-83 -54v-2 q57 -10 96 -61.5t39 -122.5z" />
+<glyph unicode="C" d="M30 365q0 195 64.5 285t190.5 90q80 0 150 -25v-115q-70 25 -125 25q-74 0 -109.5 -58.5t-35.5 -201.5q0 -260 150 -260q57 0 125 30v-120q-70 -25 -150 -25q-260 0 -260 375z" />
+<glyph unicode="D" d="M344 365q0 142 -30 198.5t-94 56.5q-23 0 -40 -5v-500q17 -5 40 -5q63 0 93.5 55.5t30.5 199.5zM480 365q0 -144 -28.5 -226.5t-83.5 -115.5t-148 -33q-92 0 -180 15v720q88 15 180 15q141 0 200.5 -82t59.5 -293z" />
+<glyph unicode="E" d="M210 610v-165h220v-115h-220v-210h230v-120h-370v730h370v-120h-230z" />
+<glyph unicode="F" d="M220 330v-330h-140v730h360v-120h-220v-165h210v-115h-210z" />
+<glyph unicode="G" d="M310 625q-82 0 -116 -55t-34 -205q0 -143 32 -201.5t93 -58.5q27 0 48 10v215h-98v115h230v-415q-83 -40 -180 -40q-260 0 -260 375q0 196 69.5 285.5t215.5 89.5q70 0 130 -25v-115q-72 25 -130 25z" />
+<glyph unicode="H" d="M318 330h-140v-330h-138v730h138v-280h140v280h142v-730h-142v330z" />
+<glyph unicode="I" d="M430 0h-360v115h108v500h-108v115h360v-115h-108v-500h108v-115z" />
+<glyph unicode="J" d="M410 730v-515q0 -126 -48.5 -175.5t-166.5 -49.5q-86 0 -155 30v130q29 -18 68 -30t67 -12q50 0 71 26.5t21 95.5v385h-147v115h290z" />
+<glyph unicode="K" d="M192 330h-2v-330h-140v730h140v-300h2l135 300h148l-160 -345l165 -385h-150z" />
+<glyph unicode="L" d="M230 730v-610h210v-120h-350v730h140z" />
+<glyph unicode="M" d="M338 500h-2l-38 -300h-100l-38 300h-2v-500h-133v730h167l59 -400h2l59 400h163v-730h-137v500z" />
+<glyph unicode="N" d="M187 460h-2v-460h-140v730h147l125 -460h2v460h136v-730h-143z" />
+<glyph unicode="O" d="M250 740q121 0 175.5 -84t54.5 -291t-54.5 -291t-175.5 -84t-175.5 84t-54.5 291t54.5 291t175.5 84zM250 108q52 0 75 53.5t23 203.5t-23 203.5t-75 53.5t-75 -53.5t-23 -203.5t23 -203.5t75 -53.5z" />
+<glyph unicode="P" d="M334 503q0 120 -104 120q-23 0 -40 -5v-235q18 -5 40 -5q53 0 78.5 28t25.5 97zM470 503q0 -127 -57 -184.5t-173 -57.5q-26 0 -50 5v-266h-140v725q90 15 185 15q122 0 178.5 -56t56.5 -181z" />
+<glyph unicode="Q" d="M250 740q121 0 175.5 -84t54.5 -291q0 -257 -92 -333v-2q39 -22 68.5 -74t33.5 -106h-145q-15 81 -36.5 110.5t-58.5 29.5q-121 0 -175.5 84t-54.5 291t54.5 291t175.5 84zM250 108q52 0 75 53.5t23 203.5t-23 203.5t-75 53.5t-75 -53.5t-23 -203.5t23 -203.5t75 -53.5z " />
+<glyph unicode="R" d="M465 513q0 -151 -98 -199l-1 -2q27 -19 58 -118l61 -194h-145l-57 204q-12 43 -25.5 57.5t-42.5 14.5h-30v-276h-140v725q90 15 185 15q124 0 179.5 -53.5t55.5 -173.5zM185 393h30q64 0 89 24.5t25 95.5q0 58 -25.5 84t-78.5 26q-23 0 -40 -5v-225z" />
+<glyph unicode="S" d="M440 575q-84 48 -165 48q-41 0 -65 -21t-24 -57q0 -71 69 -100q116 -48 160.5 -103t44.5 -142q0 -210 -225 -210q-100 0 -180 50v135q83 -68 173 -68q94 0 94 88q0 76 -77 110q-108 46 -151.5 99.5t-43.5 135.5q0 90 57 145t153 55q102 0 180 -35v-130z" />
+<glyph unicode="T" d="M320 615v-615h-140v615h-145v115h430v-115h-145z" />
+<glyph unicode="U" d="M250 -10q-112 0 -161 54t-49 186v500h142v-460q0 -101 14.5 -131.5t55.5 -30.5t55.5 30.5t14.5 131.5v460h138v-500q0 -132 -49 -186t-161 -54z" />
+<glyph unicode="V" d="M253 110l92 620h140l-155 -730h-160l-155 730h144l92 -620h2z" />
+<glyph unicode="W" d="M164 190h2l38 440h100l38 -440h2l15 540h126l-45 -730h-157l-34 420h-2l-34 -420h-153l-45 730h134z" />
+<glyph unicode="X" d="M251 470h2l74 260h145l-132 -360l135 -370h-152l-74 270h-2l-74 -270h-148l135 370l-132 360h149z" />
+<glyph unicode="Y" d="M251 415h2l84 315h148l-165 -455v-275h-140v275l-165 455h152z" />
+<glyph unicode="Z" d="M290 613v2h-235v115h390v-115l-235 -498v-2h235v-115h-390v115z" />
+<glyph unicode="[" d="M410 675h-170v-750h170v-95h-290v940h290v-95z" />
+<glyph unicode="\" d="M35 730h120l310 -770h-120z" />
+<glyph unicode="]" d="M90 675v95h290v-940h-290v95h170v750h-170z" />
+<glyph unicode="^" d="M251 655h-2l-111 -375h-123l145 450h180l145 -450h-123z" />
+<glyph unicode="_" d="M40 -170v88h420v-88h-420z" />
+<glyph unicode="`" d="M90 810h190l100 -320h-120z" />
+<glyph unicode="a" d="M65 495q39 14 95 24.5t90 10.5q111 0 155.5 -45t44.5 -160v-325h-127l-2 65h-2q-49 -75 -134 -75q-68 0 -106.5 42t-38.5 118q0 88 63.5 136.5t186.5 48.5h25v10q0 40 -16 56.5t-54 16.5q-32 0 -86.5 -11.5t-93.5 -26.5v115zM315 245h-25q-59 0 -89.5 -23t-30.5 -62 q0 -31 15 -48t40 -17q90 0 90 130v20z" />
+<glyph unicode="b" d="M45 730h137v-275h2q49 75 116 75q83 0 129 -66.5t46 -203.5q0 -133 -47.5 -201.5t-127.5 -68.5q-35 0 -62.5 17.5t-56.5 62.5h-2l-2 -70h-132v730zM338 260q0 150 -78 150q-80 0 -80 -145v-10q0 -145 80 -145q35 0 56.5 36.5t21.5 113.5z" />
+<glyph unicode="c" d="M305 420q-115 0 -115 -160q0 -163 120 -163q60 0 120 28v-110q-68 -25 -140 -25q-116 0 -178 67.5t-62 202.5t60 202.5t175 67.5q67 0 135 -25v-110q-61 25 -115 25z" />
+<glyph unicode="d" d="M455 0h-132l-2 70h-2q-29 -45 -56.5 -62.5t-62.5 -17.5q-80 0 -127.5 68.5t-47.5 201.5q0 137 46 203.5t129 66.5q67 0 116 -75h2v275h137v-730zM162 260q0 -77 21.5 -113.5t56.5 -36.5q80 0 80 145v10q0 145 -80 145q-78 0 -78 -150z" />
+<glyph unicode="e" d="M182 206q7 -62 33 -85.5t80 -23.5q52 0 135 28v-110q-84 -25 -155 -25q-112 0 -173.5 68t-61.5 202q0 270 220 270q200 0 200 -270q0 -31 -2 -54h-276zM181 310h142q-1 63 -15.5 88t-47.5 25q-41 0 -58 -23t-21 -90z" />
+<glyph unicode="f" d="M60 391v109h100v45q0 104 40.5 149.5t129.5 45.5q56 0 110 -15v-110q-36 16 -80 16q-37 0 -50 -20.5t-13 -85.5v-25h143v-109h-143v-391h-137v391h-100z" />
+<glyph unicode="g" d="M323 75h-2q-45 -75 -116 -75q-78 0 -126.5 66.5t-48.5 193.5q0 137 46 203.5t129 66.5q35 0 62.5 -17.5t56.5 -62.5h2l2 70h132v-505q0 -245 -240 -245q-81 0 -150 25v115q76 -33 145 -33q55 0 81.5 34t26.5 114v50zM167 260q0 -70 22 -105t56 -35q80 0 80 135v10 q0 145 -80 145q-78 0 -78 -150z" />
+<glyph unicode="h" d="M50 730h137v-275h2q47 75 126 75t112 -47.5t33 -172.5v-310h-135v290q0 74 -12.5 98t-47.5 24t-56.5 -43.5t-21.5 -131.5v-237h-137v730z" />
+<glyph unicode="i" d="M110 520h240v-413h100v-107h-370v107h130v306h-100v107zM190 630v130h160v-130h-160z" />
+<glyph unicode="j" d="M225 -20v433h-110v107h250v-540q0 -68 -10.5 -106t-44 -63t-87.5 -33t-148 -8v109q39 0 60.5 0.5t41 5t27 9.5t13.5 18t7 27.5t1 40.5zM205 630v130h160v-130h-160z" />
+<glyph unicode="k" d="M480 520l-185 -250l185 -270h-162l-131 224v-224h-137v730h137v-418l133 208h160z" />
+<glyph unicode="l" d="M310 190q0 -68 9 -80.5t56 -12.5q31 0 75 6v-108q-44 -5 -100 -5q-111 0 -145.5 32.5t-34.5 137.5v463h-120v107h260v-540z" />
+<glyph unicode="m" d="M360 0v340q0 40 -21 40q-8 0 -12.5 -5t-7 -22.5t-2.5 -52.5v-300h-130v340q0 40 -21 40q-8 0 -12.5 -5t-7 -22.5t-2.5 -52.5v-300h-134v520h120l2 -65h2q15 34 39.5 54.5t48.5 20.5q28 0 45 -16t32 -59h2q42 75 99 75q48 0 69 -36t21 -134v-360h-130z" />
+<glyph unicode="n" d="M50 520h132l2 -70h2q49 80 129 80q79 0 112 -47.5t33 -172.5v-310h-135v290q0 74 -12.5 98t-47.5 24t-56.5 -43.5t-21.5 -131.5v-237h-137v520z" />
+<glyph unicode="o" d="M250 530q220 0 220 -270t-220 -270t-220 270t220 270zM250 97q44 0 62 33.5t18 129.5t-18 129.5t-62 33.5t-62 -33.5t-18 -129.5t18 -129.5t62 -33.5z" />
+<glyph unicode="p" d="M179 70h-2v-290h-137v740h132l2 -70h2q29 45 56.5 62.5t62.5 17.5q83 0 129 -66.5t46 -203.5q0 -133 -47.5 -201.5t-127.5 -68.5q-71 0 -116 80zM333 260q0 150 -78 150q-80 0 -80 -145v-10q0 -145 80 -145q35 0 56.5 36.5t21.5 113.5z" />
+<glyph unicode="q" d="M321 70q-45 -80 -116 -80q-80 0 -127.5 68.5t-47.5 201.5q0 137 46 203.5t129 66.5q35 0 62.5 -17.5t56.5 -62.5h2l2 70h132v-740h-137v290h-2zM167 260q0 -77 21.5 -113.5t56.5 -36.5q80 0 80 145v10q0 145 -80 145q-78 0 -78 -150z" />
+<glyph unicode="r" d="M375 416q-69 0 -111 -52t-42 -144v-220h-137v520h135v-85h2q36 53 70.5 74t82.5 21q36 0 70 -10v-115q-36 11 -70 11z" />
+<glyph unicode="s" d="M265 418q-73 0 -73 -43q0 -22 14.5 -35t48.5 -20q109 -21 149.5 -60t40.5 -115q0 -74 -50.5 -114.5t-144.5 -40.5q-107 0 -190 35v120q87 -43 165 -43q45 0 64 11.5t19 36.5q0 22 -14 34t-54 21q-99 21 -142 62.5t-43 112.5t49 110.5t146 39.5q99 0 180 -30v-115 q-87 33 -165 33z" />
+<glyph unicode="t" d="M445 500v-109h-158v-201q0 -61 10.5 -74.5t57.5 -13.5q43 0 80 17v-114q-50 -15 -110 -15q-98 0 -136.5 36.5t-38.5 133.5v231h-105v109h105v190h137v-190h158z" />
+<glyph unicode="u" d="M445 0h-132l-2 70h-2q-50 -80 -124 -80q-77 0 -108.5 44.5t-31.5 165.5v320h135v-300q0 -70 11 -91t44 -21q73 0 73 175v237h137v-520z" />
+<glyph unicode="v" d="M251 90h2l79 430h138l-130 -520h-180l-130 520h142z" />
+<glyph unicode="w" d="M343 120h2l29 400h116l-70 -520h-137l-37 358h-2l-31 -358h-133l-70 520h124l29 -400h2l39 400h100z" />
+<glyph unicode="x" d="M251 335h2l69 185h143l-125 -260l125 -260h-152l-64 180h-2l-64 -180h-148l125 260l-125 260h147z" />
+<glyph unicode="y" d="M254 170h2l87 350h142l-237 -740h-138l85 230l-170 510h142z" />
+<glyph unicode="z" d="M275 411h-210v109h370v-109l-210 -300v-2h210v-109h-370v109l210 300v2z" />
+<glyph unicode="{" d="M187 301v-2q58 -24 85.5 -62t27.5 -100v-112q0 -73 12 -86.5t75 -13.5h53v-95h-107q-80 0 -116.5 37t-36.5 123v147q0 61 -22 88t-68 27h-40v96h40q46 0 68 27t22 88v147q0 86 36.5 123t116.5 37h107v-95h-53q-63 0 -75 -13.5t-12 -86.5v-112q0 -62 -27.5 -100t-85.5 -62 z" />
+<glyph unicode="|" d="M188 -220v1030h124v-1030h-124z" />
+<glyph unicode="}" d="M313 301q-58 24 -85.5 62t-27.5 100v112q0 73 -12 86.5t-75 13.5h-53v95h107q80 0 116.5 -37t36.5 -123v-147q0 -61 22 -88t68 -27h40v-96h-40q-46 0 -68 -27t-22 -88v-147q0 -86 -36.5 -123t-116.5 -37h-107v95h53q63 0 75 13.5t12 86.5v112q0 62 27.5 100t85.5 62v2z " />
+<glyph unicode="~" d="M40 568v107q45 35 100 35q63 0 131 -50q49 -37 84 -37q49 0 105 51v-107q-45 -35 -100 -35q-63 0 -131 50q-49 37 -84 37q-49 0 -105 -51z" />
+<glyph unicode="&#xa0;" />
+<glyph unicode="&#xa5;" d="M251 415h2l84 315h148l-132 -365h97v-95h-130v-65h130v-95h-130v-110h-140v110h-130v95h130v65h-130v95h97l-132 365h152z" />
+<glyph unicode="&#xad;" d="M90 240v110h320v-110h-320z" />
+<glyph unicode="&#x2000;" horiz-adv-x="407" />
+<glyph unicode="&#x2001;" horiz-adv-x="815" />
+<glyph unicode="&#x2002;" horiz-adv-x="407" />
+<glyph unicode="&#x2003;" horiz-adv-x="815" />
+<glyph unicode="&#x2004;" horiz-adv-x="271" />
+<glyph unicode="&#x2005;" horiz-adv-x="203" />
+<glyph unicode="&#x2006;" horiz-adv-x="135" />
+<glyph unicode="&#x2007;" horiz-adv-x="135" />
+<glyph unicode="&#x2008;" horiz-adv-x="101" />
+<glyph unicode="&#x2009;" horiz-adv-x="163" />
+<glyph unicode="&#x200a;" horiz-adv-x="45" />
+<glyph unicode="&#x2010;" d="M90 240v110h320v-110h-320z" />
+<glyph unicode="&#x2011;" d="M90 240v110h320v-110h-320z" />
+<glyph unicode="&#x2013;" d="M50 240v110h400v-110h-400z" />
+<glyph unicode="&#x2014;" d="M10 240v110h480v-110h-480z" />
+<glyph unicode="&#x2018;" d="M305 460h-190l130 320h120z" />
+<glyph unicode="&#x2019;" d="M190 780h190l-130 -320h-120z" />
+<glyph unicode="&#x201c;" d="M405 460h-170l130 320h100zM195 460h-170l130 320h100z" />
+<glyph unicode="&#x201d;" d="M300 780h170l-130 -320h-100zM90 780h170l-130 -320h-100z" />
+<glyph unicode="&#x2026;" horiz-adv-x="1000" d="M72 270v190h190v-190h-190zM405 270v190h190v-190h-190zM738 270v190h190v-190h-190z" />
+<glyph unicode="&#x202f;" horiz-adv-x="163" />
+<glyph unicode="&#x205f;" horiz-adv-x="203" />
+<glyph unicode="&#x2122;" horiz-adv-x="1000" d="M838 500h-2l-38 -300h-100l-38 300h-2v-500h-133v730h167l59 -400h2l59 400h163v-730h-137v500zM320 615v-615h-140v615h-145v115h430v-115h-145z" />
+</font>
+</defs></svg> 

bin/jsdoc/templates/css/fonts/mplus-1m-regular-webfont.svg

@@ -0,0 +1,134 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>
+This is a custom SVG webfont generated by Font Squirrel.
+Foundry URL : http://mplus-fonts.sourceforge.jp
+</metadata>
+<defs>
+<font id="webfontVd14f4NN" horiz-adv-x="500" >
+<font-face units-per-em="1000" ascent="860" descent="-140" />
+<missing-glyph horiz-adv-x="500" />
+<glyph unicode=" " />
+<glyph unicode="!" d="M200 730h100l-10 -515h-80zM195 0v130h110v-130h-110z" />
+<glyph unicode="&#x22;" d="M275 780h100l-20 -280h-60zM125 780h100l-20 -280h-60z" />
+<glyph unicode="#" d="M40 188v72h77l29 228h-71v72h80l21 170h82l-21 -170h76l21 170h82l-21 -170h65v-72h-74l-29 -228h68v-72h-77l-23 -188h-82l23 188h-76l-23 -188h-82l23 188h-68zM199 260h76l29 228h-76z" />
+<glyph unicode="$" d="M293 311v-214q58 21 58 108q0 71 -58 106zM293 19v-104h-76v101q-70 6 -137 49v95q65 -57 137 -69v251q-77 31 -109.5 75.5t-32.5 117.5q0 76 37 122.5t105 55.5v102h76v-102q69 -8 127 -38v-90q-52 38 -127 52v-237q77 -31 109.5 -76.5t32.5 -118.5q0 -163 -142 -186z M217 429v207q-58 -18 -58 -101q0 -73 58 -106z" />
+<glyph unicode="%" d="M60 260l380 290v-80l-380 -290v80zM160 740q61 0 95.5 -41t34.5 -119t-34.5 -119t-95.5 -41t-95.5 41t-34.5 119t34.5 119t95.5 41zM340 310q61 0 95.5 -41t34.5 -119t-34.5 -119t-95.5 -41t-95.5 41t-34.5 119t34.5 119t95.5 41zM160 488q52 0 52 92t-52 92t-52 -92 t52 -92zM340 58q52 0 52 92t-52 92t-52 -92t52 -92z" />
+<glyph unicode="&#x26;" d="M228 665q-38 0 -60.5 -20t-22.5 -55q0 -29 12.5 -59t53.5 -95q59 51 79 83.5t20 70.5q0 33 -22 54t-60 21zM151 385l-9 14q-47 71 -63.5 111.5t-16.5 79.5q0 66 45 108t118 42t119 -42t46 -108q0 -57 -30.5 -106.5t-106.5 -112.5l119 -183v217h80v-253q-13 -28 -26 -46 l69 -106h-87l-33 49q-69 -59 -175 -59q-82 0 -128.5 46t-46.5 129q0 107 126 220zM331 115l-137 206q-84 -79 -84 -153q0 -51 27 -77t78 -26q70 0 116 50z" />
+<glyph unicode="'" d="M195 780h110l-25 -280h-60z" />
+<glyph unicode="(" d="M125 315q0 275 194 455h76q-196 -184 -196 -455t196 -455h-76q-194 180 -194 455z" />
+<glyph unicode=")" d="M375 315q0 -275 -194 -455h-76q196 184 196 455t-196 455h76q194 -180 194 -455z" />
+<glyph unicode="*" d="M214 750h72l-3 -169l160 55l22 -68l-161 -50l101 -135l-58 -42l-97 138l-97 -138l-58 42l101 135l-161 50l22 68l160 -55z" />
+<glyph unicode="+" d="M291 555v-214h149v-72h-149v-214h-82v214h-149v72h149v214h82z" />
+<glyph unicode="," d="M210 150h120l-110 -280h-70z" />
+<glyph unicode="-" d="M100 269v72h300v-72h-300z" />
+<glyph unicode="." d="M185 0v150h130v-150h-130z" />
+<glyph unicode="/" d="M452 730l-332 -770h-72l332 770h72z" />
+<glyph unicode="0" d="M250 740q48 0 82 -18t59 -60t37 -115.5t12 -181.5t-12 -181.5t-37 -115.5t-59 -60t-82 -18t-82 18t-59 60t-37 115.5t-12 181.5t12 181.5t37 115.5t59 60t82 18zM142 249l196 339q-26 82 -88 82q-36 0 -60 -26t-38 -95t-14 -184q0 -50 4 -116zM158 155q26 -95 92 -95 q36 0 60 26t38 95t14 184q0 78 -6 133z" />
+<glyph unicode="1" d="M258 0v645l-2 1l-173 -101v80l175 105h82v-730h-82z" />
+<glyph unicode="2" d="M175 74v-2h245v-72h-340v72q251 288 251 478q0 116 -93 116q-30 0 -76 -22.5t-82 -55.5v87q75 65 170 65q85 0 125 -47t40 -143q0 -99 -54 -208t-186 -268z" />
+<glyph unicode="3" d="M330 656v2h-250v72h345v-72l-180 -229v-2h10q91 0 133 -51t42 -166q0 -220 -195 -220q-73 0 -145 30v87q77 -43 130 -43q64 0 95 34.5t31 111.5q0 89 -25 117t-101 28h-70v72z" />
+<glyph unicode="4" d="M293 590h-2l-175 -341v-2h177v343zM293 175h-253v82l243 473h92v-483h85v-72h-85v-175h-82v175z" />
+<glyph unicode="5" d="M180 430h2q33 30 88 30q160 0 160 -230q0 -125 -49.5 -182.5t-145.5 -57.5q-74 0 -145 30v87q75 -43 140 -43q116 0 116 166q0 156 -96 156q-46 0 -80 -41h-75l10 385h305v-72h-223z" />
+<glyph unicode="6" d="M285 740q61 0 115 -20v-77q-50 25 -105 25q-70 0 -101 -48.5t-39 -184.5h2q50 50 113 50q87 0 128.5 -56t41.5 -184q0 -134 -46.5 -194.5t-138.5 -60.5q-65 0 -104 28.5t-60 101.5t-21 200q0 158 25.5 252t71 131t118.5 37zM255 62q54 0 78.5 39t24.5 144q0 94 -23.5 132 t-74.5 38q-106 0 -106 -160q0 -107 25 -150t76 -43z" />
+<glyph unicode="7" d="M345 656v2h-270v72h350v-72q-128 -296 -210 -658h-88q84 353 218 656z" />
+<glyph unicode="8" d="M255 670q-53 0 -81.5 -27.5t-28.5 -77.5q0 -54 29 -94t76 -51q52 14 80.5 51.5t28.5 93.5q0 47 -28.5 76t-75.5 29zM250 -10q-96 0 -148 51t-52 149q0 68 33 119t92 75v2q-48 23 -79 73.5t-31 105.5q0 82 49 128.5t136 46.5t136 -47t49 -128q0 -56 -30.5 -103.5 t-79.5 -70.5v-2q59 -23 92 -75t33 -124q0 -98 -52 -149t-148 -51zM255 60q53 0 84 33.5t31 96.5q0 130 -125 160q-61 -16 -90 -54.5t-29 -105.5q0 -62 35 -96t94 -34z" />
+<glyph unicode="9" d="M215 -10q-61 0 -115 20v80q52 -26 105 -26q70 0 101 47.5t39 183.5h-2q-50 -50 -113 -50q-84 0 -127 59t-43 191q0 126 46 185.5t139 59.5q68 0 107 -28t58.5 -100.5t19.5 -201.5q0 -158 -25.5 -252t-71 -131t-118.5 -37zM245 668q-55 0 -79 -38t-24 -135t25 -138.5 t73 -41.5q49 0 77.5 41.5t28.5 128.5q0 100 -25 141.5t-76 41.5z" />
+<glyph unicode=":" d="M190 390v150h120v-150h-120zM190 0v150h120v-150h-120z" />
+<glyph unicode=";" d="M200 150h120l-110 -280h-70zM200 390v150h120v-150h-120z" />
+<glyph unicode="&#x3c;" d="M435 510l-330 -204v-2l330 -204v-80l-380 245v80l380 245v-80z" />
+<glyph unicode="=" d="M60 165v72h380v-72h-380zM60 373v72h380v-72h-380z" />
+<glyph unicode="&#x3e;" d="M65 510v80l380 -245v-80l-380 -245v80l330 204v2z" />
+<glyph unicode="?" d="M445 580q0 -41 -14 -77t-28.5 -55t-42.5 -49q-29 -33 -43 -52t-28 -55t-14 -77h-80q0 55 16.5 101.5t32.5 68t47 56.5q24 27 36 42.5t23 41.5t11 55q0 41 -29.5 63.5t-86.5 22.5q-85 0 -180 -61v90q93 45 190 45q91 0 140.5 -42t49.5 -118zM180 0v130h110v-130h-110z" />
+<glyph unicode="@" d="M375 258v167q0 41 -16 63t-44 22q-40 0 -56 -29.5t-16 -115.5q0 -82 17 -113.5t55 -31.5q44 0 60 38zM165 365q0 215 140 215q38 0 73 -25h2v5q0 50 -27.5 79t-72.5 29q-83 0 -124 -70.5t-41 -232.5q0 -166 40 -234.5t125 -68.5q62 0 125 38v-80q-59 -30 -130 -30 q-122 0 -181 86t-59 289q0 197 60.5 286t179.5 89q87 0 133.5 -50t46.5 -150v-325q-65 -65 -140 -65q-76 0 -113 49t-37 166z" />
+<glyph unicode="A" d="M249 660h-2l-83 -380h168zM348 210h-200l-46 -210h-82l180 730h100l180 -730h-86z" />
+<glyph unicode="B" d="M157 430h45q80 0 116.5 29.5t36.5 90.5q0 57 -36 88.5t-102 31.5q-36 0 -60 -8v-232zM157 360v-292q37 -8 90 -8q126 0 126 160q0 140 -161 140h-55zM455 210q0 -220 -225 -220q-80 0 -155 15v720q75 15 155 15q205 0 205 -180q0 -61 -30.5 -103t-84.5 -56v-2 q58 -11 96.5 -64t38.5 -125z" />
+<glyph unicode="C" d="M55 365q0 197 60.5 286t179.5 89q66 0 125 -30v-75q-60 33 -120 33q-165 0 -165 -303q0 -164 42 -233.5t123 -69.5q62 0 125 38v-80q-59 -30 -130 -30q-122 0 -181 86t-59 289z" />
+<glyph unicode="D" d="M383 365q0 168 -43.5 235.5t-137.5 67.5q-33 0 -55 -8v-590q22 -8 55 -8q65 0 102.5 24.5t58 91.5t20.5 187zM465 365q0 -207 -63.5 -291t-199.5 -84q-70 0 -137 15v720q67 15 137 15q137 0 200 -85.5t63 -289.5z" />
+<glyph unicode="E" d="M162 658v-228h248v-70h-248v-288h258v-72h-340v730h340v-72h-258z" />
+<glyph unicode="F" d="M172 360v-360h-82v730h330v-72h-248v-228h238v-70h-238z" />
+<glyph unicode="G" d="M370 85v275h-155v70h235v-400q-80 -40 -170 -40q-118 0 -179 89t-61 286q0 196 63.5 285.5t191.5 89.5q59 0 130 -25v-77q-66 30 -130 30q-87 0 -132 -72t-45 -231q0 -303 167 -303q45 0 85 23z" />
+<glyph unicode="H" d="M140 730v-298h216v298h84v-730h-84v360h-216v-360h-80v730h80z" />
+<glyph unicode="I" d="M410 0h-320v70h118v590h-118v70h320v-70h-118v-590h118v-70z" />
+<glyph unicode="J" d="M400 730v-540q0 -110 -43.5 -155t-146.5 -45q-82 0 -150 30v87q29 -17 75.5 -31t74.5 -14q53 0 79 30.5t26 99.5v468h-165v70h250z" />
+<glyph unicode="K" d="M157 400h2l206 330h95l-225 -350l230 -380h-95l-211 360h-2v-360h-82v730h82v-330z" />
+<glyph unicode="L" d="M182 730v-658h238v-72h-320v730h82z" />
+<glyph unicode="M" d="M378 540h-2l-88 -340h-80l-88 340h-2v-540h-78v730h92l119 -450h2l119 450h88v-730h-82v540z" />
+<glyph unicode="N" d="M151 550h-2v-550h-84v730h84l204 -550h2v550h80v-730h-80z" />
+<glyph unicode="O" d="M250 740q107 0 158.5 -84.5t51.5 -290.5t-51.5 -290.5t-158.5 -84.5t-158.5 84.5t-51.5 290.5t51.5 290.5t158.5 84.5zM250 62q44 0 71 25.5t43 93.5t16 184t-16 184t-43 93.5t-71 25.5t-71 -25.5t-43 -93.5t-16 -184t16 -184t43 -93.5t71 -25.5z" />
+<glyph unicode="P" d="M375 520q0 79 -36 114.5t-112 35.5q-41 0 -70 -8v-292q30 -5 70 -5q77 0 112.5 35.5t35.5 119.5zM455 520q0 -120 -52.5 -172.5t-165.5 -52.5q-35 0 -80 5v-300h-82v725q78 15 160 15q114 0 167 -52.5t53 -167.5z" />
+<glyph unicode="Q" d="M250 740q107 0 158.5 -84.5t51.5 -290.5q0 -273 -100 -344v-2q41 -21 73 -66t47 -103h-88q-21 78 -54 109t-88 31q-107 0 -158.5 84.5t-51.5 290.5t51.5 290.5t158.5 84.5zM250 62q44 0 71 25.5t43 93.5t16 184t-16 184t-43 93.5t-71 25.5t-71 -25.5t-43 -93.5t-16 -184 t16 -184t43 -93.5t71 -25.5z" />
+<glyph unicode="R" d="M370 540q0 130 -148 130q-41 0 -70 -8v-272h60q87 0 122.5 33.5t35.5 116.5zM152 320v-320h-82v725q78 15 160 15q112 0 166 -49.5t54 -150.5q0 -143 -109 -193v-2q31 -15 66 -131l63 -214h-86l-59 216q-17 64 -41 84t-82 20h-50z" />
+<glyph unicode="S" d="M260 668q-47 0 -77.5 -30.5t-30.5 -77.5q0 -50 21.5 -82.5t71.5 -55.5q111 -49 153 -102.5t42 -139.5q0 -94 -51.5 -142t-148.5 -48q-91 0 -165 55v95q80 -78 170 -78q113 0 113 118q0 55 -26 91t-87 64q-94 42 -134.5 95.5t-40.5 129.5q0 80 51 130t134 50q53 0 87 -8 t78 -32v-90q-77 58 -160 58z" />
+<glyph unicode="T" d="M209 0v660h-154v70h390v-70h-154v-660h-82z" />
+<glyph unicode="U" d="M250 -10q-95 0 -142.5 48.5t-47.5 151.5v540h84v-520q0 -81 26.5 -114.5t81.5 -33.5t81.5 33.5t26.5 114.5v520h80v-540q0 -103 -47.5 -151.5t-142.5 -48.5z" />
+<glyph unicode="V" d="M253 70l135 660h82l-170 -730h-100l-170 730h86l135 -660h2z" />
+<glyph unicode="W" d="M153 120h2l54 510h90l54 -510h2l45 610h75l-60 -730h-109l-55 520h-2l-55 -520h-109l-60 730h83z" />
+<glyph unicode="X" d="M251 440h2l112 290h83l-148 -355l150 -375h-90l-111 305h-2l-112 -305h-85l150 375l-148 355h88z" />
+<glyph unicode="Y" d="M251 375h2l132 355h85l-179 -440v-290h-82v290l-179 440h90z" />
+<glyph unicode="Z" d="M335 658v2h-260v70h350v-70l-260 -588v-2h260v-70h-350v70z" />
+<glyph unicode="[" d="M390 710h-178v-790h178v-60h-250v910h250v-60z" />
+<glyph unicode="\" d="M48 730h72l332 -770h-72z" />
+<glyph unicode="]" d="M110 710v60h250v-910h-250v60h178v790h-178z" />
+<glyph unicode="^" d="M251 680h-2l-147 -400h-72l170 450h100l170 -450h-72z" />
+<glyph unicode="_" d="M50 -140v56h400v-56h-400z" />
+<glyph unicode="`" d="M130 810h120l100 -280h-70z" />
+<glyph unicode="a" d="M255 530q100 0 137.5 -40t37.5 -150v-340h-72l-2 75h-2q-47 -85 -149 -85q-65 0 -105 41.5t-40 113.5q0 91 61.5 140.5t183.5 49.5h48v25q0 57 -22 80t-76 23q-33 0 -84 -12t-86 -28v72q35 15 85 25t85 10zM353 275h-48q-170 0 -170 -125q0 -45 23 -69t62 -24q59 0 96 48 t37 135v35z" />
+<glyph unicode="b" d="M144 445h2q43 85 134 85q175 0 175 -270q0 -135 -48 -202.5t-127 -67.5q-84 0 -137 85h-2l-2 -75h-74v730h79v-285zM376 260q0 195 -116 195q-51 0 -83.5 -49.5t-32.5 -140.5v-10q0 -91 32.5 -140.5t83.5 -49.5q53 0 84.5 48.5t31.5 146.5z" />
+<glyph unicode="c" d="M70 260q0 134 55 202t155 68q61 0 125 -25v-80q-60 33 -120 33q-63 0 -98 -50t-35 -148q0 -101 37 -151t101 -50q59 0 120 36v-80q-64 -25 -125 -25q-102 0 -158.5 67.5t-56.5 202.5z" />
+<glyph unicode="d" d="M356 730h79v-730h-74l-2 75h-2q-53 -85 -137 -85q-79 0 -127 67.5t-48 202.5q0 270 175 270q91 0 134 -85h2v285zM124 260q0 -98 31.5 -146.5t84.5 -48.5q51 0 83.5 49.5t32.5 140.5v10q0 91 -32.5 140.5t-83.5 49.5q-116 0 -116 -195z" />
+<glyph unicode="e" d="M138 234q4 -93 38 -134t99 -41q61 0 135 36v-80q-74 -25 -140 -25q-215 0 -215 270q0 141 50 205.5t150 64.5q91 0 135.5 -62t44.5 -203q0 -11 -2 -31h-295zM138 300h218q-1 161 -101 161q-57 0 -85 -36t-32 -125z" />
+<glyph unicode="f" d="M75 431v69h120v60q0 98 33 139t107 41q45 0 90 -15v-72q-38 18 -75 18q-47 0 -61.5 -23.5t-14.5 -107.5v-40h151v-69h-151v-431h-79v431h-120z" />
+<glyph unicode="g" d="M50 260q0 270 175 270q83 0 137 -85h2l2 75h74v-515q0 -125 -50.5 -180t-154.5 -55q-71 0 -140 25v80q71 -36 140 -36q126 0 126 166v80h-2q-43 -85 -134 -85q-80 0 -127.5 66t-47.5 194zM129 260q0 -92 31.5 -138.5t84.5 -46.5q52 0 84 45.5t32 134.5v10 q0 91 -32.5 140.5t-83.5 49.5q-58 0 -87 -46.5t-29 -148.5z" />
+<glyph unicode="h" d="M440 330v-330h-77v312q0 88 -20 117.5t-73 29.5q-50 0 -85.5 -56t-35.5 -151v-252h-79v730h79v-285h2q19 39 56.5 62t82.5 23q79 0 114.5 -45.5t35.5 -154.5z" />
+<glyph unicode="i" d="M316 520v-452h109v-68h-330v68h139v384h-109v68h191zM214 640v120h102v-120h-102z" />
+<glyph unicode="j" d="M249 -33v485h-119v68h201v-553q0 -65 -8.5 -101t-36.5 -59t-72 -30t-123 -7v68q40 0 63 1t42.5 6.5t28.5 12.5t15.5 23.5t7.5 34.5t1 51zM229 640v120h102v-120h-102z" />
+<glyph unicode="k" d="M460 520l-230 -250l230 -270h-95l-206 253v-253h-79v730h79v-444l207 234h94z" />
+<glyph unicode="l" d="M281 150q0 -66 10.5 -79t63.5 -13q33 0 75 6v-69q-47 -5 -85 -5q-90 0 -118 28.5t-28 121.5v522h-129v68h211v-580z" />
+<glyph unicode="m" d="M290 0h-78v360q-1 58 -10.5 77.5t-32.5 19.5q-20 0 -35 -24t-25 -83.5t-10 -149.5v-200h-79v520h70l2 -70h2q17 38 42.5 59t53.5 21q31 0 50.5 -18.5t33.5 -61.5h2q39 80 104 80q53 0 76.5 -32.5t23.5 -117.5v-380h-77v360q-1 59 -11.5 78t-37.5 19q-64 0 -64 -197v-260z " />
+<glyph unicode="n" d="M440 330v-330h-77v312q0 88 -20 117.5t-73 29.5q-50 0 -85.5 -56t-35.5 -151v-252h-79v520h74l2 -75h2q19 38 58 61.5t84 23.5q79 0 114.5 -45.5t35.5 -154.5z" />
+<glyph unicode="o" d="M250 530q200 0 200 -270t-200 -270t-200 270t200 270zM250 59q61 0 89.5 45.5t28.5 155.5t-28.5 155.5t-89.5 45.5t-89.5 -45.5t-28.5 -155.5t28.5 -155.5t89.5 -45.5z" />
+<glyph unicode="p" d="M141 75h-2v-295h-79v740h74l2 -75h2q54 85 137 85q175 0 175 -270q0 -135 -48 -202.5t-127 -67.5q-91 0 -134 85zM371 260q0 195 -116 195q-51 0 -83.5 -49.5t-32.5 -140.5v-10q0 -91 32.5 -140.5t83.5 -49.5q53 0 84.5 48.5t31.5 146.5z" />
+<glyph unicode="q" d="M359 75q-43 -85 -134 -85q-79 0 -127 67.5t-48 202.5q0 270 175 270q83 0 137 -85h2l2 75h74v-740h-79v295h-2zM129 260q0 -98 31.5 -146.5t84.5 -48.5q51 0 83.5 49.5t32.5 140.5v10q0 91 -32.5 140.5t-83.5 49.5q-116 0 -116 -195z" />
+<glyph unicode="r" d="M186 520v-100h2q62 110 172 110q37 0 70 -10v-70q-35 11 -70 11q-73 0 -122 -61t-49 -160v-240h-79v520h76z" />
+<glyph unicode="s" d="M255 463q-96 0 -96 -73q0 -34 21 -54.5t75 -35.5q106 -30 140.5 -63t34.5 -102t-47 -107t-133 -38t-165 40v80q78 -53 155 -53q111 0 111 78q0 37 -21.5 57t-84.5 38q-92 26 -128.5 62t-36.5 98q0 66 43.5 103t126.5 37q84 0 160 -35v-75q-79 43 -155 43z" />
+<glyph unicode="t" d="M244 500h181v-69h-181v-281q0 -56 16.5 -74.5t64.5 -18.5q50 0 90 18v-70q-48 -15 -100 -15q-84 0 -117 32.5t-33 117.5v291h-100v69h100v190h79v-190z" />
+<glyph unicode="u" d="M65 180v340h77v-322q0 -83 18.5 -110t69.5 -27q49 0 82.5 55t33.5 152v252h79v-520h-74l-2 75h-2q-19 -40 -56 -62.5t-81 -22.5q-77 0 -111 43t-34 147z" />
+<glyph unicode="v" d="M251 60h2l115 460h82l-145 -520h-110l-145 520h86z" />
+<glyph unicode="w" d="M351 80h2l49 440h78l-80 -520h-99l-54 440h-2l-49 -440h-96l-80 520h82l49 -440h2l49 440h100z" />
+<glyph unicode="x" d="M251 305h2l104 215h88l-145 -260l145 -260h-94l-102 215h-2l-102 -215h-90l145 260l-145 260h92z" />
+<glyph unicode="y" d="M259 120h2l117 400h87l-240 -740h-83l78 230l-175 510h88z" />
+<glyph unicode="z" d="M80 520h340v-69l-248 -380v-2h248v-69h-340v69l248 380v2h-248v69z" />
+<glyph unicode="{" d="M195 316l4 -2q81 -38 81 -149v-135q0 -72 16.5 -91t78.5 -19h40v-60h-65q-73 0 -107.5 35.5t-34.5 114.5v150q0 66 -21.5 95.5t-66.5 29.5h-45v60h45q45 0 66.5 29.5t21.5 95.5v150q0 79 34.5 114.5t107.5 35.5h65v-60h-40q-62 0 -78.5 -19t-16.5 -91v-135q0 -61 -20 -95 t-65 -54z" />
+<glyph unicode="|" d="M212 -220v1030h76v-1030h-76z" />
+<glyph unicode="}" d="M305 316q-45 20 -65 54t-20 95v135q0 72 -16.5 91t-78.5 19h-40v60h65q73 0 107.5 -35.5t34.5 -114.5v-150q0 -66 21.5 -95.5t66.5 -29.5h45v-60h-45q-45 0 -66.5 -29.5t-21.5 -95.5v-150q0 -79 -34.5 -114.5t-107.5 -35.5h-65v60h40q62 0 78.5 19t16.5 91v135 q0 111 81 149z" />
+<glyph unicode="~" d="M50 602v75q42 33 95 33q61 0 125 -48q48 -35 80 -35q25 0 47 10t53 39v-75q-42 -33 -95 -33q-61 0 -125 48q-47 35 -80 35q-25 0 -47 -10t-53 -39z" />
+<glyph unicode="&#xa0;" />
+<glyph unicode="&#xa5;" d="M251 375h2l132 355h85l-153 -375h123v-65h-149v-85h149v-65h-149v-140h-82v140h-149v65h149v85h-149v65h123l-153 375h90z" />
+<glyph unicode="&#xad;" d="M100 269v72h300v-72h-300z" />
+<glyph unicode="&#x2000;" horiz-adv-x="407" />
+<glyph unicode="&#x2001;" horiz-adv-x="815" />
+<glyph unicode="&#x2002;" horiz-adv-x="407" />
+<glyph unicode="&#x2003;" horiz-adv-x="815" />
+<glyph unicode="&#x2004;" horiz-adv-x="271" />
+<glyph unicode="&#x2005;" horiz-adv-x="203" />
+<glyph unicode="&#x2006;" horiz-adv-x="135" />
+<glyph unicode="&#x2007;" horiz-adv-x="135" />
+<glyph unicode="&#x2008;" horiz-adv-x="101" />
+<glyph unicode="&#x2009;" horiz-adv-x="163" />
+<glyph unicode="&#x200a;" horiz-adv-x="45" />
+<glyph unicode="&#x2010;" d="M100 269v72h300v-72h-300z" />
+<glyph unicode="&#x2011;" d="M100 269v72h300v-72h-300z" />
+<glyph unicode="&#x2013;" d="M60 269v72h380v-72h-380z" />
+<glyph unicode="&#x2014;" d="M20 269v72h460v-72h-460z" />
+<glyph unicode="&#x2018;" d="M275 500h-120l110 280h70z" />
+<glyph unicode="&#x2019;" d="M220 780h120l-110 -280h-70z" />
+<glyph unicode="&#x201c;" d="M340 500h-110l110 280h60zM190 500h-110l110 280h60z" />
+<glyph unicode="&#x201d;" d="M300 780h110l-110 -280h-60zM150 780h110l-110 -280h-60z" />
+<glyph unicode="&#x2026;" horiz-adv-x="1000" d="M102 288v150h130v-150h-130zM435 288v150h130v-150h-130zM768 288v150h130v-150h-130z" />
+<glyph unicode="&#x202f;" horiz-adv-x="163" />
+<glyph unicode="&#x205f;" horiz-adv-x="203" />
+<glyph unicode="&#x2122;" horiz-adv-x="1000" d="M878 540h-2l-88 -340h-80l-88 340h-2v-540h-78v730h92l119 -450h2l119 450h88v-730h-82v540zM209 0v660h-154v70h390v-70h-154v-660h-82z" />
+</font>
+</defs></svg> 

bin/jsdoc/templates/css/handheld.css

@@ -0,0 +1,217 @@
+/*
+ * TABLE OF CONTENTS:
+ * - Browser reset
+ * - HTML elements
+ * - JsDoc styling
+ * - Media query check
+ */
+
+
+
+
+
+
+/*
+ * HTML ELEMENTS
+ */
+
+body {
+	padding: 1% 4% 1% 4%;
+}
+
+/*
+ * HTML ELEMENTS
+ */
+
+
+
+ 
+ 
+/*
+ * BEGIN JSDOC
+ */
+
+/* Start menu */
+div.index div.menu {
+	position: fixed;
+	top: 0;
+	right: 0;
+	-moz-border-radius-bottomleft: 15px;
+	-webkit-border-bottom-left-radius: 15px;
+	-border-bottom-left-radius: 15px;
+	padding: 4px 5px 8px 10px;
+	-moz-box-shadow: 0px 0px 10px #c4c4c4;
+	-webkit-box-shadow: 0px 0px 10px #c4c4c4;
+	box-shadow: 0px 0px 10px #c4c4c4;
+	background-color: rgba(255, 255, 255, 0.9);
+}
+
+div.index input.classFilter {
+	display: none;
+}
+
+div.index div.indexLinks a {
+	float: right;
+	clear: both;
+	font-size: 1.1em;
+}
+
+div.index *.heading1 {
+	display:none;
+}
+
+div.index ul.classList {
+	display:none;
+}
+
+div.index div.fineprint {
+	display:none;
+}
+
+div.indexStatic {
+	display: none;
+}
+/* End menu */
+
+
+
+/* Start content */
+div.content *.classTitle {
+	margin-right: 60px;
+	margin-bottom: 15px;
+}
+
+div.content div.intro {
+	margin: 15px 0 35px;
+}
+
+div.content p.description.summary {
+	margin-bottom: 0.2em;
+}
+
+div.content div.props {
+	margin: 1.5em -2% 0 -2%;
+	padding: 2%;
+}
+
+table.summaryTable {
+	position: relative;
+	left: -10px;
+	width: 100%;
+	border-collapse: collapse;
+	box-sizing: content-box;
+	-moz-box-sizing: content-box;
+	-webkit-box-sizing: content-box;
+	-ms-box-sizing: content-box;
+	-o-box-sizing: content-box;
+	-icab-box-sizing: content-box;
+	-khtml-box-sizing: content-box; 
+}
+
+*.sectionTitle {
+	padding: 0 10px 10px 0;
+}
+caption.sectionTitle {
+	padding-left: 10px;
+}
+
+table.summaryTable td,
+table.summaryTable th {
+	padding: 0px 10px 10px 10px;
+}
+table.summaryTable tr:last-child td {
+	padding-bottom: 0;
+}
+
+table.summaryTable td.attributes {
+	width: 35%;
+}
+
+table.summaryTable td.nameDescription {
+	width: 65%
+}
+
+
+
+dl.detailList {
+	margin-top: 0.5em;
+}
+
+dl.detailList.nomargin + dl.detailList.nomargin {
+	margin-top: 0;
+}
+
+dl.detailList dt {
+	display: inline;
+	margin-right: 5px;
+}
+
+dl.detailList dt:before {
+	display: block;
+	content: "";
+}
+
+dl.detailList dd {
+	display: inline;
+}
+
+dl.detailList.params dt {
+	display: block;
+}
+dl.detailList.params dd {
+	display: block;
+	padding-left: 2em;
+	padding-bottom: 0.4em;
+}
+
+
+
+
+ul.fileList li {
+	margin-bottom: 1.5em;
+}
+
+
+
+.fixedFont.heading {
+	margin-bottom: 0.5em;
+}
+
+pre.code {
+	margin: 10px 0 10px 0;
+	padding: 10px;
+	border: 1px solid #ccc;
+	-moz-border-radius: 2px;
+	-webkit-border-radius: 2px;
+	border-radius: 2px;
+}
+/* End content */
+
+/*
+ * END JSDOC
+ */
+
+
+
+
+
+
+
+/*
+ * START MEDIA QUERY CHECK
+ */
+
+.cssLoadCheck {
+	position: absolute;
+	top: -99999px;
+	left: -99999px;
+	border: 0;
+	width: 100px;
+	padding: 0;
+	overflow: hidden;
+}
+
+/*
+ * END MEDIA QUERY CHECK
+ */
+

bin/jsdoc/templates/css/screen.css

@@ -0,0 +1,297 @@
+/*
+ * TABLE OF CONTENTS:
+ * - JsDoc styling
+ * - Media query check
+ */
+
+
+
+
+
+
+/*
+ * BEGIN JSDOC
+ */
+
+/* Start menu */
+div.index {
+	position: fixed;
+	top: 0;
+	bottom: 0;
+	float: left;
+	width: 30%;
+	min-width: 100px;
+	max-width: 300px;
+	padding: 0 0 10px 0;
+	overflow: auto;
+}
+
+div.index *.heading1 {
+	padding: 8px 0 0 0;
+}
+
+div.index div.menu {
+	margin: 0 15px 0 -15px;
+	-moz-border-radius-bottomright: 15px;
+	-webkit-border-bottom-right-radius: 15px;
+	-border-bottom-right-radius: 15px;
+  	padding: 15px 15px 15px 30px;
+	-moz-box-shadow: 0px 0px 10px #c4c4c4;
+	-webkit-box-shadow: 0px 0px 10px #c4c4c4;
+	box-shadow: 0px 0px 10px #c4c4c4;
+	background-color: rgba(255, 255, 255, 0.5);
+}
+
+div.index div.indexLinks {
+	margin-top: 13px;
+	position: absolute;
+	right: 30px;
+}
+
+div.index div.indexLinks a {
+	color: #999999;
+	text-transform: lowercase;
+}
+
+div.index div.indexLinks a:first-child {
+	margin-right: 3px;
+	border-right: 1px solid #999999;
+	padding-right: 5px;
+}
+
+div.index input.classFilter {
+	margin-bottom: 4px;
+	width: 100%;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #CCCCCC #999999 #999999 #CCCCCC;
+	-moz-border-radius: 3px;
+	-webkit-border-radius: 3px;
+	-border-radius: 3px;
+}
+
+div.index ul.classList a {
+	line-height: 1.3em;
+}
+
+div.index ul.classList a + a {
+	margin-left: 0.5em;
+}
+
+div.index div.fineprint {
+	margin: 1em 0 0 15px;
+	color: #777;
+	font-size: 0.9em;
+}
+
+div.index div.fineprint a {
+	color: #777;
+}
+
+div.indexStatic {
+	position: static;
+	min-height: 1em;
+}
+/* End menu */
+
+
+/* Start content */
+div.content {
+	float: left;
+	width: 70%;
+	min-width: 300px;
+	max-width: 600px;
+}
+div.innerContent {
+	padding: 0 0 0 2.5em;
+}
+
+div.content ul,
+div.content ol {
+	margin-bottom: 3em;
+}
+
+div.content ul.methodDetail {
+	margin-bottom: 0;
+}
+
+div.content *.classTitle {
+	position: relative;
+	left: -10px;
+	margin: -30px 0 15px 0;
+	-moz-border-radius: 15px;
+	-webkit-border-radius: 15px;
+	border-radius: 15px;
+  	padding: 25px 15px 15px 15px;
+	background-color: #FFFFFF;
+	background-color: rgba(255, 255, 255, 0.5);
+	-moz-box-shadow: 0px 0px 10px #c4c4c4;
+	-webkit-box-shadow: 0px 0px 10px #c4c4c4;
+	box-shadow: 0px 0px 10px #c4c4c4;
+}
+
+div.content div.intro {
+	margin: 15px 0 45px
+}
+
+div.content p.summary {
+	margin-bottom: 0.5em;
+}
+
+div.content ul.summary {
+	margin-bottom: 1.5em;
+}
+
+div.content ul *.classname a,
+div.content ul *.filename a {
+	font-family: Consolas, "Courier New", Courier, monospace;
+	text-decoration: none;
+	font-weight: bold;
+}
+div.content ul *.classname a:hover,
+div.content ul *.filename a:hover {
+	text-decoration: underline;
+}
+
+div.content div.props {
+	position: relative;
+	left: -10px;
+	margin-bottom: 2.5em;
+	padding: 10px 15px 15px 15px;
+	overflow: hidden;
+}
+
+div.content div.hr {
+	margin: 0 10px 0 0;
+	height: 4em;
+}
+
+
+
+table.summaryTable {
+	position: relative;
+	left: -10px;
+	width: 100%;
+	border-collapse: collapse;
+	box-sizing: content-box;
+	-moz-box-sizing: content-box;
+	-webkit-box-sizing: content-box;
+	-ms-box-sizing: content-box;
+	-o-box-sizing: content-box;
+	-icab-box-sizing: content-box;
+	-khtml-box-sizing: content-box; 
+}
+
+*.sectionTitle {
+	padding: 0 10px 10px 0;
+}
+caption.sectionTitle {
+	padding-left: 10px;
+}
+
+table.summaryTable td,
+table.summaryTable th {
+	padding: 0px 10px 10px 10px;
+}
+table.summaryTable tr:last-child td {
+	padding-bottom: 0;
+}
+
+table.summaryTable td.attributes {
+	width: 35%;
+}
+
+table.summaryTable td.nameDescription {
+	width: 65%
+}
+
+
+
+dl.detailList {
+	margin-top: 0.5em;
+}
+
+dl.detailList.nomargin + dl.detailList.nomargin {
+	margin-top: 0;
+}
+
+dl.detailList dt {
+	display: inline;
+	margin-right: 5px;
+}
+
+dl.detailList dt:before {
+	display: block;
+	content: "";
+}
+
+dl.detailList dd {
+	display: inline;
+}
+
+dl.detailList.params dt {
+	display: block;
+}
+dl.detailList.params dd {
+	display: block;
+	padding-left: 2em;
+	padding-bottom: 0.4em;
+}
+
+
+
+
+ul.fileList li {
+	margin-bottom: 1.5em;
+}
+
+
+
+.fixedFont.heading {
+	margin-bottom: 0.5em;
+}
+
+pre.code {
+	margin: 10px 0 10px 0;
+	padding: 10px;
+	border: 1px solid #ccc;
+	-moz-border-radius: 2px;
+	-webkit-border-radius: 2px;
+	border-radius: 2px;
+}
+/* End content */
+
+.clear {
+	clear: both;
+	width: 100%;
+	min-height: 0;
+}
+
+/*
+ * END JSDOC
+ */
+
+
+
+
+
+
+
+/*
+ * START MEDIA QUERY CHECK
+ */
+
+.cssLoadCheck {
+	position: absolute;
+	top: -99999px;
+	left: -99999px;
+	border: 0;
+	width: 100px;
+	padding: 0;
+	overflow: hidden;
+}
+
+/*
+ * END MEDIA QUERY CHECK
+ */
+

bin/jsdoc/templates/javascript/all.js

@@ -0,0 +1,326 @@
+/**
+ * @fileOverview Contains standard code in the namespace 'wbos' and code specifically written for Codeview in the namespace 'codeview'
+ * @author Wouter Bos (www.thebrightlines.com)
+ * @since 1.0 - 2010-09-10
+ * @version 1.0 - 2010-09-10
+ */
+
+
+
+
+
+
+if (typeof(wbos) == "undefined") {
+	/**
+	 * @namespace Standard code of Wouter Bos (wbos)
+	 */
+	wbos = {}
+}
+if (typeof(wbos.CssTools) == "undefined") {
+	/**
+	 * @namespace Namespace for CSS-related functionality
+	 */
+	wbos.CssTools = {}
+}
+
+
+
+
+/**
+ * @namespace Fallback for CSS advanced media query
+ * @class
+ * @since 1.0 - 2010-09-10
+ * @version 1.0 - 2010-09-10
+ */
+wbos.CssTools.MediaQueryFallBack = ( function() {
+	var config = {
+		cssScreen: "/css/screen.css",
+		cssHandheld: "/css/handheld.css",
+		mobileMaxWidth: 660,
+		testDivClass: "cssLoadCheck",
+		dynamicCssLinkId: "DynCssLink",
+		resizeDelay: 30
+	}
+	var noMediaQuery = false;
+	var delay;
+	var currentCssMediaType;
+
+	// Adding events to elements in the DOM without overwriting it
+	function addEvent(element, newFunction, eventType) {
+		var oldEvent = eval("element." + eventType);
+		var eventContentType = eval("typeof element." + eventType)
+		
+		if ( eventContentType != 'function' ) {
+			eval("element." + eventType + " = newFunction")
+		} else {
+			eval("element." + eventType + " = function(e) { oldEvent(e); newFunction(e); }")
+		}
+	}
+	
+	// Get the the inner width of the browser window
+	function getWindowWidth() {
+		if (window.innerWidth) {
+			return window.innerWidth;
+		} else if (document.documentElement.clientWidth) {
+			return document.documentElement.clientWidth;
+		} else if (document.body.clientWidth) {
+			return document.body.clientWidth;
+		} else{
+			return 0;	
+		}
+	}
+	
+	function addCssLink(cssHref) {
+		var cssNode = document.createElement('link');
+		var windowWidth;
+		cssNode.type = 'text/css';
+		cssNode.rel = 'stylesheet';
+		cssNode.media = 'screen, handheld, fallback';
+		cssNode.href = cssHref;
+		document.getElementsByTagName("head")[0].appendChild(cssNode);
+	}
+	
+
+
+	/* Start public */
+	return {
+  		/**
+		 * Adds link to CSS in the head if no CSS is loaded
+		 *
+		 * @since 1.0 - 2010-08-21
+		 * @version 1.0 - 2010-08-21
+		 * @param {String|Object} cssScreen URL to CSS file for larger screens
+		 * @param {String|Object} cssHandheld URL to CSS file for smaller screens
+		 * @param {Number} mobileMaxWidth Maximum  width for handheld devices
+		 * @example
+		 * wbos.CssTools.MediaQueryFallBack.LoadCss(['screen.css', 'screen2.css'], 'mobile.css', 480)
+		 */
+		LoadCss: function(cssScreen, cssHandheld, mobileMaxWidth) {
+			// Set config values
+			if (typeof(cssScreen) != "undefined") {
+				config.cssScreen = cssScreen;	
+			}
+			if (typeof(cssHandheld) != "undefined") {
+				config.cssHandheld = cssHandheld;	
+			}
+			if (typeof(mobileMaxWidth) != "undefined") {
+				config.mobileMaxWidth = mobileMaxWidth;	
+			}
+			
+			// Check if CSS is loaded
+			var cssloadCheckNode = document.createElement('div');
+			cssloadCheckNode.className = config.testDivClass;
+			document.getElementsByTagName("body")[0].appendChild(cssloadCheckNode);
+			if (cssloadCheckNode.offsetWidth != 100 && noMediaQuery == false) {
+				noMediaQuery = true;
+			}
+			cssloadCheckNode.parentNode.removeChild(cssloadCheckNode)
+			
+			if (noMediaQuery == true) {
+				// Browser does not support Media Queries, so JavaScript will supply a fallback 
+				var cssHref = "";
+				
+				// Determines what CSS file to load
+				if (getWindowWidth() <= config.mobileMaxWidth) {
+					cssHref = config.cssHandheld;
+					newCssMediaType = "handheld";
+				} else {
+					cssHref = config.cssScreen;
+					newCssMediaType = "screen";
+				}
+				
+				// Add CSS link to <head> of page
+				if (cssHref != "" && currentCssMediaType != newCssMediaType) {
+					var currentCssLinks = document.styleSheets
+					for (var i = 0; i < currentCssLinks.length; i++) {
+						for (var ii = 0; ii < currentCssLinks[i].media.length; ii++) {
+							if (typeof(currentCssLinks[i].media) == "object") {
+								if (currentCssLinks[i].media.item(ii) == "fallback") {
+									currentCssLinks[i].ownerNode.parentNode.removeChild(currentCssLinks[i].ownerNode)
+									i--
+									break;
+								}
+							} else {
+								if (currentCssLinks[i].media.indexOf("fallback") >= 0) {
+									currentCssLinks[i].owningElement.parentNode.removeChild(currentCssLinks[i].owningElement)
+									i--
+									break;
+								}
+							}
+						}
+					}
+					if (typeof(cssHref) == "object") {
+						for (var i = 0; i < cssHref.length; i++) {
+							addCssLink(cssHref[i])
+						}
+					} else {
+						addCssLink(cssHref)
+					}
+										
+					currentCssMediaType = newCssMediaType;
+				}
+
+				
+				// Check screen size again if user resizes window 
+				addEvent(window, wbos.CssTools.MediaQueryFallBack.LoadCssDelayed, 'onresize')
+			}
+		},
+		
+  		/**
+		 * Runs LoadCSS after a short delay
+		 *
+		 * @since 1.0 - 2010-08-21
+		 * @version 1.0 - 2010-08-21
+		 * @example
+		 * wbos.CssTools.MediaQueryFallBack.LoadCssDelayed()
+		 */
+		LoadCssDelayed: function() {
+			clearTimeout(delay);
+			delay = setTimeout( "wbos.CssTools.MediaQueryFallBack.LoadCss()", config.resizeDelay)
+		}
+		
+	}
+	/* End public */
+})();
+
+
+
+
+
+
+/**
+ * @namespace Adds a function to an event of a single element. Use this if
+ * you don't want to use jQuery
+ * @class
+ * @since 1.0 - 2010-02-23
+ * @version 1.0 - 2010-02-23
+ */
+wbos.Events = ( function() {
+	/* Start public */
+	return {
+  		/**
+		 * Adds a function to an event of a single element
+		 *
+		 * @since 1.0 - 2010-02-23
+		 * @version 1.0 - 2010-02-23
+		 * @param {Object} element The element on which the event is placed
+		 * @param {Function} newFunction The function that has to be linked to the event
+		 * @param {String} eventType Name of the event
+		 * @example
+		 * wbos.Events.AddEvent( document.getElementById('elementId'), functionName, "onclick" )
+		 */
+		AddEvent: function( element, newFunction, eventType ) {
+			var oldEvent = eval("element." + eventType);
+			var eventContentType = eval("typeof element." + eventType)
+			
+			if ( eventContentType != 'function' ) {
+				eval("element." + eventType + " = newFunction")
+			} else {
+				eval("element." + eventType + " = function(e) { oldEvent(e); newFunction(e); }")
+			}
+		}
+	}
+	/* End public */
+})();
+
+
+
+
+
+
+if (typeof(codeview) == "undefined") {
+	/**
+	 * @namespace Code written for the Codeview template
+	 */
+	codeview = {}
+}
+
+
+
+
+
+
+
+/**
+ * @namespace Enables filtering in class lists
+ * @class
+ * @since 1.0 - 2010-11-08
+ * @version 1.0 - 2010-11-08
+ */
+codeview.classFilter = ( function() {
+	function onkeyup_ClassFilter() {
+		var listItems
+		var search = document.getElementById('ClassFilter').value
+		search = search.toLowerCase()
+		if (document.getElementById('ClassList')) {
+			listItems = document.getElementById('ClassList').getElementsByTagName('li')
+			filterList(listItems, search)
+		}
+		if (document.getElementById('ClassList2')) {
+			listItems = document.getElementById('ClassList2').getElementsByTagName('li')
+			filterList(listItems, search)
+		}
+		if (document.getElementById('FileList')) {
+			listItems = document.getElementById('FileList').getElementsByTagName('li')
+			filterList(listItems, search)
+		}
+		if (document.getElementById('MethodsListInherited')) {
+			var links = document.getElementById('MethodsListInherited').getElementsByTagName('a')
+			var linksSelected = new Array()
+			for (var i=0; i < links.length; i++) {
+				if (links[i].parentNode.parentNode.tagName == "DD") {
+					linksSelected.push(links[i])
+				}
+			}
+			filterList(linksSelected, search)
+		}
+		if (document.getElementById('MethodsList')) {
+			listItems = document.getElementById('MethodsList').getElementsByTagName('tbody')[0].getElementsByTagName('tr')
+			filterList(listItems, search, document.getElementById('MethodDetail').getElementsByTagName('li'))
+		}
+	}
+	
+	function filterList(listItems, search, relatedElements) {
+		var itemContent = ""
+		for (var i=0; i < listItems.length; i++) {
+			itemContent = listItems[i].textContent||listItems[i].innerText
+			if (itemContent != undefined) {
+				itemContent = itemContent.toLowerCase()
+				itemContent = itemContent.replace(/\s/g, "")
+				if (itemContent.indexOf(search) >= 0 || itemContent == "") {
+					listItems[i].style.display = ""
+				} else {
+					listItems[i].style.display = "none"
+				}
+				if (relatedElements != null) {
+					filterRelatedList(listItems[i], search, relatedElements)
+				}
+			}
+		}
+	}
+	
+	function filterRelatedList(listItem, search, relatedElements) {
+		var itemIndex = parseInt(listItem.className.replace('item', ''))
+		if (itemIndex <= relatedElements.length) {
+			if (relatedElements[itemIndex].className == "item"+ itemIndex) {
+				relatedElements[itemIndex].style.display = listItem.style.display
+			}
+		}
+	}
+	
+	
+	
+	
+	
+	/* Start public */
+	return {
+		Init: function() {
+			wbos.Events.AddEvent(
+				document.getElementById('ClassFilter'),
+				onkeyup_ClassFilter,
+				"onkeyup"
+			)					
+		}
+	}
+	/* End public */
+})();

bin/jsdoc/templates/javascript/html5.js

@@ -0,0 +1,6 @@
+// html5shiv MIT @rem remysharp.com/html5-enabling-script
+// iepp v1.6.2 MIT @jon_neal iecss.com/print-protector
+/*@cc_on(function(m,c){var z="abbr|article|aside|audio|canvas|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video";function n(d){for(var a=-1;++a<o;)d.createElement(i[a])}function p(d,a){for(var e=-1,b=d.length,j,q=[];++e<b;){j=d[e];if((a=j.media||a)!="screen")q.push(p(j.imports,a),j.cssText)}return q.join("")}var g=c.createElement("div");g.innerHTML="<z>i</z>";if(g.childNodes.length!==1){var i=z.split("|"),o=i.length,s=RegExp("(^|\\s)("+z+")",
+"gi"),t=RegExp("<(/*)("+z+")","gi"),u=RegExp("(^|[^\\n]*?\\s)("+z+")([^\\n]*)({[\\n\\w\\W]*?})","gi"),r=c.createDocumentFragment(),k=c.documentElement;g=k.firstChild;var h=c.createElement("body"),l=c.createElement("style"),f;n(c);n(r);g.insertBefore(l,
+g.firstChild);l.media="print";m.attachEvent("onbeforeprint",function(){var d=-1,a=p(c.styleSheets,"all"),e=[],b;for(f=f||c.body;(b=u.exec(a))!=null;)e.push((b[1]+b[2]+b[3]).replace(s,"$1.iepp_$2")+b[4]);for(l.styleSheet.cssText=e.join("\n");++d<o;){a=c.getElementsByTagName(i[d]);e=a.length;for(b=-1;++b<e;)if(a[b].className.indexOf("iepp_")<0)a[b].className+=" iepp_"+i[d]}r.appendChild(f);k.appendChild(h);h.className=f.className;h.innerHTML=f.innerHTML.replace(t,"<$1font")});m.attachEvent("onafterprint",
+function(){h.innerHTML="";k.removeChild(h);k.appendChild(f);l.styleSheet.cssText=""})}})(this,document);@*/

bin/jsdoc/templates/license.txt

@@ -0,0 +1,21 @@
+The Codeview template is, like JsDoc Toolkit itself, published under the X11/MIT License.
+
+Codeview is Copyright (c) 2010 Wouter Bos (www.thebrightlines.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

bin/jsdoc/templates/publish.js

@@ -0,0 +1,236 @@
+/** Called automatically by JsDoc Toolkit. */
+function publish(symbolSet) {
+	publish.conf = {  // trailing slash expected for dirs
+		ext:         ".html",
+		outDir:      JSDOC.opt.d || SYS.pwd+"../out/jsdoc/",
+		templatesDir: JSDOC.opt.t || SYS.pwd+"../templates/jsdoc/",
+		staticDir:   "static/",
+		symbolsDir:  "symbols/",
+		srcDir:      "symbols/src/",
+		cssDir:      "css/",
+		fontsDir:    "css/fonts/",
+		jsDir:       "javascript/",
+		templateName: "Codeview",
+		templateVersion: "1.2",
+		templateLink: "http://www.thebrightlines.com/2010/05/06/new-template-for-jsdoctoolkit-codeview/"
+	};
+	
+	// is source output is suppressed, just display the links to the source file
+	if (JSDOC.opt.s && defined(Link) && Link.prototype._makeSrcLink) {
+		Link.prototype._makeSrcLink = function(srcFilePath) {
+			return "<"+srcFilePath+">";
+		}
+	}
+	
+	// create the folders and subfolders to hold the output
+	IO.mkPath((publish.conf.outDir+publish.conf.cssDir));
+	IO.mkPath((publish.conf.outDir+publish.conf.fontsDir));
+	IO.mkPath((publish.conf.outDir+publish.conf.jsDir));
+	IO.mkPath((publish.conf.outDir+"symbols/src").split("/"));
+	
+	// used to allow Link to check the details of things being linked to
+	Link.symbolSet = symbolSet;
+
+	// create the required templates
+	try {
+		var classTemplate = new JSDOC.JsPlate(publish.conf.templatesDir+"class.tmpl");
+	}
+	catch(e) {
+		print("Couldn't create the required templates: "+e);
+		quit();
+	}
+	
+	// some utility filters
+	function hasNoParent($) {return ($.memberOf == "")}
+	function isaFile($) {return ($.is("FILE"))}
+	function isaClass($) {return (($.is("CONSTRUCTOR") || $.isNamespace) && ($.alias != "_global_" || !JSDOC.opt.D.noGlobal))}
+	
+	// get an array version of the symbolset, useful for filtering
+	var symbols = symbolSet.toArray();
+	
+	// create the hilited source code files
+	var files = JSDOC.opt.srcFiles;
+ 	for (var i = 0, l = files.length; i < l; i++) {
+ 		var file = files[i];
+ 		var srcDir = publish.conf.outDir + publish.conf.srcDir;
+		makeSrcFile(file, srcDir);
+ 	}
+ 	
+ 	// get a list of all the classes in the symbolset
+ 	publish.classes = symbols.filter(isaClass).sort(makeSortby("alias"));
+	
+	// create a filemap in which outfiles must be to be named uniquely, ignoring case
+	if (JSDOC.opt.u) {
+		var filemapCounts = {};
+		Link.filemap = {};
+		for (var i = 0, l = publish.classes.length; i < l; i++) {
+			var lcAlias = publish.classes[i].alias.toLowerCase();
+			
+			if (!filemapCounts[lcAlias]) filemapCounts[lcAlias] = 1;
+			else filemapCounts[lcAlias]++;
+			
+			Link.filemap[publish.classes[i].alias] = 
+				(filemapCounts[lcAlias] > 1)?
+				lcAlias+"_"+filemapCounts[lcAlias] : lcAlias;
+		}
+	}
+	
+	// create each of the class pages
+	for (var i = 0, l = publish.classes.length; i < l; i++) {
+		var symbol = publish.classes[i];
+		
+		symbol.events = symbol.getEvents();   // 1 order matters
+		symbol.methods = symbol.getMethods(); // 2
+		
+		var output = "";
+		output = classTemplate.process(symbol);
+		
+		IO.saveFile(publish.conf.outDir+publish.conf.symbolsDir, ((JSDOC.opt.u)? Link.filemap[symbol.alias] : symbol.alias) + publish.conf.ext, output);
+	}
+	
+	// create the class index page
+	try {
+		var classesindexTemplate = new JSDOC.JsPlate(publish.conf.templatesDir+"allclasses.tmpl");
+	}
+	catch(e) { print(e.message); quit(); }
+	
+	var classesIndex = classesindexTemplate.process(publish.classes);
+	IO.saveFile(publish.conf.outDir, (JSDOC.opt.D.index=="files"?"allclasses":"index")+publish.conf.ext, classesIndex);
+	classesindexTemplate = classesIndex = classes = null;
+	
+	// create the file index page
+	try {
+		var fileindexTemplate = new JSDOC.JsPlate(publish.conf.templatesDir+"allfiles.tmpl");
+	}
+	catch(e) { print(e.message); quit(); }
+	
+	var documentedFiles = symbols.filter(isaFile); // files that have file-level docs
+	var allFiles = []; // not all files have file-level docs, but we need to list every one
+	
+	for (var i = 0; i < files.length; i++) {
+		allFiles.push(new JSDOC.Symbol(files[i], [], "FILE", new JSDOC.DocComment("/** */")));
+	}
+	
+	for (var i = 0; i < documentedFiles.length; i++) {
+		var offset = files.indexOf(documentedFiles[i].alias);
+		allFiles[offset] = documentedFiles[i];
+	}
+		
+	allFiles = allFiles.sort(makeSortby("name"));
+
+	// output the file index page
+	var filesIndex = fileindexTemplate.process(allFiles);
+	IO.saveFile(publish.conf.outDir, (JSDOC.opt.D.index=="files"?"index":"files")+publish.conf.ext, filesIndex);
+	fileindexTemplate = filesIndex = files = null;
+	
+	// copy static files
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.cssDir+"all.css", publish.conf.outDir+"/"+publish.conf.cssDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.cssDir+"screen.css", publish.conf.outDir+"/"+publish.conf.cssDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.cssDir+"handheld.css", publish.conf.outDir+"/"+publish.conf.cssDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.jsDir+"all.js", publish.conf.outDir+"/"+publish.conf.jsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.jsDir+"html5.js", publish.conf.outDir+"/"+publish.conf.jsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-regular-webfont.eot", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-regular-webfont.svg", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-regular-webfont.ttf", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-regular-webfont.woff", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-bold-webfont.eot", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-bold-webfont.svg", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-bold-webfont.ttf", publish.conf.outDir+"/"+publish.conf.fontsDir);
+	IO.copyFile(publish.conf.templatesDir+"/"+publish.conf.fontsDir+"mplus-1m-bold-webfont.woff", publish.conf.outDir+"/"+publish.conf.fontsDir);	}
+
+/** Include a sub-template in the current template, specifying a data object */
+function subtemplate(template, data) {
+	try {
+		return new JSDOC.JsPlate(publish.conf.templatesDir+template).process(data);
+	}
+	catch(e) { print(e.message); quit(); }
+}
+
+/** Just the first sentence (up to a full stop). Should not break on dotted variable names. */
+function summarize(desc) {
+	if (typeof desc != "undefined")
+		return desc.match(/([\w\W]+?\.)[^a-z0-9_$]/i)? RegExp.$1 : desc;
+}
+
+/** Make a symbol sorter by some attribute. */
+function makeSortby(attribute) {
+	return function(a, b) {
+		if (a[attribute] != undefined && b[attribute] != undefined) {
+			a = a[attribute].toLowerCase();
+			b = b[attribute].toLowerCase();
+			if (a < b) return -1;
+			if (a > b) return 1;
+			return 0;
+		}
+	}
+}
+
+function wordwrapNamespace(classLink) {
+	var classText = classLink.match(/[^<>]+(?=[<])/) + "";
+	var classTextNew = classText.replace(/\./g,  "<span class='break'> </span>.<span class='break'> </span>") + "";
+	classLink = classLink.replace(/[^<>]+(?=[<])/,  classTextNew);
+	return classLink;
+}
+
+/** Pull in the contents of an external file at the given path. */
+function include(path) {
+	var path = publish.conf.templatesDir+path;
+	return IO.readFile(path);
+}
+
+/** Turn a raw source file into a code-hilited page in the docs. */
+function makeSrcFile(path, srcDir, name) {
+	if (JSDOC.opt.s) return;
+	
+	if (!name) {
+		name = path.replace(/\.\.?[\\\/]/g, "").replace(/[\\\/]/g, "_");
+		name = name.replace(/\:/g, "_");
+	}
+	
+	var src = {path: path, name:name, charset: IO.encoding, hilited: ""};
+	
+	if (defined(JSDOC.PluginManager)) {
+		JSDOC.PluginManager.run("onPublishSrc", src);
+	}
+
+	if (src.hilited) {
+		IO.saveFile(srcDir, name+publish.conf.ext, src.hilited);
+	}
+}
+
+/** Build output for displaying function parameters. */
+function makeSignature(params) {
+	if (!params) return "()";
+	var signature = "("
+	+
+	params.filter(
+		function($) {
+			return $.name.indexOf(".") == -1; // don't show config params in signature
+		}
+	).map(
+		function($) {
+			return $.name;
+		}
+	).join(", ")
+	+
+	")";
+	return signature;
+}
+
+/** Find symbol {@link ...} strings in text and turn into html links */
+function resolveLinks(str, from) {
+   str = str.replace(/\{@link ([^}]+)\}/gi,
+     function(match, symbolName) {
+	symbolName = symbolName.trim();
+	var index = symbolName.indexOf(' ');
+	if (index > 0) {
+	   var label = symbolName.substring(index + 1);
+	   symbolName = symbolName.substring(0, index);
+	   return new Link().toSymbol(symbolName).withText(label);
+	} else {
+	   return new Link().toSymbol(symbolName);
+	}
+     }
+   );
+   return str;
+}

bin/jsdoc/templates/subtemplates/foot.tmpl

@@ -0,0 +1,6 @@
+		<script type="text/javascript">
+			wbos.CssTools.MediaQueryFallBack.LoadCss('{+Link.base+}css/screen.css', '{+Link.base+}css/handheld.css', 660)
+			codeview.classFilter.Init()
+		</script>
+	</body>
+</html>

bin/jsdoc/templates/subtemplates/head.tmpl

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="{+IO.encoding+}" />
+		<meta name="generator" content="JsDoc Toolkit" />
+		<title>{+data.subtitle+} | <if test="JSDOC.opt.D.title">{+JSDOC.opt.D.title+}<else />JsDoc Reference</if></title>
+
+		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0" />
+		<meta name="mobileoptimized" content="0" />
+	
+		<link rel="stylesheet" href="{+Link.base+}css/all.css" media="all" />
+		<link rel="stylesheet" href="{+Link.base+}css/handheld.css" media="only screen and (max-width: 660px)" />
+		<link rel="stylesheet" href="{+Link.base+}css/handheld.css" media="handheld" />
+		<link rel="stylesheet" href="{+Link.base+}css/screen.css" media="screen and (min-width: 661px)" />
+
+		<script src="{+Link.base+}javascript/all.js"></script>
+		<!--[if lt IE 9]>
+			<script src="{+Link.base+}javascript/html5.js"></script>
+		<![endif]-->
+	</head>
+
+	<body>

bin/jsdoc/templates/subtemplates/menu.tmpl

@@ -0,0 +1,43 @@
+<div class="index">
+	<div class="menu">
+		<div class="indexLinks">
+			{+new Link().toFile(JSDOC.opt.D.index=="files"?"allclasses.html":"index.html").withText("Classes")+}
+			{+new Link().toFile(JSDOC.opt.D.index=="files"?"index.html":"files.html").withText("Files")+}
+		</div>
+	
+		<h2 class="heading1">Classes</h2>
+		
+		<input type="text" name="classFilter" class="classFilter" id="ClassFilter" placeholder="Filter"></input>
+		
+		<nav>
+			<ul class="classList" id="ClassList">
+				<for each="thisClass" in="publish.classes">
+					<li>{!
+						var classLink = new Link().toClass(thisClass.alias) + "";
+						output += wordwrapNamespace(classLink);
+					!}</li>
+				</for>
+			</ul>
+		</nav>
+	</div>
+	<div class="fineprint" style="clear:both">
+		<footer>
+			<if test="JSDOC.opt.D.copyright">&copy;{+JSDOC.opt.D.copyright+}<br /></if>
+			Documentation generator: <a href="http://code.google.com/p/jsdoc-toolkit/" target="_blank">JsDoc Toolkit</a> {+JSDOC.VERSION+}<br />
+			Template: <a href="{+publish.conf.templateLink+}" target="_blank">{+publish.conf.templateName+}</a> {+publish.conf.templateVersion+}<br />
+			Generated on:
+			{!
+				var date = new Date();
+				var minutes = date.getMinutes() +"";
+				if (minutes.length == 1) {
+					minutes = '0'+ minutes;
+				}
+				var timeHuman = date.getFullYear() + "-" + date.getMonth() + "-" + date.getDate() + " " + date.getHours() + ":" + minutes;
+				var timeData = date.getFullYear() + "-" + date.getMonth() + "-" + date.getDate();
+				output += "<time datetime='"+ timeData +"' pubdate>" + timeHuman +"</time>";
+			!}
+		</footer>
+	</div>
+</div>
+
+<div class="index indexStatic"></div>

bin/jsdoc/test.js

@@ -0,0 +1,342 @@
+load("app/frame/Dumper.js");
+function symbolize(opt) {
+	symbols = null;
+	JSDOC.JsDoc(opt);
+	symbols = JSDOC.JsDoc.symbolSet;
+}
+
+var testCases = [
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/overview.js"]});
+		//print(Dumper.dump(symbols));	
+		is('symbols.getSymbolByName("My Cool Library").name', 'My Cool Library', 'File overview can be found by alias.');		
+	}
+	,
+	function() {
+		symbolize({_: [SYS.pwd+"test/name.js"]});
+
+		is('symbols.getSymbol("Response").name', "Response", 'Virtual class name is found.');
+		is('symbols.getSymbol("Response#text").alias', "Response#text", 'Virtual method name is found.');
+		is('symbols.getSymbol("Response#text").memberOf', "Response", 'Virtual method parent name is found.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/prototype.js"]});
+
+		is('symbols.getSymbol("Article").name', "Article", 'Function set to constructor prototype with inner constructor name is found.');
+		is('symbols.getSymbol("Article").hasMethod("init")', true, 'The initializer method name of prototype function is correct.');
+		is('symbols.getSymbol("Article").hasMember("counter")', true, 'A static property set in the prototype definition is found.');
+		is('symbols.getSymbol("Article").hasMember("title")', true, 'An instance property set in the prototype is found.');
+		is('symbols.getSymbol("Article#title").isStatic', false, 'An instance property has isStatic set to false.');
+		is('symbols.getSymbol("Article.counter").name', "counter", 'A static property set in the initializer has the name set correctly.');
+		is('symbols.getSymbol("Article.counter").memberOf', "Article", 'A static property set in the initializer has the memberOf set correctly.');
+		is('symbols.getSymbol("Article.counter").isStatic', true, 'A static property set in the initializer has isStatic set to true.');
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/prototype_oblit.js"]});
+		
+		is('symbols.getSymbol("Article").name', "Article", 'Oblit set to constructor prototype name is found.');
+		is('typeof symbols.getSymbol("Article.prototype")', "undefined", 'The prototype oblit is not a symbol.');
+		is('symbols.getSymbol("Article#getTitle").name', "getTitle", 'The nonstatic method name of prototype oblit is correct.');
+		is('symbols.getSymbol("Article#getTitle").alias', "Article#getTitle", 'The alias of non-static method of prototype oblit is correct.');
+		is('symbols.getSymbol("Article#getTitle").isStatic', false, 'The isStatic of a nonstatic method of prototype oblit is correct.');
+		is('symbols.getSymbol("Article.getTitle").name', "getTitle", 'The static method name of prototype oblit is correct.');
+		is('symbols.getSymbol("Article.getTitle").isStatic', true, 'The isStatic of a static method of prototype oblit is correct.');
+		is('symbols.getSymbol("Article#getTitle").isa', "FUNCTION", 'The isa of non-static method of prototype oblit is correct.');
+		is('symbols.getSymbol("Article.getTitle").alias', "Article.getTitle", 'The alias of a static method of prototype oblit is correct.');
+		is('symbols.getSymbol("Article.getTitle").isa', "FUNCTION", 'The isa of static method of prototype oblit is correct.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/prototype_oblit_constructor.js"]});
+		
+		is('symbols.getSymbol("Article").name', "Article", 'Oblit set to constructor prototype with inner constructor name is found.');
+		is('symbols.getSymbol("Article#init").name', "init", 'The initializer method name of prototype oblit is correct.');
+		is('symbols.getSymbol("Article").hasMember("pages")', true, 'Property set by initializer method "this" is on the outer constructor.');
+		is('symbols.getSymbol("Article#Title").name', "Title", 'Name of the inner constructor name is found.');
+		is('symbols.getSymbol("Article#Title").memberOf', "Article", 'The memberOf of the inner constructor name is found.');
+		is('symbols.getSymbol("Article#Title").isa', "CONSTRUCTOR", 'The isa of the inner constructor name is constructor.');
+		is('symbols.getSymbol("Article#Title").hasMember("title")', true, 'A property set on the inner constructor "this"  is on the inner constructor.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/inner.js"]});
+		
+		is('symbols.getSymbol("Outer").name', "Outer", 'Outer constructor prototype name is found.');
+		is('symbols.getSymbol("Outer").methods.length', 1, 'Inner function doesnt appear as a method of the outer.');
+		is('symbols.getSymbol("Outer").hasMethod("open")', true, 'Outer constructors methods arent affected by inner function.');
+		is('symbols.getSymbol("Outer-Inner").alias', "Outer-Inner", 'Alias of inner function is found.');
+		is('symbols.getSymbol("Outer-Inner").isa', "CONSTRUCTOR", 'isa of inner function constructor is found.');
+		is('symbols.getSymbol("Outer-Inner").memberOf', "Outer", 'The memberOf of inner function is found.');
+		is('symbols.getSymbol("Outer-Inner").name', "Inner", 'The name of inner function is found.');
+		is('symbols.getSymbol("Outer-Inner#name").name', "name", 'A member of the inner function constructor, attached to "this" is found on inner.');
+		is('symbols.getSymbol("Outer-Inner#name").memberOf', "Outer-Inner", 'The memberOf of an inner function member is found.');		
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/prototype_nested.js"]});
+		
+		is('symbols.getSymbol("Word").name', "Word", 'Base constructor name is found.');
+		is('symbols.getSymbol("Word").hasMethod("reverse")', true, 'Base constructor method is found.');
+		is('symbols.getSymbol("Word").methods.length', 1, 'Base constructor has only one method.');
+		is('symbols.getSymbol("Word").memberOf', "", 'Base constructor memberOf is empty.');
+		is('symbols.getSymbol("Word#reverse").name', "reverse", 'Member of constructor prototype name is found.');
+		is('symbols.getSymbol("Word#reverse").memberOf', "Word", 'Member of constructor prototype memberOf is found.');
+		is('symbols.getSymbol("Word#reverse.utf8").name', "utf8", 'Member of constructor prototype method name is found.');
+		is('symbols.getSymbol("Word#reverse.utf8").memberOf', "Word#reverse", 'Static nested member memberOf is found.');
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/namespace_nested.js"]});
+		
+		is('symbols.getSymbol("ns1").name', "ns1", 'Base namespace name is found.');
+		is('symbols.getSymbol("ns1").memberOf', "", 'Base namespace memberOf is empty (its a constructor).');
+		is('symbols.getSymbol("ns1.ns2").name', "ns2", 'Nested namespace name is found.');
+ 		is('symbols.getSymbol("ns1.ns2").alias', "ns1.ns2", 'Nested namespace alias is found.');
+ 		is('symbols.getSymbol("ns1.ns2").memberOf', "ns1", 'Nested namespace memberOf is found.');
+ 		is('symbols.getSymbol("ns1.ns2.Function1").name', "Function1", 'Method of nested namespace name is found.');
+ 		is('symbols.getSymbol("ns1.ns2.Function1").memberOf', "ns1.ns2", 'Constructor of nested namespace memberOf is found.');			
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/functions_nested.js"]});
+		
+		is('symbols.getSymbol("Zop").name', "Zop", 'Any constructor name is found.');
+		is('symbols.getSymbol("Zop").isa', "CONSTRUCTOR", 'It isa constructor.');
+		is('symbols.getSymbol("Zop").hasMethod("zap")', true, 'Its method name, set later, is in methods array.');
+		is('symbols.getSymbol("Foo").name', "Foo", 'The containing constructor name is found.');
+		is('symbols.getSymbol("Foo").hasMethod("methodOne")', true, 'Its method name is found.');
+		is('symbols.getSymbol("Foo").hasMethod("methodTwo")', true, 'Its second method name is found.');
+		is('symbols.getSymbol("Foo#methodOne").alias', "Foo#methodOne", 'A methods alias is found.');
+		is('symbols.getSymbol("Foo#methodOne").isStatic', false, 'A methods is not static.');
+		is('symbols.getSymbol("Bar").name', "Bar", 'A global function declared inside another function is found.');
+		is('symbols.getSymbol("Bar").isa', "FUNCTION", 'It isa function.');
+		is('symbols.getSymbol("Bar").memberOf', "_global_", 'It is global.');
+		is('symbols.getSymbol("Foo-inner").name', "inner", 'An inner functions name is found.');
+		is('symbols.getSymbol("Foo-inner").memberOf', "Foo", 'It is member of the outer function.');
+		is('symbols.getSymbol("Foo-inner").isInner', true, 'It is an inner function.');
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/memberof_constructor.js"]});
+		
+		is('symbols.getSymbol("Circle#Tangent").name', "Tangent", 'Constructor set on prototype using @member has correct name.');
+ 		is('symbols.getSymbol("Circle#Tangent").memberOf', "Circle", 'Constructor set on prototype using @member has correct memberOf.');
+ 		is('symbols.getSymbol("Circle#Tangent").alias', "Circle#Tangent", 'Constructor set on prototype using @member has correct alias.');
+ 		is('symbols.getSymbol("Circle#Tangent").isa', "CONSTRUCTOR", 'Constructor set on prototype using @member has correct isa.');
+		is('symbols.getSymbol("Circle#Tangent").isStatic', false, 'Constructor set on prototype using @member is not static.');
+		is('symbols.getSymbol("Circle#Tangent#getDiameter").name', "getDiameter", 'Method set on prototype using @member has correct name.');
+		is('symbols.getSymbol("Circle#Tangent#getDiameter").memberOf', "Circle#Tangent", 'Method set on prototype using @member has correct memberOf.');
+		is('symbols.getSymbol("Circle#Tangent#getDiameter").alias', "Circle#Tangent#getDiameter", 'Method set on prototype using @member has correct alias.');
+		is('symbols.getSymbol("Circle#Tangent#getDiameter").isa', "FUNCTION", 'Method set on prototype using @member has correct isa.');
+		is('symbols.getSymbol("Circle#Tangent#getDiameter").isStatic', false, 'Method set on prototype using @member is not static.');
+	}
+	,
+	function() {
+		symbolize({a:true, p: true,  _: [SYS.pwd+"test/memberof.js"]});
+		
+		is('symbols.getSymbol("pack.install").alias', "pack.install", 'Using @memberOf sets alias, when parent name is in memberOf tag.');
+		is('symbols.getSymbol("pack.install.overwrite").name', "install.overwrite", 'Using @memberOf sets name, even if the name is dotted.');
+		is('symbols.getSymbol("pack.install.overwrite").memberOf', "pack", 'Using @memberOf sets memberOf.');
+ 		is('symbols.getSymbol("pack.install.overwrite").isStatic', true, 'Using @memberOf with value not ending in octothorp sets isStatic to true.');
+	}
+	,
+	function() {
+		symbolize({a:true, p: true,  _: [SYS.pwd+"test/memberof2.js"]});
+		
+		is('symbols.getSymbol("Foo#bar").alias', "Foo#bar", 'An inner function can be documented as an instance method.');
+		is('symbols.getSymbol("Foo.zip").alias', "Foo.zip", 'An inner function can be documented as a static method.');
+		is('symbols.getSymbol("Foo.Fiz").alias', "Foo.Fiz", 'An inner function can be documented as a static constructor.');
+		is('symbols.getSymbol("Foo.Fiz#fipple").alias', "Foo.Fiz#fipple", 'An inner function can be documented as a static constructor with a method.');
+		is('symbols.getSymbol("Foo#blat").alias', "Foo#blat", 'An global function can be documented as an instance method.');
+	}
+	,
+	function() {
+		symbolize({a:true, p: true,  _: [SYS.pwd+"test/memberof3.js"]});
+		
+		is('symbols.getSymbol("Foo#bar").alias', "Foo#bar", 'A virtual field can be documented as an instance method.');
+		is('symbols.getSymbol("Foo2#bar").alias', "Foo2#bar", 'A virtual field with the same name can be documented as an instance method.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/borrows.js"]});
+
+		is('symbols.getSymbol("Layout").name', "Layout", 'Constructor can be found.');
+		is('symbols.getSymbol("Layout").hasMethod("init")', true, 'Constructor method name can be found.');
+		is('symbols.getSymbol("Layout").hasMember("orientation")', true, 'Constructor property name can be found.');
+		
+		is('symbols.getSymbol("Page").hasMethod("reset")', true, 'Second constructor method name can be found.');
+		is('symbols.getSymbol("Page").hasMember("orientation")', true, 'Second constructor borrowed property name can be found in properties.');
+		is('symbols.getSymbol("Page#orientation").memberOf', "Page", 'Second constructor borrowed property memberOf can be found.');
+		is('symbols.getSymbol("Page-getInnerElements").alias', "Page-getInnerElements", 'Can borrow an inner function and it is still inner.');
+		is('symbols.getSymbol("Page.units").alias', "Page.units", 'Can borrow a static function and it is still static.');
+		
+		is('symbols.getSymbol("ThreeColumnPage#init").alias', "ThreeColumnPage#init", 'Third constructor method can be found even though method with same name is borrowed.');
+		is('symbols.getSymbol("ThreeColumnPage#reset").alias', "ThreeColumnPage#reset", 'Borrowed method can be found.');
+		is('symbols.getSymbol("ThreeColumnPage#orientation").alias', "ThreeColumnPage#orientation", 'Twice borrowed method can be found.');
+	
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/borrows2.js"]});
+
+		is('symbols.getSymbol("Foo").hasMethod("my_zop")', true, 'Borrowed method can be found.');		
+		is('symbols.getSymbol("Bar").hasMethod("my_zip")', true, 'Second borrowed method can be found.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/constructs.js"]});
+
+		is('symbols.getSymbol("Person").hasMethod("say")', true, 'The constructs tag creates a class that lends can add a method to.');		
+	}
+	,
+	function() {
+		symbolize({a: true, _: [SYS.pwd+"test/augments.js", SYS.pwd+"test/augments2.js"]});
+		
+		is('symbols.getSymbol("Page").augments[0]', "Layout", 'An augmented class can be found.');
+		is('symbols.getSymbol("Page#reset").alias', "Page#reset", 'Method of augmenter can be found.');
+		is('symbols.getSymbol("Page").hasMethod("Layout#init")', true, 'Method from augmented can be found.');
+		is('symbols.getSymbol("Page").hasMember("Layout#orientation")', true, 'Property from augmented can be found.');
+		is('symbols.getSymbol("Page").methods.length', 3, 'Methods of augmented class are included in methods array.');
+	
+		is('symbols.getSymbol("ThreeColumnPage").augments[0]', "Page", 'The extends tag is a synonym for augments.');
+		is('symbols.getSymbol("ThreeColumnPage").hasMethod("ThreeColumnPage#init")', true, 'Local method overrides augmented method of same name.');
+		is('symbols.getSymbol("ThreeColumnPage").methods.length', 3, 'Local method count is right.');
+		
+		is('symbols.getSymbol("NewsletterPage").augments[0]', "ThreeColumnPage", 'Can augment across file boundaries.');
+		is('symbols.getSymbol("NewsletterPage").augments.length', 2, 'Multiple augments are supported.');
+		is('symbols.getSymbol("NewsletterPage").inherits[0].alias', "Junkmail#annoy", 'Inherited method with augments.');
+		is('symbols.getSymbol("NewsletterPage").methods.length', 6, 'Methods of augmented class are included in methods array across files.');
+		is('symbols.getSymbol("NewsletterPage").properties.length', 1, 'Properties of augmented class are included in properties array across files.');
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/static_this.js"]});
+		
+		is('symbols.getSymbol("box.holder").name', "holder", 'Static namespace name can be found.');
+		is('symbols.getSymbol("box.holder.foo").name', "foo", 'Static namespace method name can be found.');
+		is('symbols.getSymbol("box.holder").isStatic', true, 'Static namespace method is static.');
+		
+		is('symbols.getSymbol("box.holder.counter").name', "counter", 'Instance namespace property name set on "this" can be found.');
+		is('symbols.getSymbol("box.holder.counter").alias', "box.holder.counter", 'Instance namespace property alias set on "this" can be found.');
+		is('symbols.getSymbol("box.holder.counter").memberOf', "box.holder", 'Static namespace property memberOf set on "this" can be found.');
+	}
+	,
+	function() {
+		symbolize({a:true, p: true, _: [SYS.pwd+"test/lend.js"]});
+
+		is('symbols.getSymbol("Person").name', "Person", 'Class defined in lend comment is found.');
+		is('symbols.getSymbol("Person").hasMethod("initialize")', true, 'Lent instance method name can be found.');
+		is('symbols.getSymbol("Person").hasMethod("say")', true, 'Second instance method can be found.');
+		is('symbols.getSymbol("Person#sing").isStatic', false, 'Instance method is known to be not static.');
+		
+		is('symbols.getSymbol("Person.getCount").name', "getCount", 'Static method name from second lend comment can be found.');
+		is('symbols.getSymbol("Person.getCount").isStatic', true, 'Static method from second lend comment is known to be static.');
+	
+		is('LOG.warnings.filter(function($){if($.indexOf("notok") > -1) return $}).length', 1, 'A warning is emitted when lending to an undocumented parent.');
+	}
+	,
+	function() {
+		symbolize({a:true, _: [SYS.pwd+"test/param_inline.js"]});
+	
+		is('symbols.getSymbol("Layout").params[0].type', "int", 'Inline param name is set.');
+		is('symbols.getSymbol("Layout").params[0].desc', "The number of columns.", 'Inline param desc is set from comment.');
+		is('symbols.getSymbol("Layout#getElement").params[0].name', "id", 'User defined param documentation takes precedence over parser defined.');
+		is('symbols.getSymbol("Layout#getElement").params[0].isOptional', true, 'Default for param is to not be optional.');
+		is('symbols.getSymbol("Layout#getElement").params[1].isOptional', false, 'Can mark a param as being optional.');
+		is('symbols.getSymbol("Layout#getElement").params[1].type', "number|string", 'Type of inline param doc can have multiple values.');
+		is('symbols.getSymbol("Layout#Canvas").params[0].type', "", 'Type can be not defined for some params.');
+		is('symbols.getSymbol("Layout#Canvas").params[2].type', "int", 'Type can be defined inline for only some params.');
+		is('symbols.getSymbol("Layout#rotate").params.length', 0, 'Docomments inside function sig is ignored without a param.');
+		is('symbols.getSymbol("Layout#init").params[2].type', "zoppler", 'Doc comment type overrides inline type for param with same name.');
+	}
+	,
+	function() {
+		symbolize({a: true, _: [SYS.pwd+"test/shared.js", SYS.pwd+"test/shared2.js"]});
+
+		is('symbols.getSymbol("Array#some").name', 'some', 'The name of a symbol in a shared section is found.');
+		is('symbols.getSymbol("Array#some").alias', 'Array#some', 'The alias of a symbol in a shared section is found.');
+		is('symbols.getSymbol("Array#some").desc', "Extension to builtin array.", 'A description can be shared.');
+		is('symbols.getSymbol("Array#filter").desc', "Extension to builtin array.\nChange every element of an array.", 'A shared description is appended.');
+		is('symbols.getSymbol("Queue").desc', "A first in, first out data structure.", 'A description is not shared when outside a shared section.');
+		is('symbols.getSymbol("Queue.rewind").alias', "Queue.rewind", 'Second shared tag can be started.');
+		is('symbols.getSymbol("startOver").alias', "startOver", 'Shared tag doesnt cross over files.');
+	}
+	,
+	function() {
+		symbolize({a: true, _: [SYS.pwd+"test/config.js"]});
+		is('symbols.getSymbol("Contact").params[0].name', 'person', 'The name of a param is found.');
+		is('symbols.getSymbol("Contact").params[1].name', 'person.name', 'The name of a param set with a dot name is found.');
+		is('symbols.getSymbol("Contact").params[2].name', 'person.age', 'The name of a second param set with a dot name is found.');
+		is('symbols.getSymbol("Contact").params[4].name', 'connection', 'The name of a param after config is found.');
+		
+		is('symbols.getSymbol("Family").params[0].name', 'persons', 'Another name of a param is found.');
+		is('symbols.getSymbol("Family").params[1].name', 'persons.Father', 'The name of a param+config is found.');
+		is('symbols.getSymbol("Family").params[2].name', 'persons.Mother', 'The name of a second param+config is found.');
+		is('symbols.getSymbol("Family").params[3].name', 'persons.Children', 'The name of a third param+config is found.');	
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/ignore.js"]});
+		is('LOG.warnings.filter(function($){if($.indexOf("undocumented symbol Ignored") > -1) return $}).length', 1, 'A warning is emitted when documenting members of an ignored parent.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/functions_anon.js"]});
+		is('symbols.getSymbol("a.b").alias', 'a.b', 'In anonymous constructor this is found to be the container object.');
+		is('symbols.getSymbol("a.f").alias', 'a.f', 'In anonymous constructor this can have a method.');
+		is('symbols.getSymbol("a.c").alias', 'a.c', 'In anonymous constructor method this is found to be the container object.');
+		is('symbols.getSymbol("g").alias', 'g', 'In anonymous function executed inline this is the global.');
+		is('symbols.getSymbol("bar2.p").alias', 'bar2.p', 'In named constructor executed inline this is the container object.');
+		is('symbols.getSymbol("module.pub").alias', 'module.pub', 'In parenthesized anonymous function executed inline function scoped variables arent documented.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/oblit_anon.js"]});
+		is('symbols.getSymbol("opt").name', 'opt', 'Anonymous object properties are created.');
+		is('symbols.getSymbol("opt.conf.keep").alias', 'opt.conf.keep', 'Anonymous object first property is assigned to $anonymous.');
+		is('symbols.getSymbol("opt.conf.base").alias', 'opt.conf.base', 'Anonymous object second property is assigned to $anonymous.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/params_optional.js"]});
+		is('symbols.getSymbol("Document").params.length', 3, 'Correct number of params are found when optional param syntax is used.');
+		is('symbols.getSymbol("Document").params[1].name', "id", 'Name of optional param is found.');
+		is('symbols.getSymbol("Document").params[1].isOptional', true, 'Optional param is marked isOptional.');
+		is('symbols.getSymbol("Document").params[2].name', "title", 'Name of optional param with default value is found.');
+		is('symbols.getSymbol("Document").params[2].isOptional', true, 'Optional param with default value is marked isOptional.');
+		is('symbols.getSymbol("Document").params[2].defaultValue', " This is untitled.", 'Optional param default value is found.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/synonyms.js"]});
+		is('symbols.getSymbol("myObject.myFunc").type', 'function', 'Type can be set to function.');
+	}
+	,
+	function() {
+		symbolize({a:true, p:true, _: [SYS.pwd+"test/event.js"]});
+		is('symbols.getSymbol("Kitchen#event:cakeEaten").isEvent', true, 'Function with event prefix is an event.');
+		is('symbols.getSymbol("Kitchen#cakeEaten").isa', "FUNCTION", 'Function with same name as event isa function.');
+	}
+	,
+	function() {
+		symbolize({x:"js", a:true, _: [SYS.pwd+"test/scripts/"]});
+		is('JSDOC.JsDoc.srcFiles.length', 1, 'Only js files are scanned when -x=js.');
+	}
+	,
+	function() {
+		symbolize({x:"js", a:true, _: [SYS.pwd+"test/exports.js"]});
+		is('symbols.getSymbol("mxn.Map#doThings").name', 'doThings', 'Exports creates a documentation alias that can have methods.');
+	}
+	,
+	function() {
+		symbolize({p:true, a:true, _: [SYS.pwd+"test/module.js"]});
+		is('symbols.getSymbol("myProject.myModule.myPublicMethod").name', 'myPublicMethod', 'A function wrapped in parens can be recognized.');
+		is('symbols.getSymbol("myProject.myModule-myPrivateMethod").name', 'myPrivateMethod', 'A private method in the scope of a function wrapped in parens can be recognized.');
+		is('symbols.getSymbol("myProject.myModule-myPrivateVar").name', 'myPrivateVar', 'A private member in the scope of a function wrapped in parens can be recognized.');
+	}
+];
+
+//// run and print results
+print(testrun(testCases));

bin/jsdoc/test/addon.js

@@ -0,0 +1,24 @@
+String.prototype.reverse = function() {
+}
+
+String.prototype.reverse.utf8 = function() {
+}
+
+Function.count = function() {
+}
+
+/** @memberOf Function */
+Function.count.reset = function() {
+}
+
+/** @memberOf Function */
+count.getValue = function() {
+}
+
+/** @memberOf Function.prototype */
+getSig = function() {
+}
+
+/** @memberOf Function.prototype */
+Function.prototype.getProps = function() {
+}

bin/jsdoc/test/anon_inner.js

@@ -0,0 +1,14 @@
+/**
+ * @name bar
+ * @namespace
+ */
+ 
+new function() {
+    /**
+     * @name bar-foo
+     * @function
+     * @param {number} x
+     */
+    function foo(x) {
+    }
+}

bin/jsdoc/test/augments.js

@@ -0,0 +1,31 @@
+/**
+@constructor
+*/
+function Layout(p) {
+	this.init = function(p) {
+	}
+	
+	this.getId = function() {
+	}
+	
+	/** @type Page */
+	this.orientation = "landscape";
+}
+
+/**
+@constructor
+@augments Layout
+*/
+function Page() {
+	this.reset = function(b) {
+	}
+}
+
+/**
+@extends Page
+@constructor
+*/
+function ThreeColumnPage() {
+	this.init = function(resetCode) {
+	}
+}

bin/jsdoc/test/augments2.js

@@ -0,0 +1,26 @@
+/**
+@constructor
+*/
+function LibraryItem() {
+	this.reserve = function() {
+	}
+}
+
+/**
+@constructor
+*/
+function Junkmail() {
+	this.annoy = function() {
+	}
+}
+
+/**
+@inherits Junkmail.prototype.annoy as pester
+@augments ThreeColumnPage
+@augments LibraryItem
+@constructor
+*/
+function NewsletterPage() {
+	this.getHeadline = function() {
+	}
+}

bin/jsdoc/test/borrows.js

@@ -0,0 +1,46 @@
+/**
+@constructor
+*/
+function Layout(p) {
+	/** initilize 1 */
+	this.init = function(p) {
+	}
+	
+	/** get the id */
+	this.getId = function() {
+	}
+	
+	/** @type string */
+	this.orientation = "landscape";
+	
+	function getInnerElements(elementSecretId){
+	}
+}
+
+/** A static method. */
+Layout.units = function() {
+}
+
+/**
+@constructor
+@borrows Layout#orientation
+@borrows Layout-getInnerElements
+@borrows Layout.units
+*/
+function Page() {
+	/** reset the page */
+	this.reset = function(b) {
+	}
+}
+
+/**
+@constructor
+@borrows Layout.prototype.orientation as this.orientation
+@borrows Layout.prototype.init as #init
+@inherits Page.prototype.reset as #reset
+*/
+function ThreeColumnPage() {
+	/** initilize 2 */
+	this.init = function(p) {
+	}
+}

bin/jsdoc/test/borrows2.js

@@ -0,0 +1,23 @@
+// testing circular borrows
+
+/**
+	@class
+	@borrows Bar#zop as this.my_zop
+*/
+function Foo() {
+	/** this is a zip. */
+	this.zip = function() {}
+	
+	this.my_zop = new Bar().zop;
+}
+
+/**
+	@class
+	@borrows Foo#zip as this.my_zip
+*/
+function Bar() {
+	/** this is a zop. */
+	this.zop = function() {}
+	
+	this.my_zip = new Foo().zip;
+}

bin/jsdoc/test/config.js

@@ -0,0 +1,22 @@
+/**
+ * @constructor
+ * @param person The person.
+ * @param {string} person.name The person's name.
+ * @config {integer} age The person's age.
+ * @config [id=1] Optional id number to use.
+ * @param connection
+ */
+function Contact(person, connection) {
+
+}
+
+/**
+ * @constructor
+ * @param persons
+ * @config {string} Father The paternal person.
+ * @config {string} Mother The maternal person.
+ * @config {string[]} Children And the rest.
+ */
+function Family(/**Object*/persons) {
+
+}

bin/jsdoc/test/constructs.js

@@ -0,0 +1,18 @@
+var Person = makeClass(
+    /**
+      @scope Person
+    */
+    {
+        /**
+        	This is just another way to define a constructor.
+        	@constructs
+        	@param {string} name The name of the person.
+         */
+        initialize: function(name) {
+            this.name = name;
+        },
+        say: function(message) {
+            return this.name + " says: " + message;
+        }
+    }
+);

bin/jsdoc/test/encoding.js

@@ -0,0 +1,10 @@
+
+/**
+ * @Constructor
+ * @desc 配置文件
+ * @class 什么也不返回
+ */
+function Test(conf) {
+    // do something;
+}
+

bin/jsdoc/test/encoding_other.js

@@ -0,0 +1,12 @@
+
+/**
+ * @Constructor
+ * @desc ðïîÛ
+ * @class ßàáâãäåæçèçìëêíîï °±²³´µ¡¶·¸¹
+ */
+function Test(conf) {
+    // do something;
+}
+
+// run with commanline option -e=iso-8859-5
+

bin/jsdoc/test/event.js

@@ -0,0 +1,54 @@
+/**
+ * @name Kitchen
+ * @constructor
+ * @fires Bakery#event:donutOrdered
+ */
+
+/**
+ * Fired when some cake is eaten.
+ * @name Kitchen#event:cakeEaten
+ * @function
+ * @param {Number} pieces The number of pieces eaten.
+ */
+
+/**
+ * Find out if cake was eaten.
+ * @name Kitchen#cakeEaten
+ * @function
+ * @param {Boolean} wasEaten
+ */
+
+/**
+ * @name getDesert
+ * @function
+ * @fires Kitchen#event:cakeEaten
+ */
+ 
+/**
+ * @name Bakery
+ * @constructor
+ * @extends Kitchen
+ */
+
+/**
+ * Fired when a donut order is made.
+ * @name Bakery#event:donutOrdered
+ * @event
+ * @param {Event} e The event object.
+ * @param {String} [e.topping] Optional sprinkles.
+ */
+
+/**
+ * @constructor
+ * @borrows Bakery#event:donutOrdered as this.event:cakeOrdered
+ */
+function CakeShop() {
+}
+
+/** @event */
+CakeShop.prototype.icingReady = function(isPink) {
+}
+
+/** @event */
+function amHungry(/**Boolean*/enoughToEatAHorse) {
+}

bin/jsdoc/test/exports.js

@@ -0,0 +1,14 @@
+/** @namespace */
+var mxn = {};
+
+(function(){ 
+    /** @exports Map as mxn.Map */
+    var Map =
+        /** @constructor */
+        mxn.Map = function() {
+        };
+    
+    /** A method. */
+    Map.prototype.doThings = function() {
+    };
+})();

bin/jsdoc/test/functions_anon.js

@@ -0,0 +1,39 @@
+/** an anonymous constructor executed inline */
+a = new function() {
+	/** a.b*/
+    this.b = 1;
+    /** a.f */
+    this.f = function() {
+    	/** a.c */
+    	this.c = 2;
+    }
+}
+
+
+/**
+	named function executed inline
+*/
+bar1 = function Zoola1() {
+	/** property of global */
+	this.g = 1;
+}();
+
+/**
+	named constructor executed inline
+*/
+bar2 = new function Zoola2() {
+	/** property of bar */
+	this.p = 1;
+};
+
+/** module pattern */
+module = (function () {
+	/** won't appear in documentation */
+	var priv = 1;
+	
+	/** @scope module */
+	return {
+		/** will appear as a property of module */
+		pub: 1
+	}
+})();

bin/jsdoc/test/functions_nested.js

@@ -0,0 +1,33 @@
+/** @constructor */
+function Zop() {
+}
+
+/**
+ @class
+*/
+Foo = function(id) {
+	// this is a bit twisted, but if you call Foo() you will then
+	// modify Foo(). This is kinda, sorta non-insane, because you
+	// would have to call Foo() 100% of the time to use Foo's methods
+	Foo.prototype.methodOne = function(bar) {
+	  alert(bar);
+	};
+	
+	// same again
+	Foo.prototype.methodTwo = function(bar2) {
+	  alert(bar2);
+	};
+	
+	// and these are only executed if the enclosing function is actually called
+	// and who knows if that will ever happen?
+	Bar = function(pez) {
+	  alert(pez);
+	};
+	Zop.prototype.zap = function(p){
+		alert(p);
+	};
+	
+	// but this is only visible inside Foo
+	function inner() {
+	}
+};

bin/jsdoc/test/global.js

@@ -0,0 +1,13 @@
+/** ecks */
+var x = [1, 2, 4];
+
+var y = {
+	foo: function(){
+	}
+}
+
+bar = function() {
+}
+
+function zop() {
+}

bin/jsdoc/test/globals.js

@@ -0,0 +1,25 @@
+function example(/**Circle*/a, b) {
+	/** a global defined in function  */
+	var number = a;
+	
+	var hideNumber = function(){
+	}
+	
+	setNumber = function(){
+	}
+	alert('You have chosen: ' + b);
+}
+
+function initPage() {
+	var supported = document.createElement && document.getElementsByTagName;
+	if (!supported) return;
+	// start of DOM script
+	var x = document.getElementById('writeroot');
+	// etc.
+}
+
+/** an example var */
+var document = new Document(x, y);
+
+var getNumber = function(){
+}

bin/jsdoc/test/ignore.js

@@ -0,0 +1,10 @@
+/**
+ * A test constructor.
+ * @constructor
+ * @ignore
+ */
+function Ignored() {
+	/** a method */
+    this.bar = function() {
+    }
+}

bin/jsdoc/test/inner.js

@@ -0,0 +1,16 @@
+/**
+ * @constructor
+ */
+function Outer() {
+  /**
+   * @constructor
+   */
+  function Inner(name) {
+    /** The name of this. */
+    this.name = name;
+  }
+
+  this.open = function(name) {
+    return (new Inner(name));
+  }
+}

bin/jsdoc/test/jsdoc_test.js

@@ -0,0 +1,477 @@
+/** 
+ * @fileoverview This file is to be used for testing the JSDoc parser
+ * It is not intended to be an example of good JavaScript OO-programming,
+ * nor is it intended to fulfill any specific purpose apart from 
+ * demonstrating the functionality of the 
+ * <a href='http://sourceforge.net/projects/jsdoc'>JSDoc</a> parser
+ *
+ * @author Gabriel Reid gab_reid@users.sourceforge.net
+ * @version 0.1 
+ */
+
+
+/**
+ * Construct a new Shape object.
+ * @class This is the basic Shape class.  
+ * It can be considered an abstract class, even though no such thing
+ * really existing in JavaScript
+ * @constructor
+ * @throws MemoryException if there is no more memory 
+ * @throws GeneralShapeException rarely (if ever)
+ * @return {Shape|Coordinate} A new shape.
+ */
+function Shape(){
+  
+   /**
+    * This is an example of a function that is not given as a property
+    * of a prototype, but instead it is assigned within a constructor.
+    * For inner functions like this to be picked up by the parser, the
+    * function that acts as a constructor <b>must</b> be denoted with
+    * the <b>&#64;constructor</b> tag in its comment.
+    * @type String
+    */
+   this.getClassName = function(){
+      return "Shape";
+   }
+
+   /** 
+    * This is an inner method, just used here as an example
+    * @since version 0.5
+    * @author Sue Smart
+    */
+   function addReference(){
+       // Do nothing...
+   }
+   
+}
+
+/**
+ * Create a new Hexagon instance.
+ * @extends Shape
+ * @class Hexagon is a class that is a <i>logical</i> sublcass of 
+ * {@link Shape} (thanks to the <code>&#64;extends</code> tag), but in 
+ * reality it is completely unrelated to Shape.
+ * @param {int} sideLength The length of one side for the new Hexagon
+ * @example
+ * var h = new Hexagon(2);
+ * @example
+ * if (hasHex) {
+ *     hex   = new Hexagon(5);
+ *     color = hex.getColor();
+ * }
+ */
+function Hexagon(sideLength) {
+}
+
+
+/**
+ * This is an unattached (static) function that adds two integers together.
+ * @param {int} One The first number to add 
+ * @param {int} Two The second number to add 
+ * @author Gabriel Reid
+ * @deprecated So you shouldn't use it anymore! Use {@link Shape#getClassName} instead.
+ */
+function Add(One, Two){
+    return One + Two;
+}
+
+
+/**
+ * The color of this shape
+ * @type Color
+ */
+Shape.prototype.color = null;
+
+/**
+ * The border of this shape. 
+ * @field
+ * @type int
+ */
+Shape.prototype.border = function(){return border;};
+
+/*
+ * These are all the instance method implementations for Shape
+ */
+
+/**
+ * Get the coordinates of this shape. It is assumed that we're always talking
+ * about shapes in a 2D location here.
+ * @requires The {@link Shape} class
+ * @returns A Coordinate object representing the location of this Shape
+ * @type Coordinate[]
+ */
+Shape.prototype.getCoords = function(){
+   return this.coords;
+}
+
+/**
+ * Get the color of this shape.
+ * @see #setColor
+ * @see The <a href="http://example.com">Color</a> library.
+ * @link Shape
+ * @type Color
+ */
+Shape.prototype.getColor = function(){
+   return this.color;
+}
+
+/**
+ * Set the coordinates for this Shape
+ * @param {Coordinate} coordinates The coordinates to set for this Shape
+ */
+Shape.prototype.setCoords = function(coordinates){
+   this.coords = coordinates;
+}
+
+/**
+ * Set the color for this Shape
+ * @param {Color} color The color to set for this Shape
+ * @param other There is no other param, but it can still be documented if
+ *              optional parameters are used
+ * @throws NonExistantColorException (no, not really!)
+ * @see #getColor
+ */
+Shape.prototype.setColor = function(color){
+   this.color = color;
+}
+
+/**
+ * Clone this shape
+ * @returns A copy of this shape
+ * @type Shape
+ * @author Gabriel Reid
+ */
+Shape.prototype.clone = function(){
+   return new Shape();
+}
+
+/**
+ * Create a new Rectangle instance. 
+ * @class A basic rectangle class, inherits from Shape.
+ * This class could be considered a concrete implementation class
+ * @constructor
+ * @param {int} width The optional width for this Rectangle
+ * @param {int} height Thie optional height for this Rectangle
+ * @author Gabriel Reid
+ * @see Shape is the base class for this
+ * @augments Shape
+ * @hilited
+ */
+function Rectangle(width, // This is the width 
+                  height // This is the height
+                  ){
+   if (width){
+      this.width = width;
+      if (height){
+	 this.height = height;
+      }
+   }
+}
+
+
+/* Inherit from Shape */
+Rectangle.prototype = new Shape();
+
+/**
+ * Value to represent the width of the Rectangle.
+ * <br>Text in <b>bold</b> and <i>italic</i> and a 
+ * link to <a href="http://sf.net">SourceForge</a>
+ * @private
+ * @type int
+ */
+Rectangle.prototype.width = 0;
+
+/**
+ * Value to represent the height of the Rectangle
+ * @private
+ * @type int
+ */
+Rectangle.prototype.height = 0;
+
+/**
+ * Get the type of this object. 
+ * @type String
+ */
+Rectangle.prototype.getClassName= function(){
+    return "Rectangle";
+}
+
+/**
+ * Get the value of the width for the Rectangle
+ * @type int
+ * @see Rectangle#setWidth
+ */
+Rectangle.prototype.getWidth = function(){
+   return this.width;
+}
+
+/**
+ * Get the value of the height for the Rectangle.
+ * Another getter is the {@link Shape#getColor} method in the 
+ * {@link Shape} base class.  
+ * @return The height of this Rectangle
+ * @type int
+ * @see Rectangle#setHeight
+ */
+Rectangle.prototype.getHeight = function(){
+    return this.height;
+}
+
+/**
+ * Set the width value for this Rectangle.
+ * @param {int} width The width value to be set
+ * @see #setWidth
+ */
+Rectangle.prototype.setWidth = function(width){
+   this.width = width;
+}
+
+/**
+ * Set the height value for this Rectangle.
+ * @param {int} height The height value to be set
+ * @see #getHeight
+ */
+Rectangle.prototype.setHeight = function(height){
+   this.height = height;
+}
+
+/**
+ * Get the value for the total area of this Rectangle
+ * @return total area of this Rectangle
+ * @type int
+ */
+Rectangle.prototype.getArea = function(){
+   return width * height;
+}
+
+
+/**
+ * Create a new Square instance.
+ * @class A Square is a subclass of {@link Rectangle}
+ * @param {int} width The optional width for this Rectangle
+ * @param {int} height The optional height for this Rectangle
+ * @augments Rectangle
+ */
+function Square(width, height){
+   if (width){
+      this.width = width;
+      if (height){
+	 this.height = height;
+      }
+   } 
+   
+}
+
+/* Square is a subclass of Rectangle */
+Square.prototype = new Rectangle();
+
+/**
+ * Set the width value for this Shape.
+ * @param {int} width The width value to be set
+ * @see #getWidth
+ */
+Square.prototype.setWidth = function(width){
+   this.width = this.height = width;
+}
+
+/**
+ * Set the height value for this Shape 
+ * Sets the {@link Rectangle#height} attribute in the Rectangle.
+ * @param {int} height The height value to be set
+ */
+Square.prototype.setHeight = function(height){
+   this.height = this.width = height;
+}
+
+
+/**
+ * Create a new Circle instance based on a radius.
+ * @class Circle class is another subclass of Shape
+ * @extends Shape
+ * @param {int} radius The optional radius of this {@link Circle }
+ * @mixin Square.prototype.setWidth as this.setDiameter
+ */
+function Circle(radius){
+   if (radius) {
+      /** The radius of the this Circle. */
+      this.radius = radius;
+   }
+}
+
+/* Circle inherits from {@link Shape} */
+Circle.prototype = new Shape();
+
+/** 
+ * The radius value for this Circle 
+ * @private
+ * @type int
+ */
+Circle.prototype.radius = 0;
+
+/** 
+ * A very simple class (static) field that is also a constant
+ * @final
+ * @type float
+ */
+Circle.PI = 3.14;
+
+/**
+ * Get the radius value for this Circle
+ * @type int
+ * @see #setRadius
+ */
+Circle.prototype.getRadius = function(){
+   return this.radius;
+}
+
+/** 
+ * Set the radius value for this Circle
+ * @param {int} radius The {@link Circle#radius} value to set
+ * @see #getRadius
+ */
+Circle.prototype.setRadius = function(radius){
+   this.radius = radius;
+}
+
+/** 
+ * An example of a  class (static) method that acts as a factory for Circle
+ * objects. Given a radius value, this method creates a new Circle.
+ * @param {int} radius The radius value to use for the new Circle.
+ * @type Circle
+ */
+Circle.createCircle = function(radius){
+    return new Circle(radius);
+}
+
+
+/**
+ * Create a new Coordinate instance based on x and y grid data.
+ * @class Coordinate is a class that can encapsulate location information.
+ * @param {int} [x=0] The optional x portion of the Coordinate
+ * @param {int} [y=0] The optinal y portion of the Coordinate
+ */
+function Coordinate(x, y){
+   if (x){
+      this.x = x;
+      if (y){
+	 this.y = y;
+      }
+   }
+}
+
+/** 
+ * The x portion of the Coordinate 
+ * @type int
+ * @see #getX
+ * @see #setX
+ */
+Coordinate.prototype.x = 0;
+
+/** 
+ * The y portion of the Coordinate 
+ * @type int
+ * @see #getY
+ * @see #setY
+ */
+Coordinate.prototype.y = 0;
+
+/**
+ * Gets the x portion of the Coordinate.
+ * @type int
+ * @see #setX
+ */
+Coordinate.prototype.getX = function(){
+   return this.x;
+}
+
+/** 
+ * Get the y portion of the Coordinate.
+ * @type int
+ * @see #setY
+ */
+Coordinate.prototype.getY = function(){
+   return this.y;
+}
+
+/**
+ * Sets the x portion of the Coordinate.
+ * @param {int} x The x value to set
+ * @see #getX
+ */
+Coordinate.prototype.setX = function(x){
+   this.x = x;
+}
+
+/** 
+ * Sets the y portion of the Coordinate.
+ * @param {int} y The y value to set
+ * @see #getY
+ */
+Coordinate.prototype.setY = function(y){
+   this.y = y;
+}
+
+/**
+ * @class This class exists to demonstrate the assignment of a class prototype
+ * as an anonymous block.
+ */
+function ShapeFactory(){
+}
+
+ShapeFactory.prototype = {
+   /** 
+    * Creates a new {@link Shape} instance.
+    * @return A new {@link Shape}
+    * @type Shape
+    */
+   createShape: function(){
+      return new Shape();
+   }
+}
+
+/**
+ * An example of a singleton class
+ * @param ... Arguments represent {@link coordinate}s in the shape.
+ * @constructor
+ */
+MySingletonShapeFactory = function(){
+
+   /**
+    * Get the next {@link Shape}
+    * @type Shape
+    * @return A new {@link Shape}
+    */
+   this.getShape = function(){ 
+      return null; 
+   }
+
+}
+
+
+/** 
+ * Create a new Foo instance.
+ * @class This is the Foo class. It exists to demonstrate 'nested' classes.
+ * @constructor 
+ * @see Foo.Bar
+ */
+function Foo(){}
+
+/** 
+ * Creates a new instance of Bar.
+ * @class This class exists to demonstrate 'nested' classes.
+ * @constructor 
+ * @see Foo.Bar
+ */
+function Bar(){}
+
+/** 
+ * Nested class
+ * @constructor 
+ */
+Foo.Bar = function(){
+	/** The x. */ this.x = 2;
+}
+
+Foo.Bar.prototype = new Bar();
+/** The y. */ 
+Foo.Bar.prototype.y = '3';

bin/jsdoc/test/lend.js

@@ -0,0 +1,33 @@
+ /** @class  */
+var Person = Class.create(
+    /**
+      @lends Person.prototype
+    */
+    {
+      initialize: function(name) {
+            this.name = name;
+        },
+        say: function(message) {
+            return this.name + ': ' + message;
+        }
+    }
+ );
+
+/** @lends Person.prototype */
+{
+	/** like say but more musical */
+	sing: function(song) {
+	}
+}
+
+/** @lends Person */
+{
+	getCount: function() {
+	}
+}
+
+/** @lends Unknown.prototype */
+{
+	notok: function() {
+	}
+}

bin/jsdoc/test/memberof.js

@@ -0,0 +1,19 @@
+/** @constructor */
+pack = function() {
+	this.init = function(){}
+	function config(){}
+}
+ 
+ pack.build = function(task) {};
+
+/** @memberOf pack */
+pack.install = function() {}
+
+/** @memberOf pack */
+pack.install.overwrite = function() {}
+
+/** @memberOf pack */
+clean = function() {}
+
+/** @memberOf pack-config */
+install = function() {};

bin/jsdoc/test/memberof2.js

@@ -0,0 +1,38 @@
+/**
+ * @constructor
+ */
+function Foo() {
+    /**
+    	@memberOf Foo.prototype
+    */
+    function bar(a, b) {
+    }
+    
+    /**
+    	@memberOf Foo
+    */
+    var zip = function(p, q) {
+    }
+    
+    /**
+    	@memberOf Foo
+    */
+    function zop( x,y ) {
+    }
+    
+    /**
+    	@memberOf Foo
+    	@constructor
+    */
+    function Fiz() {
+    	/** A method of Foo#Fiz. */
+    	this.fipple = function(fop){}
+    }
+}
+
+/**
+	@memberOf Foo#
+ */
+var blat = function() {
+
+}

bin/jsdoc/test/memberof3.js

@@ -0,0 +1,33 @@
+/**
+* @name Foo
+* @class
+*/
+
+/**#@+
+* @memberOf Foo#
+* @field
+*/
+
+/**
+* @name bar
+* @type Object[]
+*/
+
+/**#@-*/
+
+/**
+* @name Foo2
+* @class
+*/
+
+/**#@+
+* @memberOf Foo2#
+* @field
+*/
+
+/**
+* @name bar
+* @type Object[]
+*/
+
+/**#@-*/

bin/jsdoc/test/memberof_constructor.js

@@ -0,0 +1,17 @@
+/** @constructor */
+function Circle(){}
+
+/**
+	@constructor
+	@memberOf Circle#
+ */
+Circle.prototype.Tangent = function(){};
+
+// renaming Circle#Tangent to Circle#Circle#Tangent
+
+/**
+	@memberOf Circle#Tangent#
+ */
+Circle.prototype.Tangent.prototype.getDiameter = function(){};
+
+

bin/jsdoc/test/module.js

@@ -0,0 +1,17 @@
+/** @namespace */
+myProject = myProject || {};
+
+/** @namespace */
+myProject.myModule = (function () {
+	/** describe myPrivateVar here */
+	var myPrivateVar = "";
+
+	var myPrivateMethod = function () {
+	}
+
+	/** @scope myProject.myModule */
+	return {
+		myPublicMethod: function () {
+		}
+	};
+})();

bin/jsdoc/test/multi_methods.js

@@ -0,0 +1,25 @@
+
+/**
+	Get the entire flavor.
+	@name flavor^3
+	@function
+	@returns {Object} The entire flavor hash.
+*/
+/**
+	Get a named flavor.
+	@name flavor^2
+	@function
+	@param {String} name The name of the flavor to get.
+	@returns {String} The value of that flavor.
+*/
+/**
+	Set the flavor.
+	@param {String} name The name of the flavor to set.
+	@param {String} value The value of the flavor.
+	@returns {String} The value of that flavor.
+*/
+function flavor(name, value) {
+	if (arguments.length > 1) flavor[name] = value;
+	else if (arguments.length == 1) return flavor[name];
+	else return flavor;
+}

bin/jsdoc/test/name.js

@@ -0,0 +1,19 @@
+/**
+ @name Response
+ @class
+*/
+
+Response.prototype = {
+	/**
+	 @name Response#text
+	 @function
+	 @description
+		Gets the body of the response as plain text
+	 @returns {String}
+		Response as text
+	*/
+
+	text: function() {
+		return this.nativeResponse.responseText;
+	}
+}

bin/jsdoc/test/namespace_nested.js

@@ -0,0 +1,23 @@
+/** 
+	@namespace This is the first namespace.
+*/
+ns1 = {};
+
+/** 
+	This is the second namespace.
+	@namespace
+*/
+ns1.ns2 = {};
+
+/**
+	This part of ns1.ns2
+	@constructor
+*/
+ns1.ns2.Function1 = function() {
+};
+
+ns1.staticFunction = function() {
+};
+
+/** A static field in a namespace. */
+ns1.ns2.staticField = 1;

bin/jsdoc/test/nocode.js

@@ -0,0 +1,13 @@
+/**#nocode+*/
+    /**
+      @name star
+      @function
+    */
+    function blahblah() {
+    
+    }
+/**#nocode-*/
+
+function yaddayadda() {
+
+}

bin/jsdoc/test/oblit_anon.js

@@ -0,0 +1,20 @@
+/** the options */
+opt = Opt.get(
+	arguments, 
+	{
+	 d: "directory",
+	 c: "conf",
+	 "D[]": "define"
+	}
+);
+
+/** configuration */
+opt.conf = {
+	/** keep */
+	keep: true,
+	/** base */
+	base: getBase(this, {p: properties})
+}
+
+
+

bin/jsdoc/test/overview.js

@@ -0,0 +1,20 @@
+/**
+ * @overview This "library" contains a 
+ *               lot of classes and functions.
+ * @example
+ <pre>
+	var x (x < 1);
+	alert("This 'is' \"code\"");
+ </pre>
+ * @name My Cool Library
+ * @author 	Joe Smith jsmith@company.com
+ * @version 	0.1 
+ */
+ 
+/** 
+ * Gets the current foo 
+ * @param {String} fooId	The unique identifier for the foo.
+ * @return {Object}	Returns the current foo.
+ */
+function getFoo(fooID){
+}

bin/jsdoc/test/param_inline.js

@@ -0,0 +1,37 @@
+/**
+	@constructor
+	@param columns The number of columns.
+*/
+function Layout(/**int*/columns){
+	/**
+		@param [id] The id of the element.
+		@param elName The name of the element.
+	*/
+	this.getElement = function(
+		/** string */ elName,
+		/** number|string */ id
+	) {
+	};
+	
+	/** 
+		@constructor
+	 */
+	this.Canvas = function(top, left, /**int*/width, height) {
+		/** Is it initiated yet? */
+		this.initiated = true;
+	}
+	
+	this.rotate = function(/**nothing*/) {
+	}
+	
+	/** 
+	@param x
+	@param y
+	@param {zoppler} z*/
+	this.init = function(x, y, /**abbler*/z) {
+		/** The xyz. */
+		this.xyz = x+y+z;
+		this.getXyz = function() {
+		}
+	}
+}

bin/jsdoc/test/params_optional.js

@@ -0,0 +1,8 @@
+
+/**
+ * @param {Page[]} pages
+ * @param {number} [id] Specifies the id, if applicable.
+ * @param {String} [title = This is untitled.] Specifies the title.
+ */
+function Document(pages, id, title){
+}

bin/jsdoc/test/prototype.js

@@ -0,0 +1,17 @@
+/** @constructor */
+function Article() {
+}
+
+Article.prototype.init = function(title) {
+	/** the instance title */
+	this.title = title;
+	
+	/** the static counter */
+	Article.counter = 1;
+}
+
+a = new Article();
+a.Init("my title");
+
+print(a.title);
+print(Article.counter);