docs: function()
  	{
  		var model, attr, result, result2, modelPathArray, i, ret, modelArgs;
  		var dataBindAttr = this.element.getAttribute(settings.DATA_BIND_ATTR);
  		var modelName;
  
  		this._modelBindersMap = new BinderMap();
  
  		if(dataBindAttr == null) return;
  
  		var parsedBindings = matchBindings(dataBindAttr);
  
  		if(process.env.NODE_ENV !== 'production')
  		{
  			if(parsedBindings.error)
  			{
  				if(this.element && this.element.parentNode)
  				{
  					this.element.parentNode.scrollIntoView();
  					this.element.parentNode.style.outline = '2px dashed red';
  				}
  				console.error('Error parsing binding expression: ');
  				console.error(parsedBindings.error);
  				console.log(this.element);
  			}
  		}
  
  		if(parsedBindings.match && parsedBindings.match.bindings)
  		{
  			parsedBindings = parsedBindings.match.bindings;
  
  			for(var i = 0, l = parsedBindings.length; i < l; i++)
  			{
  				var parsedBinding = parsedBindings[i];
  
  				if(parsedBinding.binder === 'each')
  				{
  					if(process.env.NODE_ENV !== 'production')
  					{
  						if(this._collectionBinder)
  						{
  							if(this.element && this.element.parentNode)
  							{
  								this.element.parentNode.scrollIntoView();
  								this.element.parentNode.style.outline = '2px dashed red';
  							}
  							console.error('You cannot have two :each binders on the same element');
  							console.log(this.element);
  						}
  					}
  					if(!this.options.isBoundView)
  					{
  						var animate = null;
  						var keyProp = null;
  						var alias = null;
  
  						if(parsedBinding.operators)
  						{
  							for(var j = 0, k = parsedBinding.operators.length; j < k; j++)
  							{
  								var operator = parsedBinding.operators[j];
  								if(operator.args.length >= 1 && operator.args[0].type === 'ident')
  								{
  									if(operator.name === 'animate') animate = operator.args[0].value;
  									if(operator.name === 'key') keyProp = operator.args[0].value;
  									if(operator.name === 'as') alias = operator.args[0].value;
  								}
  							}
  						}
  
  						this._collectionBinder = new CollectionBinder({
  							view: this,
  							keyPath: parsedBinding.keyPath,
  							collectionArgs: parsedBinding.modelArgs,
  							animate: animate,
  							keyProp: keyProp
  						});
  
  						if(alias)
  						{
  							this._itemAlias = alias;
  						}
  						else this._itemAlias = settings.defaultItemAlias;
  					}
  				}
  				else
  				{
  					if(!(parsedBinding.binder in View.binders)) break;
  
  					var scope = this.scope;
  					var isIdent = function(v){ return v != null && v.type === 'ident'; }
  					var identToParser = function(v)
  					{
  						if(scope[v.value]) return { fn: scope[v.value], args: [] };
  						else if(View.helpers[v.value]) return { fn: View.helpers[v.value], args: [] };
  					}
  					var argToValue = function(v)
  					{
  						return v.value;
  					}
  					var isNotNull = function(v)
  					{
  						return v != null;
  					}
  
  					var binderConfig = {
  						view: this,
  						element: this.element,
  						params: parsedBinding.binderArgs.filter(isNotNull),
  						keyPath: parsedBinding.keyPath,
  						modelArgs: parsedBinding.modelArgs.filter(isNotNull),
  						formatters: [],
  						parsers: [],
  						dispatch: null,
  						// dispatchNamedParams: ret.dispatchNamedParams,
  						eventNames: [],
  						eventFilters: null,
  						fill: false,
  						nopreventdef: false,
  						animate: null,
  						indexed: false
  					};
  
  
  					for(var j = 0, k = parsedBinding.operators.length; j < k; j++)
  					{
  						var operator = parsedBinding.operators[j];
  						switch(operator.name)
  						{
  							case 'format':
  							case 'f':
  								binderConfig.formatters = operator.args.filter(isIdent).map(identToParser);
  								break;
  							case 'parse':
  							case 'p':
  								binderConfig.parsers = operator.args.filter(isIdent).map(identToParser);
  								break;
  							case 'dispatch':
  								if(operator.args.length > 0)
  								{
  									binderConfig.dispatch = operator.args;
  								}
  								break;
  							case 'on':
  								if(operator.args.length > 0)
  								{
  									binderConfig.eventNames = operator.args.filter(isIdent).map(argToValue);
  								}
  								break;
  							case 'evf':
  								binderConfig.eventFilters = operator.args.filter(isIdent).map(identToParser);
  								break;
  							case 'fill':
  								binderConfig.fill = true;
  								break;
  							case 'nopreventdef':
  								binderConfig.nopreventdef = true;
  								break;
  							case 'animate':
  								binderConfig.animate = operator.args[0].value;
  								break;
  						}
  					}
  
  					for(var j = binderConfig.formatters.length - 1; j >= 0; j--)
  					{
  						if(binderConfig.formatters[j].fn.indexed === true) binderConfig.indexed = true;
  					}
  
  					var modelBinder = new View.binders[parsedBinding.binder](binderConfig);
  
  					this._modelBindersMap.add(modelBinder);
  				}
  			}
  		}
  
  		// Check for invalid combination of :each and :if binders:
  		if(process.env.NODE_ENV !== 'production')
  		{
  			var ifBinders = this._modelBindersMap.binders.filter(function(binder){ return binder instanceof View.binders.if || binder instanceof View.binders.ifnot; });
  
  			if(this._collectionBinder && ifBinders.length > 0)
  			{
  				if(this.element && this.element.parentNode)
  				{
  					this.element.parentNode.scrollIntoView();
  					this.element.parentNode.style.outline = '2px dashed red';
  				}
  				console.error('You cannot combine :each binder with :if binder on the same element');
  				console.log(this.element);
  			}
  
  			if(ifBinders.length > 2)
  			{
  				if(this.element && this.element.parentNode)
  				{
  					this.element.parentNode.scrollIntoView();
  					this.element.parentNode.style.outline = '2px dashed red';
  				}
  				console.error('You cannot combine multiple :if binders on the same element');
  				console.log(this.element);
  			}
  		}
  
  	}