build

dist/xrfragment.js

@@ -1,6 +1,13 @@
 var $hx_exports = typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this;
 (function ($global) { "use strict";
 $hx_exports["xrfragment"] = $hx_exports["xrfragment"] || {};
+var $estr = function() { return js_Boot.__string_rec(this,''); },$hxEnums = $hxEnums || {},$_;
+function $extend(from, fields) {
+	var proto = Object.create(from);
+	for (var name in fields) proto[name] = fields[name];
+	if( fields.toString !== Object.prototype.toString ) proto.toString = fields.toString;
+	return proto;
+}
 var EReg = function(r,opt) {
 	this.r = new RegExp(r,opt.split("u").join(""));
 };
@@ -14,6 +21,26 @@ EReg.prototype = {
 		this.r.s = s;
 		return this.r.m != null;
 	}
+	,matched: function(n) {
+		if(this.r.m != null && n >= 0 && n < this.r.m.length) {
+			return this.r.m[n];
+		} else {
+			throw haxe_Exception.thrown("EReg::matched");
+		}
+	}
+	,matchedRight: function() {
+		if(this.r.m == null) {
+			throw haxe_Exception.thrown("No string matched");
+		}
+		var sz = this.r.m.index + this.r.m[0].length;
+		return HxOverrides.substr(this.r.s,sz,this.r.s.length - sz);
+	}
+	,matchedPos: function() {
+		if(this.r.m == null) {
+			throw haxe_Exception.thrown("No string matched");
+		}
+		return { pos : this.r.m.index, len : this.r.m[0].length};
+	}
 	,split: function(s) {
 		var d = "#__delim__#";
 		return s.replace(this.r,d).split(d);
@@ -53,6 +80,25 @@ Reflect.field = function(o,field) {
 		return null;
 	}
 };
+Reflect.getProperty = function(o,field) {
+	var tmp;
+	if(o == null) {
+		return null;
+	} else {
+		var tmp1;
+		if(o.__properties__) {
+			tmp = o.__properties__["get_" + field];
+			tmp1 = tmp;
+		} else {
+			tmp1 = false;
+		}
+		if(tmp1) {
+			return o[tmp]();
+		} else {
+			return o[field];
+		}
+	}
+};
 Reflect.fields = function(o) {
 	var a = [];
 	if(o != null) {
@@ -65,6 +111,21 @@ Reflect.fields = function(o) {
 	}
 	return a;
 };
+Reflect.isObject = function(v) {
+	if(v == null) {
+		return false;
+	}
+	var t = typeof(v);
+	if(!(t == "string" || t == "object" && v.__enum__ == null)) {
+		if(t == "function") {
+			return (v.__name__ || v.__ename__) != null;
+		} else {
+			return false;
+		}
+	} else {
+		return true;
+	}
+};
 Reflect.deleteField = function(o,field) {
 	if(!Object.prototype.hasOwnProperty.call(o,field)) {
 		return false;
@@ -111,6 +172,10 @@ Std.parseInt = function(x) {
 	}
 	return null;
 };
+var StringBuf = function() {
+	this.b = "";
+};
+StringBuf.__name__ = true;
 var StringTools = function() { };
 StringTools.__name__ = true;
 StringTools.isSpace = function(s,pos) {
@@ -144,6 +209,55 @@ StringTools.rtrim = function(s) {
 StringTools.trim = function(s) {
 	return StringTools.ltrim(StringTools.rtrim(s));
 };
+StringTools.replace = function(s,sub,by) {
+	return s.split(sub).join(by);
+};
+var haxe_Exception = function(message,previous,native) {
+	Error.call(this,message);
+	this.message = message;
+	this.__previousException = previous;
+	this.__nativeException = native != null ? native : this;
+};
+haxe_Exception.__name__ = true;
+haxe_Exception.caught = function(value) {
+	if(((value) instanceof haxe_Exception)) {
+		return value;
+	} else if(((value) instanceof Error)) {
+		return new haxe_Exception(value.message,null,value);
+	} else {
+		return new haxe_ValueException(value,null,value);
+	}
+};
+haxe_Exception.thrown = function(value) {
+	if(((value) instanceof haxe_Exception)) {
+		return value.get_native();
+	} else if(((value) instanceof Error)) {
+		return value;
+	} else {
+		var e = new haxe_ValueException(value);
+		return e;
+	}
+};
+haxe_Exception.__super__ = Error;
+haxe_Exception.prototype = $extend(Error.prototype,{
+	unwrap: function() {
+		return this.__nativeException;
+	}
+	,get_native: function() {
+		return this.__nativeException;
+	}
+	,__properties__: {get_native:"get_native"}
+});
+var haxe__$Template_TemplateExpr = $hxEnums["haxe._Template.TemplateExpr"] = { __ename__:true,__constructs__:null
+	,OpVar: ($_=function(v) { return {_hx_index:0,v:v,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpVar",$_.__params__ = ["v"],$_)
+	,OpExpr: ($_=function(expr) { return {_hx_index:1,expr:expr,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpExpr",$_.__params__ = ["expr"],$_)
+	,OpIf: ($_=function(expr,eif,eelse) { return {_hx_index:2,expr:expr,eif:eif,eelse:eelse,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpIf",$_.__params__ = ["expr","eif","eelse"],$_)
+	,OpStr: ($_=function(str) { return {_hx_index:3,str:str,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpStr",$_.__params__ = ["str"],$_)
+	,OpBlock: ($_=function(l) { return {_hx_index:4,l:l,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpBlock",$_.__params__ = ["l"],$_)
+	,OpForeach: ($_=function(expr,loop) { return {_hx_index:5,expr:expr,loop:loop,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpForeach",$_.__params__ = ["expr","loop"],$_)
+	,OpMacro: ($_=function(name,params) { return {_hx_index:6,name:name,params:params,__enum__:"haxe._Template.TemplateExpr",toString:$estr}; },$_._hx_name="OpMacro",$_.__params__ = ["name","params"],$_)
+};
+haxe__$Template_TemplateExpr.__constructs__ = [haxe__$Template_TemplateExpr.OpVar,haxe__$Template_TemplateExpr.OpExpr,haxe__$Template_TemplateExpr.OpIf,haxe__$Template_TemplateExpr.OpStr,haxe__$Template_TemplateExpr.OpBlock,haxe__$Template_TemplateExpr.OpForeach,haxe__$Template_TemplateExpr.OpMacro];
 var haxe_iterators_ArrayIterator = function(array) {
 	this.current = 0;
 	this.array = array;
@@ -157,6 +271,587 @@ haxe_iterators_ArrayIterator.prototype = {
 		return this.array[this.current++];
 	}
 };
+var haxe_Template = function(str) {
+	var tokens = this.parseTokens(str);
+	this.expr = this.parseBlock(tokens);
+	if(!tokens.isEmpty()) {
+		throw haxe_Exception.thrown("Unexpected '" + Std.string(tokens.first().s) + "'");
+	}
+};
+haxe_Template.__name__ = true;
+haxe_Template.prototype = {
+	execute: function(context,macros) {
+		this.macros = macros == null ? { } : macros;
+		this.context = context;
+		this.stack = new haxe_ds_List();
+		this.buf = new StringBuf();
+		this.run(this.expr);
+		return this.buf.b;
+	}
+	,resolve: function(v) {
+		if(v == "__current__") {
+			return this.context;
+		}
+		if(Reflect.isObject(this.context)) {
+			var value = Reflect.getProperty(this.context,v);
+			if(value != null || Object.prototype.hasOwnProperty.call(this.context,v)) {
+				return value;
+			}
+		}
+		var _g_head = this.stack.h;
+		while(_g_head != null) {
+			var val = _g_head.item;
+			_g_head = _g_head.next;
+			var ctx = val;
+			var value = Reflect.getProperty(ctx,v);
+			if(value != null || Object.prototype.hasOwnProperty.call(ctx,v)) {
+				return value;
+			}
+		}
+		return Reflect.field(haxe_Template.globals,v);
+	}
+	,parseTokens: function(data) {
+		var tokens = new haxe_ds_List();
+		while(haxe_Template.splitter.match(data)) {
+			var p = haxe_Template.splitter.matchedPos();
+			if(p.pos > 0) {
+				tokens.add({ p : HxOverrides.substr(data,0,p.pos), s : true, l : null});
+			}
+			if(HxOverrides.cca(data,p.pos) == 58) {
+				tokens.add({ p : HxOverrides.substr(data,p.pos + 2,p.len - 4), s : false, l : null});
+				data = haxe_Template.splitter.matchedRight();
+				continue;
+			}
+			var parp = p.pos + p.len;
+			var npar = 1;
+			var params = [];
+			var part = "";
+			while(true) {
+				var c = HxOverrides.cca(data,parp);
+				++parp;
+				if(c == 40) {
+					++npar;
+				} else if(c == 41) {
+					--npar;
+					if(npar <= 0) {
+						break;
+					}
+				} else if(c == null) {
+					throw haxe_Exception.thrown("Unclosed macro parenthesis");
+				}
+				if(c == 44 && npar == 1) {
+					params.push(part);
+					part = "";
+				} else {
+					part += String.fromCodePoint(c);
+				}
+			}
+			params.push(part);
+			tokens.add({ p : haxe_Template.splitter.matched(2), s : false, l : params});
+			data = HxOverrides.substr(data,parp,data.length - parp);
+		}
+		if(data.length > 0) {
+			tokens.add({ p : data, s : true, l : null});
+		}
+		return tokens;
+	}
+	,parseBlock: function(tokens) {
+		var l = new haxe_ds_List();
+		while(true) {
+			var t = tokens.first();
+			if(t == null) {
+				break;
+			}
+			if(!t.s && (t.p == "end" || t.p == "else" || HxOverrides.substr(t.p,0,7) == "elseif ")) {
+				break;
+			}
+			l.add(this.parse(tokens));
+		}
+		if(l.length == 1) {
+			return l.first();
+		}
+		return haxe__$Template_TemplateExpr.OpBlock(l);
+	}
+	,parse: function(tokens) {
+		var t = tokens.pop();
+		var p = t.p;
+		if(t.s) {
+			return haxe__$Template_TemplateExpr.OpStr(p);
+		}
+		if(t.l != null) {
+			var pe = new haxe_ds_List();
+			var _g = 0;
+			var _g1 = t.l;
+			while(_g < _g1.length) {
+				var p1 = _g1[_g];
+				++_g;
+				pe.add(this.parseBlock(this.parseTokens(p1)));
+			}
+			return haxe__$Template_TemplateExpr.OpMacro(p,pe);
+		}
+		var kwdEnd = function(kwd) {
+			var pos = -1;
+			var length = kwd.length;
+			if(HxOverrides.substr(p,0,length) == kwd) {
+				pos = length;
+				var _g_offset = 0;
+				var _g_s = HxOverrides.substr(p,length,null);
+				while(_g_offset < _g_s.length) {
+					var c = _g_s.charCodeAt(_g_offset++);
+					if(c == 32) {
+						++pos;
+					} else {
+						break;
+					}
+				}
+			}
+			return pos;
+		};
+		var pos = kwdEnd("if");
+		if(pos > 0) {
+			p = HxOverrides.substr(p,pos,p.length - pos);
+			var e = this.parseExpr(p);
+			var eif = this.parseBlock(tokens);
+			var t = tokens.first();
+			var eelse;
+			if(t == null) {
+				throw haxe_Exception.thrown("Unclosed 'if'");
+			}
+			if(t.p == "end") {
+				tokens.pop();
+				eelse = null;
+			} else if(t.p == "else") {
+				tokens.pop();
+				eelse = this.parseBlock(tokens);
+				t = tokens.pop();
+				if(t == null || t.p != "end") {
+					throw haxe_Exception.thrown("Unclosed 'else'");
+				}
+			} else {
+				t.p = HxOverrides.substr(t.p,4,t.p.length - 4);
+				eelse = this.parse(tokens);
+			}
+			return haxe__$Template_TemplateExpr.OpIf(e,eif,eelse);
+		}
+		var pos = kwdEnd("foreach");
+		if(pos >= 0) {
+			p = HxOverrides.substr(p,pos,p.length - pos);
+			var e = this.parseExpr(p);
+			var efor = this.parseBlock(tokens);
+			var t = tokens.pop();
+			if(t == null || t.p != "end") {
+				throw haxe_Exception.thrown("Unclosed 'foreach'");
+			}
+			return haxe__$Template_TemplateExpr.OpForeach(e,efor);
+		}
+		if(haxe_Template.expr_splitter.match(p)) {
+			return haxe__$Template_TemplateExpr.OpExpr(this.parseExpr(p));
+		}
+		return haxe__$Template_TemplateExpr.OpVar(p);
+	}
+	,parseExpr: function(data) {
+		var l = new haxe_ds_List();
+		var expr = data;
+		while(haxe_Template.expr_splitter.match(data)) {
+			var p = haxe_Template.expr_splitter.matchedPos();
+			var k = p.pos + p.len;
+			if(p.pos != 0) {
+				l.add({ p : HxOverrides.substr(data,0,p.pos), s : true});
+			}
+			var p1 = haxe_Template.expr_splitter.matched(0);
+			l.add({ p : p1, s : p1.indexOf("\"") >= 0});
+			data = haxe_Template.expr_splitter.matchedRight();
+		}
+		if(data.length != 0) {
+			var _g_offset = 0;
+			var _g_s = data;
+			while(_g_offset < _g_s.length) {
+				var _g1_key = _g_offset;
+				var _g1_value = _g_s.charCodeAt(_g_offset++);
+				var i = _g1_key;
+				var c = _g1_value;
+				if(c != 32) {
+					l.add({ p : HxOverrides.substr(data,i,null), s : true});
+					break;
+				}
+			}
+		}
+		var e;
+		try {
+			e = this.makeExpr(l);
+			if(!l.isEmpty()) {
+				throw haxe_Exception.thrown(l.first().p);
+			}
+		} catch( _g ) {
+			var _g1 = haxe_Exception.caught(_g).unwrap();
+			if(typeof(_g1) == "string") {
+				var s = _g1;
+				throw haxe_Exception.thrown("Unexpected '" + s + "' in " + expr);
+			} else {
+				throw _g;
+			}
+		}
+		return function() {
+			try {
+				return e();
+			} catch( _g ) {
+				var exc = haxe_Exception.caught(_g).unwrap();
+				throw haxe_Exception.thrown("Error : " + Std.string(exc) + " in " + expr);
+			}
+		};
+	}
+	,makeConst: function(v) {
+		haxe_Template.expr_trim.match(v);
+		v = haxe_Template.expr_trim.matched(1);
+		if(HxOverrides.cca(v,0) == 34) {
+			var str = HxOverrides.substr(v,1,v.length - 2);
+			return function() {
+				return str;
+			};
+		}
+		if(haxe_Template.expr_int.match(v)) {
+			var i = Std.parseInt(v);
+			return function() {
+				return i;
+			};
+		}
+		if(haxe_Template.expr_float.match(v)) {
+			var f = parseFloat(v);
+			return function() {
+				return f;
+			};
+		}
+		var me = this;
+		return function() {
+			return me.resolve(v);
+		};
+	}
+	,makePath: function(e,l) {
+		var p = l.first();
+		if(p == null || p.p != ".") {
+			return e;
+		}
+		l.pop();
+		var field = l.pop();
+		if(field == null || !field.s) {
+			throw haxe_Exception.thrown(field.p);
+		}
+		var f = field.p;
+		haxe_Template.expr_trim.match(f);
+		f = haxe_Template.expr_trim.matched(1);
+		return this.makePath(function() {
+			return Reflect.field(e(),f);
+		},l);
+	}
+	,makeExpr: function(l) {
+		return this.makePath(this.makeExpr2(l),l);
+	}
+	,skipSpaces: function(l) {
+		var p = l.first();
+		while(p != null) {
+			var _g_offset = 0;
+			var _g_s = p.p;
+			while(_g_offset < _g_s.length) {
+				var c = _g_s.charCodeAt(_g_offset++);
+				if(c != 32) {
+					return;
+				}
+			}
+			l.pop();
+			p = l.first();
+		}
+	}
+	,makeExpr2: function(l) {
+		this.skipSpaces(l);
+		var p = l.pop();
+		this.skipSpaces(l);
+		if(p == null) {
+			throw haxe_Exception.thrown("<eof>");
+		}
+		if(p.s) {
+			return this.makeConst(p.p);
+		}
+		switch(p.p) {
+		case "!":
+			var e = this.makeExpr(l);
+			return function() {
+				var v = e();
+				if(v != null) {
+					return v == false;
+				} else {
+					return true;
+				}
+			};
+		case "(":
+			this.skipSpaces(l);
+			var e1 = this.makeExpr(l);
+			this.skipSpaces(l);
+			var p1 = l.pop();
+			if(p1 == null || p1.s) {
+				throw haxe_Exception.thrown(p1);
+			}
+			if(p1.p == ")") {
+				return e1;
+			}
+			this.skipSpaces(l);
+			var e2 = this.makeExpr(l);
+			this.skipSpaces(l);
+			var p2 = l.pop();
+			this.skipSpaces(l);
+			if(p2 == null || p2.p != ")") {
+				throw haxe_Exception.thrown(p2);
+			}
+			switch(p1.p) {
+			case "!=":
+				return function() {
+					return e1() != e2();
+				};
+			case "&&":
+				return function() {
+					return e1() && e2();
+				};
+			case "*":
+				return function() {
+					return e1() * e2();
+				};
+			case "+":
+				return function() {
+					return e1() + e2();
+				};
+			case "-":
+				return function() {
+					return e1() - e2();
+				};
+			case "/":
+				return function() {
+					return e1() / e2();
+				};
+			case "<":
+				return function() {
+					return e1() < e2();
+				};
+			case "<=":
+				return function() {
+					return e1() <= e2();
+				};
+			case "==":
+				return function() {
+					return e1() == e2();
+				};
+			case ">":
+				return function() {
+					return e1() > e2();
+				};
+			case ">=":
+				return function() {
+					return e1() >= e2();
+				};
+			case "||":
+				return function() {
+					return e1() || e2();
+				};
+			default:
+				throw haxe_Exception.thrown("Unknown operation " + p1.p);
+			}
+			break;
+		case "-":
+			var e3 = this.makeExpr(l);
+			return function() {
+				return -e3();
+			};
+		}
+		throw haxe_Exception.thrown(p.p);
+	}
+	,run: function(e) {
+		switch(e._hx_index) {
+		case 0:
+			var v = e.v;
+			var _this = this.buf;
+			var x = Std.string(this.resolve(v));
+			_this.b += Std.string(x);
+			break;
+		case 1:
+			var e1 = e.expr;
+			var _this = this.buf;
+			var x = Std.string(e1());
+			_this.b += Std.string(x);
+			break;
+		case 2:
+			var e1 = e.expr;
+			var eif = e.eif;
+			var eelse = e.eelse;
+			var v = e1();
+			if(v == null || v == false) {
+				if(eelse != null) {
+					this.run(eelse);
+				}
+			} else {
+				this.run(eif);
+			}
+			break;
+		case 3:
+			var str = e.str;
+			this.buf.b += str == null ? "null" : "" + str;
+			break;
+		case 4:
+			var l = e.l;
+			var _g_head = l.h;
+			while(_g_head != null) {
+				var val = _g_head.item;
+				_g_head = _g_head.next;
+				var e1 = val;
+				this.run(e1);
+			}
+			break;
+		case 5:
+			var e1 = e.expr;
+			var loop = e.loop;
+			var v = e1();
+			try {
+				var x = $getIterator(v);
+				if(x.hasNext == null) {
+					throw haxe_Exception.thrown(null);
+				}
+				v = x;
+			} catch( _g ) {
+				try {
+					if(v.hasNext == null) {
+						throw haxe_Exception.thrown(null);
+					}
+				} catch( _g1 ) {
+					throw haxe_Exception.thrown("Cannot iter on " + Std.string(v));
+				}
+			}
+			this.stack.push(this.context);
+			var v1 = v;
+			var ctx = v1;
+			while(ctx.hasNext()) {
+				var ctx1 = ctx.next();
+				this.context = ctx1;
+				this.run(loop);
+			}
+			this.context = this.stack.pop();
+			break;
+		case 6:
+			var m = e.name;
+			var params = e.params;
+			var v = Reflect.field(this.macros,m);
+			var pl = [];
+			var old = this.buf;
+			pl.push($bind(this,this.resolve));
+			var _g_head = params.h;
+			while(_g_head != null) {
+				var val = _g_head.item;
+				_g_head = _g_head.next;
+				var p = val;
+				if(p._hx_index == 0) {
+					var v1 = p.v;
+					pl.push(this.resolve(v1));
+				} else {
+					this.buf = new StringBuf();
+					this.run(p);
+					pl.push(this.buf.b);
+				}
+			}
+			this.buf = old;
+			try {
+				var _this = this.buf;
+				var x = Std.string(v.apply(this.macros,pl));
+				_this.b += Std.string(x);
+			} catch( _g ) {
+				var e = haxe_Exception.caught(_g).unwrap();
+				var plstr;
+				try {
+					plstr = pl.join(",");
+				} catch( _g1 ) {
+					plstr = "???";
+				}
+				var msg = "Macro call " + m + "(" + plstr + ") failed (" + Std.string(e) + ")";
+				throw haxe_Exception.thrown(msg);
+			}
+			break;
+		}
+	}
+};
+var haxe_ValueException = function(value,previous,native) {
+	haxe_Exception.call(this,String(value),previous,native);
+	this.value = value;
+};
+haxe_ValueException.__name__ = true;
+haxe_ValueException.__super__ = haxe_Exception;
+haxe_ValueException.prototype = $extend(haxe_Exception.prototype,{
+	unwrap: function() {
+		return this.value;
+	}
+});
+var haxe_ds_List = function() {
+	this.length = 0;
+};
+haxe_ds_List.__name__ = true;
+haxe_ds_List.prototype = {
+	add: function(item) {
+		var x = new haxe_ds__$List_ListNode(item,null);
+		if(this.h == null) {
+			this.h = x;
+		} else {
+			this.q.next = x;
+		}
+		this.q = x;
+		this.length++;
+	}
+	,push: function(item) {
+		var x = new haxe_ds__$List_ListNode(item,this.h);
+		this.h = x;
+		if(this.q == null) {
+			this.q = x;
+		}
+		this.length++;
+	}
+	,first: function() {
+		if(this.h == null) {
+			return null;
+		} else {
+			return this.h.item;
+		}
+	}
+	,pop: function() {
+		if(this.h == null) {
+			return null;
+		}
+		var x = this.h.item;
+		this.h = this.h.next;
+		if(this.h == null) {
+			this.q = null;
+		}
+		this.length--;
+		return x;
+	}
+	,isEmpty: function() {
+		return this.h == null;
+	}
+	,toString: function() {
+		var s_b = "";
+		var first = true;
+		var l = this.h;
+		s_b += "{";
+		while(l != null) {
+			if(first) {
+				first = false;
+			} else {
+				s_b += ", ";
+			}
+			s_b += Std.string(Std.string(l.item));
+			l = l.next;
+		}
+		s_b += "}";
+		return s_b;
+	}
+};
+var haxe_ds__$List_ListNode = function(item,next) {
+	this.item = item;
+	this.next = next;
+};
+haxe_ds__$List_ListNode.__name__ = true;
 var js_Boot = function() { };
 js_Boot.__name__ = true;
 js_Boot.__string_rec = function(o,s) {
@@ -174,6 +869,34 @@ js_Boot.__string_rec = function(o,s) {
 	case "function":
 		return "<function>";
 	case "object":
+		if(o.__enum__) {
+			var e = $hxEnums[o.__enum__];
+			var con = e.__constructs__[o._hx_index];
+			var n = con._hx_name;
+			if(con.__params__) {
+				s = s + "\t";
+				return n + "(" + ((function($this) {
+					var $r;
+					var _g = [];
+					{
+						var _g1 = 0;
+						var _g2 = con.__params__;
+						while(true) {
+							if(!(_g1 < _g2.length)) {
+								break;
+							}
+							var p = _g2[_g1];
+							_g1 = _g1 + 1;
+							_g.push(js_Boot.__string_rec(o[p],s));
+						}
+					}
+					$r = _g;
+					return $r;
+				}(this))).join(",") + ")";
+			} else {
+				return n;
+			}
+		}
 		if(((o) instanceof Array)) {
 			var str = "[";
 			s += "\t";
@@ -358,43 +1081,50 @@ var xrfragment_Parser = $hx_exports["xrfragment"]["Parser"] = function() { };
 xrfragment_Parser.__name__ = true;
 xrfragment_Parser.parse = function(key,value,store,index) {
 	var Frag_h = Object.create(null);
-	Frag_h["#"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_PREDEFINED_VIEW | xrfragment_XRF.PV_EXECUTE;
-	Frag_h["src"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_URL;
-	Frag_h["href"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_URL | xrfragment_XRF.T_PREDEFINED_VIEW;
-	Frag_h["tag"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_STRING;
-	Frag_h["pos"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.T_STRING | xrfragment_XRF.T_STRING_OBJ | xrfragment_XRF.METADATA | xrfragment_XRF.NAVIGATOR;
+	Frag_h["#"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_PREDEFINED_VIEW | xrfragment_XRF.PV_EXECUTE;
+	Frag_h["src"] = xrfragment_XRF.T_URL;
+	Frag_h["href"] = xrfragment_XRF.T_URL | xrfragment_XRF.T_PREDEFINED_VIEW;
+	Frag_h["tag"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING;
+	Frag_h["pos"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.T_STRING | xrfragment_XRF.METADATA | xrfragment_XRF.NAVIGATOR;
 	Frag_h["rot"] = xrfragment_XRF.QUERY_OPERATOR | xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.METADATA | xrfragment_XRF.NAVIGATOR;
-	Frag_h["t"] = xrfragment_XRF.ASSET | xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_FLOAT | xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.T_STRING | xrfragment_XRF.NAVIGATOR | xrfragment_XRF.METADATA;
-	Frag_h["tv"] = xrfragment_XRF.ASSET | xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_FLOAT | xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.T_VECTOR3 | xrfragment_XRF.NAVIGATOR | xrfragment_XRF.METADATA;
-	Frag_h["namespace"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_STRING;
-	Frag_h["SPDX"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_STRING;
-	Frag_h["unit"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_STRING;
-	Frag_h["description"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_STRING;
-	Frag_h["session"] = xrfragment_XRF.ASSET | xrfragment_XRF.T_URL | xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.NAVIGATOR | xrfragment_XRF.METADATA | xrfragment_XRF.PROMPT;
+	Frag_h["t"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_FLOAT | xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.NAVIGATOR | xrfragment_XRF.METADATA;
+	Frag_h["s"] = xrfragment_XRF.PV_OVERRIDE | xrfragment_XRF.T_MEDIAFRAG;
+	Frag_h["loop"] = xrfragment_XRF.PV_OVERRIDE;
+	Frag_h["uv"] = xrfragment_XRF.T_VECTOR2 | xrfragment_XRF.T_MEDIAFRAG;
+	Frag_h["namespace"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING;
+	Frag_h["SPDX"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING;
+	Frag_h["unit"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING;
+	Frag_h["description"] = xrfragment_XRF.IMMUTABLE | xrfragment_XRF.T_STRING;
 	var keyStripped = key.replace(xrfragment_XRF.operators.r,"");
 	var isPVDynamic = key.length > 0 && !Object.prototype.hasOwnProperty.call(Frag_h,key);
-	var isPVDefault = value.length == 0 && key.length > 0 && key == "#";
 	if(isPVDynamic) {
 		var v = new xrfragment_XRF(key,xrfragment_XRF.PV_EXECUTE | xrfragment_XRF.NAVIGATOR,index);
 		v.validate(value);
+		v.flags = xrfragment_XRF.set(xrfragment_XRF.T_DYNAMICKEY,v.flags);
+		if(!Object.prototype.hasOwnProperty.call(Frag_h,key)) {
+			v.flags = xrfragment_XRF.set(xrfragment_XRF.CUSTOMFRAG,v.flags);
+		}
+		if(value.length == 0) {
+			v.flags = xrfragment_XRF.set(xrfragment_XRF.T_DYNAMICKEYVALUE,v.flags);
+		}
 		store[keyStripped] = v;
 		return true;
 	}
 	var v = new xrfragment_XRF(key,Frag_h[key],index);
 	if(Object.prototype.hasOwnProperty.call(Frag_h,key)) {
 		if(!v.validate(value)) {
-			console.log("src/xrfragment/Parser.hx:66:","⚠ fragment '" + key + "' has incompatible value (" + value + ")");
+			console.log("src/xrfragment/Parser.hx:67:","⚠ fragment '" + key + "' has incompatible value (" + value + ")");
 			return false;
 		}
 		store[keyStripped] = v;
 		if(xrfragment_Parser.debug) {
-			console.log("src/xrfragment/Parser.hx:70:","✔ " + key + ": " + v.string);
+			console.log("src/xrfragment/Parser.hx:71:","✔ " + key + ": " + v.string);
 		}
 	} else {
 		if(typeof(value) == "string") {
 			v.guessType(v,value);
 		}
-		v.noXRF = true;
+		v.flags = xrfragment_XRF.set(xrfragment_XRF.CUSTOMFRAG,v.flags);
 		store[keyStripped] = v;
 	}
 	return true;
@@ -417,9 +1147,13 @@ xrfragment_URI.parse = function(url,filter) {
 		var key = splitByEqual[0];
 		var value = "";
 		if(splitByEqual.length > 1) {
+			if(xrfragment_XRF.isVector.match(splitByEqual[1])) {
+				value = splitByEqual[1];
+			} else {
 				var s = regexPlus.split(splitByEqual[1]).join(" ");
 				value = decodeURIComponent(s.split("+").join(" "));
 			}
+		}
 		var ok = xrfragment_Parser.parse(key,value,store,i);
 	}
 	if(filter != null && filter != 0) {
@@ -436,7 +1170,22 @@ xrfragment_URI.parse = function(url,filter) {
 	}
 	return store;
 };
+xrfragment_URI.template = function(uri,vars) {
+	var parts = uri.split("#");
+	if(parts.length == 1) {
+		return uri;
+	}
+	var frag = parts[1];
+	frag = StringTools.replace(frag,"{","::");
+	frag = StringTools.replace(frag,"}","::");
+	frag = new haxe_Template(frag).execute(vars);
+	frag = StringTools.replace(frag,"null","");
+	parts[1] = frag;
+	return parts.join("#");
+};
 var xrfragment_XRF = $hx_exports["xrfragment"]["XRF"] = function(_fragment,_flags,_index) {
+	this.floats = [];
+	this.shift = [];
 	this.fragment = _fragment;
 	this.flags = _flags;
 	this.index = _index;
@@ -469,23 +1218,38 @@ xrfragment_XRF.prototype = {
 	}
 	,guessType: function(v,str) {
 		v.string = str;
+		if(xrfragment_XRF.isReset.match(v.fragment)) {
+			v.reset = true;
+		}
+		if(v.fragment == "loop") {
+			v.loop = true;
+		}
 		if(typeof(str) != "string") {
 			return;
 		}
 		if(str.length > 0) {
+			if(xrfragment_XRF.isXRFScheme.match(str)) {
+				v.xrfScheme = true;
+				str = str.replace(xrfragment_XRF.isXRFScheme.r,"");
+				v.string = str;
+			}
 			if(str.split(",").length > 1) {
-				var xyzw = str.split(",");
-				if(xyzw.length > 0) {
-					v.x = parseFloat(xyzw[0]);
+				var xyzn = str.split(",");
+				if(xyzn.length > 0) {
+					v.x = parseFloat(xyzn[0]);
 				}
-				if(xyzw.length > 1) {
-					v.y = parseFloat(xyzw[1]);
+				if(xyzn.length > 1) {
+					v.y = parseFloat(xyzn[1]);
 				}
-				if(xyzw.length > 2) {
-					v.z = parseFloat(xyzw[2]);
+				if(xyzn.length > 2) {
+					v.z = parseFloat(xyzn[2]);
 				}
-				if(xyzw.length > 3) {
-					v.w = parseFloat(xyzw[3]);
+				var _g = 0;
+				var _g1 = xyzn.length;
+				while(_g < _g1) {
+					var i = _g++;
+					v.shift.push(xrfragment_XRF.isShift.match(xyzn[i]));
+					v.floats.push(parseFloat(xyzn[i].replace(xrfragment_XRF.isShift.r,"")));
 				}
 			}
 			if(xrfragment_XRF.isColor.match(str)) {
@@ -498,6 +1262,7 @@ xrfragment_XRF.prototype = {
 			if(xrfragment_XRF.isInt.match(str)) {
 				v.int = Std.parseInt(str);
 				v.x = v.int;
+				v.floats.push(v.x);
 			}
 			v.filter = new xrfragment_Filter(v.fragment + "=" + v.string);
 		} else {
@@ -505,19 +1270,31 @@ xrfragment_XRF.prototype = {
 		}
 	}
 };
+function $getIterator(o) { if( o instanceof Array ) return new haxe_iterators_ArrayIterator(o); else return o.iterator(); }
+function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $global.$haxeUID++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = m.bind(o); o.hx__closures__[m.__id__] = f; } return f; }
+$global.$haxeUID |= 0;
 if(typeof(performance) != "undefined" ? typeof(performance.now) == "function" : false) {
 	HxOverrides.now = performance.now.bind(performance);
 }
+if( String.fromCodePoint == null ) String.fromCodePoint = function(c) { return c < 0x10000 ? String.fromCharCode(c) : String.fromCharCode((c>>10)+0xD7C0)+String.fromCharCode((c&0x3FF)+0xDC00); }
 String.__name__ = true;
 Array.__name__ = true;
 js_Boot.__toStr = ({ }).toString;
+haxe_Template.splitter = new EReg("(::[A-Za-z0-9_ ()&|!+=/><*.\"-]+::|\\$\\$([A-Za-z0-9_-]+)\\()","");
+haxe_Template.expr_splitter = new EReg("(\\(|\\)|[ \r\n\t]*\"[^\"]*\"[ \r\n\t]*|[!+=/><*.&|-]+)","");
+haxe_Template.expr_trim = new EReg("^[ ]*([^ ]+)[ ]*$","");
+haxe_Template.expr_int = new EReg("^[0-9]+$","");
+haxe_Template.expr_float = new EReg("^([+-]?)(?=\\d|,\\d)\\d*(,\\d*)?([Ee]([+-]?\\d+))?$","");
+haxe_Template.globals = { };
+haxe_Template.hxKeepArrayIterator = new haxe_iterators_ArrayIterator([]);
 xrfragment_Parser.error = "";
 xrfragment_Parser.debug = false;
-xrfragment_XRF.ASSET = 1;
+xrfragment_URI.__meta__ = { statics : { template : { keep : null}}};
+xrfragment_XRF.IMMUTABLE = 1;
 xrfragment_XRF.PROP_BIND = 2;
 xrfragment_XRF.QUERY_OPERATOR = 4;
 xrfragment_XRF.PROMPT = 8;
-xrfragment_XRF.ROUNDROBIN = 16;
+xrfragment_XRF.CUSTOMFRAG = 16;
 xrfragment_XRF.NAVIGATOR = 32;
 xrfragment_XRF.METADATA = 64;
 xrfragment_XRF.PV_OVERRIDE = 128;
@@ -530,8 +1307,9 @@ xrfragment_XRF.T_VECTOR3 = 131072;
 xrfragment_XRF.T_URL = 262144;
 xrfragment_XRF.T_PREDEFINED_VIEW = 524288;
 xrfragment_XRF.T_STRING = 1048576;
-xrfragment_XRF.T_STRING_OBJ = 2097152;
-xrfragment_XRF.T_STRING_OBJ_PROP = 4194304;
+xrfragment_XRF.T_MEDIAFRAG = 2097152;
+xrfragment_XRF.T_DYNAMICKEY = 4194304;
+xrfragment_XRF.T_DYNAMICKEYVALUE = 8388608;
 xrfragment_XRF.isColor = new EReg("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$","");
 xrfragment_XRF.isInt = new EReg("^[-0-9]+$","");
 xrfragment_XRF.isFloat = new EReg("^[-0-9]+\\.[0-9]+$","");
@@ -539,10 +1317,14 @@ xrfragment_XRF.isVector = new EReg("([,]+|\\w)","");
 xrfragment_XRF.isUrl = new EReg("(://)?\\..*","");
 xrfragment_XRF.isUrlOrPretypedView = new EReg("(^#|://)?\\..*","");
 xrfragment_XRF.isString = new EReg(".*","");
-xrfragment_XRF.operators = new EReg("(^-|[\\*]+)","");
+xrfragment_XRF.operators = new EReg("(^[-]|^[!]|[\\*]$)","g");
 xrfragment_XRF.isProp = new EReg("^.*=[><=]?","");
 xrfragment_XRF.isExclude = new EReg("^-","");
 xrfragment_XRF.isDeep = new EReg("\\*","");
 xrfragment_XRF.isNumber = new EReg("^[0-9\\.]+$","");
-})({});
+xrfragment_XRF.isMediaFrag = new EReg("^([0-9\\.,\\*+-]+)$","");
+xrfragment_XRF.isReset = new EReg("^!","");
+xrfragment_XRF.isShift = new EReg("^(\\+|--)","");
+xrfragment_XRF.isXRFScheme = new EReg("^xrf://","");
+})(typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this);
 var xrfragment = $hx_exports["xrfragment"];