text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define(factory);
  	else {
  		var a = factory();
  		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
  	}
  })(this, function() {
  return /******/ (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__) {
  
  	
  	var Parser = __webpack_require__(2)
  	var Lexer = __webpack_require__(3)
  	var config = __webpack_require__(1); 
  
  	exports.parse = function(str, options){
  	  options = options || {};
  
  	  if(options.BEGIN || options.END){
  	    if(options.BEGIN) config.BEGIN = options.BEGIN;
  	    if(options.END) config.END = options.END;
  	    Lexer.setup();
  	  }
  	  var ast = new Parser(str).parse();
  	  return options.stringify === false? ast : JSON.stringify(ast);
  	}
  
  
  
  
  /***/ },
  /* 1 */
  /***/ function(module, exports, __webpack_require__) {
  
  	
  	module.exports = {
  	'BEGIN': '{',
  	'END': '}'
  	}
  
  /***/ },
  /* 2 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(4);
  
  	var config = __webpack_require__(1);
  	var node = __webpack_require__(5);
  	var Lexer = __webpack_require__(3);
  	var varName = _.varName;
  	var ctxName = _.ctxName;
  	var isPath = _.makePredicate("STRING IDENT NUMBER");
  	var isKeyWord = _.makePredicate("true false undefined null this Array Date JSON Math NaN RegExp decodeURI decodeURIComponent encodeURI encodeURIComponent parseFloat parseInt Object");
  
  
  
  
  	function Parser(input, opts){
  	  opts = opts || {};
  
  	  this.input = input;
  	  this.tokens = new Lexer(input, opts).lex();
  	  this.pos = 0;
  	  this.noComputed =  opts.noComputed;
  	  this.length = this.tokens.length;
  	}
  
  
  	var op = Parser.prototype;
  
  
  	op.parse = function(){
  	  this.pos = 0;
  	  var res= this.program();
  	  if(this.ll().type === 'TAG_CLOSE'){
  	    this.error("You may got a unclosed Tag")
  	  }
  	  return res;
  	}
  
  	op.ll =  function(k){
  	  k = k || 1;
  	  if(k < 0) k = k + 1;
  	  var pos = this.pos + k - 1;
  	  if(pos > this.length - 1){
  	      return this.tokens[this.length-1];
  	  }
  	  return this.tokens[pos];
  	}
  	  // lookahead
  	op.la = function(k){
  	  return (this.ll(k) || '').type;
  	}
  
  	op.match = function(type, value){
  	  var ll;
  	  if(!(ll = this.eat(type, value))){
  	    ll  = this.ll();
  	    this.error('expect [' + type + (value == null? '':':'+ value) + ']" -> got "[' + ll.type + (value==null? '':':'+ll.value) + ']', ll.pos)
  	  }else{
  	    return ll;
  	  }
  	}
  
  	op.error = function(msg, pos){
  	  msg =  "Parse Error: " + msg +  ':\n' + _.trackErrorPos(this.input, typeof pos === 'number'? pos: this.ll().pos||0);
  	  throw new Error(msg);
  	}
  
  	op.next = function(k){
  	  k = k || 1;
  	  this.pos += k;
  	}
  	op.eat = function(type, value){
  	  var ll = this.ll();
  	  if(typeof type !== 'string'){
  	    for(var len = type.length ; len--;){
  	      if(ll.type === type[len]) {
  	        this.next();
  	        return ll;
  	      }
  	    }
  	  }else{
  	    if( ll.type === type && (typeof value === 'undefined' || ll.value === value) ){
  	       this.next();
  	       return ll;
  	    }
  	  }
  	  return false;
  	}
  
  	// program
  	//  :EOF
  	//  | (statement)* EOF
  	op.program = function(){
  	  var statements = [],  ll = this.ll();
  	  while(ll.type !== 'EOF' && ll.type !=='TAG_CLOSE'){
  
  	    statements.push(this.statement());
  	    ll = this.ll();
  	  }
  	  // if(ll.type === 'TAG_CLOSE') this.error("You may have unmatched Tag")
  	  return statements;
  	}
  
  	// statement
  	//  : xml
  	//  | jst
  	//  | text
  	op.statement = function(){
  	  var ll = this.ll();
  	  switch(ll.type){
  	    case 'NAME':
  	    case 'TEXT':
  	      var text = ll.value;
  	      this.next();
  	      while(ll = this.eat(['NAME', 'TEXT'])){
  	        text += ll.value;
  	      }
  	      return node.text(text);
  	    case 'TAG_OPEN':
  	      return this.xml();
  	    case 'OPEN': 
  	      return this.directive();
  	    case 'EXPR_OPEN':
  	      return this.interplation();
  	    case 'PART_OPEN':
  	      return this.template();
  	    default:
  	      this.error('Unexpected token: '+ this.la())
  	  }
  	}
  
  	// xml 
  	// stag statement* TAG_CLOSE?(if self-closed tag)
  	op.xml = function(){
  	  var name, attrs, children, selfClosed;
  	  name = this.match('TAG_OPEN').value;
  	  attrs = this.attrs();
  	  selfClosed = this.eat('/')
  	  this.match('>');
  	  if( !selfClosed && !_.isVoidTag(name) ){
  	    children = this.program();
  	    if(!this.eat('TAG_CLOSE', name)) this.error('expect </'+name+'> got'+ 'no matched closeTag')
  	  }
  	  return node.element(name, attrs, children);
  	}
  
  	// xentity
  	//  -rule(wrap attribute)
  	//  -attribute
  	//
  	// __example__
  	//  name = 1 |  
  	//  ng-hide |
  	//  on-click={{}} | 
  	//  {{#if name}}on-click={{xx}}{{#else}}on-tap={{}}{{/if}}
  
  	op.xentity = function(ll){
  	  var name = ll.value, value;
  	  if(ll.type === 'NAME'){
  	    if( this.eat("=") ) value = this.attvalue();
  	    return node.attribute( name, value );
  	  }else{
  	    if( name !== 'if') this.error("current version. ONLY RULE #if #else #elseif is valid in tag, the rule #" + name + ' is invalid');
  	    return this['if'](true);
  	  }
  
  	}
  
  	// stag     ::=    '<' Name (S attr)* S? '>'  
  	// attr    ::=     Name Eq attvalue
  	op.attrs = function(isAttribute){
  	  var eat
  	  if(!isAttribute){
  	    eat = ["NAME", "OPEN"]
  	  }else{
  	    eat = ["NAME"]
  	  }
  
  	  var attrs = [], ll;
  	  while (ll = this.eat(eat)){
  	    attrs.push(this.xentity( ll ))
  	  }
  	  return attrs;
  	}
  
  	// attvalue
  	//  : STRING  
  	//  | NAME
  	op.attvalue = function(){
  	  var ll = this.ll();
  	  switch(ll.type){
  	    case "NAME":
  	    case "UNQ":
  	    case "STRING":
  	      this.next();
  	      var value = ll.value;
  	      if(~value.indexOf(config.BEGIN) && ~value.indexOf(config.END)){
  	        var constant = true;
  	        var parsed = new Parser(value, { mode: 2 }).parse();
  	        if(parsed.length === 1 && parsed[0].type === 'expression') return parsed[0];
  	        var body = [];
  	        parsed.forEach(function(item){
  	          if(!item.constant) constant=false;
  	          // silent the mutiple inteplation
  	            body.push(item.body || "'" + item.text + "'");        
  	        });
  	        body = "[" + body.join(",") + "].join('')";
  	        value = node.expression(body, null, constant);
  	      }
  	      return value;
  	    case "EXPR_OPEN":
  	      return this.interplation();
  	    default:
  	      this.error('Unexpected token: '+ this.la())
  	  }
  	}
  
  
  	// {{#}}
  	op.directive = function(){
  	  var name = this.ll().value;
  	  this.next();
  	  if(typeof this[name] === 'function'){
  	    return this[name]()
  	  }else{
  	    this.error('Undefined directive['+ name +']');
  	  }
  	}
  
  	// {{}}
  	op.interplation = function(){
  	  this.match('EXPR_OPEN');
  	  var res = this.expression(true);
  	  this.match('END');
  	  return res;
  	}
  
  	// {{~}}
  	op.include = function(){
  	  var content = this.expression();
  	  this.match('END');
  	  return node.template(content);
  	}
  
  	// {{#if}}
  	op["if"] = function(tag){
  	  var test = this.expression();
  	  var consequent = [], alternate=[];
  
  	  var container = consequent;
  	  var statement = !tag? "statement" : "attrs";
  
  	  this.match('END');
  
  	  var ll, close;
  	  while( ! (close = this.eat('CLOSE')) ){
  	    ll = this.ll();
  	    if( ll.type === 'OPEN' ){
  	      switch( ll.value ){
  	        case 'else':
  	          container = alternate;
  	          this.next();
  	          this.match( 'END' );
  	          break;
  	        case 'elseif':
  	          this.next();
  	          alternate.push( this["if"](tag) );
  	          return node['if']( test, consequent, alternate );
  	        default:
  	          container.push( this[statement](true) );
  	      }
  	    }else{
  	      container.push(this[statement](true));
  	    }
  	  }
  	  // if statement not matched
  	  if(close.value !== "if") this.error('Unmatched if directive')
  	  return node["if"](test, consequent, alternate);
  	}
  
  
  	// @mark   mustache syntax have natrure dis, canot with expression
  	// {{#list}}
  	op.list = function(){
  	  // sequence can be a list or hash
  	  var sequence = this.expression(), variable, ll;
  	  var consequent = [], alternate=[];
  	  var container = consequent;
  
  	  this.match('IDENT', 'as');
  
  	  variable = this.match('IDENT').value;
  
  	  this.match('END');
  
  	  while( !(ll = this.eat('CLOSE')) ){
  	    if(this.eat('OPEN', 'else')){
  	      container =  alternate;
  	      this.match('END');
  	    }else{
  	      container.push(this.statement());
  	    }
  	  }
  	  if(ll.value !== 'list') this.error('expect ' + 'list got ' + '/' + ll.value + ' ', ll.pos );
  	  return node.list(sequence, variable, consequent, alternate);
  	}
  
  
  	op.expression = function(){
  	  var expression;
  	  if(this.eat('@(')){ //once bind
  	    expression = this.expr();
  	    expression.once = true;
  	    this.match(')')
  	  }else{
  	    expression = this.expr();
  	  }
  	  return expression;
  	}
  
  	op.expr = function(){
  	  this.depend = [];
  
  	  var buffer = this.filter()
  
  	  var body = buffer.get || buffer;
  	  var setbody = buffer.set;
  	  return node.expression(body, setbody, !this.depend.length);
  	}
  
  
  	// filter
  	// assign ('|' filtername[':' args]) * 
  	op.filter = function(){
  	  var left = this.assign();
  	  var ll = this.eat('|');
  	  var buffer = [], setBuffer, prefix,
  	    attr = "_t_", 
  	    set = left.set, get, 
  	    tmp = "";
  
  	  if(ll){
  	    if(set) setBuffer = [];
  
  	    prefix = "(function(" + attr + "){";
  
  	    do{
  	      tmp = attr + " = " + ctxName + "._f_('" + this.match('IDENT').value+ "' ).get.call( "+_.ctxName +"," + attr ;
  	      if(this.eat(':')){
  	        tmp +=", "+ this.arguments("|").join(",") + ");"
  	      }else{
  	        tmp += ');'
  	      }
  	      buffer.push(tmp);
  	      setBuffer && setBuffer.unshift( tmp.replace(" ).get.call", " ).set.call") );
  
  	    }while(ll = this.eat('|'));
  	    buffer.push("return " + attr );
  	    setBuffer && setBuffer.push("return " + attr);
  
  	    get =  prefix + buffer.join("") + "})("+left.get+")";
  	    // we call back to value.
  	    if(setBuffer){
  	      // change _ss__(name, _p_) to _s__(name, filterFn(_p_));
  	      set = set.replace(_.setName, 
  	        prefix + setBuffer.join("") + "})("+　_.setName　+")" );
  
  	    }
  	    // the set function is depend on the filter definition. if it have set method, the set will work
  	    return this.getset(get, set);
  	  }
  	  return left;
  	}
  
  	// assign
  	// left-hand-expr = condition
  	op.assign = function(){
  	  var left = this.condition(), ll;
  	  if(ll = this.eat(['=', '+=', '-=', '*=', '/=', '%='])){
  	    if(!left.set) this.error('invalid lefthand expression in assignment expression');
  	    return this.getset( left.set.replace("_p_", this.condition().get).replace("'='", "'"+ll.type+"'"), left.set);
  	    // return this.getset('(' + left.get + ll.type  + this.condition().get + ')', left.set);
  	  }
  	  return left;
  	}
  
  	// or
  	// or ? assign : assign
  	op.condition = function(){
  
  	  var test = this.or();
  	  if(this.eat('?')){
  	    return this.getset([test.get + "?", 
  	      this.assign().get, 
  	      this.match(":").type, 
  	      this.assign().get].join(""));
  	  }
  
  	  return test;
  	}
  
  	// and
  	// and && or
  	op.or = function(){
  
  	  var left = this.and();
  
  	  if(this.eat('||')){
  	    return this.getset(left.get + '||' + this.or().get);
  	  }
  
  	  return left;
  	}
  	// equal
  	// equal && and
  	op.and = function(){
  
  	  var left = this.equal();
  
  	  if(this.eat('&&')){
  	    return this.getset(left.get + '&&' + this.and().get);
  	  }
  	  return left;
  	}
  	// relation
  	// 
  	// equal == relation
  	// equal != relation
  	// equal === relation
  	// equal !== relation
  	op.equal = function(){
  	  var left = this.relation(), ll;
  	  // @perf;
  	  if( ll = this.eat(['==','!=', '===', '!=='])){
  	    return this.getset(left.get + ll.type + this.equal().get);
  	  }
  	  return left
  	}
  	// relation < additive
  	// relation > additive
  	// relation <= additive
  	// relation >= additive
  	// relation in additive
  	op.relation = function(){
  	  var left = this.additive(), ll;
  	  // @perf
  	  if(ll = (this.eat(['<', '>', '>=', '<=']) || this.eat('IDENT', 'in') )){
  	    return this.getset(left.get + ll.value + this.relation().get);
  	  }
  	  return left
  	}
  	// additive :
  	// multive
  	// additive + multive
  	// additive - multive
  	op.additive = function(){
  	  var left = this.multive() ,ll;
  	  if(ll= this.eat(['+','-']) ){
  	    return this.getset(left.get + ll.value + this.additive().get);
  	  }
  	  return left
  	}
  	// multive :
  	// unary
  	// multive * unary
  	// multive / unary
  	// multive % unary
  	op.multive = function(){
  	  var left = this.range() ,ll;
  	  if( ll = this.eat(['*', '/' ,'%']) ){
  	    return this.getset(left.get + ll.type + this.multive().get);
  	  }
  	  return left;
  	}
  
  	op.range = function(){
  	  var left = this.unary(), ll, right;
  
  	  if(ll = this.eat('..')){
  	    right = this.unary();
  	    var body = 
  	      "(function(start,end){var res = [],step=end>start?1:-1; for(var i = start; end>start?i <= end: i>=end; i=i+step){res.push(i); } return res })("+left.get+","+right.get+")"
  	    return this.getset(body);
  	  }
  
  	  return left;
  	}
  
  
  
  	// lefthand
  	// + unary
  	// - unary
  	// ~ unary
  	// ! unary
  	op.unary = function(){
  	  var ll;
  	  if(ll = this.eat(['+','-','~', '!'])){
  	    return this.getset('(' + ll.type + this.unary().get + ')') ;
  	  }else{
  	    return this.member()
  	  }
  	}
  
  	// call[lefthand] :
  	// member args
  	// member [ expression ]
  	// member . ident  
  
  	op.member = function(base, last, pathes, prevBase){
  	  var ll, path;
  
  
  	  var onlySimpleAccessor = false;
  	  if(!base){ //first
  	    path = this.primary();
  	    var type = typeof path;
  	    if(type === 'string'){ 
  	      pathes = [];
  	      pathes.push( path );
  	      last = path;
  	      base = ctxName + "._sg_('" + path + "', " + varName + ", 1)";
  	      onlySimpleAccessor = true;
  	    }else{ //Primative Type
  	      if(path.get === 'this'){
  	        base = ctxName;
  	        pathes = ['this'];
  	      }else{
  	        pathes = null;
  	        base = path.get;
  	      }
  	    }
  	  }else{ // not first enter
  	    if(typeof last === 'string' && isPath( last) ){ // is valid path
  	      pathes.push(last);
  	    }else{
  	      if(pathes && pathes.length) this.depend.push(pathes);
  	      pathes = null;
  	    }
  	  }
  	  if(ll = this.eat(['[', '.', '('])){
  	    switch(ll.type){
  	      case '.':
  	          // member(object, property, computed)
  	        var tmpName = this.match('IDENT').value;
  	        prevBase = base;
  	        if( this.la() !== "(" ){ 
  	          base = ctxName + "._sg_('" + tmpName + "', " + base + ")";
  	        }else{
  	          base += "['" + tmpName + "']";
  	        }
  	        return this.member( base, tmpName, pathes,  prevBase);
  	      case '[':
  	          // member(object, property, computed)
  	        path = this.assign();
  	        prevBase = base;
  	        if( this.la() !== "(" ){ 
  	        // means function call, we need throw undefined error when call function
  	        // and confirm that the function call wont lose its context
  	          base = ctxName + "._sg_(" + path.get + ", " + base + ")";
  	        }else{
  	          base += "[" + path.get + "]";
  	        }
  	        this.match(']')
  	        return this.member(base, path, pathes, prevBase);
  	      case '(':
  	        // call(callee, args)
  	        var args = this.arguments().join(',');
  	        base =  base+"(" + args +")";
  	        this.match(')')
  	        return this.member(base, null, pathes);
  	    }
  	  }
  	  if( pathes && pathes.length ) this.depend.push( pathes );
  	  var res =  {get: base};
  	  if(last){
  	    res.set = ctxName + "._ss_(" + 
  	        (last.get? last.get : "'"+ last + "'") + 
  	        ","+ _.setName + ","+ 
  	        (prevBase?prevBase:_.varName) + 
  	        ", '=', "+ ( onlySimpleAccessor? 1 : 0 ) + ")";
  	  
  	  }
  	  return res;
  	}
  
  	/**
  	 * 
  	 */
  	op.arguments = function(end){
  	  end = end || ')'
  	  var args = [];
  	  do{
  	    if(this.la() !== end){
  	      args.push(this.assign().get)
  	    }
  	  }while( this.eat(','));
  	  return args
  	}
  
  
  	// primary :
  	// this 
  	// ident
  	// literal
  	// array
  	// object
  	// ( expression )
  
  	op.primary = function(){
  	  var ll = this.ll();
  	  switch(ll.type){
  	    case "{":
  	      return this.object();
  	    case "[":
  	      return this.array();
  	    case "(":
  	      return this.paren();
  	    // literal or ident
  	    case 'STRING':
  	      this.next();
  	      return this.getset("'" + ll.value + "'")
  	    case 'NUMBER':
  	      this.next();
  	      return this.getset(""+ll.value);
  	    case "IDENT":
  	      this.next();
  	      if(isKeyWord(ll.value)){
  	        return this.getset( ll.value );
  	      }
  	      return ll.value;
  	    default: 
  	      this.error('Unexpected Token: ' + ll.type);
  	  }
  	}
  
  	// object
  	//  {propAssign [, propAssign] * [,]}
  
  	// propAssign
  	//  prop : assign
  
  	// prop
  	//  STRING
  	//  IDENT
  	//  NUMBER
  
  	op.object = function(){
  	  var code = [this.match('{').type];
  
  	  var ll = this.eat( ['STRING', 'IDENT', 'NUMBER'] );
  	  while(ll){
  	    code.push("'" + ll.value + "'" + this.match(':').type);
  	    var get = this.assign().get;
  	    code.push(get);
  	    ll = null;
  	    if(this.eat(",") && (ll = this.eat(['STRING', 'IDENT', 'NUMBER'])) ) code.push(",");
  	  }
  	  code.push(this.match('}').type);
  	  return {get: code.join("")}
  	}
  
  	// array
  	// [ assign[,assign]*]
  	op.array = function(){
  	  var code = [this.match('[').type], item;
  	  if( this.eat("]") ){
  
  	     code.push("]");
  	  } else {
  	    while(item = this.assign()){
  	      code.push(item.get);
  	      if(this.eat(',')) code.push(",");
  	      else break;
  	    }
  	    code.push(this.match(']').type);
  	  }
  	  return {get: code.join("")};
  	}
  
  	// '(' expression ')'
  	op.paren = function(){
  	  this.match('(');
  	  var res = this.filter()
  	  res.get = '(' + res.get + ')';
  	  this.match(')');
  	  return res;
  	}
  
  	op.getset = function(get, set){
  	  return {
  	    get: get,
  	    set: set
  	  }
  	}
  
  
  
  	module.exports = Parser;
  
  
  /***/ },
  /* 3 */
  /***/ function(module, exports, __webpack_require__) {
  
  	var _ = __webpack_require__(4);
  	var config = __webpack_require__(1);
  
  	// some custom tag  will conflict with the Lexer progress
  	var conflictTag = {"}": "{", "]": "["}, map1, map2;
  	// some macro for lexer
  	var macro = {
  	  'NAME': /(?:[:_A-Za-z][-\.:_0-9A-Za-z]*)/,
  	  'IDENT': /[\$_A-Za-z][_0-9A-Za-z\$]*/,
  	  'SPACE': /[\r\n\f ]/
  	}
  
  
  	var test = /a|(b)/.exec("a");
  	var testSubCapure = test && test[1] === undefined? 
  	  function(str){ return str !== undefined }
  	  :function(str){return !!str};
  
  	function wrapHander(handler){
  	  return function(all){
  	    return {type: handler, value: all }
  	  }
  	}
  
  	function Lexer(input, opts){
  	  if(conflictTag[config.END]){
  	    this.markStart = conflictTag[config.END];
  	    this.markEnd = config.END;
  	  }
  
  	  this.input = (input||"").trim();
  	  this.opts = opts || {};
  	  this.map = this.opts.mode !== 2?  map1: map2;
  	  this.states = ["INIT"];
  	  if(opts && opts.expression){
  	     this.states.push("JST");
  	     this.expression = true;
  	  }
  	}
  
  	var lo = Lexer.prototype
  
  
  	lo.lex = function(str){
  	  str = (str || this.input).trim();
  	  var tokens = [], split, test,mlen, token, state;
  	  this.input = str, 
  	  this.marks = 0;
  	  // init the pos index
  	  this.index=0;
  	  var i = 0;
  	  while(str){
  	    i++
  	    state = this.state();
  	    split = this.map[state] 
  	    test = split.TRUNK.exec(str);
  	    if(!test){
  	      this.error('Unrecoginized Token');
  	    }
  	    mlen = test[0].length;
  	    str = str.slice(mlen)
  	    token = this._process.call(this, test, split, str)
  	    if(token) tokens.push(token)
  	    this.index += mlen;
  	    // if(state == 'TAG' || state == 'JST') str = this.skipspace(str);
  	  }
  
  	  tokens.push({type: 'EOF'});
  
  	  return tokens;
  	}
  
  	lo.error = function(msg){
  	  throw "Parse Error: " + msg +  ':\n' + _.trackErrorPos(this.input, this.index);
  	}
  
  	lo._process = function(args, split,str){
  	  // console.log(args.join(","), this.state())
  	  var links = split.links, marched = false, token;
  
  	  for(var len = links.length, i=0;i<len ;i++){
  	    var link = links[i],
  	      handler = link[2],
  	      index = link[0];
  	    // if(args[6] === '>' && index === 6) console.log('haha')
  	    if(testSubCapure(args[index])) {
  	      marched = true;
  	      if(handler){
  	        token = handler.apply(this, args.slice(index, index + link[1]))
  	        if(token)  token.pos = this.index;
  	      }
  	      break;
  	    }
  	  }
  	  if(!marched){ // in ie lt8 . sub capture is "" but ont 
  	    switch(str.charAt(0)){
  	      case "<":
  	        this.enter("TAG");
  	        break;
  	      default:
  	        this.enter("JST");
  	        break;
  	    }
  	  }
  	  return token;
  	}
  	lo.enter = function(state){
  	  this.states.push(state)
  	  return this;
  	}
  
  	lo.state = function(){
  	  var states = this.states;
  	  return states[states.length-1];
  	}
  
  	lo.leave = function(state){
  	  var states = this.states;
  	  if(!state || states[states.length-1] === state) states.pop()
  	}
  
  
  	Lexer.setup = function(){
  	  macro.END = config.END;
  	  macro.BEGIN = config.BEGIN;
  	  //
  	  map1 = genMap([
  	    // INIT
  	    rules.ENTER_JST,
  	    rules.ENTER_TAG,
  	    rules.TEXT,
  
  	    //TAG
  	    rules.TAG_NAME,
  	    rules.TAG_OPEN,
  	    rules.TAG_CLOSE,
  	    rules.TAG_PUNCHOR,
  	    rules.TAG_ENTER_JST,
  	    rules.TAG_UNQ_VALUE,
  	    rules.TAG_STRING,
  	    rules.TAG_SPACE,
  	    rules.TAG_COMMENT,
  
  	    // JST
  	    rules.JST_OPEN,
  	    rules.JST_CLOSE,
  	    rules.JST_COMMENT,
  	    rules.JST_EXPR_OPEN,
  	    rules.JST_IDENT,
  	    rules.JST_SPACE,
  	    rules.JST_LEAVE,
  	    rules.JST_NUMBER,
  	    rules.JST_PUNCHOR,
  	    rules.JST_STRING,
  	    rules.JST_COMMENT
  	    ])
  
  	  // ignored the tag-relative token
  	  map2 = genMap([
  	    // INIT no < restrict
  	    rules.ENTER_JST2,
  	    rules.TEXT,
  	    // JST
  	    rules.JST_COMMENT,
  	    rules.JST_OPEN,
  	    rules.JST_CLOSE,
  	    rules.JST_EXPR_OPEN,
  	    rules.JST_IDENT,
  	    rules.JST_SPACE,
  	    rules.JST_LEAVE,
  	    rules.JST_NUMBER,
  	    rules.JST_PUNCHOR,
  	    rules.JST_STRING,
  	    rules.JST_COMMENT
  	    ])
  	}
  
  
  	function genMap(rules){
  	  var rule, map = {}, sign;
  	  for(var i = 0, len = rules.length; i < len ; i++){
  	    rule = rules[i];
  	    sign = rule[2] || 'INIT';
  	    ( map[sign] || (map[sign] = {rules:[], links:[]}) ).rules.push(rule);
  	  }
  	  return setup(map);
  	}
  
  	function setup(map){
  	  var split, rules, trunks, handler, reg, retain, rule;
  	  function replaceFn(all, one){
  	    return typeof macro[one] === 'string'? 
  	      _.escapeRegExp(macro[one]) 
  	      : String(macro[one]).slice(1,-1);
  	  }
  
  	  for(var i in map){
  
  	    split = map[i];
  	    split.curIndex = 1;
  	    rules = split.rules;
  	    trunks = [];
  
  	    for(var j = 0,len = rules.length; j<len; j++){
  	      rule = rules[j]; 
  	      reg = rule[0];
  	      handler = rule[1];
  
  	      if(typeof handler === 'string'){
  	        handler = wrapHander(handler);
  	      }
  	      if(_.typeOf(reg) === 'regexp') reg = reg.toString().slice(1, -1);
  
  	      reg = reg.replace(/\{(\w+)\}/g, replaceFn)
  	      retain = _.findSubCapture(reg) + 1; 
  	      split.links.push([split.curIndex, retain, handler]); 
  	      split.curIndex += retain;
  	      trunks.push(reg);
  	    }
  	    split.TRUNK = new RegExp("^(?:(" + trunks.join(")|(") + "))")
  	  }
  	  return map;
  	}
  
  	var rules = {
  
  	  // 1. INIT
  	  // ---------------
  
  	  // mode1's JST ENTER RULE
  	  ENTER_JST: [/[^\x00<]*?(?={BEGIN})/, function(all){
  	    this.enter('JST');
  	    if(all) return {type: 'TEXT', value: all}
  	  }],
  
  	  // mode2's JST ENTER RULE
  	  ENTER_JST2: [/[^\x00]*?(?={BEGIN})/, function(all){
  	    this.enter('JST');
  	    if(all) return {type: 'TEXT', value: all}
  	  }],
  
  	  ENTER_TAG: [/[^\x00<>]*?(?=<)/, function(all){ 
  	    this.enter('TAG');
  	    if(all) return {type: 'TEXT', value: all}
  	  }],
  
  	  TEXT: [/[^\x00]+/, 'TEXT'],
  
  	  // 2. TAG
  	  // --------------------
  	  TAG_NAME: [/{NAME}/, 'NAME', 'TAG'],
  	  TAG_UNQ_VALUE: [/[^\{}&"'=><`\r\n\f ]+/, 'UNQ', 'TAG'],
  
  	  TAG_OPEN: [/<({NAME})\s*/, function(all, one){
  	    return {type: 'TAG_OPEN', value: one}
  	  }, 'TAG'],
  	  TAG_CLOSE: [/<\/({NAME})[\r\n\f ]*>/, function(all, one){
  	    this.leave();
  	    return {type: 'TAG_CLOSE', value: one }
  	  }, 'TAG'],
  
  	    // mode2's JST ENTER RULE
  	  TAG_ENTER_JST: [/(?={BEGIN})/, function(){
  	    this.enter('JST');
  	  }, 'TAG'],
  
  
  	  TAG_PUNCHOR: [/[\>\/=&]/, function(all){
  	    if(all === '>') this.leave();
  	    return {type: all, value: all }
  	  }, 'TAG'],
  	  TAG_STRING:  [ /'([^']*)'|"([^"]*)"/, function(all, one, two){ //"'
  	    var value = one || two || "";
  
  	    return {type: 'STRING', value: value}
  	  }, 'TAG'],
  
  	  TAG_SPACE: [/{SPACE}+/, null, 'TAG'],
  	  TAG_COMMENT: [/<\!--([^\x00]*?)--\>/, null ,'TAG'],
  
  	  // 3. JST
  	  // -------------------
  
  	  JST_OPEN: ['{BEGIN}#{SPACE}*({IDENT})', function(all, name){
  	    return {
  	      type: 'OPEN',
  	      value: name
  	    }
  	  }, 'JST'],
  	  JST_LEAVE: [/{END}/, function(all){
  	    if(this.markEnd === all && this.expression) return {type: this.markEnd, value: this.markEnd};
  	    if(!this.markEnd || !this.marks ){
  	      this.firstEnterStart = false;
  	      this.leave('JST');
  	      return {type: 'END'}
  	    }else{
  	      this.marks--;
  	      return {type: this.markEnd, value: this.markEnd}
  	    }
  	  }, 'JST'],
  	  JST_CLOSE: [/{BEGIN}\s*\/({IDENT})\s*{END}/, function(all, one){
  	    this.leave('JST');
  	    return {
  	      type: 'CLOSE',
  	      value: one
  	    }
  	  }, 'JST'],
  	  JST_COMMENT: [/{BEGIN}\!([^\x00]*?)\!{END}/, function(){
  	    this.leave();
  	  }, 'JST'],
  	  JST_EXPR_OPEN: ['{BEGIN}',function(all, one){
  	    if(all === this.markStart){
  	      if(this.expression) return { type: this.markStart, value: this.markStart };
  	      if(this.firstEnterStart || this.marks){
  	        this.marks++
  	        this.firstEnterStart = false;
  	        return { type: this.markStart, value: this.markStart };
  	      }else{
  	        this.firstEnterStart = true;
  	      }
  	    }
  	    return {
  	      type: 'EXPR_OPEN',
  	      escape: false
  	    }
  
  	  }, 'JST'],
  	  JST_IDENT: ['{IDENT}', 'IDENT', 'JST'],
  	  JST_SPACE: [/[ \r\n\f]+/, null, 'JST'],
  	  JST_PUNCHOR: [/[=!]?==|[-=><+*\/%\!]?\=|\|\||&&|\@\(|\.\.|[<\>\[\]\(\)\-\|\{}\+\*\/%?:\.!,]/, function(all){
  	    return { type: all, value: all }
  	  },'JST'],
  
  	  JST_STRING:  [ /'([^']*)'|"([^"]*)"/, function(all, one, two){ //"'
  	    return {type: 'STRING', value: one || two || ""}
  	  }, 'JST'],
  	  JST_NUMBER: [/(?:[0-9]*\.[0-9]+|[0-9]+)(e\d+)?/, function(all){
  	    return {type: 'NUMBER', value: parseFloat(all, 10)};
  	  }, 'JST']
  	}
  
  
  	// setup when first config
  	Lexer.setup();
  
  
  
  	module.exports = Lexer;
  
  
  /***/ },
  /* 4 */
  /***/ function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {__webpack_require__(6);
  	var _  = module.exports;
  	var entities = __webpack_require__(7);
  	var slice = [].slice;
  	var o2str = ({}).toString;
  	var win = typeof window !=='undefined'? window: global;
  
  
  	_.noop = function(){};
  	_.uid = (function(){
  	  var _uid=0;
  	  return function(){
  	    return _uid++;
  	  }
  	})();
  
  	_.varName = '_d_';
  	_.setName = '_p_';
  	_.ctxName = '_c_';
  
  	_.rWord = /^[\$\w]+$/;
  	_.rSimpleAccessor = /^[\$\w]+(\.[\$\w]+)*$/;
  
  	_.nextTick = typeof setImmediate === 'function'? 
  	  setImmediate.bind(win) : 
  	  function(callback) {
  	    setTimeout(callback, 0) 
  	  }
  
  
  
  	var prefix =  "var " + _.ctxName + "=context.$context||context;" + "var " + _.varName + "=context.data;";
  
  
  	_.host = "data";
  
  
  	_.slice = function(obj, start, end){
  	  var res = [];
  	  for(var i = start || 0, len = end || obj.length; i < len; i++){
  	    var item = obj[i];
  	    res.push(item)
  	  }
  	  return res;
  	}
  
  	_.typeOf = function (o) {
  	  return o == null ? String(o) : ({}).toString.call(o).slice(8, -1).toLowerCase();
  	}
  
  
  	_.extend = function( o1, o2, override ){
  	  if(_.typeOf(override) === 'array'){
  	   for(var i = 0, len = override.length; i < len; i++ ){
  	    var key = override[i];
  	    o1[key] = o2[key];
  	   } 
  	  }else{
  	    for(var i in o2){
  	      if( typeof o1[i] === "undefined" || override === true ){
  	        o1[i] = o2[i]
  	      }
  	    }
  	  }
  	  return o1;
  	}
  
  	_.makePredicate = function makePredicate(words, prefix) {
  	    if (typeof words === "string") {
  	        words = words.split(" ");
  	    }
  	    var f = "",
  	    cats = [];
  	    out: for (var i = 0; i < words.length; ++i) {
  	        for (var j = 0; j < cats.length; ++j){
  	          if (cats[j][0].length === words[i].length) {
  	              cats[j].push(words[i]);
  	              continue out;
  	          }
  	        }
  	        cats.push([words[i]]);
  	    }
  	    function compareTo(arr) {
  	        if (arr.length === 1) return f += "return str === '" + arr[0] + "';";
  	        f += "switch(str){";
  	        for (var i = 0; i < arr.length; ++i){
  	           f += "case '" + arr[i] + "':";
  	        }
  	        f += "return true}return false;";
  	    }
  
  	    // When there are more than three length categories, an outer
  	    // switch first dispatches on the lengths, to save on comparisons.
  	    if (cats.length > 3) {
  	        cats.sort(function(a, b) {
  	            return b.length - a.length;
  	        });
  	        f += "switch(str.length){";
  	        for (var i = 0; i < cats.length; ++i) {
  	            var cat = cats[i];
  	            f += "case " + cat[0].length + ":";
  	            compareTo(cat);
  	        }
  	        f += "}";
  
  	        // Otherwise, simply generate a flat `switch` statement.
  	    } else {
  	        compareTo(words);
  	    }
  	    return new Function("str", f);
  	}
  
  
  	_.trackErrorPos = (function (){
  	  // linebreak
  	  var lb = /\r\n|[\n\r\u2028\u2029]/g;
  	  function findLine(lines, pos){
  	    var tmpLen = 0;
  	    for(var i = 0,len = lines.length; i < len; i++){
  	      var lineLen = (lines[i] || "").length;
  	      if(tmpLen + lineLen > pos) return {num: i, line: lines[i], start: pos - tmpLen};
  	      // 1 is for the linebreak
  	      tmpLen = tmpLen + lineLen + 1;
  	    }
  	    
  	  }
  	  return function(input, pos){
  	    if(pos > input.length-1) pos = input.length-1;
  	    lb.lastIndex = 0;
  	    var lines = input.split(lb);
  	    var line = findLine(lines,pos);
  	    var len = line.line.length;
  
  	    var min = line.start - 10;
  	    if(min < 0) min = 0;
  
  	    var max = line.start + 10;
  	    if(max > len) max = len;
  
  	    var remain = line.line.slice(min, max);
  	    var prefix = (line.num+1) + "> " + (min > 0? "..." : "")
  	    var postfix = max < len ? "...": "";
  
  	    return prefix + remain + postfix + "\n" + new Array(line.start + prefix.length + 1).join(" ") + "^";
  	  }
  	})();
  
  
  	var ignoredRef = /\((\?\!|\?\:|\?\=)/g;
  	_.findSubCapture = function (regStr) {
  	  var left = 0,
  	    right = 0,
  	    len = regStr.length,
  	    ignored = regStr.match(ignoredRef); // ignored uncapture
  	  if(ignored) ignored = ignored.length
  	  else ignored = 0;
  	  for (; len--;) {
  	    var letter = regStr.charAt(len);
  	    if (len === 0 || regStr.charAt(len - 1) !== "\\" ) { 
  	      if (letter === "(") left++;
  	      if (letter === ")") right++;
  	    }
  	  }
  	  if (left !== right) throw "RegExp: "+ regStr + "'s bracket is not marched";
  	  else return left - ignored;
  	};
  
  
  	_.escapeRegExp = function( str){// Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License
  	  return str.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, function(match){
  	    return '\\' + match;
  	  });
  	};
  
  
  	var rEntity = new RegExp("&(" + Object.keys(entities).join('|') + ');', 'gi');
  
  	_.convertEntity = function(chr){
  
  	  return ("" + chr).replace(rEntity, function(all, capture){
  	    return String.fromCharCode(entities[capture])
  	  });
  
  	}
  
  
  	// simple get accessor
  
  	_.createObject = function(o, props){
  	    function Foo() {}
  	    Foo.prototype = o;
  	    var res = new Foo;
  	    if(props) _.extend(res, props);
  	    return res;
  	}
  
  	_.createProto = function(fn, o){
  	    function Foo() { this.constructor = fn;}
  	    Foo.prototype = o;
  	    return (fn.prototype = new Foo());
  	}
  
  
  	/**
  	clone
  	*/
  	_.clone = function clone(obj){
  	    var type = _.typeOf(obj);
  	    if(type === 'array'){
  	      var cloned = [];
  	      for(var i=0,len = obj.length; i< len;i++){
  	        cloned[i] = obj[i]
  	      }
  	      return cloned;
  	    }
  	    if(type === 'object'){
  	      var cloned = {};
  	      for(var i in obj) if(obj.hasOwnProperty(i)){
  	        cloned[i] = obj[i];
  	      }
  	      return cloned;
  	    }
  	    return obj;
  	  }
  
  
  	_.equals = function(now, old){
  	  var type = _.typeOf(now);
  	  if(type === 'array'){
  	    var splices = ld(now, old||[]);
  	    return splices;
  	  }
  	  if(type === 'number' && typeof old === 'number'&& isNaN(now) && isNaN(old)) return true
  	  return now === old;
  	}
  
  
  	//Levenshtein_distance
  	//=================================================
  	//1. http://en.wikipedia.org/wiki/Levenshtein_distance
  	//2. github.com:polymer/observe-js
  
  	var ld = (function(){
  	  function equals(a,b){
  	    return a === b;
  	  }
  	  function ld(array1, array2){
  	    var n = array1.length;
  	    var m = array2.length;
  	    var matrix = [];
  	    for(var i = 0; i <= n; i++){
  	      matrix.push([i]);
  	    }
  	    for(var j=1;j<=m;j++){
  	      matrix[0][j]=j;
  	    }
  	    for(var i = 1; i <= n; i++){
  	      for(var j = 1; j <= m; j++){
  	        if(equals(array1[i-1], array2[j-1])){
  	          matrix[i][j] = matrix[i-1][j-1];
  	        }else{
  	          matrix[i][j] = Math.min(
  	            matrix[i-1][j]+1, //delete
  	            matrix[i][j-1]+1//add
  	            )
  	        }
  	      }
  	    }
  	    return matrix;
  	  }
  	  function whole(arr2, arr1) {
  	      var matrix = ld(arr1, arr2)
  	      var n = arr1.length;
  	      var i = n;
  	      var m = arr2.length;
  	      var j = m;
  	      var edits = [];
  	      var current = matrix[i][j];
  	      while(i>0 || j>0){
  	      // the last line
  	        if (i === 0) {
  	          edits.unshift(3);
  	          j--;
  	          continue;
  	        }
  	        // the last col
  	        if (j === 0) {
  	          edits.unshift(2);
  	          i--;
  	          continue;
  	        }
  	        var northWest = matrix[i - 1][j - 1];
  	        var west = matrix[i - 1][j];
  	        var north = matrix[i][j - 1];
  
  	        var min = Math.min(north, west, northWest);
  
  	        if (min === west) {
  	          edits.unshift(2); //delete
  	          i--;
  	          current = west;
  	        } else if (min === northWest ) {
  	          if (northWest === current) {
  	            edits.unshift(0); //no change
  	          } else {
  	            edits.unshift(1); //update
  	            current = northWest;
  	          }
  	          i--;
  	          j--;
  	        } else {
  	          edits.unshift(3); //add
  	          j--;
  	          current = north;
  	        }
  	      }
  	      var LEAVE = 0;
  	      var ADD = 3;
  	      var DELELE = 2;
  	      var UPDATE = 1;
  	      var n = 0;m=0;
  	      var steps = [];
  	      var step = {index: null, add:0, removed:[]};
  
  	      for(var i=0;i<edits.length;i++){
  	        if(edits[i] > 0 ){ // NOT LEAVE
  	          if(step.index === null){
  	            step.index = m;
  	          }
  	        } else { //LEAVE
  	          if(step.index != null){
  	            steps.push(step)
  	            step = {index: null, add:0, removed:[]};
  	          }
  	        }
  	        switch(edits[i]){
  	          case LEAVE:
  	            n++;
  	            m++;
  	            break;
  	          case ADD:
  	            step.add++;
  	            m++;
  	            break;
  	          case DELELE:
  	            step.removed.push(arr1[n])
  	            n++;
  	            break;
  	          case UPDATE:
  	            step.add++;
  	            step.removed.push(arr1[n])
  	            n++;
  	            m++;
  	            break;
  	        }
  	      }
  	      if(step.index != null){
  	        steps.push(step)
  	      }
  	      return steps
  	    }
  	    return whole;
  	  })();
  
  
  
  	_.throttle = function throttle(func, wait){
  	  var wait = wait || 100;
  	  var context, args, result;
  	  var timeout = null;
  	  var previous = 0;
  	  var later = function() {
  	    previous = +new Date;
  	    timeout = null;
  	    result = func.apply(context, args);
  	    context = args = null;
  	  };
  	  return function() {
  	    var now = + new Date;
  	    var remaining = wait - (now - previous);
  	    context = this;
  	    args = arguments;
  	    if (remaining <= 0 || remaining > wait) {
  	      clearTimeout(timeout);
  	      timeout = null;
  	      previous = now;
  	      result = func.apply(context, args);
  	      context = args = null;
  	    } else if (!timeout) {
  	      timeout = setTimeout(later, remaining);
  	    }
  	    return result;
  	  };
  	};
  
  	// hogan escape
  	// ==============
  	_.escape = (function(){
  	  var rAmp = /&/g,
  	      rLt = /</g,
  	      rGt = />/g,
  	      rApos = /\'/g,
  	      rQuot = /\"/g,
  	      hChars = /[&<>\"\']/;
  
  	  return function(str) {
  	    return hChars.test(str) ?
  	      str
  	        .replace(rAmp, '&amp;')
  	        .replace(rLt, '&lt;')
  	        .replace(rGt, '&gt;')
  	        .replace(rApos, '&#39;')
  	        .replace(rQuot, '&quot;') :
  	      str;
  	  }
  	})();
  
  	_.cache = function(max){
  	  max = max || 1000;
  	  var keys = [],
  	      cache = {};
  	  return {
  	    set: function(key, value) {
  	      if (keys.length > this.max) {
  	        cache[keys.shift()] = undefined;
  	      }
  	      // 
  	      if(cache[key] === undefined){
  	        keys.push(key);
  	      }
  	      cache[key] = value;
  	      return value;
  	    },
  	    get: function(key) {
  	      if (key === undefined) return cache;
  	      return cache[key];
  	    },
  	    max: max,
  	    len:function(){
  	      return keys.length;
  	    }
  	  };
  	}
  
  	// setup the raw Expression
  	_.touchExpression = function(expr){
  	  if(expr.type === 'expression'){
  	    if(!expr.get){
  	      expr.get = new Function("context", prefix + "return (" + expr.body + ")");
  	      expr.body = null;
  	      if(expr.setbody){
  	        expr.set = function(ctx, value){
  	          if(expr.setbody){
  	            expr.set = new Function('context', _.setName ,  prefix + expr.setbody);
  	            expr.setbody = null;
  	          }
  	          return expr.set(ctx, value);
  	        }
  	      }
  	    }
  	  }
  	  return expr;
  	}
  
  
  	// handle the same logic on component's `on-*` and element's `on-*`
  	// return the fire object
  	_.handleEvent = function(value, type ){
  	  var self = this, evaluate;
  	  if(value.type === 'expression'){ // if is expression, go evaluated way
  	    evaluate = value.get;
  	  }
  	  if(evaluate){
  	    return function fire(obj){
  	      self.data.$event = obj;
  	      var res = evaluate(self);
  	      if(res === false && obj && obj.preventDefault) obj.preventDefault();
  	      delete self.data.$event;
  	      self.$update();
  	    }
  	  }else{
  	    return function fire(){
  	      var args = slice.call(arguments)      
  	      args.unshift(value);
  	      self.$emit.apply(self.$context, args);
  	      self.$update();
  	    }
  	  }
  	}
  
  	// only call once
  	_.once = function(fn){
  	  var time = 0;
  	  return function(){
  	    if( time++ === 0) fn.apply(this, arguments);
  	  }
  	}
  
  
  
  
  
  
  
  
  	_.log = function(msg, type){
  	  if(typeof console !== "undefined")  console[type || "log"](msg);
  	}
  
  
  
  
  	//http://www.w3.org/html/wg/drafts/html/master/single-page.html#void-elements
  	_.isVoidTag = _.makePredicate("area base br col embed hr img input keygen link menuitem meta param source track wbr r-content");
  	_.isBooleanAttr = _.makePredicate('selected checked disabled readOnly required open autofocus controls autoplay compact loop defer multiple');
  
  	_.isFalse - function(){return false}
  	_.isTrue - function(){return true}
  
  
  	_.assert = function(test, msg){
  	  if(!test) throw msg;
  	}
  
  
  
  	_.defineProperty = function(){
  	  
  	}
  
  	
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ },
  /* 5 */
  /***/ function(module, exports, __webpack_require__) {
  
  	module.exports = {
  	  element: function(name, attrs, children){
  	    return {
  	      type: 'element',
  	      tag: name,
  	      attrs: attrs,
  	      children: children
  	    }
  	  },
  	  attribute: function(name, value){
  	    return {
  	      type: 'attribute',
  	      name: name,
  	      value: value
  	    }
  	  },
  	  "if": function(test, consequent, alternate){
  	    return {
  	      type: 'if',
  	      test: test,
  	      consequent: consequent,
  	      alternate: alternate
  	    }
  	  },
  	  list: function(sequence, variable, body){
  	    return {
  	      type: 'list',
  	      sequence: sequence,
  	      variable: variable,
  	      body: body
  	    }
  	  },
  	  expression: function( body, setbody, constant ){
  	    return {
  	      type: "expression",
  	      body: body,
  	      constant: constant || false,
  	      setbody: setbody || false
  	    }
  	  },
  	  text: function(text){
  	    return {
  	      type: "text",
  	      text: text
  	    }
  	  },
  	  template: function(template){
  	    return {
  	      type: 'template',
  	      content: template
  	    }
  	  }
  	}
  
  
  /***/ },
  /* 6 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// shim for es5
  	var slice = [].slice;
  	var tstr = ({}).toString;
  
  	function extend(o1, o2 ){
  	  for(var i in o2) if( o1[i] === undefined){
  	    o1[i] = o2[i]
  	  }
  	}
  
  	// String proto ;
  	extend(String.prototype, {
  	  trim: function(){
  	    return this.replace(/^\s+|\s+$/g, '');
  	  }
  	});
  
  
  	// Array proto;
  	extend(Array.prototype, {
  	  indexOf: function(obj, from){
  	    from = from || 0;
  	    for (var i = from, len = this.length; i < len; i++) {
  	      if (this[i] === obj) return i;
  	    }
  	    return -1;
  	  },
  	  forEach: function(callback, context){
  	    for (var i = 0, len = this.length; i < len; i++) {
  	      callback.call(context, this[i], i, this);
  	    }
  	  },
  	  filter: function(callback, context){
  	    var res = [];
  	    for (var i = 0, length = this.length; i < length; i++) {
  	      var pass = callback.call(context, this[i], i, this);
  	      if(pass) res.push(this[i]);
  	    }
  	    return res;
  	  },
  	  map: function(callback, context){
  	    var res = [];
  	    for (var i = 0, length = this.length; i < length; i++) {
  	      res.push(callback.call(context, this[i], i, this));
  	    }
  	    return res;
  	  }
  	});
  
  	// Function proto;
  	extend(Function.prototype, {
  	  bind: function(context){
  	    var fn = this;
  	    var preArgs = slice.call(arguments, 1);
  	    return function(){
  	      var args = preArgs.concat(slice.call(arguments));
  	      return fn.apply(context, args);
  	    }
  	  }
  	})
  
  	// Object
  	extend(Object, {
  	  keys: function(obj){
  	    var keys = [];
  	    for(var i in obj) if(obj.hasOwnProperty(i)){
  	      keys.push(i);
  	    }
  	    return keys;
  	  } 
  	})
  
  	// Date
  	extend(Date, {
  	  now: function(){
  	    return +new Date;
  	  }
  	})
  	// Array
  	extend(Array, {
  	  isArray: function(arr){
  	    return tstr.call(arr) === "[object Array]";
  	  }
  	})
  
  
  /***/ },
  /* 7 */
  /***/ function(module, exports, __webpack_require__) {
  
  	// http://stackoverflow.com/questions/1354064/how-to-convert-characters-to-html-entities-using-plain-javascript
  	var entities = {
  	  'quot':34, 
  	  'amp':38, 
  	  'apos':39, 
  	  'lt':60, 
  	  'gt':62, 
  	  'nbsp':160, 
  	  'iexcl':161, 
  	  'cent':162, 
  	  'pound':163, 
  	  'curren':164, 
  	  'yen':165, 
  	  'brvbar':166, 
  	  'sect':167, 
  	  'uml':168, 
  	  'copy':169, 
  	  'ordf':170, 
  	  'laquo':171, 
  	  'not':172, 
  	  'shy':173, 
  	  'reg':174, 
  	  'macr':175, 
  	  'deg':176, 
  	  'plusmn':177, 
  	  'sup2':178, 
  	  'sup3':179, 
  	  'acute':180, 
  	  'micro':181, 
  	  'para':182, 
  	  'middot':183, 
  	  'cedil':184, 
  	  'sup1':185, 
  	  'ordm':186, 
  	  'raquo':187, 
  	  'frac14':188, 
  	  'frac12':189, 
  	  'frac34':190, 
  	  'iquest':191, 
  	  'Agrave':192, 
  	  'Aacute':193, 
  	  'Acirc':194, 
  	  'Atilde':195, 
  	  'Auml':196, 
  	  'Aring':197, 
  	  'AElig':198, 
  	  'Ccedil':199, 
  	  'Egrave':200, 
  	  'Eacute':201, 
  	  'Ecirc':202, 
  	  'Euml':203, 
  	  'Igrave':204, 
  	  'Iacute':205, 
  	  'Icirc':206, 
  	  'Iuml':207, 
  	  'ETH':208, 
  	  'Ntilde':209, 
  	  'Ograve':210, 
  	  'Oacute':211, 
  	  'Ocirc':212, 
  	  'Otilde':213, 
  	  'Ouml':214, 
  	  'times':215, 
  	  'Oslash':216, 
  	  'Ugrave':217, 
  	  'Uacute':218, 
  	  'Ucirc':219, 
  	  'Uuml':220, 
  	  'Yacute':221, 
  	  'THORN':222, 
  	  'szlig':223, 
  	  'agrave':224, 
  	  'aacute':225, 
  	  'acirc':226, 
  	  'atilde':227, 
  	  'auml':228, 
  	  'aring':229, 
  	  'aelig':230, 
  	  'ccedil':231, 
  	  'egrave':232, 
  	  'eacute':233, 
  	  'ecirc':234, 
  	  'euml':235, 
  	  'igrave':236, 
  	  'iacute':237, 
  	  'icirc':238, 
  	  'iuml':239, 
  	  'eth':240, 
  	  'ntilde':241, 
  	  'ograve':242, 
  	  'oacute':243, 
  	  'ocirc':244, 
  	  'otilde':245, 
  	  'ouml':246, 
  	  'divide':247, 
  	  'oslash':248, 
  	  'ugrave':249, 
  	  'uacute':250, 
  	  'ucirc':251, 
  	  'uuml':252, 
  	  'yacute':253, 
  	  'thorn':254, 
  	  'yuml':255, 
  	  'fnof':402, 
  	  'Alpha':913, 
  	  'Beta':914, 
  	  'Gamma':915, 
  	  'Delta':916, 
  	  'Epsilon':917, 
  	  'Zeta':918, 
  	  'Eta':919, 
  	  'Theta':920, 
  	  'Iota':921, 
  	  'Kappa':922, 
  	  'Lambda':923, 
  	  'Mu':924, 
  	  'Nu':925, 
  	  'Xi':926, 
  	  'Omicron':927, 
  	  'Pi':928, 
  	  'Rho':929, 
  	  'Sigma':931, 
  	  'Tau':932, 
  	  'Upsilon':933, 
  	  'Phi':934, 
  	  'Chi':935, 
  	  'Psi':936, 
  	  'Omega':937, 
  	  'alpha':945, 
  	  'beta':946, 
  	  'gamma':947, 
  	  'delta':948, 
  	  'epsilon':949, 
  	  'zeta':950, 
  	  'eta':951, 
  	  'theta':952, 
  	  'iota':953, 
  	  'kappa':954, 
  	  'lambda':955, 
  	  'mu':956, 
  	  'nu':957, 
  	  'xi':958, 
  	  'omicron':959, 
  	  'pi':960, 
  	  'rho':961, 
  	  'sigmaf':962, 
  	  'sigma':963, 
  	  'tau':964, 
  	  'upsilon':965, 
  	  'phi':966, 
  	  'chi':967, 
  	  'psi':968, 
  	  'omega':969, 
  	  'thetasym':977, 
  	  'upsih':978, 
  	  'piv':982, 
  	  'bull':8226, 
  	  'hellip':8230, 
  	  'prime':8242, 
  	  'Prime':8243, 
  	  'oline':8254, 
  	  'frasl':8260, 
  	  'weierp':8472, 
  	  'image':8465, 
  	  'real':8476, 
  	  'trade':8482, 
  	  'alefsym':8501, 
  	  'larr':8592, 
  	  'uarr':8593, 
  	  'rarr':8594, 
  	  'darr':8595, 
  	  'harr':8596, 
  	  'crarr':8629, 
  	  'lArr':8656, 
  	  'uArr':8657, 
  	  'rArr':8658, 
  	  'dArr':8659, 
  	  'hArr':8660, 
  	  'forall':8704, 
  	  'part':8706, 
  	  'exist':8707, 
  	  'empty':8709, 
  	  'nabla':8711, 
  	  'isin':8712, 
  	  'notin':8713, 
  	  'ni':8715, 
  	  'prod':8719, 
  	  'sum':8721, 
  	  'minus':8722, 
  	  'lowast':8727, 
  	  'radic':8730, 
  	  'prop':8733, 
  	  'infin':8734, 
  	  'ang':8736, 
  	  'and':8743, 
  	  'or':8744, 
  	  'cap':8745, 
  	  'cup':8746, 
  	  'int':8747, 
  	  'there4':8756, 
  	  'sim':8764, 
  	  'cong':8773, 
  	  'asymp':8776, 
  	  'ne':8800, 
  	  'equiv':8801, 
  	  'le':8804, 
  	  'ge':8805, 
  	  'sub':8834, 
  	  'sup':8835, 
  	  'nsub':8836, 
  	  'sube':8838, 
  	  'supe':8839, 
  	  'oplus':8853, 
  	  'otimes':8855, 
  	  'perp':8869, 
  	  'sdot':8901, 
  	  'lceil':8968, 
  	  'rceil':8969, 
  	  'lfloor':8970, 
  	  'rfloor':8971, 
  	  'lang':9001, 
  	  'rang':9002, 
  	  'loz':9674, 
  	  'spades':9824, 
  	  'clubs':9827, 
  	  'hearts':9829, 
  	  'diams':9830, 
  	  'OElig':338, 
  	  'oelig':339, 
  	  'Scaron':352, 
  	  'scaron':353, 
  	  'Yuml':376, 
  	  'circ':710, 
  	  'tilde':732, 
  	  'ensp':8194, 
  	  'emsp':8195, 
  	  'thinsp':8201, 
  	  'zwnj':8204, 
  	  'zwj':8205, 
  	  'lrm':8206, 
  	  'rlm':8207, 
  	  'ndash':8211, 
  	  'mdash':8212, 
  	  'lsquo':8216, 
  	  'rsquo':8217, 
  	  'sbquo':8218, 
  	  'ldquo':8220, 
  	  'rdquo':8221, 
  	  'bdquo':8222, 
  	  'dagger':8224, 
  	  'Dagger':8225, 
  	  'permil':8240, 
  	  'lsaquo':8249, 
  	  'rsaquo':8250, 
  	  'euro':8364
  	}
  
  
  
  	module.exports  = entities;
  
  /***/ }
  /******/ ])
  });
  