new Javascript libraries from all over the web.

www/extras/js/b/beyond.js

@@ -0,0 +1,863 @@
+/*
+	beyond.js
+	by Dan Shappir and Sjoerd Visscher
+	For more information see http://w3future.com/html/beyondJS
+*/
+var beyondVer = 1.00;
+
+var _FP = Function.prototype;
+if ( typeof(parseInt.apply) != "function" ) {
+	_FP.apply = function(obj, args) {
+		var s, tmp;
+		if ( obj ) {
+			tmp = "__tmp__";		// + Math.random();
+			switch ( typeof(obj) ) {
+				case "string":
+					s = "'" + obj.replace(_FP.apply.re, "\\'") + "'";
+					_SP[tmp] = this;
+					break;
+				case "number":
+					s = "(" + obj + ")";
+					_NP[tmp] = this;
+					break;
+				default:
+					s = "obj";
+					obj[tmp] = this;
+					break;
+			}
+			s = "var r = " + s + "." + tmp + "(";
+		}
+		else
+			s = "var r = this(";
+		for ( var i = 0 ; i < args.length ; ++i )
+			s += "args[" + i + "],";
+		s = ( args.length ? s.slice(0, -1) : s ) + ");";
+		eval(s);
+		return r;
+	};
+	_FP.apply.re = /\'/g;
+	_FP.call = function(obj) {
+		return this.apply(obj, Array.from(arguments).slice(1));
+	};
+}
+
+function isUndefined(x) {
+	var t = typeof(x);
+	return t == "undefined" || t == "unknown";
+}
+function isDefined(x) {
+	return !isUndefined(x);
+}
+
+Object.propertyNames = function(x, a) {
+	if ( !a ) a = [];
+	for ( var i in x )
+		a.append(i);
+	return a;
+};
+Object.propertyValues = function(x, a) {
+	return Object.propertyNames(x).collect(a, Function.from(x, null));
+};
+Object.toArray = function(x) {
+	return Object.propertyNames(x).zip(Object.propertyValues(x));
+};
+Object.from = function(n, v, x) {
+	if ( !x ) x = {};
+	var length = Math.min(n.length, v.length);
+	for ( var i = 0 ; i < length ; ++i )
+		x[n[i]] = v[i];
+	return x;
+};
+
+_FP.force = function() {
+	return "returnValue" in this ? this.returnValue : this.returnValue = this.call();
+};
+_FP.delayed = function() {
+	return Function.from(this.curry(arguments), "force");
+};
+_FP.caching = function() {
+	var self = this;
+	var map = {};
+	return function() {
+		var s = Array.from(arguments).toString();
+		return isDefined(map[s]) ? map[s] : map[s] = self.apply(this, arguments);
+	}.withArgString(this);
+};
+
+_FP.withArgString = function(x) {
+	if ( !x ) return this;
+	if ( typeof(x) != "string" )
+		x = Function.argString(x);
+	var self = this;
+	eval("function __withArgString__(" + x + ") { return self.apply(this, arguments); }");
+	return __withArgString__;
+};
+_FP.curry = function(m) {
+	var self = this;
+	var map = arguments.length != 1 || !m || typeof(m) != "object" ? arguments : m;
+	function createApplyArg(x) {
+		var val = map[x];
+		if ( val && val.asArgNameFlag ) {
+			args.append(val.toString());
+			return val.toString();
+		}
+		var arg = "__curry__.map['" + x + "']";
+		if ( typeof(val) == "function" && val.asValueFlag ) {
+			var list = addArgs(val);
+			if ( list.length ) list = "," + list;
+			arg += ".call(this" + list + ")";
+		}
+		return arg;
+	}
+	function addArgs(f) {
+		var args = Function.argString(f);
+		if ( !args )
+			return "";
+		args.split(_FP.curry.re).foreach(function(arg) {
+			if ( argSet.addToSet(arg) )
+				extraArgs.append(arg);
+		});
+		return args;
+	}
+	var origargs = Function.argString(this);
+	origargs = origargs ? origargs.split(_FP.curry.re) : [];
+	if ( map !== m && origargs.length < arguments.length ) origargs.length = arguments.length;
+	var args = [], extraArgs = [], argSet = new stringSet;
+	var applyArgs = origargs.collect(function(a, i) {
+		if ( isUndefined(a) ) {
+			if ( isDefined(map[i]) ) 
+				return createApplyArg(i);
+			a = "arg" + i;
+			args.append(a);
+			return a;
+		}
+		if ( isDefined(map[a]) )
+			return createApplyArg(a);
+		if ( isDefined(map[i]) )
+			return createApplyArg(i);
+		if ( isDefined(map[i - self.length]) ) 
+			return createApplyArg(i - self.length);
+		args.append(a);
+		return a;
+	});
+	eval("function __curry__(" + args.concat(extraArgs).join(",") + ") {" +
+		 "return self.apply(this, " +
+			(applyArgs.length == 1 ? "[].append(" + applyArgs[0] + ")" : "[" + applyArgs.join(",") + "]") +
+		 "); }");
+	__curry__.map = map;
+	return __curry__;
+};
+_FP.curry.re = /\s*,\s*/;
+_FP.using = function() {
+	return this.curry(Array.from(arguments).collect(select.curry("typeof", {
+		"function" : function(x) { return x.asValue(); },
+		"string" : function(x) { return x.asArgName(); },
+		"undefined" : function(x) { return x; }
+	})));
+};
+
+_FP.andThen = function(f) {
+	eval("function first(" + Function.argString(this) + ") { return g.first.apply(this, arguments); }");
+	function second(x) {
+		return g.second.apply ? g.second.apply(this, arguments) : g.second(x);
+	}
+	var g = second.using(first);
+	g.first = this;
+	g.second = typeof(f) != "string" ? f : Function.from(null, f);
+	return g;
+};
+_FP.andReturn = function(v) {
+	return this.andThen(Function.from(v));
+};
+_FP.replace = function(orig, replace) {
+	if ( !replace )
+		replace = Function.NOP;
+	if ( this.second == orig )
+		this.second = replace;
+	else for ( var f = this ; f.second ; f = f.second )
+		if ( f.first == orig )
+			f.first = replace;
+	return this;
+};
+
+_FP.strict = function(args) {
+	var self = this, type = typeof(args), length;
+	if ( type == "number" )
+		length = args;
+	if ( type != "string" )
+		args = Function.argString(this);
+	if ( type != "number" )
+		length = args.split(",").length;
+	return function() {
+		return self.apply(this, Array.from(arguments).head(length));
+	}.withArgString(args);
+};
+
+_FP.delay = function(iMilliSeconds) {
+	var self = this;
+	if ( !iMilliSeconds )
+		iMilliSeconds = 0;
+	return function() {
+		var args = arguments;
+		return window.setTimeout(function() { self.apply(this, args); }, iMilliSeconds);
+	}.withArgString(this);
+};
+_FP.asValue = function() {
+	var f = this.curry({});
+	f.asValueFlag = true;
+	return f;
+};
+_FP.toMethod = function() {
+	return this.using(Function.This);
+};
+_FP.gate = function(cond, els) {
+	var gate = function() {
+		return ( typeof(gate.cond) == "function" ? gate.cond.apply(this, arguments) : gate.cond ) ?
+			gate.then.apply(this, arguments) :
+			typeof(gate.els) == "function" ? gate.els.apply(this, arguments) : gate.els;
+	}.withArgString(this);
+	gate.cond = cond;
+	gate.then = this;
+	gate.els = els;
+	return gate;
+};
+_FP.loop = function(cond) {
+	var loop = function() {
+		while ( select("typeof", { 
+					"function" : function(x) { return x.apply(this, arguments); },
+					"number" : function() { return loop.cond--; },
+					"undefined" : isDefined(loop.cond) ? loop.cond : true
+				}, loop.cond) ) {
+			var r = loop.action.apply(this, arguments);
+			if ( isDefined(r) )
+				return r;
+		}
+	}.withArgString(this);
+	loop.cond = cond;
+	loop.action = this;
+	return loop;
+};
+
+_FP.factory = function() {
+	var self = this;
+	return function() {
+		return eval("new self(" +
+			(0).upTo(arguments.length-1).join2("arguments[", ",", "]") +
+			")");
+	}.withArgString(this);
+};
+
+Function.argString = function(f) {
+	var result = ("" + f).match(Function.argString.re);
+	return result ? result[1] : null;
+};
+Function.argString.re = /\(([^)]*)/;
+Function.NOP = function() {
+	if ( arguments.length > 0 )
+		return arguments[0];
+};
+Function.This = function() {
+	return this;
+};
+Function.args = function() {
+	return Array.from(arguments);
+};
+Function.invoke = function(f) {
+	return f();
+};
+Function.event = function(e) {
+	return e ? e : event;
+};
+
+Function.from = function(obj, field, args) {
+	var f;
+	if ( isUndefined(obj) || obj === null ) {
+		f = function(obj) {
+			return Function.from(obj, f.field, args).apply(obj, Array.from(arguments).slice(1));
+		};
+		if ( args && args.length )
+			f = f.withArgString("obj," + args);
+	}
+	else if ( isUndefined(field) ) {
+		if ( !args )
+			args = Function.argString(obj);
+		if ( typeof(args) != "string" )
+			f = function() {
+				return f.obj;
+			};
+		else
+			f = function() {
+				return f.obj.apply(this, arguments);
+			}.withArgString(args);
+	}
+	else if ( field === null )
+		f = function(x) {
+			return f.obj[x];
+		};
+	else if ( typeof(field) == "function" )
+		f = function() {
+			return f.field.apply(f.obj, arguments);
+		}.withArgString(args ? args : Function.argString(field));
+	else {
+		if ( !args )
+			args = Function.argString(obj[field]);
+		if ( typeof(args) != "string" )
+			f = function() {
+				if ( f.field.search(/\s/) > -1 )
+					return f.obj[f.field];
+				return eval("f.obj." + f.field);
+			};
+		else
+			f = function() {
+				if ( f.field.search(/\s/) > -1 )
+					return f.obj[f.field].apply(f.obj, arguments);
+				var s = "f.obj." + f.field + "(";
+				Array.from(arguments).foreach(function(v, i) { s += "arguments[" + i + "],"; });
+				return eval(( arguments.length ? s.slice(0, -1) : s ) + ");");
+			}.withArgString(args);
+	}
+	f.obj = obj;
+	f.field = field;
+	return f;
+}
+Function.set = function(obj, property) {
+	var f;
+	if ( isUndefined(obj) || obj === null )
+		f = function(obj, value) {
+			return Function.set(obj, f.property).call(this, value);
+		};
+	else if ( isUndefined(property) )
+		f = function(property, value) {
+			return Function.set(f.obj, property).call(this, value);
+		};
+	else
+		f = function(value) {
+			if ( f.property.search(/\s/) > -1 )
+				f.obj[f.property] = value;
+			else
+				eval("f.obj." + f.property + " = value");
+			return value;
+		}
+	f.obj = obj;
+	f.property = property;
+	return f;
+}
+
+var _AP = Array.prototype;
+if ( typeof(_AP.push) != "function" )
+	_AP.push = function() {
+		for ( var i = 0 ; i < arguments.length ; ++i )
+			this[this.length] = arguments[i];
+		return this.length;
+	}
+if ( typeof(_AP.pop) != "function" )
+	_AP.pop = function() {
+		if ( this.length ) {
+			var item = this[this.length-1];
+			--this.length;
+			return item;
+		}
+	}
+if ( typeof(_AP.shift) != "function" )
+	_AP.shift = function() {
+		this.foreach(function(v, i, self) { self[i] = self[i+1]; });
+		--this.length;
+		return this;
+	}
+if ( typeof(_AP.unshift) != "function" )
+	_AP.unshift = function() {
+		var self = this;
+		Array.from(arguments).concat(this).foreach(function(v, i) { self[i] = v; });
+		return this;
+	}
+if ( typeof(_AP.splice) != "function" )
+	_AP.splice = function(start, deleteCount) {
+		var a = start > 0 ? this.slice(0, start) : [];
+		a = a.concat(Array.from(arguments).slice(2), this.slice(start+deleteCount));
+		var self = this, deleted = this.slice(start, start+deleteCount);
+		a.foreach(function(v, i) { self[i] = v; });
+		this.length = a.length;
+		return deleted;
+	}
+	
+_AP.head = function(length) {
+	return isUndefined(length) ? this[0] : this.slice(0, length);
+};
+_AP.tail = function(start) {
+	return this.slice(start ? start : 1);
+};
+_AP.itemAt = function(i) {
+	return this[i];
+};
+_AP.isEmpty = function() {
+	return this.length === 0;
+};
+_AP.empty = function() {
+	this.length = 0;
+	return this;
+};
+
+_AP.order = function(f) {
+	if ( !f )
+		f = function(a, b) {
+			return a < b ? -1 : a > b ? 1 : 0;
+		};
+	return this.sort(function(a, b) {
+		var r = 0;
+		a.zip(b).foreach(function(pair) {
+			if ( r = f(pair[0], pair[1]) )
+				return false;
+		});
+		return r;
+	});
+};
+
+_AP.join2 = function(prefix, infix, postfix) {
+	if ( isUndefined(prefix) || prefix === null ) prefix = "";
+	if ( isUndefined(infix) || infix === null ) infix = "";
+	if ( isUndefined(postfix) || postfix === null ) postfix = "";
+	var r = this.join(postfix + infix + prefix);
+	return r.length ? prefix + r + postfix : r;
+};
+
+_AP.append = function() {
+	for ( var i = 0 ; i < arguments.length ; ++i )
+		if ( isDefined(arguments[i]) )
+			this[this.length] = arguments[i];
+	return this;
+};
+_AP.extend = function(x) {
+	if ( isDefined(x) ) {
+		if ( x.constructor == Array || typeof(x.foreach) != "function")
+			this.concat(x);
+		else {
+			var self = this;
+			x.foreach(function(v) { self.append(v); });
+		}
+	}
+	return this;
+};
+_AP.feed = function(x) {
+	x.extend(this);
+	return this;
+};
+
+_AP.foreach = function(f) {
+	for ( var i = 0 ; i < this.length ; ++i )
+		if ( f(this[i], i, this) === false )
+			return i;
+};
+_AP.coalesce = function(r, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		r = arguments[1];
+	}
+	if ( typeof(f) == "string" ) 
+		f = f.asMethod();
+	this.foreach(function(v, i, self) { 
+		var t = f(r, v, i, self); 
+		if ( isDefined(t) )
+			r = t;
+	});
+	return r;
+};
+_AP.fold = function(r, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		r = arguments[1];
+	}
+	if ( typeof(f) == "string" )
+		f = f.toFunction();
+	return this.coalesce(r, function(r, v) {
+		return isDefined(r) ? f(r, v) : v;
+	});
+};
+_AP.foldr = function(r, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		r = arguments[1];
+	}
+	if ( typeof(f) == "string" ) 
+		f = f.toFunction();
+	return this.fold(r, function(r, v) { return f(v, r); });
+};
+_AP.collect = function(a, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		a = arguments[1];
+	}
+	if ( typeof(f) == "string" ) 
+		f = f.asMethod();
+	if ( !a ) 
+		a = this.constructor ? new this.constructor : [];
+	return this.coalesce(a, function(r, v, i, self) { return r.append(f(v, i, self)); });
+};
+_AP.call = function(f) {
+	this.foreach(f);
+	return this;
+};
+
+_AP.asLongAs = function(a, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		a = arguments[1];
+	}
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	if ( !a ) 
+		a = this.constructor ? new this.constructor : [];
+	this.foreach(function(v, i, self) {
+		if ( !f(v, i, self) ) return false;
+		a.append(v);
+	});
+	return a;
+};
+_AP.filter = function(f, other) {
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	return this.collect(other ?
+		function(v, i, a) {
+			if ( f(v, i, a) )
+				return v;
+			other.append(v);
+		} :
+		function(v, i, a) {
+			if ( f(v, i, a) )
+				return v;
+		}
+	);
+};
+_AP.search = function(f) {
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	else if ( typeof(f) != "function" ) {
+		var x = f;
+		f = function(y) { return y === x; };
+	}
+	var result = this.foreach(function(v, i, self) { return !f(v, i, self); });
+	return typeof(result) == "number" ? result : -1;
+};
+_AP.indexOf = function(pattern) {
+	if ( typeof(pattern.foreach) != "function" )
+		pattern = [].append(pattern);
+	var result = this.foreach(function(v, i, self) {
+		return -1 !== pattern.foreach(function(v) {
+			return v === self[i++];
+		});
+	});
+	return typeof(result) == "number" ? result : -1;
+};
+
+_AP.inverse = function() {
+	return this.collect(function(v) {
+		return typeof(v.reverse) == "function" ? v.reverse() : v;
+	}).reverse();
+}
+
+_AP.flush = function(f) {
+	for ( ; this.length ; this.shift() )
+		if ( f(this[0], this) === false )
+			break;
+	return this;
+};
+_AP.split = function(f) {
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	else if ( typeof(f) != "function" )
+		f = "===".curry({ 0 : f });
+	var a = [[]], index = 0;
+	this.foreach(function(v) {
+		if ( f(v) )
+			a[++index] = [];
+		else
+			a[index].append(v);
+	});
+	return a;
+};
+_AP.zip = function() {
+	var result = this.collect(function(v) { return Function.args(v); });
+	Array.from(arguments).foreach(function(a) {
+		if ( !a || isUndefined(a.foreach) )
+			a = Function.args(v);
+		var last = 0;
+		if ( IsUndefined(a.foreach(function(v, i) {
+			var x = result.itemAt(i);
+			if ( isUndefined(x) ) return false;
+			x.push(v);
+			last = i;
+		})) ) {
+			if ( isDefined(result.length) )
+				result.length = last+1;
+			else
+				result = result.slice(0, last+1);
+		}
+	});
+	return result;
+};
+_AP.zipWith = function(f) {
+	if ( typeof(f) == "string" ) f = f.toFunction();
+	return this.zip.apply(this, Array.from(arguments).tail()).collect(function(v) {
+		return f.apply(null, v);
+	});
+};
+
+_AP.spread = function() {
+	return this.coalesce([], "extend");
+};
+
+Array.from = function(x) {
+	if ( typeof(x.toArray) == "function" ) {
+		x = x.toArray();
+		if ( this === Array )
+			return x;
+	}
+	if ( typeof(x.foreach) == "function" ) {
+		var a = new this;
+		x.foreach(function(v) { a.push(v); });
+		return a;
+	}
+	if ( typeof(x.length) == "number" ) {
+		var a = new this;
+		if ( typeof(x) != "string" )
+			for ( i = 0 ; i < x.length ; ++i )
+				a.push(x[i]);
+		else
+			for ( i = 0 ; i < x.length ; ++i )
+				a.push(x.charAt(i));
+		return a;
+	}
+	return (new this).push(x);
+}
+Array.fill = function(f, a) {
+	if ( !a ) a = new this;
+	var i = a.length;
+	if ( !i ) i = 0;
+	for ( ; ; ++i ) {
+		var v = f(i, a);
+		if ( isUndefined(v) )
+			return a;
+		a.append(v);
+	}
+};
+Array.recurse = function(f, resultIfEmpty) {
+	if ( isUndefined(resultIfEmpty) ) resultIfEmpty = new this;
+	return function(x) {
+		return this.isEmpty() ? 
+			typeof(resultIfEmpty) == "function" ?  
+				resultIfEmpty(x) : resultIfEmpty : 
+			f(this.head(), this.tail(), x);
+	};
+};
+
+_AP.equals = Array.recurse(function(h, t, x) {
+	return typeof(x.head) == "function" && typeof(x.tail) == "function" &&
+		( typeof(h.equals) == "function" ? h.equals(x.head()) : h == x.head() ) &&
+		t.equals(x.tail());
+	},
+	Function.from(null, "isEmpty")
+);
+
+function iteratable(x) {
+	var p = x.prototype;
+	if ( !p || p == Object )
+		p = x;
+	else {
+		if ( typeof(p.push) == "function" ) {
+			if ( !x.from )
+				x.from = Array.from;
+		}
+		if ( typeof(p.append) == "function" ) {
+			if ( !x.fill )
+				x.fill = Array.fill;
+		}
+	}
+	if ( typeof(p.foreach) == "function" ) {
+		if ( !p.coalesce )
+			p.coalesce = _AP.coalesce;
+		if ( !p.fold )
+			p.fold = _AP.fold;
+		if ( !p.foldr )
+			p.foldr = _AP.foldr;
+		if ( !p.collect )
+			p.collect = _AP.collect;
+		if ( !p.filter )
+			p.filter = _AP.filter;
+		if ( !p.search )
+			p.search = _AP.search;
+	}
+}
+
+var _NP = Number.prototype;
+_NP.times = function(f, counter) {
+	counter = counter || 0;
+	for ( var i = 0 ; i < this ; ++i )
+		f(counter++);
+};
+_NP.upTo = function(target, step) {
+	if ( !step ) step = 1;
+	var a = [];
+	for ( var i = this.valueOf() ; i <= target ; i += step )
+		a.append(i);
+	return a;
+};
+_NP.downTo = function(target, step) {
+	if ( !step ) step = 1;
+	var a = [];
+	for ( var i = this.valueOf() ; i >= target ; i -= step )
+		a.append(i);
+	return a;
+};
+_NP.to = function(target, step) {
+	return this < target ? this.upTo(target, step) : this.downTo(target, step);
+};
+_NP.chr = function() {
+	return String.fromCharCode(this);
+};
+
+var _SP = String.prototype;
+_SP.itemAt = String.charAt;
+_SP.asc = function() {
+	return this.charCodeAt(0);
+};
+_SP.to = function(target, step) {
+	return this.asc().to(target.toString().asc(), step).collect(Function.from(null, "chr"));
+};
+_SP.toFunctionUnary = function() {
+	eval("function __unary__(op) { return " + this + " op; }");
+	__unary__.op = this;
+	return __unary__;
+};
+_SP.toFunctionBinary = function() {
+	eval("function __binary__(op1, op2) { return op1 " + this + " op2; }");
+	__binary__.op = this;
+	return __binary__;
+};
+_SP.toFunction = function() {
+	return ",!,~,++,--,new,delete,typeof,void,".indexOf("," + this + ",") > -1 ?
+		this.toFunctionUnary() : this.toFunctionBinary();
+};
+_SP.toMethod = function() {
+	return this.toFunction().toMethod();
+};
+_SP.apply = function(obj, args) {
+	return this.toFunction().apply(obj, args);
+};
+_SP.call = function(obj) {
+	return this.toFunction().apply(obj, Array.from(arguments).slice(1));
+};
+_SP.curry = function() {
+	return _FP.curry.apply(this.toFunction(), arguments);
+};
+_SP.using = function() {
+	return _FP.using.apply(this.toFunction(), arguments);
+};
+_SP.asArgName = function() {
+	var self = this;
+	return { toString : function() { return self; }, asArgNameFlag : true };
+};
+
+_SP.asMethod = function(args) {
+	eval("function __method__(obj) { return obj." + this + ".apply(obj, Array.from(arguments).slice(1)); }");
+	return args ? __method__.withArgString("obj," + args) : __method__;
+};
+_SP.asMethodUsing = function() {
+	var args = (1).upTo(arguments.length).collect(function(v) { return "arg" + v; }).join(",");
+	return _FP.curry.apply(this.asMethod(args), (new Array(1)).concat(Array.from(arguments)));
+};
+
+var _RP = RegExp.prototype;
+_RP.iterate = function(s, f) {
+	var sre = this.toString(), sep = sre.lastIndexOf("/");
+	var re = new RegExp(sre.slice(1, sep), sre.slice(sep+1) + "g");
+	for ( var a ; a = re.exec(s) ; )
+		if ( f(a, s, re) === false )
+			return a;
+	return null;
+};
+_RP.not = function() {
+	return "!".using(Function.from(this, "test", "str"));
+};
+
+if ( typeof(Enumerator) == "function" && typeof(Enumerator.prototype) == "object" ) {
+	var _EP = Enumerator.prototype;
+	_EP.foreach = function(f) {
+		for ( this.moveFirst() ; !this.atEnd() ; this.moveNext() )
+			if ( f(this.item(), this) === false )
+				return this.item();
+		return null;
+	};
+	iteratable(Enumerator);
+}
+
+function select(prep, map, selector) {
+	if ( arguments.length < 3 ) {
+		selector = map;
+		map = prep;
+		prep = arguments[2];
+	}
+	var r;
+	switch ( typeof(prep) ) {
+		case "string":
+			prep = prep.toFunction();
+		case "function":
+		case "object":
+			if ( prep ) {
+				r = map[prep(selector, this)];
+				break;
+			}
+		default:
+			r = map[selector];
+	}
+	if ( isUndefined(r) ) r = map[r];
+	return typeof(r) == "function" ? r.call(this, selector, prep) : r;
+}
+
+function stringSet(initItems) {
+	if ( initItems )
+		this.addToSet.apply(this, initItems);
+}
+stringSet.prototype = {
+	addToSet : function(item) {
+		var set = this;
+		return Array.from(arguments).coalesce(false, function(r, item) {
+			return !set[item] ? set[item] = true : r;
+		});
+	},
+	foreach : function(f) {
+		for ( var item in this )
+			if ( this[item] !== stringSet.prototype[item] && f(item, this) === false )
+				return item;
+		return null;
+	},
+	mergeSet : function(set) {
+		return Array.from(this).concat(Array.from(set)).toStringSet();
+	},
+	include : function() {
+		return "&&".using(
+			Function.from(this, null), 
+			Function.from(stringSet.prototype, null).andThen(isUndefined));
+	},
+	exclude : function() {
+		return this.include().andThen("!".toFunctionUnary());
+	}
+};
+_AP.toStringSet = function() {
+	return new stringSet(this);
+};
+
+Math.even = function(n) {
+	return n % 2 == 0;
+};
+Math.odd = function(n) {
+	return n % 2 != 0;
+};
+
+var ff = isUndefined(ff) ? Function.from : ff;
+
+function debugAlert(x) {
+	if ( debugAlert.on )
+		Array.from(arguments).foreach(alert);
+	if ( arguments.length > 0 )
+		return x;
+}
+debugAlert.on = true;

www/extras/js/b/beyondBrowser.js

@@ -0,0 +1,93 @@
+/*
+   beyondBrowser.js
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+if ( typeof(beyondVer) !== "number" || beyondVer < 0.98 )
+	alert("beyondBrowser requires beyond JS library ver 0.98 or higher");
+var beyondBrowserVer = 0.96;
+
+Array.as = function(c) {
+	if ( typeof(c.length) != "number" )
+		return [].append(c);
+	if ( !c.foreach )
+		c.foreach = _AP.foreach;
+	if ( !c.head )
+		c.head = _AP.head;
+	if ( !c.tail )
+		c.tail = _AP.tail;
+	if ( !c.itemAt )
+		c.tail = _AP.itemAt;
+	if ( !c.isEmpty )
+		c.isEmpty = _AP.isEmpty;
+	if ( !c.slice )
+		c.slice = function(start, end) {
+			var a = Array.from(this);
+			return isDefined(end) ? a.slice(start, end) : a.slice(start);
+		};
+	iteratable(c);
+	return c;
+};
+
+_SP.element = function() {
+	return document.getElementById(this);
+};
+_SP.children = function(index, subIndex) {
+	var e = this.element();
+	var c = isDefined(subIndex) ? e.children(index, subIndex) :
+		isDefined(index) ? e.children(index) : e.children;
+	return isDefined(c.length) ? Array.as(c) : c;
+};
+_SP.foreach = function(f, r) {
+	return ( isUndefined(document.all) ? [ this.element() ] : Array.as(document.all[this]) ).foreach(f, r);
+};
+iteratable("");
+_SP.setTo = function(html) {
+	this.foreach(function(e) { e.innerHTML = html; });
+	return this;
+};
+_SP.into = function(id) {
+	id.toString().setTo(this);
+	return this;
+};
+_SP.add = function(where, html) {
+	this.foreach(function(e) { e.insertAdjacentHTML(where, html); });
+	return this;
+};
+_SP.insert = _SP.add.curry("afterBegin");
+_SP.append = _SP.add.curry("beforeEnd");
+_SP.showHide = function(show) {
+	var display = show ? "" : "none";
+	this.foreach(function(e) { e.style.display = display; });
+	return this;
+};
+_SP.show = _SP.showHide.curry(true);
+_SP.hide = _SP.showHide.curry(false);
+_SP.toggleShow = function() {
+	this.foreach(function(e) { e.style.display = e.style.display.length ? "" : "none"; });
+	return this;
+};
+_SP.moveTo = function(clientX, clientY) {
+	this.foreach(function(e) { e.style.left = clientX + "px"; e.style.top = clientY + "px"; });
+	return this;
+};
+_SP.w = function(text) {
+	return "<" + this + ">" + text + "</" + this.replace(_SP.w.re, "") + ">";
+};
+_SP.w.re = /\s.*/;
+_SP.tag = function(tag) {
+	return tag.toString().w(this);
+};
+_SP.write = function(s) {
+	return document.write(this.w(s));
+};
+
+if ( isUndefined(document.getElementById) )
+	document.getElementById = function(id) {
+		return Array.as(document.all[id])[0];
+	};
+if ( isUndefined(document.getElementsByTagName) )
+	document.getElementsByTagName = function(tagName) {
+		tagName = tagName.toUpperCase()
+		return Array.as(document.all).filter(function(e) { return e.tagName.toUpperCase() == tagName; });
+	};

www/extras/js/b/beyondDispatch.js

@@ -0,0 +1,126 @@
+/*
+   BeyondDispatch.JS
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+if ( typeof(beyondVer) !== "number" || beyondVer < 0.98 )
+	alert("beyondDispatch requires Beyond JS library ver 0.98 or higher");
+var beyondDispatchVer = 0.90;
+
+function dispatch(otherwise, argString) {
+	var options = [];
+	var isFunction = typeof(otherwise) == "function";
+	if ( isFunction && isUndefined(argString) )
+		argString = Function.argString(otherwise);
+	var dispatcher = function() {
+		var self = this, args = arguments, result;
+		return 0 <= options.foreach(function(v) {
+			if ( v != null && v[0].apply(self, args) ) {
+				result = typeof(v[1]) == "function" ? v[1].apply(self, args) : v[1];
+				return false;
+			}
+		}) ? result : isFunction ? otherwise.apply(self, args) : otherwise;
+	};
+	dispatcher.add = function(test, target) {
+		if ( isUndefined(target) ) {
+			target = test;
+			test = target.length;
+		}
+		if ( typeof(test) == "string" ) {
+			var args = typeof(target) == "function" ? Function.argString(target) : "";
+			eval("test = function(" + args + ") { return " + test + "; }");
+			return options.push([test, target]) - 1;
+		}
+		test = dispatch.fix(test);
+		return isUndefined(test) ? -1 : options.push([test, target]) - 1;
+	};
+	dispatcher.addList = function() {
+		var result = -1;
+		for ( var i = 0 ; i < arguments.length ; i += 2 )
+			result = this.add(arguments[i], arguments[i + 1]);
+		return result;
+	};
+	dispatcher.remove = function(index) {
+		options[index] = null;
+	};
+	dispatcher.removeAll = function() {
+		options = [];
+	};
+	dispatcher.clone = function() {
+		var clone = dispatch(otherwise, argString);
+		options.foreach(function(e) { 
+			if ( e != null )
+				clone.add(e[0], e[1]);
+		});
+		return clone;
+	};
+	return dispatcher.withArgString(argString);
+}
+
+dispatch.fix = select.curry({
+	prep: "typeof",
+	map : {
+		number : function(x) {
+			if ( x >= 0 )
+				return function() { return arguments.length == x; };
+			x = -x;
+			return function() { return arguments.length >= x; }
+		},
+		object : function(x) {
+			if ( typeof(x.foreach) == "function" )
+				return function() {
+					var args = arguments;
+					return -1 == x.foreach(function(v, i) {
+						var t = typeof(v);
+						if ( isUndefined(t) )
+							return true;
+						if ( i >= args.length )
+							return false;
+						var a = args[i];
+						if ( t == "function" )
+							return v.call(this, a);
+						if ( v instanceof RegExp )
+							return v.test(a);
+						if ( t == "string" ) {
+							t = v.slice(1);
+							switch ( v.charAt(0) ) {
+								case ".":
+									switch ( typeof(a) ) {
+										case "number":
+											a = new Number(a);
+											break;
+										case "boolean":
+											a = new Boolean(a);
+											break;
+										case "string":
+											a = new String(a);
+									}
+									var i = t.indexOf(":");
+									if ( i > -1 ) {
+										v = t.slice(i + 1);
+										t = t.slice(0, i);
+									}
+									if ( !(t in a) )
+										return false;
+									if ( i == -1 )
+										return true;
+									a = a[t];
+									t = v;
+								case ":":
+									return typeof(a) == t || 
+										( t != "function" && eval("typeof(" + t + ") == 'function' && a instanceof " + t) );
+								case "^":
+									return eval(t + ".isPrototypeOf(a)");
+								case "?":
+									return eval("a " + t);
+								case "\\":
+									v = t;
+							}
+						}
+						return typeof(v.equals) == "function" ? v.equals(a) : v == a;
+					});
+				};
+		},
+		"function" : function(x) { return x; }
+	}
+});

www/extras/js/b/beyondLazy.js

@@ -0,0 +1,367 @@
+/*
+   BeyondLazy.JS
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+if ( typeof(beyondVer) !== "number" || beyondVer < 0.98 )
+	alert("beyondLazy requires Beyond JS library ver 0.98 or higher");
+var beyondLazyVer = 0.96;
+
+function Lazy(generator, length) {
+	this.generator = generator ? generator : function() { return []; };
+	this.length = length;
+}
+var _LP = Lazy.prototype;
+
+Lazy.cache = true;
+
+_LP.foreach = function(f) {
+	var item = [];
+	for ( var i = 0 ; (item = this.generator(item)).length ; ++i )
+		if ( f(item[0], i, this) === false )
+			return i;
+};
+_LP.collect = function(f) {
+	var self = this;
+	if ( typeof(f) == "string" ) 
+		f = f.asMethod();
+	return function(prev) {
+		var current = self.generator(isDefined(prev[1]) ? prev[1] : []);
+		return current.length ? [ f(current[0], prev[0]), current ] : current;
+	}.lazy(this.length);
+};
+_LP.call = function(f) {
+	var self = this;
+	return function(prev) {
+		var current = self.generator(isDefined(prev[1]) ? prev[1] : []);
+		f(current[0]);
+		return current;
+	}.lazy();
+};
+_LP.asLongAs = function(f) {
+	var self = this;
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	return function(prev) {
+		var current = self.generator(prev);
+		return current.length && f(current[0]) ? current : [];
+	}.lazy();
+};
+_LP.filter = function(f, other) {
+	var self = this;
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	return function(item) {
+		while ( (item = self.generator(item)).length && !f(item[0]) )
+			if ( other )
+				other.append(item[0]);
+		return item;
+	}.lazy();
+};
+_LP.zip = function() {
+	var collections = [ this ].concat(Array.from(arguments).collect(Function.from(null, "lazy")));
+	return function(prev) {
+		var length = Number.POSITIVE_INFINITY;
+		collections.foreach(function(c) {
+			if ( c.length && c.length < length )
+				length = c.length;
+		});
+		var current_length = prev[1] ? prev[1] : 0;
+		if ( current_length >= length )
+			return [];
+		if ( !prev.length )
+			(collections.length + 2).times(function() { prev.push([]); });
+		var current = [ [] , current_length >= 0 ? current_length + 1 : -1 ];
+		collections.foreach(function(c, i) {
+			var x = c.generator(prev[i + 2]);
+			if ( !x.length ) {
+				current = [];
+				return false;
+			}
+			current[0].push(x[0]);
+			current.push(x);
+		});
+		return current;
+	}.lazy();
+};
+_LP.zipWith = _AP.zipWith;
+
+_LP.spread = function() {
+	var self = this;
+	return function(prev) {
+		var current;
+		for (;;) {
+			switch ( prev.length ) {
+				case 0:
+					current = self.generator([]);
+					break;
+				
+				case 2:
+					current = self.generator(prev[1]);
+					break;
+					
+				default:
+					current = prev[2].generator(prev[3]);
+					if ( current.length )
+						return [ current[0], prev[1], prev[2], current ];
+					prev = [, prev[1]];
+					continue;
+			}
+			if ( !current.length )
+				return [];
+			var value = current[0];
+			if ( !value || typeof(value.foreach) != "function" || typeof(value.lazy) != "function" )
+				return [ value, current ];
+			prev = [, current, value.lazy(), []];
+		}
+	}.lazy();
+};
+
+_LP.head = function(length) {
+	if ( !length ) return this.generator([])[0];
+	var self = this;
+	return function(prev) {
+		var index;
+		if ( prev.length ) {
+			index = prev[2] + 1;
+			prev = prev[1];
+		}
+		else
+			index = 1;
+		if ( index > length )
+			return [];
+		var current = self.generator(prev);
+		return current.length ? [ current[0], current, index ] : current;
+	}.lazy(length);
+};
+_LP.tail = function(start) {
+	if ( !start ) start = 1;
+	return this.collect(function(current, prev) { return [ current, isUndefined(prev) ? 0 : prev[1]+1 ]; }).
+			filter(function(current) { return current[1] >= start; }).
+			collect(function(current) { return current[0]; });
+};
+_LP.slice = function(start, end) {
+	var result = start ? this.tail(start) : this;
+	if ( isDefined(end) ) end -= start;
+	return end >= 1 ? result.head(end) : result;
+};
+_LP.isEmpty = function() {
+	return !this.generator([]).length;
+};
+_LP.itemAt = function(index) {
+	return this.tail(start).head();
+};
+_LP.empty = function() {
+	this.generator = function() {
+		return [];
+	};
+	this.length = 0;
+	return this;
+};
+
+_LP.toString = function() {
+	return Array.from(this).toString();
+};
+_LP.toLocaleString = function() {
+	return Array.from(this).toLocaleString();
+};
+_LP.valueOf = function() {
+	return Array.from(this).valueOf();
+};
+_LP.join = function(separator) {
+	var a = Array.from(this);
+	return isDefined(separator) ? a.join(separator) : a.join();
+};
+_LP.reverse = function() {
+	return Array.from(this).reverse();
+};
+_LP.concat = function() {
+	var a = [ this ].concat(Array.from(arguments)).filter(isDefined).collect(function(v) {
+		return v != null && v.constructor == Array ? v.lazy() : v;
+	});
+	return a.length == 1 ? this : function(prev) {
+		if ( !prev.length ) prev = [ null, [], 0 ];
+		for (;;) {
+			var current = a[prev[2]];
+			if ( isUndefined(current) )
+				return [];
+			if ( current === null || typeof(current.constructor) !== "function" || current.constructor !== Lazy )
+				return [ current, [], prev[2]+1 ];
+			current = current.generator(prev[1]);
+			if ( current.length )
+				return [ current[0], current, prev[2] ];
+			prev = [ null, [], prev[2]+1 ];
+		}
+	}.lazy();
+};
+_LP.push = _LP.append = function() {
+	var a = Array.from(arguments).filter(isDefined);
+	if ( a.length ) {
+		var generator = this.generator;
+		this.generator = function(prev) {
+			if ( isUndefined(prev[2]) ) {
+				var current = generator(prev);
+				if ( current.length )
+					return current;
+				prev = [ null, null, 0 ];
+			}
+			return isDefined(a[prev[2]]) ? [ a[prev[2]], null, prev[2]+1 ] : [];
+		};
+	}
+	return this;
+};
+_LP.shift = function() {
+	var result = this.head();
+	if ( isDefined(result) )
+		this.generator = this.generator.lazy().tail().generator;
+	return result;
+};
+_LP.unshift = function() {
+	var a = Array.from(arguments).filter(isDefined);
+	if ( a.length )
+		this.generator = a.lazy().concat(this.generator.lazy()).generator;
+	return this;
+};
+_LP.splice = function(start, deleteCount) {
+	var a = Array.from(arguments).slice(2).filter(isDefined);
+	var clone = this.generator.lazy();
+	var result = clone.tail(start+deleteCount);
+	if ( a.length ) result = a.lazy().concat(result);
+	if ( start > 0 ) result = clone.head(start).concat(result);
+	this.generator = result.generator;
+	return clone.slice(start, start+deleteCount);
+};
+
+_LP.extend = function(x) {
+	if ( isDefined(x) ) {
+		if ( typeof(x) == "function" )
+			x = x().lazy();
+		var generator = this.generator;
+		this.generator = function(prev) {
+			if ( !prev.length )
+				prev = [ null, prev, generator ];
+			var current = prev[2](prev[1]);
+			if ( current.length )
+				return [ current[0], current, prev[2] ];
+			if ( prev[2] === x.generator )
+				return current;
+			current = x.generator(current);
+			return current.length ? [ current[0], current, x.generator ] : current;
+		};
+		this.length = this.u;
+		if ( Lazy.cache )
+			return this.cached();
+	}
+	return this;
+};
+_LP.feed = _AP.feed;
+
+_LP.cached = function() {
+	if ( isUndefined(this.isCached) ) {
+		this.isCached = true;
+		var cache = [], generator = this.generator;
+		this.generator = function(prev) {
+			if ( !prev.length )
+				prev = [ null, [], 0 ];
+			if ( prev[2] < cache.length )
+				return cache[prev[2]];
+			var current = generator(prev[1]);
+			return cache[cache.length] = current.length ? [ current[0], current, cache.length+1 ] : [];
+		}
+	}
+	return this;
+};
+
+_LP.equals = _AP.equals;
+
+_LP.lazy = Function.This;
+
+_FP.lazy = function(length) {
+	return new Lazy(this, length);
+};
+
+_NP.lazyUp = function(end, step) {
+	var undef, start = this.valueOf();
+	if ( !(step > 0) ) step = 1;
+	var length;
+	if ( isUndefined(end) || end === null )
+		end = Number.POSITIVE_INFINITY;
+	else
+		length = Math.floor((end - start + 1)/step);
+	return function(item) {
+		if ( !item.length ) return [ start, undef ];
+		var value = item[0] + step;
+		return value <= end ? [ value, undef ] : [];
+	}.lazy(length);
+};
+_NP.lazyDown = function(end, step) {
+	var undef, start = this.valueOf();
+	if ( !(step > 0) ) step = 1;
+	var length;
+	if ( isUndefined(end) || end === null )
+		end = Number.NEGATIVE_INFINITY;
+	else
+		length = Math.floor((start - end + 1)/step);
+	return function(item) {
+		if ( !item.length ) return [ start, undef ];
+		var value = item[0] - step;
+		return value >= end ? [ value, undef ] : [];
+	}.lazy(length);
+};
+_NP.lazy = function(end, step) { 
+	if ( isUndefined(end) || end === null ) end = Number.POSITIVE_INFINITY;
+	return this < end ? this.lazyUp(end, step) : this.lazyDown(end, step);
+};
+
+_SP.lazy = function(target, step) {
+	return this.asc().lazy(target.toString().asc(), step).collect(Function.from(null, "chr"));
+};
+
+_AP.lazy = function() {
+	return (0).lazy(this.length-1).collect(Function.from(this, "itemAt"));
+};
+_AP.cycle = function(n) {
+	var self = this;
+	var cycle = isUndefined(n) ?
+		function() {
+			return self.lazy().extend(cycle);
+		} :
+		1 <= n ?
+		function(n) {
+			return 1 == n ? self.lazy() : self.lazy().extend(cycle.curry(n-1));
+		} :
+		function() {
+			return [].lazy();
+		};
+	return cycle(n);
+};
+
+if ( _EP )
+	_EP.lazy = function() {
+		var self = this;
+		return function(item) {
+			if ( !item.length )
+				self.moveFirst();
+			else
+				self.moveNext();
+			return !self.atEnd() ? [ self.item(), self ] : [];
+		}.lazy();
+	};
+
+Lazy.from = function(x) {
+	if ( typeof(x.lazy) == "function" )
+		return x.lazy();
+	if ( typeof(x.length) == "number" )
+		return this.fill(function(index, item) { return x[index]; });
+	return Array.from(x).lazy();
+};
+Lazy.fill = function(f) {
+	var lazy = function(item) {
+		var index = item[1] ? item[1] : 0;
+		var value = f(index, item[0]);
+		return isDefined(value) ? [ value, index+1 ] : [];
+	}.lazy();
+	return this.cache ? lazy.cached() : lazy;
+};
+Lazy.recurse = Array.recurse;
+iteratable(Lazy);

www/extras/js/b/beyondRhino.js

@@ -0,0 +1,467 @@
+/*
+   BeyondRhino.JS
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+load("beyond.js", "beyondLazy.js", "beyondStreams.js");
+
+var beyondRhinoVer = 0.9;
+var Beyond = {};
+
+importPackage(java.util);
+
+function javaArray(type, length) {
+	var alloc = new Function("length", "return java.lang.reflect.Array.newInstance(" + type + ", length)");
+	return alloc(length);
+}
+
+function alert(s) {
+	print(s);
+}
+
+function toJava(v, asObjects) {
+	return typeof(v.toJava) == "function" ? v.toJava(asObjects) : v;
+}
+
+_NP.toJava = function() {
+	var v = this.valueOf();
+	return v == Math.round(v) ? new java.lang.Integer(v) : new java.lang.Double(v);
+};
+_SP.toJava = function() {
+	var v = this.valueOf();
+	return new java.lang.String(v);
+};
+Boolean.prototype.toJava = function() {
+	var v = this.valueOf();
+	return new java.lang.Boolean(v);
+};
+
+function javaType(v) {
+	switch ( typeof(v) ) {
+		case "boolean":
+			return java.lang.Boolean.TYPE;
+
+		case "number":
+			return v == Math.round(v) ? java.lang.Integer.TYPE : java.lang.Double.TYPE;
+
+		case "string":
+			return java.lang.String;
+	}
+	return java.lang.Object;
+}
+_AP.toJava = function(asObjects) {
+	if ( !this.length )
+		return java.lang.reflect.Array.newInstance(java.lang.Object, 0);
+	var r;
+	if ( asObjects )
+		r = java.lang.reflect.Array.newInstance(java.lang.Object, this.length);
+	else {
+		var type = this.coalesce(function(type, v) {
+			var jt = javaType(v);
+			return isUndefined(type) || type == jt || ( type == java.lang.Integer.TYPE && jt == java.lang.Double.TYPE ) ?
+				jt : java.lang.Object;
+		});
+		r = java.lang.reflect.Array.newInstance(type, this.length);
+	}
+	this.foreach(function(v, i) {
+		r[i] = toJava(v);
+	});
+	return r;
+};
+
+function toJavaScript(v) {
+	if ( typeof(v) != "object" || v == null )
+		return v;
+	if ( typeof(v.getClass) != "function" ) {
+		if ( typeof(v.valueOf) == "function" )
+			v = v.valueOf();
+		return "undefined" != v ? v : undefined;
+	}
+	var cls = v.getClass();
+	switch ( String(cls.getName()) ) {
+		case "java.lang.Boolean":
+			return "true" == v;
+			
+		case "java.lang.Byte":
+		case "java.lang.Short":
+		case "java.lang.Integer":
+		case "java.lang.Long":
+			return parseInt(v);
+			
+		case "java.lang.Float":
+		case "java.lang.Double":
+			return parseFloat(v);
+
+		default:
+			var s = String(v);
+			return s == v ? s : v;
+	}
+}
+
+// Hack to enable use of Array.from() on Java arrays
+_AP.toArray = null;
+
+_AP.enumeration = function() {
+	var self = this;
+	var index = 0;
+	return new Enumeration() {
+		hasMoreElements : function() {
+			return index < self.length;
+		},
+		nextElement : function() {
+			return toJava(self[index++]);
+		}
+	};
+};
+_LP.enumeration = function() {
+	var self = this;
+	var item = [];
+	var cached = false;
+	var reuse = false;
+	return new Enumeration() {
+		hasMoreElements : function() {
+			if ( !cached ) {
+				cached = reuse = true;
+				item = self.generator(item);
+			}
+			return item.length;		  
+		},
+		nextElement : function() {
+			if ( !reuse )
+				item = self.generator(item);
+			cached = !cached;
+			reuse = false;
+			return toJava(item[0]);
+		}
+	};
+};
+Beyond.enumeration = function(e) {
+	return function() {
+		return e.hasMoreElements() ? [ toJavaScript(e.nextElement()) ] : [];
+	}.lazy();
+};
+
+_AP.iterator = function() {
+	var self = this;
+	var index = 0;
+	return new Iterator() {
+		hasNext : function() {
+			return index < self.length;
+		},
+		next : function() {
+			return toJava(self[index++]);
+		},
+		remove : function() {
+			if ( index > 0 )
+				self.splice(--index, 1);
+		}
+	};
+};
+_LP.iterator = function() {
+	var self = this;
+	var item = [];
+	var cached = false;
+	var reuse = false;
+	return new Iterator() {
+		hasNext : function() {
+			if ( !cached ) {
+				cached = reuse = true;
+				item = self.generator(item);
+			}
+			return item.length;		  
+		},
+		next : function() {
+			if ( !reuse )
+				item = self.generator(item);
+			cached = !cached;
+			reuse = false;
+			return toJava(item[0]);
+		}
+	};
+};
+Beyond.iterator = function(i) {
+	return function() {
+		return i.hasNext() ? [ toJavaScript(i.next()) ] : [];
+	}.lazy();
+};
+
+function isTypeOrDerived(v, type) {
+	for ( var c = v.getClass() ; c ; c = c.getSuperclass() )
+		if ( c.getName() == type )
+			return true;
+	return false;
+}
+
+_AP.listIterator = function() {
+	var self = this;
+	var index, prev;
+	return new ListIterator() {
+hasNext : function() {
+		  return isDefined(index) ? index < self.length : self.length > 0;
+	  },
+hasPrevious : function() {
+		  return isDefined(index) ? index > 0 : self.length > 0;
+	  },
+next : function() {
+		  if ( isUndefined(index) )
+			  index = 0;
+		  prev = index;
+		  return toJava(self[index++]);
+	  },
+previous : function() {
+		  if ( isUndefined(index) )
+			  index = self.length;
+		  prev = index;
+		  return toJava(self[--index]);
+	  },
+nextIndex : function() {
+		  return isUndefined(index) ? 0 : index;
+	  },
+previousIndex : function() {
+		  return ( isUndefiend(index) ? self.length : index ) - 1;
+	  },
+set : function(element) {
+		  if ( isDefined(prev) )
+			  self.splice(prev, 1, toJavaScript(element));
+	  },
+add : function(element) {
+		  prev = index;
+		  self.splice(index++, 0, toJavaScript(element));
+	  },
+remove : function() {
+		  if ( isDefined(prev) )
+			  self.splice(prev, 1);
+	  }
+	};
+};
+Beyond.reverseIterator = function(i) {
+	return function() {
+		return i.hasPrevious() ? [ toJavaScript(i.previous()) ] : [];
+	}.lazy();
+};
+
+_AP.collection = function() {
+	var self = this;
+	return new Collection() {
+add : function(element) {
+	      element = toJavaScript(element)
+			if ( self.search(element) != -1 )
+		      return false;
+	      self.push(element);
+	      return true;
+      },
+addAll : function(collection) {
+	      var me = this;
+	      return Beyond.iterator(collection.iterator()).coalesce(function(r, v) {
+		      return me.add(v) || r;
+	      });
+      },
+clear : function() {
+	      self.length = 0;
+      },
+contains : function(element) {
+	      return self.search(toJavaScript(element)) != -1;
+      },
+containsAll : function(collection) {
+	      var me = this;
+	      return Beyond.iterator(collection.iterator()).coalesce(true, function(r, v) {
+		      return r && me.contains(v);
+	      });
+      },
+isEmpty : function() {
+	      return self.length == 0;
+      },
+iterator : function() {
+	      return self.iterator();
+      },
+remove : function(element) {
+	      element = toJavaScript(element)
+			var index = self.search(element);
+	      if ( index == -1 )
+		      return false;
+	      self.splice(index, 1);
+	      return true;
+      },
+removeAll : function(collection) {
+	      var me = this;
+	      return Beyond.iterator(collection.iterator()).coalesce(function(r, v) { return me.remove(v) || r; });
+      },
+retainAll : function(collection) {
+	      var length = self.length;
+	      var filtered = self.filter(function(v) { return collection.contains(toJava(v)); });
+	      filtered.foreach(function(v, i) { self[i] = v; });
+	      self.length = filtered.length;
+	      return self.length != length;
+      },
+size : function() {
+	      return self.length;
+      },
+toArray : function(a) {
+	      if ( typeof(a) != "object" )
+		      return self.toJava(true);
+	      var type = a.getClass().getName().slice(2, -1);
+	      var java = self.collect(function(v) { return toJava(v, true); }).
+			 filter(function(v) { return isTypeOrDerived(v, type); });
+	      if ( a.length < java.length )
+		      a = javaArray(type, java.length);
+	      java.foreach(function(v, i) { a[i] = v; });
+	      if ( a.length > java.length )
+		      Arrays.fill(a, java.length, a.length, null);
+	      return a;
+      }
+	};
+};
+Beyond.collection = function(collection) {
+	return function(item) {
+		var i = item.length ? item[1] : collection.iterator();
+		return i.hasNext() ? [ toJavaScript(i.next()) , i ] : [];
+	}.lazy();
+};
+
+_AP.list = function() {
+	var self = this;
+	return new List() {
+add : function(index, element) {
+	      if ( isUndefined(element) )
+		      self.push(toJavaScript(index));
+	      else
+		      self.splice(index, 0, toJavaScript(element));
+	      return true;
+      },
+addAll : function(index, collection) {
+	      var me = this;
+	      if ( isUndefined(collection) )
+		      Beyond.iterator(index.iterator()).foreach(function(v) { me.add(v); });
+	      else
+		      Beyond.iterator(collection.iterator()).foreach(function(v) { me.add(index++, v); });
+	      return true;
+      },
+clear : function() {
+	      self.length = 0;
+      },
+contains : function(element) {
+	      return self.search(toJavaScript(element)) != -1;
+      },
+containsAll : function(collection) {
+	      var me = this;
+	      return Beyond.iterator(collection.iterator()).coalesce(true, function(r, v) { return r && me.contains(v); });
+      },
+get : function(index) {
+	      var x = toJava(self[index]);
+	      return toJava(self[index]);
+      },
+indexOf : function(element) {
+	      return self.search(toJavaScript(element));
+      },
+lastIndexOf : function(element) {
+	      var index = self.reverese().search(toJavaScript(element));
+	      return index == -1 ? -1 : self.length - index - 1;
+      },
+isEmpty : function() {
+	      return self.length == 0;
+      },
+iterator : function() {
+	      return self.iterator();
+      },
+listIterator : function(index) {
+	      var i = self.listIterator();
+	      if ( isDefined(index) )
+		      for ( ; i.hasNext() && i.nextIndex() < index ; i.next() );
+	      return i;
+      },
+remove : function(index) {
+	      return self.splice(index, 1)[0];
+      },
+removeAll : function(collection) {
+	      var me = this;
+	      return Beyond.iterator(collection.iterator()).coalesce(function(r, v) { return me.remove(v) || r; });
+      },
+retainAll : function(collection) {
+	      var length = self.length;
+	      var filtered = self.filter(function(v) { return collection.contains(toJava(v)); });
+	      filtered.foreach(function(v, i) { self[i] = v; });
+	      self.length = filtered.length;
+	      return self.length != length;
+      },
+set : function(index, element) {
+	      var prev = self[index];
+	      self[index] = toJavaScript(element);
+	      return toJava(prev, true);
+      },
+size : function() {
+	      return self.length;
+      },
+subList : function(from, to) {
+	      return self.slice(from, to).list();
+      },
+toArray : function(a) {
+	      if ( typeof(a) != "object" )
+		      return self.toJava(true);
+	      var type = a.getClass().getName().slice(2, -1);
+	      var java = self.collect(function(v) { return toJava(v, true); }).
+			 filter(function(v) { return isTypeOrDerived(v, type); });
+	      if ( a.length < java.length )
+		      a = javaArray(type, java.length);
+	      java.foreach(function(v, i) { a[i] = v; });
+	      if ( a.length > java.length )
+		      Arrays.fill(a, java.length, a.length, null);
+	      return a;
+      }
+	};
+};
+Beyond.list = Beyond.collection;
+Beyond.reverseList = function(list) {
+	return function(item) {
+		var i = item.length ? item[1] : list.listIterator();
+		return i.hasPrevious() ? [ toJavaScript(i.previous()) , i ] : [];
+	}.lazy();
+};
+
+var File = {
+
+read : function(file, cache, reader) {
+	       var rf = function(item) {
+		       var stream = item[1] ? 
+				    item[1] :
+				    new java.io.BufferedReader(reader ? file : new java.io.FileReader(file));
+		       var line = stream.readLine();
+		       return line != null ? [ String(line), stream ] : [];
+	       }.lazy();
+	       if ( cache )
+		       rf = rf.cached();
+	       rf.file = file;
+	       return rf;
+       },
+write : function(file, overwrite, writer) {
+	       var st = new Stream(writer ? file : new java.io.FileWriter(file, !overwrite));
+	       var handle = st.foreach(function(v, stream) {
+		       if ( isDefined(v) ) {
+			       var s = String(v) + "\n";
+			       stream.write(s, 0, s.length);
+			       stream.flush();
+		       }
+	       });
+	       st.stop = function() {
+		       this.detach(handle);
+		       this.owner.Close();
+	       };
+	       return st;
+       },
+process : function(input, output, f, append) {
+	       if ( !f )
+		       f = Function.NOP;
+	       else if ( f.constructor === RegExp ) {
+		       var re = f;
+		       f = function(line) {
+			       if ( re.test(line) )
+				       return line;
+		       };
+	       }
+	       return this.write(output, !append).extend(this.read(input).collect(f));
+       }
+
+};
+
+File.StdIn = File.read(new java.io.InputStreamReader(java.lang.System["in"]), false, true);
+File.StdOut = File.write(new java.io.OutputStreamWriter(java.lang.System["out"]), false, true);
+File.StdErr = File.write(new java.io.OutputStreamWriter(java.lang.System["err"]), false, true);

www/extras/js/b/beyondStreams.js

@@ -0,0 +1,221 @@
+/*
+   BeyondStreams.JS
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+if ( typeof(beyondVer) !== "number" || beyondVer < 0.99 )
+	alert("beyondStreams requires Beyond JS library ver 0.99 or higher");
+var beyondStreamsVer = 0.91;
+
+function Stream(owner) {
+	this.owner = owner;
+	this.callbacks = [];
+}
+var _STP = Stream.prototype;
+
+_STP.foreach = function(f) {
+	return this.callbacks.push(f)-1;
+};
+_STP.detach = function(x) {
+	if ( isUndefined(x) || x === null ) {
+		if ( this.callbacks.isEmpty() )
+			return false;
+		this.callbacks.empty();
+		return true;
+	}
+	if ( typeof(x) == "function" || typeof(x) == "object" )
+		x = this.callbacks.search("===".curry(x));
+	if ( x < 0 || x >= this.callbacks.length )
+		return false;
+	if ( x == this.callbacks.length-1 )
+		this.callbacks.pop();
+	else {
+		this.callbacks[x] = this.undef;
+		if ( this.callbacks.filter(isDefined).isEmpty() )
+			this.callbacks.empty();
+	}
+	return true;
+};
+
+_STP.push = function() {
+	var self = this;
+	Array.from(arguments).foreach(function(v) {
+		self.callbacks.foreach(function(f, i) {
+			if ( typeof(f) == "function" ) {
+				if ( f.call(self.owner, v, self.owner, self) === false )
+					self.detach(i);
+			}
+			else if ( f(v, self.owner, self) === false )
+				self.detach(i);
+		});
+	});
+	return this;
+};
+_STP.append = function() {
+	this.push.apply(this, Array.from(arguments).filter(isDefined));
+	return this;
+};
+_STP.extend = function(x) {
+	if ( !x || isUndefined(x.foreach) )
+		this.push(x);
+	else {
+		var self = this;
+		x.foreach(function(v) { self.push(v); });
+	}
+	return this;
+};
+
+_STP.feed = function(st) {
+	return this.foreach(function(v) { st.push(v); });
+};
+
+_STP.pre = function(f) {
+	var st = new Stream(this.owner);
+	st.collect(f).feed(this);
+	return st;
+};
+
+_STP.fold = function(r, f) {
+	if ( isUndefined(f) ) {
+		f = arguments[0];
+		r = arguments[1];
+	}
+	if ( typeof(f) == "string" ) 
+		f = f.toFunction();
+	var st = new Stream(this.owner);
+	this.coalesce(function(x, v) {
+		r = isDefined(r) ? f(r, v) : v;
+		st.push(r);
+	});
+	return st;
+};
+_STP.search = function(f) {
+	if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	else if ( typeof(f) != "function" ) {
+		var x = f;
+		f = function(y) { return y === x; };
+	}
+	var st = new Stream(this.owner);
+	this.foreach(function(v, owner, self) {
+		if ( f(v, owner, self) ) {
+			st.push(v);
+			return false;
+		}
+	});
+	return st;
+};
+
+_STP.delay = function(iMilliSeconds) {
+	var st = new Stream(this.owner);
+	this.foreach(function(v) { Function.from(st, "push").delay(iMilliSeconds)(v); });
+	return st;
+};
+_STP.buffer = function(f) {
+	if ( typeof(f) == "number" ) {
+		var count = f;
+		f = function(v, buffer) {
+			return buffer.length+1 >= count;
+		};
+	}
+	else if ( f.constructor === RegExp )
+		f = Function.from(f, "test");
+	var st = new Stream(this.owner), buffer = [];
+	this.foreach(function(v, owner, self) {
+		var r = f.call(owner, v, buffer, owner, self);
+		buffer.push(v);
+		if ( r ) {
+			st.push(buffer);
+			buffer = [];
+		}
+	});
+	return st;
+};
+
+Stream.from = function(x) {
+	if ( typeof(x.foreach) != "function" )
+		x = Array.from(x);
+	var st = new this(x);
+	x.foreach(function(v) { st.push(v); });
+	return st;
+};
+iteratable(Stream);
+
+function timerStream(iMilliSeconds) {
+	var st = new Stream(iMilliSeconds);
+	var nInterval = setInterval(function() { st.push(new Date); }, iMilliSeconds);
+	st.stop = function() {
+		if ( isDefined(nInterval) ) {
+			clearInterval(nInterval);
+			nInterval = timerStream.undef;
+		}
+	};
+	return st;
+}
+
+function eventStream(element, eventName, noAttach) {
+	if ( typeof(element) == "string" )
+		element = element.element();
+	var st = new Stream(element);
+
+	if ( !noAttach && isDefined(element.attachEvent) ) {
+		function pushEvent(event) {
+			st.push(event ? event : window.event);
+		}
+		if ( element.attachEvent(eventName, pushEvent) ) {
+			st.stop = function() {
+				element.detachEvent(eventName, pushEvent);
+			};
+			return st;
+		}
+	}
+
+	function pushEvent(event) {
+		if ( !st.stopped )
+			st.push(event ? event : window.event);
+	}
+	var prev = eval("element." + eventName);
+	if ( !prev )
+		eval("element." + eventName + " = pushEvent");
+	else
+		eval("element." + eventName + " = prev.andThen(pushEvent)");
+	st.stop = function() {
+		st.stopped = true;
+	};
+	return st;
+}
+function propertyStream(element, propertyName) {
+	if ( typeof(element) == "string" )
+		element = element.element();
+	var st = new Stream(element);
+	var handle = st.foreach(Function.set(element, propertyName));
+	st.stop = function() {
+		this.detach(handle);
+		this.stop = Function.NOP;
+	};
+	return st;
+}
+
+function cancelDefaultAction(e) {
+	e.returnValue = false;
+	return e;
+}
+function cancelBubble(e) {
+	e.cancelBubble = true;
+	return e;
+}
+
+function logStream(log) {
+	var st = new Stream(log ? log : []);
+	var handle = st.foreach(function(v) {
+		st.owner.push([ new Date, v ]);
+	});
+	st.stop = function() {
+		st.detach(handle);
+		this.stop = Function.NOP;
+	};
+	st.flush = function() {
+		st.owner.empty();
+	};
+	return st;
+}

www/extras/js/b/beyondXML.js

@@ -0,0 +1,85 @@
+/*
+   beyondXML.js
+   by Dan Shappir and Sjoerd Visscher
+   For more information see http://w3future.com/html/beyondJS
+*/
+if ( typeof(beyondVer) !== "number" || beyondVer < 0.95 )
+	alert("BeyondXML requires Beyond JS library ver 0.95 or higher");
+var beyondXMLVer = 0.96;
+
+var beyondXML = new function() {
+	var isMozilla = typeof(Document) != "undefined";
+
+	this.createDocument = function() {
+		return isMozilla ? new Document() : new ActiveXObject("Microsoft.XMLDOM");
+	};
+	this.parseFromString = function(doc, xml) {
+		return isMozilla ? doc = (new DOMParser()).parseFromString(xml, "text/xml") : doc.loadXML(xml);
+	};
+	this.load = function(doc, url) {
+		return doc.load(url);
+	};
+	this.invoke = function(method) {
+		return Function.from(null, method);
+	};
+
+	var origToArray = Array.from;
+	Array.from = function(x) {
+		var n = x.nextNode;
+		return typeof(n) != "object" ? origToArray.call(this, x) :
+			!n ? [] : Array.fill(function() { if ( n = x.nextNode ) return n; }, [ n ]);
+	};
+
+	if ( typeof(beyondLazyVer) == "number" && beyondLazyVer >= 0.95 ) {
+		var origToLazy = Lazy.from;
+		Lazy.from = function(x) {
+			var n = x.nextNode;
+			if ( typeof(n) != "object" )
+				return origToLazy.call(this, x);
+			return function(prev) {
+				if ( !prev.length ) x.reset();
+				var n = x.nextNode;
+				return n ? [ n ] : [];
+			}.lazy();
+		};
+		this.lazyLists = false;
+		this.list = function(list) {
+			return beyondXML.lazyLists ? Lazy.from(list) : Array.from(list);
+		};
+	}
+};
+
+function childNodes(n) {
+	return beyondXML.list(n.childNodes);
+}
+
+_SP.parseFromString = function(doc) {
+	if ( !doc )
+		doc = beyondXML.createDocument();
+	return beyondXML.parseFromString(doc, this) ? doc : null;
+};
+_SP.load = function(document) {
+	if ( !doc )
+		doc = beyondXML.createDocument();
+	return beyondXML.load(doc, this) ? doc : null;
+};
+
+_SP.selectSingleNode = function(node) {
+	return node.selectSingleNode(this);
+};
+_SP.selectNodes = function(node) {
+	return beyondXML.list(node.selectNodes(this));
+};
+_SP.nodeFromID = function(node) {
+	return node.ownerDocument.nodeFromID(this);
+};
+_SP.getElementsByTagName = function(node) {
+	return beyondXML.list(node.getElementsByTagName(this));
+};
+
+_SP.node = function(node) {
+	return node.getElementsByTagName(this).nextNode();
+};
+_SP.value = function(node) {
+	return this.node(node).nodeTypedValue;
+};