imba-source 0.14.1 → 0.14.3.1

data/vendor/imba/dist/imba.dev.js

@@ -0,0 +1,4048 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+/******/
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	(function(){
+		
+		if (typeof Imba === 'undefined') {
+			__webpack_require__(1);
+			__webpack_require__(2);
+			__webpack_require__(3);
+			__webpack_require__(4);
+			__webpack_require__(5);
+			__webpack_require__(6);
+			__webpack_require__(7);
+			
+			if (false) {
+				require('./dom.server');
+			};
+			
+			if (true) {
+				__webpack_require__(8);
+				__webpack_require__(9);
+				__webpack_require__(10);
+			};
+			
+			return __webpack_require__(11);
+		} else {
+			return console.warn(("Imba v" + (Imba.VERSION) + " is already loaded"));
+		};
+
+	})()
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(global) {(function(){
+		if (typeof window !== 'undefined') {
+			// should not go there
+			global = window;
+		};
+		
+		var isClient = (typeof window == 'object' && this == window);
+		/*
+		Imba is the namespace for all runtime related utilities
+		@namespace
+		*/
+		
+		Imba = {
+			VERSION: '0.14.3',
+			CLIENT: isClient,
+			SERVER: !(isClient),
+			DEBUG: false
+		};
+		
+		var reg = /-./g;
+		
+		/*
+		True if running in client environment.
+		@return {bool}
+		*/
+		
+		Imba.isClient = function (){
+			return (true) == true;
+		};
+		
+		/*
+		True if running in server environment.
+		@return {bool}
+		*/
+		
+		Imba.isServer = function (){
+			return (false) == true;
+		};
+		
+		Imba.subclass = function (obj,sup){
+			;
+			for (var k in sup){
+				if (sup.hasOwnProperty(k)) { obj[k] = sup[k] };
+			};
+			
+			obj.prototype = Object.create(sup.prototype);
+			obj.__super__ = obj.prototype.__super__ = sup.prototype;
+			obj.prototype.initialize = obj.prototype.constructor = obj;
+			return obj;
+		};
+		
+		/*
+		Lightweight method for making an object iterable in imbas for/in loops.
+		If the compiler cannot say for certain that a target in a for loop is an
+		array, it will cache the iterable version before looping.
+		
+		```imba
+		# this is the whole method
+		def Imba.iterable o
+			return o ? (o:toArray ? o.toArray : o) : []
+		
+		class CustomIterable
+			def toArray
+				[1,2,3]
+		
+		# will return [2,4,6]
+		for x in CustomIterable.new
+			x * 2
+		
+		```
+		*/
+		
+		Imba.iterable = function (o){
+			return o ? ((o.toArray ? (o.toArray()) : (o))) : ([]);
+		};
+		
+		/*
+		Coerces a value into a promise. If value is array it will
+		call `Promise.all(value)`, or if it is not a promise it will
+		wrap the value in `Promise.resolve(value)`. Used for experimental
+		await syntax.
+		@return {Promise}
+		*/
+		
+		Imba.await = function (value){
+			if (value instanceof Array) {
+				return Promise.all(value);
+			} else if (value && value.then) {
+				return value;
+			} else {
+				return Promise.resolve(value);
+			};
+		};
+		
+		Imba.toCamelCase = function (str){
+			return str.replace(reg,function(m) { return m.charAt(1).toUpperCase(); });
+		};
+		
+		Imba.toCamelCase = function (str){
+			return str.replace(reg,function(m) { return m.charAt(1).toUpperCase(); });
+		};
+		
+		Imba.indexOf = function (a,b){
+			return (b && b.indexOf) ? (b.indexOf(a)) : ([].indexOf.call(a,b));
+		};
+		
+		Imba.prop = function (scope,name,opts){
+			if (scope.defineProperty) {
+				return scope.defineProperty(name,opts);
+			};
+			return;
+		};
+		
+		return Imba.attr = function (scope,name,opts){
+			if (scope.defineAttribute) {
+				return scope.defineAttribute(name,opts);
+			};
+			
+			var getName = Imba.toCamelCase(name);
+			var setName = Imba.toCamelCase('set-' + name);
+			
+			scope.prototype[getName] = function() {
+				return this.getAttribute(name);
+			};
+			
+			scope.prototype[setName] = function(value) {
+				this.setAttribute(name,value);
+				return this;
+			};
+			
+			return;
+		};
+
+	})()
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
+
+/***/ },
+/* 2 */
+/***/ function(module, exports) {
+
+	(function(){
+		
+		
+		function emit__(event,args,node){
+			// var node = cbs[event]
+			var prev,cb,ret;
+			
+			while ((prev = node) && (node = node.next)){
+				if (cb = node.listener) {
+					if (node.path && cb[node.path]) {
+						ret = args ? (cb[node.path].apply(cb,args)) : (cb[node.path]());
+					} else {
+						// check if it is a method?
+						ret = args ? (cb.apply(node,args)) : (cb.call(node));
+					};
+				};
+				
+				if (node.times && --node.times <= 0) {
+					prev.next = node.next;
+					node.listener = null;
+				};
+			};
+			return;
+		};
+		
+		// method for registering a listener on object
+		Imba.listen = function (obj,event,listener,path){
+			var $1;
+			var cbs,list,tail;
+			cbs = obj.__listeners__ || (obj.__listeners__ = {});
+			list = cbs[($1 = event)] || (cbs[$1] = {});
+			tail = list.tail || (list.tail = (list.next = {}));
+			tail.listener = listener;
+			tail.path = path;
+			list.tail = tail.next = {};
+			return tail;
+		};
+		
+		Imba.once = function (obj,event,listener){
+			var tail = Imba.listen(obj,event,listener);
+			tail.times = 1;
+			return tail;
+		};
+		
+		Imba.unlisten = function (obj,event,cb,meth){
+			var node,prev;
+			var meta = obj.__listeners__;
+			if (!(meta)) { return };
+			
+			if (node = meta[event]) {
+				while ((prev = node) && (node = node.next)){
+					if (node == cb || node.listener == cb) {
+						prev.next = node.next;
+						// check for correct path as well?
+						node.listener = null;
+						break;
+					};
+				};
+			};
+			return;
+		};
+		
+		Imba.emit = function (obj,event,params){
+			var cb;
+			if (cb = obj.__listeners__) {
+				if (cb[event]) { emit__(event,params,cb[event]) };
+				if (cb.all) { emit__(event,[event,params],cb.all) }; // and event != 'all'
+			};
+			return;
+		};
+		
+		return Imba.observeProperty = function (observer,key,trigger,target,prev){
+			if (prev && typeof prev == 'object') {
+				Imba.unlisten(prev,'all',observer,trigger);
+			};
+			if (target && typeof target == 'object') {
+				Imba.listen(target,'all',observer,trigger);
+			};
+			return this;
+		};
+
+	})()
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	/* WEBPACK VAR INJECTION */(function(global) {(function(){
+		function idx$(a,b){
+			return (b && b.indexOf) ? b.indexOf(a) : [].indexOf.call(a,b);
+		};
+		
+		
+		var raf; // very simple raf polyfill
+		raf || (raf = global.requestAnimationFrame);
+		raf || (raf = global.webkitRequestAnimationFrame);
+		raf || (raf = global.mozRequestAnimationFrame);
+		raf || (raf = function(blk) { return setTimeout(blk,1000 / 60); });
+		
+		Imba.tick = function (d){
+			if (this._scheduled) { raf(Imba.ticker()) };
+			Imba.Scheduler.willRun();
+			this.emit(this,'tick',[d]);
+			Imba.Scheduler.didRun();
+			return;
+		};
+		
+		Imba.ticker = function (){
+			var self = this;
+			return self._ticker || (self._ticker = function(e) { return self.tick(e); });
+		};
+		
+		/*
+		
+		Global alternative to requestAnimationFrame. Schedule a target
+		to tick every frame. You can specify which method to call on the
+		target (defaults to tick).
+		
+		*/
+		
+		Imba.schedule = function (target,method){
+			if(method === undefined) method = 'tick';
+			this.listen(this,'tick',target,method);
+			// start scheduling now if this was the first one
+			if (!this._scheduled) {
+				this._scheduled = true;
+				raf(Imba.ticker());
+			};
+			return this;
+		};
+		
+		/*
+		
+		Unschedule a previously scheduled target
+		
+		*/
+		
+		Imba.unschedule = function (target,method){
+			this.unlisten(this,'tick',target,method);
+			var cbs = this.__listeners__ || (this.__listeners__ = {});
+			if (!cbs.tick || !cbs.tick.next || !cbs.tick.next.listener) {
+				this._scheduled = false;
+			};
+			return this;
+		};
+		
+		/*
+		
+		Light wrapper around native setTimeout that expects the block / function
+		as last argument (instead of first). It also triggers an event to Imba
+		after the timeout to let schedulers update (to rerender etc) afterwards.
+		
+		*/
+		
+		Imba.setTimeout = function (delay,block){
+			return setTimeout(function() {
+				block();
+				return Imba.Scheduler.markDirty();
+				// Imba.emit(Imba,'timeout',[block])
+			},delay);
+		};
+		
+		/*
+		
+		Light wrapper around native setInterval that expects the block / function
+		as last argument (instead of first). It also triggers an event to Imba
+		after every interval to let schedulers update (to rerender etc) afterwards.
+		
+		*/
+		
+		Imba.setInterval = function (interval,block){
+			return setInterval(function() {
+				block();
+				return Imba.Scheduler.markDirty();
+				// Imba.emit(Imba,'interval',[block])
+			},interval);
+		};
+		
+		/*
+		Clear interval with specified id
+		*/
+		
+		Imba.clearInterval = function (interval){
+			return clearInterval(interval);
+		};
+		
+		/*
+		Clear timeout with specified id
+		*/
+		
+		Imba.clearTimeout = function (timeout){
+			return clearTimeout(timeout);
+		};
+		
+		// should add an Imba.run / setImmediate that
+		// pushes listener onto the tick-queue with times - once
+		
+		
+		/*
+		
+		Instances of Imba.Scheduler manages when to call `tick()` on their target,
+		at a specified framerate or when certain events occur. Root-nodes in your
+		applications will usually have a scheduler to make sure they rerender when
+		something changes. It is also possible to make inner components use their
+		own schedulers to control when they render.
+		
+		@iname scheduler
+		
+		*/
+		
+		Imba.Scheduler = function Scheduler(target){
+			var self = this;
+			self._target = target;
+			self._marked = false;
+			self._active = false;
+			self._marker = function() { return self.mark(); };
+			self._ticker = function(e) { return self.tick(e); };
+			
+			self._events = true;
+			self._fps = 1;
+			
+			self._dt = 0;
+			self._timestamp = 0;
+			self._ticks = 0;
+			self._flushes = 0;
+		};
+		
+		Imba.Scheduler.markDirty = function (){
+			this._dirty = true;
+			return this;
+		};
+		
+		Imba.Scheduler.isDirty = function (){
+			return !(!this._dirty);
+		};
+		
+		Imba.Scheduler.willRun = function (){
+			return this._active = true;
+		};
+		
+		Imba.Scheduler.didRun = function (){
+			this._active = false;
+			return this._dirty = false;
+		};
+		
+		Imba.Scheduler.isActive = function (){
+			return !(!this._active);
+		};
+		
+		/*
+			Create a new Imba.Scheduler for specified target
+			@return {Imba.Scheduler}
+			*/
+		
+		/*
+			Check whether the current scheduler is active or not
+			@return {bool}
+			*/
+		
+		Imba.Scheduler.prototype.active = function (){
+			return this._active;
+		};
+		
+		/*
+			Delta time between the two last ticks
+			@return {Number}
+			*/
+		
+		Imba.Scheduler.prototype.dt = function (){
+			return this._dt;
+		};
+		
+		/*
+			Configure the scheduler
+			@return {self}
+			*/
+		
+		Imba.Scheduler.prototype.configure = function (pars){
+			if(!pars||pars.constructor !== Object) pars = {};
+			var fps = pars.fps !== undefined ? pars.fps : 1;
+			var events = pars.events !== undefined ? pars.events : true;
+			if (events != null) { this._events = events };
+			if (fps != null) { this._fps = fps };
+			return this;
+		};
+		
+		/*
+			Mark the scheduler as dirty. This will make sure that
+			the scheduler calls `target.tick` on the next frame
+			@return {self}
+			*/
+		
+		Imba.Scheduler.prototype.mark = function (){
+			this._marked = true;
+			return this;
+		};
+		
+		/*
+			Instantly trigger target.tick and mark scheduler as clean (not dirty/marked).
+			This is called implicitly from tick, but can also be called manually if you
+			really want to force a tick without waiting for the next frame.
+			@return {self}
+			*/
+		
+		Imba.Scheduler.prototype.flush = function (){
+			this._marked = false;
+			this._flushes++;
+			this._target.tick();
+			return this;
+		};
+		
+		/*
+			@fixme this expects raf to run at 60 fps 
+		
+			Called automatically on every frame while the scheduler is active.
+			It will only call `target.tick` if the scheduler is marked dirty,
+			or when according to @fps setting.
+		
+			If you have set up a scheduler with an fps of 1, tick will still be
+			called every frame, but `target.tick` will only be called once every
+			second, and it will *make sure* each `target.tick` happens in separate
+			seconds according to Date. So if you have a node that renders a clock
+			based on Date.now (or something similar), you can schedule it with 1fps,
+			never needing to worry about two ticks happening within the same second.
+			The same goes for 4fps, 10fps etc.
+		
+			@protected
+			@return {self}
+			*/
+		
+		Imba.Scheduler.prototype.tick = function (delta){
+			this._ticks++;
+			this._dt = delta;
+			
+			var fps = this._fps;
+			
+			if (fps == 60) {
+				this._marked = true;
+			} else if (fps == 30) {
+				if (this._ticks % 2) { this._marked = true };
+			} else if (fps) {
+				// if it is less round - we trigger based
+				// on date, for consistent rendering.
+				// ie, if you want to render every second
+				// it is important that no two renders
+				// happen during the same second (according to Date)
+				var period = ((60 / fps) / 60) * 1000;
+				var beat = Math.floor(Date.now() / period);
+				
+				if (this._beat != beat) {
+					this._beat = beat;
+					this._marked = true;
+				};
+			};
+			
+			if (this._marked || (this._events && Imba.Scheduler.isDirty())) this.flush();
+			// reschedule if @active
+			return this;
+		};
+		
+		/*
+			Start the scheduler if it is not already active.
+			**While active**, the scheduler will override `target.commit`
+			to do nothing. By default Imba.tag#commit calls render, so
+			that rendering is cascaded through to children when rendering
+			a node. When a scheduler is active (for a node), Imba disables
+			this automatic rendering.
+			*/
+		
+		Imba.Scheduler.prototype.activate = function (){
+			if (!this._active) {
+				this._active = true;
+				// override target#commit while this is active
+				this._commit = this._target.commit;
+				this._target.commit = function() { return this; };
+				Imba.schedule(this);
+				if (this._events) { Imba.listen(Imba,'event',this,'onevent') };
+				this._target && this._target.flag  &&  this._target.flag('scheduled_');
+				this.tick(0); // start ticking
+			};
+			return this;
+		};
+		
+		/*
+			Stop the scheduler if it is active.
+			*/
+		
+		Imba.Scheduler.prototype.deactivate = function (){
+			if (this._active) {
+				this._active = false;
+				this._target.commit = this._commit;
+				Imba.unschedule(this);
+				Imba.unlisten(Imba,'event',this);
+				this._target && this._target.unflag  &&  this._target.unflag('scheduled_');
+			};
+			return this;
+		};
+		
+		Imba.Scheduler.prototype.track = function (){
+			return this._marker;
+		};
+		
+		Imba.Scheduler.prototype.onevent = function (event){
+			var $1;
+			if (this._marked) { return this };
+			
+			if (this._events instanceof Function) {
+				if (this._events(event)) this.mark();
+			} else if (this._events instanceof Array) {
+				if (idx$(($1 = event) && $1.type  &&  $1.type(),this._events) >= 0) this.mark();
+			} else if (this._events) {
+				if (event._responder) this.mark();
+			};
+			return this;
+		};
+		return Imba.Scheduler;
+	
+	})()
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	(function(){
+		function idx$(a,b){
+			return (b && b.indexOf) ? b.indexOf(a) : [].indexOf.call(a,b);
+		};
+		
+		Imba.static = function (items,nr){
+			items.static = nr;
+			return items;
+		};
+		
+		/*
+		This is the baseclass that all tags in imba inherit from.
+		@iname node
+		*/
+		
+		Imba.Tag = function Tag(dom){
+			this.setDom(dom);
+		};
+		
+		Imba.Tag.createNode = function (){
+			throw "Not implemented";
+		};
+		
+		Imba.Tag.build = function (){
+			return new this(this.createNode());
+		};
+		
+		Imba.Tag.prototype.object = function(v){ return this._object; }
+		Imba.Tag.prototype.setObject = function(v){ this._object = v; return this; };
+		
+		Imba.Tag.prototype.dom = function (){
+			return this._dom;
+		};
+		
+		Imba.Tag.prototype.setDom = function (dom){
+			dom._tag = this;
+			this._dom = dom;
+			return this;
+		};
+		
+		/*
+			Setting references for tags like
+			`<div@header>` will compile to `tag('div').setRef('header',this).end()`
+			By default it adds the reference as a className to the tag.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.setRef = function (ref,ctx){
+			this.flag(this._ref = ref);
+			return this;
+		};
+		
+		/*
+			Method that is called by the compiled tag-chains, for
+			binding events on tags to methods etc.
+			`<a :tap=fn>` compiles to `tag('a').setHandler('tap',fn,this).end()`
+			where this refers to the context in which the tag is created.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.setHandler = function (event,handler,ctx){
+			var key = 'on' + event;
+			
+			if (handler instanceof Function) {
+				this[key] = handler;
+			} else if (handler instanceof Array) {
+				var fn = handler.shift();
+				this[key] = function(e) { return ctx[fn].apply(ctx,handler.concat(e)); };
+			} else {
+				this[key] = function(e) { return ctx[handler](e); };
+			};
+			return this;
+		};
+		
+		Imba.Tag.prototype.setId = function (id){
+			this.dom().id = id;
+			return this;
+		};
+		
+		Imba.Tag.prototype.id = function (){
+			return this.dom().id;
+		};
+		
+		/*
+			Adds a new attribute or changes the value of an existing attribute
+			on the specified tag. If the value is null or false, the attribute
+			will be removed.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.setAttribute = function (name,value){
+			// should this not return self?
+			var old = this.dom().getAttribute(name);
+			
+			if (old == value) {
+				return value;
+			} else if (value != null && value !== false) {
+				return this.dom().setAttribute(name,value);
+			} else {
+				return this.dom().removeAttribute(name);
+			};
+		};
+		
+		/*
+			removes an attribute from the specified tag
+			*/
+		
+		Imba.Tag.prototype.removeAttribute = function (name){
+			return this.dom().removeAttribute(name);
+		};
+		
+		/*
+			returns the value of an attribute on the tag.
+			If the given attribute does not exist, the value returned
+			will either be null or "" (the empty string)
+			*/
+		
+		Imba.Tag.prototype.getAttribute = function (name){
+			return this.dom().getAttribute(name);
+		};
+		
+		/*
+			Override this to provide special wrapping etc.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.setContent = function (content,type){
+			this.setChildren(content,type);
+			return this;
+		};
+		
+		/*
+			Set the children of node. type param is optional,
+			and should only be used by Imba when compiling tag trees. 
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.setChildren = function (nodes,type){
+			throw "Not implemented";
+		};
+		
+		/*
+			Get text of node. Uses textContent behind the scenes (not innerText)
+			[https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent]()
+			@return {string} inner text of node
+			*/
+		
+		Imba.Tag.prototype.text = function (v){
+			return this._dom.textContent;
+		};
+		
+		/*
+			Set text of node. Uses textContent behind the scenes (not innerText)
+			[https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent]()
+			*/
+		
+		Imba.Tag.prototype.setText = function (txt){
+			this._empty = false;
+			this._dom.textContent = txt == null ? (txt = "") : (txt);
+			return this;
+		};
+		
+		
+		/*
+			Method for getting and setting data-attributes. When called with zero
+			arguments it will return the actual dataset for the tag.
+		
+				var node = <div data-name='hello'>
+				# get the whole dataset
+				node.dataset # {name: 'hello'}
+				# get a single value
+				node.dataset('name') # 'hello'
+				# set a single value
+				node.dataset('name','newname') # self
+		
+		
+			*/
+		
+		Imba.Tag.prototype.dataset = function (key,val){
+			throw "Not implemented";
+		};
+		
+		/*
+			Empty placeholder. Override to implement custom render behaviour.
+			Works much like the familiar render-method in React.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.render = function (){
+			return this;
+		};
+		
+		/*
+			Called implicitly through Imba.Tag#end, upon creating a tag. All
+			properties will have been set before build is called, including
+			setContent.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.build = function (){
+			this.render();
+			return this;
+		};
+		
+		/*
+			Called implicitly through Imba.Tag#end, for tags that are part of
+			a tag tree (that are rendered several times).
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.commit = function (){
+			this.render();
+			return this;
+		};
+		
+		/*
+		
+			Called by the tag-scheduler (if this tag is scheduled)
+			By default it will call this.render. Do not override unless
+			you really understand it.
+		
+			*/
+		
+		Imba.Tag.prototype.tick = function (){
+			this.render();
+			return this;
+		};
+		
+		/*
+			
+			A very important method that you will practically never manually.
+			The tag syntax of Imba compiles to a chain of setters, which always
+			ends with .end. `<a.large>` compiles to `tag('a').flag('large').end()`
+			
+			You are highly adviced to not override its behaviour. The first time
+			end is called it will mark the tag as built and call Imba.Tag#build,
+			and call Imba.Tag#commit on subsequent calls.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.end = function (){
+			if (this._built) {
+				this.commit();
+			} else {
+				this._built = true;
+				this.build();
+			};
+			return this;
+		};
+		
+		/*
+			This is called instead of Imba.Tag#end for `<self>` tag chains.
+			Defaults to noop
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.synced = function (){
+			return this;
+		};
+		
+		// called when the node is awakened in the dom - either automatically
+		// upon attachment to the dom-tree, or the first time imba needs the
+		// tag for a domnode that has been rendered on the server
+		Imba.Tag.prototype.awaken = function (){
+			return this;
+		};
+		
+		/*
+			List of flags for this node. 
+			*/
+		
+		Imba.Tag.prototype.flags = function (){
+			return this._dom.classList;
+		};
+		
+		/*
+			Add speficied flag to current node.
+			If a second argument is supplied, it will be coerced into a Boolean,
+			and used to indicate whether we should remove the flag instead.
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.flag = function (name,toggler){
+			// it is most natural to treat a second undefined argument as a no-switch
+			// so we need to check the arguments-length
+			if (arguments.length == 2 && !(toggler)) {
+				this._dom.classList.remove(name);
+			} else {
+				this._dom.classList.add(name);
+			};
+			return this;
+		};
+		
+		/*
+			Remove specified flag from node
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.unflag = function (name){
+			this._dom.classList.remove(name);
+			return this;
+		};
+		
+		/*
+			Toggle specified flag on node
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.toggleFlag = function (name){
+			this._dom.classList.toggle(name);
+			return this;
+		};
+		
+		/*
+			Check whether current node has specified flag
+			@return {bool}
+			*/
+		
+		Imba.Tag.prototype.hasFlag = function (name){
+			return this._dom.classList.contains(name);
+		};
+		
+		/*
+			Get the scheduler for this node. A new scheduler will be created
+			if it does not already exist.
+		
+			@return {Imba.Scheduler}
+			*/
+		
+		Imba.Tag.prototype.scheduler = function (){
+			return this._scheduler == null ? (this._scheduler = new Imba.Scheduler(this)) : (this._scheduler);
+		};
+		
+		/*
+		
+			Shorthand to start scheduling a node. The method will basically
+			proxy the arguments through to scheduler.configure, and then
+			activate the scheduler.
+			
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.schedule = function (options){
+			if(options === undefined) options = {};
+			this.scheduler().configure(options).activate();
+			return this;
+		};
+		
+		/*
+			Shorthand for deactivating scheduler (if tag has one).
+			@deprecated
+			*/
+		
+		Imba.Tag.prototype.unschedule = function (){
+			if (this._scheduler) { this.scheduler().deactivate() };
+			return this;
+		};
+		
+		
+		/*
+			Get the parent of current node
+			@return {Imba.Tag} 
+			*/
+		
+		Imba.Tag.prototype.parent = function (){
+			return tag$wrap(this.dom().parentNode);
+		};
+		
+		/*
+			Shorthand for console.log on elements
+			@return {self}
+			*/
+		
+		Imba.Tag.prototype.log = function (){
+			var $0 = arguments, i = $0.length;
+			var args = new Array(i>0 ? i : 0);
+			while(i>0) args[i-1] = $0[--i];
+			args.unshift(console);
+			Function.prototype.call.apply(console.log,args);
+			return this;
+		};
+		
+		Imba.Tag.prototype.css = function (key,val){
+			if (key instanceof Object) {
+				for (var i = 0, keys = Object.keys(key), l = keys.length; i < l; i++){
+					this.css(keys[i],key[keys[i]]);
+				};
+			} else if (val == null) {
+				this.dom().style.removeProperty(key);
+			} else if (val == undefined) {
+				return this.dom().style[key];
+			} else {
+				if ((typeof val=='number'||val instanceof Number) && key.match(/width|height|left|right|top|bottom/)) {
+					val = val + "px";
+				};
+				this.dom().style[key] = val;
+			};
+			return this;
+		};
+		
+		Imba.Tag.prototype.setTransform = function (value){
+			this.css('transform',value);
+			return this;
+		};
+		
+		Imba.Tag.prototype.transform = function (){
+			return this.css('transform');
+		};
+		
+		
+		Imba.Tag.prototype.initialize = Imba.Tag;
+		
+		HTML_TAGS = "a abbr address area article aside audio b base bdi bdo big blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hr html i iframe img input ins kbd keygen label legend li link main map mark menu menuitem meta meter nav noscript object ol optgroup option output p param pre progress q rp rt ruby s samp script section select small source span strong style sub summary sup table tbody td textarea tfoot th thead time title tr track u ul var video wbr".split(" ");
+		HTML_TAGS_UNSAFE = "article aside header section".split(" ");
+		SVG_TAGS = "circle defs ellipse g line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan".split(" ");
+		
+		
+		function extender(obj,sup){
+			for (var i = 0, keys = Object.keys(sup), l = keys.length; i < l; i++){
+				obj[($1 = keys[i])] == null ? (obj[$1] = sup[keys[i]]) : (obj[$1]);
+			};
+			
+			obj.prototype = Object.create(sup.prototype);
+			obj.__super__ = obj.prototype.__super__ = sup.prototype;
+			obj.prototype.initialize = obj.prototype.constructor = obj;
+			if (sup.inherit) { sup.inherit(obj) };
+			return obj;
+		};
+		
+		function Tag(){
+			return function(dom) {
+				this.setDom(dom);
+				return this;
+			};
+		};
+		
+		function TagSpawner(type){
+			return function() { return type.build(); };
+		};
+		
+		Imba.Tags = function Tags(){
+			this;
+		};
+		
+		Imba.Tags.prototype.__clone = function (ns){
+			var clone = Object.create(this);
+			clone._parent = this;
+			return clone;
+		};
+		
+		Imba.Tags.prototype.defineNamespace = function (name){
+			var clone = Object.create(this);
+			clone._parent = this;
+			clone._ns = name;
+			this[name.toUpperCase()] = clone;
+			return clone;
+		};
+		
+		Imba.Tags.prototype.baseType = function (name){
+			return idx$(name,HTML_TAGS) >= 0 ? ('htmlelement') : ('div');
+		};
+		
+		Imba.Tags.prototype.defineTag = function (name,supr,body){
+			if(body==undefined && typeof supr == 'function') body = supr,supr = '';
+			if(supr==undefined) supr = '';
+			supr || (supr = this.baseType(name));
+			var supertype = this[supr];
+			var tagtype = Tag();
+			var norm = name.replace(/\-/g,'_');
+			
+			
+			tagtype._name = name;
+			extender(tagtype,supertype);
+			
+			if (name[0] == '#') {
+				this[name] = tagtype;
+				Imba.SINGLETONS[name.slice(1)] = tagtype;
+			} else {
+				this[name] = tagtype;
+				this['$' + norm] = TagSpawner(tagtype);
+			};
+			
+			if (body) {
+				if (body.length == 2) {
+					// create clone
+					if (!tagtype.hasOwnProperty('TAGS')) {
+						tagtype.TAGS = (supertype.TAGS || this).__clone();
+					};
+				};
+				
+				body.call(tagtype,tagtype,tagtype.TAGS || this);
+			};
+			
+			return tagtype;
+		};
+		
+		Imba.Tags.prototype.defineSingleton = function (name,supr,body){
+			return this.defineTag(name,supr,body);
+		};
+		
+		Imba.Tags.prototype.extendTag = function (name,supr,body){
+			if(body==undefined && typeof supr == 'function') body = supr,supr = '';
+			if(supr==undefined) supr = '';
+			var klass = ((typeof name=='string'||name instanceof String) ? (this[name]) : (name));
+			// allow for private tags here as well?
+			if (body) { body && body.call(klass,klass,klass.prototype) };
+			return klass;
+		};
+		
+		
+		Imba.TAGS = new Imba.Tags();
+		Imba.TAGS.element = Imba.Tag;
+		
+		var svg = Imba.TAGS.defineNamespace('svg');
+		
+		svg.baseType = function (name){
+			return 'svgelement';
+		};
+		
+		
+		Imba.SINGLETONS = {};
+		
+		
+		Imba.defineTag = function (name,supr,body){
+			if(body==undefined && typeof supr == 'function') body = supr,supr = '';
+			if(supr==undefined) supr = '';
+			return Imba.TAGS.defineTag(name,supr,body);
+		};
+		
+		Imba.defineSingletonTag = function (id,supr,body){
+			if(body==undefined && typeof supr == 'function') body = supr,supr = 'div';
+			if(supr==undefined) supr = 'div';
+			return Imba.TAGS.defineTag(this.name(),supr,body);
+		};
+		
+		Imba.extendTag = function (name,body){
+			return Imba.TAGS.extendTag(name,body);
+		};
+		
+		Imba.tag = function (name){
+			var typ = Imba.TAGS[name];
+			if (!(typ)) { throw new Error(("tag " + name + " is not defined")) };
+			return new typ(typ.createNode());
+		};
+		
+		Imba.tagWithId = function (name,id){
+			var typ = Imba.TAGS[name];
+			if (!(typ)) { throw new Error(("tag " + name + " is not defined")) };
+			var dom = typ.createNode();
+			dom.id = id;
+			return new typ(dom);
+		};
+		
+		// TODO: Can we move these out and into dom.imba in a clean way?
+		// These methods depends on Imba.document.getElementById
+		
+		Imba.getTagSingleton = function (id){
+			var klass;
+			var dom,node;
+			
+			if (klass = Imba.SINGLETONS[id]) {
+				if (klass && klass.Instance) { return klass.Instance };
+				
+				// no instance - check for element
+				if (dom = Imba.document().getElementById(id)) {
+					// we have a live instance - when finding it through a selector we should awake it, no?
+					// console.log('creating the singleton from existing node in dom?',id,type)
+					node = klass.Instance = new klass(dom);
+					node.awaken(dom); // should only awaken
+					return node;
+				};
+				
+				dom = klass.createNode();
+				dom.id = id;
+				node = klass.Instance = new klass(dom);
+				node.end().awaken(dom);
+				return node;
+			} else if (dom = Imba.document().getElementById(id)) {
+				return Imba.getTagForDom(dom);
+			};
+		};
+		
+		var svgSupport = typeof SVGElement !== 'undefined';
+		
+		Imba.getTagForDom = function (dom){
+			var m;
+			if (!(dom)) { return null };
+			if (dom._dom) { return dom }; // could use inheritance instead
+			if (dom._tag) { return dom._tag };
+			if (!dom.nodeName) { return null };
+			
+			var ns = null;
+			var id = dom.id;
+			var type = dom.nodeName.toLowerCase();
+			var tags = Imba.TAGS;
+			var native$ = type;
+			var cls = dom.className;
+			
+			if (id && Imba.SINGLETONS[id]) {
+				// FIXME control that it is the same singleton?
+				// might collide -- not good?
+				return Imba.getTagSingleton(id);
+			};
+			// look for id - singleton
+			
+			// need better test here
+			if (svgSupport && (dom instanceof SVGElement)) {
+				ns = "svg";
+				cls = dom.className.baseVal;
+				tags = tags.SVG;
+			};
+			
+			var spawner;
+			
+			if (cls) {
+				// there can be several matches here - should choose the last
+				// should fall back to less specific later? - otherwise things may fail
+				// TODO rework this
+				if (m = cls.match(/\b_([a-z\-]+)\b(?!\s*_[a-z\-]+)/)) {
+					type = m[1]; // .replace(/-/g,'_')
+				};
+				
+				if (m = cls.match(/\b([A-Z\-]+)_\b/)) {
+					ns = m[1];
+				};
+			};
+			
+			
+			spawner = tags[type] || tags[native$];
+			return spawner ? (new spawner(dom).awaken(dom)) : (null);
+		};
+		
+		tag$ = Imba.TAGS;
+		t$ = Imba.tag;
+		tc$ = Imba.tagWithFlags;
+		ti$ = Imba.tagWithId;
+		tic$ = Imba.tagWithIdAndFlags;
+		id$ = Imba.getTagSingleton;
+		return tag$wrap = Imba.getTagForDom;
+		
+
+	})()
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+	(function(){
+		function iter$(a){ return a ? (a.toArray ? a.toArray() : a) : []; };
+		
+		Imba.document = function (){
+			return window.document;
+		};
+		
+		/*
+		Returns the body element wrapped in an Imba.Tag
+		*/
+		
+		Imba.root = function (){
+			return tag$wrap(Imba.document().body);
+		};
+		
+		tag$.defineTag('htmlelement', 'element', function(tag){
+			
+			/*
+				Called when a tag type is being subclassed.
+				*/
+			
+			tag.inherit = function (child){
+				child.prototype._empty = true;
+				child._protoDom = null;
+				
+				if (this._nodeType) {
+					child._nodeType = this._nodeType;
+					
+					var className = "_" + child._name.replace(/_/g,'-');
+					if (child._name[0] != '#') { return child._classes = this._classes.concat(className) };
+				} else {
+					child._nodeType = child._name;
+					return child._classes = [];
+				};
+			};
+			
+			tag.buildNode = function (){
+				var dom = Imba.document().createElement(this._nodeType);
+				var cls = this._classes.join(" ");
+				if (cls) { dom.className = cls };
+				return dom;
+			};
+			
+			tag.createNode = function (){
+				var proto = (this._protoDom || (this._protoDom = this.buildNode()));
+				return proto.cloneNode(false);
+			};
+			
+			tag.dom = function (){
+				return this._protoDom || (this._protoDom = this.buildNode());
+			};
+			
+			tag.prototype.id = function(v){ return this.getAttribute('id'); }
+			tag.prototype.setId = function(v){ this.setAttribute('id',v); return this; };
+			tag.prototype.tabindex = function(v){ return this.getAttribute('tabindex'); }
+			tag.prototype.setTabindex = function(v){ this.setAttribute('tabindex',v); return this; };
+			tag.prototype.title = function(v){ return this.getAttribute('title'); }
+			tag.prototype.setTitle = function(v){ this.setAttribute('title',v); return this; };
+			tag.prototype.role = function(v){ return this.getAttribute('role'); }
+			tag.prototype.setRole = function(v){ this.setAttribute('role',v); return this; };
+			
+			tag.prototype.width = function (){
+				return this._dom.offsetWidth;
+			};
+			
+			tag.prototype.height = function (){
+				return this._dom.offsetHeight;
+			};
+			
+			tag.prototype.setChildren = function (nodes,type){
+				this._empty ? (this.append(nodes)) : (this.empty().append(nodes));
+				this._children = null;
+				return this;
+			};
+			
+			/*
+				Set inner html of node
+				*/
+			
+			tag.prototype.setHtml = function (html){
+				this._dom.innerHTML = html;
+				return this;
+			};
+			
+			/*
+				Get inner html of node
+				*/
+			
+			tag.prototype.html = function (){
+				return this._dom.innerHTML;
+			};
+			
+			/*
+				Remove all content inside node
+				*/
+			
+			tag.prototype.empty = function (){
+				while (this._dom.firstChild){
+					this._dom.removeChild(this._dom.firstChild);
+				};
+				this._children = null;
+				this._empty = true;
+				return this;
+			};
+			
+			/*
+				Remove specified child from current node.
+				*/
+			
+			tag.prototype.remove = function (child){
+				var par = this.dom();
+				var el = child && child.dom();
+				if (el && el.parentNode == par) { par.removeChild(el) };
+				return this;
+			};
+			
+			tag.prototype.emit = function (name,pars){
+				if(!pars||pars.constructor !== Object) pars = {};
+				var data = pars.data !== undefined ? pars.data : null;
+				var bubble = pars.bubble !== undefined ? pars.bubble : true;
+				Imba.Events.trigger(name,this,{data: data,bubble: bubble});
+				return this;
+			};
+			
+			tag.prototype.dataset = function (key,val){
+				if (key instanceof Object) {
+					for (var i = 0, keys = Object.keys(key), l = keys.length; i < l; i++){
+						this.dataset(keys[i],key[keys[i]]);
+					};
+					return this;
+				};
+				
+				if (arguments.length == 2) {
+					this.setAttribute(("data-" + key),val);
+					return this;
+				};
+				
+				if (key) {
+					return this.getAttribute(("data-" + key));
+				};
+				
+				var dataset = this.dom().dataset;
+				
+				if (!(dataset)) {
+					dataset = {};
+					for (var i = 0, ary = iter$(this.dom().attributes), len = ary.length, atr; i < len; i++) {
+						atr = ary[i];
+						if (atr.name.substr(0,5) == 'data-') {
+							dataset[Imba.toCamelCase(atr.name.slice(5))] = atr.value;
+						};
+					};
+				};
+				
+				return dataset;
+			};
+			
+			/*
+				Get descendants of current node, optionally matching selector
+				@return {Imba.Selector}
+				*/
+			
+			tag.prototype.find = function (sel){
+				return new Imba.Selector(sel,this);
+			};
+			
+			/*
+				Get the first matching child of node
+			
+				@return {Imba.Tag}
+				*/
+			
+			tag.prototype.first = function (sel){
+				return sel ? (this.find(sel).first()) : (tag$wrap(this.dom().firstElementChild));
+			};
+			
+			/*
+				Get the last matching child of node
+			
+					node.last # returns the last child of node
+					node.last %span # returns the last span inside node
+					node.last do |el| el.text == 'Hi' # return last node with text Hi
+			
+				@return {Imba.Tag}
+				*/
+			
+			tag.prototype.last = function (sel){
+				return sel ? (this.find(sel).last()) : (tag$wrap(this.dom().lastElementChild));
+			};
+			
+			/*
+				Get the child at index
+				*/
+			
+			tag.prototype.child = function (i){
+				return tag$wrap(this.dom().children[i || 0]);
+			};
+			
+			tag.prototype.children = function (sel){
+				var nodes = new Imba.Selector(null,this,this._dom.children);
+				return sel ? (nodes.filter(sel)) : (nodes);
+			};
+			
+			tag.prototype.orphanize = function (){
+				var par;
+				if (par = this.dom().parentNode) { par.removeChild(this._dom) };
+				return this;
+			};
+			
+			tag.prototype.matches = function (sel){
+				var fn;
+				if (sel instanceof Function) {
+					return sel(this);
+				};
+				
+				if (sel.query) { sel = sel.query() };
+				if (fn = (this._dom.matches || this._dom.matchesSelector || this._dom.webkitMatchesSelector || this._dom.msMatchesSelector || this._dom.mozMatchesSelector)) {
+					return fn.call(this._dom,sel);
+				};
+			};
+			
+			/*
+				Get the first element matching supplied selector / filter
+				traversing upwards, but including the node itself.
+				@return {Imba.Tag}
+				*/
+			
+			tag.prototype.closest = function (sel){
+				if (!(sel)) { return this.parent() }; // should return self?!
+				var node = this;
+				if (sel.query) { sel = sel.query() };
+				
+				while (node){
+					if (node.matches(sel)) { return node };
+					node = node.parent();
+				};
+				return null;
+			};
+			
+			/*
+				Get the closest ancestor of node that matches
+				specified selector / matcher.
+			
+				@return {Imba.Tag}
+				*/
+			
+			tag.prototype.up = function (sel){
+				if (!(sel)) { return this.parent() };
+				return this.parent() && this.parent().closest(sel);
+			};
+			
+			tag.prototype.path = function (sel){
+				var node = this;
+				var nodes = [];
+				if (sel && sel.query) { sel = sel.query() };
+				
+				while (node){
+					if (!(sel) || node.matches(sel)) { nodes.push(node) };
+					node = node.parent();
+				};
+				return nodes;
+			};
+			
+			tag.prototype.parents = function (sel){
+				var par = this.parent();
+				return par ? (par.path(sel)) : ([]);
+			};
+			
+			
+			
+			tag.prototype.siblings = function (sel){
+				var par, self = this;
+				if (!(par = this.parent())) { return [] }; // FIXME
+				var ary = this.dom().parentNode.children;
+				var nodes = new Imba.Selector(null,this,ary);
+				return nodes.filter(function(n) { return n != self && (!(sel) || n.matches(sel)); });
+			};
+			
+			/*
+				Get the immediately following sibling of node.
+				*/
+			
+			tag.prototype.next = function (sel){
+				if (sel) {
+					var el = this;
+					while (el = el.next()){
+						if (el.matches(sel)) { return el };
+					};
+					return null;
+				};
+				return tag$wrap(this.dom().nextElementSibling);
+			};
+			
+			/*
+				Get the immediately preceeding sibling of node.
+				*/
+			
+			tag.prototype.prev = function (sel){
+				if (sel) {
+					var el = this;
+					while (el = el.prev()){
+						if (el.matches(sel)) { return el };
+					};
+					return null;
+				};
+				return tag$wrap(this.dom().previousElementSibling);
+			};
+			
+			tag.prototype.contains = function (node){
+				return this.dom().contains(node && node._dom || node);
+			};
+			
+			tag.prototype.index = function (){
+				var i = 0;
+				var el = this.dom();
+				while (el.previousSibling){
+					el = el.previousSibling;
+					i++;
+				};
+				return i;
+			};
+			
+			
+			/*
+				
+				@deprecated
+				*/
+			
+			tag.prototype.insert = function (node,pars){
+				if(!pars||pars.constructor !== Object) pars = {};
+				var before = pars.before !== undefined ? pars.before : null;
+				var after = pars.after !== undefined ? pars.after : null;
+				if (after) { before = after.next() };
+				if (node instanceof Array) {
+					node = (tag$.$fragment().setContent(node,0).end());
+				};
+				if (before) {
+					this.dom().insertBefore(node.dom(),before.dom());
+				} else {
+					this.append(node);
+				};
+				return this;
+			};
+			
+			/*
+				Focus on current node
+				@return {self}
+				*/
+			
+			tag.prototype.focus = function (){
+				this.dom().focus();
+				return this;
+			};
+			
+			/*
+				Remove focus from current node
+				@return {self}
+				*/
+			
+			tag.prototype.blur = function (){
+				this.dom().blur();
+				return this;
+			};
+			
+			tag.prototype.template = function (){
+				return null;
+			};
+			
+			/*
+				@todo Should support multiple arguments like append
+			
+				The .prepend method inserts the specified content as the first
+				child of the target node. If the content is already a child of 
+				node it will be moved to the start.
+				
+			    	node.prepend <div.top> # prepend node
+			    	node.prepend "some text" # prepend text
+			    	node.prepend [<ul>,<ul>] # prepend array
+			
+				*/
+			
+			tag.prototype.prepend = function (item){
+				var first = this._dom.childNodes[0];
+				first ? (this.insertBefore(item,first)) : (this.appendChild(item));
+				return this;
+			};
+			
+			/*
+				The .append method inserts the specified content as the last child
+				of the target node. If the content is already a child of node it
+				will be moved to the end.
+				
+				# example
+				    var root = <div.root>
+				    var item = <div.item> "This is an item"
+				    root.append item # appends item to the end of root
+			
+				    root.prepend "some text" # append text
+				    root.prepend [<ul>,<ul>] # append array
+				*/
+			
+			tag.prototype.append = function (item){
+				// possible to append blank
+				// possible to simplify on server?
+				if (!(item)) { return this };
+				
+				if (item instanceof Array) {
+					for (var i = 0, ary = iter$(item), len = ary.length, member; i < len; i++) {
+						member = ary[i];
+						member && this.append(member);
+					};
+				} else if ((typeof item=='string'||item instanceof String) || (typeof item=='number'||item instanceof Number)) {
+					var node = Imba.document().createTextNode(item);
+					this._dom.appendChild(node);
+					if (this._empty) { this._empty = false };
+				} else {
+					this._dom.appendChild(item._dom || item);
+					if (this._empty) { this._empty = false };
+				};
+				
+				return this;
+			};
+			
+			/*
+				Insert a node into the current node (self), before another.
+				The relative node must be a child of current node. 
+				*/
+			
+			tag.prototype.insertBefore = function (node,rel){
+				if ((typeof node=='string'||node instanceof String)) { node = Imba.document().createTextNode(node) };
+				if (node && rel) { this.dom().insertBefore((node._dom || node),(rel._dom || rel)) };
+				return this;
+			};
+			
+			/*
+				Append a single item (node or string) to the current node.
+				If supplied item is a string it will automatically. This is used
+				by Imba internally, but will practically never be used explicitly.
+				*/
+			
+			tag.prototype.appendChild = function (node){
+				if ((typeof node=='string'||node instanceof String)) { node = Imba.document().createTextNode(node) };
+				if (node) { this.dom().appendChild(node._dom || node) };
+				return this;
+			};
+			
+			/*
+				Remove a single child from the current node.
+				Used by Imba internally.
+				*/
+			
+			tag.prototype.removeChild = function (node){
+				if (node) { this.dom().removeChild(node._dom || node) };
+				return this;
+			};
+			
+			tag.prototype.toString = function (){
+				return this._dom.toString(); // really?
+			};
+			
+			/*
+				@deprecated
+				*/
+			
+			tag.prototype.classes = function (){
+				console.log('Imba.Tag#classes is deprecated');
+				return this._dom.classList;
+			};
+		});
+		
+		return tag$.defineTag('svgelement', 'htmlelement');
+	
+	})()
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+	(function(){
+		
+		// predefine all supported html tags
+		tag$.defineTag('fragment', 'htmlelement', function(tag){
+			
+			tag.createNode = function (){
+				return Imba.document().createDocumentFragment();
+			};
+		});
+		
+		tag$.defineTag('a', function(tag){
+			tag.prototype.href = function(v){ return this.getAttribute('href'); }
+			tag.prototype.setHref = function(v){ this.setAttribute('href',v); return this; };
+		});
+		
+		tag$.defineTag('abbr');
+		tag$.defineTag('address');
+		tag$.defineTag('area');
+		tag$.defineTag('article');
+		tag$.defineTag('aside');
+		tag$.defineTag('audio');
+		tag$.defineTag('b');
+		tag$.defineTag('base');
+		tag$.defineTag('bdi');
+		tag$.defineTag('bdo');
+		tag$.defineTag('big');
+		tag$.defineTag('blockquote');
+		tag$.defineTag('body');
+		tag$.defineTag('br');
+		
+		tag$.defineTag('button', function(tag){
+			tag.prototype.autofocus = function(v){ return this.getAttribute('autofocus'); }
+			tag.prototype.setAutofocus = function(v){ this.setAttribute('autofocus',v); return this; };
+			tag.prototype.type = function(v){ return this.getAttribute('type'); }
+			tag.prototype.setType = function(v){ this.setAttribute('type',v); return this; };
+			tag.prototype.disabled = function(v){ return this.getAttribute('disabled'); }
+			tag.prototype.setDisabled = function(v){ this.setAttribute('disabled',v); return this; };
+		});
+		
+		tag$.defineTag('canvas', function(tag){
+			tag.prototype.setWidth = function (val){
+				if (this.width() != val) { this.dom().width = val };
+				return this;
+			};
+			
+			tag.prototype.setHeight = function (val){
+				if (this.height() != val) { this.dom().height = val };
+				return this;
+			};
+			
+			tag.prototype.width = function (){
+				return this.dom().width;
+			};
+			
+			tag.prototype.height = function (){
+				return this.dom().height;
+			};
+			
+			tag.prototype.context = function (type){
+				if(type === undefined) type = '2d';
+				return this.dom().getContext(type);
+			};
+		});
+		
+		tag$.defineTag('caption');
+		tag$.defineTag('cite');
+		tag$.defineTag('code');
+		tag$.defineTag('col');
+		tag$.defineTag('colgroup');
+		tag$.defineTag('data');
+		tag$.defineTag('datalist');
+		tag$.defineTag('dd');
+		tag$.defineTag('del');
+		tag$.defineTag('details');
+		tag$.defineTag('dfn');
+		tag$.defineTag('div');
+		tag$.defineTag('dl');
+		tag$.defineTag('dt');
+		tag$.defineTag('em');
+		tag$.defineTag('embed');
+		tag$.defineTag('fieldset');
+		tag$.defineTag('figcaption');
+		tag$.defineTag('figure');
+		tag$.defineTag('footer');
+		
+		tag$.defineTag('form', function(tag){
+			tag.prototype.method = function(v){ return this.getAttribute('method'); }
+			tag.prototype.setMethod = function(v){ this.setAttribute('method',v); return this; };
+			tag.prototype.action = function(v){ return this.getAttribute('action'); }
+			tag.prototype.setAction = function(v){ this.setAttribute('action',v); return this; };
+		});
+		
+		tag$.defineTag('h1');
+		tag$.defineTag('h2');
+		tag$.defineTag('h3');
+		tag$.defineTag('h4');
+		tag$.defineTag('h5');
+		tag$.defineTag('h6');
+		tag$.defineTag('head');
+		tag$.defineTag('header');
+		tag$.defineTag('hr');
+		tag$.defineTag('html');
+		tag$.defineTag('i');
+		
+		tag$.defineTag('iframe', function(tag){
+			tag.prototype.src = function(v){ return this.getAttribute('src'); }
+			tag.prototype.setSrc = function(v){ this.setAttribute('src',v); return this; };
+		});
+		
+		tag$.defineTag('img', function(tag){
+			tag.prototype.src = function(v){ return this.getAttribute('src'); }
+			tag.prototype.setSrc = function(v){ this.setAttribute('src',v); return this; };
+		});
+		
+		tag$.defineTag('input', function(tag){
+			// can use attr instead
+			tag.prototype.name = function(v){ return this.getAttribute('name'); }
+			tag.prototype.setName = function(v){ this.setAttribute('name',v); return this; };
+			tag.prototype.type = function(v){ return this.getAttribute('type'); }
+			tag.prototype.setType = function(v){ this.setAttribute('type',v); return this; };
+			tag.prototype.required = function(v){ return this.getAttribute('required'); }
+			tag.prototype.setRequired = function(v){ this.setAttribute('required',v); return this; };
+			tag.prototype.disabled = function(v){ return this.getAttribute('disabled'); }
+			tag.prototype.setDisabled = function(v){ this.setAttribute('disabled',v); return this; };
+			tag.prototype.autofocus = function(v){ return this.getAttribute('autofocus'); }
+			tag.prototype.setAutofocus = function(v){ this.setAttribute('autofocus',v); return this; };
+			
+			tag.prototype.value = function (){
+				return this.dom().value;
+			};
+			
+			tag.prototype.setValue = function (v){
+				if (v != this.dom().value) { this.dom().value = v };
+				return this;
+			};
+			
+			tag.prototype.setPlaceholder = function (v){
+				if (v != this.dom().placeholder) { this.dom().placeholder = v };
+				return this;
+			};
+			
+			tag.prototype.placeholder = function (){
+				return this.dom().placeholder;
+			};
+			
+			tag.prototype.checked = function (){
+				return this.dom().checked;
+			};
+			
+			tag.prototype.setChecked = function (bool){
+				if (bool != this.dom().checked) { this.dom().checked = bool };
+				return this;
+			};
+		});
+		
+		tag$.defineTag('ins');
+		tag$.defineTag('kbd');
+		tag$.defineTag('keygen');
+		tag$.defineTag('label');
+		tag$.defineTag('legend');
+		tag$.defineTag('li');
+		
+		tag$.defineTag('link', function(tag){
+			tag.prototype.rel = function(v){ return this.getAttribute('rel'); }
+			tag.prototype.setRel = function(v){ this.setAttribute('rel',v); return this; };
+			tag.prototype.type = function(v){ return this.getAttribute('type'); }
+			tag.prototype.setType = function(v){ this.setAttribute('type',v); return this; };
+			tag.prototype.href = function(v){ return this.getAttribute('href'); }
+			tag.prototype.setHref = function(v){ this.setAttribute('href',v); return this; };
+			tag.prototype.media = function(v){ return this.getAttribute('media'); }
+			tag.prototype.setMedia = function(v){ this.setAttribute('media',v); return this; };
+		});
+		
+		tag$.defineTag('main');
+		tag$.defineTag('map');
+		tag$.defineTag('mark');
+		tag$.defineTag('menu');
+		tag$.defineTag('menuitem');
+		
+		tag$.defineTag('meta', function(tag){
+			tag.prototype.name = function(v){ return this.getAttribute('name'); }
+			tag.prototype.setName = function(v){ this.setAttribute('name',v); return this; };
+			tag.prototype.content = function(v){ return this.getAttribute('content'); }
+			tag.prototype.setContent = function(v){ this.setAttribute('content',v); return this; };
+			tag.prototype.charset = function(v){ return this.getAttribute('charset'); }
+			tag.prototype.setCharset = function(v){ this.setAttribute('charset',v); return this; };
+		});
+		
+		tag$.defineTag('meter');
+		tag$.defineTag('nav');
+		tag$.defineTag('noscript');
+		tag$.defineTag('object');
+		tag$.defineTag('ol');
+		tag$.defineTag('optgroup');
+		
+		tag$.defineTag('option', function(tag){
+			tag.prototype.value = function(v){ return this.getAttribute('value'); }
+			tag.prototype.setValue = function(v){ this.setAttribute('value',v); return this; };
+		});
+		
+		tag$.defineTag('output');
+		tag$.defineTag('p');
+		tag$.defineTag('param');
+		tag$.defineTag('pre');
+		tag$.defineTag('progress');
+		tag$.defineTag('q');
+		tag$.defineTag('rp');
+		tag$.defineTag('rt');
+		tag$.defineTag('ruby');
+		tag$.defineTag('s');
+		tag$.defineTag('samp');
+		
+		tag$.defineTag('script', function(tag){
+			tag.prototype.src = function(v){ return this.getAttribute('src'); }
+			tag.prototype.setSrc = function(v){ this.setAttribute('src',v); return this; };
+			tag.prototype.type = function(v){ return this.getAttribute('type'); }
+			tag.prototype.setType = function(v){ this.setAttribute('type',v); return this; };
+			tag.prototype.async = function(v){ return this.getAttribute('async'); }
+			tag.prototype.setAsync = function(v){ this.setAttribute('async',v); return this; };
+			tag.prototype.defer = function(v){ return this.getAttribute('defer'); }
+			tag.prototype.setDefer = function(v){ this.setAttribute('defer',v); return this; };
+		});
+		
+		tag$.defineTag('section');
+		
+		tag$.defineTag('select', function(tag){
+			tag.prototype.name = function(v){ return this.getAttribute('name'); }
+			tag.prototype.setName = function(v){ this.setAttribute('name',v); return this; };
+			tag.prototype.multiple = function(v){ return this.getAttribute('multiple'); }
+			tag.prototype.setMultiple = function(v){ this.setAttribute('multiple',v); return this; };
+			tag.prototype.required = function(v){ return this.getAttribute('required'); }
+			tag.prototype.setRequired = function(v){ this.setAttribute('required',v); return this; };
+			tag.prototype.disabled = function(v){ return this.getAttribute('disabled'); }
+			tag.prototype.setDisabled = function(v){ this.setAttribute('disabled',v); return this; };
+			
+			tag.prototype.value = function (){
+				return this.dom().value;
+			};
+			
+			tag.prototype.setValue = function (v){
+				if (v != this.dom().value) { this.dom().value = v };
+				return this;
+			};
+		});
+		
+		
+		tag$.defineTag('small');
+		tag$.defineTag('source');
+		tag$.defineTag('span');
+		tag$.defineTag('strong');
+		tag$.defineTag('style');
+		tag$.defineTag('sub');
+		tag$.defineTag('summary');
+		tag$.defineTag('sup');
+		tag$.defineTag('table');
+		tag$.defineTag('tbody');
+		tag$.defineTag('td');
+		
+		tag$.defineTag('textarea', function(tag){
+			tag.prototype.name = function(v){ return this.getAttribute('name'); }
+			tag.prototype.setName = function(v){ this.setAttribute('name',v); return this; };
+			tag.prototype.disabled = function(v){ return this.getAttribute('disabled'); }
+			tag.prototype.setDisabled = function(v){ this.setAttribute('disabled',v); return this; };
+			tag.prototype.required = function(v){ return this.getAttribute('required'); }
+			tag.prototype.setRequired = function(v){ this.setAttribute('required',v); return this; };
+			tag.prototype.rows = function(v){ return this.getAttribute('rows'); }
+			tag.prototype.setRows = function(v){ this.setAttribute('rows',v); return this; };
+			tag.prototype.cols = function(v){ return this.getAttribute('cols'); }
+			tag.prototype.setCols = function(v){ this.setAttribute('cols',v); return this; };
+			tag.prototype.autofocus = function(v){ return this.getAttribute('autofocus'); }
+			tag.prototype.setAutofocus = function(v){ this.setAttribute('autofocus',v); return this; };
+			
+			tag.prototype.value = function (){
+				return this.dom().value;
+			};
+			
+			tag.prototype.setValue = function (v){
+				if (v != this.dom().value) { this.dom().value = v };
+				return this;
+			};
+			
+			tag.prototype.setPlaceholder = function (v){
+				if (v != this.dom().placeholder) { this.dom().placeholder = v };
+				return this;
+			};
+			
+			tag.prototype.placeholder = function (){
+				return this.dom().placeholder;
+			};
+		});
+		
+		tag$.defineTag('tfoot');
+		tag$.defineTag('th');
+		tag$.defineTag('thead');
+		tag$.defineTag('time');
+		tag$.defineTag('title');
+		tag$.defineTag('tr');
+		tag$.defineTag('track');
+		tag$.defineTag('u');
+		tag$.defineTag('ul');
+		tag$.defineTag('video');
+		return tag$.defineTag('wbr');
+	
+	})()
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	(function(){
+		function idx$(a,b){
+			return (b && b.indexOf) ? b.indexOf(a) : [].indexOf.call(a,b);
+		};
+		
+		
+		tag$.SVG.defineTag('svgelement', function(tag){
+			
+			tag.namespaceURI = function (){
+				return "http://www.w3.org/2000/svg";
+			};
+			
+			var types = "circle defs ellipse g line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan".split(" ");
+			
+			tag.buildNode = function (){
+				var dom = Imba.document().createElementNS(this.namespaceURI(),this._nodeType);
+				var cls = this._classes.join(" ");
+				if (cls) { dom.className.baseVal = cls };
+				return dom;
+			};
+			
+			tag.inherit = function (child){
+				child._protoDom = null;
+				
+				if (idx$(child._name,types) >= 0) {
+					child._nodeType = child._name;
+					return child._classes = [];
+				} else {
+					child._nodeType = this._nodeType;
+					var className = "_" + child._name.replace(/_/g,'-');
+					return child._classes = this._classes.concat(className);
+				};
+			};
+			
+			
+			Imba.attr(tag,'x');
+			Imba.attr(tag,'y');
+			
+			Imba.attr(tag,'width');
+			Imba.attr(tag,'height');
+			
+			Imba.attr(tag,'stroke');
+			Imba.attr(tag,'stroke-width');
+		});
+		
+		tag$.SVG.defineTag('svg', function(tag){
+			Imba.attr(tag,'viewbox');
+		});
+		
+		tag$.SVG.defineTag('g');
+		
+		tag$.SVG.defineTag('defs');
+		
+		tag$.SVG.defineTag('symbol', function(tag){
+			Imba.attr(tag,'preserveAspectRatio');
+			Imba.attr(tag,'viewBox');
+		});
+		
+		tag$.SVG.defineTag('marker', function(tag){
+			Imba.attr(tag,'markerUnits');
+			Imba.attr(tag,'refX');
+			Imba.attr(tag,'refY');
+			Imba.attr(tag,'markerWidth');
+			Imba.attr(tag,'markerHeight');
+			Imba.attr(tag,'orient');
+		});
+		
+		
+		// Basic shapes
+		
+		tag$.SVG.defineTag('rect', function(tag){
+			Imba.attr(tag,'rx');
+			Imba.attr(tag,'ry');
+		});
+		
+		tag$.SVG.defineTag('circle', function(tag){
+			Imba.attr(tag,'cx');
+			Imba.attr(tag,'cy');
+			Imba.attr(tag,'r');
+		});
+		
+		tag$.SVG.defineTag('ellipse', function(tag){
+			Imba.attr(tag,'cx');
+			Imba.attr(tag,'cy');
+			Imba.attr(tag,'rx');
+			Imba.attr(tag,'ry');
+		});
+		
+		tag$.SVG.defineTag('path', function(tag){
+			Imba.attr(tag,'d');
+			Imba.attr(tag,'pathLength');
+		});
+		
+		tag$.SVG.defineTag('line', function(tag){
+			Imba.attr(tag,'x1');
+			Imba.attr(tag,'x2');
+			Imba.attr(tag,'y1');
+			Imba.attr(tag,'y2');
+		});
+		
+		tag$.SVG.defineTag('polyline', function(tag){
+			Imba.attr(tag,'points');
+		});
+		
+		tag$.SVG.defineTag('polygon', function(tag){
+			Imba.attr(tag,'points');
+		});
+		
+		tag$.SVG.defineTag('text', function(tag){
+			Imba.attr(tag,'dx');
+			Imba.attr(tag,'dy');
+			Imba.attr(tag,'text-anchor');
+			Imba.attr(tag,'rotate');
+			Imba.attr(tag,'textLength');
+			Imba.attr(tag,'lengthAdjust');
+		});
+		
+		return tag$.SVG.defineTag('tspan', function(tag){
+			Imba.attr(tag,'dx');
+			Imba.attr(tag,'dy');
+			Imba.attr(tag,'rotate');
+			Imba.attr(tag,'textLength');
+			Imba.attr(tag,'lengthAdjust');
+		});
+
+	})()
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	(function(){
+		function iter$(a){ return a ? (a.toArray ? a.toArray() : a) : []; };
+		// Extending Imba.Tag#css to work without prefixes by inspecting
+		// the properties of a CSSStyleDeclaration and creating a map
+		
+		// var prefixes = ['-webkit-','-ms-','-moz-','-o-','-blink-']
+		// var props = ['transform','transition','animation']
+		
+		if (true) {
+			var styles = window.getComputedStyle(document.documentElement,'');
+			
+			Imba.CSSKeyMap = {};
+			
+			for (var i = 0, ary = iter$(styles), len = ary.length, prefixed; i < len; i++) {
+				prefixed = ary[i];
+				var unprefixed = prefixed.replace(/^-(webkit|ms|moz|o|blink)-/,'');
+				var camelCase = unprefixed.replace(/-(\w)/g,function(m,a) { return a.toUpperCase(); });
+				
+				// if there exists an unprefixed version -- always use this
+				if (prefixed != unprefixed) {
+					if (styles.hasOwnProperty(unprefixed)) { continue; };
+				};
+				
+				// register the prefixes
+				Imba.CSSKeyMap[unprefixed] = Imba.CSSKeyMap[camelCase] = prefixed;
+			};
+			
+			tag$.extendTag('element', function(tag){
+				
+				// override the original css method
+				tag.prototype.css = function (key,val){
+					if (key instanceof Object) {
+						for (var i = 0, keys = Object.keys(key), l = keys.length; i < l; i++){
+							this.css(keys[i],key[keys[i]]);
+						};
+						return this;
+					};
+					
+					key = Imba.CSSKeyMap[key] || key;
+					
+					if (val == null) {
+						this.dom().style.removeProperty(key);
+					} else if (val == undefined) {
+						return this.dom().style[key];
+					} else {
+						if ((typeof val=='number'||val instanceof Number) && key.match(/width|height|left|right|top|bottom/)) {
+							val = val + "px";
+						};
+						this.dom().style[key] = val;
+					};
+					return this;
+				};
+			});
+			
+			if (!document.documentElement.classList) {
+				tag$.extendTag('element', function(tag){
+					
+					tag.prototype.hasFlag = function (ref){
+						return new RegExp('(^|\\s)' + ref + '(\\s|$)').test(this._dom.className);
+					};
+					
+					tag.prototype.addFlag = function (ref){
+						if (this.hasFlag(ref)) { return this };
+						this._dom.className += (this._dom.className ? (' ') : ('')) + ref;
+						return this;
+					};
+					
+					tag.prototype.unflag = function (ref){
+						if (!this.hasFlag(ref)) { return this };
+						var regex = new RegExp('(^|\\s)*' + ref + '(\\s|$)*','g');
+						this._dom.className = this._dom.className.replace(regex,'');
+						return this;
+					};
+					
+					tag.prototype.toggleFlag = function (ref){
+						return this.hasFlag(ref) ? (this.unflag(ref)) : (this.flag(ref));
+					};
+					
+					tag.prototype.flag = function (ref,bool){
+						if (arguments.length == 2 && !(!(bool)) === false) {
+							return this.unflag(ref);
+						};
+						return this.addFlag(ref);
+					};
+				});
+				return true;
+			};
+		};
+
+	})()
+
+/***/ },
+/* 9 */
+/***/ function(module, exports) {
+
+	(function(){
+		function iter$(a){ return a ? (a.toArray ? a.toArray() : a) : []; };
+		var doc = document;
+		var win = window;
+		
+		var hasTouchEvents = window && window.ontouchstart !== undefined;
+		
+		Imba.Pointer = function Pointer(){
+			this.setButton(-1);
+			this.setEvent({x: 0,y: 0,type: 'uninitialized'});
+			return this;
+		};
+		
+		Imba.Pointer.prototype.phase = function(v){ return this._phase; }
+		Imba.Pointer.prototype.setPhase = function(v){ this._phase = v; return this; };
+		Imba.Pointer.prototype.prevEvent = function(v){ return this._prevEvent; }
+		Imba.Pointer.prototype.setPrevEvent = function(v){ this._prevEvent = v; return this; };
+		Imba.Pointer.prototype.button = function(v){ return this._button; }
+		Imba.Pointer.prototype.setButton = function(v){ this._button = v; return this; };
+		Imba.Pointer.prototype.event = function(v){ return this._event; }
+		Imba.Pointer.prototype.setEvent = function(v){ this._event = v; return this; };
+		Imba.Pointer.prototype.dirty = function(v){ return this._dirty; }
+		Imba.Pointer.prototype.setDirty = function(v){ this._dirty = v; return this; };
+		Imba.Pointer.prototype.events = function(v){ return this._events; }
+		Imba.Pointer.prototype.setEvents = function(v){ this._events = v; return this; };
+		Imba.Pointer.prototype.touch = function(v){ return this._touch; }
+		Imba.Pointer.prototype.setTouch = function(v){ this._touch = v; return this; };
+		
+		Imba.Pointer.prototype.update = function (e){
+			this.setEvent(e);
+			this.setDirty(true);
+			return this;
+		};
+		
+		// this is just for regular mouse now
+		Imba.Pointer.prototype.process = function (){
+			var e1 = this.event();
+			
+			if (this.dirty()) {
+				this.setPrevEvent(e1);
+				this.setDirty(false);
+				
+				// button should only change on mousedown etc
+				if (e1.type == 'mousedown') {
+					this.setButton(e1.button);
+					
+					// do not create touch for right click
+					if (this.button() == 2 || (this.touch() && this.button() != 0)) {
+						return;
+					};
+					
+					// cancel the previous touch
+					if (this.touch()) { this.touch().cancel() };
+					this.setTouch(new Imba.Touch(e1,this));
+					this.touch().mousedown(e1,e1);
+				} else if (e1.type == 'mousemove') {
+					if (this.touch()) { this.touch().mousemove(e1,e1) };
+				} else if (e1.type == 'mouseup') {
+					this.setButton(-1);
+					
+					if (this.touch() && this.touch().button() == e1.button) {
+						this.touch().mouseup(e1,e1);
+						this.setTouch(null);
+					};
+					// trigger pointerup
+				};
+			} else {
+				if (this.touch()) { this.touch().idle() };
+			};
+			return this;
+		};
+		
+		Imba.Pointer.prototype.cleanup = function (){
+			return Imba.POINTERS;
+		};
+		
+		Imba.Pointer.prototype.x = function (){
+			return this.event().x;
+		};
+		Imba.Pointer.prototype.y = function (){
+			return this.event().y;
+		};
+		
+		// deprecated -- should remove
+		Imba.Pointer.update = function (){
+			// console.log('update touch')
+			for (var i = 0, ary = iter$(Imba.POINTERS), len = ary.length; i < len; i++) {
+				ary[i].process();
+			};
+			// need to be able to prevent the default behaviour of touch, no?
+			win.requestAnimationFrame(Imba.Pointer.update);
+			return this;
+		};
+		
+		var lastNativeTouchTimeStamp = 0;
+		var lastNativeTouchTimeout = 50;
+		
+		// Imba.Touch
+		// Began	A finger touched the screen.
+		// Moved	A finger moved on the screen.
+		// Stationary	A finger is touching the screen but hasn't moved.
+		// Ended	A finger was lifted from the screen. This is the final phase of a touch.
+		// Canceled The system cancelled tracking for the touch.
+		
+		/*
+		Consolidates mouse and touch events. Touch objects persist across a touch,
+		from touchstart until end/cancel. When a touch starts, it will traverse
+		down from the innermost target, until it finds a node that responds to
+		ontouchstart. Unless the touch is explicitly redirected, the touch will
+		call ontouchmove and ontouchend / ontouchcancel on the responder when appropriate.
+		
+			tag draggable
+				# called when a touch starts
+				def ontouchstart touch
+					flag 'dragging'
+					self
+				
+				# called when touch moves - same touch object
+				def ontouchmove touch
+					# move the node with touch
+					css top: touch.dy, left: touch.dx
+				
+				# called when touch ends
+				def ontouchend touch
+					unflag 'dragging'
+		
+		@iname touch
+		*/
+		
+		Imba.Touch = function Touch(event,pointer){
+			// @native  = false
+			this.setEvent(event);
+			this.setData({});
+			this.setActive(true);
+			this._button = event && event.button || 0;
+			this._suppress = false; // deprecated
+			this._captured = false;
+			this.setBubble(false);
+			pointer = pointer;
+			this.setUpdates(0);
+			return this;
+		};
+		
+		var touches = [];
+		var count = 0;
+		var identifiers = {};
+		
+		Imba.Touch.count = function (){
+			return count;
+		};
+		
+		Imba.Touch.lookup = function (item){
+			return item && (item.__touch__ || identifiers[item.identifier]);
+		};
+		
+		Imba.Touch.release = function (item,touch){
+			var v_, $1;
+			(((v_ = identifiers[item.identifier]),delete identifiers[item.identifier], v_));
+			((($1 = item.__touch__),delete item.__touch__, $1));
+			return;
+		};
+		
+		Imba.Touch.ontouchstart = function (e){
+			for (var i = 0, ary = iter$(e.changedTouches), len = ary.length, t; i < len; i++) {
+				t = ary[i];
+				if (this.lookup(t)) { continue; };
+				var touch = identifiers[t.identifier] = new this(e); // (e)
+				t.__touch__ = touch;
+				touches.push(touch);
+				count++;
+				touch.touchstart(e,t);
+			};
+			return this;
+		};
+		
+		Imba.Touch.ontouchmove = function (e){
+			var touch;
+			for (var i = 0, ary = iter$(e.changedTouches), len = ary.length, t; i < len; i++) {
+				t = ary[i];
+				if (touch = this.lookup(t)) {
+					touch.touchmove(e,t);
+				};
+			};
+			
+			return this;
+		};
+		
+		Imba.Touch.ontouchend = function (e){
+			var touch;
+			for (var i = 0, ary = iter$(e.changedTouches), len = ary.length, t; i < len; i++) {
+				t = ary[i];
+				if (touch = this.lookup(t)) {
+					touch.touchend(e,t);
+					this.release(t,touch);
+					count--;
+				};
+			};
+			
+			// e.preventDefault
+			// not always supported!
+			// touches = touches.filter(||)
+			return this;
+		};
+		
+		Imba.Touch.ontouchcancel = function (e){
+			var touch;
+			for (var i = 0, ary = iter$(e.changedTouches), len = ary.length, t; i < len; i++) {
+				t = ary[i];
+				if (touch = this.lookup(t)) {
+					touch.touchcancel(e,t);
+					this.release(t,touch);
+					count--;
+				};
+			};
+			return this;
+		};
+		
+		Imba.Touch.onmousedown = function (e){
+			return this;
+		};
+		
+		Imba.Touch.onmousemove = function (e){
+			return this;
+		};
+		
+		Imba.Touch.onmouseup = function (e){
+			return this;
+		};
+		
+		
+		Imba.Touch.prototype.phase = function(v){ return this._phase; }
+		Imba.Touch.prototype.setPhase = function(v){ this._phase = v; return this; };
+		Imba.Touch.prototype.active = function(v){ return this._active; }
+		Imba.Touch.prototype.setActive = function(v){ this._active = v; return this; };
+		Imba.Touch.prototype.event = function(v){ return this._event; }
+		Imba.Touch.prototype.setEvent = function(v){ this._event = v; return this; };
+		Imba.Touch.prototype.pointer = function(v){ return this._pointer; }
+		Imba.Touch.prototype.setPointer = function(v){ this._pointer = v; return this; };
+		Imba.Touch.prototype.target = function(v){ return this._target; }
+		Imba.Touch.prototype.setTarget = function(v){ this._target = v; return this; };
+		Imba.Touch.prototype.handler = function(v){ return this._handler; }
+		Imba.Touch.prototype.setHandler = function(v){ this._handler = v; return this; };
+		Imba.Touch.prototype.updates = function(v){ return this._updates; }
+		Imba.Touch.prototype.setUpdates = function(v){ this._updates = v; return this; };
+		Imba.Touch.prototype.suppress = function(v){ return this._suppress; }
+		Imba.Touch.prototype.setSuppress = function(v){ this._suppress = v; return this; };
+		Imba.Touch.prototype.data = function(v){ return this._data; }
+		Imba.Touch.prototype.setData = function(v){ this._data = v; return this; };
+		Imba.Touch.prototype.__bubble = {chainable: true,name: 'bubble'};
+		Imba.Touch.prototype.bubble = function(v){ return v !== undefined ? (this.setBubble(v),this) : this._bubble; }
+		Imba.Touch.prototype.setBubble = function(v){ this._bubble = v; return this; };
+		
+		Imba.Touch.prototype.gestures = function(v){ return this._gestures; }
+		Imba.Touch.prototype.setGestures = function(v){ this._gestures = v; return this; };
+		
+		/*
+			
+		
+			@internal
+			@constructor
+			*/
+		
+		Imba.Touch.prototype.capture = function (){
+			this._captured = true;
+			this._event && this._event.preventDefault();
+			return this;
+		};
+		
+		Imba.Touch.prototype.isCaptured = function (){
+			return !(!this._captured);
+		};
+		
+		/*
+			Extend the touch with a plugin / gesture. 
+			All events (touchstart,move etc) for the touch
+			will be triggered on the plugins in the order they
+			are added.
+			*/
+		
+		Imba.Touch.prototype.extend = function (plugin){
+			// console.log "added gesture!!!"
+			this._gestures || (this._gestures = []);
+			this._gestures.push(plugin);
+			return this;
+		};
+		
+		/*
+			Redirect touch to specified target. ontouchstart will always be
+			called on the new target.
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.redirect = function (target){
+			this._redirect = target;
+			return this;
+		};
+		
+		/*
+			Suppress the default behaviour. Will call preventDefault for
+			all native events that are part of the touch.
+			*/
+		
+		Imba.Touch.prototype.suppress = function (){
+			// collision with the suppress property
+			this._active = false;
+			return this;
+		};
+		
+		Imba.Touch.prototype.setSuppress = function (value){
+			console.warn('Imba.Touch#suppress= is deprecated');
+			this._supress = value;
+			return this;
+		};
+		
+		Imba.Touch.prototype.touchstart = function (e,t){
+			this._event = e;
+			this._touch = t;
+			this._button = 0;
+			this._x = t.clientX;
+			this._y = t.clientY;
+			this.began();
+			if (e && this.isCaptured()) { e.preventDefault() };
+			return this;
+		};
+		
+		Imba.Touch.prototype.touchmove = function (e,t){
+			this._event = e;
+			this._x = t.clientX;
+			this._y = t.clientY;
+			this.update();
+			if (e && this.isCaptured()) { e.preventDefault() };
+			return this;
+		};
+		
+		Imba.Touch.prototype.touchend = function (e,t){
+			this._event = e;
+			this._x = t.clientX;
+			this._y = t.clientY;
+			this.ended();
+			
+			lastNativeTouchTimeStamp = e.timeStamp;
+			
+			if (this._maxdr < 20) {
+				var tap = new Imba.Event(e);
+				tap.setType('tap');
+				tap.process();
+				if (tap._responder) { e.preventDefault() };
+			};
+			
+			if (e && this.isCaptured()) {
+				e.preventDefault();
+			};
+			
+			return this;
+		};
+		
+		Imba.Touch.prototype.touchcancel = function (e,t){
+			return this.cancel();
+		};
+		
+		Imba.Touch.prototype.mousedown = function (e,t){
+			var self = this;
+			self._event = e;
+			self._button = e.button;
+			self._x = t.clientX;
+			self._y = t.clientY;
+			self.began();
+			
+			self._mousemove = function(e) { return self.mousemove(e,e); };
+			doc.addEventListener('mousemove',self._mousemove,true);
+			return self;
+		};
+		
+		Imba.Touch.prototype.mousemove = function (e,t){
+			this._x = t.clientX;
+			this._y = t.clientY;
+			this._event = e;
+			if (this.isCaptured()) { e.preventDefault() };
+			this.update();
+			this.move();
+			return this;
+		};
+		
+		Imba.Touch.prototype.mouseup = function (e,t){
+			this._x = t.clientX;
+			this._y = t.clientY;
+			this.ended();
+			doc.removeEventListener('mousemove',this._mousemove,true);
+			this._mousemove = null;
+			return this;
+		};
+		
+		Imba.Touch.prototype.idle = function (){
+			return this.update();
+		};
+		
+		Imba.Touch.prototype.began = function (){
+			this._maxdr = this._dr = 0;
+			this._x0 = this._x;
+			this._y0 = this._y;
+			
+			var dom = this.event().target;
+			var node = null;
+			
+			this._sourceTarget = dom && tag$wrap(dom);
+			
+			while (dom){
+				node = tag$wrap(dom);
+				if (node && node.ontouchstart) {
+					this._bubble = false;
+					this.setTarget(node);
+					this.target().ontouchstart(this);
+					if (!this._bubble) { break; };
+				};
+				dom = dom.parentNode;
+			};
+			
+			this._updates++;
+			return this;
+		};
+		
+		Imba.Touch.prototype.update = function (){
+			var target_;
+			if (!this._active) { return this };
+			
+			var dr = Math.sqrt(this.dx() * this.dx() + this.dy() * this.dy());
+			if (dr > this._dr) { this._maxdr = dr };
+			this._dr = dr;
+			
+			// catching a touch-redirect?!?
+			if (this._redirect) {
+				if (this._target && this._target.ontouchcancel) {
+					this._target.ontouchcancel(this);
+				};
+				this.setTarget(this._redirect);
+				this._redirect = null;
+				if (this.target().ontouchstart) { this.target().ontouchstart(this) };
+			};
+			
+			
+			this._updates++;
+			if (this._gestures) {
+				for (var i = 0, ary = iter$(this._gestures), len = ary.length; i < len; i++) {
+					ary[i].ontouchupdate(this);
+				};
+			};
+			
+			(target_ = this.target()) && target_.ontouchupdate  &&  target_.ontouchupdate(this);
+			return this;
+		};
+		
+		Imba.Touch.prototype.move = function (){
+			var target_;
+			if (!this._active) { return this };
+			
+			if (this._gestures) {
+				for (var i = 0, ary = iter$(this._gestures), len = ary.length, g; i < len; i++) {
+					g = ary[i];
+					if (g.ontouchmove) { g.ontouchmove(this,this._event) };
+				};
+			};
+			
+			(target_ = this.target()) && target_.ontouchmove  &&  target_.ontouchmove(this,this._event);
+			return this;
+		};
+		
+		Imba.Touch.prototype.ended = function (){
+			var target_;
+			if (!this._active) { return this };
+			
+			this._updates++;
+			
+			if (this._gestures) {
+				for (var i = 0, ary = iter$(this._gestures), len = ary.length; i < len; i++) {
+					ary[i].ontouchend(this);
+				};
+			};
+			
+			(target_ = this.target()) && target_.ontouchend  &&  target_.ontouchend(this);
+			
+			return this;
+		};
+		
+		Imba.Touch.prototype.cancel = function (){
+			if (!this._cancelled) {
+				this._cancelled = true;
+				this.cancelled();
+				if (this._mousemove) { doc.removeEventListener('mousemove',this._mousemove,true) };
+			};
+			return this;
+		};
+		
+		Imba.Touch.prototype.cancelled = function (){
+			var target_;
+			if (!this._active) { return this };
+			
+			this._cancelled = true;
+			this._updates++;
+			
+			if (this._gestures) {
+				for (var i = 0, ary = iter$(this._gestures), len = ary.length, g; i < len; i++) {
+					g = ary[i];
+					if (g.ontouchcancel) { g.ontouchcancel(this) };
+				};
+			};
+			
+			(target_ = this.target()) && target_.ontouchcancel  &&  target_.ontouchcancel(this);
+			return this;
+		};
+		
+		/*
+			The absolute distance the touch has moved from starting position 
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.dr = function (){
+			return this._dr;
+		};
+		
+		/*
+			The distance the touch has moved horizontally
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.dx = function (){
+			return this._x - this._x0;
+		};
+		
+		/*
+			The distance the touch has moved vertically
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.dy = function (){
+			return this._y - this._y0;
+		};
+		
+		/*
+			Initial horizontal position of touch
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.x0 = function (){
+			return this._x0;
+		};
+		
+		/*
+			Initial vertical position of touch
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.y0 = function (){
+			return this._y0;
+		};
+		
+		/*
+			Horizontal position of touch
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.x = function (){
+			return this._x;
+		};
+		
+		/*
+			Vertical position of touch
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.y = function (){
+			return this._y;
+		};
+		
+		/*
+			Horizontal position of touch relative to target
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.tx = function (){
+			this._targetBox || (this._targetBox = this._target.dom().getBoundingClientRect());
+			return this._x - this._targetBox.left;
+		};
+		
+		/*
+			Vertical position of touch relative to target
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.ty = function (){
+			this._targetBox || (this._targetBox = this._target.dom().getBoundingClientRect());
+			return this._y - this._targetBox.top;
+		};
+		
+		/*
+			Button pressed in this touch. Native touches defaults to left-click (0)
+			@return {Number}
+			*/
+		
+		Imba.Touch.prototype.button = function (){
+			return this._button;
+		}; // @pointer ? @pointer.button : 0
+		
+		Imba.Touch.prototype.sourceTarget = function (){
+			return this._sourceTarget;
+		};
+		
+		
+		Imba.TouchGesture = function TouchGesture(){ };
+		
+		Imba.TouchGesture.prototype.__active = {'default': false,name: 'active'};
+		Imba.TouchGesture.prototype.active = function(v){ return this._active; }
+		Imba.TouchGesture.prototype.setActive = function(v){ this._active = v; return this; }
+		Imba.TouchGesture.prototype._active = false;
+		
+		Imba.TouchGesture.prototype.ontouchstart = function (e){
+			return this;
+		};
+		
+		Imba.TouchGesture.prototype.ontouchupdate = function (e){
+			return this;
+		};
+		
+		Imba.TouchGesture.prototype.ontouchend = function (e){
+			return this;
+		};
+		
+		
+		// A Touch-event is created on mousedown (always)
+		// and while it exists, mousemove and mouseup will
+		// be delegated to this active event.
+		Imba.POINTER = new Imba.Pointer();
+		Imba.POINTERS = [Imba.POINTER];
+		
+		
+		// regular event stuff
+		Imba.KEYMAP = {
+			"8": 'backspace',
+			"9": 'tab',
+			"13": 'enter',
+			"16": 'shift',
+			"17": 'ctrl',
+			"18": 'alt',
+			"19": 'break',
+			"20": 'caps',
+			"27": 'esc',
+			"32": 'space',
+			"35": 'end',
+			"36": 'home',
+			"37": 'larr',
+			"38": 'uarr',
+			"39": 'rarr',
+			"40": 'darr',
+			"45": 'insert',
+			"46": 'delete',
+			"107": 'plus',
+			"106": 'mult',
+			"91": 'meta'
+		};
+		
+		Imba.CHARMAP = {
+			"%": 'modulo',
+			"*": 'multiply',
+			"+": 'add',
+			"-": 'sub',
+			"/": 'divide',
+			".": 'dot'
+		};
+		
+		/*
+		Imba handles all events in the dom through a single manager,
+		listening at the root of your document. If Imba finds a tag
+		that listens to a certain event, the event will be wrapped 
+		in an `Imba.Event`, which normalizes some of the quirks and 
+		browser differences.
+		
+		@iname event
+		*/
+		
+		Imba.Event = function Event(e){
+			this.setEvent(e);
+			this.setBubble(true);
+		};
+		
+		/* reference to the native event */
+		
+		Imba.Event.prototype.event = function(v){ return this._event; }
+		Imba.Event.prototype.setEvent = function(v){ this._event = v; return this; };
+		
+		/* reference to the native event */
+		
+		Imba.Event.prototype.prefix = function(v){ return this._prefix; }
+		Imba.Event.prototype.setPrefix = function(v){ this._prefix = v; return this; };
+		
+		Imba.Event.prototype.data = function(v){ return this._data; }
+		Imba.Event.prototype.setData = function(v){ this._data = v; return this; };
+		
+		/*
+			should remove this alltogether?
+			@deprecated
+			*/
+		
+		Imba.Event.prototype.source = function(v){ return this._source; }
+		Imba.Event.prototype.setSource = function(v){ this._source = v; return this; };
+		
+		/* A {Boolean} indicating whether the event bubbles up or not */
+		
+		Imba.Event.prototype.__bubble = {type: Boolean,chainable: true,name: 'bubble'};
+		Imba.Event.prototype.bubble = function(v){ return v !== undefined ? (this.setBubble(v),this) : this._bubble; }
+		Imba.Event.prototype.setBubble = function(v){ this._bubble = v; return this; };
+		
+		Imba.Event.wrap = function (e){
+			return new this(e);
+		};
+		
+		Imba.Event.prototype.setType = function (type){
+			this._type = type;
+			return this;
+		};
+		
+		/*
+			@return {String} The name of the event (case-insensitive)
+			*/
+		
+		Imba.Event.prototype.type = function (){
+			return this._type || this.event().type;
+		};
+		
+		Imba.Event.prototype.name = function (){
+			return this._name || (this._name = this.type().toLowerCase().replace(/\:/g,''));
+		};
+		
+		// mimc getset
+		Imba.Event.prototype.bubble = function (v){
+			if (v != undefined) {
+				this.setBubble(v);
+				return this;
+			};
+			return this._bubble;
+		};
+		
+		/*
+			Prevents further propagation of the current event.
+			@return {self}
+			*/
+		
+		Imba.Event.prototype.halt = function (){
+			this.setBubble(false);
+			return this;
+		};
+		
+		/*
+			Cancel the event (if cancelable). In the case of native events it
+			will call `preventDefault` on the wrapped event object.
+			@return {self}
+			*/
+		
+		Imba.Event.prototype.cancel = function (){
+			if (this.event().preventDefault) { this.event().preventDefault() };
+			this._cancel = true;
+			return this;
+		};
+		
+		Imba.Event.prototype.silence = function (){
+			this._silenced = true;
+			return this;
+		};
+		
+		Imba.Event.prototype.isSilenced = function (){
+			return !(!this._silenced);
+		};
+		
+		/*
+			Indicates whether or not event.cancel has been called.
+		
+			@return {Boolean}
+			*/
+		
+		Imba.Event.prototype.isPrevented = function (){
+			return this.event() && this.event().defaultPrevented || this._cancel;
+		};
+		
+		/*
+			A reference to the initial target of the event.
+			*/
+		
+		Imba.Event.prototype.target = function (){
+			return tag$wrap(this.event()._target || this.event().target);
+		};
+		
+		/*
+			A reference to the object responding to the event.
+			*/
+		
+		Imba.Event.prototype.responder = function (){
+			return this._responder;
+		};
+		
+		/*
+			Redirect the event to new target
+			*/
+		
+		Imba.Event.prototype.redirect = function (node){
+			this._redirect = node;
+			return this;
+		};
+		
+		/*
+			Get the normalized character for KeyboardEvent/TextEvent
+			@return {String}
+			*/
+		
+		Imba.Event.prototype.keychar = function (){
+			if (this.event() instanceof KeyboardEvent) {
+				var ki = this.event().keyIdentifier;
+				var sym = Imba.KEYMAP[this.event().keyCode];
+				
+				if (!(sym) && ki.substr(0,2) == "U+") {
+					sym = String.fromCharCode(parseInt(ki.substr(2),16));
+				};
+				return sym;
+			} else if (this.event() instanceof (window.TextEvent || window.InputEvent)) {
+				return this.event().data;
+			};
+			
+			return null;
+		};
+		
+		/*
+			@deprecated
+			*/
+		
+		Imba.Event.prototype.keycombo = function (){
+			var sym;
+			if (!(sym = this.keychar())) { return };
+			sym = Imba.CHARMAP[sym] || sym;
+			var combo = [],e = this.event();
+			if (e.ctrlKey) { combo.push('ctrl') };
+			if (e.shiftKey) { combo.push('shift') };
+			if (e.altKey) { combo.push('alt') };
+			if (e.metaKey) { combo.push('cmd') };
+			combo.push(sym);
+			return combo.join("_").toLowerCase();
+		};
+		
+		
+		Imba.Event.prototype.process = function (){
+			var node;
+			var meth = ("on" + (this._prefix || '') + this.name());
+			var args = null;
+			var domtarget = this.event()._target || this.event().target;
+			// var node = <{domtarget:_responder or domtarget}>
+			// need to clean up and document this behaviour
+			
+			var domnode = domtarget._responder || domtarget;
+			// @todo need to stop infinite redirect-rules here
+			
+			var $1;while (domnode){
+				this._redirect = null;
+				if (node = tag$wrap(domnode)) { // not only tag 
+					
+					if ((typeof node[($1 = meth)]=='string'||node[$1] instanceof String)) {
+						// should remember the receiver of the event
+						meth = node[meth];
+						continue; // should not continue?
+					};
+					
+					if (node[meth] instanceof Array) {
+						args = node[meth].concat(node);
+						meth = args.shift();
+						continue; // should not continue?
+					};
+					
+					if (node[meth] instanceof Function) {
+						this._responder || (this._responder = node);
+						// should autostop bubble here?
+						args ? (node[meth].apply(node,args)) : (node[meth](this,this.data()));
+					};
+				};
+				
+				// add node.nextEventResponder as a separate method here?
+				if (!(this.bubble() && (domnode = (this._redirect || (node ? (node.parent()) : (domnode.parentNode)))))) {
+					break;
+				};
+			};
+			
+			this.processed();
+			return this;
+		};
+		
+		
+		Imba.Event.prototype.processed = function (){
+			if (!this._silenced) { Imba.emit(Imba,'event',[this]) };
+			return this;
+		};
+		
+		/*
+			Return the x/left coordinate of the mouse / pointer for this event
+			@return {Number} x coordinate of mouse / pointer for event
+			*/
+		
+		Imba.Event.prototype.x = function (){
+			return this.event().x;
+		};
+		
+		/*
+			Return the y/top coordinate of the mouse / pointer for this event
+			@return {Number} y coordinate of mouse / pointer for event
+			*/
+		
+		Imba.Event.prototype.y = function (){
+			return this.event().y;
+		};
+		
+		/*
+			Returns a Number representing a system and implementation
+			dependent numeric code identifying the unmodified value of the
+			pressed key; this is usually the same as keyCode.
+		
+			For mouse-events, the returned value indicates which button was
+			pressed on the mouse to trigger the event.
+		
+			@return {Number}
+			*/
+		
+		Imba.Event.prototype.which = function (){
+			return this.event().which;
+		};
+		
+		
+		/*
+		
+		Manager for listening to and delegating events in Imba. A single instance
+		is always created by Imba (as `Imba.Events`), which handles and delegates all
+		events at the very root of the document. Imba does not capture all events
+		by default, so if you want to make sure exotic or custom DOMEvents are delegated
+		in Imba you will need to register them in `Imba.Events.register(myCustomEventName)`
+		
+		@iname manager
+		
+		*/
+		
+		Imba.EventManager = function EventManager(node,pars){
+			var self = this;
+			if(!pars||pars.constructor !== Object) pars = {};
+			var events = pars.events !== undefined ? pars.events : [];
+			self.setRoot(node);
+			self.setCount(0);
+			self.setListeners([]);
+			self.setDelegators({});
+			self.setDelegator(function(e) {
+				// console.log "delegating event?! {e}"
+				self.delegate(e);
+				return true;
+			});
+			
+			for (var i = 0, ary = iter$(events), len = ary.length; i < len; i++) {
+				self.register(ary[i]);
+			};
+			
+			return self;
+		};
+		
+		Imba.EventManager.prototype.root = function(v){ return this._root; }
+		Imba.EventManager.prototype.setRoot = function(v){ this._root = v; return this; };
+		Imba.EventManager.prototype.count = function(v){ return this._count; }
+		Imba.EventManager.prototype.setCount = function(v){ this._count = v; return this; };
+		Imba.EventManager.prototype.__enabled = {'default': false,watch: 'enabledDidSet',name: 'enabled'};
+		Imba.EventManager.prototype.enabled = function(v){ return this._enabled; }
+		Imba.EventManager.prototype.setEnabled = function(v){
+			var a = this.enabled();
+			if(v != a) { this._enabled = v; }
+			if(v != a) { this.enabledDidSet && this.enabledDidSet(v,a,this.__enabled) }
+			return this;
+		}
+		Imba.EventManager.prototype._enabled = false;
+		Imba.EventManager.prototype.listeners = function(v){ return this._listeners; }
+		Imba.EventManager.prototype.setListeners = function(v){ this._listeners = v; return this; };
+		Imba.EventManager.prototype.delegators = function(v){ return this._delegators; }
+		Imba.EventManager.prototype.setDelegators = function(v){ this._delegators = v; return this; };
+		Imba.EventManager.prototype.delegator = function(v){ return this._delegator; }
+		Imba.EventManager.prototype.setDelegator = function(v){ this._delegator = v; return this; };
+		
+		Imba.EventManager.prototype.enabledDidSet = function (bool){
+			bool ? (this.onenable()) : (this.ondisable());
+			return this;
+		};
+		
+		/*
+		
+			Tell the current EventManager to intercept and handle event of a certain name.
+			By default, Imba.Events will register interceptors for: *keydown*, *keyup*, 
+			*keypress*, *textInput*, *input*, *change*, *submit*, *focusin*, *focusout*, 
+			*blur*, *contextmenu*, *dblclick*, *mousewheel*, *wheel*
+		
+			*/
+		
+		Imba.EventManager.prototype.register = function (name,handler){
+			if(handler === undefined) handler = true;
+			if (name instanceof Array) {
+				for (var i = 0, ary = iter$(name), len = ary.length; i < len; i++) {
+					this.register(ary[i],handler);
+				};
+				return this;
+			};
+			
+			if (this.delegators()[name]) { return this };
+			// console.log("register for event {name}")
+			var fn = this.delegators()[name] = handler instanceof Function ? (handler) : (this.delegator());
+			if (this.enabled()) { return this.root().addEventListener(name,fn,true) };
+		};
+		
+		Imba.EventManager.prototype.listen = function (name,handler,capture){
+			if(capture === undefined) capture = true;
+			this.listeners().push([name,handler,capture]);
+			if (this.enabled()) { this.root().addEventListener(name,handler,capture) };
+			return this;
+		};
+		
+		Imba.EventManager.prototype.delegate = function (e){
+			this.setCount(this.count() + 1);
+			var event = Imba.Event.wrap(e);
+			event.process();
+			return this;
+		};
+		
+		Imba.EventManager.prototype.create = function (type,target,pars){
+			if(!pars||pars.constructor !== Object) pars = {};
+			var data = pars.data !== undefined ? pars.data : null;
+			var source = pars.source !== undefined ? pars.source : null;
+			var event = Imba.Event.wrap({type: type,target: target});
+			if (data) { (event.setData(data),data) };
+			if (source) { (event.setSource(source),source) };
+			return event;
+		};
+		
+		// use create instead?
+		Imba.EventManager.prototype.trigger = function (){
+			return this.create.apply(this,arguments).process();
+		};
+		
+		Imba.EventManager.prototype.onenable = function (){
+			for (var o = this.delegators(), i = 0, keys = Object.keys(o), l = keys.length; i < l; i++){
+				this.root().addEventListener(keys[i],o[keys[i]],true);
+			};
+			
+			for (var i = 0, ary = iter$(this.listeners()), len = ary.length, item; i < len; i++) {
+				item = ary[i];
+				this.root().addEventListener(item[0],item[1],item[2]);
+			};
+			return this;
+		};
+		
+		Imba.EventManager.prototype.ondisable = function (){
+			for (var o = this.delegators(), i = 0, keys = Object.keys(o), l = keys.length; i < l; i++){
+				this.root().removeEventListener(keys[i],o[keys[i]],true);
+			};
+			
+			for (var i = 0, ary = iter$(this.listeners()), len = ary.length, item; i < len; i++) {
+				item = ary[i];
+				this.root().removeEventListener(item[0],item[1],item[2]);
+			};
+			return this;
+		};
+		
+		
+		ED = Imba.Events = new Imba.EventManager(document,{events: [
+			'keydown','keyup','keypress','textInput','input','change','submit',
+			'focusin','focusout','blur','contextmenu','dblclick',
+			'mousewheel','wheel','scroll'
+		]});
+		
+		// should set these up inside the Imba.Events object itself
+		// so that we can have different EventManager for different roots
+		
+		if (hasTouchEvents) {
+			Imba.Events.listen('touchstart',function(e) {
+				var Events_, v_;
+				(((Events_ = Imba.Events).setCount(v_ = Events_.count() + 1),v_)) - 1;
+				return Imba.Touch.ontouchstart(e);
+			});
+			
+			Imba.Events.listen('touchmove',function(e) {
+				var Events_, v_;
+				(((Events_ = Imba.Events).setCount(v_ = Events_.count() + 1),v_)) - 1;
+				return Imba.Touch.ontouchmove(e);
+			});
+			
+			Imba.Events.listen('touchend',function(e) {
+				var Events_, v_;
+				(((Events_ = Imba.Events).setCount(v_ = Events_.count() + 1),v_)) - 1;
+				return Imba.Touch.ontouchend(e);
+			});
+			
+			Imba.Events.listen('touchcancel',function(e) {
+				var Events_, v_;
+				(((Events_ = Imba.Events).setCount(v_ = Events_.count() + 1),v_)) - 1;
+				return Imba.Touch.ontouchcancel(e);
+			});
+		};
+		
+		Imba.Events.register('click',function(e) {
+			// Only for main mousebutton, no?
+			if ((e.timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout) {
+				var tap = new Imba.Event(e);
+				tap.setType('tap');
+				tap.process();
+				if (tap._responder) {
+					return e.preventDefault();
+				};
+			};
+			// delegate the real click event
+			return Imba.Events.delegate(e);
+		});
+		
+		Imba.Events.listen('mousedown',function(e) {
+			if ((e.timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout) {
+				if (Imba.POINTER) { return Imba.POINTER.update(e).process() };
+			};
+		});
+		
+		// Imba.Events.listen(:mousemove) do |e|
+		// 	# console.log 'mousemove',e:timeStamp
+		// 	if (e:timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout
+		// 		Imba.POINTER.update(e).process if Imba.POINTER # .process if touch # should not happen? We process through 
+		
+		Imba.Events.listen('mouseup',function(e) {
+			// console.log 'mouseup',e:timeStamp
+			if ((e.timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout) {
+				if (Imba.POINTER) { return Imba.POINTER.update(e).process() };
+			};
+		});
+		
+		
+		Imba.Events.register(['mousedown','mouseup']);
+		return (Imba.Events.setEnabled(true),true);
+	
+	})()
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+	(function(){
+		function iter$(a){ return a ? (a.toArray ? a.toArray() : a) : []; };
+		var ImbaTag = Imba.TAGS.element;
+		
+		function removeNested(root,node,caret){
+			// if node/nodes isa String
+			// 	we need to use the caret to remove elements
+			// 	for now we will simply not support this
+			if (node instanceof ImbaTag) {
+				root.removeChild(node);
+			} else if (node instanceof Array) {
+				for (var i = 0, ary = iter$(node), len = ary.length; i < len; i++) {
+					removeNested(root,ary[i],caret);
+				};
+			} else {
+				// what if this is not null?!?!?
+				// take a chance and remove a text-elementng
+				var next = caret ? (caret.nextSibling) : (root._dom.firstChild);
+				if ((next instanceof Text) && next.textContent == node) {
+					root.removeChild(next);
+				} else {
+					throw 'cannot remove string';
+				};
+			};
+			
+			return caret;
+		};
+		
+		function appendNested(root,node){
+			if (node instanceof ImbaTag) {
+				root.appendChild(node);
+			} else if (node instanceof Array) {
+				for (var i = 0, ary = iter$(node), len = ary.length; i < len; i++) {
+					appendNested(root,ary[i]);
+				};
+			} else if (node != null && node !== false) {
+				root.appendChild(Imba.document().createTextNode(node));
+			};
+			
+			return;
+		};
+		
+		
+		// insert nodes before a certain node
+		// does not need to return any tail, as before
+		// will still be correct there
+		// before must be an actual domnode
+		function insertNestedBefore(root,node,before){
+			if (node instanceof ImbaTag) {
+				root.insertBefore(node,before);
+			} else if (node instanceof Array) {
+				for (var i = 0, ary = iter$(node), len = ary.length; i < len; i++) {
+					insertNestedBefore(root,ary[i],before);
+				};
+			} else if (node != null && node !== false) {
+				root.insertBefore(Imba.document().createTextNode(node),before);
+			};
+			
+			return before;
+		};
+		
+		// after must be an actual domnode
+		function insertNestedAfter(root,node,after){
+			var before = after ? (after.nextSibling) : (root._dom.firstChild);
+			
+			if (before) {
+				insertNestedBefore(root,node,before);
+				return before.previousSibling;
+			} else {
+				appendNested(root,node);
+				return root._dom.lastChild;
+			};
+		};
+		
+		function reconcileCollectionChanges(root,new$,old,caret){
+			
+			var newLen = new$.length;
+			var lastNew = new$[newLen - 1];
+			
+			// This re-order algorithm is based on the following principle:
+			// 
+			// We build a "chain" which shows which items are already sorted.
+			// If we're going from [1, 2, 3] -> [2, 1, 3], the tree looks like:
+			//
+			// 	3 ->  0 (idx)
+			// 	2 -> -1 (idx)
+			// 	1 -> -1 (idx)
+			//
+			// This tells us that we have two chains of ordered items:
+			// 
+			// 	(1, 3) and (2)
+			// 
+			// The optimal re-ordering then becomes two keep the longest chain intact,
+			// and move all the other items.
+			
+			var newPosition = [];
+			
+			// The tree/graph itself
+			var prevChain = [];
+			// The length of the chain
+			var lengthChain = [];
+			
+			// Keep track of the longest chain
+			var maxChainLength = 0;
+			var maxChainEnd = 0;
+			
+			for (var idx = 0, ary = iter$(old), len = ary.length, node; idx < len; idx++) {
+				node = ary[idx];
+				var newPos = new$.indexOf(node);
+				newPosition.push(newPos);
+				
+				if (newPos == -1) {
+					root.removeChild(node);
+					prevChain.push(-1);
+					lengthChain.push(-1);
+					continue;
+				};
+				
+				var prevIdx = newPosition.length - 2;
+				
+				// Build the chain:
+				while (prevIdx >= 0){
+					if (newPosition[prevIdx] == -1) {
+						prevIdx--;
+					} else if (newPos > newPosition[prevIdx]) {
+						// Yay, we're bigger than the previous!
+						break;
+					} else {
+						// Nope, let's walk back the chain
+						prevIdx = prevChain[prevIdx];
+					};
+				};
+				
+				prevChain.push(prevIdx);
+				
+				var currLength = (prevIdx == -1) ? (0) : (lengthChain[prevIdx] + 1);
+				
+				if (currLength > maxChainLength) {
+					maxChainLength = currLength;
+					maxChainEnd = idx;
+				};
+				
+				lengthChain.push(currLength);
+			};
+			
+			var stickyNodes = [];
+			
+			// Now we can walk the longest chain backwards and mark them as "sticky",
+			// which implies that they should not be moved
+			var cursor = newPosition.length - 1;
+			while (cursor >= 0){
+				if (cursor == maxChainEnd && newPosition[cursor] != -1) {
+					stickyNodes[newPosition[cursor]] = true;
+					maxChainEnd = prevChain[maxChainEnd];
+				};
+				
+				cursor -= 1;
+			};
+			
+			// And let's iterate forward, but only move non-sticky nodes
+			for (var idx1 = 0, ary = iter$(new$), len = ary.length; idx1 < len; idx1++) {
+				if (!stickyNodes[idx1]) {
+					var after = new$[idx1 - 1];
+					insertNestedAfter(root,ary[idx1],(after && after._dom) || caret);
+				};
+			};
+			
+			// should trust that the last item in new list is the caret
+			return lastNew && lastNew._dom || caret;
+		};
+		
+		
+		// expects a flat non-sparse array of nodes in both new and old, always
+		function reconcileCollection(root,new$,old,caret){
+			var k = new$.length;
+			var i = k;
+			var last = new$[k - 1];
+			
+			
+			if (k == old.length && new$[0] === old[0]) {
+				// running through to compare
+				while (i--){
+					if (new$[i] !== old[i]) { break; };
+				};
+			};
+			
+			if (i == -1) {
+				return last && last._dom || caret;
+			} else {
+				return reconcileCollectionChanges(root,new$,old,caret);
+			};
+		};
+		
+		// the general reconciler that respects conditions etc
+		// caret is the current node we want to insert things after
+		function reconcileNested(root,new$,old,caret){
+			
+			// if new == null or new === false or new === true
+			// 	if new === old
+			// 		return caret
+			// 	if old && new != old
+			// 		removeNested(root,old,caret) if old
+			// 
+			// 	return caret
+			
+			// var skipnew = new == null or new === false or new === true
+			var newIsNull = new$ == null || new$ === false;
+			var oldIsNull = old == null || old === false;
+			
+			
+			if (new$ === old) {
+				// remember that the caret must be an actual dom element
+				// we should instead move the actual caret? - trust
+				if (newIsNull) {
+					return caret;
+				} else if (new$ && new$._dom) {
+					return new$._dom;
+				} else {
+					return caret ? (caret.nextSibling) : (root._dom.firstChild);
+				};
+			} else if (new$ instanceof Array) {
+				if (old instanceof Array) {
+					if (new$.static || old.static) {
+						// if the static is not nested - we could get a hint from compiler
+						// and just skip it
+						if (new$.static == old.static) {
+							for (var i = 0, ary = iter$(new$), len = ary.length; i < len; i++) {
+								// this is where we could do the triple equal directly
+								caret = reconcileNested(root,ary[i],old[i],caret);
+							};
+							return caret;
+						} else {
+							removeNested(root,old,caret);
+						};
+						
+						// if they are not the same we continue through to the default
+					} else {
+						return reconcileCollection(root,new$,old,caret);
+					};
+				} else if (old instanceof ImbaTag) {
+					root.removeChild(old);
+				} else if (!(oldIsNull)) {
+					// old was a string-like object?
+					root.removeChild(caret ? (caret.nextSibling) : (root._dom.firstChild));
+				};
+				
+				return insertNestedAfter(root,new$,caret);
+				// remove old
+			} else if (new$ instanceof ImbaTag) {
+				if (!(oldIsNull)) { removeNested(root,old,caret) };
+				insertNestedAfter(root,new$,caret);
+				return new$;
+			} else if (newIsNull) {
+				if (!(oldIsNull)) { removeNested(root,old,caret) };
+				return caret;
+			} else {
+				// if old did not exist we need to add a new directly
+				var nextNode;
+				// if old was array or imbatag we need to remove it and then add
+				if (old instanceof Array) {
+					removeNested(root,old,caret);
+				} else if (old instanceof ImbaTag) {
+					root.removeChild(old);
+				} else if (!(oldIsNull)) {
+					// ...
+					nextNode = caret ? (caret.nextSibling) : (root._dom.firstChild);
+					if ((nextNode instanceof Text) && nextNode.textContent != new$) {
+						nextNode.textContent = new$;
+						return nextNode;
+					};
+				};
+				
+				// now add the textnode
+				return insertNestedAfter(root,new$,caret);
+			};
+		};
+		
+		
+		return tag$.extendTag('htmlelement', function(tag){
+			
+			tag.prototype.setChildren = function (new$,typ){
+				var old = this._children;
+				// var isArray = nodes isa Array
+				if (new$ === old) {
+					return this;
+				};
+				
+				if (!(old)) {
+					this.empty();
+					appendNested(this,new$);
+				} else if (typ == 2) {
+					return this;
+				} else if (typ == 1) {
+					// here we _know _that it is an array with the same shape
+					// every time
+					var caret = null;
+					for (var i = 0, ary = iter$(new$), len = ary.length; i < len; i++) {
+						// prev = old[i]
+						caret = reconcileNested(this,ary[i],old[i],caret);
+					};
+				} else if (typ == 3) {
+					// this is possibly fully dynamic. It often is
+					// but the old or new could be static while the other is not
+					// this is not handled now
+					// what if it was previously a static array? edgecase - but must work
+					if (new$ instanceof ImbaTag) {
+						this.empty();
+						this.appendChild(new$);
+					} else if (new$ instanceof Array) {
+						if (old instanceof Array) {
+							// is this not the same as setting staticChildren now but with the
+							reconcileCollection(this,new$,old,null);
+						} else {
+							this.empty();
+							appendNested(this,new$);
+						};
+					} else {
+						this.setText(new$);
+						return this;
+					};
+				} else if ((new$ instanceof Array) && (old instanceof Array)) {
+					reconcileCollection(this,new$,old,null);
+				} else {
+					this.empty();
+					appendNested(this,new$);
+				};
+				
+				this._children = new$;
+				return this;
+			};
+			
+			
+			// only ever called with array as argument
+			tag.prototype.setStaticChildren = function (new$){
+				var old = this._children;
+				
+				var caret = null;
+				for (var i = 0, ary = iter$(new$), len = ary.length; i < len; i++) {
+					// prev = old[i]
+					caret = reconcileNested(this,ary[i],old[i],caret);
+				};
+				
+				this._children = new$;
+				return this;
+			};
+			
+			tag.prototype.content = function (){
+				return this._content || this.children().toArray();
+			};
+			
+			tag.prototype.setText = function (text){
+				if (text != this._children) {
+					this._children = text;
+					this.dom().textContent = text == null || text === false ? ('') : (text);
+				};
+				return this;
+			};
+		});
+
+	})()
+
+/***/ },
+/* 11 */
+/***/ function(module, exports) {
+
+	(function(){
+		function iter$(a){ return a ? (a.toArray ? a.toArray() : a) : []; };
+		
+		/*
+		The special syntax for selectors in Imba creates Imba.Selector
+		instances.
+		*/
+		
+		Imba.Selector = function Selector(sel,scope,nodes){
+			
+			this._query = sel instanceof Imba.Selector ? (sel.query()) : (sel);
+			this._context = scope;
+			
+			if (nodes) {
+				for (var i = 0, ary = iter$(nodes), len = ary.length, res = []; i < len; i++) {
+					res.push(tag$wrap(ary[i]));
+				};
+				this._nodes = res;
+			};
+			
+			this._lazy = !(nodes);
+			return this;
+		};
+		
+		Imba.Selector.one = function (sel,scope){
+			var el = (scope || Imba.document()).querySelector(sel);
+			return el && tag$wrap(el) || null;
+		};
+		
+		Imba.Selector.all = function (sel,scope){
+			return new Imba.Selector(sel,scope);
+		};
+		
+		Imba.Selector.prototype.query = function(v){ return this._query; }
+		Imba.Selector.prototype.setQuery = function(v){ this._query = v; return this; };
+		
+		Imba.Selector.prototype.reload = function (){
+			this._nodes = null;
+			return this;
+		};
+		
+		Imba.Selector.prototype.scope = function (){
+			var ctx;
+			if (this._scope) { return this._scope };
+			if (!(ctx = this._context)) { return Imba.document() };
+			return this._scope = ctx.toScope ? (ctx.toScope()) : (ctx);
+		};
+		
+		/*
+			@returns {Imba.Tag} first node matching this selector
+			*/
+		
+		Imba.Selector.prototype.first = function (){
+			if (this._lazy) { return tag$wrap(this._first || (this._first = this.scope().querySelector(this.query()))) } else {
+				return this.nodes()[0];
+			};
+		};
+		
+		/*
+			@returns {Imba.Tag} last node matching this selector
+			*/
+		
+		Imba.Selector.prototype.last = function (){
+			return this.nodes()[this._nodes.length - 1];
+		};
+		
+		/*
+			@returns [Imba.Tag] all nodes matching this selector
+			*/
+		
+		Imba.Selector.prototype.nodes = function (){
+			if (this._nodes) { return this._nodes };
+			var items = this.scope().querySelectorAll(this.query());
+			for (var i = 0, ary = iter$(items), len = ary.length, res = []; i < len; i++) {
+				res.push(tag$wrap(ary[i]));
+			};
+			this._nodes = res;
+			this._lazy = false;
+			return this._nodes;
+		};
+		
+		/*
+			The number of nodes matching this selector
+			*/
+		
+		Imba.Selector.prototype.count = function (){
+			return this.nodes().length;
+		};
+		
+		Imba.Selector.prototype.len = function (){
+			return this.nodes().length;
+		};
+		
+		/*
+			@todo Add support for block or selector?
+			*/
+		
+		Imba.Selector.prototype.some = function (){
+			return this.count() >= 1;
+		};
+		
+		/*
+			Get node at index
+			*/
+		
+		Imba.Selector.prototype.at = function (idx){
+			return this.nodes()[idx];
+		};
+		
+		/*
+			Loop through nodes
+			*/
+		
+		Imba.Selector.prototype.forEach = function (block){
+			this.nodes().forEach(block);
+			return this;
+		};
+		
+		/*
+			Map nodes
+			*/
+		
+		Imba.Selector.prototype.map = function (block){
+			return this.nodes().map(block);
+		};
+		
+		/*
+			Returns a plain array containing nodes. Implicitly called
+			when iterating over a selector in Imba `(node for node in $(selector))`
+			*/
+		
+		Imba.Selector.prototype.toArray = function (){
+			return this.nodes();
+		};
+		
+		// Get the first element that matches the selector, 
+		// beginning at the current element and progressing up through the DOM tree
+		Imba.Selector.prototype.closest = function (sel){
+			// seems strange that we alter this selector?
+			this._nodes = this.map(function(node) { return node.closest(sel); });
+			return this;
+		};
+		
+		// Get the siblings of each element in the set of matched elements, 
+		// optionally filtered by a selector.
+		// TODO remove duplicates?
+		Imba.Selector.prototype.siblings = function (sel){
+			this._nodes = this.map(function(node) { return node.siblings(sel); });
+			return this;
+		};
+		
+		// Get the descendants of each element in the current set of matched 
+		// elements, filtered by a selector.
+		Imba.Selector.prototype.find = function (sel){
+			this._nodes = this.__query__(sel.query(),this.nodes());
+			return this;
+		};
+		
+		Imba.Selector.prototype.reject = function (blk){
+			return this.filter(blk,false);
+		};
+		
+		/*
+			Filter the nodes in selector by a function or other selector
+			*/
+		
+		Imba.Selector.prototype.filter = function (blk,bool){
+			if(bool === undefined) bool = true;
+			var fn = (blk instanceof Function) && blk || function(n) { return n.matches(blk); };
+			var ary = this.nodes().filter(function(n) { return fn(n) == bool; });
+			// if we want to return a new selector for this, we should do that for
+			// others as well
+			return new Imba.Selector("",this._scope,ary);
+		};
+		
+		Imba.Selector.prototype.__query__ = function (query,contexts){
+			var nodes = [];
+			var i = 0;
+			var l = contexts.length;
+			
+			while (i < l){
+				nodes.push.apply(nodes,contexts[i++].querySelectorAll(query));
+			};
+			return nodes;
+		};
+		
+		Imba.Selector.prototype.__matches__ = function (){
+			return true;
+		};
+		
+		/*
+			Add specified flag to all nodes in selector
+			*/
+		
+		Imba.Selector.prototype.flag = function (flag){
+			return this.forEach(function(n) { return n.flag(flag); });
+		};
+		
+		/*
+			Remove specified flag from all nodes in selector
+			*/
+		
+		Imba.Selector.prototype.unflag = function (flag){
+			return this.forEach(function(n) { return n.unflag(flag); });
+		};
+		
+		
+		// def Imba.querySelectorAll
+		q$ = function(sel,scope) { return new Imba.Selector(sel,scope); };
+		
+		// def Imba.Selector.one
+		q$$ = function(sel,scope) {
+			var el = (scope || Imba.document()).querySelector(sel);
+			return el && tag$wrap(el) || null;
+		};
+		
+		
+		// extending tags with query-methods
+		// must be a better way to reopen classes
+		return tag$.extendTag('element', function(tag){
+			tag.prototype.querySelectorAll = function (q){
+				return this._dom.querySelectorAll(q);
+			};
+			tag.prototype.querySelector = function (q){
+				return this._dom.querySelector(q);
+			};
+			
+			// should be moved to Imba.Tag instead?
+			// or we should implement all of them here
+			tag.prototype.find = function (sel){
+				return new Imba.Selector(sel,this);
+			};
+		});
+		
+
+	})()
+
+/***/ }
+/******/ ]);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["webpack:///webpack/bootstrap bcf40a5c334ac2197531","webpack:///src/imba/index.imba","webpack:///src/imba/imba.imba","webpack:///src/imba/core.events.imba","webpack:///src/imba/scheduler.imba","webpack:///src/imba/tag.imba","webpack:///src/imba/dom.imba","webpack:///src/imba/dom.html.imba","webpack:///src/imba/dom.svg.imba","webpack:///src/imba/dom.client.imba","webpack:///src/imba/dom.events.imba","webpack:///src/imba/dom.static.imba","webpack:///src/imba/selector.imba"],"names":[],"mappings":"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","file":"./dist/imba.dev.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap bcf40a5c334ac2197531\n **/","\nif typeof Imba === 'undefined'\n\trequire './imba'\n\trequire './core.events'\n\trequire './scheduler'\n\trequire './tag'\n\trequire './dom'\n\trequire './dom.html'\n\trequire './dom.svg'\n\n\tif Imba.SERVER\n\t\trequire './dom.server'\n\t\n\tif Imba.CLIENT\n\t\trequire './dom.client'\n\t\trequire './dom.events'\n\t\trequire './dom.static'\n\n\trequire './selector'\nelse\n\tconsole.warn \"Imba v{Imba.VERSION} is already loaded\"\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/index.imba\n **/","if typeof window !== 'undefined'\n\t# should not go there\n\tglobal = window\n\nvar isClient = (typeof window == 'object' and this == window)\n###\nImba is the namespace for all runtime related utilities\n@namespace\n###\nImba = {\n\tVERSION: '0.14.3'\n\tCLIENT: isClient\n\tSERVER: !isClient\n\tDEBUG: no\n}\n\nvar reg = /-./g\n\n###\nTrue if running in client environment.\n@return {bool}\n###\ndef Imba.isClient\n\tImba.CLIENT == yes\n\n###\nTrue if running in server environment.\n@return {bool}\n###\ndef Imba.isServer\n\tImba.SERVER == yes\n\ndef Imba.subclass obj, sup\n\tfor k,v of sup\n\t\tobj[k] = v if sup.hasOwnProperty(k)\n\n\tobj:prototype = Object.create(sup:prototype)\n\tobj:__super__ = obj:prototype:__super__ = sup:prototype\n\tobj:prototype:initialize = obj:prototype:constructor = obj\n\treturn obj\n\n###\nLightweight method for making an object iterable in imbas for/in loops.\nIf the compiler cannot say for certain that a target in a for loop is an\narray, it will cache the iterable version before looping.\n\n```imba\n# this is the whole method\ndef Imba.iterable o\n\treturn o ? (o:toArray ? o.toArray : o) : []\n\nclass CustomIterable\n\tdef toArray\n\t\t[1,2,3]\n\n# will return [2,4,6]\nfor x in CustomIterable.new\n\tx * 2\n\n```\n###\ndef Imba.iterable o\n\treturn o ? (o:toArray ? o.toArray : o) : []\n\n###\nCoerces a value into a promise. If value is array it will\ncall `Promise.all(value)`, or if it is not a promise it will\nwrap the value in `Promise.resolve(value)`. Used for experimental\nawait syntax.\n@return {Promise}\n###\ndef Imba.await value\n\tif value isa Array\n\t\tPromise.all(value)\n\telif value and value:then\n\t\tvalue\n\telse\n\t\tPromise.resolve(value)\n\ndef Imba.toCamelCase str\n\tstr.replace(reg) do |m| m.charAt(1).toUpperCase\n\ndef Imba.toCamelCase str\n\tstr.replace(reg) do |m| m.charAt(1).toUpperCase\n\ndef Imba.indexOf a,b\n\treturn (b && b:indexOf) ? b.indexOf(a) : []:indexOf.call(a,b)\n\ndef Imba.prop scope, name, opts\n\tif scope:defineProperty\n\t\treturn scope.defineProperty(name,opts)\n\treturn\n\ndef Imba.attr scope, name, opts\n\tif scope:defineAttribute\n\t\treturn scope.defineAttribute(name,opts)\n\n\tlet getName = Imba.toCamelCase(name)\n\tlet setName = Imba.toCamelCase('set-' + name)\n\n\tscope:prototype[getName] = do\n\t\treturn this.getAttribute(name)\n\n\tscope:prototype[setName] = do |value|\n\t\tthis.setAttribute(name,value)\n\t\treturn this\n\n\treturn\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/imba.imba\n **/","\n\ndef emit__ event, args, node\n\t# var node = cbs[event]\n\tvar prev, cb, ret\n\n\twhile (prev = node) and (node = node:next)\n\t\tif cb = node:listener\n\t\t\tif node:path and cb[node:path]\n\t\t\t\tret = args ? cb[node:path].apply(cb,args) : cb[node:path]()\n\t\t\telse\n\t\t\t\t# check if it is a method?\n\t\t\t\tret = args ? cb.apply(node, args) : cb.call(node)\n\n\t\tif node:times && --node:times <= 0\n\t\t\tprev:next = node:next\n\t\t\tnode:listener = null\n\treturn\n\n# method for registering a listener on object\ndef Imba.listen obj, event, listener, path\n\tvar cbs, list, tail\n\tcbs = obj:__listeners__ ||= {}\n\tlist = cbs[event] ||= {}\n\ttail = list:tail || (list:tail = (list:next = {}))\n\ttail:listener = listener\n\ttail:path = path\n\tlist:tail = tail:next = {}\n\treturn tail\n\ndef Imba.once obj, event, listener\n\tvar tail = Imba.listen(obj,event,listener)\n\ttail:times = 1\n\treturn tail\n\ndef Imba.unlisten obj, event, cb, meth\n\tvar node, prev\n\tvar meta = obj:__listeners__\n\treturn unless meta\n\n\tif node = meta[event]\n\t\twhile (prev = node) and (node = node:next)\n\t\t\tif node == cb || node:listener == cb\n\t\t\t\tprev:next = node:next\n\t\t\t\t# check for correct path as well?\n\t\t\t\tnode:listener = null\n\t\t\t\tbreak\n\treturn\n\ndef Imba.emit obj, event, params\n\tif var cb = obj:__listeners__\n\t\temit__(event,params,cb[event]) if cb[event]\n\t\temit__(event,[event,params],cb:all) if cb:all # and event != 'all'\n\treturn\n\ndef Imba.observeProperty observer, key, trigger, target, prev\n\tif prev and typeof prev == 'object'\n\t\tImba.unlisten(prev,'all',observer,trigger)\n\tif target and typeof target == 'object'\n\t\tImba.listen(target,'all',observer,trigger)\n\tself\n\n\n/** WEBPACK FOOTER **\n ** src/imba/core.events.imba\n **/","\nvar raf # very simple raf polyfill\nraf ||= global:requestAnimationFrame\nraf ||= global:webkitRequestAnimationFrame\nraf ||= global:mozRequestAnimationFrame\nraf ||= do |blk| setTimeout(blk,1000 / 60)\n\ndef Imba.tick d\n\traf(Imba.ticker) if @scheduled\n\tImba.Scheduler.willRun\n\temit(self,'tick',[d])\n\tImba.Scheduler.didRun\n\treturn\n\ndef Imba.ticker\n\t@ticker ||= do |e| tick(e)\n\n###\n\nGlobal alternative to requestAnimationFrame. Schedule a target\nto tick every frame. You can specify which method to call on the\ntarget (defaults to tick).\n\n###\ndef Imba.schedule target, method = 'tick'\n\tlisten(self,'tick',target,method)\n\t# start scheduling now if this was the first one\n\tunless @scheduled\n\t\t@scheduled = yes\n\t\traf(Imba.ticker)\n\tself\n\n###\n\nUnschedule a previously scheduled target\n\n###\ndef Imba.unschedule target, method\n\tunlisten(self,'tick',target,method)\n\tvar cbs = self:__listeners__ ||= {}\n\tif !cbs:tick or !cbs:tick:next or !cbs:tick:next:listener\n\t\t@scheduled = no\n\tself\n\n###\n\nLight wrapper around native setTimeout that expects the block / function\nas last argument (instead of first). It also triggers an event to Imba\nafter the timeout to let schedulers update (to rerender etc) afterwards.\n\n###\ndef Imba.setTimeout delay, &block\n\tsetTimeout(&,delay) do\n\t\tblock()\n\t\tImba.Scheduler.markDirty\n\t\t# Imba.emit(Imba,'timeout',[block])\n\n###\n\nLight wrapper around native setInterval that expects the block / function\nas last argument (instead of first). It also triggers an event to Imba\nafter every interval to let schedulers update (to rerender etc) afterwards.\n\n###\ndef Imba.setInterval interval, &block\n\tsetInterval(&,interval) do\n\t\tblock()\n\t\tImba.Scheduler.markDirty\n\t\t# Imba.emit(Imba,'interval',[block])\n\n###\nClear interval with specified id\n###\ndef Imba.clearInterval interval\n\tclearInterval(interval)\n\n###\nClear timeout with specified id\n###\ndef Imba.clearTimeout timeout\n\tclearTimeout(timeout)\n\n# should add an Imba.run / setImmediate that\n# pushes listener onto the tick-queue with times - once\n\n\n###\n\nInstances of Imba.Scheduler manages when to call `tick()` on their target,\nat a specified framerate or when certain events occur. Root-nodes in your\napplications will usually have a scheduler to make sure they rerender when\nsomething changes. It is also possible to make inner components use their\nown schedulers to control when they render.\n\n@iname scheduler\n\n###\nclass Imba.Scheduler\n\n\tdef self.markDirty\n\t\t@dirty = yes\n\t\tself\n\n\tdef self.isDirty\n\t\t!!@dirty\n\n\tdef self.willRun\n\t\t@active = yes\n\n\tdef self.didRun\n\t\t@active = no\n\t\t@dirty = no\n\n\tdef self.isActive\n\t\t!!@active\n\n\t###\n\tCreate a new Imba.Scheduler for specified target\n\t@return {Imba.Scheduler}\n\t###\n\tdef initialize target\n\t\t@target = target\n\t\t@marked = no\n\t\t@active = no\n\t\t@marker = do mark\n\t\t@ticker = do |e| tick(e)\n\t\t\n\t\t@events = yes\n\t\t@fps = 1\n\n\t\t@dt = 0\n\t\t@timestamp = 0\n\t\t@ticks = 0\n\t\t@flushes = 0\n\n\t###\n\tCheck whether the current scheduler is active or not\n\t@return {bool}\n\t###\n\tdef active\n\t\t@active\n\n\t###\n\tDelta time between the two last ticks\n\t@return {Number}\n\t###\n\tdef dt\n\t\t@dt\n\n\t###\n\tConfigure the scheduler\n\t@return {self}\n\t###\n\tdef configure fps: 1, events: yes\n\t\t@events = events if events != null\n\t\t@fps = fps if fps != null\n\t\tself\n\n\t###\n\tMark the scheduler as dirty. This will make sure that\n\tthe scheduler calls `target.tick` on the next frame\n\t@return {self}\n\t###\n\tdef mark\n\t\t@marked = yes\n\t\tself\n\n\t###\n\tInstantly trigger target.tick and mark scheduler as clean (not dirty/marked).\n\tThis is called implicitly from tick, but can also be called manually if you\n\treally want to force a tick without waiting for the next frame.\n\t@return {self}\n\t###\n\tdef flush\n\t\t@marked = no\n\t\t@flushes++\n\t\t@target.tick\n\t\tself\n\n\t###\n\t@fixme this expects raf to run at 60 fps \n\n\tCalled automatically on every frame while the scheduler is active.\n\tIt will only call `target.tick` if the scheduler is marked dirty,\n\tor when according to @fps setting.\n\n\tIf you have set up a scheduler with an fps of 1, tick will still be\n\tcalled every frame, but `target.tick` will only be called once every\n\tsecond, and it will *make sure* each `target.tick` happens in separate\n\tseconds according to Date. So if you have a node that renders a clock\n\tbased on Date.now (or something similar), you can schedule it with 1fps,\n\tnever needing to worry about two ticks happening within the same second.\n\tThe same goes for 4fps, 10fps etc.\n\n\t@protected\n\t@return {self}\n\t###\n\tdef tick delta\n\t\t@ticks++\n\t\t@dt = delta\n\n\t\tlet fps = @fps\n\t\t\n\t\tif fps == 60\n\t\t\t@marked = yes\n\t\telif fps == 30\n\t\t\t@marked = yes if @ticks % 2\n\t\telif fps\n\t\t\t# if it is less round - we trigger based\n\t\t\t# on date, for consistent rendering.\n\t\t\t# ie, if you want to render every second\n\t\t\t# it is important that no two renders\n\t\t\t# happen during the same second (according to Date)\n\t\t\tlet period = ((60 / fps) / 60) * 1000\n\t\t\tlet beat = Math.floor(Date.now / period)\n\n\t\t\tif @beat != beat\n\t\t\t\t@beat = beat\n\t\t\t\t@marked = yes\n\n\t\tflush if @marked or (@events and Imba.Scheduler.isDirty)\n\t\t# reschedule if @active\n\t\tself\n\n\t###\n\tStart the scheduler if it is not already active.\n\t**While active**, the scheduler will override `target.commit`\n\tto do nothing. By default Imba.tag#commit calls render, so\n\tthat rendering is cascaded through to children when rendering\n\ta node. When a scheduler is active (for a node), Imba disables\n\tthis automatic rendering.\n\t###\n\tdef activate\n\t\tunless @active\n\t\t\t@active = yes\n\t\t\t# override target#commit while this is active\n\t\t\t@commit = @target:commit\n\t\t\t@target:commit = do this\n\t\t\tImba.schedule(self)\n\t\t\tImba.listen(Imba,'event',self,'onevent') if @events\n\t\t\t@target?.flag('scheduled_')\n\t\t\ttick(0) # start ticking\n\t\treturn self\n\n\t###\n\tStop the scheduler if it is active.\n\t###\n\tdef deactivate\n\t\tif @active\n\t\t\t@active = no\n\t\t\t@target:commit = @commit\n\t\t\tImba.unschedule(self)\n\t\t\tImba.unlisten(Imba,'event',self)\n\t\t\t@target?.unflag('scheduled_')\n\t\treturn self\n\n\tdef track\n\t\t@marker\n\n\tdef onevent event\n\t\treturn self if @marked\n\n\t\tif @events isa Function\n\t\t\tmark if @events(event)\t\n\t\telif @events isa Array\n\t\t\tmark if event?.type in @events\n\t\telif @events\n\t\t\tmark if event.@responder\n\t\tself\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/scheduler.imba\n **/","def Imba.static items, nr\n\titems:static = nr\n\treturn items\n\n###\nThis is the baseclass that all tags in imba inherit from.\n@iname node\n###\nclass Imba.Tag\n\n\tdef self.createNode\n\t\tthrow \"Not implemented\"\n\n\tdef self.build\n\t\tself.new(self.createNode)\n\n\tprop object\n\n\tdef dom\n\t\t@dom\n\n\tdef initialize dom\n\t\tself.dom = dom\n\t\t\n\tdef setDom dom\n\t\tdom.@tag = self\n\t\t@dom = dom\n\t\tself\n\n\t###\n\tSetting references for tags like\n\t`<div@header>` will compile to `tag('div').setRef('header',this).end()`\n\tBy default it adds the reference as a className to the tag.\n\t@return {self}\n\t###\n\tdef setRef ref, ctx\n\t\tflag(@ref = ref)\n\t\tself\n\n\t###\n\tMethod that is called by the compiled tag-chains, for\n\tbinding events on tags to methods etc.\n\t`<a :tap=fn>` compiles to `tag('a').setHandler('tap',fn,this).end()`\n\twhere this refers to the context in which the tag is created.\n\t@return {self}\n\t###\n\tdef setHandler event, handler, ctx\n\t\tvar key = 'on' + event\n\n\t\tif handler isa Function\n\t\t\tself[key] = handler\n\t\telif handler isa Array\n\t\t\tvar fn = handler.shift\n\t\t\tself[key] = do |e| ctx[fn].apply(ctx,handler.concat(e))\n\t\telse\n\t\t\tself[key] = do |e| ctx[handler](e)\n\t\tself\n\n\tdef id= id\n\t\tdom:id = id\n\t\tself\n\n\tdef id\n\t\tdom:id\n\n\t###\n\tAdds a new attribute or changes the value of an existing attribute\n\ton the specified tag. If the value is null or false, the attribute\n\twill be removed.\n\t@return {self}\n\t###\n\tdef setAttribute name, value\n\t\t# should this not return self?\n\t\tvar old = dom.getAttribute(name)\n\n\t\tif old == value\n\t\t\tvalue\n\t\telif value != null && value !== false\n\t\t\tdom.setAttribute(name,value)\n\t\telse\n\t\t\tdom.removeAttribute(name)\n\n\t###\n\tremoves an attribute from the specified tag\n\t###\n\tdef removeAttribute name\n\t\tdom.removeAttribute(name)\n\n\t###\n\treturns the value of an attribute on the tag.\n\tIf the given attribute does not exist, the value returned\n\twill either be null or \"\" (the empty string)\n\t###\n\tdef getAttribute name\n\t\tdom.getAttribute(name)\n\n\t###\n\tOverride this to provide special wrapping etc.\n\t@return {self}\n\t###\n\tdef setContent content, type\n\t\tsetChildren content, type\n\t\tself\n\n\t###\n\tSet the children of node. type param is optional,\n\tand should only be used by Imba when compiling tag trees. \n\t@return {self}\n\t###\n\tdef setChildren nodes, type\n\t\tthrow \"Not implemented\"\n\n\t###\n\tGet text of node. Uses textContent behind the scenes (not innerText)\n\t[https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent]()\n\t@return {string} inner text of node\n\t###\n\tdef text v\n\t\t@dom:textContent\n\n\t###\n\tSet text of node. Uses textContent behind the scenes (not innerText)\n\t[https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent]()\n\t###\n\tdef text= txt\n\t\t@empty = no\n\t\t@dom:textContent = txt ?= \"\"\n\t\tself\n\n\n\t###\n\tMethod for getting and setting data-attributes. When called with zero\n\targuments it will return the actual dataset for the tag.\n\n\t\tvar node = <div data-name='hello'>\n\t\t# get the whole dataset\n\t\tnode.dataset # {name: 'hello'}\n\t\t# get a single value\n\t\tnode.dataset('name') # 'hello'\n\t\t# set a single value\n\t\tnode.dataset('name','newname') # self\n\n\n\t###\n\tdef dataset key, val\n\t\tthrow \"Not implemented\"\n\n\t###\n\tEmpty placeholder. Override to implement custom render behaviour.\n\tWorks much like the familiar render-method in React.\n\t@return {self}\n\t###\n\tdef render\n\t\tself\n\n\t###\n\tCalled implicitly through Imba.Tag#end, upon creating a tag. All\n\tproperties will have been set before build is called, including\n\tsetContent.\n\t@return {self}\n\t###\n\tdef build\n\t\trender\n\t\tself\n\n\t###\n\tCalled implicitly through Imba.Tag#end, for tags that are part of\n\ta tag tree (that are rendered several times).\n\t@return {self}\n\t###\n\tdef commit\n\t\trender\n\t\tself\n\n\t###\n\n\tCalled by the tag-scheduler (if this tag is scheduled)\n\tBy default it will call this.render. Do not override unless\n\tyou really understand it.\n\n\t###\n\tdef tick\n\t\trender\n\t\tself\n\n\t###\n\t\n\tA very important method that you will practically never manually.\n\tThe tag syntax of Imba compiles to a chain of setters, which always\n\tends with .end. `<a.large>` compiles to `tag('a').flag('large').end()`\n\t\n\tYou are highly adviced to not override its behaviour. The first time\n\tend is called it will mark the tag as built and call Imba.Tag#build,\n\tand call Imba.Tag#commit on subsequent calls.\n\t@return {self}\n\t###\n\tdef end\n\t\tif @built\n\t\t\tcommit\n\t\telse\n\t\t\t@built = yes\n\t\t\tbuild\n\t\tself\n\n\t###\n\tThis is called instead of Imba.Tag#end for `<self>` tag chains.\n\tDefaults to noop\n\t@return {self}\n\t###\n\tdef synced\n\t\tself\n\n\t# called when the node is awakened in the dom - either automatically\n\t# upon attachment to the dom-tree, or the first time imba needs the\n\t# tag for a domnode that has been rendered on the server\n\tdef awaken\n\t\tself\n\n\t###\n\tList of flags for this node. \n\t###\n\tdef flags\n\t\t@dom:classList\n\n\t###\n\tAdd speficied flag to current node.\n\tIf a second argument is supplied, it will be coerced into a Boolean,\n\tand used to indicate whether we should remove the flag instead.\n\t@return {self}\n\t###\n\tdef flag name, toggler\n\t\t# it is most natural to treat a second undefined argument as a no-switch\n\t\t# so we need to check the arguments-length\n\t\tif arguments:length == 2 and !toggler\n\t\t\t@dom:classList.remove(name)\n\t\telse\n\t\t\t@dom:classList.add(name)\n\t\treturn self\n\n\t###\n\tRemove specified flag from node\n\t@return {self}\n\t###\n\tdef unflag name\n\t\t@dom:classList.remove(name)\n\t\tself\n\n\t###\n\tToggle specified flag on node\n\t@return {self}\n\t###\n\tdef toggleFlag name\n\t\t@dom:classList.toggle(name)\n\t\tself\n\n\t###\n\tCheck whether current node has specified flag\n\t@return {bool}\n\t###\n\tdef hasFlag name\n\t\t@dom:classList.contains(name)\n\n\t###\n\tGet the scheduler for this node. A new scheduler will be created\n\tif it does not already exist.\n\n\t@return {Imba.Scheduler}\n\t###\n\tdef scheduler\n\t\t@scheduler ?= Imba.Scheduler.new(self)\n\n\t###\n\n\tShorthand to start scheduling a node. The method will basically\n\tproxy the arguments through to scheduler.configure, and then\n\tactivate the scheduler.\n\t\n\t@return {self}\n\t###\n\tdef schedule options = {}\n\t\tscheduler.configure(options).activate\n\t\tself\n\n\t###\n\tShorthand for deactivating scheduler (if tag has one).\n\t@deprecated\n\t###\n\tdef unschedule\n\t\tscheduler.deactivate if @scheduler\n\t\tself\n\n\n\t###\n\tGet the parent of current node\n\t@return {Imba.Tag} \n\t###\n\tdef parent\n\t\ttag(dom:parentNode)\n\n\t###\n\tShorthand for console.log on elements\n\t@return {self}\n\t###\n\tdef log *args\n\t\targs.unshift(console)\n\t\tFunction:prototype:call.apply(console:log, args)\n\t\tself\n\n\tdef css key, val\n\t\tif key isa Object\n\t\t\tcss(k,v) for own k,v of key\n\t\telif val == null\n\t\t\tdom:style.removeProperty(key)\n\t\telif val == undefined\n\t\t\treturn dom:style[key]\n\t\telse\n\t\t\tif val isa Number and key.match(/width|height|left|right|top|bottom/)\n\t\t\t\tval = val + \"px\"\n\t\t\tdom:style[key] = val\n\t\tself\n\n\tdef transform= value\n\t\tcss(:transform, value)\n\t\tself\n\n\tdef transform\n\t\tcss(:transform)\n\n\nImba.Tag:prototype:initialize = Imba.Tag\n\nHTML_TAGS = \"a abbr address area article aside audio b base bdi bdo big blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hr html i iframe img input ins kbd keygen label legend li link main map mark menu menuitem meta meter nav noscript object ol optgroup option output p param pre progress q rp rt ruby s samp script section select small source span strong style sub summary sup table tbody td textarea tfoot th thead time title tr track u ul var video wbr\".split(\" \")\nHTML_TAGS_UNSAFE = \"article aside header section\".split(\" \")\nSVG_TAGS = \"circle defs ellipse g line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan\".split(\" \")\n\n\ndef extender obj, sup\n\tfor own k,v of sup\n\t\tobj[k] ?= v\n\n\tobj:prototype = Object.create(sup:prototype)\n\tobj:__super__ = obj:prototype:__super__ = sup:prototype\n\tobj:prototype:initialize = obj:prototype:constructor = obj\n\tsup.inherit(obj) if sup:inherit\n\treturn obj\n\ndef Tag\n\treturn do |dom|\n\t\tthis.setDom(dom)\n\t\treturn this\n\ndef TagSpawner type\n\treturn do type.build\n\nclass Imba.Tags\n\n\tdef initialize\n\t\tself\n\n\tdef __clone ns\n\t\tvar clone = Object.create(self)\n\t\tclone.@parent = self\n\t\treturn clone\n\n\tdef defineNamespace name\n\t\tvar clone = Object.create(self)\n\t\tclone.@parent = self\n\t\tclone.@ns = name\n\t\tself[name.toUpperCase] = clone\n\t\treturn clone\n\n\tdef baseType name\n\t\tname in HTML_TAGS ? 'htmlelement' : 'div'\n\n\tdef defineTag name, supr = '', &body\n\t\tsupr ||= baseType(name)\n\t\tlet supertype = self[supr]\n\t\tlet tagtype = Tag()\n\t\tlet norm = name.replace(/\\-/g,'_')\n\n\n\t\ttagtype.@name = name\n\t\textender(tagtype,supertype)\n\n\t\tif name[0] == '#'\n\t\t\tself[name] = tagtype\n\t\t\tImba.SINGLETONS[name.slice(1)] = tagtype\n\t\telse\n\t\t\tself[name] = tagtype\n\t\t\tself['$'+norm] = TagSpawner(tagtype)\n\n\t\tif body\n\t\t\tif body:length == 2\n\t\t\t\t# create clone\n\t\t\t\tunless tagtype.hasOwnProperty('TAGS')\n\t\t\t\t\ttagtype.TAGS = (supertype.TAGS or self).__clone\n\n\t\t\tbody.call(tagtype,tagtype, tagtype.TAGS or self)\n\n\t\treturn tagtype\n\n\tdef defineSingleton name, supr, &body\n\t\tdefineTag(name,supr,body)\n\n\tdef extendTag name, supr = '', &body\n\t\tvar klass = (name isa String ? self[name] : name)\n\t\t# allow for private tags here as well?\n\t\tbody and body.call(klass,klass,klass:prototype) if body\n\t\treturn klass\n\n\nImba.TAGS = Imba.Tags.new\nImba.TAGS[:element] = Imba.Tag\n\nvar svg = Imba.TAGS.defineNamespace('svg')\n\ndef svg.baseType name\n\t'svgelement'\n\n\nImba.SINGLETONS = {}\n\n\ndef Imba.defineTag name, supr = '', &body\n\treturn Imba.TAGS.defineTag(name,supr,body)\n\ndef Imba.defineSingletonTag id, supr = 'div', &body\n\treturn Imba.TAGS.defineTag(name,supr,body)\n\ndef Imba.extendTag name, body\n\treturn Imba.TAGS.extendTag(name,body)\n\ndef Imba.tag name\n\tvar typ = Imba.TAGS[name]\n\tthrow Error.new(\"tag {name} is not defined\") if !typ\n\treturn typ.new(typ.createNode)\n\ndef Imba.tagWithId name, id\n\tvar typ = Imba.TAGS[name]\n\tthrow Error.new(\"tag {name} is not defined\") if !typ\n\tvar dom = typ.createNode\n\tdom:id = id\n\treturn typ.new(dom)\n\n# TODO: Can we move these out and into dom.imba in a clean way?\n# These methods depends on Imba.document.getElementById\n\ndef Imba.getTagSingleton id\t\n\tvar dom, node\n\n\tif var klass = Imba.SINGLETONS[id]\n\t\treturn klass.Instance if klass and klass.Instance \n\n\t\t# no instance - check for element\n\t\tif dom = Imba.document.getElementById(id)\n\t\t\t# we have a live instance - when finding it through a selector we should awake it, no?\n\t\t\t# console.log('creating the singleton from existing node in dom?',id,type)\n\t\t\tnode = klass.Instance = klass.new(dom)\n\t\t\tnode.awaken(dom) # should only awaken\n\t\t\treturn node\n\n\t\tdom = klass.createNode\n\t\tdom:id = id\n\t\tnode = klass.Instance = klass.new(dom)\n\t\tnode.end.awaken(dom)\n\t\treturn node\n\telif dom = Imba.document.getElementById(id)\n\t\treturn Imba.getTagForDom(dom)\n\nvar svgSupport = typeof SVGElement !== 'undefined'\n\ndef Imba.getTagForDom dom\n\treturn null unless dom\n\treturn dom if dom.@dom # could use inheritance instead\n\treturn dom.@tag if dom.@tag\n\treturn null unless dom:nodeName\n\n\tvar ns   = null\n\tvar id   = dom:id\n\tvar type = dom:nodeName.toLowerCase\n\tvar tags = Imba.TAGS\n\tvar native = type\n\tvar cls  = dom:className\n\n\tif id and Imba.SINGLETONS[id]\n\t\t# FIXME control that it is the same singleton?\n\t\t# might collide -- not good?\n\t\treturn Imba.getTagSingleton(id)\n\t# look for id - singleton\n\n\t# need better test here\n\tif svgSupport and dom isa SVGElement\n\t\tns = \"svg\" \n\t\tcls = dom:className:baseVal\n\t\ttags = tags.SVG\n\n\tvar spawner\n\n\tif cls\n\t\t# there can be several matches here - should choose the last\n\t\t# should fall back to less specific later? - otherwise things may fail\n\t\t# TODO rework this\n\t\tif var m = cls.match(/\\b_([a-z\\-]+)\\b(?!\\s*_[a-z\\-]+)/)\n\t\t\ttype = m[1] # .replace(/-/g,'_')\n\n\t\tif m = cls.match(/\\b([A-Z\\-]+)_\\b/)\n\t\t\tns = m[1]\n\n\n\tspawner = tags[type] or tags[native]\n\tspawner ? spawner.new(dom).awaken(dom) : null\n\ntag$ = Imba.TAGS\nt$ = Imba:tag\ntc$ = Imba:tagWithFlags\nti$ = Imba:tagWithId\ntic$ = Imba:tagWithIdAndFlags\nid$ = Imba:getTagSingleton\ntag$wrap = Imba:getTagForDom\n\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/tag.imba\n **/","\ndef Imba.document\n\twindow:document\n\n###\nReturns the body element wrapped in an Imba.Tag\n###\ndef Imba.root\n\ttag(Imba.document:body)\n\ntag htmlelement < element\n\n\t###\n\tCalled when a tag type is being subclassed.\n\t###\n\tdef self.inherit child\n\t\tchild:prototype.@empty = yes\n\t\tchild.@protoDom = null\n\n\t\tif @nodeType\n\t\t\tchild.@nodeType = @nodeType\n\n\t\t\tvar className = \"_\" + child.@name.replace(/_/g, '-')\n\t\t\tchild.@classes = @classes.concat(className) unless child.@name[0] == '#'\n\t\telse\n\t\t\tchild.@nodeType = child.@name\n\t\t\tchild.@classes = []\n\n\tdef self.buildNode\n\t\tvar dom = Imba.document.createElement(@nodeType)\n\t\tvar cls = @classes.join(\" \")\n\t\tdom:className = cls if cls\n\t\tdom\n\n\tdef self.createNode\n\t\tvar proto = (@protoDom ||= buildNode)\n\t\tproto.cloneNode(false)\n\n\tdef self.dom\n\t\t@protoDom ||= buildNode\n\n\tattr id\n\tattr tabindex\n\tattr title\n\tattr role\n\n\tdef width\n\t\t@dom:offsetWidth\n\n\tdef height\n\t\t@dom:offsetHeight\n\n\tdef setChildren nodes, type\n\t\t@empty ? append(nodes) : empty.append(nodes)\n\t\t@children = null\n\t\tself\n\n\t###\n\tSet inner html of node\n\t###\n\tdef html= html\n\t\t@dom:innerHTML = html\n\t\tself\n\n\t###\n\tGet inner html of node\n\t###\n\tdef html\n\t\t@dom:innerHTML\n\n\t###\n\tRemove all content inside node\n\t###\n\tdef empty\n\t\t@dom.removeChild(@dom:firstChild) while @dom:firstChild\n\t\t@children = null\n\t\t@empty = yes\n\t\tself\n\n\t###\n\tRemove specified child from current node.\n\t###\n\tdef remove child\n\t\tvar par = dom\n\t\tvar el = child and child.dom\n\t\tpar.removeChild(el) if el and el:parentNode == par\n\t\tself\n\t\t\n\tdef emit name, data: null, bubble: yes\n\t\tImba.Events.trigger name, self, data: data, bubble: bubble\n\t\treturn self\n\n\tdef dataset key, val\n\t\tif key isa Object\n\t\t\tdataset(k,v) for own k,v of key\n\t\t\treturn self\n\n\t\tif arguments:length == 2\n\t\t\tsetAttribute(\"data-{key}\",val)\n\t\t\treturn self\n\n\t\tif key\n\t\t\treturn getAttribute(\"data-{key}\")\n\n\t\tvar dataset = dom:dataset\n\n\t\tunless dataset\n\t\t\tdataset = {}\n\t\t\tfor atr,i in dom:attributes\n\t\t\t\tif atr:name.substr(0,5) == 'data-'\n\t\t\t\t\tdataset[Imba.toCamelCase(atr:name.slice(5))] = atr:value\n\n\t\treturn dataset\n\n\t###\n\tGet descendants of current node, optionally matching selector\n\t@return {Imba.Selector}\n\t###\n\tdef find sel\n\t\tImba.Selector.new(sel,self)\n\n\t###\n\tGet the first matching child of node\n\n\t@return {Imba.Tag}\n\t###\n\tdef first sel\n\t\tsel ? find(sel).first : tag(dom:firstElementChild)\n\n\t###\n\tGet the last matching child of node\n\n\t\tnode.last # returns the last child of node\n\t\tnode.last %span # returns the last span inside node\n\t\tnode.last do |el| el.text == 'Hi' # return last node with text Hi\n\n\t@return {Imba.Tag}\n\t###\n\tdef last sel\n\t\tsel ? find(sel).last : tag(dom:lastElementChild)\n\n\t###\n\tGet the child at index\n\t###\n\tdef child i\n\t\ttag(dom:children[i or 0])\n\n\tdef children sel\n\t\tvar nodes = Imba.Selector.new(null, self, @dom:children)\n\t\tsel ? nodes.filter(sel) : nodes\n\t\n\tdef orphanize\n\t\tpar.removeChild(@dom) if let par = dom:parentNode\n\t\treturn self\n\t\n\tdef matches sel\n\t\tif sel isa Function\n\t\t\treturn sel(self)\n\n\t\tsel = sel.query if sel:query\n\t\tif var fn = (@dom:matches or @dom:matchesSelector or @dom:webkitMatchesSelector or @dom:msMatchesSelector or @dom:mozMatchesSelector)\n\t\t\treturn fn.call(@dom,sel)\n\n\t###\n\tGet the first element matching supplied selector / filter\n\ttraversing upwards, but including the node itself.\n\t@return {Imba.Tag}\n\t###\n\tdef closest sel\n\t\treturn parent unless sel # should return self?!\n\t\tvar node = self\n\t\tsel = sel.query if sel:query\n\n\t\twhile node\n\t\t\treturn node if node.matches(sel)\n\t\t\tnode = node.parent\n\t\treturn null\n\n\t###\n\tGet the closest ancestor of node that matches\n\tspecified selector / matcher.\n\n\t@return {Imba.Tag}\n\t###\n\tdef up sel\n\t\treturn parent unless sel\n\t\tparent and parent.closest(sel)\n\n\tdef path sel\n\t\tvar node = self\n\t\tvar nodes = []\n\t\tsel = sel.query if sel and sel:query\n\n\t\twhile node\n\t\t\tnodes.push(node) if !sel or node.matches(sel)\n\t\t\tnode = node.parent\n\t\treturn nodes\n\n\tdef parents sel\n\t\tvar par = parent\n\t\tpar ? par.path(sel) : []\n\n\t\n\n\tdef siblings sel\n\t\treturn [] unless var par = parent # FIXME\n\t\tvar ary = dom:parentNode:children\n\t\tvar nodes = Imba.Selector.new(null, self, ary)\n\t\tnodes.filter(|n| n != self && (!sel || n.matches(sel)))\n\n\t###\n\tGet the immediately following sibling of node.\n\t###\n\tdef next sel\n\t\tif sel\n\t\t\tvar el = self\n\t\t\twhile el = el.next\n\t\t\t\treturn el if el.matches(sel)\n\t\t\treturn null\n\t\ttag(dom:nextElementSibling)\n\n\t###\n\tGet the immediately preceeding sibling of node.\n\t###\n\tdef prev sel\n\t\tif sel\n\t\t\tvar el = self\n\t\t\twhile el = el.prev\n\t\t\t\treturn el if el.matches(sel)\n\t\t\treturn null\n\t\ttag(dom:previousElementSibling)\n\n\tdef contains node\n\t\tdom.contains(node and node.@dom or node)\n\n\tdef index\n\t\tvar i = 0\n\t\tvar el = dom\n\t\twhile el:previousSibling\n\t\t\tel = el:previousSibling\n\t\t\ti++\n\t\treturn i\n\n\n\t###\n\t\n\t@deprecated\n\t###\n\tdef insert node, before: null, after: null\n\t\tbefore = after.next if after\n\t\tif node isa Array\n\t\t\tnode = (<fragment> node)\n\t\tif before\n\t\t\tdom.insertBefore(node.dom,before.dom)\n\t\telse\n\t\t\tappend(node)\n\t\tself\t\n\n\t###\n\tFocus on current node\n\t@return {self}\n\t###\n\tdef focus\n\t\tdom.focus\n\t\tself\n\n\t###\n\tRemove focus from current node\n\t@return {self}\n\t###\n\tdef blur\n\t\tdom.blur\n\t\tself\n\n\tdef template\n\t\tnull\n\n\t###\n\t@todo Should support multiple arguments like append\n\n\tThe .prepend method inserts the specified content as the first\n\tchild of the target node. If the content is already a child of \n\tnode it will be moved to the start.\n\t\n    \tnode.prepend <div.top> # prepend node\n    \tnode.prepend \"some text\" # prepend text\n    \tnode.prepend [<ul>,<ul>] # prepend array\n\n\t###\n\tdef prepend item\n\t\tvar first = @dom:childNodes[0]\n\t\tfirst ? insertBefore(item, first) : appendChild(item)\n\t\tself\n\n\t###\n\tThe .append method inserts the specified content as the last child\n\tof the target node. If the content is already a child of node it\n\twill be moved to the end.\n\t\n\t# example\n\t    var root = <div.root>\n\t    var item = <div.item> \"This is an item\"\n\t    root.append item # appends item to the end of root\n\n\t    root.prepend \"some text\" # append text\n\t    root.prepend [<ul>,<ul>] # append array\n\t###\n\tdef append item\n\t\t# possible to append blank\n\t\t# possible to simplify on server?\n\t\treturn self unless item\n\n\t\tif item isa Array\n\t\t\tmember && append(member) for member in item\n\n\t\telif item isa String or item isa Number\n\t\t\tvar node = Imba.document.createTextNode(item)\n\t\t\t@dom.appendChild(node)\n\t\t\t@empty = no if @empty\t\t\t\n\t\telse\n\t\t\t@dom.appendChild(item.@dom or item)\n\t\t\t@empty = no if @empty\n\n\t\treturn self\n\n\t###\n\tInsert a node into the current node (self), before another.\n\tThe relative node must be a child of current node. \n\t###\n\tdef insertBefore node, rel\n\t\tnode = Imba.document.createTextNode(node) if node isa String \n\t\tdom.insertBefore( (node.@dom or node), (rel.@dom or rel) ) if node and rel\n\t\tself\n\n\t###\n\tAppend a single item (node or string) to the current node.\n\tIf supplied item is a string it will automatically. This is used\n\tby Imba internally, but will practically never be used explicitly.\n\t###\n\tdef appendChild node\n\t\tnode = Imba.document.createTextNode(node) if node isa String\n\t\tdom.appendChild(node.@dom or node) if node\n\t\tself\n\n\t###\n\tRemove a single child from the current node.\n\tUsed by Imba internally.\n\t###\n\tdef removeChild node\n\t\tdom.removeChild(node.@dom or node) if node\n\t\tself\n\n\tdef toString\n\t\t@dom.toString # really?\n\n\t###\n\t@deprecated\n\t###\n\tdef classes\n\t\tconsole.log 'Imba.Tag#classes is deprecated'\n\t\t@dom:classList\n\ntag svgelement < htmlelement\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.imba\n **/","\n# predefine all supported html tags\ntag fragment < htmlelement\n\t\n\tdef self.createNode\n\t\tImba.document.createDocumentFragment\n\ntag a\n\tattr href\n\ntag abbr\ntag address\ntag area\ntag article\ntag aside\ntag audio\ntag b\ntag base\ntag bdi\ntag bdo\ntag big\ntag blockquote\ntag body\ntag br\n\ntag button\n\tattr autofocus\n\tattr type\n\tattr disabled\n\ntag canvas\n\tdef width= val\n\t\tdom:width = val unless width == val\n\t\tself\n\n\tdef height= val\n\t\tdom:height = val unless height == val\n\t\tself\n\n\tdef width\n\t\tdom:width\n\n\tdef height\n\t\tdom:height\n\n\tdef context type = '2d'\n\t\tdom.getContext(type)\n\ntag caption\ntag cite\ntag code\ntag col\ntag colgroup\ntag data\ntag datalist\ntag dd\ntag del\ntag details\ntag dfn\ntag div\ntag dl\ntag dt\ntag em\ntag embed\ntag fieldset\ntag figcaption\ntag figure\ntag footer\n\ntag form\n\tattr method\n\tattr action\n\ntag h1\ntag h2\ntag h3\ntag h4\ntag h5\ntag h6\ntag head\ntag header\ntag hr\ntag html\ntag i\n\ntag iframe\n\tattr src\n\ntag img\n\tattr src\n\ntag input\n\t# can use attr instead\n\tattr name\n\tattr type\n\tattr required\n\tattr disabled\n\tattr autofocus\n\n\tdef value\n\t\tdom:value\n\n\tdef value= v\n\t\tdom:value = v unless v == dom:value\n\t\tself\n\n\tdef placeholder= v\n\t\tdom:placeholder = v unless v == dom:placeholder\n\t\tself\n\n\tdef placeholder\n\t\tdom:placeholder\n\n\tdef checked\n\t\tdom:checked\n\n\tdef checked= bool\n\t\tdom:checked = bool unless bool == dom:checked\n\t\tself\n\ntag ins\ntag kbd\ntag keygen\ntag label\ntag legend\ntag li\n\ntag link\n\tattr rel\n\tattr type\n\tattr href\n\tattr media\n\ntag main\ntag map\ntag mark\ntag menu\ntag menuitem\n\ntag meta\n\tattr name\n\tattr content\n\tattr charset\n\ntag meter\ntag nav\ntag noscript\ntag object\ntag ol\ntag optgroup\n\ntag option\n\tattr value\n\ntag output\ntag p\ntag param\ntag pre\ntag progress\ntag q\ntag rp\ntag rt\ntag ruby\ntag s\ntag samp\n\ntag script\n\tattr src\n\tattr type\n\tattr async\n\tattr defer\n\ntag section\n\ntag select\n\tattr name\n\tattr multiple\n\tattr required\n\tattr disabled\n\t\n\tdef value\n\t\tdom:value\n\n\tdef value= v\n\t\tdom:value = v unless v == dom:value\n\t\tself\n\n\ntag small\ntag source\ntag span\ntag strong\ntag style\ntag sub\ntag summary\ntag sup\ntag table\ntag tbody\ntag td\n\ntag textarea\n\tattr name\n\tattr disabled\n\tattr required\n\tattr rows\n\tattr cols\n\tattr autofocus\n\n\tdef value\n\t\tdom:value\n\n\tdef value= v\n\t\tdom:value = v unless v == dom:value\n\t\tself\n\n\tdef placeholder= v\n\t\tdom:placeholder = v unless v == dom:placeholder\n\t\tself\n\n\tdef placeholder\n\t\tdom:placeholder\n\ntag tfoot\ntag th\ntag thead\ntag time\ntag title\ntag tr\ntag track\ntag u\ntag ul\ntag video\ntag wbr\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.html.imba\n **/","\ntag svg:svgelement\n\n\tdef self.namespaceURI\n\t\t\"http://www.w3.org/2000/svg\"\n\n\tlet types = \"circle defs ellipse g line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan\".split(\" \")\n\n\tdef self.buildNode\n\t\tvar dom = Imba.document.createElementNS(namespaceURI,@nodeType)\n\t\tvar cls = @classes.join(\" \")\n\t\tdom:className:baseVal = cls if cls\n\t\tdom\n\n\tdef self.inherit child\n\t\tchild.@protoDom = null\n\n\t\tif child.@name in types\n\t\t\tchild.@nodeType = child.@name\n\t\t\tchild.@classes = []\n\t\telse\n\t\t\tchild.@nodeType = @nodeType\n\t\t\tvar className = \"_\" + child.@name.replace(/_/g, '-')\n\t\t\tchild.@classes = @classes.concat(className)\n\n\n\tattr x inline: no\n\tattr y inline: no\n\n\tattr width inline: no\n\tattr height inline: no\n\n\tattr stroke inline: no\n\tattr stroke-width inline: no\n\ntag svg:svg\n\tattr viewbox inline: no\n\ntag svg:g\n\ntag svg:defs\n\ntag svg:symbol\n\tattr preserveAspectRatio inline: no\n\tattr viewBox inline: no\n\ntag svg:marker\n\tattr markerUnits inline: no\n\tattr refX inline: no\n\tattr refY inline: no\n\tattr markerWidth inline: no\n\tattr markerHeight inline: no\n\tattr orient inline: no\n\n\n# Basic shapes\n\ntag svg:rect\n\tattr rx inline: no\n\tattr ry inline: no\n\ntag svg:circle\n\tattr cx inline: no\n\tattr cy inline: no\n\tattr r inline: no\n\ntag svg:ellipse\n\tattr cx inline: no\n\tattr cy inline: no\n\tattr rx inline: no\n\tattr ry inline: no\n\ntag svg:path\n\tattr d inline: no\n\tattr pathLength inline: no\n\ntag svg:line\n\tattr x1 inline: no\n\tattr x2 inline: no\n\tattr y1 inline: no\n\tattr y2 inline: no\n\ntag svg:polyline\n\tattr points inline: no\n\ntag svg:polygon\n\tattr points inline: no\n\ntag svg:text\n\tattr dx inline: no\n\tattr dy inline: no\n\tattr text-anchor inline: no\n\tattr rotate inline: no\n\tattr textLength inline: no\n\tattr lengthAdjust inline: no\n\ntag svg:tspan\n\tattr dx inline: no\n\tattr dy inline: no\n\tattr rotate inline: no\n\tattr textLength inline: no\n\tattr lengthAdjust inline: no\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.svg.imba\n **/","# Extending Imba.Tag#css to work without prefixes by inspecting\n# the properties of a CSSStyleDeclaration and creating a map\n\n# var prefixes = ['-webkit-','-ms-','-moz-','-o-','-blink-']\n# var props = ['transform','transition','animation']\n\nif Imba.CLIENT\n\tvar styles = window.getComputedStyle(document:documentElement, '')\n\n\tImba.CSSKeyMap = {}\n\n\tfor prefixed in styles\n\t\tvar unprefixed = prefixed.replace(/^-(webkit|ms|moz|o|blink)-/,'')\n\t\tvar camelCase = unprefixed.replace(/-(\\w)/g) do |m,a| a.toUpperCase\n\n\t\t# if there exists an unprefixed version -- always use this\n\t\tif prefixed != unprefixed\n\t\t\tcontinue if styles.hasOwnProperty(unprefixed)\n\n\t\t# register the prefixes\n\t\tImba.CSSKeyMap[unprefixed] = Imba.CSSKeyMap[camelCase] = prefixed\n\n\textend tag element\n\n\t\t# override the original css method\n\t\tdef css key, val\n\t\t\tif key isa Object\n\t\t\t\tcss(k,v) for own k,v of key\n\t\t\t\treturn self\n\n\t\t\tkey = Imba.CSSKeyMap[key] or key\n\n\t\t\tif val == null\n\t\t\t\tdom:style.removeProperty(key)\n\t\t\telif val == undefined\n\t\t\t\treturn dom:style[key]\n\t\t\telse\n\t\t\t\tif val isa Number and key.match(/width|height|left|right|top|bottom/)\n\t\t\t\t\tval = val + \"px\"\n\t\t\t\tdom:style[key] = val\n\t\t\tself\n\t\t\t\n\tunless document:documentElement:classList\n\t\textend tag element\n\n\t\t\tdef hasFlag ref\n\t\t\t\treturn RegExp.new('(^|\\\\s)' + ref + '(\\\\s|$)').test(@dom:className)\n\n\t\t\tdef addFlag ref\n\t\t\t\treturn self if hasFlag(ref)\n\t\t\t\t@dom:className += (@dom:className ? ' ' : '') + ref\n\t\t\t\treturn self\n\n\t\t\tdef unflag ref\n\t\t\t\treturn self unless hasFlag(ref)\n\t\t\t\tvar regex = RegExp.new('(^|\\\\s)*' + ref + '(\\\\s|$)*', 'g')\n\t\t\t\t@dom:className = @dom:className.replace(regex, '')\n\t\t\t\treturn self\n\n\t\t\tdef toggleFlag ref\n\t\t\t\thasFlag(ref) ? unflag(ref) : flag(ref)\n\n\t\t\tdef flag ref, bool\n\t\t\t\tif arguments:length == 2 and !!bool === no\n\t\t\t\t\treturn unflag(ref)\n\t\t\t\treturn addFlag(ref)\n\t\ttrue\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.client.imba\n **/","var doc = document\nvar win = window\n\nvar hasTouchEvents = window && window:ontouchstart !== undefined\n\nclass Imba.Pointer\n\n\t# began, moved, stationary, ended, cancelled\n\n\tprop phase\n\tprop prevEvent\n\tprop button\n\tprop event\n\tprop dirty\n\tprop events\n\tprop touch\n\n\tdef initialize\n\t\tbutton = -1\n\t\tevent = {x: 0, y: 0, type: 'uninitialized'}\n\t\treturn self\n\n\tdef update e\n\t\tevent = e\n\t\tdirty = yes\n\t\tself\n\n\t# this is just for regular mouse now\n\tdef process\n\t\tvar e1 = event\n\n\t\tif dirty\n\t\t\tprevEvent = e1\n\t\t\tdirty = no\n\n\t\t\t# button should only change on mousedown etc\n\t\t\tif e1:type == 'mousedown'\n\t\t\t\tbutton = e1:button\n\n\t\t\t\t# do not create touch for right click\n\t\t\t\tif button == 2 or (touch and button != 0)\n\t\t\t\t\treturn\n\n\t\t\t\t# cancel the previous touch\n\t\t\t\ttouch.cancel if touch\n\t\t\t\ttouch = Imba.Touch.new(e1,self)\n\t\t\t\ttouch.mousedown(e1,e1)\n\n\t\t\telif e1:type == 'mousemove'\n\t\t\t\ttouch.mousemove(e1,e1) if touch\n\n\t\t\telif e1:type == 'mouseup'\n\t\t\t\tbutton = -1\n\n\t\t\t\tif touch and touch.button == e1:button\n\t\t\t\t\ttouch.mouseup(e1,e1)\n\t\t\t\t\ttouch = null\n\t\t\t\t# trigger pointerup\n\t\telse\n\t\t\ttouch.idle if touch\n\t\tself\n\t\t\n\tdef cleanup\n\t\tImba.POINTERS\n\n\tdef x do event:x\n\tdef y do event:y\n\n\t# deprecated -- should remove\n\tdef self.update \n\t\t# console.log('update touch')\n\t\tfor ptr,i in Imba.POINTERS\n\t\t\tptr.process\n\t\t# need to be able to prevent the default behaviour of touch, no?\n\t\twin.requestAnimationFrame(Imba.Pointer:update)\n\t\tself\n\nvar lastNativeTouchTimeStamp = 0\nvar lastNativeTouchTimeout = 50\n\n# Imba.Touch\n# Began\tA finger touched the screen.\n# Moved\tA finger moved on the screen.\n# Stationary\tA finger is touching the screen but hasn't moved.\n# Ended\tA finger was lifted from the screen. This is the final phase of a touch.\n# Canceled The system cancelled tracking for the touch.\n\n###\nConsolidates mouse and touch events. Touch objects persist across a touch,\nfrom touchstart until end/cancel. When a touch starts, it will traverse\ndown from the innermost target, until it finds a node that responds to\nontouchstart. Unless the touch is explicitly redirected, the touch will\ncall ontouchmove and ontouchend / ontouchcancel on the responder when appropriate.\n\n\ttag draggable\n\t\t# called when a touch starts\n\t\tdef ontouchstart touch\n\t\t\tflag 'dragging'\n\t\t\tself\n\t\t\n\t\t# called when touch moves - same touch object\n\t\tdef ontouchmove touch\n\t\t\t# move the node with touch\n\t\t\tcss top: touch.dy, left: touch.dx\n\t\t\n\t\t# called when touch ends\n\t\tdef ontouchend touch\n\t\t\tunflag 'dragging'\n\n@iname touch\n###\nclass Imba.Touch\n\n\tvar touches = []\n\tvar count = 0\n\tvar identifiers = {}\n\n\tdef self.count\n\t\tcount\n\n\tdef self.lookup item\n\t\treturn item and (item:__touch__ or identifiers[item:identifier])\n\n\tdef self.release item,touch\n\t\tdelete identifiers[item:identifier]\n\t\tdelete item:__touch__\n\t\treturn\n\n\tdef self.ontouchstart e\n\t\tfor t in e:changedTouches\n\t\t\tcontinue if lookup(t)\n\t\t\tvar touch = identifiers[t:identifier] = self.new(e) # (e)\n\t\t\tt:__touch__ = touch\n\t\t\ttouches.push(touch)\n\t\t\tcount++\n\t\t\ttouch.touchstart(e,t)\n\t\tself\n\n\tdef self.ontouchmove e\n\t\tfor t in e:changedTouches\n\t\t\tif var touch = lookup(t)\n\t\t\t\ttouch.touchmove(e,t)\n\n\t\tself\n\n\tdef self.ontouchend e\n\t\tfor t in e:changedTouches\n\t\t\tif var touch = lookup(t)\n\t\t\t\ttouch.touchend(e,t)\n\t\t\t\trelease(t,touch)\n\t\t\t\tcount--\n\n\t\t# e.preventDefault\n\t\t# not always supported!\n\t\t# touches = touches.filter(||)\n\t\tself\n\n\tdef self.ontouchcancel e\n\t\tfor t in e:changedTouches\n\t\t\tif var touch = lookup(t)\n\t\t\t\ttouch.touchcancel(e,t)\n\t\t\t\trelease(t,touch)\n\t\t\t\tcount--\n\t\tself\n\n\tdef self.onmousedown e\n\t\tself\n\n\tdef self.onmousemove e\n\t\tself\n\n\tdef self.onmouseup e\n\t\tself\n\n\n\tprop phase\n\tprop active\n\tprop event\n\tprop pointer\n\tprop target\n\tprop handler\n\tprop updates\n\tprop suppress\n\tprop data\n\tprop bubble chainable: yes\n\n\tprop gestures\n\n\t###\n\t\n\n\t@internal\n\t@constructor\n\t###\n\tdef initialize event, pointer\n\t\t# @native  = false\n\t\tself.event = event\n\t\tdata = {}\n\t\tactive = yes\n\t\t@button = event and event:button or 0\n\t\t@suppress = no # deprecated\n\t\t@captured = no\n\t\tbubble = no\n\t\tpointer = pointer\n\t\tupdates = 0\n\t\treturn self\n\n\tdef capture\n\t\t@captured = yes\n\t\t@event and @event.preventDefault\n\t\tself\n\n\tdef isCaptured\n\t\t!!@captured\n\n\t###\n\tExtend the touch with a plugin / gesture. \n\tAll events (touchstart,move etc) for the touch\n\twill be triggered on the plugins in the order they\n\tare added.\n\t###\n\tdef extend plugin\n\t\t# console.log \"added gesture!!!\"\n\t\t@gestures ||= []\n\t\t@gestures.push(plugin)\n\t\tself\n\n\t###\n\tRedirect touch to specified target. ontouchstart will always be\n\tcalled on the new target.\n\t@return {Number}\n\t###\n\tdef redirect target\n\t\t@redirect = target\n\t\tself\n\n\t###\n\tSuppress the default behaviour. Will call preventDefault for\n\tall native events that are part of the touch.\n\t###\n\tdef suppress\n\t\t# collision with the suppress property\n\t\t@active = no\n\t\tself\n\n\tdef suppress= value\n\t\tconsole.warn 'Imba.Touch#suppress= is deprecated'\n\t\t@supress = value\n\t\tself\n\n\tdef touchstart e,t\n\t\t@event = e\n\t\t@touch = t\n\t\t@button = 0\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\tbegan\n\t\te.preventDefault if e and isCaptured\n\t\tself\n\n\tdef touchmove e,t\n\t\t@event = e\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\tupdate\n\t\te.preventDefault if e and isCaptured\n\t\tself\n\n\tdef touchend e,t\n\t\t@event = e\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\tended\n\n\t\tlastNativeTouchTimeStamp = e:timeStamp\n\n\t\tif @maxdr < 20\n\t\t\tvar tap = Imba.Event.new(e)\n\t\t\ttap.type = 'tap'\n\t\t\ttap.process\n\t\t\te.preventDefault if tap.@responder\t\n\n\t\tif e and isCaptured\n\t\t\te.preventDefault\n\n\t\tself\n\n\tdef touchcancel e,t\n\t\tcancel\n\n\tdef mousedown e,t\n\t\t@event = e\n\t\t@button = e:button\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\tbegan\n\n\t\t@mousemove = (|e| mousemove(e,e) )\n\t\tdoc.addEventListener('mousemove',@mousemove,yes)\n\t\tself\n\n\tdef mousemove e,t\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\t@event = e\n\t\te.preventDefault if isCaptured\n\t\tupdate\n\t\tmove\n\t\tself\n\n\tdef mouseup e,t\n\t\t@x = t:clientX\n\t\t@y = t:clientY\n\t\tended\n\t\tdoc.removeEventListener('mousemove',@mousemove,yes)\n\t\t@mousemove = null\n\t\tself\n\n\tdef idle\n\t\tupdate\n\n\tdef began\n\t\t@maxdr = @dr = 0\n\t\t@x0 = @x\n\t\t@y0 = @y\n\n\t\tvar dom = event:target\n\t\tvar node = null\n\n\t\t@sourceTarget = dom and tag(dom)\n\n\t\twhile dom\n\t\t\tnode = tag(dom)\n\t\t\tif node && node:ontouchstart\n\t\t\t\t@bubble = no\n\t\t\t\ttarget = node\n\t\t\t\ttarget.ontouchstart(self)\n\t\t\t\tbreak unless @bubble\n\t\t\tdom = dom:parentNode\n\n\t\t@updates++\n\t\tself\n\n\tdef update\n\t\treturn self unless @active\n\n\t\tvar dr = Math.sqrt(dx*dx + dy*dy)\n\t\t@maxdr = dr if dr > @dr\n\t\t@dr = dr\n\n\t\t# catching a touch-redirect?!?\n\t\tif @redirect\n\t\t\tif @target and @target:ontouchcancel\n\t\t\t\t@target.ontouchcancel(self)\n\t\t\ttarget = @redirect\n\t\t\t@redirect = null\n\t\t\ttarget.ontouchstart(self) if target:ontouchstart\n\n\n\t\t@updates++\n\t\tif @gestures\n\t\t\tg.ontouchupdate(self) for g in @gestures\n\n\t\ttarget?.ontouchupdate(self)\n\t\tself\n\n\tdef move\n\t\treturn self unless @active\n\n\t\tif @gestures\n\t\t\tfor g in @gestures\n\t\t\t\tg.ontouchmove(self,@event) if g:ontouchmove\n\n\t\ttarget?.ontouchmove(self,@event)\n\t\tself\n\n\tdef ended\n\t\treturn self unless @active\n\n\t\t@updates++\n\n\t\tif @gestures\n\t\t\tg.ontouchend(self) for g in @gestures\n\n\t\ttarget?.ontouchend(self)\n\n\t\tself\n\n\tdef cancel\n\t\tunless @cancelled\n\t\t\t@cancelled = yes\n\t\t\tcancelled\n\t\t\tdoc.removeEventListener('mousemove',@mousemove,yes) if @mousemove\n\t\tself\n\n\tdef cancelled\n\t\treturn self unless @active\n\n\t\t@cancelled = yes\n\t\t@updates++\n\n\t\tif @gestures\n\t\t\tfor g in @gestures\n\t\t\t\tg.ontouchcancel(self) if g:ontouchcancel\n\n\t\ttarget?.ontouchcancel(self)\n\t\tself\n\n\t###\n\tThe absolute distance the touch has moved from starting position \n\t@return {Number}\n\t###\n\tdef dr do @dr\n\n\t###\n\tThe distance the touch has moved horizontally\n\t@return {Number}\n\t###\n\tdef dx do @x - @x0\n\n\t###\n\tThe distance the touch has moved vertically\n\t@return {Number}\n\t###\n\tdef dy do @y - @y0\n\n\t###\n\tInitial horizontal position of touch\n\t@return {Number}\n\t###\n\tdef x0 do @x0\n\n\t###\n\tInitial vertical position of touch\n\t@return {Number}\n\t###\n\tdef y0 do @y0\n\n\t###\n\tHorizontal position of touch\n\t@return {Number}\n\t###\n\tdef x do @x\n\n\t###\n\tVertical position of touch\n\t@return {Number}\n\t###\n\tdef y do @y\n\n\t###\n\tHorizontal position of touch relative to target\n\t@return {Number}\n\t###\n\tdef tx do\n\t\t@targetBox ||= @target.dom.getBoundingClientRect\n\t\t@x - @targetBox:left\n\n\t###\n\tVertical position of touch relative to target\n\t@return {Number}\n\t###\n\tdef ty\n\t\t@targetBox ||= @target.dom.getBoundingClientRect\n\t\t@y - @targetBox:top\n\n\t###\n\tButton pressed in this touch. Native touches defaults to left-click (0)\n\t@return {Number}\n\t###\n\tdef button do @button # @pointer ? @pointer.button : 0\n\n\tdef sourceTarget\n\t\t@sourceTarget\n\n\nclass Imba.TouchGesture\n\n\tprop active default: no\n\n\tdef ontouchstart e\n\t\tself\n\n\tdef ontouchupdate e\n\t\tself\n\n\tdef ontouchend e\n\t\tself\n\n\n# A Touch-event is created on mousedown (always)\n# and while it exists, mousemove and mouseup will\n# be delegated to this active event.\nImba.POINTER = Imba.Pointer.new\nImba.POINTERS = [Imba.POINTER]\n\n\n# regular event stuff\nImba.KEYMAP = {\n\t\"8\": 'backspace'\n\t\"9\": 'tab'\n\t\"13\": 'enter'\n\t\"16\": 'shift'\n\t\"17\": 'ctrl'\n\t\"18\": 'alt'\n\t\"19\": 'break'\n\t\"20\": 'caps'\n\t\"27\": 'esc'\n\t\"32\": 'space'\n\t\"35\": 'end'\n\t\"36\": 'home'\n\t\"37\": 'larr'\n\t\"38\": 'uarr'\n\t\"39\": 'rarr'\n\t\"40\": 'darr'\n\t\"45\": 'insert'\n\t\"46\": 'delete'\n\t\"107\": 'plus'\n\t\"106\": 'mult'\n\t\"91\": 'meta'\n}\n\nImba.CHARMAP = {\n\t\"%\": 'modulo'\n\t\"*\": 'multiply'\n\t\"+\": 'add'\n\t\"-\": 'sub'\n\t\"/\": 'divide'\n\t\".\": 'dot'\n}\n\n###\nImba handles all events in the dom through a single manager,\nlistening at the root of your document. If Imba finds a tag\nthat listens to a certain event, the event will be wrapped \nin an `Imba.Event`, which normalizes some of the quirks and \nbrowser differences.\n\n@iname event\n###\nclass Imba.Event\n\n\t### reference to the native event ###\n\tprop event\n\n\t### reference to the native event ###\n\tprop prefix\n\n\tprop data\n\n\t###\n\tshould remove this alltogether?\n\t@deprecated\n\t###\n\tprop source\n\n\t### A {Boolean} indicating whether the event bubbles up or not ###\n\tprop bubble type: Boolean, chainable: yes\n\n\tdef self.wrap e\n\t\tself.new(e)\n\t\n\tdef initialize e\n\t\tevent = e\n\t\tbubble = yes\n\n\tdef type= type\n\t\t@type = type\n\t\tself\n\n\t###\n\t@return {String} The name of the event (case-insensitive)\n\t###\n\tdef type\n\t\t@type || event:type\n\n\tdef name\n\t\t@name ||= type.toLowerCase.replace(/\\:/g,'')\n\n\t# mimc getset\n\tdef bubble v\n\t\tif v != undefined\n\t\t\tself.bubble = v\n\t\t\treturn self\n\t\treturn @bubble\n\n\t###\n\tPrevents further propagation of the current event.\n\t@return {self}\n\t###\n\tdef halt\n\t\tbubble = no\n\t\tself\n\n\t###\n\tCancel the event (if cancelable). In the case of native events it\n\twill call `preventDefault` on the wrapped event object.\n\t@return {self}\n\t###\n\tdef cancel\n\t\tevent.preventDefault if event:preventDefault\n\t\t@cancel = yes\n\t\tself\n\n\tdef silence\n\t\t@silenced = yes\n\t\tself\n\n\tdef isSilenced\n\t\t!!@silenced\n\n\t###\n\tIndicates whether or not event.cancel has been called.\n\n\t@return {Boolean}\n\t###\n\tdef isPrevented\n\t\tevent and event:defaultPrevented or @cancel\n\n\t###\n\tA reference to the initial target of the event.\n\t###\n\tdef target\n\t\ttag(event:_target or event:target)\n\n\t###\n\tA reference to the object responding to the event.\n\t###\n\tdef responder\n\t\t@responder\n\n\t###\n\tRedirect the event to new target\n\t###\n\tdef redirect node\n\t\t@redirect = node\n\t\tself\n\n\t###\n\tGet the normalized character for KeyboardEvent/TextEvent\n\t@return {String}\n\t###\n\tdef keychar\n\t\tif event isa KeyboardEvent\n\t\t\tvar ki = event:keyIdentifier\n\t\t\tvar sym = Imba.KEYMAP[event:keyCode]\n\n\t\t\tif !sym and ki.substr(0,2) == \"U+\"\n\t\t\t\tsym = String.fromCharCode(parseInt(ki.substr(2), 16))\n\t\t\treturn sym\n\n\t\telif event isa (window.TextEvent or window.InputEvent)\n\t\t\treturn event:data\n\n\t\treturn null\n\n\t###\n\t@deprecated\n\t###\n\tdef keycombo\n\t\treturn unless var sym = keychar\n\t\tsym = Imba.CHARMAP[sym] or sym\n\t\tvar combo = [], e = event\n\t\tcombo.push(:ctrl) if e:ctrlKey\n\t\tcombo.push(:shift) if e:shiftKey\n\t\tcombo.push(:alt) if e:altKey\n\t\tcombo.push(:cmd) if e:metaKey\n\t\tcombo.push(sym)\n\t\tcombo.join(\"_\").toLowerCase\n\n\n\tdef process\n\t\tvar meth = \"on{@prefix or ''}{name}\"\n\t\tvar args = null\n\t\tvar domtarget = event:_target or event:target\t\t\n\t\t# var node = <{domtarget:_responder or domtarget}>\n\t\t# need to clean up and document this behaviour\n\n\t\tvar domnode = domtarget:_responder or domtarget\n\t\t# @todo need to stop infinite redirect-rules here\n\n\t\twhile domnode\n\t\t\t@redirect = null\n\t\t\tif var node = tag(domnode) # not only tag \n\n\t\t\t\tif node[meth] isa String\n\t\t\t\t\t# should remember the receiver of the event\n\t\t\t\t\tmeth = node[meth]\n\t\t\t\t\tcontinue # should not continue?\n\n\t\t\t\tif node[meth] isa Array\n\t\t\t\t\targs = node[meth].concat(node)\n\t\t\t\t\tmeth = args.shift\n\t\t\t\t\tcontinue # should not continue?\n\n\t\t\t\tif node[meth] isa Function\n\t\t\t\t\t@responder ||= node\n\t\t\t\t\t# should autostop bubble here?\n\t\t\t\t\targs ? node[meth].apply(node,args) : node[meth](self,data)\n\t\t\t\t\t\n\t\t\t# add node.nextEventResponder as a separate method here?\n\t\t\tunless bubble and domnode = (@redirect or (node ? node.parent : domnode:parentNode))\n\t\t\t\tbreak\n\n\t\tprocessed\n\t\treturn self\n\n\n\tdef processed\n\t\tImba.emit(Imba,'event',[self]) unless @silenced\n\t\tself\n\n\t###\n\tReturn the x/left coordinate of the mouse / pointer for this event\n\t@return {Number} x coordinate of mouse / pointer for event\n\t###\n\tdef x do event:x\n\n\t###\n\tReturn the y/top coordinate of the mouse / pointer for this event\n\t@return {Number} y coordinate of mouse / pointer for event\n\t###\n\tdef y do event:y\n\n\t###\n\tReturns a Number representing a system and implementation\n\tdependent numeric code identifying the unmodified value of the\n\tpressed key; this is usually the same as keyCode.\n\n\tFor mouse-events, the returned value indicates which button was\n\tpressed on the mouse to trigger the event.\n\n\t@return {Number}\n\t###\n\tdef which do event:which\n\n\n###\n\nManager for listening to and delegating events in Imba. A single instance\nis always created by Imba (as `Imba.Events`), which handles and delegates all\nevents at the very root of the document. Imba does not capture all events\nby default, so if you want to make sure exotic or custom DOMEvents are delegated\nin Imba you will need to register them in `Imba.Events.register(myCustomEventName)`\n\n@iname manager\n\n###\nclass Imba.EventManager\n\n\tprop root\n\tprop count\n\tprop enabled default: no, watch: yes\n\tprop listeners\n\tprop delegators\n\tprop delegator\n\n\tdef enabled-did-set bool\n\t\tbool ? onenable : ondisable\n\t\tself\n\n\tdef initialize node, events: []\n\t\troot = node\n\t\tcount = 0\n\t\tlisteners = []\n\t\tdelegators = {}\n\t\tdelegator = do |e| \n\t\t\t# console.log \"delegating event?! {e}\"\n\t\t\tdelegate(e)\n\t\t\treturn true\n\n\t\tfor event in events\n\t\t\tregister(event)\n\n\t\treturn self\n\n\t###\n\n\tTell the current EventManager to intercept and handle event of a certain name.\n\tBy default, Imba.Events will register interceptors for: *keydown*, *keyup*, \n\t*keypress*, *textInput*, *input*, *change*, *submit*, *focusin*, *focusout*, \n\t*blur*, *contextmenu*, *dblclick*, *mousewheel*, *wheel*\n\n\t###\n\tdef register name, handler = true\n\t\tif name isa Array\n\t\t\tregister(v,handler) for v in name\n\t\t\treturn self\n\n\t\treturn self if delegators[name]\n\t\t# console.log(\"register for event {name}\")\n\t\tvar fn = delegators[name] = handler isa Function ? handler : delegator\n\t\troot.addEventListener(name,fn,yes) if enabled\n\n\tdef listen name, handler, capture = yes\n\t\tlisteners.push([name,handler,capture])\n\t\troot.addEventListener(name,handler,capture) if enabled\n\t\tself\n\n\tdef delegate e\n\t\tcount += 1\n\t\tvar event = Imba.Event.wrap(e)\n\t\tevent.process\n\t\tself\n\n\tdef create type, target, data: null, source: null\n\t\tvar event = Imba.Event.wrap type: type, target: target\n\t\tevent.data = data if data\n\t\tevent.source = source if source\n\t\tevent\n\n\t# use create instead?\n\tdef trigger\n\t\tcreate(*arguments).process\n\n\tdef onenable\n\t\tfor own name,handler of delegators\n\t\t\troot.addEventListener(name,handler,yes)\n\n\t\tfor item in listeners\n\t\t\troot.addEventListener(item[0],item[1],item[2])\n\t\tself\n\n\tdef ondisable\n\t\tfor own name,handler of delegators\n\t\t\troot.removeEventListener(name,handler,yes)\n\n\t\tfor item in listeners\n\t\t\troot.removeEventListener(item[0],item[1],item[2])\n\t\tself\n\t\t\n\nED = Imba.Events = Imba.EventManager.new(document, events: [\n\t:keydown,:keyup,:keypress,:textInput,:input,:change,:submit,\n\t:focusin,:focusout,:blur,:contextmenu,:dblclick,\n\t:mousewheel,:wheel,:scroll\n])\n\n# should set these up inside the Imba.Events object itself\n# so that we can have different EventManager for different roots\n\nif hasTouchEvents\n\tImba.Events.listen(:touchstart) do |e|\n\t\tImba.Events.count++\n\t\tImba.Touch.ontouchstart(e)\n\n\tImba.Events.listen(:touchmove) do |e|\n\t\tImba.Events.count++\n\t\tImba.Touch.ontouchmove(e)\n\n\tImba.Events.listen(:touchend) do |e|\n\t\tImba.Events.count++\n\t\tImba.Touch.ontouchend(e)\n\n\tImba.Events.listen(:touchcancel) do |e|\n\t\tImba.Events.count++\n\t\tImba.Touch.ontouchcancel(e)\n\nImba.Events.register(:click) do |e|\n\t# Only for main mousebutton, no?\n\tif (e:timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout\n\t\tvar tap = Imba.Event.new(e)\n\t\ttap.type = 'tap'\n\t\ttap.process\n\t\tif tap.@responder\n\t\t\treturn e.preventDefault\n\t# delegate the real click event\n\tImba.Events.delegate(e)\n\nImba.Events.listen(:mousedown) do |e|\n\tif (e:timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout\n\t\tImba.POINTER.update(e).process if Imba.POINTER\n\n# Imba.Events.listen(:mousemove) do |e|\n# \t# console.log 'mousemove',e:timeStamp\n# \tif (e:timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout\n# \t\tImba.POINTER.update(e).process if Imba.POINTER # .process if touch # should not happen? We process through \n\nImba.Events.listen(:mouseup) do |e|\n\t# console.log 'mouseup',e:timeStamp\n\tif (e:timeStamp - lastNativeTouchTimeStamp) > lastNativeTouchTimeout\n\t\tImba.POINTER.update(e).process if Imba.POINTER\n\n\nImba.Events.register([:mousedown,:mouseup])\nImba.Events.enabled = yes\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.events.imba\n **/","var ImbaTag = Imba.TAGS:element\n\ndef removeNested root, node, caret\n\t# if node/nodes isa String\n\t# \twe need to use the caret to remove elements\n\t# \tfor now we will simply not support this\n\tif node isa ImbaTag\n\t\troot.removeChild(node)\n\telif node isa Array\n\t\tremoveNested(root,member,caret) for member in node\n\telse\n\t\t# what if this is not null?!?!?\n\t\t# take a chance and remove a text-elementng\n\t\tlet next = caret ? caret:nextSibling : root.@dom:firstChild\n\t\tif next isa Text and next:textContent == node\n\t\t\troot.removeChild(next)\n\t\telse\n\t\t\tthrow 'cannot remove string'\n\n\treturn caret\n\ndef appendNested root, node\n\tif node isa ImbaTag\n\t\troot.appendChild(node)\n\n\telif node isa Array\n\t\tappendNested(root,member) for member in node\n\n\telif node != null and node !== false\n\t\troot.appendChild Imba.document.createTextNode(node)\n\n\treturn\n\n\n# insert nodes before a certain node\n# does not need to return any tail, as before\n# will still be correct there\n# before must be an actual domnode\ndef insertNestedBefore root, node, before\n\tif node isa ImbaTag\n\t\troot.insertBefore(node,before)\n\telif node isa Array\n\t\tinsertNestedBefore(root,member,before) for member in node\n\telif node != null and node !== false\n\t\troot.insertBefore(Imba.document.createTextNode(node),before)\n\n\treturn before\n\n# after must be an actual domnode\ndef insertNestedAfter root, node, after\n\tvar before = after ? after:nextSibling : root.@dom:firstChild\n\n\tif before\n\t\tinsertNestedBefore(root,node,before)\n\t\treturn before:previousSibling\n\telse\n\t\tappendNested(root,node)\n\t\treturn root.@dom:lastChild\n\ndef reconcileCollectionChanges root, new, old, caret\n\n\tvar newLen = new:length\n\tvar lastNew = new[newLen - 1]\n\n\t# This re-order algorithm is based on the following principle:\n\t# \n\t# We build a \"chain\" which shows which items are already sorted.\n\t# If we're going from [1, 2, 3] -> [2, 1, 3], the tree looks like:\n\t#\n\t# \t3 ->  0 (idx)\n\t# \t2 -> -1 (idx)\n\t# \t1 -> -1 (idx)\n\t#\n\t# This tells us that we have two chains of ordered items:\n\t# \n\t# \t(1, 3) and (2)\n\t# \n\t# The optimal re-ordering then becomes two keep the longest chain intact,\n\t# and move all the other items.\n\n\tvar newPosition = []\n\n\t# The tree/graph itself\n\tvar prevChain = []\n\t# The length of the chain\n\tvar lengthChain = []\n\n\t# Keep track of the longest chain\n\tvar maxChainLength = 0\n\tvar maxChainEnd = 0\n\n\tfor node, idx in old\n\t\tvar newPos = new.indexOf(node)\n\t\tnewPosition.push(newPos)\n\n\t\tif newPos == -1\n\t\t\troot.removeChild(node)\n\t\t\tprevChain.push(-1)\n\t\t\tlengthChain.push(-1)\n\t\t\tcontinue\n\n\t\tvar prevIdx = newPosition:length - 2\n\n\t\t# Build the chain:\n\t\twhile prevIdx >= 0\n\t\t\tif newPosition[prevIdx] == -1\n\t\t\t\tprevIdx--\n\t\t\telif newPos > newPosition[prevIdx]\n\t\t\t\t# Yay, we're bigger than the previous!\n\t\t\t\tbreak\n\t\t\telse\n\t\t\t\t# Nope, let's walk back the chain\n\t\t\t\tprevIdx = prevChain[prevIdx]\n\n\t\tprevChain.push(prevIdx)\n\n\t\tvar currLength = (prevIdx == -1) ? 0 : lengthChain[prevIdx]+1\n\n\t\tif currLength > maxChainLength\n\t\t\tmaxChainLength = currLength\n\t\t\tmaxChainEnd = idx\n\n\t\tlengthChain.push(currLength)\n\n\tvar stickyNodes = []\n\n\t# Now we can walk the longest chain backwards and mark them as \"sticky\",\n\t# which implies that they should not be moved\n\tvar cursor = newPosition:length - 1\n\twhile cursor >= 0\n\t\tif cursor == maxChainEnd and newPosition[cursor] != -1\n\t\t\tstickyNodes[newPosition[cursor]] = true\n\t\t\tmaxChainEnd = prevChain[maxChainEnd]\n\t\t\n\t\tcursor -= 1\n\n\t# And let's iterate forward, but only move non-sticky nodes\n\tfor node, idx in new\n\t\tif !stickyNodes[idx]\n\t\t\tvar after = new[idx - 1]\n\t\t\tinsertNestedAfter(root, node, (after and after.@dom) or caret)\n\n\t# should trust that the last item in new list is the caret\n\treturn lastNew and lastNew.@dom or caret\n\n\n# expects a flat non-sparse array of nodes in both new and old, always\ndef reconcileCollection root, new, old, caret\n\tvar k = new:length\n\tvar i = k\n\tvar last = new[k - 1]\n\n\n\tif k == old:length and new[0] === old[0]\n\t\t# running through to compare\n\t\twhile i--\n\t\t\tbreak if new[i] !== old[i]\n\n\tif i == -1\n\t\treturn last and last.@dom or caret\n\telse\n\t\treturn reconcileCollectionChanges(root,new,old,caret)\n\n# the general reconciler that respects conditions etc\n# caret is the current node we want to insert things after\ndef reconcileNested root, new, old, caret\n\n\t# if new == null or new === false or new === true\n\t# \tif new === old\n\t# \t\treturn caret\n\t# \tif old && new != old\n\t# \t\tremoveNested(root,old,caret) if old\n\t# \n\t# \treturn caret\n\n\t# var skipnew = new == null or new === false or new === true\n\tvar newIsNull = new == null or new === false\n\tvar oldIsNull = old == null or old === false\n\n\n\tif new === old\n\t\t# remember that the caret must be an actual dom element\n\t\t# we should instead move the actual caret? - trust\n\t\tif newIsNull\n\t\t\treturn caret\n\t\telif new and new.@dom\n\t\t\treturn new.@dom\n\t\telse\n\t\t\treturn caret ? caret:nextSibling : root.@dom:firstChild\n\n\telif new isa Array\n\t\tif old isa Array\n\t\t\tif new:static or old:static\n\t\t\t\t# if the static is not nested - we could get a hint from compiler\n\t\t\t\t# and just skip it\n\t\t\t\tif new:static == old:static\n\t\t\t\t\tfor item,i in new\n\t\t\t\t\t\t# this is where we could do the triple equal directly\n\t\t\t\t\t\tcaret = reconcileNested(root,item,old[i],caret)\n\t\t\t\t\treturn caret\n\t\t\t\telse\n\t\t\t\t\tremoveNested(root,old,caret)\n\t\t\t\t\t\n\t\t\t\t# if they are not the same we continue through to the default\n\t\t\telse\n\t\t\t\treturn reconcileCollection(root,new,old,caret)\n\n\t\telif old isa ImbaTag\n\t\t\troot.removeChild(old)\n\t\telif !oldIsNull\n\t\t\t# old was a string-like object?\n\t\t\troot.removeChild(caret ? caret:nextSibling : root.@dom:firstChild)\t\t\t\n\n\t\treturn insertNestedAfter(root,new,caret)\n\t\t# remove old\n\n\telif new isa ImbaTag\n\t\tremoveNested(root,old,caret) unless oldIsNull\n\t\tinsertNestedAfter(root,new,caret)\n\t\treturn new\n\n\telif newIsNull\n\t\tremoveNested(root,old,caret) unless oldIsNull\n\t\treturn caret\n\telse\n\t\t# if old did not exist we need to add a new directly\n\t\tlet nextNode\n\t\t# if old was array or imbatag we need to remove it and then add\n\t\tif old isa Array\n\t\t\tremoveNested(root,old,caret)\n\t\telif old isa ImbaTag\n\t\t\troot.removeChild(old)\n\t\telif !oldIsNull\n\t\t\t# ...\n\t\t\tnextNode = caret ? caret:nextSibling : root.@dom:firstChild\n\t\t\tif nextNode isa Text and nextNode:textContent != new\n\t\t\t\tnextNode:textContent = new\n\t\t\t\treturn nextNode\n\n\t\t# now add the textnode\n\t\treturn insertNestedAfter(root,new,caret)\n\n\nextend tag htmlelement\n\t\n\tdef setChildren new, typ\n\t\tvar old = @children\n\t\t# var isArray = nodes isa Array\n\t\tif new === old\n\t\t\treturn self\n\n\t\tif !old\n\t\t\tempty\n\t\t\tappendNested(self,new)\n\n\t\telif typ == 2\n\t\t\treturn self\n\n\t\telif typ == 1\n\t\t\t# here we _know _that it is an array with the same shape\n\t\t\t# every time\n\t\t\tlet caret = null\n\t\t\tfor item,i in new\n\t\t\t\t# prev = old[i]\n\t\t\t\tcaret = reconcileNested(self,item,old[i],caret)\n\n\t\telif typ == 3\n\t\t\t# this is possibly fully dynamic. It often is\n\t\t\t# but the old or new could be static while the other is not\n\t\t\t# this is not handled now\n\t\t\t# what if it was previously a static array? edgecase - but must work\n\t\t\tif new isa ImbaTag\n\t\t\t\tempty\n\t\t\t\tappendChild(new)\n\n\t\t\t# check if old and new isa array\n\t\t\telif new isa Array\n\t\t\t\tif old isa Array\n\t\t\t\t\t# is this not the same as setting staticChildren now but with the\n\t\t\t\t\treconcileCollection(self,new,old,null)\n\t\t\t\telse\n\t\t\t\t\tempty\n\t\t\t\t\tappendNested(self,new)\n\t\t\t\t\n\t\t\telse\n\t\t\t\ttext = new\n\t\t\t\treturn self\n\n\t\telif new isa Array and old isa Array\n\t\t\treconcileCollection(self,new,old,null)\n\t\telse\n\t\t\tempty\n\t\t\tappendNested(self,new)\n\n\t\t@children = new\n\t\treturn self\n\n\n\t# only ever called with array as argument\n\tdef setStaticChildren new\n\t\tvar old = @children\n\n\t\tlet caret = null\n\t\tfor item,i in new\n\t\t\t# prev = old[i]\n\t\t\tcaret = reconcileNested(self,item,old[i],caret)\n\n\t\t@children = new\n\t\treturn self\n\n\tdef content\n\t\t@content or children.toArray\n\n\tdef text= text\n\t\tif text != @children\n\t\t\t@children = text\n\t\t\tdom:textContent = text == null or text === false ? '' : text\n\t\tself\n\n\n/** WEBPACK FOOTER **\n ** src/imba/dom.static.imba\n **/","\n###\nThe special syntax for selectors in Imba creates Imba.Selector\ninstances.\n###\nclass Imba.Selector\n\t\n\tdef self.one sel, scope\n\t\tvar el = (scope || Imba.document).querySelector(sel)\n\t\tel && tag(el) || null\n\n\tdef self.all sel, scope\n\t\tImba.Selector.new(sel,scope)\n\n\tprop query\n\n\tdef initialize sel, scope, nodes\n\n\t\t@query = sel isa Imba.Selector ? sel.query : sel\n\t\t@context = scope\n\n\t\tif nodes\n\t\t\t@nodes = (tag(node) for node in nodes)\n\n\t\t@lazy = !nodes\n\t\treturn self\n\n\tdef reload\n\t\t@nodes = null\n\t\tself\n\n\tdef scope\n\t\treturn @scope if @scope\n\t\treturn Imba.document unless var ctx = @context\n\t\t@scope = ctx:toScope ? ctx.toScope : ctx\n\n\t###\n\t@returns {Imba.Tag} first node matching this selector\n\t###\n\tdef first\n\t\tif @lazy then tag(@first ||= scope.querySelector(query))\n\t\telse nodes[0]\n\n\t###\n\t@returns {Imba.Tag} last node matching this selector\n\t###\n\tdef last\n\t\tnodes[@nodes:length - 1]\n\n\t###\n\t@returns [Imba.Tag] all nodes matching this selector\n\t###\n\tdef nodes\n\t\treturn @nodes if @nodes\n\t\tvar items = scope.querySelectorAll(query)\n\t\t@nodes = (tag(node) for node in items)\n\t\t@lazy = no\n\t\t@nodes\n\t\n\t###\n\tThe number of nodes matching this selector\n\t###\n\tdef count do nodes:length\n\n\tdef len do nodes:length\n\n\t###\n\t@todo Add support for block or selector?\n\t###\n\tdef some\n\t\tcount >= 1\n\t\n\t###\n\tGet node at index\n\t###\n\tdef at idx\n\t\tnodes[idx]\n\n\t###\n\tLoop through nodes\n\t###\n\tdef forEach block\n\t\tnodes.forEach(block)\n\t\tself\n\n\t###\n\tMap nodes\n\t###\n\tdef map block\n\t\tnodes.map(block)\n\n\t###\n\tReturns a plain array containing nodes. Implicitly called\n\twhen iterating over a selector in Imba `(node for node in $(selector))`\n\t###\n\tdef toArray\n\t\tnodes\n\t\n\t# Get the first element that matches the selector, \n\t# beginning at the current element and progressing up through the DOM tree\n\tdef closest sel\n\t\t# seems strange that we alter this selector?\n\t\t@nodes = map do |node| node.closest(sel)\n\t\tself\n\n\t# Get the siblings of each element in the set of matched elements, \n\t# optionally filtered by a selector.\n\t# TODO remove duplicates?\n\tdef siblings sel\n\t\t@nodes = map do |node| node.siblings(sel)\n\t\tself\n\n\t# Get the descendants of each element in the current set of matched \n\t# elements, filtered by a selector.\n\tdef find sel\n\t\t@nodes = __query__(sel.query, nodes)\n\t\tself\n\n\tdef reject blk\n\t\tfilter(blk,no)\n\n\t###\n\tFilter the nodes in selector by a function or other selector\n\t###\n\tdef filter blk, bool = yes\n\t\tvar fn = blk isa Function and blk or (|n| n.matches(blk) )\n\t\tvar ary = nodes.filter(|n| fn(n) == bool)\n\t\t# if we want to return a new selector for this, we should do that for\n\t\t# others as well\n\t\tImba.Selector.new(\"\", @scope, ary)\n\n\tdef __query__ query, contexts\n\t\tvar nodes = []\n\t\tvar i = 0\n\t\tvar l = contexts:length\n\n\t\twhile i < l\n\t\t\tnodes.push(*contexts[i++].querySelectorAll(query))\n\t\treturn nodes\n\n\tdef __matches__\n\t\treturn yes\n\n\t###\n\tAdd specified flag to all nodes in selector\n\t###\n\tdef flag flag\n\t\tforEach do |n| n.flag(flag)\n\n\t###\n\tRemove specified flag from all nodes in selector\n\t###\n\tdef unflag flag\n\t\tforEach do |n| n.unflag(flag)\n\n\n# def Imba.querySelectorAll\nq$ = do |sel,scope| Imba.Selector.new(sel, scope)\n\n# def Imba.Selector.one\nq$$ = do |sel,scope| \n\tvar el = (scope || Imba.document).querySelector(sel)\n\tel && tag(el) || nil\n\n\n# extending tags with query-methods\n# must be a better way to reopen classes\nextend tag element\n\tdef querySelectorAll q do @dom.querySelectorAll q\n\tdef querySelector q do @dom.querySelector q\n\n\t# should be moved to Imba.Tag instead?\n\t# or we should implement all of them here\n\tdef find sel do Imba.Selector.new(sel,self)\n\n\n\n\n/** WEBPACK FOOTER **\n ** src/imba/selector.imba\n **/"],"sourceRoot":""}