bundle.js

this["aliceui.org"] =
/******/ (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__) {

	module.exports = __webpack_require__(110)
	window['./docs/widget.css'] = __webpack_require__(113);
	window['alice-button-dropdown'] = __webpack_require__(114);
	window['alice-select'] = __webpack_require__(115);
	window['alice-tab'] = __webpack_require__(116);
	window['arale-autocomplete'] = __webpack_require__(34);
	window['arale-dialog'] = __webpack_require__(43);
	window['arale-dialog/src/dialog.css'] = __webpack_require__(117);
	window['arale-popup'] = __webpack_require__(17);
	window['arale-switchable'] = __webpack_require__(56);
	window['arale-tip'] = __webpack_require__(59);
	window['jquery'] = __webpack_require__(2);
	window['underscore'] = __webpack_require__(68);

/***/ },
/* 1 */
/***/ function(module, exports) {

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	// css base code, injected by the css-loader
	module.exports = function() {
		var list = [];
	
		// return the list of modules as css string
		list.toString = function toString() {
			var result = [];
			for(var i = 0; i < this.length; i++) {
				var item = this[i];
				if(item[2]) {
					result.push("@media " + item[2] + "{" + item[1] + "}");
				} else {
					result.push(item[1]);
				}
			}
			return result.join("");
		};
	
		// import a list of modules into the list
		list.i = function(modules, mediaQuery) {
			if(typeof modules === "string")
				modules = [[null, modules, ""]];
			var alreadyImportedModules = {};
			for(var i = 0; i < this.length; i++) {
				var id = this[i][0];
				if(typeof id === "number")
					alreadyImportedModules[id] = true;
			}
			for(i = 0; i < modules.length; i++) {
				var item = modules[i];
				// skip already imported module
				// this implementation is not 100% perfect for weird media query combinations
				//  when a module is imported multiple times with different media queries.
				//  I hope this will never occur (Hey this way we have smaller bundles)
				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
					if(mediaQuery && !item[2]) {
						item[2] = mediaQuery;
					} else if(mediaQuery) {
						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
					}
					list.push(item);
				}
			}
		};
		return list;
	};


/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {/*!
	 * jQuery JavaScript Library v1.7.2
	 * http://jquery.com/
	 *
	 * Copyright 2011, John Resig
	 * Dual licensed under the MIT or GPL Version 2 licenses.
	 * http://jquery.org/license
	 *
	 * Includes Sizzle.js
	 * http://sizzlejs.com/
	 * Copyright 2011, The Dojo Foundation
	 * Released under the MIT, BSD, and GPL Licenses.
	 *
	 * Date: Wed Mar 21 12:46:34 2012 -0700
	 */
	(function( window, undefined ) {
	
	// Use the correct document accordingly with window argument (sandbox)
	var document = window.document,
		navigator = window.navigator,
		location = window.location;
	var jQuery = (function() {
	
	// Define a local copy of jQuery
	var jQuery = function( selector, context ) {
			// The jQuery object is actually just the init constructor 'enhanced'
			return new jQuery.fn.init( selector, context, rootjQuery );
		},
	
		// Map over jQuery in case of overwrite
		_jQuery = window.jQuery,
	
		// Map over the $ in case of overwrite
		_$ = window.$,
	
		// A central reference to the root jQuery(document)
		rootjQuery,
	
		// A simple way to check for HTML strings or ID strings
		// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
		quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
	
		// Check if a string has a non-whitespace character in it
		rnotwhite = /\S/,
	
		// Used for trimming whitespace
		trimLeft = /^\s+/,
		trimRight = /\s+$/,
	
		// Match a standalone tag
		rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
	
		// JSON RegExp
		rvalidchars = /^[\],:{}\s]*$/,
		rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
		rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
		rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
	
		// Useragent RegExp
		rwebkit = /(webkit)[ \/]([\w.]+)/,
		ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
		rmsie = /(msie) ([\w.]+)/,
		rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
	
		// Matches dashed string for camelizing
		rdashAlpha = /-([a-z]|[0-9])/ig,
		rmsPrefix = /^-ms-/,
	
		// Used by jQuery.camelCase as callback to replace()
		fcamelCase = function( all, letter ) {
			return ( letter + "" ).toUpperCase();
		},
	
		// Keep a UserAgent string for use with jQuery.browser
		userAgent = navigator.userAgent,
	
		// For matching the engine and version of the browser
		browserMatch,
	
		// The deferred used on DOM ready
		readyList,
	
		// The ready event handler
		DOMContentLoaded,
	
		// Save a reference to some core methods
		toString = Object.prototype.toString,
		hasOwn = Object.prototype.hasOwnProperty,
		push = Array.prototype.push,
		slice = Array.prototype.slice,
		trim = String.prototype.trim,
		indexOf = Array.prototype.indexOf,
	
		// [[Class]] -> type pairs
		class2type = {};
	
	jQuery.fn = jQuery.prototype = {
		constructor: jQuery,
		init: function( selector, context, rootjQuery ) {
			var match, elem, ret, doc;
	
			// Handle $(""), $(null), or $(undefined)
			if ( !selector ) {
				return this;
			}
	
			// Handle $(DOMElement)
			if ( selector.nodeType ) {
				this.context = this[0] = selector;
				this.length = 1;
				return this;
			}
	
			// The body element only exists once, optimize finding it
			if ( selector === "body" && !context && document.body ) {
				this.context = document;
				this[0] = document.body;
				this.selector = selector;
				this.length = 1;
				return this;
			}
	
			// Handle HTML strings
			if ( typeof selector === "string" ) {
				// Are we dealing with HTML string or an ID?
				if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
					// Assume that strings that start and end with <> are HTML and skip the regex check
					match = [ null, selector, null ];
	
				} else {
					match = quickExpr.exec( selector );
				}
	
				// Verify a match, and that no context was specified for #id
				if ( match && (match[1] || !context) ) {
	
					// HANDLE: $(html) -> $(array)
					if ( match[1] ) {
						context = context instanceof jQuery ? context[0] : context;
						doc = ( context ? context.ownerDocument || context : document );
	
						// If a single string is passed in and it's a single tag
						// just do a createElement and skip the rest
						ret = rsingleTag.exec( selector );
	
						if ( ret ) {
							if ( jQuery.isPlainObject( context ) ) {
								selector = [ document.createElement( ret[1] ) ];
								jQuery.fn.attr.call( selector, context, true );
	
							} else {
								selector = [ doc.createElement( ret[1] ) ];
							}
	
						} else {
							ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
							selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
						}
	
						return jQuery.merge( this, selector );
	
					// HANDLE: $("#id")
					} else {
						elem = document.getElementById( match[2] );
	
						// Check parentNode to catch when Blackberry 4.6 returns
						// nodes that are no longer in the document #6963
						if ( elem && elem.parentNode ) {
							// Handle the case where IE and Opera return items
							// by name instead of ID
							if ( elem.id !== match[2] ) {
								return rootjQuery.find( selector );
							}
	
							// Otherwise, we inject the element directly into the jQuery object
							this.length = 1;
							this[0] = elem;
						}
	
						this.context = document;
						this.selector = selector;
						return this;
					}
	
				// HANDLE: $(expr, $(...))
				} else if ( !context || context.jquery ) {
					return ( context || rootjQuery ).find( selector );
	
				// HANDLE: $(expr, context)
				// (which is just equivalent to: $(context).find(expr)
				} else {
					return this.constructor( context ).find( selector );
				}
	
			// HANDLE: $(function)
			// Shortcut for document ready
			} else if ( jQuery.isFunction( selector ) ) {
				return rootjQuery.ready( selector );
			}
	
			if ( selector.selector !== undefined ) {
				this.selector = selector.selector;
				this.context = selector.context;
			}
	
			return jQuery.makeArray( selector, this );
		},
	
		// Start with an empty selector
		selector: "",
	
		// The current version of jQuery being used
		jquery: "1.7.2",
	
		// The default length of a jQuery object is 0
		length: 0,
	
		// The number of elements contained in the matched element set
		size: function() {
			return this.length;
		},
	
		toArray: function() {
			return slice.call( this, 0 );
		},
	
		// Get the Nth element in the matched element set OR
		// Get the whole matched element set as a clean array
		get: function( num ) {
			return num == null ?
	
				// Return a 'clean' array
				this.toArray() :
	
				// Return just the object
				( num < 0 ? this[ this.length + num ] : this[ num ] );
		},
	
		// Take an array of elements and push it onto the stack
		// (returning the new matched element set)
		pushStack: function( elems, name, selector ) {
			// Build a new jQuery matched element set
			var ret = this.constructor();
	
			if ( jQuery.isArray( elems ) ) {
				push.apply( ret, elems );
	
			} else {
				jQuery.merge( ret, elems );
			}
	
			// Add the old object onto the stack (as a reference)
			ret.prevObject = this;
	
			ret.context = this.context;
	
			if ( name === "find" ) {
				ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
			} else if ( name ) {
				ret.selector = this.selector + "." + name + "(" + selector + ")";
			}
	
			// Return the newly-formed element set
			return ret;
		},
	
		// Execute a callback for every element in the matched set.
		// (You can seed the arguments with an array of args, but this is
		// only used internally.)
		each: function( callback, args ) {
			return jQuery.each( this, callback, args );
		},
	
		ready: function( fn ) {
			// Attach the listeners
			jQuery.bindReady();
	
			// Add the callback
			readyList.add( fn );
	
			return this;
		},
	
		eq: function( i ) {
			i = +i;
			return i === -1 ?
				this.slice( i ) :
				this.slice( i, i + 1 );
		},
	
		first: function() {
			return this.eq( 0 );
		},
	
		last: function() {
			return this.eq( -1 );
		},
	
		slice: function() {
			return this.pushStack( slice.apply( this, arguments ),
				"slice", slice.call(arguments).join(",") );
		},
	
		map: function( callback ) {
			return this.pushStack( jQuery.map(this, function( elem, i ) {
				return callback.call( elem, i, elem );
			}));
		},
	
		end: function() {
			return this.prevObject || this.constructor(null);
		},
	
		// For internal use only.
		// Behaves like an Array's method, not like a jQuery method.
		push: push,
		sort: [].sort,
		splice: [].splice
	};
	
	// Give the init function the jQuery prototype for later instantiation
	jQuery.fn.init.prototype = jQuery.fn;
	
	jQuery.extend = jQuery.fn.extend = function() {
		var options, name, src, copy, copyIsArray, clone,
			target = arguments[0] || {},
			i = 1,
			length = arguments.length,
			deep = false;
	
		// Handle a deep copy situation
		if ( typeof target === "boolean" ) {
			deep = target;
			target = arguments[1] || {};
			// skip the boolean and the target
			i = 2;
		}
	
		// Handle case when target is a string or something (possible in deep copy)
		if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
			target = {};
		}
	
		// extend jQuery itself if only one argument is passed
		if ( length === i ) {
			target = this;
			--i;
		}
	
		for ( ; i < length; i++ ) {
			// Only deal with non-null/undefined values
			if ( (options = arguments[ i ]) != null ) {
				// Extend the base object
				for ( name in options ) {
					src = target[ name ];
					copy = options[ name ];
	
					// Prevent never-ending loop
					if ( target === copy ) {
						continue;
					}
	
					// Recurse if we're merging plain objects or arrays
					if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
						if ( copyIsArray ) {
							copyIsArray = false;
							clone = src && jQuery.isArray(src) ? src : [];
	
						} else {
							clone = src && jQuery.isPlainObject(src) ? src : {};
						}
	
						// Never move original objects, clone them
						target[ name ] = jQuery.extend( deep, clone, copy );
	
					// Don't bring in undefined values
					} else if ( copy !== undefined ) {
						target[ name ] = copy;
					}
				}
			}
		}
	
		// Return the modified object
		return target;
	};
	
	jQuery.extend({
		noConflict: function( deep ) {
			if ( window.$ === jQuery ) {
				window.$ = _$;
			}
	
			if ( deep && window.jQuery === jQuery ) {
				window.jQuery = _jQuery;
			}
	
			return jQuery;
		},
	
		// Is the DOM ready to be used? Set to true once it occurs.
		isReady: false,
	
		// A counter to track how many items to wait for before
		// the ready event fires. See #6781
		readyWait: 1,
	
		// Hold (or release) the ready event
		holdReady: function( hold ) {
			if ( hold ) {
				jQuery.readyWait++;
			} else {
				jQuery.ready( true );
			}
		},
	
		// Handle when the DOM is ready
		ready: function( wait ) {
			// Either a released hold or an DOMready/load event and not yet ready
			if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
				// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
				if ( !document.body ) {
					return setTimeout( jQuery.ready, 1 );
				}
	
				// Remember that the DOM is ready
				jQuery.isReady = true;
	
				// If a normal DOM Ready event fired, decrement, and wait if need be
				if ( wait !== true && --jQuery.readyWait > 0 ) {
					return;
				}
	
				// If there are functions bound, to execute
				readyList.fireWith( document, [ jQuery ] );
	
				// Trigger any bound ready events
				if ( jQuery.fn.trigger ) {
					jQuery( document ).trigger( "ready" ).off( "ready" );
				}
			}
		},
	
		bindReady: function() {
			if ( readyList ) {
				return;
			}
	
			readyList = jQuery.Callbacks( "once memory" );
	
			// Catch cases where $(document).ready() is called after the
			// browser event has already occurred.
			if ( document.readyState === "complete" ) {
				// Handle it asynchronously to allow scripts the opportunity to delay ready
				return setTimeout( jQuery.ready, 1 );
			}
	
			// Mozilla, Opera and webkit nightlies currently support this event
			if ( document.addEventListener ) {
				// Use the handy event callback
				document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
	
				// A fallback to window.onload, that will always work
				window.addEventListener( "load", jQuery.ready, false );
	
			// If IE event model is used
			} else if ( document.attachEvent ) {
				// ensure firing before onload,
				// maybe late but safe also for iframes
				document.attachEvent( "onreadystatechange", DOMContentLoaded );
	
				// A fallback to window.onload, that will always work
				window.attachEvent( "onload", jQuery.ready );
	
				// If IE and not a frame
				// continually check to see if the document is ready
				var toplevel = false;
	
				try {
					toplevel = window.frameElement == null;
				} catch(e) {}
	
				if ( document.documentElement.doScroll && toplevel ) {
					doScrollCheck();
				}
			}
		},
	
		// See test/unit/core.js for details concerning isFunction.
		// Since version 1.3, DOM methods and functions like alert
		// aren't supported. They return false on IE (#2968).
		isFunction: function( obj ) {
			return jQuery.type(obj) === "function";
		},
	
		isArray: Array.isArray || function( obj ) {
			return jQuery.type(obj) === "array";
		},
	
		isWindow: function( obj ) {
			return obj != null && obj == obj.window;
		},
	
		isNumeric: function( obj ) {
			return !isNaN( parseFloat(obj) ) && isFinite( obj );
		},
	
		type: function( obj ) {
			return obj == null ?
				String( obj ) :
				class2type[ toString.call(obj) ] || "object";
		},
	
		isPlainObject: function( obj ) {
			// Must be an Object.
			// Because of IE, we also have to check the presence of the constructor property.
			// Make sure that DOM nodes and window objects don't pass through, as well
			if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
				return false;
			}
	
			try {
				// Not own constructor property must be Object
				if ( obj.constructor &&
					!hasOwn.call(obj, "constructor") &&
					!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
					return false;
				}
			} catch ( e ) {
				// IE8,9 Will throw exceptions on certain host objects #9897
				return false;
			}
	
			// Own properties are enumerated firstly, so to speed up,
			// if last one is own, then all properties are own.
	
			var key;
			for ( key in obj ) {}
	
			return key === undefined || hasOwn.call( obj, key );
		},
	
		isEmptyObject: function( obj ) {
			for ( var name in obj ) {
				return false;
			}
			return true;
		},
	
		error: function( msg ) {
			throw new Error( msg );
		},
	
		parseJSON: function( data ) {
			if ( typeof data !== "string" || !data ) {
				return null;
			}
	
			// Make sure leading/trailing whitespace is removed (IE can't handle it)
			data = jQuery.trim( data );
	
			// Attempt to parse using the native JSON parser first
			if ( window.JSON && window.JSON.parse ) {
				return window.JSON.parse( data );
			}
	
			// Make sure the incoming data is actual JSON
			// Logic borrowed from http://json.org/json2.js
			if ( rvalidchars.test( data.replace( rvalidescape, "@" )
				.replace( rvalidtokens, "]" )
				.replace( rvalidbraces, "")) ) {
	
				return ( new Function( "return " + data ) )();
	
			}
			jQuery.error( "Invalid JSON: " + data );
		},
	
		// Cross-browser xml parsing
		parseXML: function( data ) {
			if ( typeof data !== "string" || !data ) {
				return null;
			}
			var xml, tmp;
			try {
				if ( window.DOMParser ) { // Standard
					tmp = new DOMParser();
					xml = tmp.parseFromString( data , "text/xml" );
				} else { // IE
					xml = new ActiveXObject( "Microsoft.XMLDOM" );
					xml.async = "false";
					xml.loadXML( data );
				}
			} catch( e ) {
				xml = undefined;
			}
			if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
				jQuery.error( "Invalid XML: " + data );
			}
			return xml;
		},
	
		noop: function() {},
	
		// Evaluates a script in a global context
		// Workarounds based on findings by Jim Driscoll
		// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
		globalEval: function( data ) {
			if ( data && rnotwhite.test( data ) ) {
				// We use execScript on Internet Explorer
				// We use an anonymous function so that context is window
				// rather than jQuery in Firefox
				( window.execScript || function( data ) {
					window[ "eval" ].call( window, data );
				} )( data );
			}
		},
	
		// Convert dashed to camelCase; used by the css and data modules
		// Microsoft forgot to hump their vendor prefix (#9572)
		camelCase: function( string ) {
			return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
		},
	
		nodeName: function( elem, name ) {
			return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
		},
	
		// args is for internal usage only
		each: function( object, callback, args ) {
			var name, i = 0,
				length = object.length,
				isObj = length === undefined || jQuery.isFunction( object );
	
			if ( args ) {
				if ( isObj ) {
					for ( name in object ) {
						if ( callback.apply( object[ name ], args ) === false ) {
							break;
						}
					}
				} else {
					for ( ; i < length; ) {
						if ( callback.apply( object[ i++ ], args ) === false ) {
							break;
						}
					}
				}
	
			// A special, fast, case for the most common use of each
			} else {
				if ( isObj ) {
					for ( name in object ) {
						if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
							break;
						}
					}
				} else {
					for ( ; i < length; ) {
						if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
							break;
						}
					}
				}
			}
	
			return object;
		},
	
		// Use native String.trim function wherever possible
		trim: trim ?
			function( text ) {
				return text == null ?
					"" :
					trim.call( text );
			} :
	
			// Otherwise use our own trimming functionality
			function( text ) {
				return text == null ?
					"" :
					text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
			},
	
		// results is for internal usage only
		makeArray: function( array, results ) {
			var ret = results || [];
	
			if ( array != null ) {
				// The window, strings (and functions) also have 'length'
				// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
				var type = jQuery.type( array );
	
				if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
					push.call( ret, array );
				} else {
					jQuery.merge( ret, array );
				}
			}
	
			return ret;
		},
	
		inArray: function( elem, array, i ) {
			var len;
	
			if ( array ) {
				if ( indexOf ) {
					return indexOf.call( array, elem, i );
				}
	
				len = array.length;
				i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
	
				for ( ; i < len; i++ ) {
					// Skip accessing in sparse arrays
					if ( i in array && array[ i ] === elem ) {
						return i;
					}
				}
			}
	
			return -1;
		},
	
		merge: function( first, second ) {
			var i = first.length,
				j = 0;
	
			if ( typeof second.length === "number" ) {
				for ( var l = second.length; j < l; j++ ) {
					first[ i++ ] = second[ j ];
				}
	
			} else {
				while ( second[j] !== undefined ) {
					first[ i++ ] = second[ j++ ];
				}
			}
	
			first.length = i;
	
			return first;
		},
	
		grep: function( elems, callback, inv ) {
			var ret = [], retVal;
			inv = !!inv;
	
			// Go through the array, only saving the items
			// that pass the validator function
			for ( var i = 0, length = elems.length; i < length; i++ ) {
				retVal = !!callback( elems[ i ], i );
				if ( inv !== retVal ) {
					ret.push( elems[ i ] );
				}
			}
	
			return ret;
		},
	
		// arg is for internal usage only
		map: function( elems, callback, arg ) {
			var value, key, ret = [],
				i = 0,
				length = elems.length,
				// jquery objects are treated as arrays
				isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
	
			// Go through the array, translating each of the items to their
			if ( isArray ) {
				for ( ; i < length; i++ ) {
					value = callback( elems[ i ], i, arg );
	
					if ( value != null ) {
						ret[ ret.length ] = value;
					}
				}
	
			// Go through every key on the object,
			} else {
				for ( key in elems ) {
					value = callback( elems[ key ], key, arg );
	
					if ( value != null ) {
						ret[ ret.length ] = value;
					}
				}
			}
	
			// Flatten any nested arrays
			return ret.concat.apply( [], ret );
		},
	
		// A global GUID counter for objects
		guid: 1,
	
		// Bind a function to a context, optionally partially applying any
		// arguments.
		proxy: function( fn, context ) {
			if ( typeof context === "string" ) {
				var tmp = fn[ context ];
				context = fn;
				fn = tmp;
			}
	
			// Quick check to determine if target is callable, in the spec
			// this throws a TypeError, but we will just return undefined.
			if ( !jQuery.isFunction( fn ) ) {
				return undefined;
			}
	
			// Simulated bind
			var args = slice.call( arguments, 2 ),
				proxy = function() {
					return fn.apply( context, args.concat( slice.call( arguments ) ) );
				};
	
			// Set the guid of unique handler to the same of original handler, so it can be removed
			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
	
			return proxy;
		},
	
		// Mutifunctional method to get and set values to a collection
		// The value/s can optionally be executed if it's a function
		access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
			var exec,
				bulk = key == null,
				i = 0,
				length = elems.length;
	
			// Sets many values
			if ( key && typeof key === "object" ) {
				for ( i in key ) {
					jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
				}
				chainable = 1;
	
			// Sets one value
			} else if ( value !== undefined ) {
				// Optionally, function values get executed if exec is true
				exec = pass === undefined && jQuery.isFunction( value );
	
				if ( bulk ) {
					// Bulk operations only iterate when executing function values
					if ( exec ) {
						exec = fn;
						fn = function( elem, key, value ) {
							return exec.call( jQuery( elem ), value );
						};
	
					// Otherwise they run against the entire set
					} else {
						fn.call( elems, value );
						fn = null;
					}
				}
	
				if ( fn ) {
					for (; i < length; i++ ) {
						fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
					}
				}
	
				chainable = 1;
			}
	
			return chainable ?
				elems :
	
				// Gets
				bulk ?
					fn.call( elems ) :
					length ? fn( elems[0], key ) : emptyGet;
		},
	
		now: function() {
			return ( new Date() ).getTime();
		},
	
		// Use of jQuery.browser is frowned upon.
		// More details: http://docs.jquery.com/Utilities/jQuery.browser
		uaMatch: function( ua ) {
			ua = ua.toLowerCase();
	
			var match = rwebkit.exec( ua ) ||
				ropera.exec( ua ) ||
				rmsie.exec( ua ) ||
				ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
				[];
	
			return { browser: match[1] || "", version: match[2] || "0" };
		},
	
		sub: function() {
			function jQuerySub( selector, context ) {
				return new jQuerySub.fn.init( selector, context );
			}
			jQuery.extend( true, jQuerySub, this );
			jQuerySub.superclass = this;
			jQuerySub.fn = jQuerySub.prototype = this();
			jQuerySub.fn.constructor = jQuerySub;
			jQuerySub.sub = this.sub;
			jQuerySub.fn.init = function init( selector, context ) {
				if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
					context = jQuerySub( context );
				}
	
				return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
			};
			jQuerySub.fn.init.prototype = jQuerySub.fn;
			var rootjQuerySub = jQuerySub(document);
			return jQuerySub;
		},
	
		browser: {}
	});
	
	// Populate the class2type map
	jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
		class2type[ "[object " + name + "]" ] = name.toLowerCase();
	});
	
	browserMatch = jQuery.uaMatch( userAgent );
	if ( browserMatch.browser ) {
		jQuery.browser[ browserMatch.browser ] = true;
		jQuery.browser.version = browserMatch.version;
	}
	
	// Deprecated, use jQuery.browser.webkit instead
	if ( jQuery.browser.webkit ) {
		jQuery.browser.safari = true;
	}
	
	// IE doesn't match non-breaking spaces with \s
	if ( rnotwhite.test( "\xA0" ) ) {
		trimLeft = /^[\s\xA0]+/;
		trimRight = /[\s\xA0]+$/;
	}
	
	// All jQuery objects should point back to these
	rootjQuery = jQuery(document);
	
	// Cleanup functions for the document ready method
	if ( document.addEventListener ) {
		DOMContentLoaded = function() {
			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
			jQuery.ready();
		};
	
	} else if ( document.attachEvent ) {
		DOMContentLoaded = function() {
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
			if ( document.readyState === "complete" ) {
				document.detachEvent( "onreadystatechange", DOMContentLoaded );
				jQuery.ready();
			}
		};
	}
	
	// The DOM ready check for Internet Explorer
	function doScrollCheck() {
		if ( jQuery.isReady ) {
			return;
		}
	
		try {
			// If IE is used, use the trick by Diego Perini
			// http://javascript.nwbox.com/IEContentLoaded/
			document.documentElement.doScroll("left");
		} catch(e) {
			setTimeout( doScrollCheck, 1 );
			return;
		}
	
		// and execute any waiting functions
		jQuery.ready();
	}
	
	return jQuery;
	
	})();
	
	
	// String to Object flags format cache
	var flagsCache = {};
	
	// Convert String-formatted flags into Object-formatted ones and store in cache
	function createFlags( flags ) {
		var object = flagsCache[ flags ] = {},
			i, length;
		flags = flags.split( /\s+/ );
		for ( i = 0, length = flags.length; i < length; i++ ) {
			object[ flags[i] ] = true;
		}
		return object;
	}
	
	/*
	 * Create a callback list using the following parameters:
	 *
	 *	flags:	an optional list of space-separated flags that will change how
	 *			the callback list behaves
	 *
	 * By default a callback list will act like an event callback list and can be
	 * "fired" multiple times.
	 *
	 * Possible flags:
	 *
	 *	once:			will ensure the callback list can only be fired once (like a Deferred)
	 *
	 *	memory:			will keep track of previous values and will call any callback added
	 *					after the list has been fired right away with the latest "memorized"
	 *					values (like a Deferred)
	 *
	 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
	 *
	 *	stopOnFalse:	interrupt callings when a callback returns false
	 *
	 */
	jQuery.Callbacks = function( flags ) {
	
		// Convert flags from String-formatted to Object-formatted
		// (we check in cache first)
		flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
	
		var // Actual callback list
			list = [],
			// Stack of fire calls for repeatable lists
			stack = [],
			// Last fire value (for non-forgettable lists)
			memory,
			// Flag to know if list was already fired
			fired,
			// Flag to know if list is currently firing
			firing,
			// First callback to fire (used internally by add and fireWith)
			firingStart,
			// End of the loop when firing
			firingLength,
			// Index of currently firing callback (modified by remove if needed)
			firingIndex,
			// Add one or several callbacks to the list
			add = function( args ) {
				var i,
					length,
					elem,
					type,
					actual;
				for ( i = 0, length = args.length; i < length; i++ ) {
					elem = args[ i ];
					type = jQuery.type( elem );
					if ( type === "array" ) {
						// Inspect recursively
						add( elem );
					} else if ( type === "function" ) {
						// Add if not in unique mode and callback is not in
						if ( !flags.unique || !self.has( elem ) ) {
							list.push( elem );
						}
					}
				}
			},
			// Fire callbacks
			fire = function( context, args ) {
				args = args || [];
				memory = !flags.memory || [ context, args ];
				fired = true;
				firing = true;
				firingIndex = firingStart || 0;
				firingStart = 0;
				firingLength = list.length;
				for ( ; list && firingIndex < firingLength; firingIndex++ ) {
					if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
						memory = true; // Mark as halted
						break;
					}
				}
				firing = false;
				if ( list ) {
					if ( !flags.once ) {
						if ( stack && stack.length ) {
							memory = stack.shift();
							self.fireWith( memory[ 0 ], memory[ 1 ] );
						}
					} else if ( memory === true ) {
						self.disable();
					} else {
						list = [];
					}
				}
			},
			// Actual Callbacks object
			self = {
				// Add a callback or a collection of callbacks to the list
				add: function() {
					if ( list ) {
						var length = list.length;
						add( arguments );
						// Do we need to add the callbacks to the
						// current firing batch?
						if ( firing ) {
							firingLength = list.length;
						// With memory, if we're not firing then
						// we should call right away, unless previous
						// firing was halted (stopOnFalse)
						} else if ( memory && memory !== true ) {
							firingStart = length;
							fire( memory[ 0 ], memory[ 1 ] );
						}
					}
					return this;
				},
				// Remove a callback from the list
				remove: function() {
					if ( list ) {
						var args = arguments,
							argIndex = 0,
							argLength = args.length;
						for ( ; argIndex < argLength ; argIndex++ ) {
							for ( var i = 0; i < list.length; i++ ) {
								if ( args[ argIndex ] === list[ i ] ) {
									// Handle firingIndex and firingLength
									if ( firing ) {
										if ( i <= firingLength ) {
											firingLength--;
											if ( i <= firingIndex ) {
												firingIndex--;
											}
										}
									}
									// Remove the element
									list.splice( i--, 1 );
									// If we have some unicity property then
									// we only need to do this once
									if ( flags.unique ) {
										break;
									}
								}
							}
						}
					}
					return this;
				},
				// Control if a given callback is in the list
				has: function( fn ) {
					if ( list ) {
						var i = 0,
							length = list.length;
						for ( ; i < length; i++ ) {
							if ( fn === list[ i ] ) {
								return true;
							}
						}
					}
					return false;
				},
				// Remove all callbacks from the list
				empty: function() {
					list = [];
					return this;
				},
				// Have the list do nothing anymore
				disable: function() {
					list = stack = memory = undefined;
					return this;
				},
				// Is it disabled?
				disabled: function() {
					return !list;
				},
				// Lock the list in its current state
				lock: function() {
					stack = undefined;
					if ( !memory || memory === true ) {
						self.disable();
					}
					return this;
				},
				// Is it locked?
				locked: function() {
					return !stack;
				},
				// Call all callbacks with the given context and arguments
				fireWith: function( context, args ) {
					if ( stack ) {
						if ( firing ) {
							if ( !flags.once ) {
								stack.push( [ context, args ] );
							}
						} else if ( !( flags.once && memory ) ) {
							fire( context, args );
						}
					}
					return this;
				},
				// Call all the callbacks with the given arguments
				fire: function() {
					self.fireWith( this, arguments );
					return this;
				},
				// To know if the callbacks have already been called at least once
				fired: function() {
					return !!fired;
				}
			};
	
		return self;
	};
	
	
	
	
	var // Static reference to slice
		sliceDeferred = [].slice;
	
	jQuery.extend({
	
		Deferred: function( func ) {
			var doneList = jQuery.Callbacks( "once memory" ),
				failList = jQuery.Callbacks( "once memory" ),
				progressList = jQuery.Callbacks( "memory" ),
				state = "pending",
				lists = {
					resolve: doneList,
					reject: failList,
					notify: progressList
				},
				promise = {
					done: doneList.add,
					fail: failList.add,
					progress: progressList.add,
	
					state: function() {
						return state;
					},
	
					// Deprecated
					isResolved: doneList.fired,
					isRejected: failList.fired,
	
					then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
						deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
						return this;
					},
					always: function() {
						deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
						return this;
					},
					pipe: function( fnDone, fnFail, fnProgress ) {
						return jQuery.Deferred(function( newDefer ) {
							jQuery.each( {
								done: [ fnDone, "resolve" ],
								fail: [ fnFail, "reject" ],
								progress: [ fnProgress, "notify" ]
							}, function( handler, data ) {
								var fn = data[ 0 ],
									action = data[ 1 ],
									returned;
								if ( jQuery.isFunction( fn ) ) {
									deferred[ handler ](function() {
										returned = fn.apply( this, arguments );
										if ( returned && jQuery.isFunction( returned.promise ) ) {
											returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
										} else {
											newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
										}
									});
								} else {
									deferred[ handler ]( newDefer[ action ] );
								}
							});
						}).promise();
					},
					// Get a promise for this deferred
					// If obj is provided, the promise aspect is added to the object
					promise: function( obj ) {
						if ( obj == null ) {
							obj = promise;
						} else {
							for ( var key in promise ) {
								obj[ key ] = promise[ key ];
							}
						}
						return obj;
					}
				},
				deferred = promise.promise({}),
				key;
	
			for ( key in lists ) {
				deferred[ key ] = lists[ key ].fire;
				deferred[ key + "With" ] = lists[ key ].fireWith;
			}
	
			// Handle state
			deferred.done( function() {
				state = "resolved";
			}, failList.disable, progressList.lock ).fail( function() {
				state = "rejected";
			}, doneList.disable, progressList.lock );
	
			// Call given func if any
			if ( func ) {
				func.call( deferred, deferred );
			}
	
			// All done!
			return deferred;
		},
	
		// Deferred helper
		when: function( firstParam ) {
			var args = sliceDeferred.call( arguments, 0 ),
				i = 0,
				length = args.length,
				pValues = new Array( length ),
				count = length,
				pCount = length,
				deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
					firstParam :
					jQuery.Deferred(),
				promise = deferred.promise();
			function resolveFunc( i ) {
				return function( value ) {
					args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
					if ( !( --count ) ) {
						deferred.resolveWith( deferred, args );
					}
				};
			}
			function progressFunc( i ) {
				return function( value ) {
					pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
					deferred.notifyWith( promise, pValues );
				};
			}
			if ( length > 1 ) {
				for ( ; i < length; i++ ) {
					if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
						args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
					} else {
						--count;
					}
				}
				if ( !count ) {
					deferred.resolveWith( deferred, args );
				}
			} else if ( deferred !== firstParam ) {
				deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
			}
			return promise;
		}
	});
	
	
	
	
	jQuery.support = (function() {
	
		var support,
			all,
			a,
			select,
			opt,
			input,
			fragment,
			tds,
			events,
			eventName,
			i,
			isSupported,
			div = document.createElement( "div" ),
			documentElement = document.documentElement;
	
		// Preliminary tests
		div.setAttribute("className", "t");
		div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
	
		all = div.getElementsByTagName( "*" );
		a = div.getElementsByTagName( "a" )[ 0 ];
	
		// Can't get basic test support
		if ( !all || !all.length || !a ) {
			return {};
		}
	
		// First batch of supports tests
		select = document.createElement( "select" );
		opt = select.appendChild( document.createElement("option") );
		input = div.getElementsByTagName( "input" )[ 0 ];
	
		support = {
			// IE strips leading whitespace when .innerHTML is used
			leadingWhitespace: ( div.firstChild.nodeType === 3 ),
	
			// Make sure that tbody elements aren't automatically inserted
			// IE will insert them into empty tables
			tbody: !div.getElementsByTagName("tbody").length,
	
			// Make sure that link elements get serialized correctly by innerHTML
			// This requires a wrapper element in IE
			htmlSerialize: !!div.getElementsByTagName("link").length,
	
			// Get the style information from getAttribute
			// (IE uses .cssText instead)
			style: /top/.test( a.getAttribute("style") ),
	
			// Make sure that URLs aren't manipulated
			// (IE normalizes it by default)
			hrefNormalized: ( a.getAttribute("href") === "/a" ),
	
			// Make sure that element opacity exists
			// (IE uses filter instead)
			// Use a regex to work around a WebKit issue. See #5145
			opacity: /^0.55/.test( a.style.opacity ),
	
			// Verify style float existence
			// (IE uses styleFloat instead of cssFloat)
			cssFloat: !!a.style.cssFloat,
	
			// Make sure that if no value is specified for a checkbox
			// that it defaults to "on".
			// (WebKit defaults to "" instead)
			checkOn: ( input.value === "on" ),
	
			// Make sure that a selected-by-default option has a working selected property.
			// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
			optSelected: opt.selected,
	
			// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
			getSetAttribute: div.className !== "t",
	
			// Tests for enctype support on a form(#6743)
			enctype: !!document.createElement("form").enctype,
	
			// Makes sure cloning an html5 element does not cause problems
			// Where outerHTML is undefined, this still works
			html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
	
			// Will be defined later
			submitBubbles: true,
			changeBubbles: true,
			focusinBubbles: false,
			deleteExpando: true,
			noCloneEvent: true,
			inlineBlockNeedsLayout: false,
			shrinkWrapBlocks: false,
			reliableMarginRight: true,
			pixelMargin: true
		};
	
		// jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
		jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");
	
		// Make sure checked status is properly cloned
		input.checked = true;
		support.noCloneChecked = input.cloneNode( true ).checked;
	
		// Make sure that the options inside disabled selects aren't marked as disabled
		// (WebKit marks them as disabled)
		select.disabled = true;
		support.optDisabled = !opt.disabled;
	
		// Test to see if it's possible to delete an expando from an element
		// Fails in Internet Explorer
		try {
			delete div.test;
		} catch( e ) {
			support.deleteExpando = false;
		}
	
		if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
			div.attachEvent( "onclick", function() {
				// Cloning a node shouldn't copy over any
				// bound event handlers (IE does this)
				support.noCloneEvent = false;
			});
			div.cloneNode( true ).fireEvent( "onclick" );
		}
	
		// Check if a radio maintains its value
		// after being appended to the DOM
		input = document.createElement("input");
		input.value = "t";
		input.setAttribute("type", "radio");
		support.radioValue = input.value === "t";
	
		input.setAttribute("checked", "checked");
	
		// #11217 - WebKit loses check when the name is after the checked attribute
		input.setAttribute( "name", "t" );
	
		div.appendChild( input );
		fragment = document.createDocumentFragment();
		fragment.appendChild( div.lastChild );
	
		// WebKit doesn't clone checked state correctly in fragments
		support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
	
		// Check if a disconnected checkbox will retain its checked
		// value of true after appended to the DOM (IE6/7)
		support.appendChecked = input.checked;
	
		fragment.removeChild( input );
		fragment.appendChild( div );
	
		// Technique from Juriy Zaytsev
		// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
		// We only care about the case where non-standard event systems
		// are used, namely in IE. Short-circuiting here helps us to
		// avoid an eval call (in setAttribute) which can cause CSP
		// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
		if ( div.attachEvent ) {
			for ( i in {
				submit: 1,
				change: 1,
				focusin: 1
			}) {
				eventName = "on" + i;
				isSupported = ( eventName in div );
				if ( !isSupported ) {
					div.setAttribute( eventName, "return;" );
					isSupported = ( typeof div[ eventName ] === "function" );
				}
				support[ i + "Bubbles" ] = isSupported;
			}
		}
	
		fragment.removeChild( div );
	
		// Null elements to avoid leaks in IE
		fragment = select = opt = div = input = null;
	
		// Run tests that need a body at doc ready
		jQuery(function() {
			var container, outer, inner, table, td, offsetSupport,
				marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
				paddingMarginBorderVisibility, paddingMarginBorder,
				body = document.getElementsByTagName("body")[0];
	
			if ( !body ) {
				// Return for frameset docs that don't have a body
				return;
			}
	
			conMarginTop = 1;
			paddingMarginBorder = "padding:0;margin:0;border:";
			positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
			paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
			style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
			html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
				"<table " + style + "' cellpadding='0' cellspacing='0'>" +
				"<tr><td></td></tr></table>";
	
			container = document.createElement("div");
			container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
			body.insertBefore( container, body.firstChild );
	
			// Construct the test element
			div = document.createElement("div");
			container.appendChild( div );
	
			// Check if table cells still have offsetWidth/Height when they are set
			// to display:none and there are still other visible table cells in a
			// table row; if so, offsetWidth/Height are not reliable for use when
			// determining if an element has been hidden directly using
			// display:none (it is still safe to use offsets if a parent element is
			// hidden; don safety goggles and see bug #4512 for more information).
			// (only IE 8 fails this test)
			div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
			tds = div.getElementsByTagName( "td" );
			isSupported = ( tds[ 0 ].offsetHeight === 0 );
	
			tds[ 0 ].style.display = "";
			tds[ 1 ].style.display = "none";
	
			// Check if empty table cells still have offsetWidth/Height
			// (IE <= 8 fail this test)
			support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
	
			// Check if div with explicit width and no margin-right incorrectly
			// gets computed margin-right based on width of container. For more
			// info see bug #3333
			// Fails in WebKit before Feb 2011 nightlies
			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
			if ( window.getComputedStyle ) {
				div.innerHTML = "";
				marginDiv = document.createElement( "div" );
				marginDiv.style.width = "0";
				marginDiv.style.marginRight = "0";
				div.style.width = "2px";
				div.appendChild( marginDiv );
				support.reliableMarginRight =
					( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
			}
	
			if ( typeof div.style.zoom !== "undefined" ) {
				// Check if natively block-level elements act like inline-block
				// elements when setting their display to 'inline' and giving
				// them layout
				// (IE < 8 does this)
				div.innerHTML = "";
				div.style.width = div.style.padding = "1px";
				div.style.border = 0;
				div.style.overflow = "hidden";
				div.style.display = "inline";
				div.style.zoom = 1;
				support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
	
				// Check if elements with layout shrink-wrap their children
				// (IE 6 does this)
				div.style.display = "block";
				div.style.overflow = "visible";
				div.innerHTML = "<div style='width:5px;'></div>";
				support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
			}
	
			div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
			div.innerHTML = html;
	
			outer = div.firstChild;
			inner = outer.firstChild;
			td = outer.nextSibling.firstChild.firstChild;
	
			offsetSupport = {
				doesNotAddBorder: ( inner.offsetTop !== 5 ),
				doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
			};
	
			inner.style.position = "fixed";
			inner.style.top = "20px";
	
			// safari subtracts parent border width here which is 5px
			offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
			inner.style.position = inner.style.top = "";
	
			outer.style.overflow = "hidden";
			outer.style.position = "relative";
	
			offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
			offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
	
			if ( window.getComputedStyle ) {
				div.style.marginTop = "1%";
				support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%";
			}
	
			if ( typeof container.style.zoom !== "undefined" ) {
				container.style.zoom = 1;
			}
	
			body.removeChild( container );
			marginDiv = div = container = null;
	
			jQuery.extend( support, offsetSupport );
		});
	
		return support;
	})();
	
	
	
	
	var rbrace = /^(?:\{.*\}|\[.*\])$/,
		rmultiDash = /([A-Z])/g;
	
	jQuery.extend({
		cache: {},
	
		// Please use with caution
		uuid: 0,
	
		// Unique for each copy of jQuery on the page
		// Non-digits removed to match rinlinejQuery
		expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
	
		// The following elements throw uncatchable exceptions if you
		// attempt to add expando properties to them.
		noData: {
			"embed": true,
			// Ban all objects except for Flash (which handle expandos)
			"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
			"applet": true
		},
	
		hasData: function( elem ) {
			elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
			return !!elem && !isEmptyDataObject( elem );
		},
	
		data: function( elem, name, data, pvt /* Internal Use Only */ ) {
			if ( !jQuery.acceptData( elem ) ) {
				return;
			}
	
			var privateCache, thisCache, ret,
				internalKey = jQuery.expando,
				getByName = typeof name === "string",
	
				// We have to handle DOM nodes and JS objects differently because IE6-7
				// can't GC object references properly across the DOM-JS boundary
				isNode = elem.nodeType,
	
				// Only DOM nodes need the global jQuery cache; JS object data is
				// attached directly to the object so GC can occur automatically
				cache = isNode ? jQuery.cache : elem,
	
				// Only defining an ID for JS objects if its cache already exists allows
				// the code to shortcut on the same path as a DOM node with no cache
				id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
				isEvents = name === "events";
	
			// Avoid doing any more work than we need to when trying to get data on an
			// object that has no data at all
			if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
				return;
			}
	
			if ( !id ) {
				// Only DOM nodes need a new unique ID for each element since their data
				// ends up in the global cache
				if ( isNode ) {
					elem[ internalKey ] = id = ++jQuery.uuid;
				} else {
					id = internalKey;
				}
			}
	
			if ( !cache[ id ] ) {
				cache[ id ] = {};
	
				// Avoids exposing jQuery metadata on plain JS objects when the object
				// is serialized using JSON.stringify
				if ( !isNode ) {
					cache[ id ].toJSON = jQuery.noop;
				}
			}
	
			// An object can be passed to jQuery.data instead of a key/value pair; this gets
			// shallow copied over onto the existing cache
			if ( typeof name === "object" || typeof name === "function" ) {
				if ( pvt ) {
					cache[ id ] = jQuery.extend( cache[ id ], name );
				} else {
					cache[ id ].data = jQuery.extend( cache[ id ].data, name );
				}
			}
	
			privateCache = thisCache = cache[ id ];
	
			// jQuery data() is stored in a separate object inside the object's internal data
			// cache in order to avoid key collisions between internal data and user-defined
			// data.
			if ( !pvt ) {
				if ( !thisCache.data ) {
					thisCache.data = {};
				}
	
				thisCache = thisCache.data;
			}
	
			if ( data !== undefined ) {
				thisCache[ jQuery.camelCase( name ) ] = data;
			}
	
			// Users should not attempt to inspect the internal events object using jQuery.data,
			// it is undocumented and subject to change. But does anyone listen? No.
			if ( isEvents && !thisCache[ name ] ) {
				return privateCache.events;
			}
	
			// Check for both converted-to-camel and non-converted data property names
			// If a data property was specified
			if ( getByName ) {
	
				// First Try to find as-is property data
				ret = thisCache[ name ];
	
				// Test for null|undefined property data
				if ( ret == null ) {
	
					// Try to find the camelCased property
					ret = thisCache[ jQuery.camelCase( name ) ];
				}
			} else {
				ret = thisCache;
			}
	
			return ret;
		},
	
		removeData: function( elem, name, pvt /* Internal Use Only */ ) {
			if ( !jQuery.acceptData( elem ) ) {
				return;
			}
	
			var thisCache, i, l,
	
				// Reference to internal data cache key
				internalKey = jQuery.expando,
	
				isNode = elem.nodeType,
	
				// See jQuery.data for more information
				cache = isNode ? jQuery.cache : elem,
	
				// See jQuery.data for more information
				id = isNode ? elem[ internalKey ] : internalKey;
	
			// If there is already no cache entry for this object, there is no
			// purpose in continuing
			if ( !cache[ id ] ) {
				return;
			}
	
			if ( name ) {
	
				thisCache = pvt ? cache[ id ] : cache[ id ].data;
	
				if ( thisCache ) {
	
					// Support array or space separated string names for data keys
					if ( !jQuery.isArray( name ) ) {
	
						// try the string as a key before any manipulation
						if ( name in thisCache ) {
							name = [ name ];
						} else {
	
							// split the camel cased version by spaces unless a key with the spaces exists
							name = jQuery.camelCase( name );
							if ( name in thisCache ) {
								name = [ name ];
							} else {
								name = name.split( " " );
							}
						}
					}
	
					for ( i = 0, l = name.length; i < l; i++ ) {
						delete thisCache[ name[i] ];
					}
	
					// If there is no data left in the cache, we want to continue
					// and let the cache object itself get destroyed
					if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
						return;
					}
				}
			}
	
			// See jQuery.data for more information
			if ( !pvt ) {
				delete cache[ id ].data;
	
				// Don't destroy the parent cache unless the internal data object
				// had been the only thing left in it
				if ( !isEmptyDataObject(cache[ id ]) ) {
					return;
				}
			}
	
			// Browsers that fail expando deletion also refuse to delete expandos on
			// the window, but it will allow it on all other JS objects; other browsers
			// don't care
			// Ensure that `cache` is not a window object #10080
			if ( jQuery.support.deleteExpando || !cache.setInterval ) {
				delete cache[ id ];
			} else {
				cache[ id ] = null;
			}
	
			// We destroyed the cache and need to eliminate the expando on the node to avoid
			// false lookups in the cache for entries that no longer exist
			if ( isNode ) {
				// IE does not allow us to delete expando properties from nodes,
				// nor does it have a removeAttribute function on Document nodes;
				// we must handle all of these cases
				if ( jQuery.support.deleteExpando ) {
					delete elem[ internalKey ];
				} else if ( elem.removeAttribute ) {
					elem.removeAttribute( internalKey );
				} else {
					elem[ internalKey ] = null;
				}
			}
		},
	
		// For internal use only.
		_data: function( elem, name, data ) {
			return jQuery.data( elem, name, data, true );
		},
	
		// A method for determining if a DOM node can handle the data expando
		acceptData: function( elem ) {
			if ( elem.nodeName ) {
				var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
	
				if ( match ) {
					return !(match === true || elem.getAttribute("classid") !== match);
				}
			}
	
			return true;
		}
	});
	
	jQuery.fn.extend({
		data: function( key, value ) {
			var parts, part, attr, name, l,
				elem = this[0],
				i = 0,
				data = null;
	
			// Gets all values
			if ( key === undefined ) {
				if ( this.length ) {
					data = jQuery.data( elem );
	
					if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
						attr = elem.attributes;
						for ( l = attr.length; i < l; i++ ) {
							name = attr[i].name;
	
							if ( name.indexOf( "data-" ) === 0 ) {
								name = jQuery.camelCase( name.substring(5) );
	
								dataAttr( elem, name, data[ name ] );
							}
						}
						jQuery._data( elem, "parsedAttrs", true );
					}
				}
	
				return data;
			}
	
			// Sets multiple values
			if ( typeof key === "object" ) {
				return this.each(function() {
					jQuery.data( this, key );
				});
			}
	
			parts = key.split( ".", 2 );
			parts[1] = parts[1] ? "." + parts[1] : "";
			part = parts[1] + "!";
	
			return jQuery.access( this, function( value ) {
	
				if ( value === undefined ) {
					data = this.triggerHandler( "getData" + part, [ parts[0] ] );
	
					// Try to fetch any internally stored data first
					if ( data === undefined && elem ) {
						data = jQuery.data( elem, key );
						data = dataAttr( elem, key, data );
					}
	
					return data === undefined && parts[1] ?
						this.data( parts[0] ) :
						data;
				}
	
				parts[1] = value;
				this.each(function() {
					var self = jQuery( this );
	
					self.triggerHandler( "setData" + part, parts );
					jQuery.data( this, key, value );
					self.triggerHandler( "changeData" + part, parts );
				});
			}, null, value, arguments.length > 1, null, false );
		},
	
		removeData: function( key ) {
			return this.each(function() {
				jQuery.removeData( this, key );
			});
		}
	});
	
	function dataAttr( elem, key, data ) {
		// If nothing was found internally, try to fetch any
		// data from the HTML5 data-* attribute
		if ( data === undefined && elem.nodeType === 1 ) {
	
			var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
	
			data = elem.getAttribute( name );
	
			if ( typeof data === "string" ) {
				try {
					data = data === "true" ? true :
					data === "false" ? false :
					data === "null" ? null :
					jQuery.isNumeric( data ) ? +data :
						rbrace.test( data ) ? jQuery.parseJSON( data ) :
						data;
				} catch( e ) {}
	
				// Make sure we set the data so it isn't changed later
				jQuery.data( elem, key, data );
	
			} else {
				data = undefined;
			}
		}
	
		return data;
	}
	
	// checks a cache object for emptiness
	function isEmptyDataObject( obj ) {
		for ( var name in obj ) {
	
			// if the public data object is empty, the private is still empty
			if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
				continue;
			}
			if ( name !== "toJSON" ) {
				return false;
			}
		}
	
		return true;
	}
	
	
	
	
	function handleQueueMarkDefer( elem, type, src ) {
		var deferDataKey = type + "defer",
			queueDataKey = type + "queue",
			markDataKey = type + "mark",
			defer = jQuery._data( elem, deferDataKey );
		if ( defer &&
			( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
			( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
			// Give room for hard-coded callbacks to fire first
			// and eventually mark/queue something else on the element
			setTimeout( function() {
				if ( !jQuery._data( elem, queueDataKey ) &&
					!jQuery._data( elem, markDataKey ) ) {
					jQuery.removeData( elem, deferDataKey, true );
					defer.fire();
				}
			}, 0 );
		}
	}
	
	jQuery.extend({
	
		_mark: function( elem, type ) {
			if ( elem ) {
				type = ( type || "fx" ) + "mark";
				jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
			}
		},
	
		_unmark: function( force, elem, type ) {
			if ( force !== true ) {
				type = elem;
				elem = force;
				force = false;
			}
			if ( elem ) {
				type = type || "fx";
				var key = type + "mark",
					count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
				if ( count ) {
					jQuery._data( elem, key, count );
				} else {
					jQuery.removeData( elem, key, true );
					handleQueueMarkDefer( elem, type, "mark" );
				}
			}
		},
	
		queue: function( elem, type, data ) {
			var q;
			if ( elem ) {
				type = ( type || "fx" ) + "queue";
				q = jQuery._data( elem, type );
	
				// Speed up dequeue by getting out quickly if this is just a lookup
				if ( data ) {
					if ( !q || jQuery.isArray(data) ) {
						q = jQuery._data( elem, type, jQuery.makeArray(data) );
					} else {
						q.push( data );
					}
				}
				return q || [];
			}
		},
	
		dequeue: function( elem, type ) {
			type = type || "fx";
	
			var queue = jQuery.queue( elem, type ),
				fn = queue.shift(),
				hooks = {};
	
			// If the fx queue is dequeued, always remove the progress sentinel
			if ( fn === "inprogress" ) {
				fn = queue.shift();
			}
	
			if ( fn ) {
				// Add a progress sentinel to prevent the fx queue from being
				// automatically dequeued
				if ( type === "fx" ) {
					queue.unshift( "inprogress" );
				}
	
				jQuery._data( elem, type + ".run", hooks );
				fn.call( elem, function() {
					jQuery.dequeue( elem, type );
				}, hooks );
			}
	
			if ( !queue.length ) {
				jQuery.removeData( elem, type + "queue " + type + ".run", true );
				handleQueueMarkDefer( elem, type, "queue" );
			}
		}
	});
	
	jQuery.fn.extend({
		queue: function( type, data ) {
			var setter = 2;
	
			if ( typeof type !== "string" ) {
				data = type;
				type = "fx";
				setter--;
			}
	
			if ( arguments.length < setter ) {
				return jQuery.queue( this[0], type );
			}
	
			return data === undefined ?
				this :
				this.each(function() {
					var queue = jQuery.queue( this, type, data );
	
					if ( type === "fx" && queue[0] !== "inprogress" ) {
						jQuery.dequeue( this, type );
					}
				});
		},
		dequeue: function( type ) {
			return this.each(function() {
				jQuery.dequeue( this, type );
			});
		},
		// Based off of the plugin by Clint Helfers, with permission.
		// http://blindsignals.com/index.php/2009/07/jquery-delay/
		delay: function( time, type ) {
			time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
			type = type || "fx";
	
			return this.queue( type, function( next, hooks ) {
				var timeout = setTimeout( next, time );
				hooks.stop = function() {
					clearTimeout( timeout );
				};
			});
		},
		clearQueue: function( type ) {
			return this.queue( type || "fx", [] );
		},
		// Get a promise resolved when queues of a certain type
		// are emptied (fx is the type by default)
		promise: function( type, object ) {
			if ( typeof type !== "string" ) {
				object = type;
				type = undefined;
			}
			type = type || "fx";
			var defer = jQuery.Deferred(),
				elements = this,
				i = elements.length,
				count = 1,
				deferDataKey = type + "defer",
				queueDataKey = type + "queue",
				markDataKey = type + "mark",
				tmp;
			function resolve() {
				if ( !( --count ) ) {
					defer.resolveWith( elements, [ elements ] );
				}
			}
			while( i-- ) {
				if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
						( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
							jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
						jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
					count++;
					tmp.add( resolve );
				}
			}
			resolve();
			return defer.promise( object );
		}
	});
	
	
	
	
	var rclass = /[\n\t\r]/g,
		rspace = /\s+/,
		rreturn = /\r/g,
		rtype = /^(?:button|input)$/i,
		rfocusable = /^(?:button|input|object|select|textarea)$/i,
		rclickable = /^a(?:rea)?$/i,
		rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
		getSetAttribute = jQuery.support.getSetAttribute,
		nodeHook, boolHook, fixSpecified;
	
	jQuery.fn.extend({
		attr: function( name, value ) {
			return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
		},
	
		removeAttr: function( name ) {
			return this.each(function() {
				jQuery.removeAttr( this, name );
			});
		},
	
		prop: function( name, value ) {
			return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
		},
	
		removeProp: function( name ) {
			name = jQuery.propFix[ name ] || name;
			return this.each(function() {
				// try/catch handles cases where IE balks (such as removing a property on window)
				try {
					this[ name ] = undefined;
					delete this[ name ];
				} catch( e ) {}
			});
		},
	
		addClass: function( value ) {
			var classNames, i, l, elem,
				setClass, c, cl;
	
			if ( jQuery.isFunction( value ) ) {
				return this.each(function( j ) {
					jQuery( this ).addClass( value.call(this, j, this.className) );
				});
			}
	
			if ( value && typeof value === "string" ) {
				classNames = value.split( rspace );
	
				for ( i = 0, l = this.length; i < l; i++ ) {
					elem = this[ i ];
	
					if ( elem.nodeType === 1 ) {
						if ( !elem.className && classNames.length === 1 ) {
							elem.className = value;
	
						} else {
							setClass = " " + elem.className + " ";
	
							for ( c = 0, cl = classNames.length; c < cl; c++ ) {
								if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
									setClass += classNames[ c ] + " ";
								}
							}
							elem.className = jQuery.trim( setClass );
						}
					}
				}
			}
	
			return this;
		},
	
		removeClass: function( value ) {
			var classNames, i, l, elem, className, c, cl;
	
			if ( jQuery.isFunction( value ) ) {
				return this.each(function( j ) {
					jQuery( this ).removeClass( value.call(this, j, this.className) );
				});
			}
	
			if ( (value && typeof value === "string") || value === undefined ) {
				classNames = ( value || "" ).split( rspace );
	
				for ( i = 0, l = this.length; i < l; i++ ) {
					elem = this[ i ];
	
					if ( elem.nodeType === 1 && elem.className ) {
						if ( value ) {
							className = (" " + elem.className + " ").replace( rclass, " " );
							for ( c = 0, cl = classNames.length; c < cl; c++ ) {
								className = className.replace(" " + classNames[ c ] + " ", " ");
							}
							elem.className = jQuery.trim( className );
	
						} else {
							elem.className = "";
						}
					}
				}
			}
	
			return this;
		},
	
		toggleClass: function( value, stateVal ) {
			var type = typeof value,
				isBool = typeof stateVal === "boolean";
	
			if ( jQuery.isFunction( value ) ) {
				return this.each(function( i ) {
					jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
				});
			}
	
			return this.each(function() {
				if ( type === "string" ) {
					// toggle individual class names
					var className,
						i = 0,
						self = jQuery( this ),
						state = stateVal,
						classNames = value.split( rspace );
	
					while ( (className = classNames[ i++ ]) ) {
						// check each className given, space seperated list
						state = isBool ? state : !self.hasClass( className );
						self[ state ? "addClass" : "removeClass" ]( className );
					}
	
				} else if ( type === "undefined" || type === "boolean" ) {
					if ( this.className ) {
						// store className if set
						jQuery._data( this, "__className__", this.className );
					}
	
					// toggle whole className
					this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
				}
			});
		},
	
		hasClass: function( selector ) {
			var className = " " + selector + " ",
				i = 0,
				l = this.length;
			for ( ; i < l; i++ ) {
				if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
					return true;
				}
			}
	
			return false;
		},
	
		val: function( value ) {
			var hooks, ret, isFunction,
				elem = this[0];
	
			if ( !arguments.length ) {
				if ( elem ) {
					hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
	
					if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
						return ret;
					}
	
					ret = elem.value;
	
					return typeof ret === "string" ?
						// handle most common string cases
						ret.replace(rreturn, "") :
						// handle cases where value is null/undef or number
						ret == null ? "" : ret;
				}
	
				return;
			}
	
			isFunction = jQuery.isFunction( value );
	
			return this.each(function( i ) {
				var self = jQuery(this), val;
	
				if ( this.nodeType !== 1 ) {
					return;
				}
	
				if ( isFunction ) {
					val = value.call( this, i, self.val() );
				} else {
					val = value;
				}
	
				// Treat null/undefined as ""; convert numbers to string
				if ( val == null ) {
					val = "";
				} else if ( typeof val === "number" ) {
					val += "";
				} else if ( jQuery.isArray( val ) ) {
					val = jQuery.map(val, function ( value ) {
						return value == null ? "" : value + "";
					});
				}
	
				hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
	
				// If set returns undefined, fall back to normal setting
				if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
					this.value = val;
				}
			});
		}
	});
	
	jQuery.extend({
		valHooks: {
			option: {
				get: function( elem ) {
					// attributes.value is undefined in Blackberry 4.7 but
					// uses .value. See #6932
					var val = elem.attributes.value;
					return !val || val.specified ? elem.value : elem.text;
				}
			},
			select: {
				get: function( elem ) {
					var value, i, max, option,
						index = elem.selectedIndex,
						values = [],
						options = elem.options,
						one = elem.type === "select-one";
	
					// Nothing was selected
					if ( index < 0 ) {
						return null;
					}
	
					// Loop through all the selected options
					i = one ? index : 0;
					max = one ? index + 1 : options.length;
					for ( ; i < max; i++ ) {
						option = options[ i ];
	
						// Don't return options that are disabled or in a disabled optgroup
						if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
								(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
	
							// Get the specific value for the option
							value = jQuery( option ).val();
	
							// We don't need an array for one selects
							if ( one ) {
								return value;
							}
	
							// Multi-Selects return an array
							values.push( value );
						}
					}
	
					// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
					if ( one && !values.length && options.length ) {
						return jQuery( options[ index ] ).val();
					}
	
					return values;
				},
	
				set: function( elem, value ) {
					var values = jQuery.makeArray( value );
	
					jQuery(elem).find("option").each(function() {
						this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
					});
	
					if ( !values.length ) {
						elem.selectedIndex = -1;
					}
					return values;
				}
			}
		},
	
		attrFn: {
			val: true,
			css: true,
			html: true,
			text: true,
			data: true,
			width: true,
			height: true,
			offset: true
		},
	
		attr: function( elem, name, value, pass ) {
			var ret, hooks, notxml,
				nType = elem.nodeType;
	
			// don't get/set attributes on text, comment and attribute nodes
			if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
				return;
			}
	
			if ( pass && name in jQuery.attrFn ) {
				return jQuery( elem )[ name ]( value );
			}
	
			// Fallback to prop when attributes are not supported
			if ( typeof elem.getAttribute === "undefined" ) {
				return jQuery.prop( elem, name, value );
			}
	
			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
	
			// All attributes are lowercase
			// Grab necessary hook if one is defined
			if ( notxml ) {
				name = name.toLowerCase();
				hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
			}
	
			if ( value !== undefined ) {
	
				if ( value === null ) {
					jQuery.removeAttr( elem, name );
					return;
	
				} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
					return ret;
	
				} else {
					elem.setAttribute( name, "" + value );
					return value;
				}
	
			} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
				return ret;
	
			} else {
	
				ret = elem.getAttribute( name );
	
				// Non-existent attributes return null, we normalize to undefined
				return ret === null ?
					undefined :
					ret;
			}
		},
	
		removeAttr: function( elem, value ) {
			var propName, attrNames, name, l, isBool,
				i = 0;
	
			if ( value && elem.nodeType === 1 ) {
				attrNames = value.toLowerCase().split( rspace );
				l = attrNames.length;
	
				for ( ; i < l; i++ ) {
					name = attrNames[ i ];
	
					if ( name ) {
						propName = jQuery.propFix[ name ] || name;
						isBool = rboolean.test( name );
	
						// See #9699 for explanation of this approach (setting first, then removal)
						// Do not do this for boolean attributes (see #10870)
						if ( !isBool ) {
							jQuery.attr( elem, name, "" );
						}
						elem.removeAttribute( getSetAttribute ? name : propName );
	
						// Set corresponding property to false for boolean attributes
						if ( isBool && propName in elem ) {
							elem[ propName ] = false;
						}
					}
				}
			}
		},
	
		attrHooks: {
			type: {
				set: function( elem, value ) {
					// We can't allow the type property to be changed (since it causes problems in IE)
					if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
						jQuery.error( "type property can't be changed" );
					} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
						// Setting the type on a radio button after the value resets the value in IE6-9
						// Reset value to it's default in case type is set after value
						// This is for element creation
						var val = elem.value;
						elem.setAttribute( "type", value );
						if ( val ) {
							elem.value = val;
						}
						return value;
					}
				}
			},
			// Use the value property for back compat
			// Use the nodeHook for button elements in IE6/7 (#1954)
			value: {
				get: function( elem, name ) {
					if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
						return nodeHook.get( elem, name );
					}
					return name in elem ?
						elem.value :
						null;
				},
				set: function( elem, value, name ) {
					if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
						return nodeHook.set( elem, value, name );
					}
					// Does not return so that setAttribute is also used
					elem.value = value;
				}
			}
		},
	
		propFix: {
			tabindex: "tabIndex",
			readonly: "readOnly",
			"for": "htmlFor",
			"class": "className",
			maxlength: "maxLength",
			cellspacing: "cellSpacing",
			cellpadding: "cellPadding",
			rowspan: "rowSpan",
			colspan: "colSpan",
			usemap: "useMap",
			frameborder: "frameBorder",
			contenteditable: "contentEditable"
		},
	
		prop: function( elem, name, value ) {
			var ret, hooks, notxml,
				nType = elem.nodeType;
	
			// don't get/set properties on text, comment and attribute nodes
			if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
				return;
			}
	
			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
	
			if ( notxml ) {
				// Fix name and attach hooks
				name = jQuery.propFix[ name ] || name;
				hooks = jQuery.propHooks[ name ];
			}
	
			if ( value !== undefined ) {
				if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
					return ret;
	
				} else {
					return ( elem[ name ] = value );
				}
	
			} else {
				if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
					return ret;
	
				} else {
					return elem[ name ];
				}
			}
		},
	
		propHooks: {
			tabIndex: {
				get: function( elem ) {
					// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
					// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
					var attributeNode = elem.getAttributeNode("tabindex");
	
					return attributeNode && attributeNode.specified ?
						parseInt( attributeNode.value, 10 ) :
						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
							0 :
							undefined;
				}
			}
		}
	});
	
	// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
	jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
	
	// Hook for boolean attributes
	boolHook = {
		get: function( elem, name ) {
			// Align boolean attributes with corresponding properties
			// Fall back to attribute presence where some booleans are not supported
			var attrNode,
				property = jQuery.prop( elem, name );
			return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
				name.toLowerCase() :
				undefined;
		},
		set: function( elem, value, name ) {
			var propName;
			if ( value === false ) {
				// Remove boolean attributes when set to false
				jQuery.removeAttr( elem, name );
			} else {
				// value is true since we know at this point it's type boolean and not false
				// Set boolean attributes to the same name and set the DOM property
				propName = jQuery.propFix[ name ] || name;
				if ( propName in elem ) {
					// Only set the IDL specifically if it already exists on the element
					elem[ propName ] = true;
				}
	
				elem.setAttribute( name, name.toLowerCase() );
			}
			return name;
		}
	};
	
	// IE6/7 do not support getting/setting some attributes with get/setAttribute
	if ( !getSetAttribute ) {
	
		fixSpecified = {
			name: true,
			id: true,
			coords: true
		};
	
		// Use this for any attribute in IE6/7
		// This fixes almost every IE6/7 issue
		nodeHook = jQuery.valHooks.button = {
			get: function( elem, name ) {
				var ret;
				ret = elem.getAttributeNode( name );
				return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
					ret.nodeValue :
					undefined;
			},
			set: function( elem, value, name ) {
				// Set the existing or create a new attribute node
				var ret = elem.getAttributeNode( name );
				if ( !ret ) {
					ret = document.createAttribute( name );
					elem.setAttributeNode( ret );
				}
				return ( ret.nodeValue = value + "" );
			}
		};
	
		// Apply the nodeHook to tabindex
		jQuery.attrHooks.tabindex.set = nodeHook.set;
	
		// Set width and height to auto instead of 0 on empty string( Bug #8150 )
		// This is for removals
		jQuery.each([ "width", "height" ], function( i, name ) {
			jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
				set: function( elem, value ) {
					if ( value === "" ) {
						elem.setAttribute( name, "auto" );
						return value;
					}
				}
			});
		});
	
		// Set contenteditable to false on removals(#10429)
		// Setting to empty string throws an error as an invalid value
		jQuery.attrHooks.contenteditable = {
			get: nodeHook.get,
			set: function( elem, value, name ) {
				if ( value === "" ) {
					value = "false";
				}
				nodeHook.set( elem, value, name );
			}
		};
	}
	
	
	// Some attributes require a special call on IE
	if ( !jQuery.support.hrefNormalized ) {
		jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
			jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
				get: function( elem ) {
					var ret = elem.getAttribute( name, 2 );
					return ret === null ? undefined : ret;
				}
			});
		});
	}
	
	if ( !jQuery.support.style ) {
		jQuery.attrHooks.style = {
			get: function( elem ) {
				// Return undefined in the case of empty string
				// Normalize to lowercase since IE uppercases css property names
				return elem.style.cssText.toLowerCase() || undefined;
			},
			set: function( elem, value ) {
				return ( elem.style.cssText = "" + value );
			}
		};
	}
	
	// Safari mis-reports the default selected property of an option
	// Accessing the parent's selectedIndex property fixes it
	if ( !jQuery.support.optSelected ) {
		jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
			get: function( elem ) {
				var parent = elem.parentNode;
	
				if ( parent ) {
					parent.selectedIndex;
	
					// Make sure that it also works with optgroups, see #5701
					if ( parent.parentNode ) {
						parent.parentNode.selectedIndex;
					}
				}
				return null;
			}
		});
	}
	
	// IE6/7 call enctype encoding
	if ( !jQuery.support.enctype ) {
		jQuery.propFix.enctype = "encoding";
	}
	
	// Radios and checkboxes getter/setter
	if ( !jQuery.support.checkOn ) {
		jQuery.each([ "radio", "checkbox" ], function() {
			jQuery.valHooks[ this ] = {
				get: function( elem ) {
					// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
					return elem.getAttribute("value") === null ? "on" : elem.value;
				}
			};
		});
	}
	jQuery.each([ "radio", "checkbox" ], function() {
		jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
			set: function( elem, value ) {
				if ( jQuery.isArray( value ) ) {
					return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
				}
			}
		});
	});
	
	
	
	
	var rformElems = /^(?:textarea|input|select)$/i,
		rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
		rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
		rkeyEvent = /^key/,
		rmouseEvent = /^(?:mouse|contextmenu)|click/,
		rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
		rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
		quickParse = function( selector ) {
			var quick = rquickIs.exec( selector );
			if ( quick ) {
				//   0  1    2   3
				// [ _, tag, id, class ]
				quick[1] = ( quick[1] || "" ).toLowerCase();
				quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
			}
			return quick;
		},
		quickIs = function( elem, m ) {
			var attrs = elem.attributes || {};
			return (
				(!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
				(!m[2] || (attrs.id || {}).value === m[2]) &&
				(!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
			);
		},
		hoverHack = function( events ) {
			return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
		};
	
	/*
	 * Helper functions for managing events -- not part of the public interface.
	 * Props to Dean Edwards' addEvent library for many of the ideas.
	 */
	jQuery.event = {
	
		add: function( elem, types, handler, data, selector ) {
	
			var elemData, eventHandle, events,
				t, tns, type, namespaces, handleObj,
				handleObjIn, quick, handlers, special;
	
			// Don't attach events to noData or text/comment nodes (allow plain objects tho)
			if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
				return;
			}
	
			// Caller can pass in an object of custom data in lieu of the handler
			if ( handler.handler ) {
				handleObjIn = handler;
				handler = handleObjIn.handler;
				selector = handleObjIn.selector;
			}
	
			// Make sure that the handler has a unique ID, used to find/remove it later
			if ( !handler.guid ) {
				handler.guid = jQuery.guid++;
			}
	
			// Init the element's event structure and main handler, if this is the first
			events = elemData.events;
			if ( !events ) {
				elemData.events = events = {};
			}
			eventHandle = elemData.handle;
			if ( !eventHandle ) {
				elemData.handle = eventHandle = function( e ) {
					// Discard the second event of a jQuery.event.trigger() and
					// when an event is called after a page has unloaded
					return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
						jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
						undefined;
				};
				// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
				eventHandle.elem = elem;
			}
	
			// Handle multiple events separated by a space
			// jQuery(...).bind("mouseover mouseout", fn);
			types = jQuery.trim( hoverHack(types) ).split( " " );
			for ( t = 0; t < types.length; t++ ) {
	
				tns = rtypenamespace.exec( types[t] ) || [];
				type = tns[1];
				namespaces = ( tns[2] || "" ).split( "." ).sort();
	
				// If event changes its type, use the special event handlers for the changed type
				special = jQuery.event.special[ type ] || {};
	
				// If selector defined, determine special event api type, otherwise given type
				type = ( selector ? special.delegateType : special.bindType ) || type;
	
				// Update special based on newly reset type
				special = jQuery.event.special[ type ] || {};
	
				// handleObj is passed to all event handlers
				handleObj = jQuery.extend({
					type: type,
					origType: tns[1],
					data: data,
					handler: handler,
					guid: handler.guid,
					selector: selector,
					quick: selector && quickParse( selector ),
					namespace: namespaces.join(".")
				}, handleObjIn );
	
				// Init the event handler queue if we're the first
				handlers = events[ type ];
				if ( !handlers ) {
					handlers = events[ type ] = [];
					handlers.delegateCount = 0;
	
					// Only use addEventListener/attachEvent if the special events handler returns false
					if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
						// Bind the global event handler to the element
						if ( elem.addEventListener ) {
							elem.addEventListener( type, eventHandle, false );
	
						} else if ( elem.attachEvent ) {
							elem.attachEvent( "on" + type, eventHandle );
						}
					}
				}
	
				if ( special.add ) {
					special.add.call( elem, handleObj );
	
					if ( !handleObj.handler.guid ) {
						handleObj.handler.guid = handler.guid;
					}
				}
	
				// Add to the element's handler list, delegates in front
				if ( selector ) {
					handlers.splice( handlers.delegateCount++, 0, handleObj );
				} else {
					handlers.push( handleObj );
				}
	
				// Keep track of which events have ever been used, for event optimization
				jQuery.event.global[ type ] = true;
			}
	
			// Nullify elem to prevent memory leaks in IE
			elem = null;
		},
	
		global: {},
	
		// Detach an event or set of events from an element
		remove: function( elem, types, handler, selector, mappedTypes ) {
	
			var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
				t, tns, type, origType, namespaces, origCount,
				j, events, special, handle, eventType, handleObj;
	
			if ( !elemData || !(events = elemData.events) ) {
				return;
			}
	
			// Once for each type.namespace in types; type may be omitted
			types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
			for ( t = 0; t < types.length; t++ ) {
				tns = rtypenamespace.exec( types[t] ) || [];
				type = origType = tns[1];
				namespaces = tns[2];
	
				// Unbind all events (on this namespace, if provided) for the element
				if ( !type ) {
					for ( type in events ) {
						jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
					}
					continue;
				}
	
				special = jQuery.event.special[ type ] || {};
				type = ( selector? special.delegateType : special.bindType ) || type;
				eventType = events[ type ] || [];
				origCount = eventType.length;
				namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
	
				// Remove matching events
				for ( j = 0; j < eventType.length; j++ ) {
					handleObj = eventType[ j ];
	
					if ( ( mappedTypes || origType === handleObj.origType ) &&
						 ( !handler || handler.guid === handleObj.guid ) &&
						 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
						 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
						eventType.splice( j--, 1 );
	
						if ( handleObj.selector ) {
							eventType.delegateCount--;
						}
						if ( special.remove ) {
							special.remove.call( elem, handleObj );
						}
					}
				}
	
				// Remove generic event handler if we removed something and no more handlers exist
				// (avoids potential for endless recursion during removal of special event handlers)
				if ( eventType.length === 0 && origCount !== eventType.length ) {
					if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
						jQuery.removeEvent( elem, type, elemData.handle );
					}
	
					delete events[ type ];
				}
			}
	
			// Remove the expando if it's no longer used
			if ( jQuery.isEmptyObject( events ) ) {
				handle = elemData.handle;
				if ( handle ) {
					handle.elem = null;
				}
	
				// removeData also checks for emptiness and clears the expando if empty
				// so use it instead of delete
				jQuery.removeData( elem, [ "events", "handle" ], true );
			}
		},
	
		// Events that are safe to short-circuit if no handlers are attached.
		// Native DOM events should not be added, they may have inline handlers.
		customEvent: {
			"getData": true,
			"setData": true,
			"changeData": true
		},
	
		trigger: function( event, data, elem, onlyHandlers ) {
			// Don't do events on text and comment nodes
			if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
				return;
			}
	
			// Event object or event type
			var type = event.type || event,
				namespaces = [],
				cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
	
			// focus/blur morphs to focusin/out; ensure we're not firing them right now
			if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
				return;
			}
	
			if ( type.indexOf( "!" ) >= 0 ) {
				// Exclusive events trigger only for the exact event (no namespaces)
				type = type.slice(0, -1);
				exclusive = true;
			}
	
			if ( type.indexOf( "." ) >= 0 ) {
				// Namespaced trigger; create a regexp to match event type in handle()
				namespaces = type.split(".");
				type = namespaces.shift();
				namespaces.sort();
			}
	
			if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
				// No jQuery handlers for this event type, and it can't have inline handlers
				return;
			}
	
			// Caller can pass in an Event, Object, or just an event type string
			event = typeof event === "object" ?
				// jQuery.Event object
				event[ jQuery.expando ] ? event :
				// Object literal
				new jQuery.Event( type, event ) :
				// Just the event type (string)
				new jQuery.Event( type );
	
			event.type = type;
			event.isTrigger = true;
			event.exclusive = exclusive;
			event.namespace = namespaces.join( "." );
			event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
			ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
	
			// Handle a global trigger
			if ( !elem ) {
	
				// TODO: Stop taunting the data cache; remove global events and always attach to document
				cache = jQuery.cache;
				for ( i in cache ) {
					if ( cache[ i ].events && cache[ i ].events[ type ] ) {
						jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
					}
				}
				return;
			}
	
			// Clean up the event in case it is being reused
			event.result = undefined;
			if ( !event.target ) {
				event.target = elem;
			}
	
			// Clone any incoming data and prepend the event, creating the handler arg list
			data = data != null ? jQuery.makeArray( data ) : [];
			data.unshift( event );
	
			// Allow special events to draw outside the lines
			special = jQuery.event.special[ type ] || {};
			if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
				return;
			}
	
			// Determine event propagation path in advance, per W3C events spec (#9951)
			// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
			eventPath = [[ elem, special.bindType || type ]];
			if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
	
				bubbleType = special.delegateType || type;
				cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
				old = null;
				for ( ; cur; cur = cur.parentNode ) {
					eventPath.push([ cur, bubbleType ]);
					old = cur;
				}
	
				// Only add window if we got to document (e.g., not plain obj or detached DOM)
				if ( old && old === elem.ownerDocument ) {
					eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
				}
			}
	
			// Fire handlers on the event path
			for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
	
				cur = eventPath[i][0];
				event.type = eventPath[i][1];
	
				handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
				if ( handle ) {
					handle.apply( cur, data );
				}
				// Note that this is a bare JS function and not a jQuery handler
				handle = ontype && cur[ ontype ];
				if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
					event.preventDefault();
				}
			}
			event.type = type;
	
			// If nobody prevented the default action, do it now
			if ( !onlyHandlers && !event.isDefaultPrevented() ) {
	
				if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
					!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
	
					// Call a native DOM method on the target with the same name name as the event.
					// Can't use an .isFunction() check here because IE6/7 fails that test.
					// Don't do default actions on window, that's where global variables be (#6170)
					// IE<9 dies on focus/blur to hidden element (#1486)
					if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
	
						// Don't re-trigger an onFOO event when we call its FOO() method
						old = elem[ ontype ];
	
						if ( old ) {
							elem[ ontype ] = null;
						}
	
						// Prevent re-triggering of the same event, since we already bubbled it above
						jQuery.event.triggered = type;
						elem[ type ]();
						jQuery.event.triggered = undefined;
	
						if ( old ) {
							elem[ ontype ] = old;
						}
					}
				}
			}
	
			return event.result;
		},
	
		dispatch: function( event ) {
	
			// Make a writable jQuery.Event from the native event object
			event = jQuery.event.fix( event || window.event );
	
			var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
				delegateCount = handlers.delegateCount,
				args = [].slice.call( arguments, 0 ),
				run_all = !event.exclusive && !event.namespace,
				special = jQuery.event.special[ event.type ] || {},
				handlerQueue = [],
				i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
	
			// Use the fix-ed jQuery.Event rather than the (read-only) native event
			args[0] = event;
			event.delegateTarget = this;
	
			// Call the preDispatch hook for the mapped type, and let it bail if desired
			if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
				return;
			}
	
			// Determine handlers that should run if there are delegated events
			// Avoid non-left-click bubbling in Firefox (#3861)
			if ( delegateCount && !(event.button && event.type === "click") ) {
	
				// Pregenerate a single jQuery object for reuse with .is()
				jqcur = jQuery(this);
				jqcur.context = this.ownerDocument || this;
	
				for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
	
					// Don't process events on disabled elements (#6911, #8165)
					if ( cur.disabled !== true ) {
						selMatch = {};
						matches = [];
						jqcur[0] = cur;
						for ( i = 0; i < delegateCount; i++ ) {
							handleObj = handlers[ i ];
							sel = handleObj.selector;
	
							if ( selMatch[ sel ] === undefined ) {
								selMatch[ sel ] = (
									handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
								);
							}
							if ( selMatch[ sel ] ) {
								matches.push( handleObj );
							}
						}
						if ( matches.length ) {
							handlerQueue.push({ elem: cur, matches: matches });
						}
					}
				}
			}
	
			// Add the remaining (directly-bound) handlers
			if ( handlers.length > delegateCount ) {
				handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
			}
	
			// Run delegates first; they may want to stop propagation beneath us
			for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
				matched = handlerQueue[ i ];
				event.currentTarget = matched.elem;
	
				for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
					handleObj = matched.matches[ j ];
	
					// Triggered event must either 1) be non-exclusive and have no namespace, or
					// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
					if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
	
						event.data = handleObj.data;
						event.handleObj = handleObj;
	
						ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
								.apply( matched.elem, args );
	
						if ( ret !== undefined ) {
							event.result = ret;
							if ( ret === false ) {
								event.preventDefault();
								event.stopPropagation();
							}
						}
					}
				}
			}
	
			// Call the postDispatch hook for the mapped type
			if ( special.postDispatch ) {
				special.postDispatch.call( this, event );
			}
	
			return event.result;
		},
	
		// Includes some event props shared by KeyEvent and MouseEvent
		// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
		props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
	
		fixHooks: {},
	
		keyHooks: {
			props: "char charCode key keyCode".split(" "),
			filter: function( event, original ) {
	
				// Add which for key events
				if ( event.which == null ) {
					event.which = original.charCode != null ? original.charCode : original.keyCode;
				}
	
				return event;
			}
		},
	
		mouseHooks: {
			props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
			filter: function( event, original ) {
				var eventDoc, doc, body,
					button = original.button,
					fromElement = original.fromElement;
	
				// Calculate pageX/Y if missing and clientX/Y available
				if ( event.pageX == null && original.clientX != null ) {
					eventDoc = event.target.ownerDocument || document;
					doc = eventDoc.documentElement;
					body = eventDoc.body;
	
					event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
					event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
				}
	
				// Add relatedTarget, if necessary
				if ( !event.relatedTarget && fromElement ) {
					event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
				}
	
				// Add which for click: 1 === left; 2 === middle; 3 === right
				// Note: button is not normalized, so don't use it
				if ( !event.which && button !== undefined ) {
					event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
				}
	
				return event;
			}
		},
	
		fix: function( event ) {
			if ( event[ jQuery.expando ] ) {
				return event;
			}
	
			// Create a writable copy of the event object and normalize some properties
			var i, prop,
				originalEvent = event,
				fixHook = jQuery.event.fixHooks[ event.type ] || {},
				copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
	
			event = jQuery.Event( originalEvent );
	
			for ( i = copy.length; i; ) {
				prop = copy[ --i ];
				event[ prop ] = originalEvent[ prop ];
			}
	
			// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
			if ( !event.target ) {
				event.target = originalEvent.srcElement || document;
			}
	
			// Target should not be a text node (#504, Safari)
			if ( event.target.nodeType === 3 ) {
				event.target = event.target.parentNode;
			}
	
			// For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
			if ( event.metaKey === undefined ) {
				event.metaKey = event.ctrlKey;
			}
	
			return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
		},
	
		special: {
			ready: {
				// Make sure the ready event is setup
				setup: jQuery.bindReady
			},
	
			load: {
				// Prevent triggered image.load events from bubbling to window.load
				noBubble: true
			},
	
			focus: {
				delegateType: "focusin"
			},
			blur: {
				delegateType: "focusout"
			},
	
			beforeunload: {
				setup: function( data, namespaces, eventHandle ) {
					// We only want to do this special case on windows
					if ( jQuery.isWindow( this ) ) {
						this.onbeforeunload = eventHandle;
					}
				},
	
				teardown: function( namespaces, eventHandle ) {
					if ( this.onbeforeunload === eventHandle ) {
						this.onbeforeunload = null;
					}
				}
			}
		},
	
		simulate: function( type, elem, event, bubble ) {
			// Piggyback on a donor event to simulate a different one.
			// Fake originalEvent to avoid donor's stopPropagation, but if the
			// simulated event prevents default then we do the same on the donor.
			var e = jQuery.extend(
				new jQuery.Event(),
				event,
				{ type: type,
					isSimulated: true,
					originalEvent: {}
				}
			);
			if ( bubble ) {
				jQuery.event.trigger( e, null, elem );
			} else {
				jQuery.event.dispatch.call( elem, e );
			}
			if ( e.isDefaultPrevented() ) {
				event.preventDefault();
			}
		}
	};
	
	// Some plugins are using, but it's undocumented/deprecated and will be removed.
	// The 1.7 special event interface should provide all the hooks needed now.
	jQuery.event.handle = jQuery.event.dispatch;
	
	jQuery.removeEvent = document.removeEventListener ?
		function( elem, type, handle ) {
			if ( elem.removeEventListener ) {
				elem.removeEventListener( type, handle, false );
			}
		} :
		function( elem, type, handle ) {
			if ( elem.detachEvent ) {
				elem.detachEvent( "on" + type, handle );
			}
		};
	
	jQuery.Event = function( src, props ) {
		// Allow instantiation without the 'new' keyword
		if ( !(this instanceof jQuery.Event) ) {
			return new jQuery.Event( src, props );
		}
	
		// Event object
		if ( src && src.type ) {
			this.originalEvent = src;
			this.type = src.type;
	
			// Events bubbling up the document may have been marked as prevented
			// by a handler lower down the tree; reflect the correct value.
			this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
				src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
	
		// Event type
		} else {
			this.type = src;
		}
	
		// Put explicitly provided properties onto the event object
		if ( props ) {
			jQuery.extend( this, props );
		}
	
		// Create a timestamp if incoming event doesn't have one
		this.timeStamp = src && src.timeStamp || jQuery.now();
	
		// Mark it as fixed
		this[ jQuery.expando ] = true;
	};
	
	function returnFalse() {
		return false;
	}
	function returnTrue() {
		return true;
	}
	
	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
	// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
	jQuery.Event.prototype = {
		preventDefault: function() {
			this.isDefaultPrevented = returnTrue;
	
			var e = this.originalEvent;
			if ( !e ) {
				return;
			}
	
			// if preventDefault exists run it on the original event
			if ( e.preventDefault ) {
				e.preventDefault();
	
			// otherwise set the returnValue property of the original event to false (IE)
			} else {
				e.returnValue = false;
			}
		},
		stopPropagation: function() {
			this.isPropagationStopped = returnTrue;
	
			var e = this.originalEvent;
			if ( !e ) {
				return;
			}
			// if stopPropagation exists run it on the original event
			if ( e.stopPropagation ) {
				e.stopPropagation();
			}
			// otherwise set the cancelBubble property of the original event to true (IE)
			e.cancelBubble = true;
		},
		stopImmediatePropagation: function() {
			this.isImmediatePropagationStopped = returnTrue;
			this.stopPropagation();
		},
		isDefaultPrevented: returnFalse,
		isPropagationStopped: returnFalse,
		isImmediatePropagationStopped: returnFalse
	};
	
	// Create mouseenter/leave events using mouseover/out and event-time checks
	jQuery.each({
		mouseenter: "mouseover",
		mouseleave: "mouseout"
	}, function( orig, fix ) {
		jQuery.event.special[ orig ] = {
			delegateType: fix,
			bindType: fix,
	
			handle: function( event ) {
				var target = this,
					related = event.relatedTarget,
					handleObj = event.handleObj,
					selector = handleObj.selector,
					ret;
	
				// For mousenter/leave call the handler if related is outside the target.
				// NB: No relatedTarget if the mouse left/entered the browser window
				if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
					event.type = handleObj.origType;
					ret = handleObj.handler.apply( this, arguments );
					event.type = fix;
				}
				return ret;
			}
		};
	});
	
	// IE submit delegation
	if ( !jQuery.support.submitBubbles ) {
	
		jQuery.event.special.submit = {
			setup: function() {
				// Only need this for delegated form submit events
				if ( jQuery.nodeName( this, "form" ) ) {
					return false;
				}
	
				// Lazy-add a submit handler when a descendant form may potentially be submitted
				jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
					// Node name check avoids a VML-related crash in IE (#9807)
					var elem = e.target,
						form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
					if ( form && !form._submit_attached ) {
						jQuery.event.add( form, "submit._submit", function( event ) {
							event._submit_bubble = true;
						});
						form._submit_attached = true;
					}
				});
				// return undefined since we don't need an event listener
			},
			
			postDispatch: function( event ) {
				// If form was submitted by the user, bubble the event up the tree
				if ( event._submit_bubble ) {
					delete event._submit_bubble;
					if ( this.parentNode && !event.isTrigger ) {
						jQuery.event.simulate( "submit", this.parentNode, event, true );
					}
				}
			},
	
			teardown: function() {
				// Only need this for delegated form submit events
				if ( jQuery.nodeName( this, "form" ) ) {
					return false;
				}
	
				// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
				jQuery.event.remove( this, "._submit" );
			}
		};
	}
	
	// IE change delegation and checkbox/radio fix
	if ( !jQuery.support.changeBubbles ) {
	
		jQuery.event.special.change = {
	
			setup: function() {
	
				if ( rformElems.test( this.nodeName ) ) {
					// IE doesn't fire change on a check/radio until blur; trigger it on click
					// after a propertychange. Eat the blur-change in special.change.handle.
					// This still fires onchange a second time for check/radio after blur.
					if ( this.type === "checkbox" || this.type === "radio" ) {
						jQuery.event.add( this, "propertychange._change", function( event ) {
							if ( event.originalEvent.propertyName === "checked" ) {
								this._just_changed = true;
							}
						});
						jQuery.event.add( this, "click._change", function( event ) {
							if ( this._just_changed && !event.isTrigger ) {
								this._just_changed = false;
								jQuery.event.simulate( "change", this, event, true );
							}
						});
					}
					return false;
				}
				// Delegated event; lazy-add a change handler on descendant inputs
				jQuery.event.add( this, "beforeactivate._change", function( e ) {
					var elem = e.target;
	
					if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
						jQuery.event.add( elem, "change._change", function( event ) {
							if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
								jQuery.event.simulate( "change", this.parentNode, event, true );
							}
						});
						elem._change_attached = true;
					}
				});
			},
	
			handle: function( event ) {
				var elem = event.target;
	
				// Swallow native change events from checkbox/radio, we already triggered them above
				if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
					return event.handleObj.handler.apply( this, arguments );
				}
			},
	
			teardown: function() {
				jQuery.event.remove( this, "._change" );
	
				return rformElems.test( this.nodeName );
			}
		};
	}
	
	// Create "bubbling" focus and blur events
	if ( !jQuery.support.focusinBubbles ) {
		jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
	
			// Attach a single capturing handler while someone wants focusin/focusout
			var attaches = 0,
				handler = function( event ) {
					jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
				};
	
			jQuery.event.special[ fix ] = {
				setup: function() {
					if ( attaches++ === 0 ) {
						document.addEventListener( orig, handler, true );
					}
				},
				teardown: function() {
					if ( --attaches === 0 ) {
						document.removeEventListener( orig, handler, true );
					}
				}
			};
		});
	}
	
	jQuery.fn.extend({
	
		on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
			var origFn, type;
	
			// Types can be a map of types/handlers
			if ( typeof types === "object" ) {
				// ( types-Object, selector, data )
				if ( typeof selector !== "string" ) { // && selector != null
					// ( types-Object, data )
					data = data || selector;
					selector = undefined;
				}
				for ( type in types ) {
					this.on( type, selector, data, types[ type ], one );
				}
				return this;
			}
	
			if ( data == null && fn == null ) {
				// ( types, fn )
				fn = selector;
				data = selector = undefined;
			} else if ( fn == null ) {
				if ( typeof selector === "string" ) {
					// ( types, selector, fn )
					fn = data;
					data = undefined;
				} else {
					// ( types, data, fn )
					fn = data;
					data = selector;
					selector = undefined;
				}
			}
			if ( fn === false ) {
				fn = returnFalse;
			} else if ( !fn ) {
				return this;
			}
	
			if ( one === 1 ) {
				origFn = fn;
				fn = function( event ) {
					// Can use an empty set, since event contains the info
					jQuery().off( event );
					return origFn.apply( this, arguments );
				};
				// Use same guid so caller can remove using origFn
				fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
			}
			return this.each( function() {
				jQuery.event.add( this, types, fn, data, selector );
			});
		},
		one: function( types, selector, data, fn ) {
			return this.on( types, selector, data, fn, 1 );
		},
		off: function( types, selector, fn ) {
			if ( types && types.preventDefault && types.handleObj ) {
				// ( event )  dispatched jQuery.Event
				var handleObj = types.handleObj;
				jQuery( types.delegateTarget ).off(
					handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
					handleObj.selector,
					handleObj.handler
				);
				return this;
			}
			if ( typeof types === "object" ) {
				// ( types-object [, selector] )
				for ( var type in types ) {
					this.off( type, selector, types[ type ] );
				}
				return this;
			}
			if ( selector === false || typeof selector === "function" ) {
				// ( types [, fn] )
				fn = selector;
				selector = undefined;
			}
			if ( fn === false ) {
				fn = returnFalse;
			}
			return this.each(function() {
				jQuery.event.remove( this, types, fn, selector );
			});
		},
	
		bind: function( types, data, fn ) {
			return this.on( types, null, data, fn );
		},
		unbind: function( types, fn ) {
			return this.off( types, null, fn );
		},
	
		live: function( types, data, fn ) {
			jQuery( this.context ).on( types, this.selector, data, fn );
			return this;
		},
		die: function( types, fn ) {
			jQuery( this.context ).off( types, this.selector || "**", fn );
			return this;
		},
	
		delegate: function( selector, types, data, fn ) {
			return this.on( types, selector, data, fn );
		},
		undelegate: function( selector, types, fn ) {
			// ( namespace ) or ( selector, types [, fn] )
			return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
		},
	
		trigger: function( type, data ) {
			return this.each(function() {
				jQuery.event.trigger( type, data, this );
			});
		},
		triggerHandler: function( type, data ) {
			if ( this[0] ) {
				return jQuery.event.trigger( type, data, this[0], true );
			}
		},
	
		toggle: function( fn ) {
			// Save reference to arguments for access in closure
			var args = arguments,
				guid = fn.guid || jQuery.guid++,
				i = 0,
				toggler = function( event ) {
					// Figure out which function to execute
					var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
					jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
	
					// Make sure that clicks stop
					event.preventDefault();
	
					// and execute the function
					return args[ lastToggle ].apply( this, arguments ) || false;
				};
	
			// link all the functions, so any of them can unbind this click handler
			toggler.guid = guid;
			while ( i < args.length ) {
				args[ i++ ].guid = guid;
			}
	
			return this.click( toggler );
		},
	
		hover: function( fnOver, fnOut ) {
			return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
		}
	});
	
	jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
		"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
		"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
	
		// Handle event binding
		jQuery.fn[ name ] = function( data, fn ) {
			if ( fn == null ) {
				fn = data;
				data = null;
			}
	
			return arguments.length > 0 ?
				this.on( name, null, data, fn ) :
				this.trigger( name );
		};
	
		if ( jQuery.attrFn ) {
			jQuery.attrFn[ name ] = true;
		}
	
		if ( rkeyEvent.test( name ) ) {
			jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
		}
	
		if ( rmouseEvent.test( name ) ) {
			jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
		}
	});
	
	
	
	/*!
	 * Sizzle CSS Selector Engine
	 *  Copyright 2011, The Dojo Foundation
	 *  Released under the MIT, BSD, and GPL Licenses.
	 *  More information: http://sizzlejs.com/
	 */
	(function(){
	
	var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
		expando = "sizcache" + (Math.random() + '').replace('.', ''),
		done = 0,
		toString = Object.prototype.toString,
		hasDuplicate = false,
		baseHasDuplicate = true,
		rBackslash = /\\/g,
		rReturn = /\r\n/g,
		rNonWord = /\W/;
	
	// Here we check if the JavaScript engine is using some sort of
	// optimization where it does not always call our comparision
	// function. If that is the case, discard the hasDuplicate value.
	//   Thus far that includes Google Chrome.
	[0, 0].sort(function() {
		baseHasDuplicate = false;
		return 0;
	});
	
	var Sizzle = function( selector, context, results, seed ) {
		results = results || [];
		context = context || document;
	
		var origContext = context;
	
		if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
			return [];
		}
	
		if ( !selector || typeof selector !== "string" ) {
			return results;
		}
	
		var m, set, checkSet, extra, ret, cur, pop, i,
			prune = true,
			contextXML = Sizzle.isXML( context ),
			parts = [],
			soFar = selector;
	
		// Reset the position of the chunker regexp (start from head)
		do {
			chunker.exec( "" );
			m = chunker.exec( soFar );
	
			if ( m ) {
				soFar = m[3];
	
				parts.push( m[1] );
	
				if ( m[2] ) {
					extra = m[3];
					break;
				}
			}
		} while ( m );
	
		if ( parts.length > 1 && origPOS.exec( selector ) ) {
	
			if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
				set = posProcess( parts[0] + parts[1], context, seed );
	
			} else {
				set = Expr.relative[ parts[0] ] ?
					[ context ] :
					Sizzle( parts.shift(), context );
	
				while ( parts.length ) {
					selector = parts.shift();
	
					if ( Expr.relative[ selector ] ) {
						selector += parts.shift();
					}
	
					set = posProcess( selector, set, seed );
				}
			}
	
		} else {
			// Take a shortcut and set the context if the root selector is an ID
			// (but not if it'll be faster if the inner selector is an ID)
			if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
					Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
	
				ret = Sizzle.find( parts.shift(), context, contextXML );
				context = ret.expr ?
					Sizzle.filter( ret.expr, ret.set )[0] :
					ret.set[0];
			}
	
			if ( context ) {
				ret = seed ?
					{ expr: parts.pop(), set: makeArray(seed) } :
					Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
	
				set = ret.expr ?
					Sizzle.filter( ret.expr, ret.set ) :
					ret.set;
	
				if ( parts.length > 0 ) {
					checkSet = makeArray( set );
	
				} else {
					prune = false;
				}
	
				while ( parts.length ) {
					cur = parts.pop();
					pop = cur;
	
					if ( !Expr.relative[ cur ] ) {
						cur = "";
					} else {
						pop = parts.pop();
					}
	
					if ( pop == null ) {
						pop = context;
					}
	
					Expr.relative[ cur ]( checkSet, pop, contextXML );
				}
	
			} else {
				checkSet = parts = [];
			}
		}
	
		if ( !checkSet ) {
			checkSet = set;
		}
	
		if ( !checkSet ) {
			Sizzle.error( cur || selector );
		}
	
		if ( toString.call(checkSet) === "[object Array]" ) {
			if ( !prune ) {
				results.push.apply( results, checkSet );
	
			} else if ( context && context.nodeType === 1 ) {
				for ( i = 0; checkSet[i] != null; i++ ) {
					if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
						results.push( set[i] );
					}
				}
	
			} else {
				for ( i = 0; checkSet[i] != null; i++ ) {
					if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
						results.push( set[i] );
					}
				}
			}
	
		} else {
			makeArray( checkSet, results );
		}
	
		if ( extra ) {
			Sizzle( extra, origContext, results, seed );
			Sizzle.uniqueSort( results );
		}
	
		return results;
	};
	
	Sizzle.uniqueSort = function( results ) {
		if ( sortOrder ) {
			hasDuplicate = baseHasDuplicate;
			results.sort( sortOrder );
	
			if ( hasDuplicate ) {
				for ( var i = 1; i < results.length; i++ ) {
					if ( results[i] === results[ i - 1 ] ) {
						results.splice( i--, 1 );
					}
				}
			}
		}
	
		return results;
	};
	
	Sizzle.matches = function( expr, set ) {
		return Sizzle( expr, null, null, set );
	};
	
	Sizzle.matchesSelector = function( node, expr ) {
		return Sizzle( expr, null, null, [node] ).length > 0;
	};
	
	Sizzle.find = function( expr, context, isXML ) {
		var set, i, len, match, type, left;
	
		if ( !expr ) {
			return [];
		}
	
		for ( i = 0, len = Expr.order.length; i < len; i++ ) {
			type = Expr.order[i];
	
			if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
				left = match[1];
				match.splice( 1, 1 );
	
				if ( left.substr( left.length - 1 ) !== "\\" ) {
					match[1] = (match[1] || "").replace( rBackslash, "" );
					set = Expr.find[ type ]( match, context, isXML );
	
					if ( set != null ) {
						expr = expr.replace( Expr.match[ type ], "" );
						break;
					}
				}
			}
		}
	
		if ( !set ) {
			set = typeof context.getElementsByTagName !== "undefined" ?
				context.getElementsByTagName( "*" ) :
				[];
		}
	
		return { set: set, expr: expr };
	};
	
	Sizzle.filter = function( expr, set, inplace, not ) {
		var match, anyFound,
			type, found, item, filter, left,
			i, pass,
			old = expr,
			result = [],
			curLoop = set,
			isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
	
		while ( expr && set.length ) {
			for ( type in Expr.filter ) {
				if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
					filter = Expr.filter[ type ];
					left = match[1];
	
					anyFound = false;
	
					match.splice(1,1);
	
					if ( left.substr( left.length - 1 ) === "\\" ) {
						continue;
					}
	
					if ( curLoop === result ) {
						result = [];
					}
	
					if ( Expr.preFilter[ type ] ) {
						match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
	
						if ( !match ) {
							anyFound = found = true;
	
						} else if ( match === true ) {
							continue;
						}
					}
	
					if ( match ) {
						for ( i = 0; (item = curLoop[i]) != null; i++ ) {
							if ( item ) {
								found = filter( item, match, i, curLoop );
								pass = not ^ found;
	
								if ( inplace && found != null ) {
									if ( pass ) {
										anyFound = true;
	
									} else {
										curLoop[i] = false;
									}
	
								} else if ( pass ) {
									result.push( item );
									anyFound = true;
								}
							}
						}
					}
	
					if ( found !== undefined ) {
						if ( !inplace ) {
							curLoop = result;
						}
	
						expr = expr.replace( Expr.match[ type ], "" );
	
						if ( !anyFound ) {
							return [];
						}
	
						break;
					}
				}
			}
	
			// Improper expression
			if ( expr === old ) {
				if ( anyFound == null ) {
					Sizzle.error( expr );
	
				} else {
					break;
				}
			}
	
			old = expr;
		}
	
		return curLoop;
	};
	
	Sizzle.error = function( msg ) {
		throw new Error( "Syntax error, unrecognized expression: " + msg );
	};
	
	/**
	 * Utility function for retreiving the text value of an array of DOM nodes
	 * @param {Array|Element} elem
	 */
	var getText = Sizzle.getText = function( elem ) {
	    var i, node,
			nodeType = elem.nodeType,
			ret = "";
	
		if ( nodeType ) {
			if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
				// Use textContent || innerText for elements
				if ( typeof elem.textContent === 'string' ) {
					return elem.textContent;
				} else if ( typeof elem.innerText === 'string' ) {
					// Replace IE's carriage returns
					return elem.innerText.replace( rReturn, '' );
				} else {
					// Traverse it's children
					for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
						ret += getText( elem );
					}
				}
			} else if ( nodeType === 3 || nodeType === 4 ) {
				return elem.nodeValue;
			}
		} else {
	
			// If no nodeType, this is expected to be an array
			for ( i = 0; (node = elem[i]); i++ ) {
				// Do not traverse comment nodes
				if ( node.nodeType !== 8 ) {
					ret += getText( node );
				}
			}
		}
		return ret;
	};
	
	var Expr = Sizzle.selectors = {
		order: [ "ID", "NAME", "TAG" ],
	
		match: {
			ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
			CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
			NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
			ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
			TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
			CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
			POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
			PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
		},
	
		leftMatch: {},
	
		attrMap: {
			"class": "className",
			"for": "htmlFor"
		},
	
		attrHandle: {
			href: function( elem ) {
				return elem.getAttribute( "href" );
			},
			type: function( elem ) {
				return elem.getAttribute( "type" );
			}
		},
	
		relative: {
			"+": function(checkSet, part){
				var isPartStr = typeof part === "string",
					isTag = isPartStr && !rNonWord.test( part ),
					isPartStrNotTag = isPartStr && !isTag;
	
				if ( isTag ) {
					part = part.toLowerCase();
				}
	
				for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
					if ( (elem = checkSet[i]) ) {
						while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
	
						checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
							elem || false :
							elem === part;
					}
				}
	
				if ( isPartStrNotTag ) {
					Sizzle.filter( part, checkSet, true );
				}
			},
	
			">": function( checkSet, part ) {
				var elem,
					isPartStr = typeof part === "string",
					i = 0,
					l = checkSet.length;
	
				if ( isPartStr && !rNonWord.test( part ) ) {
					part = part.toLowerCase();
	
					for ( ; i < l; i++ ) {
						elem = checkSet[i];
	
						if ( elem ) {
							var parent = elem.parentNode;
							checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
						}
					}
	
				} else {
					for ( ; i < l; i++ ) {
						elem = checkSet[i];
	
						if ( elem ) {
							checkSet[i] = isPartStr ?
								elem.parentNode :
								elem.parentNode === part;
						}
					}
	
					if ( isPartStr ) {
						Sizzle.filter( part, checkSet, true );
					}
				}
			},
	
			"": function(checkSet, part, isXML){
				var nodeCheck,
					doneName = done++,
					checkFn = dirCheck;
	
				if ( typeof part === "string" && !rNonWord.test( part ) ) {
					part = part.toLowerCase();
					nodeCheck = part;
					checkFn = dirNodeCheck;
				}
	
				checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
			},
	
			"~": function( checkSet, part, isXML ) {
				var nodeCheck,
					doneName = done++,
					checkFn = dirCheck;
	
				if ( typeof part === "string" && !rNonWord.test( part ) ) {
					part = part.toLowerCase();
					nodeCheck = part;
					checkFn = dirNodeCheck;
				}
	
				checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
			}
		},
	
		find: {
			ID: function( match, context, isXML ) {
				if ( typeof context.getElementById !== "undefined" && !isXML ) {
					var m = context.getElementById(match[1]);
					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					return m && m.parentNode ? [m] : [];
				}
			},
	
			NAME: function( match, context ) {
				if ( typeof context.getElementsByName !== "undefined" ) {
					var ret = [],
						results = context.getElementsByName( match[1] );
	
					for ( var i = 0, l = results.length; i < l; i++ ) {
						if ( results[i].getAttribute("name") === match[1] ) {
							ret.push( results[i] );
						}
					}
	
					return ret.length === 0 ? null : ret;
				}
			},
	
			TAG: function( match, context ) {
				if ( typeof context.getElementsByTagName !== "undefined" ) {
					return context.getElementsByTagName( match[1] );
				}
			}
		},
		preFilter: {
			CLASS: function( match, curLoop, inplace, result, not, isXML ) {
				match = " " + match[1].replace( rBackslash, "" ) + " ";
	
				if ( isXML ) {
					return match;
				}
	
				for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
					if ( elem ) {
						if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
							if ( !inplace ) {
								result.push( elem );
							}
	
						} else if ( inplace ) {
							curLoop[i] = false;
						}
					}
				}
	
				return false;
			},
	
			ID: function( match ) {
				return match[1].replace( rBackslash, "" );
			},
	
			TAG: function( match, curLoop ) {
				return match[1].replace( rBackslash, "" ).toLowerCase();
			},
	
			CHILD: function( match ) {
				if ( match[1] === "nth" ) {
					if ( !match[2] ) {
						Sizzle.error( match[0] );
					}
	
					match[2] = match[2].replace(/^\+|\s*/g, '');
	
					// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
					var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
						match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
						!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
	
					// calculate the numbers (first)n+(last) including if they are negative
					match[2] = (test[1] + (test[2] || 1)) - 0;
					match[3] = test[3] - 0;
				}
				else if ( match[2] ) {
					Sizzle.error( match[0] );
				}
	
				// TODO: Move to normal caching system
				match[0] = done++;
	
				return match;
			},
	
			ATTR: function( match, curLoop, inplace, result, not, isXML ) {
				var name = match[1] = match[1].replace( rBackslash, "" );
	
				if ( !isXML && Expr.attrMap[name] ) {
					match[1] = Expr.attrMap[name];
				}
	
				// Handle if an un-quoted value was used
				match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
	
				if ( match[2] === "~=" ) {
					match[4] = " " + match[4] + " ";
				}
	
				return match;
			},
	
			PSEUDO: function( match, curLoop, inplace, result, not ) {
				if ( match[1] === "not" ) {
					// If we're dealing with a complex expression, or a simple one
					if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
						match[3] = Sizzle(match[3], null, null, curLoop);
	
					} else {
						var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
	
						if ( !inplace ) {
							result.push.apply( result, ret );
						}
	
						return false;
					}
	
				} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
					return true;
				}
	
				return match;
			},
	
			POS: function( match ) {
				match.unshift( true );
	
				return match;
			}
		},
	
		filters: {
			enabled: function( elem ) {
				return elem.disabled === false && elem.type !== "hidden";
			},
	
			disabled: function( elem ) {
				return elem.disabled === true;
			},
	
			checked: function( elem ) {
				return elem.checked === true;
			},
	
			selected: function( elem ) {
				// Accessing this property makes selected-by-default
				// options in Safari work properly
				if ( elem.parentNode ) {
					elem.parentNode.selectedIndex;
				}
	
				return elem.selected === true;
			},
	
			parent: function( elem ) {
				return !!elem.firstChild;
			},
	
			empty: function( elem ) {
				return !elem.firstChild;
			},
	
			has: function( elem, i, match ) {
				return !!Sizzle( match[3], elem ).length;
			},
	
			header: function( elem ) {
				return (/h\d/i).test( elem.nodeName );
			},
	
			text: function( elem ) {
				var attr = elem.getAttribute( "type" ), type = elem.type;
				// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
				// use getAttribute instead to test this case
				return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
			},
	
			radio: function( elem ) {
				return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
			},
	
			checkbox: function( elem ) {
				return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
			},
	
			file: function( elem ) {
				return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
			},
	
			password: function( elem ) {
				return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
			},
	
			submit: function( elem ) {
				var name = elem.nodeName.toLowerCase();
				return (name === "input" || name === "button") && "submit" === elem.type;
			},
	
			image: function( elem ) {
				return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
			},
	
			reset: function( elem ) {
				var name = elem.nodeName.toLowerCase();
				return (name === "input" || name === "button") && "reset" === elem.type;
			},
	
			button: function( elem ) {
				var name = elem.nodeName.toLowerCase();
				return name === "input" && "button" === elem.type || name === "button";
			},
	
			input: function( elem ) {
				return (/input|select|textarea|button/i).test( elem.nodeName );
			},
	
			focus: function( elem ) {
				return elem === elem.ownerDocument.activeElement;
			}
		},
		setFilters: {
			first: function( elem, i ) {
				return i === 0;
			},
	
			last: function( elem, i, match, array ) {
				return i === array.length - 1;
			},
	
			even: function( elem, i ) {
				return i % 2 === 0;
			},
	
			odd: function( elem, i ) {
				return i % 2 === 1;
			},
	
			lt: function( elem, i, match ) {
				return i < match[3] - 0;
			},
	
			gt: function( elem, i, match ) {
				return i > match[3] - 0;
			},
	
			nth: function( elem, i, match ) {
				return match[3] - 0 === i;
			},
	
			eq: function( elem, i, match ) {
				return match[3] - 0 === i;
			}
		},
		filter: {
			PSEUDO: function( elem, match, i, array ) {
				var name = match[1],
					filter = Expr.filters[ name ];
	
				if ( filter ) {
					return filter( elem, i, match, array );
	
				} else if ( name === "contains" ) {
					return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
	
				} else if ( name === "not" ) {
					var not = match[3];
	
					for ( var j = 0, l = not.length; j < l; j++ ) {
						if ( not[j] === elem ) {
							return false;
						}
					}
	
					return true;
	
				} else {
					Sizzle.error( name );
				}
			},
	
			CHILD: function( elem, match ) {
				var first, last,
					doneName, parent, cache,
					count, diff,
					type = match[1],
					node = elem;
	
				switch ( type ) {
					case "only":
					case "first":
						while ( (node = node.previousSibling) ) {
							if ( node.nodeType === 1 ) {
								return false;
							}
						}
	
						if ( type === "first" ) {
							return true;
						}
	
						node = elem;
	
						/* falls through */
					case "last":
						while ( (node = node.nextSibling) ) {
							if ( node.nodeType === 1 ) {
								return false;
							}
						}
	
						return true;
	
					case "nth":
						first = match[2];
						last = match[3];
	
						if ( first === 1 && last === 0 ) {
							return true;
						}
	
						doneName = match[0];
						parent = elem.parentNode;
	
						if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
							count = 0;
	
							for ( node = parent.firstChild; node; node = node.nextSibling ) {
								if ( node.nodeType === 1 ) {
									node.nodeIndex = ++count;
								}
							}
	
							parent[ expando ] = doneName;
						}
	
						diff = elem.nodeIndex - last;
	
						if ( first === 0 ) {
							return diff === 0;
	
						} else {
							return ( diff % first === 0 && diff / first >= 0 );
						}
				}
			},
	
			ID: function( elem, match ) {
				return elem.nodeType === 1 && elem.getAttribute("id") === match;
			},
	
			TAG: function( elem, match ) {
				return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
			},
	
			CLASS: function( elem, match ) {
				return (" " + (elem.className || elem.getAttribute("class")) + " ")
					.indexOf( match ) > -1;
			},
	
			ATTR: function( elem, match ) {
				var name = match[1],
					result = Sizzle.attr ?
						Sizzle.attr( elem, name ) :
						Expr.attrHandle[ name ] ?
						Expr.attrHandle[ name ]( elem ) :
						elem[ name ] != null ?
							elem[ name ] :
							elem.getAttribute( name ),
					value = result + "",
					type = match[2],
					check = match[4];
	
				return result == null ?
					type === "!=" :
					!type && Sizzle.attr ?
					result != null :
					type === "=" ?
					value === check :
					type === "*=" ?
					value.indexOf(check) >= 0 :
					type === "~=" ?
					(" " + value + " ").indexOf(check) >= 0 :
					!check ?
					value && result !== false :
					type === "!=" ?
					value !== check :
					type === "^=" ?
					value.indexOf(check) === 0 :
					type === "$=" ?
					value.substr(value.length - check.length) === check :
					type === "|=" ?
					value === check || value.substr(0, check.length + 1) === check + "-" :
					false;
			},
	
			POS: function( elem, match, i, array ) {
				var name = match[2],
					filter = Expr.setFilters[ name ];
	
				if ( filter ) {
					return filter( elem, i, match, array );
				}
			}
		}
	};
	
	var origPOS = Expr.match.POS,
		fescape = function(all, num){
			return "\\" + (num - 0 + 1);
		};
	
	for ( var type in Expr.match ) {
		Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
		Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
	}
	// Expose origPOS
	// "global" as in regardless of relation to brackets/parens
	Expr.match.globalPOS = origPOS;
	
	var makeArray = function( array, results ) {
		array = Array.prototype.slice.call( array, 0 );
	
		if ( results ) {
			results.push.apply( results, array );
			return results;
		}
	
		return array;
	};
	
	// Perform a simple check to determine if the browser is capable of
	// converting a NodeList to an array using builtin methods.
	// Also verifies that the returned array holds DOM nodes
	// (which is not the case in the Blackberry browser)
	try {
		Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
	
	// Provide a fallback method if it does not work
	} catch( e ) {
		makeArray = function( array, results ) {
			var i = 0,
				ret = results || [];
	
			if ( toString.call(array) === "[object Array]" ) {
				Array.prototype.push.apply( ret, array );
	
			} else {
				if ( typeof array.length === "number" ) {
					for ( var l = array.length; i < l; i++ ) {
						ret.push( array[i] );
					}
	
				} else {
					for ( ; array[i]; i++ ) {
						ret.push( array[i] );
					}
				}
			}
	
			return ret;
		};
	}
	
	var sortOrder, siblingCheck;
	
	if ( document.documentElement.compareDocumentPosition ) {
		sortOrder = function( a, b ) {
			if ( a === b ) {
				hasDuplicate = true;
				return 0;
			}
	
			if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
				return a.compareDocumentPosition ? -1 : 1;
			}
	
			return a.compareDocumentPosition(b) & 4 ? -1 : 1;
		};
	
	} else {
		sortOrder = function( a, b ) {
			// The nodes are identical, we can exit early
			if ( a === b ) {
				hasDuplicate = true;
				return 0;
	
			// Fallback to using sourceIndex (in IE) if it's available on both nodes
			} else if ( a.sourceIndex && b.sourceIndex ) {
				return a.sourceIndex - b.sourceIndex;
			}
	
			var al, bl,
				ap = [],
				bp = [],
				aup = a.parentNode,
				bup = b.parentNode,
				cur = aup;
	
			// If the nodes are siblings (or identical) we can do a quick check
			if ( aup === bup ) {
				return siblingCheck( a, b );
	
			// If no parents were found then the nodes are disconnected
			} else if ( !aup ) {
				return -1;
	
			} else if ( !bup ) {
				return 1;
			}
	
			// Otherwise they're somewhere else in the tree so we need
			// to build up a full list of the parentNodes for comparison
			while ( cur ) {
				ap.unshift( cur );
				cur = cur.parentNode;
			}
	
			cur = bup;
	
			while ( cur ) {
				bp.unshift( cur );
				cur = cur.parentNode;
			}
	
			al = ap.length;
			bl = bp.length;
	
			// Start walking down the tree looking for a discrepancy
			for ( var i = 0; i < al && i < bl; i++ ) {
				if ( ap[i] !== bp[i] ) {
					return siblingCheck( ap[i], bp[i] );
				}
			}
	
			// We ended someplace up the tree so do a sibling check
			return i === al ?
				siblingCheck( a, bp[i], -1 ) :
				siblingCheck( ap[i], b, 1 );
		};
	
		siblingCheck = function( a, b, ret ) {
			if ( a === b ) {
				return ret;
			}
	
			var cur = a.nextSibling;
	
			while ( cur ) {
				if ( cur === b ) {
					return -1;
				}
	
				cur = cur.nextSibling;
			}
	
			return 1;
		};
	}
	
	// Check to see if the browser returns elements by name when
	// querying by getElementById (and provide a workaround)
	(function(){
		// We're going to inject a fake input element with a specified name
		var form = document.createElement("div"),
			id = "script" + (new Date()).getTime(),
			root = document.documentElement;
	
		form.innerHTML = "<a name='" + id + "'/>";
	
		// Inject it into the root element, check its status, and remove it quickly
		root.insertBefore( form, root.firstChild );
	
		// The workaround has to do additional checks after a getElementById
		// Which slows things down for other browsers (hence the branching)
		if ( document.getElementById( id ) ) {
			Expr.find.ID = function( match, context, isXML ) {
				if ( typeof context.getElementById !== "undefined" && !isXML ) {
					var m = context.getElementById(match[1]);
	
					return m ?
						m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
							[m] :
							undefined :
						[];
				}
			};
	
			Expr.filter.ID = function( elem, match ) {
				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
	
				return elem.nodeType === 1 && node && node.nodeValue === match;
			};
		}
	
		root.removeChild( form );
	
		// release memory in IE
		root = form = null;
	})();
	
	(function(){
		// Check to see if the browser returns only elements
		// when doing getElementsByTagName("*")
	
		// Create a fake element
		var div = document.createElement("div");
		div.appendChild( document.createComment("") );
	
		// Make sure no comments are found
		if ( div.getElementsByTagName("*").length > 0 ) {
			Expr.find.TAG = function( match, context ) {
				var results = context.getElementsByTagName( match[1] );
	
				// Filter out possible comments
				if ( match[1] === "*" ) {
					var tmp = [];
	
					for ( var i = 0; results[i]; i++ ) {
						if ( results[i].nodeType === 1 ) {
							tmp.push( results[i] );
						}
					}
	
					results = tmp;
				}
	
				return results;
			};
		}
	
		// Check to see if an attribute returns normalized href attributes
		div.innerHTML = "<a href='#'></a>";
	
		if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
				div.firstChild.getAttribute("href") !== "#" ) {
	
			Expr.attrHandle.href = function( elem ) {
				return elem.getAttribute( "href", 2 );
			};
		}
	
		// release memory in IE
		div = null;
	})();
	
	if ( document.querySelectorAll ) {
		(function(){
			var oldSizzle = Sizzle,
				div = document.createElement("div"),
				id = "__sizzle__";
	
			div.innerHTML = "<p class='TEST'></p>";
	
			// Safari can't handle uppercase or unicode characters when
			// in quirks mode.
			if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
				return;
			}
	
			Sizzle = function( query, context, extra, seed ) {
				context = context || document;
	
				// Only use querySelectorAll on non-XML documents
				// (ID selectors don't work in non-HTML documents)
				if ( !seed && !Sizzle.isXML(context) ) {
					// See if we find a selector to speed up
					var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
	
					if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
						// Speed-up: Sizzle("TAG")
						if ( match[1] ) {
							return makeArray( context.getElementsByTagName( query ), extra );
	
						// Speed-up: Sizzle(".CLASS")
						} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
							return makeArray( context.getElementsByClassName( match[2] ), extra );
						}
					}
	
					if ( context.nodeType === 9 ) {
						// Speed-up: Sizzle("body")
						// The body element only exists once, optimize finding it
						if ( query === "body" && context.body ) {
							return makeArray( [ context.body ], extra );
	
						// Speed-up: Sizzle("#ID")
						} else if ( match && match[3] ) {
							var elem = context.getElementById( match[3] );
	
							// Check parentNode to catch when Blackberry 4.6 returns
							// nodes that are no longer in the document #6963
							if ( elem && elem.parentNode ) {
								// Handle the case where IE and Opera return items
								// by name instead of ID
								if ( elem.id === match[3] ) {
									return makeArray( [ elem ], extra );
								}
	
							} else {
								return makeArray( [], extra );
							}
						}
	
						try {
							return makeArray( context.querySelectorAll(query), extra );
						} catch(qsaError) {}
	
					// qSA works strangely on Element-rooted queries
					// We can work around this by specifying an extra ID on the root
					// and working up from there (Thanks to Andrew Dupont for the technique)
					// IE 8 doesn't work on object elements
					} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
						var oldContext = context,
							old = context.getAttribute( "id" ),
							nid = old || id,
							hasParent = context.parentNode,
							relativeHierarchySelector = /^\s*[+~]/.test( query );
	
						if ( !old ) {
							context.setAttribute( "id", nid );
						} else {
							nid = nid.replace( /'/g, "\\$&" );
						}
						if ( relativeHierarchySelector && hasParent ) {
							context = context.parentNode;
						}
	
						try {
							if ( !relativeHierarchySelector || hasParent ) {
								return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
							}
	
						} catch(pseudoError) {
						} finally {
							if ( !old ) {
								oldContext.removeAttribute( "id" );
							}
						}
					}
				}
	
				return oldSizzle(query, context, extra, seed);
			};
	
			for ( var prop in oldSizzle ) {
				Sizzle[ prop ] = oldSizzle[ prop ];
			}
	
			// release memory in IE
			div = null;
		})();
	}
	
	(function(){
		var html = document.documentElement,
			matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
	
		if ( matches ) {
			// Check to see if it's possible to do matchesSelector
			// on a disconnected node (IE 9 fails this)
			var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
				pseudoWorks = false;
	
			try {
				// This should fail with an exception
				// Gecko does not error, returns false instead
				matches.call( document.documentElement, "[test!='']:sizzle" );
	
			} catch( pseudoError ) {
				pseudoWorks = true;
			}
	
			Sizzle.matchesSelector = function( node, expr ) {
				// Make sure that attribute selectors are quoted
				expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
	
				if ( !Sizzle.isXML( node ) ) {
					try {
						if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
							var ret = matches.call( node, expr );
	
							// IE 9's matchesSelector returns false on disconnected nodes
							if ( ret || !disconnectedMatch ||
									// As well, disconnected nodes are said to be in a document
									// fragment in IE 9, so check for that
									node.document && node.document.nodeType !== 11 ) {
								return ret;
							}
						}
					} catch(e) {}
				}
	
				return Sizzle(expr, null, null, [node]).length > 0;
			};
		}
	})();
	
	(function(){
		var div = document.createElement("div");
	
		div.innerHTML = "<div class='test e'></div><div class='test'></div>";
	
		// Opera can't find a second classname (in 9.6)
		// Also, make sure that getElementsByClassName actually exists
		if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
			return;
		}
	
		// Safari caches class attributes, doesn't catch changes (in 3.2)
		div.lastChild.className = "e";
	
		if ( div.getElementsByClassName("e").length === 1 ) {
			return;
		}
	
		Expr.order.splice(1, 0, "CLASS");
		Expr.find.CLASS = function( match, context, isXML ) {
			if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
				return context.getElementsByClassName(match[1]);
			}
		};
	
		// release memory in IE
		div = null;
	})();
	
	function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
		for ( var i = 0, l = checkSet.length; i < l; i++ ) {
			var elem = checkSet[i];
	
			if ( elem ) {
				var match = false;
	
				elem = elem[dir];
	
				while ( elem ) {
					if ( elem[ expando ] === doneName ) {
						match = checkSet[elem.sizset];
						break;
					}
	
					if ( elem.nodeType === 1 && !isXML ){
						elem[ expando ] = doneName;
						elem.sizset = i;
					}
	
					if ( elem.nodeName.toLowerCase() === cur ) {
						match = elem;
						break;
					}
	
					elem = elem[dir];
				}
	
				checkSet[i] = match;
			}
		}
	}
	
	function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
		for ( var i = 0, l = checkSet.length; i < l; i++ ) {
			var elem = checkSet[i];
	
			if ( elem ) {
				var match = false;
	
				elem = elem[dir];
	
				while ( elem ) {
					if ( elem[ expando ] === doneName ) {
						match = checkSet[elem.sizset];
						break;
					}
	
					if ( elem.nodeType === 1 ) {
						if ( !isXML ) {
							elem[ expando ] = doneName;
							elem.sizset = i;
						}
	
						if ( typeof cur !== "string" ) {
							if ( elem === cur ) {
								match = true;
								break;
							}
	
						} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
							match = elem;
							break;
						}
					}
	
					elem = elem[dir];
				}
	
				checkSet[i] = match;
			}
		}
	}
	
	if ( document.documentElement.contains ) {
		Sizzle.contains = function( a, b ) {
			return a !== b && (a.contains ? a.contains(b) : true);
		};
	
	} else if ( document.documentElement.compareDocumentPosition ) {
		Sizzle.contains = function( a, b ) {
			return !!(a.compareDocumentPosition(b) & 16);
		};
	
	} else {
		Sizzle.contains = function() {
			return false;
		};
	}
	
	Sizzle.isXML = function( elem ) {
		// documentElement is verified for cases where it doesn't yet exist
		// (such as loading iframes in IE - #4833)
		var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
	
		return documentElement ? documentElement.nodeName !== "HTML" : false;
	};
	
	var posProcess = function( selector, context, seed ) {
		var match,
			tmpSet = [],
			later = "",
			root = context.nodeType ? [context] : context;
	
		// Position selectors must be done after the filter
		// And so must :not(positional) so we move all PSEUDOs to the end
		while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
			later += match[0];
			selector = selector.replace( Expr.match.PSEUDO, "" );
		}
	
		selector = Expr.relative[selector] ? selector + "*" : selector;
	
		for ( var i = 0, l = root.length; i < l; i++ ) {
			Sizzle( selector, root[i], tmpSet, seed );
		}
	
		return Sizzle.filter( later, tmpSet );
	};
	
	// EXPOSE
	// Override sizzle attribute retrieval
	Sizzle.attr = jQuery.attr;
	Sizzle.selectors.attrMap = {};
	jQuery.find = Sizzle;
	jQuery.expr = Sizzle.selectors;
	jQuery.expr[":"] = jQuery.expr.filters;
	jQuery.unique = Sizzle.uniqueSort;
	jQuery.text = Sizzle.getText;
	jQuery.isXMLDoc = Sizzle.isXML;
	jQuery.contains = Sizzle.contains;
	
	
	})();
	
	
	var runtil = /Until$/,
		rparentsprev = /^(?:parents|prevUntil|prevAll)/,
		// Note: This RegExp should be improved, or likely pulled from Sizzle
		rmultiselector = /,/,
		isSimple = /^.[^:#\[\.,]*$/,
		slice = Array.prototype.slice,
		POS = jQuery.expr.match.globalPOS,
		// methods guaranteed to produce a unique set when starting from a unique set
		guaranteedUnique = {
			children: true,
			contents: true,
			next: true,
			prev: true
		};
	
	jQuery.fn.extend({
		find: function( selector ) {
			var self = this,
				i, l;
	
			if ( typeof selector !== "string" ) {
				return jQuery( selector ).filter(function() {
					for ( i = 0, l = self.length; i < l; i++ ) {
						if ( jQuery.contains( self[ i ], this ) ) {
							return true;
						}
					}
				});
			}
	
			var ret = this.pushStack( "", "find", selector ),
				length, n, r;
	
			for ( i = 0, l = this.length; i < l; i++ ) {
				length = ret.length;
				jQuery.find( selector, this[i], ret );
	
				if ( i > 0 ) {
					// Make sure that the results are unique
					for ( n = length; n < ret.length; n++ ) {
						for ( r = 0; r < length; r++ ) {
							if ( ret[r] === ret[n] ) {
								ret.splice(n--, 1);
								break;
							}
						}
					}
				}
			}
	
			return ret;
		},
	
		has: function( target ) {
			var targets = jQuery( target );
			return this.filter(function() {
				for ( var i = 0, l = targets.length; i < l; i++ ) {
					if ( jQuery.contains( this, targets[i] ) ) {
						return true;
					}
				}
			});
		},
	
		not: function( selector ) {
			return this.pushStack( winnow(this, selector, false), "not", selector);
		},
	
		filter: function( selector ) {
			return this.pushStack( winnow(this, selector, true), "filter", selector );
		},
	
		is: function( selector ) {
			return !!selector && (
				typeof selector === "string" ?
					// If this is a positional selector, check membership in the returned set
					// so $("p:first").is("p:last") won't return true for a doc with two "p".
					POS.test( selector ) ?
						jQuery( selector, this.context ).index( this[0] ) >= 0 :
						jQuery.filter( selector, this ).length > 0 :
					this.filter( selector ).length > 0 );
		},
	
		closest: function( selectors, context ) {
			var ret = [], i, l, cur = this[0];
	
			// Array (deprecated as of jQuery 1.7)
			if ( jQuery.isArray( selectors ) ) {
				var level = 1;
	
				while ( cur && cur.ownerDocument && cur !== context ) {
					for ( i = 0; i < selectors.length; i++ ) {
	
						if ( jQuery( cur ).is( selectors[ i ] ) ) {
							ret.push({ selector: selectors[ i ], elem: cur, level: level });
						}
					}
	
					cur = cur.parentNode;
					level++;
				}
	
				return ret;
			}
	
			// String
			var pos = POS.test( selectors ) || typeof selectors !== "string" ?
					jQuery( selectors, context || this.context ) :
					0;
	
			for ( i = 0, l = this.length; i < l; i++ ) {
				cur = this[i];
	
				while ( cur ) {
					if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
						ret.push( cur );
						break;
	
					} else {
						cur = cur.parentNode;
						if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
							break;
						}
					}
				}
			}
	
			ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
	
			return this.pushStack( ret, "closest", selectors );
		},
	
		// Determine the position of an element within
		// the matched set of elements
		index: function( elem ) {
	
			// No argument, return index in parent
			if ( !elem ) {
				return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
			}
	
			// index in selector
			if ( typeof elem === "string" ) {
				return jQuery.inArray( this[0], jQuery( elem ) );
			}
	
			// Locate the position of the desired element
			return jQuery.inArray(
				// If it receives a jQuery object, the first element is used
				elem.jquery ? elem[0] : elem, this );
		},
	
		add: function( selector, context ) {
			var set = typeof selector === "string" ?
					jQuery( selector, context ) :
					jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
				all = jQuery.merge( this.get(), set );
	
			return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
				all :
				jQuery.unique( all ) );
		},
	
		andSelf: function() {
			return this.add( this.prevObject );
		}
	});
	
	// A painfully simple check to see if an element is disconnected
	// from a document (should be improved, where feasible).
	function isDisconnected( node ) {
		return !node || !node.parentNode || node.parentNode.nodeType === 11;
	}
	
	jQuery.each({
		parent: function( elem ) {
			var parent = elem.parentNode;
			return parent && parent.nodeType !== 11 ? parent : null;
		},
		parents: function( elem ) {
			return jQuery.dir( elem, "parentNode" );
		},
		parentsUntil: function( elem, i, until ) {
			return jQuery.dir( elem, "parentNode", until );
		},
		next: function( elem ) {
			return jQuery.nth( elem, 2, "nextSibling" );
		},
		prev: function( elem ) {
			return jQuery.nth( elem, 2, "previousSibling" );
		},
		nextAll: function( elem ) {
			return jQuery.dir( elem, "nextSibling" );
		},
		prevAll: function( elem ) {
			return jQuery.dir( elem, "previousSibling" );
		},
		nextUntil: function( elem, i, until ) {
			return jQuery.dir( elem, "nextSibling", until );
		},
		prevUntil: function( elem, i, until ) {
			return jQuery.dir( elem, "previousSibling", until );
		},
		siblings: function( elem ) {
			return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
		},
		children: function( elem ) {
			return jQuery.sibling( elem.firstChild );
		},
		contents: function( elem ) {
			return jQuery.nodeName( elem, "iframe" ) ?
				elem.contentDocument || elem.contentWindow.document :
				jQuery.makeArray( elem.childNodes );
		}
	}, function( name, fn ) {
		jQuery.fn[ name ] = function( until, selector ) {
			var ret = jQuery.map( this, fn, until );
	
			if ( !runtil.test( name ) ) {
				selector = until;
			}
	
			if ( selector && typeof selector === "string" ) {
				ret = jQuery.filter( selector, ret );
			}
	
			ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
	
			if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
				ret = ret.reverse();
			}
	
			return this.pushStack( ret, name, slice.call( arguments ).join(",") );
		};
	});
	
	jQuery.extend({
		filter: function( expr, elems, not ) {
			if ( not ) {
				expr = ":not(" + expr + ")";
			}
	
			return elems.length === 1 ?
				jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
				jQuery.find.matches(expr, elems);
		},
	
		dir: function( elem, dir, until ) {
			var matched = [],
				cur = elem[ dir ];
	
			while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
				if ( cur.nodeType === 1 ) {
					matched.push( cur );
				}
				cur = cur[dir];
			}
			return matched;
		},
	
		nth: function( cur, result, dir, elem ) {
			result = result || 1;
			var num = 0;
	
			for ( ; cur; cur = cur[dir] ) {
				if ( cur.nodeType === 1 && ++num === result ) {
					break;
				}
			}
	
			return cur;
		},
	
		sibling: function( n, elem ) {
			var r = [];
	
			for ( ; n; n = n.nextSibling ) {
				if ( n.nodeType === 1 && n !== elem ) {
					r.push( n );
				}
			}
	
			return r;
		}
	});
	
	// Implement the identical functionality for filter and not
	function winnow( elements, qualifier, keep ) {
	
		// Can't pass null or undefined to indexOf in Firefox 4
		// Set to 0 to skip string check
		qualifier = qualifier || 0;
	
		if ( jQuery.isFunction( qualifier ) ) {
			return jQuery.grep(elements, function( elem, i ) {
				var retVal = !!qualifier.call( elem, i, elem );
				return retVal === keep;
			});
	
		} else if ( qualifier.nodeType ) {
			return jQuery.grep(elements, function( elem, i ) {
				return ( elem === qualifier ) === keep;
			});
	
		} else if ( typeof qualifier === "string" ) {
			var filtered = jQuery.grep(elements, function( elem ) {
				return elem.nodeType === 1;
			});
	
			if ( isSimple.test( qualifier ) ) {
				return jQuery.filter(qualifier, filtered, !keep);
			} else {
				qualifier = jQuery.filter( qualifier, filtered );
			}
		}
	
		return jQuery.grep(elements, function( elem, i ) {
			return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
		});
	}
	
	
	
	
	function createSafeFragment( document ) {
		var list = nodeNames.split( "|" ),
		safeFrag = document.createDocumentFragment();
	
		if ( safeFrag.createElement ) {
			while ( list.length ) {
				safeFrag.createElement(
					list.pop()
				);
			}
		}
		return safeFrag;
	}
	
	var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
			"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
		rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
		rleadingWhitespace = /^\s+/,
		rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
		rtagName = /<([\w:]+)/,
		rtbody = /<tbody/i,
		rhtml = /<|&#?\w+;/,
		rnoInnerhtml = /<(?:script|style)/i,
		rnocache = /<(?:script|object|embed|option|style)/i,
		rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
		// checked="checked" or checked
		rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
		rscriptType = /\/(java|ecma)script/i,
		rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
		wrapMap = {
			option: [ 1, "<select multiple='multiple'>", "</select>" ],
			legend: [ 1, "<fieldset>", "</fieldset>" ],
			thead: [ 1, "<table>", "</table>" ],
			tr: [ 2, "<table><tbody>", "</tbody></table>" ],
			td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
			col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
			area: [ 1, "<map>", "</map>" ],
			_default: [ 0, "", "" ]
		},
		safeFragment = createSafeFragment( document );
	
	wrapMap.optgroup = wrapMap.option;
	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
	wrapMap.th = wrapMap.td;
	
	// IE can't serialize <link> and <script> tags normally
	if ( !jQuery.support.htmlSerialize ) {
		wrapMap._default = [ 1, "div<div>", "</div>" ];
	}
	
	jQuery.fn.extend({
		text: function( value ) {
			return jQuery.access( this, function( value ) {
				return value === undefined ?
					jQuery.text( this ) :
					this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
			}, null, value, arguments.length );
		},
	
		wrapAll: function( html ) {
			if ( jQuery.isFunction( html ) ) {
				return this.each(function(i) {
					jQuery(this).wrapAll( html.call(this, i) );
				});
			}
	
			if ( this[0] ) {
				// The elements to wrap the target around
				var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
	
				if ( this[0].parentNode ) {
					wrap.insertBefore( this[0] );
				}
	
				wrap.map(function() {
					var elem = this;
	
					while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
						elem = elem.firstChild;
					}
	
					return elem;
				}).append( this );
			}
	
			return this;
		},
	
		wrapInner: function( html ) {
			if ( jQuery.isFunction( html ) ) {
				return this.each(function(i) {
					jQuery(this).wrapInner( html.call(this, i) );
				});
			}
	
			return this.each(function() {
				var self = jQuery( this ),
					contents = self.contents();
	
				if ( contents.length ) {
					contents.wrapAll( html );
	
				} else {
					self.append( html );
				}
			});
		},
	
		wrap: function( html ) {
			var isFunction = jQuery.isFunction( html );
	
			return this.each(function(i) {
				jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
			});
		},
	
		unwrap: function() {
			return this.parent().each(function() {
				if ( !jQuery.nodeName( this, "body" ) ) {
					jQuery( this ).replaceWith( this.childNodes );
				}
			}).end();
		},
	
		append: function() {
			return this.domManip(arguments, true, function( elem ) {
				if ( this.nodeType === 1 ) {
					this.appendChild( elem );
				}
			});
		},
	
		prepend: function() {
			return this.domManip(arguments, true, function( elem ) {
				if ( this.nodeType === 1 ) {
					this.insertBefore( elem, this.firstChild );
				}
			});
		},
	
		before: function() {
			if ( this[0] && this[0].parentNode ) {
				return this.domManip(arguments, false, function( elem ) {
					this.parentNode.insertBefore( elem, this );
				});
			} else if ( arguments.length ) {
				var set = jQuery.clean( arguments );
				set.push.apply( set, this.toArray() );
				return this.pushStack( set, "before", arguments );
			}
		},
	
		after: function() {
			if ( this[0] && this[0].parentNode ) {
				return this.domManip(arguments, false, function( elem ) {
					this.parentNode.insertBefore( elem, this.nextSibling );
				});
			} else if ( arguments.length ) {
				var set = this.pushStack( this, "after", arguments );
				set.push.apply( set, jQuery.clean(arguments) );
				return set;
			}
		},
	
		// keepData is for internal use only--do not document
		remove: function( selector, keepData ) {
			for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
				if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
					if ( !keepData && elem.nodeType === 1 ) {
						jQuery.cleanData( elem.getElementsByTagName("*") );
						jQuery.cleanData( [ elem ] );
					}
	
					if ( elem.parentNode ) {
						elem.parentNode.removeChild( elem );
					}
				}
			}
	
			return this;
		},
	
		empty: function() {
			for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
				// Remove element nodes and prevent memory leaks
				if ( elem.nodeType === 1 ) {
					jQuery.cleanData( elem.getElementsByTagName("*") );
				}
	
				// Remove any remaining nodes
				while ( elem.firstChild ) {
					elem.removeChild( elem.firstChild );
				}
			}
	
			return this;
		},
	
		clone: function( dataAndEvents, deepDataAndEvents ) {
			dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
			deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
	
			return this.map( function () {
				return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
			});
		},
	
		html: function( value ) {
			return jQuery.access( this, function( value ) {
				var elem = this[0] || {},
					i = 0,
					l = this.length;
	
				if ( value === undefined ) {
					return elem.nodeType === 1 ?
						elem.innerHTML.replace( rinlinejQuery, "" ) :
						null;
				}
	
	
				if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
					( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
					!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
	
					value = value.replace( rxhtmlTag, "<$1></$2>" );
	
					try {
						for (; i < l; i++ ) {
							// Remove element nodes and prevent memory leaks
							elem = this[i] || {};
							if ( elem.nodeType === 1 ) {
								jQuery.cleanData( elem.getElementsByTagName( "*" ) );
								elem.innerHTML = value;
							}
						}
	
						elem = 0;
	
					// If using innerHTML throws an exception, use the fallback method
					} catch(e) {}
				}
	
				if ( elem ) {
					this.empty().append( value );
				}
			}, null, value, arguments.length );
		},
	
		replaceWith: function( value ) {
			if ( this[0] && this[0].parentNode ) {
				// Make sure that the elements are removed from the DOM before they are inserted
				// this can help fix replacing a parent with child elements
				if ( jQuery.isFunction( value ) ) {
					return this.each(function(i) {
						var self = jQuery(this), old = self.html();
						self.replaceWith( value.call( this, i, old ) );
					});
				}
	
				if ( typeof value !== "string" ) {
					value = jQuery( value ).detach();
				}
	
				return this.each(function() {
					var next = this.nextSibling,
						parent = this.parentNode;
	
					jQuery( this ).remove();
	
					if ( next ) {
						jQuery(next).before( value );
					} else {
						jQuery(parent).append( value );
					}
				});
			} else {
				return this.length ?
					this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
					this;
			}
		},
	
		detach: function( selector ) {
			return this.remove( selector, true );
		},
	
		domManip: function( args, table, callback ) {
			var results, first, fragment, parent,
				value = args[0],
				scripts = [];
	
			// We can't cloneNode fragments that contain checked, in WebKit
			if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
				return this.each(function() {
					jQuery(this).domManip( args, table, callback, true );
				});
			}
	
			if ( jQuery.isFunction(value) ) {
				return this.each(function(i) {
					var self = jQuery(this);
					args[0] = value.call(this, i, table ? self.html() : undefined);
					self.domManip( args, table, callback );
				});
			}
	
			if ( this[0] ) {
				parent = value && value.parentNode;
	
				// If we're in a fragment, just use that instead of building a new one
				if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
					results = { fragment: parent };
	
				} else {
					results = jQuery.buildFragment( args, this, scripts );
				}
	
				fragment = results.fragment;
	
				if ( fragment.childNodes.length === 1 ) {
					first = fragment = fragment.firstChild;
				} else {
					first = fragment.firstChild;
				}
	
				if ( first ) {
					table = table && jQuery.nodeName( first, "tr" );
	
					for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
						callback.call(
							table ?
								root(this[i], first) :
								this[i],
							// Make sure that we do not leak memory by inadvertently discarding
							// the original fragment (which might have attached data) instead of
							// using it; in addition, use the original fragment object for the last
							// item instead of first because it can end up being emptied incorrectly
							// in certain situations (Bug #8070).
							// Fragments from the fragment cache must always be cloned and never used
							// in place.
							results.cacheable || ( l > 1 && i < lastIndex ) ?
								jQuery.clone( fragment, true, true ) :
								fragment
						);
					}
				}
	
				if ( scripts.length ) {
					jQuery.each( scripts, function( i, elem ) {
						if ( elem.src ) {
							jQuery.ajax({
								type: "GET",
								global: false,
								url: elem.src,
								async: false,
								dataType: "script"
							});
						} else {
							jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
						}
	
						if ( elem.parentNode ) {
							elem.parentNode.removeChild( elem );
						}
					});
				}
			}
	
			return this;
		}
	});
	
	function root( elem, cur ) {
		return jQuery.nodeName(elem, "table") ?
			(elem.getElementsByTagName("tbody")[0] ||
			elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
			elem;
	}
	
	function cloneCopyEvent( src, dest ) {
	
		if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
			return;
		}
	
		var type, i, l,
			oldData = jQuery._data( src ),
			curData = jQuery._data( dest, oldData ),
			events = oldData.events;
	
		if ( events ) {
			delete curData.handle;
			curData.events = {};
	
			for ( type in events ) {
				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
					jQuery.event.add( dest, type, events[ type ][ i ] );
				}
			}
		}
	
		// make the cloned public data object a copy from the original
		if ( curData.data ) {
			curData.data = jQuery.extend( {}, curData.data );
		}
	}
	
	function cloneFixAttributes( src, dest ) {
		var nodeName;
	
		// We do not need to do anything for non-Elements
		if ( dest.nodeType !== 1 ) {
			return;
		}
	
		// clearAttributes removes the attributes, which we don't want,
		// but also removes the attachEvent events, which we *do* want
		if ( dest.clearAttributes ) {
			dest.clearAttributes();
		}
	
		// mergeAttributes, in contrast, only merges back on the
		// original attributes, not the events
		if ( dest.mergeAttributes ) {
			dest.mergeAttributes( src );
		}
	
		nodeName = dest.nodeName.toLowerCase();
	
		// IE6-8 fail to clone children inside object elements that use
		// the proprietary classid attribute value (rather than the type
		// attribute) to identify the type of content to display
		if ( nodeName === "object" ) {
			dest.outerHTML = src.outerHTML;
	
		} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
			// IE6-8 fails to persist the checked state of a cloned checkbox
			// or radio button. Worse, IE6-7 fail to give the cloned element
			// a checked appearance if the defaultChecked value isn't also set
			if ( src.checked ) {
				dest.defaultChecked = dest.checked = src.checked;
			}
	
			// IE6-7 get confused and end up setting the value of a cloned
			// checkbox/radio button to an empty string instead of "on"
			if ( dest.value !== src.value ) {
				dest.value = src.value;
			}
	
		// IE6-8 fails to return the selected option to the default selected
		// state when cloning options
		} else if ( nodeName === "option" ) {
			dest.selected = src.defaultSelected;
	
		// IE6-8 fails to set the defaultValue to the correct value when
		// cloning other types of input fields
		} else if ( nodeName === "input" || nodeName === "textarea" ) {
			dest.defaultValue = src.defaultValue;
	
		// IE blanks contents when cloning scripts
		} else if ( nodeName === "script" && dest.text !== src.text ) {
			dest.text = src.text;
		}
	
		// Event data gets referenced instead of copied if the expando
		// gets copied too
		dest.removeAttribute( jQuery.expando );
	
		// Clear flags for bubbling special change/submit events, they must
		// be reattached when the newly cloned events are first activated
		dest.removeAttribute( "_submit_attached" );
		dest.removeAttribute( "_change_attached" );
	}
	
	jQuery.buildFragment = function( args, nodes, scripts ) {
		var fragment, cacheable, cacheresults, doc,
		first = args[ 0 ];
	
		// nodes may contain either an explicit document object,
		// a jQuery collection or context object.
		// If nodes[0] contains a valid object to assign to doc
		if ( nodes && nodes[0] ) {
			doc = nodes[0].ownerDocument || nodes[0];
		}
	
		// Ensure that an attr object doesn't incorrectly stand in as a document object
		// Chrome and Firefox seem to allow this to occur and will throw exception
		// Fixes #8950
		if ( !doc.createDocumentFragment ) {
			doc = document;
		}
	
		// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
		// Cloning options loses the selected state, so don't cache them
		// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
		// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
		// Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
		if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
			first.charAt(0) === "<" && !rnocache.test( first ) &&
			(jQuery.support.checkClone || !rchecked.test( first )) &&
			(jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
	
			cacheable = true;
	
			cacheresults = jQuery.fragments[ first ];
			if ( cacheresults && cacheresults !== 1 ) {
				fragment = cacheresults;
			}
		}
	
		if ( !fragment ) {
			fragment = doc.createDocumentFragment();
			jQuery.clean( args, doc, fragment, scripts );
		}
	
		if ( cacheable ) {
			jQuery.fragments[ first ] = cacheresults ? fragment : 1;
		}
	
		return { fragment: fragment, cacheable: cacheable };
	};
	
	jQuery.fragments = {};
	
	jQuery.each({
		appendTo: "append",
		prependTo: "prepend",
		insertBefore: "before",
		insertAfter: "after",
		replaceAll: "replaceWith"
	}, function( name, original ) {
		jQuery.fn[ name ] = function( selector ) {
			var ret = [],
				insert = jQuery( selector ),
				parent = this.length === 1 && this[0].parentNode;
	
			if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
				insert[ original ]( this[0] );
				return this;
	
			} else {
				for ( var i = 0, l = insert.length; i < l; i++ ) {
					var elems = ( i > 0 ? this.clone(true) : this ).get();
					jQuery( insert[i] )[ original ]( elems );
					ret = ret.concat( elems );
				}
	
				return this.pushStack( ret, name, insert.selector );
			}
		};
	});
	
	function getAll( elem ) {
		if ( typeof elem.getElementsByTagName !== "undefined" ) {
			return elem.getElementsByTagName( "*" );
	
		} else if ( typeof elem.querySelectorAll !== "undefined" ) {
			return elem.querySelectorAll( "*" );
	
		} else {
			return [];
		}
	}
	
	// Used in clean, fixes the defaultChecked property
	function fixDefaultChecked( elem ) {
		if ( elem.type === "checkbox" || elem.type === "radio" ) {
			elem.defaultChecked = elem.checked;
		}
	}
	// Finds all inputs and passes them to fixDefaultChecked
	function findInputs( elem ) {
		var nodeName = ( elem.nodeName || "" ).toLowerCase();
		if ( nodeName === "input" ) {
			fixDefaultChecked( elem );
		// Skip scripts, get other children
		} else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
			jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
		}
	}
	
	// Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
	function shimCloneNode( elem ) {
		var div = document.createElement( "div" );
		safeFragment.appendChild( div );
	
		div.innerHTML = elem.outerHTML;
		return div.firstChild;
	}
	
	jQuery.extend({
		clone: function( elem, dataAndEvents, deepDataAndEvents ) {
			var srcElements,
				destElements,
				i,
				// IE<=8 does not properly clone detached, unknown element nodes
				clone = jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ?
					elem.cloneNode( true ) :
					shimCloneNode( elem );
	
			if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
					(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
				// IE copies events bound via attachEvent when using cloneNode.
				// Calling detachEvent on the clone will also remove the events
				// from the original. In order to get around this, we use some
				// proprietary methods to clear the events. Thanks to MooTools
				// guys for this hotness.
	
				cloneFixAttributes( elem, clone );
	
				// Using Sizzle here is crazy slow, so we use getElementsByTagName instead
				srcElements = getAll( elem );
				destElements = getAll( clone );
	
				// Weird iteration because IE will replace the length property
				// with an element if you are cloning the body and one of the
				// elements on the page has a name or id of "length"
				for ( i = 0; srcElements[i]; ++i ) {
					// Ensure that the destination node is not null; Fixes #9587
					if ( destElements[i] ) {
						cloneFixAttributes( srcElements[i], destElements[i] );
					}
				}
			}
	
			// Copy the events from the original to the clone
			if ( dataAndEvents ) {
				cloneCopyEvent( elem, clone );
	
				if ( deepDataAndEvents ) {
					srcElements = getAll( elem );
					destElements = getAll( clone );
	
					for ( i = 0; srcElements[i]; ++i ) {
						cloneCopyEvent( srcElements[i], destElements[i] );
					}
				}
			}
	
			srcElements = destElements = null;
	
			// Return the cloned set
			return clone;
		},
	
		clean: function( elems, context, fragment, scripts ) {
			var checkScriptType, script, j,
					ret = [];
	
			context = context || document;
	
			// !context.createElement fails in IE with an error but returns typeof 'object'
			if ( typeof context.createElement === "undefined" ) {
				context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
			}
	
			for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
				if ( typeof elem === "number" ) {
					elem += "";
				}
	
				if ( !elem ) {
					continue;
				}
	
				// Convert html string into DOM nodes
				if ( typeof elem === "string" ) {
					if ( !rhtml.test( elem ) ) {
						elem = context.createTextNode( elem );
					} else {
						// Fix "XHTML"-style tags in all browsers
						elem = elem.replace(rxhtmlTag, "<$1></$2>");
	
						// Trim whitespace, otherwise indexOf won't work as expected
						var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
							wrap = wrapMap[ tag ] || wrapMap._default,
							depth = wrap[0],
							div = context.createElement("div"),
							safeChildNodes = safeFragment.childNodes,
							remove;
	
						// Append wrapper element to unknown element safe doc fragment
						if ( context === document ) {
							// Use the fragment we've already created for this document
							safeFragment.appendChild( div );
						} else {
							// Use a fragment created with the owner document
							createSafeFragment( context ).appendChild( div );
						}
	
						// Go to html and back, then peel off extra wrappers
						div.innerHTML = wrap[1] + elem + wrap[2];
	
						// Move to the right depth
						while ( depth-- ) {
							div = div.lastChild;
						}
	
						// Remove IE's autoinserted <tbody> from table fragments
						if ( !jQuery.support.tbody ) {
	
							// String was a <table>, *may* have spurious <tbody>
							var hasBody = rtbody.test(elem),
								tbody = tag === "table" && !hasBody ?
									div.firstChild && div.firstChild.childNodes :
	
									// String was a bare <thead> or <tfoot>
									wrap[1] === "<table>" && !hasBody ?
										div.childNodes :
										[];
	
							for ( j = tbody.length - 1; j >= 0 ; --j ) {
								if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
									tbody[ j ].parentNode.removeChild( tbody[ j ] );
								}
							}
						}
	
						// IE completely kills leading whitespace when innerHTML is used
						if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
							div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
						}
	
						elem = div.childNodes;
	
						// Clear elements from DocumentFragment (safeFragment or otherwise)
						// to avoid hoarding elements. Fixes #11356
						if ( div ) {
							div.parentNode.removeChild( div );
	
							// Guard against -1 index exceptions in FF3.6
							if ( safeChildNodes.length > 0 ) {
								remove = safeChildNodes[ safeChildNodes.length - 1 ];
	
								if ( remove && remove.parentNode ) {
									remove.parentNode.removeChild( remove );
								}
							}
						}
					}
				}
	
				// Resets defaultChecked for any radios and checkboxes
				// about to be appended to the DOM in IE 6/7 (#8060)
				var len;
				if ( !jQuery.support.appendChecked ) {
					if ( elem[0] && typeof (len = elem.length) === "number" ) {
						for ( j = 0; j < len; j++ ) {
							findInputs( elem[j] );
						}
					} else {
						findInputs( elem );
					}
				}
	
				if ( elem.nodeType ) {
					ret.push( elem );
				} else {
					ret = jQuery.merge( ret, elem );
				}
			}
	
			if ( fragment ) {
				checkScriptType = function( elem ) {
					return !elem.type || rscriptType.test( elem.type );
				};
				for ( i = 0; ret[i]; i++ ) {
					script = ret[i];
					if ( scripts && jQuery.nodeName( script, "script" ) && (!script.type || rscriptType.test( script.type )) ) {
						scripts.push( script.parentNode ? script.parentNode.removeChild( script ) : script );
	
					} else {
						if ( script.nodeType === 1 ) {
							var jsTags = jQuery.grep( script.getElementsByTagName( "script" ), checkScriptType );
	
							ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
						}
						fragment.appendChild( script );
					}
				}
			}
	
			return ret;
		},
	
		cleanData: function( elems ) {
			var data, id,
				cache = jQuery.cache,
				special = jQuery.event.special,
				deleteExpando = jQuery.support.deleteExpando;
	
			for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
				if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
					continue;
				}
	
				id = elem[ jQuery.expando ];
	
				if ( id ) {
					data = cache[ id ];
	
					if ( data && data.events ) {
						for ( var type in data.events ) {
							if ( special[ type ] ) {
								jQuery.event.remove( elem, type );
	
							// This is a shortcut to avoid jQuery.event.remove's overhead
							} else {
								jQuery.removeEvent( elem, type, data.handle );
							}
						}
	
						// Null the DOM reference to avoid IE6/7/8 leak (#7054)
						if ( data.handle ) {
							data.handle.elem = null;
						}
					}
	
					if ( deleteExpando ) {
						delete elem[ jQuery.expando ];
	
					} else if ( elem.removeAttribute ) {
						elem.removeAttribute( jQuery.expando );
					}
	
					delete cache[ id ];
				}
			}
		}
	});
	
	
	
	
	var ralpha = /alpha\([^)]*\)/i,
		ropacity = /opacity=([^)]*)/,
		// fixed for IE9, see #8346
		rupper = /([A-Z]|^ms)/g,
		rnum = /^[\-+]?(?:\d*\.)?\d+$/i,
		rnumnonpx = /^-?(?:\d*\.)?\d+(?!px)[^\d\s]+$/i,
		rrelNum = /^([\-+])=([\-+.\de]+)/,
		rmargin = /^margin/,
	
		cssShow = { position: "absolute", visibility: "hidden", display: "block" },
	
		// order is important!
		cssExpand = [ "Top", "Right", "Bottom", "Left" ],
	
		curCSS,
	
		getComputedStyle,
		currentStyle;
	
	jQuery.fn.css = function( name, value ) {
		return jQuery.access( this, function( elem, name, value ) {
			return value !== undefined ?
				jQuery.style( elem, name, value ) :
				jQuery.css( elem, name );
		}, name, value, arguments.length > 1 );
	};
	
	jQuery.extend({
		// Add in style property hooks for overriding the default
		// behavior of getting and setting a style property
		cssHooks: {
			opacity: {
				get: function( elem, computed ) {
					if ( computed ) {
						// We should always get a number back from opacity
						var ret = curCSS( elem, "opacity" );
						return ret === "" ? "1" : ret;
	
					} else {
						return elem.style.opacity;
					}
				}
			}
		},
	
		// Exclude the following css properties to add px
		cssNumber: {
			"fillOpacity": true,
			"fontWeight": true,
			"lineHeight": true,
			"opacity": true,
			"orphans": true,
			"widows": true,
			"zIndex": true,
			"zoom": true
		},
	
		// Add in properties whose names you wish to fix before
		// setting or getting the value
		cssProps: {
			// normalize float css property
			"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
		},
	
		// Get and set the style property on a DOM Node
		style: function( elem, name, value, extra ) {
			// Don't set styles on text and comment nodes
			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
				return;
			}
	
			// Make sure that we're working with the right name
			var ret, type, origName = jQuery.camelCase( name ),
				style = elem.style, hooks = jQuery.cssHooks[ origName ];
	
			name = jQuery.cssProps[ origName ] || origName;
	
			// Check if we're setting a value
			if ( value !== undefined ) {
				type = typeof value;
	
				// convert relative number strings (+= or -=) to relative numbers. #7345
				if ( type === "string" && (ret = rrelNum.exec( value )) ) {
					value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
					// Fixes bug #9237
					type = "number";
				}
	
				// Make sure that NaN and null values aren't set. See: #7116
				if ( value == null || type === "number" && isNaN( value ) ) {
					return;
				}
	
				// If a number was passed in, add 'px' to the (except for certain CSS properties)
				if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
					value += "px";
				}
	
				// If a hook was provided, use that value, otherwise just set the specified value
				if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
					// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
					// Fixes bug #5509
					try {
						style[ name ] = value;
					} catch(e) {}
				}
	
			} else {
				// If a hook was provided get the non-computed value from there
				if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
					return ret;
				}
	
				// Otherwise just get the value from the style object
				return style[ name ];
			}
		},
	
		css: function( elem, name, extra ) {
			var ret, hooks;
	
			// Make sure that we're working with the right name
			name = jQuery.camelCase( name );
			hooks = jQuery.cssHooks[ name ];
			name = jQuery.cssProps[ name ] || name;
	
			// cssFloat needs a special treatment
			if ( name === "cssFloat" ) {
				name = "float";
			}
	
			// If a hook was provided get the computed value from there
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
				return ret;
	
			// Otherwise, if a way to get the computed value exists, use that
			} else if ( curCSS ) {
				return curCSS( elem, name );
			}
		},
	
		// A method for quickly swapping in/out CSS properties to get correct calculations
		swap: function( elem, options, callback ) {
			var old = {},
				ret, name;
	
			// Remember the old values, and insert the new ones
			for ( name in options ) {
				old[ name ] = elem.style[ name ];
				elem.style[ name ] = options[ name ];
			}
	
			ret = callback.call( elem );
	
			// Revert the old values
			for ( name in options ) {
				elem.style[ name ] = old[ name ];
			}
	
			return ret;
		}
	});
	
	// DEPRECATED in 1.3, Use jQuery.css() instead
	jQuery.curCSS = jQuery.css;
	
	if ( document.defaultView && document.defaultView.getComputedStyle ) {
		getComputedStyle = function( elem, name ) {
			var ret, defaultView, computedStyle, width,
				style = elem.style;
	
			name = name.replace( rupper, "-$1" ).toLowerCase();
	
			if ( (defaultView = elem.ownerDocument.defaultView) &&
					(computedStyle = defaultView.getComputedStyle( elem, null )) ) {
	
				ret = computedStyle.getPropertyValue( name );
				if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
					ret = jQuery.style( elem, name );
				}
			}
	
			// A tribute to the "awesome hack by Dean Edwards"
			// WebKit uses "computed value (percentage if specified)" instead of "used value" for margins
			// which is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
			if ( !jQuery.support.pixelMargin && computedStyle && rmargin.test( name ) && rnumnonpx.test( ret ) ) {
				width = style.width;
				style.width = ret;
				ret = computedStyle.width;
				style.width = width;
			}
	
			return ret;
		};
	}
	
	if ( document.documentElement.currentStyle ) {
		currentStyle = function( elem, name ) {
			var left, rsLeft, uncomputed,
				ret = elem.currentStyle && elem.currentStyle[ name ],
				style = elem.style;
	
			// Avoid setting ret to empty string here
			// so we don't default to auto
			if ( ret == null && style && (uncomputed = style[ name ]) ) {
				ret = uncomputed;
			}
	
			// From the awesome hack by Dean Edwards
			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
	
			// If we're not dealing with a regular pixel number
			// but a number that has a weird ending, we need to convert it to pixels
			if ( rnumnonpx.test( ret ) ) {
	
				// Remember the original values
				left = style.left;
				rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
	
				// Put in the new values to get a computed value out
				if ( rsLeft ) {
					elem.runtimeStyle.left = elem.currentStyle.left;
				}
				style.left = name === "fontSize" ? "1em" : ret;
				ret = style.pixelLeft + "px";
	
				// Revert the changed values
				style.left = left;
				if ( rsLeft ) {
					elem.runtimeStyle.left = rsLeft;
				}
			}
	
			return ret === "" ? "auto" : ret;
		};
	}
	
	curCSS = getComputedStyle || currentStyle;
	
	function getWidthOrHeight( elem, name, extra ) {
	
		// Start with offset property
		var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
			i = name === "width" ? 1 : 0,
			len = 4;
	
		if ( val > 0 ) {
			if ( extra !== "border" ) {
				for ( ; i < len; i += 2 ) {
					if ( !extra ) {
						val -= parseFloat( jQuery.css( elem, "padding" + cssExpand[ i ] ) ) || 0;
					}
					if ( extra === "margin" ) {
						val += parseFloat( jQuery.css( elem, extra + cssExpand[ i ] ) ) || 0;
					} else {
						val -= parseFloat( jQuery.css( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
					}
				}
			}
	
			return val + "px";
		}
	
		// Fall back to computed then uncomputed css if necessary
		val = curCSS( elem, name );
		if ( val < 0 || val == null ) {
			val = elem.style[ name ];
		}
	
		// Computed unit is not pixels. Stop here and return.
		if ( rnumnonpx.test(val) ) {
			return val;
		}
	
		// Normalize "", auto, and prepare for extra
		val = parseFloat( val ) || 0;
	
		// Add padding, border, margin
		if ( extra ) {
			for ( ; i < len; i += 2 ) {
				val += parseFloat( jQuery.css( elem, "padding" + cssExpand[ i ] ) ) || 0;
				if ( extra !== "padding" ) {
					val += parseFloat( jQuery.css( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
				}
				if ( extra === "margin" ) {
					val += parseFloat( jQuery.css( elem, extra + cssExpand[ i ]) ) || 0;
				}
			}
		}
	
		return val + "px";
	}
	
	jQuery.each([ "height", "width" ], function( i, name ) {
		jQuery.cssHooks[ name ] = {
			get: function( elem, computed, extra ) {
				if ( computed ) {
					if ( elem.offsetWidth !== 0 ) {
						return getWidthOrHeight( elem, name, extra );
					} else {
						return jQuery.swap( elem, cssShow, function() {
							return getWidthOrHeight( elem, name, extra );
						});
					}
				}
			},
	
			set: function( elem, value ) {
				return rnum.test( value ) ?
					value + "px" :
					value;
			}
		};
	});
	
	if ( !jQuery.support.opacity ) {
		jQuery.cssHooks.opacity = {
			get: function( elem, computed ) {
				// IE uses filters for opacity
				return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
					( parseFloat( RegExp.$1 ) / 100 ) + "" :
					computed ? "1" : "";
			},
	
			set: function( elem, value ) {
				var style = elem.style,
					currentStyle = elem.currentStyle,
					opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
					filter = currentStyle && currentStyle.filter || style.filter || "";
	
				// IE has trouble with opacity if it does not have layout
				// Force it by setting the zoom level
				style.zoom = 1;
	
				// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
				if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
	
					// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
					// if "filter:" is present at all, clearType is disabled, we want to avoid this
					// style.removeAttribute is IE Only, but so apparently is this code path...
					style.removeAttribute( "filter" );
	
					// if there there is no filter style applied in a css rule, we are done
					if ( currentStyle && !currentStyle.filter ) {
						return;
					}
				}
	
				// otherwise, set new filter values
				style.filter = ralpha.test( filter ) ?
					filter.replace( ralpha, opacity ) :
					filter + " " + opacity;
			}
		};
	}
	
	jQuery(function() {
		// This hook cannot be added until DOM ready because the support test
		// for it is not run until after DOM ready
		if ( !jQuery.support.reliableMarginRight ) {
			jQuery.cssHooks.marginRight = {
				get: function( elem, computed ) {
					// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
					// Work around by temporarily setting element display to inline-block
					return jQuery.swap( elem, { "display": "inline-block" }, function() {
						if ( computed ) {
							return curCSS( elem, "margin-right" );
						} else {
							return elem.style.marginRight;
						}
					});
				}
			};
		}
	});
	
	if ( jQuery.expr && jQuery.expr.filters ) {
		jQuery.expr.filters.hidden = function( elem ) {
			var width = elem.offsetWidth,
				height = elem.offsetHeight;
	
			return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
		};
	
		jQuery.expr.filters.visible = function( elem ) {
			return !jQuery.expr.filters.hidden( elem );
		};
	}
	
	// These hooks are used by animate to expand properties
	jQuery.each({
		margin: "",
		padding: "",
		border: "Width"
	}, function( prefix, suffix ) {
	
		jQuery.cssHooks[ prefix + suffix ] = {
			expand: function( value ) {
				var i,
	
					// assumes a single number if not a string
					parts = typeof value === "string" ? value.split(" ") : [ value ],
					expanded = {};
	
				for ( i = 0; i < 4; i++ ) {
					expanded[ prefix + cssExpand[ i ] + suffix ] =
						parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
				}
	
				return expanded;
			}
		};
	});
	
	
	
	
	var r20 = /%20/g,
		rbracket = /\[\]$/,
		rCRLF = /\r?\n/g,
		rhash = /#.*$/,
		rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
		rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
		// #7653, #8125, #8152: local protocol detection
		rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
		rnoContent = /^(?:GET|HEAD)$/,
		rprotocol = /^\/\//,
		rquery = /\?/,
		rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
		rselectTextarea = /^(?:select|textarea)/i,
		rspacesAjax = /\s+/,
		rts = /([?&])_=[^&]*/,
		rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
	
		// Keep a copy of the old load method
		_load = jQuery.fn.load,
	
		/* Prefilters
		 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
		 * 2) These are called:
		 *    - BEFORE asking for a transport
		 *    - AFTER param serialization (s.data is a string if s.processData is true)
		 * 3) key is the dataType
		 * 4) the catchall symbol "*" can be used
		 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
		 */
		prefilters = {},
	
		/* Transports bindings
		 * 1) key is the dataType
		 * 2) the catchall symbol "*" can be used
		 * 3) selection will start with transport dataType and THEN go to "*" if needed
		 */
		transports = {},
	
		// Document location
		ajaxLocation,
	
		// Document location segments
		ajaxLocParts,
	
		// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
		allTypes = ["*/"] + ["*"];
	
	// #8138, IE may throw an exception when accessing
	// a field from window.location if document.domain has been set
	try {
		ajaxLocation = location.href;
	} catch( e ) {
		// Use the href attribute of an A element
		// since IE will modify it given document.location
		ajaxLocation = document.createElement( "a" );
		ajaxLocation.href = "";
		ajaxLocation = ajaxLocation.href;
	}
	
	// Segment location into parts
	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
	
	// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
	function addToPrefiltersOrTransports( structure ) {
	
		// dataTypeExpression is optional and defaults to "*"
		return function( dataTypeExpression, func ) {
	
			if ( typeof dataTypeExpression !== "string" ) {
				func = dataTypeExpression;
				dataTypeExpression = "*";
			}
	
			if ( jQuery.isFunction( func ) ) {
				var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
					i = 0,
					length = dataTypes.length,
					dataType,
					list,
					placeBefore;
	
				// For each dataType in the dataTypeExpression
				for ( ; i < length; i++ ) {
					dataType = dataTypes[ i ];
					// We control if we're asked to add before
					// any existing element
					placeBefore = /^\+/.test( dataType );
					if ( placeBefore ) {
						dataType = dataType.substr( 1 ) || "*";
					}
					list = structure[ dataType ] = structure[ dataType ] || [];
					// then we add to the structure accordingly
					list[ placeBefore ? "unshift" : "push" ]( func );
				}
			}
		};
	}
	
	// Base inspection function for prefilters and transports
	function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
			dataType /* internal */, inspected /* internal */ ) {
	
		dataType = dataType || options.dataTypes[ 0 ];
		inspected = inspected || {};
	
		inspected[ dataType ] = true;
	
		var list = structure[ dataType ],
			i = 0,
			length = list ? list.length : 0,
			executeOnly = ( structure === prefilters ),
			selection;
	
		for ( ; i < length && ( executeOnly || !selection ); i++ ) {
			selection = list[ i ]( options, originalOptions, jqXHR );
			// If we got redirected to another dataType
			// we try there if executing only and not done already
			if ( typeof selection === "string" ) {
				if ( !executeOnly || inspected[ selection ] ) {
					selection = undefined;
				} else {
					options.dataTypes.unshift( selection );
					selection = inspectPrefiltersOrTransports(
							structure, options, originalOptions, jqXHR, selection, inspected );
				}
			}
		}
		// If we're only executing or nothing was selected
		// we try the catchall dataType if not done already
		if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
			selection = inspectPrefiltersOrTransports(
					structure, options, originalOptions, jqXHR, "*", inspected );
		}
		// unnecessary when only executing (prefilters)
		// but it'll be ignored by the caller in that case
		return selection;
	}
	
	// A special extend for ajax options
	// that takes "flat" options (not to be deep extended)
	// Fixes #9887
	function ajaxExtend( target, src ) {
		var key, deep,
			flatOptions = jQuery.ajaxSettings.flatOptions || {};
		for ( key in src ) {
			if ( src[ key ] !== undefined ) {
				( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
			}
		}
		if ( deep ) {
			jQuery.extend( true, target, deep );
		}
	}
	
	jQuery.fn.extend({
		load: function( url, params, callback ) {
			if ( typeof url !== "string" && _load ) {
				return _load.apply( this, arguments );
	
			// Don't do a request if no elements are being requested
			} else if ( !this.length ) {
				return this;
			}
	
			var off = url.indexOf( " " );
			if ( off >= 0 ) {
				var selector = url.slice( off, url.length );
				url = url.slice( 0, off );
			}
	
			// Default to a GET request
			var type = "GET";
	
			// If the second parameter was provided
			if ( params ) {
				// If it's a function
				if ( jQuery.isFunction( params ) ) {
					// We assume that it's the callback
					callback = params;
					params = undefined;
	
				// Otherwise, build a param string
				} else if ( typeof params === "object" ) {
					params = jQuery.param( params, jQuery.ajaxSettings.traditional );
					type = "POST";
				}
			}
	
			var self = this;
	
			// Request the remote document
			jQuery.ajax({
				url: url,
				type: type,
				dataType: "html",
				data: params,
				// Complete callback (responseText is used internally)
				complete: function( jqXHR, status, responseText ) {
					// Store the response as specified by the jqXHR object
					responseText = jqXHR.responseText;
					// If successful, inject the HTML into all the matched elements
					if ( jqXHR.isResolved() ) {
						// #4825: Get the actual response in case
						// a dataFilter is present in ajaxSettings
						jqXHR.done(function( r ) {
							responseText = r;
						});
						// See if a selector was specified
						self.html( selector ?
							// Create a dummy div to hold the results
							jQuery("<div>")
								// inject the contents of the document in, removing the scripts
								// to avoid any 'Permission Denied' errors in IE
								.append(responseText.replace(rscript, ""))
	
								// Locate the specified elements
								.find(selector) :
	
							// If not, just inject the full result
							responseText );
					}
	
					if ( callback ) {
						self.each( callback, [ responseText, status, jqXHR ] );
					}
				}
			});
	
			return this;
		},
	
		serialize: function() {
			return jQuery.param( this.serializeArray() );
		},
	
		serializeArray: function() {
			return this.map(function(){
				return this.elements ? jQuery.makeArray( this.elements ) : this;
			})
			.filter(function(){
				return this.name && !this.disabled &&
					( this.checked || rselectTextarea.test( this.nodeName ) ||
						rinput.test( this.type ) );
			})
			.map(function( i, elem ){
				var val = jQuery( this ).val();
	
				return val == null ?
					null :
					jQuery.isArray( val ) ?
						jQuery.map( val, function( val, i ){
							return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
						}) :
						{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
			}).get();
		}
	});
	
	// Attach a bunch of functions for handling common AJAX events
	jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
		jQuery.fn[ o ] = function( f ){
			return this.on( o, f );
		};
	});
	
	jQuery.each( [ "get", "post" ], function( i, method ) {
		jQuery[ method ] = function( url, data, callback, type ) {
			// shift arguments if data argument was omitted
			if ( jQuery.isFunction( data ) ) {
				type = type || callback;
				callback = data;
				data = undefined;
			}
	
			return jQuery.ajax({
				type: method,
				url: url,
				data: data,
				success: callback,
				dataType: type
			});
		};
	});
	
	jQuery.extend({
	
		getScript: function( url, callback ) {
			return jQuery.get( url, undefined, callback, "script" );
		},
	
		getJSON: function( url, data, callback ) {
			return jQuery.get( url, data, callback, "json" );
		},
	
		// Creates a full fledged settings object into target
		// with both ajaxSettings and settings fields.
		// If target is omitted, writes into ajaxSettings.
		ajaxSetup: function( target, settings ) {
			if ( settings ) {
				// Building a settings object
				ajaxExtend( target, jQuery.ajaxSettings );
			} else {
				// Extending ajaxSettings
				settings = target;
				target = jQuery.ajaxSettings;
			}
			ajaxExtend( target, settings );
			return target;
		},
	
		ajaxSettings: {
			url: ajaxLocation,
			isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
			global: true,
			type: "GET",
			contentType: "application/x-www-form-urlencoded; charset=UTF-8",
			processData: true,
			async: true,
			/*
			timeout: 0,
			data: null,
			dataType: null,
			username: null,
			password: null,
			cache: null,
			traditional: false,
			headers: {},
			*/
	
			accepts: {
				xml: "application/xml, text/xml",
				html: "text/html",
				text: "text/plain",
				json: "application/json, text/javascript",
				"*": allTypes
			},
	
			contents: {
				xml: /xml/,
				html: /html/,
				json: /json/
			},
	
			responseFields: {
				xml: "responseXML",
				text: "responseText"
			},
	
			// List of data converters
			// 1) key format is "source_type destination_type" (a single space in-between)
			// 2) the catchall symbol "*" can be used for source_type
			converters: {
	
				// Convert anything to text
				"* text": window.String,
	
				// Text to html (true = no transformation)
				"text html": true,
	
				// Evaluate text as a json expression
				"text json": jQuery.parseJSON,
	
				// Parse text as xml
				"text xml": jQuery.parseXML
			},
	
			// For options that shouldn't be deep extended:
			// you can add your own custom options here if
			// and when you create one that shouldn't be
			// deep extended (see ajaxExtend)
			flatOptions: {
				context: true,
				url: true
			}
		},
	
		ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
		ajaxTransport: addToPrefiltersOrTransports( transports ),
	
		// Main method
		ajax: function( url, options ) {
	
			// If url is an object, simulate pre-1.5 signature
			if ( typeof url === "object" ) {
				options = url;
				url = undefined;
			}
	
			// Force options to be an object
			options = options || {};
	
			var // Create the final options object
				s = jQuery.ajaxSetup( {}, options ),
				// Callbacks context
				callbackContext = s.context || s,
				// Context for global events
				// It's the callbackContext if one was provided in the options
				// and if it's a DOM node or a jQuery collection
				globalEventContext = callbackContext !== s &&
					( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
							jQuery( callbackContext ) : jQuery.event,
				// Deferreds
				deferred = jQuery.Deferred(),
				completeDeferred = jQuery.Callbacks( "once memory" ),
				// Status-dependent callbacks
				statusCode = s.statusCode || {},
				// ifModified key
				ifModifiedKey,
				// Headers (they are sent all at once)
				requestHeaders = {},
				requestHeadersNames = {},
				// Response headers
				responseHeadersString,
				responseHeaders,
				// transport
				transport,
				// timeout handle
				timeoutTimer,
				// Cross-domain detection vars
				parts,
				// The jqXHR state
				state = 0,
				// To know if global events are to be dispatched
				fireGlobals,
				// Loop variable
				i,
				// Fake xhr
				jqXHR = {
	
					readyState: 0,
	
					// Caches the header
					setRequestHeader: function( name, value ) {
						if ( !state ) {
							var lname = name.toLowerCase();
							name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
							requestHeaders[ name ] = value;
						}
						return this;
					},
	
					// Raw string
					getAllResponseHeaders: function() {
						return state === 2 ? responseHeadersString : null;
					},
	
					// Builds headers hashtable if needed
					getResponseHeader: function( key ) {
						var match;
						if ( state === 2 ) {
							if ( !responseHeaders ) {
								responseHeaders = {};
								while( ( match = rheaders.exec( responseHeadersString ) ) ) {
									responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
								}
							}
							match = responseHeaders[ key.toLowerCase() ];
						}
						return match === undefined ? null : match;
					},
	
					// Overrides response content-type header
					overrideMimeType: function( type ) {
						if ( !state ) {
							s.mimeType = type;
						}
						return this;
					},
	
					// Cancel the request
					abort: function( statusText ) {
						statusText = statusText || "abort";
						if ( transport ) {
							transport.abort( statusText );
						}
						done( 0, statusText );
						return this;
					}
				};
	
			// Callback for when everything is done
			// It is defined here because jslint complains if it is declared
			// at the end of the function (which would be more logical and readable)
			function done( status, nativeStatusText, responses, headers ) {
	
				// Called once
				if ( state === 2 ) {
					return;
				}
	
				// State is "done" now
				state = 2;
	
				// Clear timeout if it exists
				if ( timeoutTimer ) {
					clearTimeout( timeoutTimer );
				}
	
				// Dereference transport for early garbage collection
				// (no matter how long the jqXHR object will be used)
				transport = undefined;
	
				// Cache response headers
				responseHeadersString = headers || "";
	
				// Set readyState
				jqXHR.readyState = status > 0 ? 4 : 0;
	
				var isSuccess,
					success,
					error,
					statusText = nativeStatusText,
					response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
					lastModified,
					etag;
	
				// If successful, handle type chaining
				if ( status >= 200 && status < 300 || status === 304 ) {
	
					// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
					if ( s.ifModified ) {
	
						if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
							jQuery.lastModified[ ifModifiedKey ] = lastModified;
						}
						if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
							jQuery.etag[ ifModifiedKey ] = etag;
						}
					}
	
					// If not modified
					if ( status === 304 ) {
	
						statusText = "notmodified";
						isSuccess = true;
	
					// If we have data
					} else {
	
						try {
							success = ajaxConvert( s, response );
							statusText = "success";
							isSuccess = true;
						} catch(e) {
							// We have a parsererror
							statusText = "parsererror";
							error = e;
						}
					}
				} else {
					// We extract error from statusText
					// then normalize statusText and status for non-aborts
					error = statusText;
					if ( !statusText || status ) {
						statusText = "error";
						if ( status < 0 ) {
							status = 0;
						}
					}
				}
	
				// Set data for the fake xhr object
				jqXHR.status = status;
				jqXHR.statusText = "" + ( nativeStatusText || statusText );
	
				// Success/Error
				if ( isSuccess ) {
					deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
				} else {
					deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
				}
	
				// Status-dependent callbacks
				jqXHR.statusCode( statusCode );
				statusCode = undefined;
	
				if ( fireGlobals ) {
					globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
							[ jqXHR, s, isSuccess ? success : error ] );
				}
	
				// Complete
				completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
	
				if ( fireGlobals ) {
					globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
					// Handle the global AJAX counter
					if ( !( --jQuery.active ) ) {
						jQuery.event.trigger( "ajaxStop" );
					}
				}
			}
	
			// Attach deferreds
			deferred.promise( jqXHR );
			jqXHR.success = jqXHR.done;
			jqXHR.error = jqXHR.fail;
			jqXHR.complete = completeDeferred.add;
	
			// Status-dependent callbacks
			jqXHR.statusCode = function( map ) {
				if ( map ) {
					var tmp;
					if ( state < 2 ) {
						for ( tmp in map ) {
							statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
						}
					} else {
						tmp = map[ jqXHR.status ];
						jqXHR.then( tmp, tmp );
					}
				}
				return this;
			};
	
			// Remove hash character (#7531: and string promotion)
			// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
			// We also use the url parameter if available
			s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
	
			// Extract dataTypes list
			s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
	
			// Determine if a cross-domain request is in order
			if ( s.crossDomain == null ) {
				parts = rurl.exec( s.url.toLowerCase() );
				s.crossDomain = !!( parts &&
					( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
						( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
							( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
				);
			}
	
			// Convert data if not already a string
			if ( s.data && s.processData && typeof s.data !== "string" ) {
				s.data = jQuery.param( s.data, s.traditional );
			}
	
			// Apply prefilters
			inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
	
			// If request was aborted inside a prefilter, stop there
			if ( state === 2 ) {
				return false;
			}
	
			// We can fire global events as of now if asked to
			fireGlobals = s.global;
	
			// Uppercase the type
			s.type = s.type.toUpperCase();
	
			// Determine if request has content
			s.hasContent = !rnoContent.test( s.type );
	
			// Watch for a new set of requests
			if ( fireGlobals && jQuery.active++ === 0 ) {
				jQuery.event.trigger( "ajaxStart" );
			}
	
			// More options handling for requests with no content
			if ( !s.hasContent ) {
	
				// If data is available, append data to url
				if ( s.data ) {
					s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
					// #9682: remove data so that it's not used in an eventual retry
					delete s.data;
				}
	
				// Get ifModifiedKey before adding the anti-cache parameter
				ifModifiedKey = s.url;
	
				// Add anti-cache in url if needed
				if ( s.cache === false ) {
	
					var ts = jQuery.now(),
						// try replacing _= if it is there
						ret = s.url.replace( rts, "$1_=" + ts );
	
					// if nothing was replaced, add timestamp to the end
					s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
				}
			}
	
			// Set the correct header, if data is being sent
			if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
				jqXHR.setRequestHeader( "Content-Type", s.contentType );
			}
	
			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
			if ( s.ifModified ) {
				ifModifiedKey = ifModifiedKey || s.url;
				if ( jQuery.lastModified[ ifModifiedKey ] ) {
					jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
				}
				if ( jQuery.etag[ ifModifiedKey ] ) {
					jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
				}
			}
	
			// Set the Accepts header for the server, depending on the dataType
			jqXHR.setRequestHeader(
				"Accept",
				s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
					s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
					s.accepts[ "*" ]
			);
	
			// Check for headers option
			for ( i in s.headers ) {
				jqXHR.setRequestHeader( i, s.headers[ i ] );
			}
	
			// Allow custom headers/mimetypes and early abort
			if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
					// Abort if not done already
					jqXHR.abort();
					return false;
	
			}
	
			// Install callbacks on deferreds
			for ( i in { success: 1, error: 1, complete: 1 } ) {
				jqXHR[ i ]( s[ i ] );
			}
	
			// Get transport
			transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
	
			// If no transport, we auto-abort
			if ( !transport ) {
				done( -1, "No Transport" );
			} else {
				jqXHR.readyState = 1;
				// Send global event
				if ( fireGlobals ) {
					globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
				}
				// Timeout
				if ( s.async && s.timeout > 0 ) {
					timeoutTimer = setTimeout( function(){
						jqXHR.abort( "timeout" );
					}, s.timeout );
				}
	
				try {
					state = 1;
					transport.send( requestHeaders, done );
				} catch (e) {
					// Propagate exception as error if not done
					if ( state < 2 ) {
						done( -1, e );
					// Simply rethrow otherwise
					} else {
						throw e;
					}
				}
			}
	
			return jqXHR;
		},
	
		// Serialize an array of form elements or a set of
		// key/values into a query string
		param: function( a, traditional ) {
			var s = [],
				add = function( key, value ) {
					// If value is a function, invoke it and return its value
					value = jQuery.isFunction( value ) ? value() : value;
					s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
				};
	
			// Set traditional to true for jQuery <= 1.3.2 behavior.
			if ( traditional === undefined ) {
				traditional = jQuery.ajaxSettings.traditional;
			}
	
			// If an array was passed in, assume that it is an array of form elements.
			if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
				// Serialize the form elements
				jQuery.each( a, function() {
					add( this.name, this.value );
				});
	
			} else {
				// If traditional, encode the "old" way (the way 1.3.2 or older
				// did it), otherwise encode params recursively.
				for ( var prefix in a ) {
					buildParams( prefix, a[ prefix ], traditional, add );
				}
			}
	
			// Return the resulting serialization
			return s.join( "&" ).replace( r20, "+" );
		}
	});
	
	function buildParams( prefix, obj, traditional, add ) {
		if ( jQuery.isArray( obj ) ) {
			// Serialize array item.
			jQuery.each( obj, function( i, v ) {
				if ( traditional || rbracket.test( prefix ) ) {
					// Treat each array item as a scalar.
					add( prefix, v );
	
				} else {
					// If array item is non-scalar (array or object), encode its
					// numeric index to resolve deserialization ambiguity issues.
					// Note that rack (as of 1.0.0) can't currently deserialize
					// nested arrays properly, and attempting to do so may cause
					// a server error. Possible fixes are to modify rack's
					// deserialization algorithm or to provide an option or flag
					// to force array serialization to be shallow.
					buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
				}
			});
	
		} else if ( !traditional && jQuery.type( obj ) === "object" ) {
			// Serialize object item.
			for ( var name in obj ) {
				buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
			}
	
		} else {
			// Serialize scalar item.
			add( prefix, obj );
		}
	}
	
	// This is still on the jQuery object... for now
	// Want to move this to jQuery.ajax some day
	jQuery.extend({
	
		// Counter for holding the number of active queries
		active: 0,
	
		// Last-Modified header cache for next request
		lastModified: {},
		etag: {}
	
	});
	
	/* Handles responses to an ajax request:
	 * - sets all responseXXX fields accordingly
	 * - finds the right dataType (mediates between content-type and expected dataType)
	 * - returns the corresponding response
	 */
	function ajaxHandleResponses( s, jqXHR, responses ) {
	
		var contents = s.contents,
			dataTypes = s.dataTypes,
			responseFields = s.responseFields,
			ct,
			type,
			finalDataType,
			firstDataType;
	
		// Fill responseXXX fields
		for ( type in responseFields ) {
			if ( type in responses ) {
				jqXHR[ responseFields[type] ] = responses[ type ];
			}
		}
	
		// Remove auto dataType and get content-type in the process
		while( dataTypes[ 0 ] === "*" ) {
			dataTypes.shift();
			if ( ct === undefined ) {
				ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
			}
		}
	
		// Check if we're dealing with a known content-type
		if ( ct ) {
			for ( type in contents ) {
				if ( contents[ type ] && contents[ type ].test( ct ) ) {
					dataTypes.unshift( type );
					break;
				}
			}
		}
	
		// Check to see if we have a response for the expected dataType
		if ( dataTypes[ 0 ] in responses ) {
			finalDataType = dataTypes[ 0 ];
		} else {
			// Try convertible dataTypes
			for ( type in responses ) {
				if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
					finalDataType = type;
					break;
				}
				if ( !firstDataType ) {
					firstDataType = type;
				}
			}
			// Or just use first one
			finalDataType = finalDataType || firstDataType;
		}
	
		// If we found a dataType
		// We add the dataType to the list if needed
		// and return the corresponding response
		if ( finalDataType ) {
			if ( finalDataType !== dataTypes[ 0 ] ) {
				dataTypes.unshift( finalDataType );
			}
			return responses[ finalDataType ];
		}
	}
	
	// Chain conversions given the request and the original response
	function ajaxConvert( s, response ) {
	
		// Apply the dataFilter if provided
		if ( s.dataFilter ) {
			response = s.dataFilter( response, s.dataType );
		}
	
		var dataTypes = s.dataTypes,
			converters = {},
			i,
			key,
			length = dataTypes.length,
			tmp,
			// Current and previous dataTypes
			current = dataTypes[ 0 ],
			prev,
			// Conversion expression
			conversion,
			// Conversion function
			conv,
			// Conversion functions (transitive conversion)
			conv1,
			conv2;
	
		// For each dataType in the chain
		for ( i = 1; i < length; i++ ) {
	
			// Create converters map
			// with lowercased keys
			if ( i === 1 ) {
				for ( key in s.converters ) {
					if ( typeof key === "string" ) {
						converters[ key.toLowerCase() ] = s.converters[ key ];
					}
				}
			}
	
			// Get the dataTypes
			prev = current;
			current = dataTypes[ i ];
	
			// If current is auto dataType, update it to prev
			if ( current === "*" ) {
				current = prev;
			// If no auto and dataTypes are actually different
			} else if ( prev !== "*" && prev !== current ) {
	
				// Get the converter
				conversion = prev + " " + current;
				conv = converters[ conversion ] || converters[ "* " + current ];
	
				// If there is no direct converter, search transitively
				if ( !conv ) {
					conv2 = undefined;
					for ( conv1 in converters ) {
						tmp = conv1.split( " " );
						if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
							conv2 = converters[ tmp[1] + " " + current ];
							if ( conv2 ) {
								conv1 = converters[ conv1 ];
								if ( conv1 === true ) {
									conv = conv2;
								} else if ( conv2 === true ) {
									conv = conv1;
								}
								break;
							}
						}
					}
				}
				// If we found no converter, dispatch an error
				if ( !( conv || conv2 ) ) {
					jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
				}
				// If found converter is not an equivalence
				if ( conv !== true ) {
					// Convert with 1 or 2 converters accordingly
					response = conv ? conv( response ) : conv2( conv1(response) );
				}
			}
		}
		return response;
	}
	
	
	
	
	var jsc = jQuery.now(),
		jsre = /(\=)\?(&|$)|\?\?/i;
	
	// Default jsonp settings
	jQuery.ajaxSetup({
		jsonp: "callback",
		jsonpCallback: function() {
			return jQuery.expando + "_" + ( jsc++ );
		}
	});
	
	// Detect, normalize options and install callbacks for jsonp requests
	jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
	
		var inspectData = ( typeof s.data === "string" ) && /^application\/x\-www\-form\-urlencoded/.test( s.contentType );
	
		if ( s.dataTypes[ 0 ] === "jsonp" ||
			s.jsonp !== false && ( jsre.test( s.url ) ||
					inspectData && jsre.test( s.data ) ) ) {
	
			var responseContainer,
				jsonpCallback = s.jsonpCallback =
					jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
				previous = window[ jsonpCallback ],
				url = s.url,
				data = s.data,
				replace = "$1" + jsonpCallback + "$2";
	
			if ( s.jsonp !== false ) {
				url = url.replace( jsre, replace );
				if ( s.url === url ) {
					if ( inspectData ) {
						data = data.replace( jsre, replace );
					}
					if ( s.data === data ) {
						// Add callback manually
						url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
					}
				}
			}
	
			s.url = url;
			s.data = data;
	
			// Install callback
			window[ jsonpCallback ] = function( response ) {
				responseContainer = [ response ];
			};
	
			// Clean-up function
			jqXHR.always(function() {
				// Set callback back to previous value
				window[ jsonpCallback ] = previous;
				// Call if it was a function and we have a response
				if ( responseContainer && jQuery.isFunction( previous ) ) {
					window[ jsonpCallback ]( responseContainer[ 0 ] );
				}
			});
	
			// Use data converter to retrieve json after script execution
			s.converters["script json"] = function() {
				if ( !responseContainer ) {
					jQuery.error( jsonpCallback + " was not called" );
				}
				return responseContainer[ 0 ];
			};
	
			// force json dataType
			s.dataTypes[ 0 ] = "json";
	
			// Delegate to script
			return "script";
		}
	});
	
	
	
	
	// Install script dataType
	jQuery.ajaxSetup({
		accepts: {
			script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
		},
		contents: {
			script: /javascript|ecmascript/
		},
		converters: {
			"text script": function( text ) {
				jQuery.globalEval( text );
				return text;
			}
		}
	});
	
	// Handle cache's special case and global
	jQuery.ajaxPrefilter( "script", function( s ) {
		if ( s.cache === undefined ) {
			s.cache = false;
		}
		if ( s.crossDomain ) {
			s.type = "GET";
			s.global = false;
		}
	});
	
	// Bind script tag hack transport
	jQuery.ajaxTransport( "script", function(s) {
	
		// This transport only deals with cross domain requests
		if ( s.crossDomain ) {
	
			var script,
				head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
	
			return {
	
				send: function( _, callback ) {
	
					script = document.createElement( "script" );
	
					script.async = "async";
	
					if ( s.scriptCharset ) {
						script.charset = s.scriptCharset;
					}
	
					script.src = s.url;
	
					// Attach handlers for all browsers
					script.onload = script.onreadystatechange = function( _, isAbort ) {
	
						if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
	
							// Handle memory leak in IE
							script.onload = script.onreadystatechange = null;
	
							// Remove the script
							if ( head && script.parentNode ) {
								head.removeChild( script );
							}
	
							// Dereference the script
							script = undefined;
	
							// Callback if not abort
							if ( !isAbort ) {
								callback( 200, "success" );
							}
						}
					};
					// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
					// This arises when a base node is used (#2709 and #4378).
					head.insertBefore( script, head.firstChild );
				},
	
				abort: function() {
					if ( script ) {
						script.onload( 0, 1 );
					}
				}
			};
		}
	});
	
	
	
	
	var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
		xhrOnUnloadAbort = window.ActiveXObject ? function() {
			// Abort all pending requests
			for ( var key in xhrCallbacks ) {
				xhrCallbacks[ key ]( 0, 1 );
			}
		} : false,
		xhrId = 0,
		xhrCallbacks;
	
	// Functions to create xhrs
	function createStandardXHR() {
		try {
			return new window.XMLHttpRequest();
		} catch( e ) {}
	}
	
	function createActiveXHR() {
		try {
			return new window.ActiveXObject( "Microsoft.XMLHTTP" );
		} catch( e ) {}
	}
	
	// Create the request object
	// (This is still attached to ajaxSettings for backward compatibility)
	jQuery.ajaxSettings.xhr = window.ActiveXObject ?
		/* Microsoft failed to properly
		 * implement the XMLHttpRequest in IE7 (can't request local files),
		 * so we use the ActiveXObject when it is available
		 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
		 * we need a fallback.
		 */
		function() {
			return !this.isLocal && createStandardXHR() || createActiveXHR();
		} :
		// For all other browsers, use the standard XMLHttpRequest object
		createStandardXHR;
	
	// Determine support properties
	(function( xhr ) {
		jQuery.extend( jQuery.support, {
			ajax: !!xhr,
			cors: !!xhr && ( "withCredentials" in xhr )
		});
	})( jQuery.ajaxSettings.xhr() );
	
	// Create transport if the browser can provide an xhr
	if ( jQuery.support.ajax ) {
	
		jQuery.ajaxTransport(function( s ) {
			// Cross domain only allowed if supported through XMLHttpRequest
			if ( !s.crossDomain || jQuery.support.cors ) {
	
				var callback;
	
				return {
					send: function( headers, complete ) {
	
						// Get a new xhr
						var xhr = s.xhr(),
							handle,
							i;
	
						// Open the socket
						// Passing null username, generates a login popup on Opera (#2865)
						if ( s.username ) {
							xhr.open( s.type, s.url, s.async, s.username, s.password );
						} else {
							xhr.open( s.type, s.url, s.async );
						}
	
						// Apply custom fields if provided
						if ( s.xhrFields ) {
							for ( i in s.xhrFields ) {
								xhr[ i ] = s.xhrFields[ i ];
							}
						}
	
						// Override mime type if needed
						if ( s.mimeType && xhr.overrideMimeType ) {
							xhr.overrideMimeType( s.mimeType );
						}
	
						// X-Requested-With header
						// For cross-domain requests, seeing as conditions for a preflight are
						// akin to a jigsaw puzzle, we simply never set it to be sure.
						// (it can always be set on a per-request basis or even using ajaxSetup)
						// For same-domain requests, won't change header if already provided.
						if ( !s.crossDomain && !headers["X-Requested-With"] ) {
							headers[ "X-Requested-With" ] = "XMLHttpRequest";
						}
	
						// Need an extra try/catch for cross domain requests in Firefox 3
						try {
							for ( i in headers ) {
								xhr.setRequestHeader( i, headers[ i ] );
							}
						} catch( _ ) {}
	
						// Do send the request
						// This may raise an exception which is actually
						// handled in jQuery.ajax (so no try/catch here)
						xhr.send( ( s.hasContent && s.data ) || null );
	
						// Listener
						callback = function( _, isAbort ) {
	
							var status,
								statusText,
								responseHeaders,
								responses,
								xml;
	
							// Firefox throws exceptions when accessing properties
							// of an xhr when a network error occured
							// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
							try {
	
								// Was never called and is aborted or complete
								if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
	
									// Only called once
									callback = undefined;
	
									// Do not keep as active anymore
									if ( handle ) {
										xhr.onreadystatechange = jQuery.noop;
										if ( xhrOnUnloadAbort ) {
											delete xhrCallbacks[ handle ];
										}
									}
	
									// If it's an abort
									if ( isAbort ) {
										// Abort it manually if needed
										if ( xhr.readyState !== 4 ) {
											xhr.abort();
										}
									} else {
										status = xhr.status;
										responseHeaders = xhr.getAllResponseHeaders();
										responses = {};
										xml = xhr.responseXML;
	
										// Construct response list
										if ( xml && xml.documentElement /* #4958 */ ) {
											responses.xml = xml;
										}
	
										// When requesting binary data, IE6-9 will throw an exception
										// on any attempt to access responseText (#11426)
										try {
											responses.text = xhr.responseText;
										} catch( _ ) {
										}
	
										// Firefox throws an exception when accessing
										// statusText for faulty cross-domain requests
										try {
											statusText = xhr.statusText;
										} catch( e ) {
											// We normalize with Webkit giving an empty statusText
											statusText = "";
										}
	
										// Filter status for non standard behaviors
	
										// If the request is local and we have data: assume a success
										// (success with no data won't get notified, that's the best we
										// can do given current implementations)
										if ( !status && s.isLocal && !s.crossDomain ) {
											status = responses.text ? 200 : 404;
										// IE - #1450: sometimes returns 1223 when it should be 204
										} else if ( status === 1223 ) {
											status = 204;
										}
									}
								}
							} catch( firefoxAccessException ) {
								if ( !isAbort ) {
									complete( -1, firefoxAccessException );
								}
							}
	
							// Call complete if needed
							if ( responses ) {
								complete( status, statusText, responses, responseHeaders );
							}
						};
	
						// if we're in sync mode or it's in cache
						// and has been retrieved directly (IE6 & IE7)
						// we need to manually fire the callback
						if ( !s.async || xhr.readyState === 4 ) {
							callback();
						} else {
							handle = ++xhrId;
							if ( xhrOnUnloadAbort ) {
								// Create the active xhrs callbacks list if needed
								// and attach the unload handler
								if ( !xhrCallbacks ) {
									xhrCallbacks = {};
									jQuery( window ).unload( xhrOnUnloadAbort );
								}
								// Add to list of active xhrs callbacks
								xhrCallbacks[ handle ] = callback;
							}
							xhr.onreadystatechange = callback;
						}
					},
	
					abort: function() {
						if ( callback ) {
							callback(0,1);
						}
					}
				};
			}
		});
	}
	
	
	
	
	var elemdisplay = {},
		iframe, iframeDoc,
		rfxtypes = /^(?:toggle|show|hide)$/,
		rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
		timerId,
		fxAttrs = [
			// height animations
			[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
			// width animations
			[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
			// opacity animations
			[ "opacity" ]
		],
		fxNow;
	
	jQuery.fn.extend({
		show: function( speed, easing, callback ) {
			var elem, display;
	
			if ( speed || speed === 0 ) {
				return this.animate( genFx("show", 3), speed, easing, callback );
	
			} else {
				for ( var i = 0, j = this.length; i < j; i++ ) {
					elem = this[ i ];
	
					if ( elem.style ) {
						display = elem.style.display;
	
						// Reset the inline display of this element to learn if it is
						// being hidden by cascaded rules or not
						if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
							display = elem.style.display = "";
						}
	
						// Set elements which have been overridden with display: none
						// in a stylesheet to whatever the default browser style is
						// for such an element
						if ( (display === "" && jQuery.css(elem, "display") === "none") ||
							!jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
							jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
						}
					}
				}
	
				// Set the display of most of the elements in a second loop
				// to avoid the constant reflow
				for ( i = 0; i < j; i++ ) {
					elem = this[ i ];
	
					if ( elem.style ) {
						display = elem.style.display;
	
						if ( display === "" || display === "none" ) {
							elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
						}
					}
				}
	
				return this;
			}
		},
	
		hide: function( speed, easing, callback ) {
			if ( speed || speed === 0 ) {
				return this.animate( genFx("hide", 3), speed, easing, callback);
	
			} else {
				var elem, display,
					i = 0,
					j = this.length;
	
				for ( ; i < j; i++ ) {
					elem = this[i];
					if ( elem.style ) {
						display = jQuery.css( elem, "display" );
	
						if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
							jQuery._data( elem, "olddisplay", display );
						}
					}
				}
	
				// Set the display of the elements in a second loop
				// to avoid the constant reflow
				for ( i = 0; i < j; i++ ) {
					if ( this[i].style ) {
						this[i].style.display = "none";
					}
				}
	
				return this;
			}
		},
	
		// Save the old toggle function
		_toggle: jQuery.fn.toggle,
	
		toggle: function( fn, fn2, callback ) {
			var bool = typeof fn === "boolean";
	
			if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
				this._toggle.apply( this, arguments );
	
			} else if ( fn == null || bool ) {
				this.each(function() {
					var state = bool ? fn : jQuery(this).is(":hidden");
					jQuery(this)[ state ? "show" : "hide" ]();
				});
	
			} else {
				this.animate(genFx("toggle", 3), fn, fn2, callback);
			}
	
			return this;
		},
	
		fadeTo: function( speed, to, easing, callback ) {
			return this.filter(":hidden").css("opacity", 0).show().end()
						.animate({opacity: to}, speed, easing, callback);
		},
	
		animate: function( prop, speed, easing, callback ) {
			var optall = jQuery.speed( speed, easing, callback );
	
			if ( jQuery.isEmptyObject( prop ) ) {
				return this.each( optall.complete, [ false ] );
			}
	
			// Do not change referenced properties as per-property easing will be lost
			prop = jQuery.extend( {}, prop );
	
			function doAnimation() {
				// XXX 'this' does not always have a nodeName when running the
				// test suite
	
				if ( optall.queue === false ) {
					jQuery._mark( this );
				}
	
				var opt = jQuery.extend( {}, optall ),
					isElement = this.nodeType === 1,
					hidden = isElement && jQuery(this).is(":hidden"),
					name, val, p, e, hooks, replace,
					parts, start, end, unit,
					method;
	
				// will store per property easing and be used to determine when an animation is complete
				opt.animatedProperties = {};
	
				// first pass over propertys to expand / normalize
				for ( p in prop ) {
					name = jQuery.camelCase( p );
					if ( p !== name ) {
						prop[ name ] = prop[ p ];
						delete prop[ p ];
					}
	
					if ( ( hooks = jQuery.cssHooks[ name ] ) && "expand" in hooks ) {
						replace = hooks.expand( prop[ name ] );
						delete prop[ name ];
	
						// not quite $.extend, this wont overwrite keys already present.
						// also - reusing 'p' from above because we have the correct "name"
						for ( p in replace ) {
							if ( ! ( p in prop ) ) {
								prop[ p ] = replace[ p ];
							}
						}
					}
				}
	
				for ( name in prop ) {
					val = prop[ name ];
					// easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
					if ( jQuery.isArray( val ) ) {
						opt.animatedProperties[ name ] = val[ 1 ];
						val = prop[ name ] = val[ 0 ];
					} else {
						opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
					}
	
					if ( val === "hide" && hidden || val === "show" && !hidden ) {
						return opt.complete.call( this );
					}
	
					if ( isElement && ( name === "height" || name === "width" ) ) {
						// Make sure that nothing sneaks out
						// Record all 3 overflow attributes because IE does not
						// change the overflow attribute when overflowX and
						// overflowY are set to the same value
						opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
	
						// Set display property to inline-block for height/width
						// animations on inline elements that are having width/height animated
						if ( jQuery.css( this, "display" ) === "inline" &&
								jQuery.css( this, "float" ) === "none" ) {
	
							// inline-level elements accept inline-block;
							// block-level elements need to be inline with layout
							if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
								this.style.display = "inline-block";
	
							} else {
								this.style.zoom = 1;
							}
						}
					}
				}
	
				if ( opt.overflow != null ) {
					this.style.overflow = "hidden";
				}
	
				for ( p in prop ) {
					e = new jQuery.fx( this, opt, p );
					val = prop[ p ];
	
					if ( rfxtypes.test( val ) ) {
	
						// Tracks whether to show or hide based on private
						// data attached to the element
						method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
						if ( method ) {
							jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
							e[ method ]();
						} else {
							e[ val ]();
						}
	
					} else {
						parts = rfxnum.exec( val );
						start = e.cur();
	
						if ( parts ) {
							end = parseFloat( parts[2] );
							unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
	
							// We need to compute starting value
							if ( unit !== "px" ) {
								jQuery.style( this, p, (end || 1) + unit);
								start = ( (end || 1) / e.cur() ) * start;
								jQuery.style( this, p, start + unit);
							}
	
							// If a +=/-= token was provided, we're doing a relative animation
							if ( parts[1] ) {
								end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
							}
	
							e.custom( start, end, unit );
	
						} else {
							e.custom( start, val, "" );
						}
					}
				}
	
				// For JS strict compliance
				return true;
			}
	
			return optall.queue === false ?
				this.each( doAnimation ) :
				this.queue( optall.queue, doAnimation );
		},
	
		stop: function( type, clearQueue, gotoEnd ) {
			if ( typeof type !== "string" ) {
				gotoEnd = clearQueue;
				clearQueue = type;
				type = undefined;
			}
			if ( clearQueue && type !== false ) {
				this.queue( type || "fx", [] );
			}
	
			return this.each(function() {
				var index,
					hadTimers = false,
					timers = jQuery.timers,
					data = jQuery._data( this );
	
				// clear marker counters if we know they won't be
				if ( !gotoEnd ) {
					jQuery._unmark( true, this );
				}
	
				function stopQueue( elem, data, index ) {
					var hooks = data[ index ];
					jQuery.removeData( elem, index, true );
					hooks.stop( gotoEnd );
				}
	
				if ( type == null ) {
					for ( index in data ) {
						if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
							stopQueue( this, data, index );
						}
					}
				} else if ( data[ index = type + ".run" ] && data[ index ].stop ){
					stopQueue( this, data, index );
				}
	
				for ( index = timers.length; index--; ) {
					if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
						if ( gotoEnd ) {
	
							// force the next step to be the last
							timers[ index ]( true );
						} else {
							timers[ index ].saveState();
						}
						hadTimers = true;
						timers.splice( index, 1 );
					}
				}
	
				// start the next in the queue if the last step wasn't forced
				// timers currently will call their complete callbacks, which will dequeue
				// but only if they were gotoEnd
				if ( !( gotoEnd && hadTimers ) ) {
					jQuery.dequeue( this, type );
				}
			});
		}
	
	});
	
	// Animations created synchronously will run synchronously
	function createFxNow() {
		setTimeout( clearFxNow, 0 );
		return ( fxNow = jQuery.now() );
	}
	
	function clearFxNow() {
		fxNow = undefined;
	}
	
	// Generate parameters to create a standard animation
	function genFx( type, num ) {
		var obj = {};
	
		jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
			obj[ this ] = type;
		});
	
		return obj;
	}
	
	// Generate shortcuts for custom animations
	jQuery.each({
		slideDown: genFx( "show", 1 ),
		slideUp: genFx( "hide", 1 ),
		slideToggle: genFx( "toggle", 1 ),
		fadeIn: { opacity: "show" },
		fadeOut: { opacity: "hide" },
		fadeToggle: { opacity: "toggle" }
	}, function( name, props ) {
		jQuery.fn[ name ] = function( speed, easing, callback ) {
			return this.animate( props, speed, easing, callback );
		};
	});
	
	jQuery.extend({
		speed: function( speed, easing, fn ) {
			var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
				complete: fn || !fn && easing ||
					jQuery.isFunction( speed ) && speed,
				duration: speed,
				easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
			};
	
			opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
				opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
	
			// normalize opt.queue - true/undefined/null -> "fx"
			if ( opt.queue == null || opt.queue === true ) {
				opt.queue = "fx";
			}
	
			// Queueing
			opt.old = opt.complete;
	
			opt.complete = function( noUnmark ) {
				if ( jQuery.isFunction( opt.old ) ) {
					opt.old.call( this );
				}
	
				if ( opt.queue ) {
					jQuery.dequeue( this, opt.queue );
				} else if ( noUnmark !== false ) {
					jQuery._unmark( this );
				}
			};
	
			return opt;
		},
	
		easing: {
			linear: function( p ) {
				return p;
			},
			swing: function( p ) {
				return ( -Math.cos( p*Math.PI ) / 2 ) + 0.5;
			}
		},
	
		timers: [],
	
		fx: function( elem, options, prop ) {
			this.options = options;
			this.elem = elem;
			this.prop = prop;
	
			options.orig = options.orig || {};
		}
	
	});
	
	jQuery.fx.prototype = {
		// Simple function for setting a style value
		update: function() {
			if ( this.options.step ) {
				this.options.step.call( this.elem, this.now, this );
			}
	
			( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
		},
	
		// Get the current size
		cur: function() {
			if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
				return this.elem[ this.prop ];
			}
	
			var parsed,
				r = jQuery.css( this.elem, this.prop );
			// Empty strings, null, undefined and "auto" are converted to 0,
			// complex values such as "rotate(1rad)" are returned as is,
			// simple values such as "10px" are parsed to Float.
			return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
		},
	
		// Start an animation from one number to another
		custom: function( from, to, unit ) {
			var self = this,
				fx = jQuery.fx;
	
			this.startTime = fxNow || createFxNow();
			this.end = to;
			this.now = this.start = from;
			this.pos = this.state = 0;
			this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
	
			function t( gotoEnd ) {
				return self.step( gotoEnd );
			}
	
			t.queue = this.options.queue;
			t.elem = this.elem;
			t.saveState = function() {
				if ( jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
					if ( self.options.hide ) {
						jQuery._data( self.elem, "fxshow" + self.prop, self.start );
					} else if ( self.options.show ) {
						jQuery._data( self.elem, "fxshow" + self.prop, self.end );
					}
				}
			};
	
			if ( t() && jQuery.timers.push(t) && !timerId ) {
				timerId = setInterval( fx.tick, fx.interval );
			}
		},
	
		// Simple 'show' function
		show: function() {
			var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );
	
			// Remember where we started, so that we can go back to it later
			this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
			this.options.show = true;
	
			// Begin the animation
			// Make sure that we start at a small width/height to avoid any flash of content
			if ( dataShow !== undefined ) {
				// This show is picking up where a previous hide or show left off
				this.custom( this.cur(), dataShow );
			} else {
				this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
			}
	
			// Start by showing the element
			jQuery( this.elem ).show();
		},
	
		// Simple 'hide' function
		hide: function() {
			// Remember where we started, so that we can go back to it later
			this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
			this.options.hide = true;
	
			// Begin the animation
			this.custom( this.cur(), 0 );
		},
	
		// Each step of an animation
		step: function( gotoEnd ) {
			var p, n, complete,
				t = fxNow || createFxNow(),
				done = true,
				elem = this.elem,
				options = this.options;
	
			if ( gotoEnd || t >= options.duration + this.startTime ) {
				this.now = this.end;
				this.pos = this.state = 1;
				this.update();
	
				options.animatedProperties[ this.prop ] = true;
	
				for ( p in options.animatedProperties ) {
					if ( options.animatedProperties[ p ] !== true ) {
						done = false;
					}
				}
	
				if ( done ) {
					// Reset the overflow
					if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
	
						jQuery.each( [ "", "X", "Y" ], function( index, value ) {
							elem.style[ "overflow" + value ] = options.overflow[ index ];
						});
					}
	
					// Hide the element if the "hide" operation was done
					if ( options.hide ) {
						jQuery( elem ).hide();
					}
	
					// Reset the properties, if the item has been hidden or shown
					if ( options.hide || options.show ) {
						for ( p in options.animatedProperties ) {
							jQuery.style( elem, p, options.orig[ p ] );
							jQuery.removeData( elem, "fxshow" + p, true );
							// Toggle data is no longer needed
							jQuery.removeData( elem, "toggle" + p, true );
						}
					}
	
					// Execute the complete function
					// in the event that the complete function throws an exception
					// we must ensure it won't be called twice. #5684
	
					complete = options.complete;
					if ( complete ) {
	
						options.complete = false;
						complete.call( elem );
					}
				}
	
				return false;
	
			} else {
				// classical easing cannot be used with an Infinity duration
				if ( options.duration == Infinity ) {
					this.now = t;
				} else {
					n = t - this.startTime;
					this.state = n / options.duration;
	
					// Perform the easing function, defaults to swing
					this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
					this.now = this.start + ( (this.end - this.start) * this.pos );
				}
				// Perform the next step of the animation
				this.update();
			}
	
			return true;
		}
	};
	
	jQuery.extend( jQuery.fx, {
		tick: function() {
			var timer,
				timers = jQuery.timers,
				i = 0;
	
			for ( ; i < timers.length; i++ ) {
				timer = timers[ i ];
				// Checks the timer has not already been removed
				if ( !timer() && timers[ i ] === timer ) {
					timers.splice( i--, 1 );
				}
			}
	
			if ( !timers.length ) {
				jQuery.fx.stop();
			}
		},
	
		interval: 13,
	
		stop: function() {
			clearInterval( timerId );
			timerId = null;
		},
	
		speeds: {
			slow: 600,
			fast: 200,
			// Default speed
			_default: 400
		},
	
		step: {
			opacity: function( fx ) {
				jQuery.style( fx.elem, "opacity", fx.now );
			},
	
			_default: function( fx ) {
				if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
					fx.elem.style[ fx.prop ] = fx.now + fx.unit;
				} else {
					fx.elem[ fx.prop ] = fx.now;
				}
			}
		}
	});
	
	// Ensure props that can't be negative don't go there on undershoot easing
	jQuery.each( fxAttrs.concat.apply( [], fxAttrs ), function( i, prop ) {
		// exclude marginTop, marginLeft, marginBottom and marginRight from this list
		if ( prop.indexOf( "margin" ) ) {
			jQuery.fx.step[ prop ] = function( fx ) {
				jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
			};
		}
	});
	
	if ( jQuery.expr && jQuery.expr.filters ) {
		jQuery.expr.filters.animated = function( elem ) {
			return jQuery.grep(jQuery.timers, function( fn ) {
				return elem === fn.elem;
			}).length;
		};
	}
	
	// Try to restore the default display value of an element
	function defaultDisplay( nodeName ) {
	
		if ( !elemdisplay[ nodeName ] ) {
	
			var body = document.body,
				elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
				display = elem.css( "display" );
			elem.remove();
	
			// If the simple way fails,
			// get element's real default display by attaching it to a temp iframe
			if ( display === "none" || display === "" ) {
				// No iframe to use yet, so create it
				if ( !iframe ) {
					iframe = document.createElement( "iframe" );
					iframe.frameBorder = iframe.width = iframe.height = 0;
				}
	
				body.appendChild( iframe );
	
				// Create a cacheable copy of the iframe document on first call.
				// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
				// document to it; WebKit & Firefox won't allow reusing the iframe document.
				if ( !iframeDoc || !iframe.createElement ) {
					iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
					iframeDoc.write( ( jQuery.support.boxModel ? "<!doctype html>" : "" ) + "<html><body>" );
					iframeDoc.close();
				}
	
				elem = iframeDoc.createElement( nodeName );
	
				iframeDoc.body.appendChild( elem );
	
				display = jQuery.css( elem, "display" );
				body.removeChild( iframe );
			}
	
			// Store the correct default display
			elemdisplay[ nodeName ] = display;
		}
	
		return elemdisplay[ nodeName ];
	}
	
	
	
	
	var getOffset,
		rtable = /^t(?:able|d|h)$/i,
		rroot = /^(?:body|html)$/i;
	
	if ( "getBoundingClientRect" in document.documentElement ) {
		getOffset = function( elem, doc, docElem, box ) {
			try {
				box = elem.getBoundingClientRect();
			} catch(e) {}
	
			// Make sure we're not dealing with a disconnected DOM node
			if ( !box || !jQuery.contains( docElem, elem ) ) {
				return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
			}
	
			var body = doc.body,
				win = getWindow( doc ),
				clientTop  = docElem.clientTop  || body.clientTop  || 0,
				clientLeft = docElem.clientLeft || body.clientLeft || 0,
				scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
				scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
				top  = box.top  + scrollTop  - clientTop,
				left = box.left + scrollLeft - clientLeft;
	
			return { top: top, left: left };
		};
	
	} else {
		getOffset = function( elem, doc, docElem ) {
			var computedStyle,
				offsetParent = elem.offsetParent,
				prevOffsetParent = elem,
				body = doc.body,
				defaultView = doc.defaultView,
				prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
				top = elem.offsetTop,
				left = elem.offsetLeft;
	
			while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
				if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
					break;
				}
	
				computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
				top  -= elem.scrollTop;
				left -= elem.scrollLeft;
	
				if ( elem === offsetParent ) {
					top  += elem.offsetTop;
					left += elem.offsetLeft;
	
					if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
						top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
						left += parseFloat( computedStyle.borderLeftWidth ) || 0;
					}
	
					prevOffsetParent = offsetParent;
					offsetParent = elem.offsetParent;
				}
	
				if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
				}
	
				prevComputedStyle = computedStyle;
			}
	
			if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
				top  += body.offsetTop;
				left += body.offsetLeft;
			}
	
			if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
				top  += Math.max( docElem.scrollTop, body.scrollTop );
				left += Math.max( docElem.scrollLeft, body.scrollLeft );
			}
	
			return { top: top, left: left };
		};
	}
	
	jQuery.fn.offset = function( options ) {
		if ( arguments.length ) {
			return options === undefined ?
				this :
				this.each(function( i ) {
					jQuery.offset.setOffset( this, options, i );
				});
		}
	
		var elem = this[0],
			doc = elem && elem.ownerDocument;
	
		if ( !doc ) {
			return null;
		}
	
		if ( elem === doc.body ) {
			return jQuery.offset.bodyOffset( elem );
		}
	
		return getOffset( elem, doc, doc.documentElement );
	};
	
	jQuery.offset = {
	
		bodyOffset: function( body ) {
			var top = body.offsetTop,
				left = body.offsetLeft;
	
			if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
				top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
				left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
			}
	
			return { top: top, left: left };
		},
	
		setOffset: function( elem, options, i ) {
			var position = jQuery.css( elem, "position" );
	
			// set position first, in-case top/left are set even on static elem
			if ( position === "static" ) {
				elem.style.position = "relative";
			}
	
			var curElem = jQuery( elem ),
				curOffset = curElem.offset(),
				curCSSTop = jQuery.css( elem, "top" ),
				curCSSLeft = jQuery.css( elem, "left" ),
				calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
				props = {}, curPosition = {}, curTop, curLeft;
	
			// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
			if ( calculatePosition ) {
				curPosition = curElem.position();
				curTop = curPosition.top;
				curLeft = curPosition.left;
			} else {
				curTop = parseFloat( curCSSTop ) || 0;
				curLeft = parseFloat( curCSSLeft ) || 0;
			}
	
			if ( jQuery.isFunction( options ) ) {
				options = options.call( elem, i, curOffset );
			}
	
			if ( options.top != null ) {
				props.top = ( options.top - curOffset.top ) + curTop;
			}
			if ( options.left != null ) {
				props.left = ( options.left - curOffset.left ) + curLeft;
			}
	
			if ( "using" in options ) {
				options.using.call( elem, props );
			} else {
				curElem.css( props );
			}
		}
	};
	
	
	jQuery.fn.extend({
	
		position: function() {
			if ( !this[0] ) {
				return null;
			}
	
			var elem = this[0],
	
			// Get *real* offsetParent
			offsetParent = this.offsetParent(),
	
			// Get correct offsets
			offset       = this.offset(),
			parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
	
			// Subtract element margins
			// note: when an element has margin: auto the offsetLeft and marginLeft
			// are the same in Safari causing offset.left to incorrectly be 0
			offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
			offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
	
			// Add offsetParent borders
			parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
			parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
	
			// Subtract the two offsets
			return {
				top:  offset.top  - parentOffset.top,
				left: offset.left - parentOffset.left
			};
		},
	
		offsetParent: function() {
			return this.map(function() {
				var offsetParent = this.offsetParent || document.body;
				while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
					offsetParent = offsetParent.offsetParent;
				}
				return offsetParent;
			});
		}
	});
	
	
	// Create scrollLeft and scrollTop methods
	jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
		var top = /Y/.test( prop );
	
		jQuery.fn[ method ] = function( val ) {
			return jQuery.access( this, function( elem, method, val ) {
				var win = getWindow( elem );
	
				if ( val === undefined ) {
					return win ? (prop in win) ? win[ prop ] :
						jQuery.support.boxModel && win.document.documentElement[ method ] ||
							win.document.body[ method ] :
						elem[ method ];
				}
	
				if ( win ) {
					win.scrollTo(
						!top ? val : jQuery( win ).scrollLeft(),
						 top ? val : jQuery( win ).scrollTop()
					);
	
				} else {
					elem[ method ] = val;
				}
			}, method, val, arguments.length, null );
		};
	});
	
	function getWindow( elem ) {
		return jQuery.isWindow( elem ) ?
			elem :
			elem.nodeType === 9 ?
				elem.defaultView || elem.parentWindow :
				false;
	}
	
	
	
	
	// Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
	jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
		var clientProp = "client" + name,
			scrollProp = "scroll" + name,
			offsetProp = "offset" + name;
	
		// innerHeight and innerWidth
		jQuery.fn[ "inner" + name ] = function() {
			var elem = this[0];
			return elem ?
				elem.style ?
				parseFloat( jQuery.css( elem, type, "padding" ) ) :
				this[ type ]() :
				null;
		};
	
		// outerHeight and outerWidth
		jQuery.fn[ "outer" + name ] = function( margin ) {
			var elem = this[0];
			return elem ?
				elem.style ?
				parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
				this[ type ]() :
				null;
		};
	
		jQuery.fn[ type ] = function( value ) {
			return jQuery.access( this, function( elem, type, value ) {
				var doc, docElemProp, orig, ret;
	
				if ( jQuery.isWindow( elem ) ) {
					// 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
					doc = elem.document;
					docElemProp = doc.documentElement[ clientProp ];
					return jQuery.support.boxModel && docElemProp ||
						doc.body && doc.body[ clientProp ] || docElemProp;
				}
	
				// Get document width or height
				if ( elem.nodeType === 9 ) {
					// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
					doc = elem.documentElement;
	
					// when a window > document, IE6 reports a offset[Width/Height] > client[Width/Height]
					// so we can't use max, as it'll choose the incorrect offset[Width/Height]
					// instead we use the correct client[Width/Height]
					// support:IE6
					if ( doc[ clientProp ] >= doc[ scrollProp ] ) {
						return doc[ clientProp ];
					}
	
					return Math.max(
						elem.body[ scrollProp ], doc[ scrollProp ],
						elem.body[ offsetProp ], doc[ offsetProp ]
					);
				}
	
				// Get width or height on the element
				if ( value === undefined ) {
					orig = jQuery.css( elem, type );
					ret = parseFloat( orig );
					return jQuery.isNumeric( ret ) ? ret : orig;
				}
	
				// Set the width or height on the element
				jQuery( elem ).css( type, value );
			}, type, value, arguments.length, null );
		};
	});
	
	
	
	
	if ( typeof module === "object" && module && typeof module.exports === "object" ) {
		// Expose jQuery as module.exports in loaders that implement the Node
		// module pattern (including browserify). Do not create the global, since
		// the user will be storing it themselves locally, and globals are frowned
		// upon in the Node module world.
		module.exports = jQuery;
	} else {
		// Otherwise expose jQuery to the global object as usual
		window.jQuery = window.$ = jQuery;
	
		// Register as a named AMD module, since jQuery can be concatenated with other
		// files that may use define, but not via a proper concatenation script that
		// understands anonymous AMD modules. A named AMD is safest and most robust
		// way to register. Lowercase jquery is used because AMD module names are
		// derived from file names, and jQuery is normally delivered in a lowercase
		// file name. Do this after creating the global so that if an AMD module wants
		// to call noConflict to hide this version of jQuery, it will work.
		if ( true ) {
			!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () { return jQuery; }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
		}
	}
	
	
	
	})( window );
	
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(111)(module)))

/***/ },
/* 3 */
/***/ function(module, exports) {

	'use strict';
	
	exports.__esModule = true;
	exports.extend = extend;
	exports.indexOf = indexOf;
	exports.escapeExpression = escapeExpression;
	exports.isEmpty = isEmpty;
	exports.createFrame = createFrame;
	exports.blockParams = blockParams;
	exports.appendContextPath = appendContextPath;
	var escape = {
	  '&': '&amp;',
	  '<': '&lt;',
	  '>': '&gt;',
	  '"': '&quot;',
	  "'": '&#x27;',
	  '`': '&#x60;',
	  '=': '&#x3D;'
	};
	
	var badChars = /[&<>"'`=]/g,
	    possible = /[&<>"'`=]/;
	
	function escapeChar(chr) {
	  return escape[chr];
	}
	
	function extend(obj /* , ...source */) {
	  for (var i = 1; i < arguments.length; i++) {
	    for (var key in arguments[i]) {
	      if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
	        obj[key] = arguments[i][key];
	      }
	    }
	  }
	
	  return obj;
	}
	
	var toString = Object.prototype.toString;
	
	exports.toString = toString;
	// Sourced from lodash
	// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
	/* eslint-disable func-style */
	var isFunction = function isFunction(value) {
	  return typeof value === 'function';
	};
	// fallback for older versions of Chrome and Safari
	/* istanbul ignore next */
	if (isFunction(/x/)) {
	  exports.isFunction = isFunction = function (value) {
	    return typeof value === 'function' && toString.call(value) === '[object Function]';
	  };
	}
	exports.isFunction = isFunction;
	
	/* eslint-enable func-style */
	
	/* istanbul ignore next */
	var isArray = Array.isArray || function (value) {
	  return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
	};
	
	exports.isArray = isArray;
	// Older IE versions do not directly support indexOf so we must implement our own, sadly.
	
	function indexOf(array, value) {
	  for (var i = 0, len = array.length; i < len; i++) {
	    if (array[i] === value) {
	      return i;
	    }
	  }
	  return -1;
	}
	
	function escapeExpression(string) {
	  if (typeof string !== 'string') {
	    // don't escape SafeStrings, since they're already safe
	    if (string && string.toHTML) {
	      return string.toHTML();
	    } else if (string == null) {
	      return '';
	    } else if (!string) {
	      return string + '';
	    }
	
	    // Force a string conversion as this will be done by the append regardless and
	    // the regex test will do this transparently behind the scenes, causing issues if
	    // an object's to string has escaped characters in it.
	    string = '' + string;
	  }
	
	  if (!possible.test(string)) {
	    return string;
	  }
	  return string.replace(badChars, escapeChar);
	}
	
	function isEmpty(value) {
	  if (!value && value !== 0) {
	    return true;
	  } else if (isArray(value) && value.length === 0) {
	    return true;
	  } else {
	    return false;
	  }
	}
	
	function createFrame(object) {
	  var frame = extend({}, object);
	  frame._parent = object;
	  return frame;
	}
	
	function blockParams(params, ids) {
	  params.path = ids;
	  return params;
	}
	
	function appendContextPath(contextPath, id) {
	  return (contextPath ? contextPath + '.' : '') + id;
	}
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Utils = __webpack_require__(12);
	var Exception = __webpack_require__(5)["default"];
	
	var VERSION = "1.3.0";
	exports.VERSION = VERSION;var COMPILER_REVISION = 4;
	exports.COMPILER_REVISION = COMPILER_REVISION;
	var REVISION_CHANGES = {
	  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
	  2: '== 1.0.0-rc.3',
	  3: '== 1.0.0-rc.4',
	  4: '>= 1.0.0'
	};
	exports.REVISION_CHANGES = REVISION_CHANGES;
	var isArray = Utils.isArray,
	    isFunction = Utils.isFunction,
	    toString = Utils.toString,
	    objectType = '[object Object]';
	
	function HandlebarsEnvironment(helpers, partials) {
	  this.helpers = helpers || {};
	  this.partials = partials || {};
	
	  registerDefaultHelpers(this);
	}
	
	exports.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
	  constructor: HandlebarsEnvironment,
	
	  logger: logger,
	  log: log,
	
	  registerHelper: function(name, fn, inverse) {
	    if (toString.call(name) === objectType) {
	      if (inverse || fn) { throw new Exception('Arg not supported with multiple helpers'); }
	      Utils.extend(this.helpers, name);
	    } else {
	      if (inverse) { fn.not = inverse; }
	      this.helpers[name] = fn;
	    }
	  },
	
	  registerPartial: function(name, str) {
	    if (toString.call(name) === objectType) {
	      Utils.extend(this.partials,  name);
	    } else {
	      this.partials[name] = str;
	    }
	  }
	};
	
	function registerDefaultHelpers(instance) {
	  instance.registerHelper('helperMissing', function(arg) {
	    if(arguments.length === 2) {
	      return undefined;
	    } else {
	      throw new Exception("Missing helper: '" + arg + "'");
	    }
	  });
	
	  instance.registerHelper('blockHelperMissing', function(context, options) {
	    var inverse = options.inverse || function() {}, fn = options.fn;
	
	    if (isFunction(context)) { context = context.call(this); }
	
	    if(context === true) {
	      return fn(this);
	    } else if(context === false || context == null) {
	      return inverse(this);
	    } else if (isArray(context)) {
	      if(context.length > 0) {
	        return instance.helpers.each(context, options);
	      } else {
	        return inverse(this);
	      }
	    } else {
	      return fn(context);
	    }
	  });
	
	  instance.registerHelper('each', function(context, options) {
	    var fn = options.fn, inverse = options.inverse;
	    var i = 0, ret = "", data;
	
	    if (isFunction(context)) { context = context.call(this); }
	
	    if (options.data) {
	      data = createFrame(options.data);
	    }
	
	    if(context && typeof context === 'object') {
	      if (isArray(context)) {
	        for(var j = context.length; i<j; i++) {
	          if (data) {
	            data.index = i;
	            data.first = (i === 0);
	            data.last  = (i === (context.length-1));
	          }
	          ret = ret + fn(context[i], { data: data });
	        }
	      } else {
	        for(var key in context) {
	          if(context.hasOwnProperty(key)) {
	            if(data) { 
	              data.key = key; 
	              data.index = i;
	              data.first = (i === 0);
	            }
	            ret = ret + fn(context[key], {data: data});
	            i++;
	          }
	        }
	      }
	    }
	
	    if(i === 0){
	      ret = inverse(this);
	    }
	
	    return ret;
	  });
	
	  instance.registerHelper('if', function(conditional, options) {
	    if (isFunction(conditional)) { conditional = conditional.call(this); }
	
	    // Default behavior is to render the positive path if the value is truthy and not empty.
	    // The `includeZero` option may be set to treat the condtional as purely not empty based on the
	    // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
	    if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
	      return options.inverse(this);
	    } else {
	      return options.fn(this);
	    }
	  });
	
	  instance.registerHelper('unless', function(conditional, options) {
	    return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
	  });
	
	  instance.registerHelper('with', function(context, options) {
	    if (isFunction(context)) { context = context.call(this); }
	
	    if (!Utils.isEmpty(context)) return options.fn(context);
	  });
	
	  instance.registerHelper('log', function(context, options) {
	    var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
	    instance.log(level, context);
	  });
	}
	
	var logger = {
	  methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
	
	  // State enum
	  DEBUG: 0,
	  INFO: 1,
	  WARN: 2,
	  ERROR: 3,
	  level: 3,
	
	  // can be overridden in the host environment
	  log: function(level, obj) {
	    if (logger.level <= level) {
	      var method = logger.methodMap[level];
	      if (typeof console !== 'undefined' && console[method]) {
	        console[method].call(console, obj);
	      }
	    }
	  }
	};
	exports.logger = logger;
	function log(level, obj) { logger.log(level, obj); }
	
	exports.log = log;var createFrame = function(object) {
	  var obj = {};
	  Utils.extend(obj, object);
	  return obj;
	};
	exports.createFrame = createFrame;

/***/ },
/* 5 */
/***/ function(module, exports) {

	"use strict";
	
	var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
	
	function Exception(message, node) {
	  var line;
	  if (node && node.firstLine) {
	    line = node.firstLine;
	
	    message += ' - ' + line + ':' + node.firstColumn;
	  }
	
	  var tmp = Error.prototype.constructor.call(this, message);
	
	  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
	  for (var idx = 0; idx < errorProps.length; idx++) {
	    this[errorProps[idx]] = tmp[errorProps[idx]];
	  }
	
	  if (line) {
	    this.lineNumber = line;
	    this.column = node.firstColumn;
	  }
	}
	
	Exception.prototype = new Error();
	
	exports["default"] = Exception;

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	var stylesInDom = {},
		memoize = function(fn) {
			var memo;
			return function () {
				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
				return memo;
			};
		},
		isIE9 = memoize(function() {
			return /msie 9\b/.test(window.navigator.userAgent.toLowerCase());
		}),
		getHeadElement = memoize(function () {
			return document.head || document.getElementsByTagName("head")[0];
		}),
		singletonElement = null,
		singletonCounter = 0;
	
	module.exports = function(list, options) {
		if(false) {
			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
		}
	
		options = options || {};
		// Force single-tag solution on IE9, which has a hard limit on the # of <style>
		// tags it will allow on a page
		if (typeof options.singleton === "undefined") options.singleton = isIE9();
	
		var styles = listToStyles(list);
		addStylesToDom(styles, options);
	
		return function update(newList) {
			var mayRemove = [];
			for(var i = 0; i < styles.length; i++) {
				var item = styles[i];
				var domStyle = stylesInDom[item.id];
				domStyle.refs--;
				mayRemove.push(domStyle);
			}
			if(newList) {
				var newStyles = listToStyles(newList);
				addStylesToDom(newStyles, options);
			}
			for(var i = 0; i < mayRemove.length; i++) {
				var domStyle = mayRemove[i];
				if(domStyle.refs === 0) {
					for(var j = 0; j < domStyle.parts.length; j++)
						domStyle.parts[j]();
					delete stylesInDom[domStyle.id];
				}
			}
		};
	}
	
	function addStylesToDom(styles, options) {
		for(var i = 0; i < styles.length; i++) {
			var item = styles[i];
			var domStyle = stylesInDom[item.id];
			if(domStyle) {
				domStyle.refs++;
				for(var j = 0; j < domStyle.parts.length; j++) {
					domStyle.parts[j](item.parts[j]);
				}
				for(; j < item.parts.length; j++) {
					domStyle.parts.push(addStyle(item.parts[j], options));
				}
			} else {
				var parts = [];
				for(var j = 0; j < item.parts.length; j++) {
					parts.push(addStyle(item.parts[j], options));
				}
				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
			}
		}
	}
	
	function listToStyles(list) {
		var styles = [];
		var newStyles = {};
		for(var i = 0; i < list.length; i++) {
			var item = list[i];
			var id = item[0];
			var css = item[1];
			var media = item[2];
			var sourceMap = item[3];
			var part = {css: css, media: media, sourceMap: sourceMap};
			if(!newStyles[id])
				styles.push(newStyles[id] = {id: id, parts: [part]});
			else
				newStyles[id].parts.push(part);
		}
		return styles;
	}
	
	function createStyleElement() {
		var styleElement = document.createElement("style");
		var head = getHeadElement();
		styleElement.type = "text/css";
		head.appendChild(styleElement);
		return styleElement;
	}
	
	function addStyle(obj, options) {
		var styleElement, update, remove;
	
		if (options.singleton) {
			var styleIndex = singletonCounter++;
			styleElement = singletonElement || (singletonElement = createStyleElement());
			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
		} else {
			styleElement = createStyleElement();
			update = applyToTag.bind(null, styleElement);
			remove = function () {
				styleElement.parentNode.removeChild(styleElement);
			};
		}
	
		update(obj);
	
		return function updateStyle(newObj) {
			if(newObj) {
				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
					return;
				update(obj = newObj);
			} else {
				remove();
			}
		};
	}
	
	function replaceText(source, id, replacement) {
		var boundaries = ["/** >>" + id + " **/", "/** " + id + "<< **/"];
		var start = source.lastIndexOf(boundaries[0]);
		var wrappedReplacement = replacement
			? (boundaries[0] + replacement + boundaries[1])
			: "";
		if (source.lastIndexOf(boundaries[0]) >= 0) {
			var end = source.lastIndexOf(boundaries[1]) + boundaries[1].length;
			return source.slice(0, start) + wrappedReplacement + source.slice(end);
		} else {
			return source + wrappedReplacement;
		}
	}
	
	function applyToSingletonTag(styleElement, index, remove, obj) {
		var css = remove ? "" : obj.css;
	
		if(styleElement.styleSheet) {
			styleElement.styleSheet.cssText = replaceText(styleElement.styleSheet.cssText, index, css);
		} else {
			var cssNode = document.createTextNode(css);
			var childNodes = styleElement.childNodes;
			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
			if (childNodes.length) {
				styleElement.insertBefore(cssNode, childNodes[index]);
			} else {
				styleElement.appendChild(cssNode);
			}
		}
	}
	
	function applyToTag(styleElement, obj) {
		var css = obj.css;
		var media = obj.media;
		var sourceMap = obj.sourceMap;
	
		if(sourceMap && typeof btoa === "function") {
			try {
				css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(JSON.stringify(sourceMap)) + " */";
				css = "@import url(\"data:text/css;base64," + btoa(css) + "\")";
			} catch(e) {}
		}
	
		if(media) {
			styleElement.setAttribute("media", media)
		}
	
		if(styleElement.styleSheet) {
			styleElement.styleSheet.cssText = css;
		} else {
			while(styleElement.firstChild) {
				styleElement.removeChild(styleElement.firstChild);
			}
			styleElement.appendChild(document.createTextNode(css));
		}
	}


/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	// Switchable
	// -----------
	// 可切换组件，核心特征是：有一组可切换的面板（Panel），可通过触点（Trigger）来触发。
	// 感谢：
	//  - https://github.com/kissyteam/kissy/tree/6707ecc4cdfddd59e21698c8eb4a50b65dbe7632/src/switchable
	
	var $ = __webpack_require__(2);
	var Widget = __webpack_require__(20);
	
	var Effects = __webpack_require__(18);
	var Autoplay = __webpack_require__(52);
	var Circular = __webpack_require__(53);
	
	var Switchable = Widget.extend({
	  attrs: {
	
	    // 用户传入的 triggers 和 panels
	    // 可以是 Selector、jQuery 对象、或 DOM 元素集
	    triggers: {
	      value: [],
	      getter: function (val) {
	        return $(val);
	      }
	    },
	
	    panels: {
	      value: [],
	      getter: function (val) {
	        return $(val);
	      }
	    },
	
	    classPrefix: 'ui-switchable',
	
	    // 是否包含 triggers，用于没有传入 triggers 时，是否自动生成的判断标准
	    hasTriggers: true,
	    // 触发类型
	    triggerType: 'hover',
	    // or 'click'
	    // 触发延迟
	    delay: 100,
	
	    // 初始切换到哪个面板
	    activeIndex: {
	      value: 0,
	      setter: function (val) {
	        return parseInt(val) || 0;
	      }
	    },
	
	    // 一屏内有多少个 panels
	    step: 1,
	    // 有多少屏
	    length: {
	      readOnly: true,
	      getter: function () {
	        return Math.ceil(this.get('panels').length / this.get('step'));
	      }
	    },
	
	    // 可见视图区域的大小。一般不需要设定此值，仅当获取值不正确时，用于手工指定大小
	    viewSize: [],
	
	    activeTriggerClass: {
	      getter: function (val) {
	        return val ? val : this.get("classPrefix") + '-active';
	      }
	    }
	  },
	
	  setup: function () {
	    this._initConstClass();
	    this._initElement();
	
	    var role = this._getDatasetRole();
	    this._initPanels(role);
	    // 配置中的 triggers > dataset > 自动生成
	    this._initTriggers(role);
	    this._bindTriggers();
	    this._initPlugins();
	
	    // 渲染默认初始状态
	    this.render();
	  },
	
	  _initConstClass: function () {
	    this.CONST = constClass(this.get('classPrefix'));
	  },
	  _initElement: function () {
	    this.element.addClass(this.CONST.UI_SWITCHABLE);
	  },
	
	  // 从 HTML 标记中获取各个 role, 替代原来的 markupType
	  _getDatasetRole: function () {
	    var self = this;
	    var role = {};
	    var roles = ['trigger', 'panel', 'nav', 'content'];
	    $.each(roles, function (index, key) {
	      var elems = self.$('[data-role=' + key + ']');
	      if (elems.length) {
	        role[key] = elems;
	      }
	    });
	    return role;
	  },
	
	  _initPanels: function (role) {
	    var panels = this.get('panels');
	
	    // 先获取 panels 和 content
	    if (panels.length > 0) {} else if (role.panel) {
	      this.set('panels', panels = role.panel);
	    } else if (role.content) {
	      this.set('panels', panels = role.content.find('> *'));
	      this.content = role.content;
	    }
	
	    if (panels.length === 0) {
	      throw new Error('panels.length is ZERO');
	    }
	    if (!this.content) {
	      this.content = panels.parent();
	    }
	    this.content.addClass(this.CONST.CONTENT_CLASS);
	    this.get('panels').addClass(this.CONST.PANEL_CLASS);
	  },
	
	  _initTriggers: function (role) {
	    var triggers = this.get('triggers');
	
	    // 再获取 triggers 和 nav
	    if (triggers.length > 0) {}
	    // attr 里没找到时，才根据 data-role 来解析
	    else if (role.trigger) {
	      this.set('triggers', triggers = role.trigger);
	    } else if (role.nav) {
	      triggers = role.nav.find('> *');
	
	      // 空的 nav 标记
	      if (triggers.length === 0) {
	        triggers = generateTriggersMarkup(
	        this.get('length'), this.get('activeIndex'), this.get('activeTriggerClass'), true).appendTo(role.nav);
	      }
	      this.set('triggers', triggers);
	
	      this.nav = role.nav;
	    }
	    // 用户没有传入 triggers，也没有通过 data-role 指定时，如果
	    // hasTriggers 为 true，则自动生成 triggers
	    else if (this.get('hasTriggers')) {
	      this.nav = generateTriggersMarkup(
	      this.get('length'), this.get('activeIndex'), this.get('activeTriggerClass')).appendTo(this.element);
	      this.set('triggers', triggers = this.nav.children());
	    }
	
	    if (!this.nav && triggers.length) {
	      this.nav = triggers.parent();
	    }
	
	    this.nav && this.nav.addClass(this.CONST.NAV_CLASS);
	    triggers.addClass(this.CONST.TRIGGER_CLASS).each(function (i, trigger) {
	      $(trigger).data('value', i);
	    });
	  },
	
	  _bindTriggers: function () {
	    var that = this,
	        triggers = this.get('triggers');
	
	    if (this.get('triggerType') === 'click') {
	      triggers.click(focus);
	    }
	    // hover
	    else {
	      triggers.hover(focus, leave);
	    }
	
	    function focus(ev) {
	      that._onFocusTrigger(ev.type, $(this).data('value'));
	    }
	
	    function leave() {
	      clearTimeout(that._switchTimer);
	    }
	  },
	
	  _onFocusTrigger: function (type, index) {
	    var that = this;
	
	    // click or tab 键激活时
	    if (type === 'click') {
	      this.switchTo(index);
	    }
	
	    // hover
	    else {
	      this._switchTimer = setTimeout(function () {
	        that.switchTo(index);
	      }, this.get('delay'));
	    }
	  },
	
	  _initPlugins: function () {
	    this._plugins = [];
	
	    this._plug(Effects);
	    this._plug(Autoplay);
	    this._plug(Circular);
	  },
	  // 切换到指定 index
	  switchTo: function (toIndex) {
	    this.set('activeIndex', toIndex);
	  },
	
	  // change 事件触发的前提是当前值和先前值不一致, 所以无需验证 toIndex !== fromIndex
	  _onRenderActiveIndex: function (toIndex, fromIndex) {
	    this._switchTo(toIndex, fromIndex);
	  },
	
	  _switchTo: function (toIndex, fromIndex) {
	    this.trigger('switch', toIndex, fromIndex);
	    this._switchTrigger(toIndex, fromIndex);
	    this._switchPanel(this._getPanelInfo(toIndex, fromIndex));
	    this.trigger('switched', toIndex, fromIndex);
	
	    // 恢复手工向后切换标识
	    this._isBackward = undefined;
	  },
	
	  _switchTrigger: function (toIndex, fromIndex) {
	    var triggers = this.get('triggers');
	    if (triggers.length < 1) return;
	
	    triggers.eq(fromIndex).removeClass(this.get('activeTriggerClass'));
	    triggers.eq(toIndex).addClass(this.get('activeTriggerClass'));
	  },
	
	  _switchPanel: function (panelInfo) {
	    // 默认是最简单的切换效果：直接隐藏/显示
	    panelInfo.fromPanels.hide();
	    panelInfo.toPanels.show();
	  },
	
	  _getPanelInfo: function (toIndex, fromIndex) {
	    var panels = this.get('panels').get();
	    var step = this.get('step');
	
	    var fromPanels, toPanels;
	
	    // 初始情况下 fromIndex 为 undefined
	    if (fromIndex > -1) {
	      fromPanels = panels.slice(fromIndex * step, (fromIndex + 1) * step);
	    }
	
	    toPanels = panels.slice(toIndex * step, (toIndex + 1) * step);
	
	    return {
	      toIndex: toIndex,
	      fromIndex: fromIndex,
	      toPanels: $(toPanels),
	      fromPanels: $(fromPanels)
	    };
	  },
	
	  // 切换到上一视图
	  prev: function () {
	    //  设置手工向后切换标识, 外部调用 prev 一样
	    this._isBackward = true;
	
	    var fromIndex = this.get('activeIndex');
	    // 考虑循环切换的情况
	    var index = (fromIndex - 1 + this.get('length')) % this.get('length');
	    this.switchTo(index);
	  },
	
	  // 切换到下一视图
	  next: function () {
	    this._isBackward = false;
	
	    var fromIndex = this.get('activeIndex');
	    var index = (fromIndex + 1) % this.get('length');
	    this.switchTo(index);
	  },
	
	  _plug: function (plugin) {
	    var pluginAttrs = plugin.attrs;
	
	    if (pluginAttrs) {
	      for (var key in pluginAttrs) {
	        if (pluginAttrs.hasOwnProperty(key) &&
	        // 不覆盖用户传入的配置
	        !(key in this.attrs)) {
	          this.set(key, pluginAttrs[key]);
	        }
	      }
	    }
	    if (!plugin.isNeeded.call(this)) return;
	
	
	    if (plugin.install) {
	      plugin.install.call(this);
	    }
	
	    this._plugins.push(plugin);
	  },
	
	
	  destroy: function () {
	    // todo: events
	    var that = this;
	
	    $.each(this._plugins, function (i, plugin) {
	      if (plugin.destroy) {
	        plugin.destroy.call(that);
	      }
	    });
	
	    Switchable.superclass.destroy.call(this);
	  }
	});
	
	module.exports = Switchable;
	
	
	// Helpers
	// -------
	
	function generateTriggersMarkup(length, activeIndex, activeTriggerClass, justChildren) {
	  var nav = $('<ul>');
	
	  for (var i = 0; i < length; i++) {
	    var className = i === activeIndex ? activeTriggerClass : '';
	
	    $('<li>', {
	      'class': className,
	      'html': i + 1
	    }).appendTo(nav);
	  }
	
	  return justChildren ? nav.children() : nav;
	}
	
	
	// 内部默认的 className
	
	
	function constClass(classPrefix) {
	  return {
	    UI_SWITCHABLE: classPrefix || '',
	    NAV_CLASS: classPrefix ? classPrefix + '-nav' : '',
	    CONTENT_CLASS: classPrefix ? classPrefix + '-content' : '',
	    TRIGGER_CLASS: classPrefix ? classPrefix + '-trigger' : '',
	    PANEL_CLASS: classPrefix ? classPrefix + '-panel' : '',
	    PREV_BTN_CLASS: classPrefix ? classPrefix + '-prev-btn' : '',
	    NEXT_BTN_CLASS: classPrefix ? classPrefix + '-next-btn' : ''
	  }
	}

/***/ },
/* 8 */
/***/ function(module, exports) {

	'use strict';
	
	exports.__esModule = true;
	
	var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
	
	function Exception(message, node) {
	  var loc = node && node.loc,
	      line = undefined,
	      column = undefined;
	  if (loc) {
	    line = loc.start.line;
	    column = loc.start.column;
	
	    message += ' - ' + line + ':' + column;
	  }
	
	  var tmp = Error.prototype.constructor.call(this, message);
	
	  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
	  for (var idx = 0; idx < errorProps.length; idx++) {
	    this[errorProps[idx]] = tmp[errorProps[idx]];
	  }
	
	  /* istanbul ignore else */
	  if (Error.captureStackTrace) {
	    Error.captureStackTrace(this, Exception);
	  }
	
	  try {
	    if (loc) {
	      this.lineNumber = line;
	
	      // Work around issue under safari where we can't directly set the column value
	      /* istanbul ignore next */
	      if (Object.defineProperty) {
	        Object.defineProperty(this, 'column', {
	          value: column,
	          enumerable: true
	        });
	      } else {
	        this.column = column;
	      }
	    }
	  } catch (nop) {
	    /* Ignore if the browser is very particular */
	  }
	}
	
	Exception.prototype = new Error();
	
	exports['default'] = Exception;
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(41);


/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(16);
	module.exports.Mask = __webpack_require__(47);


/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Exception = __webpack_require__(5)["default"];
	
	function Compiler() {}
	
	exports.Compiler = Compiler;// the foundHelper register will disambiguate helper lookup from finding a
	// function in a context. This is necessary for mustache compatibility, which
	// requires that context functions in blocks are evaluated by blockHelperMissing,
	// and then proceed as if the resulting value was provided to blockHelperMissing.
	
	Compiler.prototype = {
	  compiler: Compiler,
	
	  disassemble: function() {
	    var opcodes = this.opcodes, opcode, out = [], params, param;
	
	    for (var i=0, l=opcodes.length; i<l; i++) {
	      opcode = opcodes[i];
	
	      if (opcode.opcode === 'DECLARE') {
	        out.push("DECLARE " + opcode.name + "=" + opcode.value);
	      } else {
	        params = [];
	        for (var j=0; j<opcode.args.length; j++) {
	          param = opcode.args[j];
	          if (typeof param === "string") {
	            param = "\"" + param.replace("\n", "\\n") + "\"";
	          }
	          params.push(param);
	        }
	        out.push(opcode.opcode + " " + params.join(" "));
	      }
	    }
	
	    return out.join("\n");
	  },
	
	  equals: function(other) {
	    var len = this.opcodes.length;
	    if (other.opcodes.length !== len) {
	      return false;
	    }
	
	    for (var i = 0; i < len; i++) {
	      var opcode = this.opcodes[i],
	          otherOpcode = other.opcodes[i];
	      if (opcode.opcode !== otherOpcode.opcode || opcode.args.length !== otherOpcode.args.length) {
	        return false;
	      }
	      for (var j = 0; j < opcode.args.length; j++) {
	        if (opcode.args[j] !== otherOpcode.args[j]) {
	          return false;
	        }
	      }
	    }
	
	    len = this.children.length;
	    if (other.children.length !== len) {
	      return false;
	    }
	    for (i = 0; i < len; i++) {
	      if (!this.children[i].equals(other.children[i])) {
	        return false;
	      }
	    }
	
	    return true;
	  },
	
	  guid: 0,
	
	  compile: function(program, options) {
	    this.opcodes = [];
	    this.children = [];
	    this.depths = {list: []};
	    this.options = options;
	
	    // These changes will propagate to the other compiler components
	    var knownHelpers = this.options.knownHelpers;
	    this.options.knownHelpers = {
	      'helperMissing': true,
	      'blockHelperMissing': true,
	      'each': true,
	      'if': true,
	      'unless': true,
	      'with': true,
	      'log': true
	    };
	    if (knownHelpers) {
	      for (var name in knownHelpers) {
	        this.options.knownHelpers[name] = knownHelpers[name];
	      }
	    }
	
	    return this.accept(program);
	  },
	
	  accept: function(node) {
	    var strip = node.strip || {},
	        ret;
	    if (strip.left) {
	      this.opcode('strip');
	    }
	
	    ret = this[node.type](node);
	
	    if (strip.right) {
	      this.opcode('strip');
	    }
	
	    return ret;
	  },
	
	  program: function(program) {
	    var statements = program.statements;
	
	    for(var i=0, l=statements.length; i<l; i++) {
	      this.accept(statements[i]);
	    }
	    this.isSimple = l === 1;
	
	    this.depths.list = this.depths.list.sort(function(a, b) {
	      return a - b;
	    });
	
	    return this;
	  },
	
	  compileProgram: function(program) {
	    var result = new this.compiler().compile(program, this.options);
	    var guid = this.guid++, depth;
	
	    this.usePartial = this.usePartial || result.usePartial;
	
	    this.children[guid] = result;
	
	    for(var i=0, l=result.depths.list.length; i<l; i++) {
	      depth = result.depths.list[i];
	
	      if(depth < 2) { continue; }
	      else { this.addDepth(depth - 1); }
	    }
	
	    return guid;
	  },
	
	  block: function(block) {
	    var mustache = block.mustache,
	        program = block.program,
	        inverse = block.inverse;
	
	    if (program) {
	      program = this.compileProgram(program);
	    }
	
	    if (inverse) {
	      inverse = this.compileProgram(inverse);
	    }
	
	    var sexpr = mustache.sexpr;
	    var type = this.classifySexpr(sexpr);
	
	    if (type === "helper") {
	      this.helperSexpr(sexpr, program, inverse);
	    } else if (type === "simple") {
	      this.simpleSexpr(sexpr);
	
	      // now that the simple mustache is resolved, we need to
	      // evaluate it by executing `blockHelperMissing`
	      this.opcode('pushProgram', program);
	      this.opcode('pushProgram', inverse);
	      this.opcode('emptyHash');
	      this.opcode('blockValue');
	    } else {
	      this.ambiguousSexpr(sexpr, program, inverse);
	
	      // now that the simple mustache is resolved, we need to
	      // evaluate it by executing `blockHelperMissing`
	      this.opcode('pushProgram', program);
	      this.opcode('pushProgram', inverse);
	      this.opcode('emptyHash');
	      this.opcode('ambiguousBlockValue');
	    }
	
	    this.opcode('append');
	  },
	
	  hash: function(hash) {
	    var pairs = hash.pairs, pair, val;
	
	    this.opcode('pushHash');
	
	    for(var i=0, l=pairs.length; i<l; i++) {
	      pair = pairs[i];
	      val  = pair[1];
	
	      if (this.options.stringParams) {
	        if(val.depth) {
	          this.addDepth(val.depth);
	        }
	        this.opcode('getContext', val.depth || 0);
	        this.opcode('pushStringParam', val.stringModeValue, val.type);
	
	        if (val.type === 'sexpr') {
	          // Subexpressions get evaluated and passed in
	          // in string params mode.
	          this.sexpr(val);
	        }
	      } else {
	        this.accept(val);
	      }
	
	      this.opcode('assignToHash', pair[0]);
	    }
	    this.opcode('popHash');
	  },
	
	  partial: function(partial) {
	    var partialName = partial.partialName;
	    this.usePartial = true;
	
	    if(partial.context) {
	      this.ID(partial.context);
	    } else {
	      this.opcode('push', 'depth0');
	    }
	
	    this.opcode('invokePartial', partialName.name);
	    this.opcode('append');
	  },
	
	  content: function(content) {
	    this.opcode('appendContent', content.string);
	  },
	
	  mustache: function(mustache) {
	    this.sexpr(mustache.sexpr);
	
	    if(mustache.escaped && !this.options.noEscape) {
	      this.opcode('appendEscaped');
	    } else {
	      this.opcode('append');
	    }
	  },
	
	  ambiguousSexpr: function(sexpr, program, inverse) {
	    var id = sexpr.id,
	        name = id.parts[0],
	        isBlock = program != null || inverse != null;
	
	    this.opcode('getContext', id.depth);
	
	    this.opcode('pushProgram', program);
	    this.opcode('pushProgram', inverse);
	
	    this.opcode('invokeAmbiguous', name, isBlock);
	  },
	
	  simpleSexpr: function(sexpr) {
	    var id = sexpr.id;
	
	    if (id.type === 'DATA') {
	      this.DATA(id);
	    } else if (id.parts.length) {
	      this.ID(id);
	    } else {
	      // Simplified ID for `this`
	      this.addDepth(id.depth);
	      this.opcode('getContext', id.depth);
	      this.opcode('pushContext');
	    }
	
	    this.opcode('resolvePossibleLambda');
	  },
	
	  helperSexpr: function(sexpr, program, inverse) {
	    var params = this.setupFullMustacheParams(sexpr, program, inverse),
	        name = sexpr.id.parts[0];
	
	    if (this.options.knownHelpers[name]) {
	      this.opcode('invokeKnownHelper', params.length, name);
	    } else if (this.options.knownHelpersOnly) {
	      throw new Exception("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
	    } else {
	      this.opcode('invokeHelper', params.length, name, sexpr.isRoot);
	    }
	  },
	
	  sexpr: function(sexpr) {
	    var type = this.classifySexpr(sexpr);
	
	    if (type === "simple") {
	      this.simpleSexpr(sexpr);
	    } else if (type === "helper") {
	      this.helperSexpr(sexpr);
	    } else {
	      this.ambiguousSexpr(sexpr);
	    }
	  },
	
	  ID: function(id) {
	    this.addDepth(id.depth);
	    this.opcode('getContext', id.depth);
	
	    var name = id.parts[0];
	    if (!name) {
	      this.opcode('pushContext');
	    } else {
	      this.opcode('lookupOnContext', id.parts[0]);
	    }
	
	    for(var i=1, l=id.parts.length; i<l; i++) {
	      this.opcode('lookup', id.parts[i]);
	    }
	  },
	
	  DATA: function(data) {
	    this.options.data = true;
	    if (data.id.isScoped || data.id.depth) {
	      throw new Exception('Scoped data references are not supported: ' + data.original, data);
	    }
	
	    this.opcode('lookupData');
	    var parts = data.id.parts;
	    for(var i=0, l=parts.length; i<l; i++) {
	      this.opcode('lookup', parts[i]);
	    }
	  },
	
	  STRING: function(string) {
	    this.opcode('pushString', string.string);
	  },
	
	  INTEGER: function(integer) {
	    this.opcode('pushLiteral', integer.integer);
	  },
	
	  BOOLEAN: function(bool) {
	    this.opcode('pushLiteral', bool.bool);
	  },
	
	  comment: function() {},
	
	  // HELPERS
	  opcode: function(name) {
	    this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
	  },
	
	  declare: function(name, value) {
	    this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
	  },
	
	  addDepth: function(depth) {
	    if(depth === 0) { return; }
	
	    if(!this.depths[depth]) {
	      this.depths[depth] = true;
	      this.depths.list.push(depth);
	    }
	  },
	
	  classifySexpr: function(sexpr) {
	    var isHelper   = sexpr.isHelper;
	    var isEligible = sexpr.eligibleHelper;
	    var options    = this.options;
	
	    // if ambiguous, we can possibly resolve the ambiguity now
	    if (isEligible && !isHelper) {
	      var name = sexpr.id.parts[0];
	
	      if (options.knownHelpers[name]) {
	        isHelper = true;
	      } else if (options.knownHelpersOnly) {
	        isEligible = false;
	      }
	    }
	
	    if (isHelper) { return "helper"; }
	    else if (isEligible) { return "ambiguous"; }
	    else { return "simple"; }
	  },
	
	  pushParams: function(params) {
	    var i = params.length, param;
	
	    while(i--) {
	      param = params[i];
	
	      if(this.options.stringParams) {
	        if(param.depth) {
	          this.addDepth(param.depth);
	        }
	
	        this.opcode('getContext', param.depth || 0);
	        this.opcode('pushStringParam', param.stringModeValue, param.type);
	
	        if (param.type === 'sexpr') {
	          // Subexpressions get evaluated and passed in
	          // in string params mode.
	          this.sexpr(param);
	        }
	      } else {
	        this[param.type](param);
	      }
	    }
	  },
	
	  setupFullMustacheParams: function(sexpr, program, inverse) {
	    var params = sexpr.params;
	    this.pushParams(params);
	
	    this.opcode('pushProgram', program);
	    this.opcode('pushProgram', inverse);
	
	    if (sexpr.hash) {
	      this.hash(sexpr.hash);
	    } else {
	      this.opcode('emptyHash');
	    }
	
	    return params;
	  }
	};
	
	function precompile(input, options, env) {
	  if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
	    throw new Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
	  }
	
	  options = options || {};
	  if (!('data' in options)) {
	    options.data = true;
	  }
	
	  var ast = env.parse(input);
	  var environment = new env.Compiler().compile(ast, options);
	  return new env.JavaScriptCompiler().compile(environment, options);
	}
	
	exports.precompile = precompile;function compile(input, options, env) {
	  if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
	    throw new Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
	  }
	
	  options = options || {};
	
	  if (!('data' in options)) {
	    options.data = true;
	  }
	
	  var compiled;
	
	  function compileInput() {
	    var ast = env.parse(input);
	    var environment = new env.Compiler().compile(ast, options);
	    var templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true);
	    return env.template(templateSpec);
	  }
	
	  // Template is only compiled on first use and cached after that point.
	  return function(context, options) {
	    if (!compiled) {
	      compiled = compileInput();
	    }
	    return compiled.call(this, context, options);
	  };
	}
	
	exports.compile = compile;

/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/*jshint -W004 */
	var SafeString = __webpack_require__(23)["default"];
	
	var escape = {
	  "&": "&amp;",
	  "<": "&lt;",
	  ">": "&gt;",
	  '"': "&quot;",
	  "'": "&#x27;",
	  "`": "&#x60;"
	};
	
	var badChars = /[&<>"'`]/g;
	var possible = /[&<>"'`]/;
	
	function escapeChar(chr) {
	  return escape[chr] || "&amp;";
	}
	
	function extend(obj, value) {
	  for(var key in value) {
	    if(Object.prototype.hasOwnProperty.call(value, key)) {
	      obj[key] = value[key];
	    }
	  }
	}
	
	exports.extend = extend;var toString = Object.prototype.toString;
	exports.toString = toString;
	// Sourced from lodash
	// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
	var isFunction = function(value) {
	  return typeof value === 'function';
	};
	// fallback for older versions of Chrome and Safari
	if (isFunction(/x/)) {
	  isFunction = function(value) {
	    return typeof value === 'function' && toString.call(value) === '[object Function]';
	  };
	}
	var isFunction;
	exports.isFunction = isFunction;
	var isArray = Array.isArray || function(value) {
	  return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
	};
	exports.isArray = isArray;
	
	function escapeExpression(string) {
	  // don't escape SafeStrings, since they're already safe
	  if (string instanceof SafeString) {
	    return string.toString();
	  } else if (!string && string !== 0) {
	    return "";
	  }
	
	  // Force a string conversion as this will be done by the append regardless and
	  // the regex test will do this transparently behind the scenes, causing issues if
	  // an object's to string has escaped characters in it.
	  string = "" + string;
	
	  if(!possible.test(string)) { return string; }
	  return string.replace(badChars, escapeChar);
	}
	
	exports.escapeExpression = escapeExpression;function isEmpty(value) {
	  if (!value && value !== 0) {
	    return true;
	  } else if (isArray(value) && value.length === 0) {
	    return true;
	  } else {
	    return false;
	  }
	}
	
	exports.isEmpty = isEmpty;

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	// Create a simple path alias to allow browserify to resolve
	// the runtime on a supported path.
	module.exports = __webpack_require__(95)['default'];


/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2),
	    Overlay = __webpack_require__(10),
	    mask = Overlay.Mask,
	    Events = __webpack_require__(15),
	    Templatable = __webpack_require__(19);
	
	// Dialog
	// ---
	// Dialog 是通用对话框组件，提供显隐关闭、遮罩层、内嵌iframe、内容区域自定义功能。
	// 是所有对话框类型组件的基类。
	var Dialog = Overlay.extend({
	
	  Implements: Templatable,
	
	  attrs: {
	    // 模板
	    template: __webpack_require__(33),
	
	    // 对话框触发点
	    trigger: {
	      value: null,
	      getter: function (val) {
	        return $(val);
	      }
	    },
	
	    // 统一样式前缀
	    classPrefix: 'ui-dialog',
	
	    // 指定内容元素，可以是 url 地址
	    content: {
	      value: null,
	      setter: function (val) {
	        // 判断是否是 url 地址
	        if (/^(https?:\/\/|\/|\.\/|\.\.\/)/.test(val)) {
	          this._type = 'iframe';
	          // 用 ajax 的方式而不是 iframe 进行载入
	          if (val.indexOf('?ajax') > 0 || val.indexOf('&ajax') > 0) {
	            this._ajax = true;
	          }
	        }
	        return val;
	      }
	    },
	
	    // 是否有背景遮罩层
	    hasMask: true,
	
	    // 关闭按钮可以自定义
	    closeTpl: '×',
	
	    // 默认宽度
	    width: 500,
	
	    // 默认高度
	    height: null,
	
	    // iframe 类型时，dialog 的最初高度
	    initialHeight: 300,
	
	    // 简单的动画效果 none | fade
	    effect: 'none',
	
	    // 不用解释了吧
	    zIndex: 999,
	
	    // 是否自适应高度
	    autoFit: true,
	
	    // 默认定位居中
	    align: {
	      value: {
	        selfXY: ['50%', '50%'],
	        baseXY: ['50%', '42%']
	      },
	      getter: function (val) {
	        // 高度超过一屏的情况
	        // https://github.com/aralejs/dialog/issues/41
	        if (this.element.height() > $(window).height()) {
	          return {
	            selfXY: ['50%', '0'],
	            baseXY: ['50%', '0']
	          };
	        }
	        return val;
	      }
	    }
	  },
	
	
	  parseElement: function () {
	    this.set("model", {
	      classPrefix: this.get('classPrefix')
	    });
	    Dialog.superclass.parseElement.call(this);
	    this.contentElement = this.$('[data-role=content]');
	
	    // 必要的样式
	    this.contentElement.css({
	      height: '100%',
	      zoom: 1
	    });
	    // 关闭按钮先隐藏
	    // 后面当 onRenderCloseTpl 时，如果 closeTpl 不为空，会显示出来
	    // 这样写是为了回避 arale.base 的一个问题：
	    // 当属性初始值为''时，不会进入 onRender 方法
	    // https://github.com/aralejs/base/issues/7
	    this.$('[data-role=close]').hide();
	  },
	
	  events: {
	    'click [data-role=close]': function (e) {
	      e.preventDefault();
	      this.hide();
	    }
	  },
	
	  show: function () {
	    // iframe 要在载入完成才显示
	    if (this._type === 'iframe') {
	      // ajax 读入内容并 append 到容器中
	      if (this._ajax) {
	        this._ajaxHtml();
	      } else {
	        // iframe 还未请求完，先设置一个固定高度
	        !this.get('height') && this.contentElement.css('height', this.get('initialHeight'));
	        this._showIframe();
	      }
	    }
	
	    Dialog.superclass.show.call(this);
	    return this;
	  },
	
	  hide: function () {
	    // 把 iframe 状态复原
	    if (this._type === 'iframe' && this.iframe) {
	      this.iframe.attr({
	        src: 'javascript:\'\';'
	      });
	      // 原来只是将 iframe 的状态复原
	      // 但是发现在 IE6 下，将 src 置为 javascript:''; 会出现 404 页面
	      this.iframe.remove();
	      this.iframe = null;
	    }
	
	    Dialog.superclass.hide.call(this);
	    clearInterval(this._interval);
	    delete this._interval;
	    return this;
	  },
	
	  destroy: function () {
	    this.element.remove();
	    this._hideMask();
	    clearInterval(this._interval);
	    return Dialog.superclass.destroy.call(this);
	  },
	
	  setup: function () {
	    Dialog.superclass.setup.call(this);
	
	    this._setupTrigger();
	    this._setupMask();
	    this._setupKeyEvents();
	    this._setupFocus();
	    toTabed(this.element);
	    toTabed(this.get('trigger'));
	
	    // 默认当前触发器
	    this.activeTrigger = this.get('trigger').eq(0);
	  },
	
	  // onRender
	  // ---
	  _onRenderContent: function (val) {
	    if (this._type !== 'iframe') {
	      var value;
	      // 有些情况会报错
	      try {
	        value = $(val);
	      } catch (e) {
	        value = [];
	      }
	      if (value[0]) {
	        this.contentElement.empty().append(value);
	      } else {
	        this.contentElement.empty().html(val);
	      }
	      // #38 #44
	      this._setPosition();
	    }
	  },
	
	  _onRenderCloseTpl: function (val) {
	    if (val === '') {
	      this.$('[data-role=close]').html(val).hide();
	    } else {
	      this.$('[data-role=close]').html(val).show();
	    }
	  },
	
	  // 覆盖 overlay，提供动画
	  _onRenderVisible: function (val) {
	    if (val) {
	      if (this.get('effect') === 'fade') {
	        // 固定 300 的动画时长，暂不可定制
	        this.element.fadeIn(300);
	      } else {
	        this.element.show();
	      }
	    } else {
	      this.element.hide();
	    }
	  },
	
	  // 私有方法
	  // ---
	  // 绑定触发对话框出现的事件
	  _setupTrigger: function () {
	    this.delegateEvents(this.get('trigger'), 'click', function (e) {
	      e.preventDefault();
	      // 标识当前点击的元素
	      this.activeTrigger = $(e.currentTarget);
	      this.show();
	    });
	  },
	
	  // 绑定遮罩层事件
	  _setupMask: function () {
	    var that = this;
	
	    // 存放 mask 对应的对话框
	    mask._dialogs = mask._dialogs || [];
	
	    this.after('show', function () {
	      if (!this.get('hasMask')) {
	        return;
	      }
	      // not using the z-index
	      // because multiable dialogs may share same mask
	      mask.set('zIndex', that.get('zIndex')).show();
	      mask.element.insertBefore(that.element);
	
	      // 避免重复存放
	      var existed = false;
	      for (var i = 0; i < mask._dialogs.length; i++) {
	        if (mask._dialogs[i] === that) {
	          existed = true;
	        }
	      }
	      // 依次存放对应的对话框
	      if (!existed) {
	        mask._dialogs.push(that);
	      }
	    });
	
	    this.after('hide', this._hideMask);
	  },
	
	  // 隐藏 mask
	  _hideMask: function () {
	    if (!this.get('hasMask')) {
	      return;
	    }
	
	    mask._dialogs && mask._dialogs.pop();
	    if (mask._dialogs && mask._dialogs.length > 0) {
	      var last = mask._dialogs[mask._dialogs.length - 1];
	      mask.set('zIndex', last.get('zIndex'));
	      mask.element.insertBefore(last.element);
	    } else {
	      mask.hide();
	    }
	  },
	
	  // 绑定元素聚焦状态
	  _setupFocus: function () {
	    this.after('show', function () {
	      this.element.focus();
	    });
	    this.after('hide', function () {
	      // 关于网页中浮层消失后的焦点处理
	      // http://www.qt06.com/post/280/
	      this.activeTrigger && this.activeTrigger.focus();
	    });
	  },
	
	  // 绑定键盘事件，ESC关闭窗口
	  _setupKeyEvents: function () {
	    this.delegateEvents($(document), 'keyup.esc', function (e) {
	      if (e.keyCode === 27) {
	        this.get('visible') && this.hide();
	      }
	    });
	  },
	
	  _showIframe: function () {
	    var that = this;
	    // 若未创建则新建一个
	    if (!this.iframe) {
	      this._createIframe();
	    }
	    // 开始请求 iframe
	    this.iframe.attr({
	      src: this._fixUrl(),
	      name: 'dialog-iframe' + new Date().getTime()
	    });
	    // 因为在 IE 下 onload 无法触发
	    // http://my.oschina.net/liangrockman/blog/24015
	    // 所以使用 jquery 的 one 函数来代替 onload
	    // one 比 on 好，因为它只执行一次，并在执行后自动销毁
	    this.iframe.one('load', function () {
	      // 如果 dialog 已经隐藏了，就不需要触发 onload
	      if (!that.get('visible')) {
	        return;
	      }
	      // 绑定自动处理高度的事件
	      if (that.get('autoFit')) {
	        clearInterval(that._interval);
	        that._interval = setInterval(function () {
	          that._syncHeight();
	        }, 300);
	      }
	      that._syncHeight();
	      that._setPosition();
	      that.trigger('complete:show');
	    });
	  },
	
	  _fixUrl: function () {
	    var s = this.get('content').match(/([^?#]*)(\?[^#]*)?(#.*)?/);
	    s.shift();
	    s[1] = ((s[1] && s[1] !== '?') ? (s[1] + '&') : '?') + 't=' + new Date().getTime();
	    return s.join('');
	  },
	
	  _createIframe: function () {
	    var that = this;
	
	    this.iframe = $('<iframe>', {
	      src: 'javascript:\'\';',
	      scrolling: 'no',
	      frameborder: 'no',
	      allowTransparency: 'true',
	      css: {
	        border: 'none',
	        width: '100%',
	        display: 'block',
	        height: '100%',
	        overflow: 'hidden'
	      }
	    }).appendTo(this.contentElement);
	
	    // 给 iframe 绑一个 close 事件
	    // iframe 内部可通过 window.frameElement.trigger('close') 关闭
	    Events.mixTo(this.iframe[0]);
	    this.iframe[0].on('close', function () {
	      that.hide();
	    });
	  },
	
	  _syncHeight: function () {
	    var h;
	    // 如果未传 height，才会自动获取
	    if (!this.get('height')) {
	      try {
	        this._errCount = 0;
	        h = getIframeHeight(this.iframe) + 'px';
	      } catch (err) {
	        // 页面跳转也会抛错，最多失败6次
	        this._errCount = (this._errCount || 0) + 1;
	        if (this._errCount >= 6) {
	          // 获取失败则给默认高度 300px
	          // 跨域会抛错进入这个流程
	          h = this.get('initialHeight');
	          clearInterval(this._interval);
	          delete this._interval;
	        }
	      }
	      this.contentElement.css('height', h);
	      // force to reflow in ie6
	      // http://44ux.com/blog/2011/08/24/ie67-reflow-bug/
	      this.element[0].className = this.element[0].className;
	    } else {
	      clearInterval(this._interval);
	      delete this._interval;
	    }
	  },
	
	  _ajaxHtml: function () {
	    var that = this;
	    this.contentElement.css('height', this.get('initialHeight'));
	    this.contentElement.load(this.get('content'), function () {
	      that._setPosition();
	      that.contentElement.css('height', '');
	      that.trigger('complete:show');
	    });
	  }
	
	});
	
	module.exports = Dialog;
	
	// Helpers
	// ----
	// 让目标节点可以被 Tab
	
	
	function toTabed(element) {
	  if (element.attr('tabindex') == null) {
	    element.attr('tabindex', '-1');
	  }
	}
	
	// 获取 iframe 内部的高度
	
	
	function getIframeHeight(iframe) {
	  var D = iframe[0].contentWindow.document;
	  if (D.body.scrollHeight && D.documentElement.scrollHeight) {
	    return Math.min(
	    D.body.scrollHeight, D.documentElement.scrollHeight);
	  } else if (D.documentElement.scrollHeight) {
	    return D.documentElement.scrollHeight;
	  } else if (D.body.scrollHeight) {
	    return D.body.scrollHeight;
	  }
	}


/***/ },
/* 15 */
/***/ function(module, exports) {

	// Events
	// -----------------
	// Thanks to:
	//  - https://github.com/documentcloud/backbone/blob/master/backbone.js
	//  - https://github.com/joyent/node/blob/master/lib/events.js
	
	
	// Regular expression used to split event strings
	var eventSplitter = /\s+/
	
	
	// A module that can be mixed in to *any object* in order to provide it
	// with custom events. You may bind with `on` or remove with `off` callback
	// functions to an event; `trigger`-ing an event fires all callbacks in
	// succession.
	//
	//     var object = new Events();
	//     object.on('expand', function(){ alert('expanded'); });
	//     object.trigger('expand');
	//
	function Events() {
	}
	
	
	// Bind one or more space separated events, `events`, to a `callback`
	// function. Passing `"all"` will bind the callback to all events fired.
	Events.prototype.on = function(events, callback, context) {
	  var cache, event, list
	  if (!callback) return this
	
	  cache = this.__events || (this.__events = {})
	  events = events.split(eventSplitter)
	
	  while (event = events.shift()) {
	    list = cache[event] || (cache[event] = [])
	    list.push(callback, context)
	  }
	
	  return this
	}
	
	Events.prototype.once = function(events, callback, context) {
	  var that = this
	  var cb = function() {
	    that.off(events, cb)
	    callback.apply(context || that, arguments)
	  }
	  return this.on(events, cb, context)
	}
	
	// Remove one or many callbacks. If `context` is null, removes all callbacks
	// with that function. If `callback` is null, removes all callbacks for the
	// event. If `events` is null, removes all bound callbacks for all events.
	Events.prototype.off = function(events, callback, context) {
	  var cache, event, list, i
	
	  // No events, or removing *all* events.
	  if (!(cache = this.__events)) return this
	  if (!(events || callback || context)) {
	    delete this.__events
	    return this
	  }
	
	  events = events ? events.split(eventSplitter) : keys(cache)
	
	  // Loop through the callback list, splicing where appropriate.
	  while (event = events.shift()) {
	    list = cache[event]
	    if (!list) continue
	
	    if (!(callback || context)) {
	      delete cache[event]
	      continue
	    }
	
	    for (i = list.length - 2; i >= 0; i -= 2) {
	      if (!(callback && list[i] !== callback ||
	          context && list[i + 1] !== context)) {
	        list.splice(i, 2)
	      }
	    }
	  }
	
	  return this
	}
	
	
	// Trigger one or many events, firing all bound callbacks. Callbacks are
	// passed the same arguments as `trigger` is, apart from the event name
	// (unless you're listening on `"all"`, which will cause your callback to
	// receive the true name of the event as the first argument).
	Events.prototype.trigger = function(events) {
	  var cache, event, all, list, i, len, rest = [], args, returned = true;
	  if (!(cache = this.__events)) return this
	
	  events = events.split(eventSplitter)
	
	  // Fill up `rest` with the callback arguments.  Since we're only copying
	  // the tail of `arguments`, a loop is much faster than Array#slice.
	  for (i = 1, len = arguments.length; i < len; i++) {
	    rest[i - 1] = arguments[i]
	  }
	
	  // For each event, walk through the list of callbacks twice, first to
	  // trigger the event, then to trigger any `"all"` callbacks.
	  while (event = events.shift()) {
	    // Copy callback lists to prevent modification.
	    if (all = cache.all) all = all.slice()
	    if (list = cache[event]) list = list.slice()
	
	    // Execute event callbacks except one named "all"
	    if (event !== 'all') {
	      returned = triggerEvents(list, rest, this) && returned
	    }
	
	    // Execute "all" callbacks.
	    returned = triggerEvents(all, [event].concat(rest), this) && returned
	  }
	
	  return returned
	}
	
	Events.prototype.emit = Events.prototype.trigger
	
	
	// Helpers
	// -------
	
	var keys = Object.keys
	
	if (!keys) {
	  keys = function(o) {
	    var result = []
	
	    for (var name in o) {
	      if (o.hasOwnProperty(name)) {
	        result.push(name)
	      }
	    }
	    return result
	  }
	}
	
	// Mix `Events` to object instance or Class function.
	Events.mixTo = function(receiver) {
	  receiver = isFunction(receiver) ? receiver.prototype : receiver
	  var proto = Events.prototype
	
	  var event = new Events
	  for (var key in proto) {
	    if (proto.hasOwnProperty(key)) {
	      copyProto(key)
	    }
	  }
	
	  function copyProto(key) {
	    receiver[key] = function() {
	      proto[key].apply(event, Array.prototype.slice.call(arguments))
	      return this
	    }
	  }
	}
	
	// Execute callbacks
	function triggerEvents(list, args, context) {
	  var pass = true
	
	  if (list) {
	    var i = 0, l = list.length, a1 = args[0], a2 = args[1], a3 = args[2]
	    // call is faster than apply, optimize less than 3 argu
	    // http://blog.csdn.net/zhengyinhui100/article/details/7837127
	    switch (args.length) {
	      case 0: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context) !== false && pass} break;
	      case 1: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1) !== false && pass} break;
	      case 2: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1, a2) !== false && pass} break;
	      case 3: for (; i < l; i += 2) {pass = list[i].call(list[i + 1] || context, a1, a2, a3) !== false && pass} break;
	      default: for (; i < l; i += 2) {pass = list[i].apply(list[i + 1] || context, args) !== false && pass} break;
	    }
	  }
	  // trigger will return false if one of the callbacks return false
	  return pass;
	}
	
	function isFunction(func) {
	  return Object.prototype.toString.call(func) === '[object Function]'
	}
	
	module.exports = Events


/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2),
	    Position = __webpack_require__(24),
	    Shim = __webpack_require__(46),
	    Widget = __webpack_require__(20);
	
	
	// Overlay
	// -------
	// Overlay 组件的核心特点是可定位（Positionable）和可层叠（Stackable）
	// 是一切悬浮类 UI 组件的基类
	var Overlay = Widget.extend({
	
	  attrs: {
	    // 基本属性
	    width: null,
	    height: null,
	    zIndex: 99,
	    visible: false,
	
	    // 定位配置
	    align: {
	      // element 的定位点，默认为左上角
	      selfXY: [0, 0],
	      // 基准定位元素，默认为当前可视区域
	      baseElement: Position.VIEWPORT,
	      // 基准定位元素的定位点，默认为左上角
	      baseXY: [0, 0]
	    },
	
	    // 父元素
	    parentNode: document.body
	  },
	
	  show: function () {
	    // 若从未渲染，则调用 render
	    if (!this.rendered) {
	      this.render();
	    }
	    this.set('visible', true);
	    return this;
	  },
	
	  hide: function () {
	    this.set('visible', false);
	    return this;
	  },
	
	  setup: function () {
	    var that = this;
	    // 加载 iframe 遮罩层并与 overlay 保持同步
	    this._setupShim();
	    // 窗口resize时，重新定位浮层
	    this._setupResize();
	
	    this.after('render', function () {
	      var _pos = this.element.css('position');
	      if (_pos === 'static' || _pos === 'relative') {
	        this.element.css({
	          position: 'absolute',
	          left: '-9999px',
	          top: '-9999px'
	        });
	      }
	    });
	    // 统一在显示之后重新设定位置
	    this.after('show', function () {
	      that._setPosition();
	    });
	  },
	
	  destroy: function () {
	    // 销毁两个静态数组中的实例
	    erase(this, Overlay.allOverlays);
	    erase(this, Overlay.blurOverlays);
	    return Overlay.superclass.destroy.call(this);
	  },
	
	  // 进行定位
	  _setPosition: function (align) {
	    // 不在文档流中，定位无效
	    if (!isInDocument(this.element[0])) return;
	
	    align || (align = this.get('align'));
	
	    // 如果align为空，表示不需要使用js对齐
	    if (!align) return;
	
	    var isHidden = this.element.css('display') === 'none';
	
	    // 在定位时，为避免元素高度不定，先显示出来
	    if (isHidden) {
	      this.element.css({
	        visibility: 'hidden',
	        display: 'block'
	      });
	    }
	
	    Position.pin({
	      element: this.element,
	      x: align.selfXY[0],
	      y: align.selfXY[1]
	    }, {
	      element: align.baseElement,
	      x: align.baseXY[0],
	      y: align.baseXY[1]
	    });
	
	    // 定位完成后，还原
	    if (isHidden) {
	      this.element.css({
	        visibility: '',
	        display: 'none'
	      });
	    }
	
	    return this;
	  },
	
	  // 加载 iframe 遮罩层并与 overlay 保持同步
	  _setupShim: function () {
	    var shim = new Shim(this.element);
	
	    // 在隐藏和设置位置后，要重新定位
	    // 显示后会设置位置，所以不用绑定 shim.sync
	    this.after('hide _setPosition', shim.sync, shim);
	
	    // 除了 parentNode 之外的其他属性发生变化时，都触发 shim 同步
	    var attrs = ['width', 'height'];
	    for (var attr in attrs) {
	      if (attrs.hasOwnProperty(attr)) {
	        this.on('change:' + attr, shim.sync, shim);
	      }
	    }
	
	    // 在销魂自身前要销毁 shim
	    this.before('destroy', shim.destroy, shim);
	  },
	
	  // resize窗口时重新定位浮层，用这个方法收集所有浮层实例
	  _setupResize: function () {
	    Overlay.allOverlays.push(this);
	  },
	
	  // 除了 element 和 relativeElements，点击 body 后都会隐藏 element
	  _blurHide: function (arr) {
	    arr = $.makeArray(arr);
	    arr.push(this.element);
	    this._relativeElements = arr;
	    Overlay.blurOverlays.push(this);
	  },
	
	  // 用于 set 属性后的界面更新
	  _onRenderWidth: function (val) {
	    this.element.css('width', val);
	  },
	
	  _onRenderHeight: function (val) {
	    this.element.css('height', val);
	  },
	
	  _onRenderZIndex: function (val) {
	    this.element.css('zIndex', val);
	  },
	
	  _onRenderAlign: function (val) {
	    this._setPosition(val);
	  },
	
	  _onRenderVisible: function (val) {
	    this.element[val ? 'show' : 'hide']();
	  }
	
	});
	
	// 绑定 blur 隐藏事件
	Overlay.blurOverlays = [];
	$(document).on('click', function (e) {
	  hideBlurOverlays(e);
	});
	
	// 绑定 resize 重新定位事件
	var timeout;
	var winWidth = $(window).width();
	var winHeight = $(window).height();
	Overlay.allOverlays = [];
	
	$(window).resize(function () {
	  timeout && clearTimeout(timeout);
	  timeout = setTimeout(function () {
	    var winNewWidth = $(window).width();
	    var winNewHeight = $(window).height();
	
	    // IE678 莫名其妙触发 resize
	    // http://stackoverflow.com/questions/1852751/window-resize-event-firing-in-internet-explorer
	    if (winWidth !== winNewWidth || winHeight !== winNewHeight) {
	      $(Overlay.allOverlays).each(function (i, item) {
	        // 当实例为空或隐藏时，不处理
	        if (!item || !item.get('visible')) {
	          return;
	        }
	        item._setPosition();
	      });
	    }
	
	    winWidth = winNewWidth;
	    winHeight = winNewHeight;
	  }, 80);
	});
	
	module.exports = Overlay;
	
	
	// Helpers
	// -------
	
	function isInDocument(element) {
	  return $.contains(document.documentElement, element);
	}
	
	function hideBlurOverlays(e) {
	  $(Overlay.blurOverlays).each(function (index, item) {
	    // 当实例为空或隐藏时，不处理
	    if (!item || !item.get('visible')) {
	      return;
	    }
	
	    // 遍历 _relativeElements ，当点击的元素落在这些元素上时，不处理
	    for (var i = 0; i < item._relativeElements.length; i++) {
	      var el = $(item._relativeElements[i])[0];
	      if (el === e.target || $.contains(el, e.target)) {
	        return;
	      }
	    }
	
	    // 到这里，判断触发了元素的 blur 事件，隐藏元素
	    item.hide();
	  });
	}
	
	// 从数组中删除对应元素
	
	
	function erase(target, array) {
	  for (var i = 0; i < array.length; i++) {
	    if (target === array[i]) {
	      array.splice(i, 1);
	      return array;
	    }
	  }
	}


/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(48);


/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	
	__webpack_require__(45);
	
	var SCROLLX = 'scrollx';
	var SCROLLY = 'scrolly';
	var FADE = 'fade';
	
	
	// 切换效果插件
	module.exports = {
	  attrs: {
	    // 切换效果，可取 scrollx | scrolly | fade 或直接传入 effect function
	    effect: 'none',
	    easing: 'linear',
	    duration: 500
	  },
	
	  isNeeded: function () {
	    return this.get('effect') !== 'none';
	  },
	
	  install: function () {
	    var panels = this.get('panels');
	
	    // 注：
	    // 1. 所有 panel 的尺寸应该相同
	    //    最好指定第一个 panel 的 width 和 height
	    //    因为 Safari 下，图片未加载时，读取的 offsetHeight 等值会不对
	    // 2. 初始化 panels 样式
	    //    这些特效需要将 panels 都显示出来
	    // 3. 在 CSS 里，需要给 container 设定高宽和 overflow: hidden
	    panels.show();
	    var effect = this.get('effect');
	    var step = this.get('step');
	
	    var isFunction = $.isFunction(effect);
	
	    // 初始化滚动效果
	    if (!isFunction && effect.indexOf('scroll') === 0) {
	      var content = this.content;
	      var firstPanel = panels.eq(0);
	
	      // 设置定位信息，为滚动效果做铺垫
	      content.css('position', 'relative');
	
	      // 注：content 的父级不一定是 container
	      if (content.parent().css('position') === 'static') {
	        content.parent().css('position', 'relative');
	      }
	
	      // 水平排列
	      if (effect === SCROLLX) {
	        panels.css('float', 'left');
	        // 设置最大宽度，以保证有空间让 panels 水平排布
	        // 35791197px 为 360 下 width 最大数值
	        content.width('35791197px');
	      }
	
	      // 只有 scrollX, scrollY 需要设置 viewSize
	      // 其他情况下不需要
	      var viewSize = this.get('viewSize');
	      if (!viewSize[0]) {
	        viewSize[0] = firstPanel.outerWidth() * step;
	        viewSize[1] = firstPanel.outerHeight() * step;
	        this.set('viewSize', viewSize);
	      }
	
	      if (!viewSize[0]) {
	        throw new Error('Please specify viewSize manually');
	      }
	    }
	    // 初始化淡隐淡出效果
	    else if (!isFunction && effect === FADE) {
	      var activeIndex = this.get('activeIndex');
	      var min = activeIndex * step;
	      var max = min + step - 1;
	
	      panels.each(function (i, panel) {
	        var isActivePanel = i >= min && i <= max;
	        $(panel).css({
	          opacity: isActivePanel ? 1 : 0,
	          position: 'absolute',
	          zIndex: isActivePanel ? 9 : 1
	        });
	      });
	    }
	
	    // 覆盖 switchPanel 方法
	    this._switchPanel = function (panelInfo) {
	      var effect = this.get('effect');
	      var fn = $.isFunction(effect) ? effect : Effects[effect];
	      fn.call(this, panelInfo);
	    };
	  }
	};
	
	
	// 切换效果方法集
	var Effects = {
	
	  // 淡隐淡现效果
	  fade: function (panelInfo) {
	    // 简单起见，目前不支持 step > 1 的情景。若需要此效果时，可修改结构来达成。
	    if (this.get('step') > 1) {
	      throw new Error('Effect "fade" only supports step === 1');
	    }
	
	    var fromPanel = panelInfo.fromPanels.eq(0);
	    var toPanel = panelInfo.toPanels.eq(0);
	
	    if (this.anim) {
	      // 立刻停止，以开始新的
	      this.anim.stop(false, true);
	    }
	
	    // 首先显示下一张
	    toPanel.css('opacity', 1);
	    toPanel.show();
	
	    if (panelInfo.fromIndex > -1) {
	      var that = this;
	      var duration = this.get('duration');
	      var easing = this.get('easing');
	
	      // 动画切换
	      this.anim = fromPanel.animate({
	        opacity: 0
	      }, duration, easing, function () {
	        that.anim = null; // free
	        // 切换 z-index
	        toPanel.css('zIndex', 9);
	        fromPanel.css('zIndex', 1);
	        fromPanel.css('display', 'none');
	      });
	    }
	    // 初始情况下没有必要动画切换
	    else {
	      toPanel.css('zIndex', 9);
	    }
	  },
	
	  // 水平/垂直滚动效果
	  scroll: function (panelInfo) {
	    var isX = this.get('effect') === SCROLLX;
	    var diff = this.get('viewSize')[isX ? 0 : 1] * panelInfo.toIndex;
	
	    var props = {};
	    props[isX ? 'left' : 'top'] = -diff + 'px';
	
	    if (this.anim) {
	      this.anim.stop();
	    }
	
	    if (panelInfo.fromIndex > -1) {
	      var that = this;
	      var duration = this.get('duration');
	      var easing = this.get('easing');
	
	      this.anim = this.content.animate(props, duration, easing, function () {
	        that.anim = null; // free
	      });
	    }
	    else {
	      this.content.css(props);
	    }
	  }
	};
	
	Effects[SCROLLY] = Effects.scroll;
	Effects[SCROLLX] = Effects.scroll;
	module.exports.Effects = Effects;

/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var Handlebars = __webpack_require__(63)['default'];
	
	var compiledTemplates = {};
	
	// 提供 Template 模板支持，默认引擎是 Handlebars
	module.exports = {
	
	  // Handlebars 的 helpers
	  templateHelpers: null,
	
	  // Handlebars 的 partials
	  templatePartials: null,
	
	  // template 对应的 DOM-like object
	  templateObject: null,
	
	  // 根据配置的模板和传入的数据，构建 this.element 和 templateElement
	  parseElementFromTemplate: function () {
	    // template 支持 id 选择器
	    var t, template = this.get('template');
	    if (/^#/.test(template) && (t = document.getElementById(template.substring(1)))) {
	      template = t.innerHTML;
	      this.set('template', template);
	    }
	    this.templateObject = convertTemplateToObject(template);
	    this.element = $(this.compile());
	  },
	
	  // 编译模板，混入数据，返回 html 结果
	  compile: function (template, model) {
	    template || (template = this.get('template'));
	
	    model || (model = this.get('model')) || (model = {});
	    if (model.toJSON) {
	      model = model.toJSON();
	    }
	
	    // handlebars runtime，注意 partials 也需要预编译
	    if (isFunction(template)) {
	      return template(model, {
	        helpers: this.templateHelpers,
	        partials: precompile(this.templatePartials)
	      });
	    } else {
	      var helpers = this.templateHelpers;
	      var partials = this.templatePartials;
	      var helper, partial;
	
	      // 注册 helpers
	      if (helpers) {
	        for (helper in helpers) {
	          if (helpers.hasOwnProperty(helper)) {
	            Handlebars.registerHelper(helper, helpers[helper]);
	          }
	        }
	      }
	      // 注册 partials
	      if (partials) {
	        for (partial in partials) {
	          if (partials.hasOwnProperty(partial)) {
	            Handlebars.registerPartial(partial, partials[partial]);
	          }
	        }
	      }
	
	      var compiledTemplate = compiledTemplates[template];
	      if (!compiledTemplate) {
	        compiledTemplate = compiledTemplates[template] = Handlebars.compile(template);
	      }
	
	      // 生成 html
	      var html = compiledTemplate(model);
	
	      // 卸载 helpers
	      if (helpers) {
	        for (helper in helpers) {
	          if (helpers.hasOwnProperty(helper)) {
	            delete Handlebars.helpers[helper];
	          }
	        }
	      }
	      // 卸载 partials
	      if (partials) {
	        for (partial in partials) {
	          if (partials.hasOwnProperty(partial)) {
	            delete Handlebars.partials[partial];
	          }
	        }
	      }
	      return html;
	    }
	  },
	
	  // 刷新 selector 指定的局部区域
	  renderPartial: function (selector) {
	    if (this.templateObject) {
	      var template = convertObjectToTemplate(this.templateObject, selector);
	
	      if (template) {
	        if (selector) {
	          this.$(selector).html(this.compile(template));
	        } else {
	          this.element.html(this.compile(template));
	        }
	      } else {
	        this.element.html(this.compile());
	      }
	    }
	
	    // 如果 template 已经编译过了，templateObject 不存在
	    else {
	      var all = $(this.compile());
	      var selected = all.find(selector);
	      if (selected.length) {
	        this.$(selector).html(selected.html());
	      } else {
	        this.element.html(all.html());
	      }
	    }
	
	    return this;
	  }
	};
	
	
	// Helpers
	// -------
	var _compile = Handlebars.compile;
	
	Handlebars.compile = function (template) {
	  return isFunction(template) ? template : _compile.call(Handlebars, template);
	};
	
	// 将 template 字符串转换成对应的 DOM-like object
	
	
	function convertTemplateToObject(template) {
	  return isFunction(template) ? null : $(encode(template));
	}
	
	// 根据 selector 得到 DOM-like template object，并转换为 template 字符串
	
	
	function convertObjectToTemplate(templateObject, selector) {
	  if (!templateObject) return;
	
	  var element;
	  if (selector) {
	    element = templateObject.find(selector);
	    if (element.length === 0) {
	      throw new Error('Invalid template selector: ' + selector);
	    }
	  } else {
	    element = templateObject;
	  }
	  return decode(element.html());
	}
	
	function encode(template) {
	  return template
	  // 替换 {{xxx}} 为 <!-- {{xxx}} -->
	  .replace(/({[^}]+}})/g, '<!--$1-->')
	  // 替换 src="{{xxx}}" 为 data-TEMPLATABLE-src="{{xxx}}"
	  .replace(/\s(src|href)\s*=\s*(['"])(.*?\{.+?)\2/g, ' data-templatable-$1=$2$3$2');
	}
	
	function decode(template) {
	  return template.replace(/(?:<|&lt;)!--({{[^}]+}})--(?:>|&gt;)/g, '$1').replace(/data-templatable-/ig, '');
	}
	
	function isFunction(obj) {
	  return typeof obj === "function";
	}
	
	function precompile(partials) {
	  if (!partials) return {};
	
	  var result = {};
	  for (var name in partials) {
	    var partial = partials[name];
	    result[name] = isFunction(partial) ? partial : Handlebars.compile(partial);
	  }
	  return result;
	};
	
	// 调用 renderPartial 时，Templatable 对模板有一个约束：
	// ** template 自身必须是有效的 html 代码片段**，比如
	//   1. 代码闭合
	//   2. 嵌套符合规范
	//
	// 总之，要保证在 template 里，将 `{{...}}` 转换成注释后，直接 innerHTML 插入到
	// DOM 中，浏览器不会自动增加一些东西。比如：
	//
	// tbody 里没有 tr：
	//  `<table><tbody>{{#each items}}<td>{{this}}</td>{{/each}}</tbody></table>`
	//
	// 标签不闭合：
	//  `<div><span>{{name}}</div>`


/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(62)


/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Exception = __webpack_require__(5)["default"];
	
	function LocationInfo(locInfo){
	  locInfo = locInfo || {};
	  this.firstLine   = locInfo.first_line;
	  this.firstColumn = locInfo.first_column;
	  this.lastColumn  = locInfo.last_column;
	  this.lastLine    = locInfo.last_line;
	}
	
	var AST = {
	  ProgramNode: function(statements, inverseStrip, inverse, locInfo) {
	    var inverseLocationInfo, firstInverseNode;
	    if (arguments.length === 3) {
	      locInfo = inverse;
	      inverse = null;
	    } else if (arguments.length === 2) {
	      locInfo = inverseStrip;
	      inverseStrip = null;
	    }
	
	    LocationInfo.call(this, locInfo);
	    this.type = "program";
	    this.statements = statements;
	    this.strip = {};
	
	    if(inverse) {
	      firstInverseNode = inverse[0];
	      if (firstInverseNode) {
	        inverseLocationInfo = {
	          first_line: firstInverseNode.firstLine,
	          last_line: firstInverseNode.lastLine,
	          last_column: firstInverseNode.lastColumn,
	          first_column: firstInverseNode.firstColumn
	        };
	        this.inverse = new AST.ProgramNode(inverse, inverseStrip, inverseLocationInfo);
	      } else {
	        this.inverse = new AST.ProgramNode(inverse, inverseStrip);
	      }
	      this.strip.right = inverseStrip.left;
	    } else if (inverseStrip) {
	      this.strip.left = inverseStrip.right;
	    }
	  },
	
	  MustacheNode: function(rawParams, hash, open, strip, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "mustache";
	    this.strip = strip;
	
	    // Open may be a string parsed from the parser or a passed boolean flag
	    if (open != null && open.charAt) {
	      // Must use charAt to support IE pre-10
	      var escapeFlag = open.charAt(3) || open.charAt(2);
	      this.escaped = escapeFlag !== '{' && escapeFlag !== '&';
	    } else {
	      this.escaped = !!open;
	    }
	
	    if (rawParams instanceof AST.SexprNode) {
	      this.sexpr = rawParams;
	    } else {
	      // Support old AST API
	      this.sexpr = new AST.SexprNode(rawParams, hash);
	    }
	
	    this.sexpr.isRoot = true;
	
	    // Support old AST API that stored this info in MustacheNode
	    this.id = this.sexpr.id;
	    this.params = this.sexpr.params;
	    this.hash = this.sexpr.hash;
	    this.eligibleHelper = this.sexpr.eligibleHelper;
	    this.isHelper = this.sexpr.isHelper;
	  },
	
	  SexprNode: function(rawParams, hash, locInfo) {
	    LocationInfo.call(this, locInfo);
	
	    this.type = "sexpr";
	    this.hash = hash;
	
	    var id = this.id = rawParams[0];
	    var params = this.params = rawParams.slice(1);
	
	    // a mustache is an eligible helper if:
	    // * its id is simple (a single part, not `this` or `..`)
	    var eligibleHelper = this.eligibleHelper = id.isSimple;
	
	    // a mustache is definitely a helper if:
	    // * it is an eligible helper, and
	    // * it has at least one parameter or hash segment
	    this.isHelper = eligibleHelper && (params.length || hash);
	
	    // if a mustache is an eligible helper but not a definite
	    // helper, it is ambiguous, and will be resolved in a later
	    // pass or at runtime.
	  },
	
	  PartialNode: function(partialName, context, strip, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type         = "partial";
	    this.partialName  = partialName;
	    this.context      = context;
	    this.strip = strip;
	  },
	
	  BlockNode: function(mustache, program, inverse, close, locInfo) {
	    LocationInfo.call(this, locInfo);
	
	    if(mustache.sexpr.id.original !== close.path.original) {
	      throw new Exception(mustache.sexpr.id.original + " doesn't match " + close.path.original, this);
	    }
	
	    this.type = 'block';
	    this.mustache = mustache;
	    this.program  = program;
	    this.inverse  = inverse;
	
	    this.strip = {
	      left: mustache.strip.left,
	      right: close.strip.right
	    };
	
	    (program || inverse).strip.left = mustache.strip.right;
	    (inverse || program).strip.right = close.strip.left;
	
	    if (inverse && !program) {
	      this.isInverse = true;
	    }
	  },
	
	  ContentNode: function(string, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "content";
	    this.string = string;
	  },
	
	  HashNode: function(pairs, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "hash";
	    this.pairs = pairs;
	  },
	
	  IdNode: function(parts, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "ID";
	
	    var original = "",
	        dig = [],
	        depth = 0;
	
	    for(var i=0,l=parts.length; i<l; i++) {
	      var part = parts[i].part;
	      original += (parts[i].separator || '') + part;
	
	      if (part === ".." || part === "." || part === "this") {
	        if (dig.length > 0) {
	          throw new Exception("Invalid path: " + original, this);
	        } else if (part === "..") {
	          depth++;
	        } else {
	          this.isScoped = true;
	        }
	      } else {
	        dig.push(part);
	      }
	    }
	
	    this.original = original;
	    this.parts    = dig;
	    this.string   = dig.join('.');
	    this.depth    = depth;
	
	    // an ID is simple if it only has one part, and that part is not
	    // `..` or `this`.
	    this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
	
	    this.stringModeValue = this.string;
	  },
	
	  PartialNameNode: function(name, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "PARTIAL_NAME";
	    this.name = name.original;
	  },
	
	  DataNode: function(id, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "DATA";
	    this.id = id;
	  },
	
	  StringNode: function(string, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "STRING";
	    this.original =
	      this.string =
	      this.stringModeValue = string;
	  },
	
	  IntegerNode: function(integer, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "INTEGER";
	    this.original =
	      this.integer = integer;
	    this.stringModeValue = Number(integer);
	  },
	
	  BooleanNode: function(bool, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "BOOLEAN";
	    this.bool = bool;
	    this.stringModeValue = bool === "true";
	  },
	
	  CommentNode: function(comment, locInfo) {
	    LocationInfo.call(this, locInfo);
	    this.type = "comment";
	    this.comment = comment;
	  }
	};
	
	// Must be exported as an object rather than the root of the module as the jison lexer
	// most modify the object to operate properly.
	exports["default"] = AST;

/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var parser = __webpack_require__(66)["default"];
	var AST = __webpack_require__(21)["default"];
	
	exports.parser = parser;
	
	function parse(input) {
	  // Just return if an already-compile AST was passed in.
	  if(input.constructor === AST.ProgramNode) { return input; }
	
	  parser.yy = AST;
	  return parser.parse(input);
	}
	
	exports.parse = parse;

/***/ },
/* 23 */
/***/ function(module, exports) {

	"use strict";
	// Build out our basic SafeString type
	function SafeString(string) {
	  this.string = string;
	}
	
	SafeString.prototype.toString = function() {
	  return "" + this.string;
	};
	
	exports["default"] = SafeString;

/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

	// Position
	// --------
	// 定位工具组件，将一个 DOM 节点相对对另一个 DOM 节点进行定位操作。
	// 代码易改，人生难得
	
	var Position = exports,
	    VIEWPORT = { _id: 'VIEWPORT', nodeType: 1 },
	    $ = __webpack_require__(2),
	    isPinFixed = false,
	    ua = (window.navigator.userAgent || "").toLowerCase(),
	    isIE6 = ua.indexOf("msie 6") !== -1;
	
	
	// 将目标元素相对于基准元素进行定位
	// 这是 Position 的基础方法，接收两个参数，分别描述了目标元素和基准元素的定位点
	Position.pin = function(pinObject, baseObject) {
	
	    // 将两个参数转换成标准定位对象 { element: a, x: 0, y: 0 }
	    pinObject = normalize(pinObject);
	    baseObject = normalize(baseObject);
	
	    // if pinObject.element is not present
	    // https://github.com/aralejs/position/pull/11
	    if (pinObject.element === VIEWPORT ||
	        pinObject.element._id === 'VIEWPORT') {
	        return;
	    }
	
	    // 设定目标元素的 position 为绝对定位
	    // 若元素的初始 position 不为 absolute，会影响元素的 display、宽高等属性
	    var pinElement = $(pinObject.element);
	
	    if (pinElement.css('position') !== 'fixed' || isIE6) {
	        pinElement.css('position', 'absolute');
	        isPinFixed = false;
	    }
	    else {
	        // 定位 fixed 元素的标志位，下面有特殊处理
	        isPinFixed = true;
	    }
	
	    // 将位置属性归一化为数值
	    // 注：必须放在上面这句 `css('position', 'absolute')` 之后，
	    //    否则获取的宽高有可能不对
	    posConverter(pinObject);
	    posConverter(baseObject);
	
	    var parentOffset = getParentOffset(pinElement);
	    var baseOffset = baseObject.offset();
	
	    // 计算目标元素的位置
	    var top = baseOffset.top + baseObject.y -
	            pinObject.y - parentOffset.top;
	
	    var left = baseOffset.left + baseObject.x -
	            pinObject.x - parentOffset.left;
	
	    // 定位目标元素
	    pinElement.css({ left: left, top: top });
	};
	
	
	// 将目标元素相对于基准元素进行居中定位
	// 接受两个参数，分别为目标元素和定位的基准元素，都是 DOM 节点类型
	Position.center = function(pinElement, baseElement) {
	    Position.pin({
	        element: pinElement,
	        x: '50%',
	        y: '50%'
	    }, {
	        element: baseElement,
	        x: '50%',
	        y: '50%'
	    });
	};
	
	
	// 这是当前可视区域的伪 DOM 节点
	// 需要相对于当前可视区域定位时，可传入此对象作为 element 参数
	Position.VIEWPORT = VIEWPORT;
	
	
	// Helpers
	// -------
	
	// 将参数包装成标准的定位对象，形似 { element: a, x: 0, y: 0 }
	function normalize(posObject) {
	    posObject = toElement(posObject) || {};
	
	    if (posObject.nodeType) {
	        posObject = { element: posObject };
	    }
	
	    var element = toElement(posObject.element) || VIEWPORT;
	    if (element.nodeType !== 1) {
	        throw new Error('posObject.element is invalid.');
	    }
	
	    var result = {
	        element: element,
	        x: posObject.x || 0,
	        y: posObject.y || 0
	    };
	
	    // config 的深度克隆会替换掉 Position.VIEWPORT, 导致直接比较为 false
	    var isVIEWPORT = (element === VIEWPORT || element._id === 'VIEWPORT');
	
	    // 归一化 offset
	    result.offset = function() {
	        // 若定位 fixed 元素，则父元素的 offset 没有意义
	        if (isPinFixed) {
	            return {
	                left: 0,
	                top: 0
	            };
	        }
	        else if (isVIEWPORT) {
	            return {
	                left: $(document).scrollLeft(),
	                top: $(document).scrollTop()
	            };
	        }
	        else {
	            return getOffset($(element)[0]);
	        }
	    };
	
	    // 归一化 size, 含 padding 和 border
	    result.size = function() {
	        var el = isVIEWPORT ? $(window) : $(element);
	        return {
	            width: el.outerWidth(),
	            height: el.outerHeight()
	        };
	    };
	
	    return result;
	}
	
	// 对 x, y 两个参数为 left|center|right|%|px 时的处理，全部处理为纯数字
	function posConverter(pinObject) {
	    pinObject.x = xyConverter(pinObject.x, pinObject, 'width');
	    pinObject.y = xyConverter(pinObject.y, pinObject, 'height');
	}
	
	// 处理 x, y 值，都转化为数字
	function xyConverter(x, pinObject, type) {
	    // 先转成字符串再说！好处理
	    x = x + '';
	
	    // 处理 px
	    x = x.replace(/px/gi, '');
	
	    // 处理 alias
	    if (/\D/.test(x)) {
	        x = x.replace(/(?:top|left)/gi, '0%')
	             .replace(/center/gi, '50%')
	             .replace(/(?:bottom|right)/gi, '100%');
	    }
	
	    // 将百分比转为像素值
	    if (x.indexOf('%') !== -1) {
	        //支持小数
	        x = x.replace(/(\d+(?:\.\d+)?)%/gi, function(m, d) {
	            return pinObject.size()[type] * (d / 100.0);
	        });
	    }
	
	    // 处理类似 100%+20px 的情况
	    if (/[+\-*\/]/.test(x)) {
	        try {
	            // eval 会影响压缩
	            // new Function 方法效率高于 for 循环拆字符串的方法
	            // 参照：http://jsperf.com/eval-newfunction-for
	            x = (new Function('return ' + x))();
	        } catch (e) {
	            throw new Error('Invalid position value: ' + x);
	        }
	    }
	
	    // 转回为数字
	    return numberize(x);
	}
	
	// 获取 offsetParent 的位置
	function getParentOffset(element) {
	    var parent = element.offsetParent();
	
	    // IE7 下，body 子节点的 offsetParent 为 html 元素，其 offset 为
	    // { top: 2, left: 2 }，会导致定位差 2 像素，所以这里将 parent
	    // 转为 document.body
	    if (parent[0] === document.documentElement) {
	        parent = $(document.body);
	    }
	
	    // 修正 ie6 下 absolute 定位不准的 bug
	    if (isIE6) {
	        parent.css('zoom', 1);
	    }
	
	    // 获取 offsetParent 的 offset
	    var offset;
	
	    // 当 offsetParent 为 body，
	    // 而且 body 的 position 是 static 时
	    // 元素并不按照 body 来定位，而是按 document 定位
	    // http://jsfiddle.net/afc163/hN9Tc/2/
	    // 因此这里的偏移值直接设为 0 0
	    if (parent[0] === document.body &&
	        parent.css('position') === 'static') {
	            offset = { top:0, left: 0 };
	    } else {
	        offset = getOffset(parent[0]);
	    }
	
	    // 根据基准元素 offsetParent 的 border 宽度，来修正 offsetParent 的基准位置
	    offset.top += numberize(parent.css('border-top-width'));
	    offset.left += numberize(parent.css('border-left-width'));
	
	    return offset;
	}
	
	function numberize(s) {
	    return parseFloat(s, 10) || 0;
	}
	
	function toElement(element) {
	    return $(element)[0];
	}
	
	// fix jQuery 1.7.2 offset
	// document.body 的 position 是 absolute 或 relative 时
	// jQuery.offset 方法无法正确获取 body 的偏移值
	//   -> http://jsfiddle.net/afc163/gMAcp/
	// jQuery 1.9.1 已经修正了这个问题
	//   -> http://jsfiddle.net/afc163/gMAcp/1/
	// 这里先实现一份
	// 参照 kissy 和 jquery 1.9.1
	//   -> https://github.com/kissyteam/kissy/blob/master/src/dom/sub-modules/base/src/base/offset.js#L366
	//   -> https://github.com/jquery/jquery/blob/1.9.1/src/offset.js#L28
	function getOffset(element) {
	    var box = element.getBoundingClientRect(),
	        docElem = document.documentElement;
	
	    // < ie8 不支持 win.pageXOffset, 则使用 docElem.scrollLeft
	    return {
	        left: box.left + (window.pageXOffset || docElem.scrollLeft) -
	              (docElem.clientLeft || document.body.clientLeft  || 0),
	        top: box.top  + (window.pageYOffset || docElem.scrollTop) -
	             (docElem.clientTop || document.body.clientTop  || 0)
	    };
	}


/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(27), "");
	exports.i(__webpack_require__(26), "");
	exports.i(__webpack_require__(71), "");
	exports.i(__webpack_require__(72), "");
	
	// module
	exports.push([module.id, "/* alice.dropdown 样式模块 */\n", ""]);
	
	// exports


/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(73), "");
	exports.i(__webpack_require__(77), "");
	exports.i(__webpack_require__(78), "");
	exports.i(__webpack_require__(75), "");
	exports.i(__webpack_require__(74), "");
	exports.i(__webpack_require__(76), "");
	
	// module
	exports.push([module.id, "\n", ""]);
	
	// exports


/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* \n * @name: ui-iconfont\n * @overview: REI——支付宝的iconfont\n * @require: 无\n */\n@font-face {\n    font-family: \"rei\";\n    src: url(\"https://i.alipayobjects.com/common/fonts/rei.eot\"); /* IE9*/\n    src: url(\"https://i.alipayobjects.com/common/fonts/rei.eot?#iefix\") format(\"embedded-opentype\"), /* IE6-IE8 */\n         url(\"https://i.alipayobjects.com/common/fonts/rei.woff\") format(\"woff\"), /* chrome 6+、firefox 3.6+、Safari5.1+、Opera 11+ */\n         url(\"https://i.alipayobjects.com/common/fonts/rei.ttf\")  format(\"truetype\"), /* chrome、firefox、opera、Safari, Android, iOS 4.2+*/\n         url(\"https://i.alipayobjects.com/common/fonts/rei.svg#rei\") format(\"svg\"); /*  iOS 4.1- */\n    font-weight: normal;\n    font-style: normal;\n}\n.iconfont {\n    font-family: \"rei\";\n    font-style: normal;\n    cursor: default;\n    -webkit-font-smoothing: antialiased;\n}\n", ""]);
	
	// exports


/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.poptip 样式模块 */\n\n.ui-poptip {\n    color: #DB7C22;\n    z-index: 101;\n    font-size: 12px;\n    line-height: 1.5;\n    zoom: 1;\n}\n\n.ui-poptip-shadow {\n    background-color: rgba(229, 169, 107, 0.15);\n    FILTER: progid:DXImageTransform.Microsoft.Gradient(startColorstr=#26e5a96b, endColorstr=#26e5a96b);\n    /* Math.floor(0.15 * 255).toString(16); */\n    border-radius: 2px;\n    padding: 2px;\n    zoom: 1;\n    _display: inline;\n}\n\n.ui-poptip-container {\n    position: relative;\n    background-color: #FFFCEF;\n    border: 1px solid #ffbb76;\n    border-radius: 2px;\n    padding: 5px 15px;\n    zoom: 1;\n    _display: inline;\n}\n\n.ui-poptip:after,\n.ui-poptip-shadow:after,\n.ui-poptip-container:after {\n    visibility: hidden;\n    display: block;\n    font-size: 0;\n    content: \" \";\n    clear: both;\n    height: 0;\n}\n\na.ui-poptip-close {\n    position: absolute;\n    right: 3px;\n    top: 3px;\n    border: 1px solid #ffc891;\n    text-decoration: none;\n    border-radius: 3px;\n    width: 12px;\n    height: 12px;\n    font-family: tahoma;\n    color: #dd7e00;\n    line-height: 10px;\n    *line-height: 12px;\n    text-align: center;\n    font-size: 14px;\n    background: #ffd7af;\n    background: -webkit-gradient(linear, left top, left bottom, from(#FFF0E1), to(#FFE7CD));\n    background: -moz-linear-gradient(top, #FFF0E1, #FFE7CD);\n    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFF0E1', endColorstr='#FFE7CD');\n    background: -o-linear-gradient(top, #FFF0E1, #FFE7CD);\n    background: linear-gradient(top, #FFF0E1, #FFE7CD);\n    overflow: hidden;\n}\n\na.ui-poptip-close:hover {\n    border: 1px solid #ffb24c;\n    text-decoration: none;\n    color: #dd7e00;\n    background: #ffd7af;\n    background: -webkit-gradient(linear, left top, left bottom, from(#FFE5CA), to(#FFCC98));\n    background: -moz-linear-gradient(top, #FFE5CA, #FFCC98);\n    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#FFE5CA', endColorstr='#FFCC98');\n    background: -o-linear-gradient(top, #FFE5CA, #FFCC98);\n    background: linear-gradient(top, #FFE5CA, #FFCC98);\n}\n\n\n.ui-poptip-arrow {\n    position: absolute;\n    z-index: 10;\n    *zoom: 1;\n}\n\n.ui-poptip-arrow em, .ui-poptip-arrow span {\n    position: absolute;\n    *zoom: 1;\n    width: 0;\n    height: 0;\n    /* 解决window下firefox的border渲染出深色边框的问题 */\n    /* http://stackoverflow.com/questions/13630886/firefox-17-and-css-borders-based-triangles-not-rendering-properly */\n    border-color: rgba(255, 255, 255, 0);\n    border-color: transparent\\0;\n    *border-color: transparent;\n    _border-color:tomato;\n    _filter:chroma(color=tomato); /* http://blog.sina.com.cn/s/blog_6283c54a0100f7ae.html */\n    border-style: solid;\n    overflow: hidden;\n    top: 0;\n    left: 0;\n}\n\n/* 箭头用 border 实现 http://www.css88.com/demo/border/border1.html */\n\n/* 箭头在左边 10,9 */\n\n.ui-poptip-arrow-10 {\n    left: -6px;\n    top: 10px;\n}\n\n.ui-poptip-arrow-10 em {\n    top: 0;\n    left: -1px;\n    border-right-color: #ffbb76;\n    border-width: 6px 6px 6px 0;\n}\n\n.ui-poptip-arrow-10 span {\n    border-right-color: #FFFCEF;\n    border-width: 6px 6px 6px 0;\n}\n\n.ui-poptip-arrow-9 {\n    left: -6px;\n    top: 50%;\n}\n\n.ui-poptip-arrow-9 em {\n    top: -6px;\n    left: -1px;\n    border-right-color: #ffbb76;\n    border-width: 6px 6px 6px 0;\n}\n\n.ui-poptip-arrow-9 span {\n    top: -6px;\n    border-right-color: #FFFCEF;\n    border-width: 6px 6px 6px 0;\n}\n\n/* 箭头在右边 2,3 */\n\n.ui-poptip-arrow-2 {\n    top: 10px;\n    right: 0;\n}\n\n.ui-poptip-arrow-2 em {\n    top: 0;\n    left: 1px;\n    border-left-color: #ffbb76;\n    border-width: 6px 0 6px 6px;\n}\n\n.ui-poptip-arrow-2 span {\n    border-left-color: #FFFCEF;\n    border-width: 6px 0 6px 6px;\n}\n\n.ui-poptip-arrow-3 {\n    top: 50%;\n    right: 0;\n}\n\n.ui-poptip-arrow-3 em {\n    top: -6px;\n    left: 1px;\n    border-left-color: #ffbb76;\n    border-width: 6px 0 6px 6px;\n}\n\n.ui-poptip-arrow-3 span {\n    top: -6px;\n    border-left-color: #FFFCEF;\n    border-width: 6px 0 6px 6px;\n}\n\n/* 箭头在上边 11,12,1 */\n\n.ui-poptip-arrow-11 em,\n.ui-poptip-arrow-12 em,\n.ui-poptip-arrow-1 em {\n    border-width: 0 6px 6px;\n    border-bottom-color: #ffbb76;\n    top: -1px;\n    left: 0;\n}\n\n.ui-poptip-arrow-11 span,\n.ui-poptip-arrow-12 span,\n.ui-poptip-arrow-1 span {\n    border-width: 0 6px 6px;\n    border-bottom-color: #FFFCEF;\n}\n\n.ui-poptip-arrow-11 {\n    left: 14px;\n    top: -6px;\n}\n\n.ui-poptip-arrow-1 {\n    right: 28px;\n    top: -6px;\n}\n\n.ui-poptip-arrow-12 {\n    left: 50%;\n    top: -6px;\n}\n\n.ui-poptip-arrow-12 em,\n.ui-poptip-arrow-12 span {\n    left: -6px;\n}\n\n/* 箭头在下方 5 6 7 */\n\n.ui-poptip-arrow-5 em,\n.ui-poptip-arrow-6 em,\n.ui-poptip-arrow-7 em {\n    border-width: 6px 6px 0;\n    border-top-color: #ffbb76;\n    top: 1px;\n    left: 0;\n}\n\n.ui-poptip-arrow-5 span,\n.ui-poptip-arrow-6 span,\n.ui-poptip-arrow-7 span {\n    border-width: 6px 6px 0;\n    border-top-color: #FFFCEF;\n}\n\n.ui-poptip-arrow-5 {\n    right: 28px;\n    bottom: 0;\n}\n\n.ui-poptip-arrow-6 {\n    left: 50%;\n    bottom: 0;\n}\n\n.ui-poptip-arrow-7 {\n    left: 14px;\n    bottom: 0;\n}\n\n.ui-poptip-arrow-6 em,\n.ui-poptip-arrow-6 span {\n    left: -6px;\n}\n\n/* ie9 filter */\n:root .ui-poptip-shadow {\n    FILTER: none\\9;\n}\n\n/* 蓝色 */\n.ui-poptip-blue {\n    color: #4d4d4d;\n}\n\n.ui-poptip-blue .ui-poptip-shadow {\n    background-color: rgba(0, 0, 0, 0.05);\n    FILTER: progid:DXImageTransform.Microsoft.Gradient(startColorstr=#0c000000, endColorstr=#0c000000);\n}\n\n.ui-poptip-blue .ui-poptip-container {\n    background-color: #F8FCFF;\n    border: 1px solid #B9C8D3;\n}\n\n.ui-poptip-blue .ui-poptip-arrow-10 em, \n.ui-poptip-blue .ui-poptip-arrow-9 em {\n    border-right-color: #B9C8D3;\n}\n.ui-poptip-blue .ui-poptip-arrow-11 em,\n.ui-poptip-blue .ui-poptip-arrow-12 em,\n.ui-poptip-blue .ui-poptip-arrow-1 em {\n    border-bottom-color: #B9C8D3;\n}\n.ui-poptip-blue .ui-poptip-arrow-2 em,\n.ui-poptip-blue .ui-poptip-arrow-3 em {\n    border-left-color: #B9C8D3;\n}\n.ui-poptip-blue .ui-poptip-arrow-5 em,\n.ui-poptip-blue .ui-poptip-arrow-6 em,\n.ui-poptip-blue .ui-poptip-arrow-7 em {\n    border-top-color: #B9C8D3;\n}\n\n.ui-poptip-blue .ui-poptip-arrow-10 span,\n.ui-poptip-blue .ui-poptip-arrow-9 span {\n    border-right-color: #F8FCFF;\n}\n.ui-poptip-blue .ui-poptip-arrow-11 span,\n.ui-poptip-blue .ui-poptip-arrow-12 span,\n.ui-poptip-blue .ui-poptip-arrow-1 span {\n    border-bottom-color: #F8FCFF;\n}\n.ui-poptip-blue .ui-poptip-arrow-2 span,\n.ui-poptip-blue .ui-poptip-arrow-3 span {\n    border-left-color: #F8FCFF;\n}\n.ui-poptip-blue .ui-poptip-arrow-5 span,\n.ui-poptip-blue .ui-poptip-arrow-6 span,\n.ui-poptip-blue .ui-poptip-arrow-7 span {\n    border-top-color: #F8FCFF;\n}\n\n/* 白色 */\n\n.ui-poptip-white {\n    color: #333;\n}\n\n.ui-poptip-white .ui-poptip-shadow {\n    background-color: rgba(0, 0, 0, 0.05);\n    FILTER: progid:DXImageTransform.Microsoft.Gradient(startColorstr=#0c000000, endColorstr=#0c000000);\n}\n\n.ui-poptip-white .ui-poptip-container {\n    background-color: #fff;\n    border: 1px solid #b1b1b1;\n}\n\n.ui-poptip-white .ui-poptip-arrow-10 em,\n.ui-poptip-white .ui-poptip-arrow-9 em {\n    border-right-color: #b1b1b1;\n}\n.ui-poptip-white .ui-poptip-arrow-11 em,\n.ui-poptip-white .ui-poptip-arrow-12 em,\n.ui-poptip-white .ui-poptip-arrow-1 em {\n    border-bottom-color: #b1b1b1;\n}\n.ui-poptip-white .ui-poptip-arrow-2 em,\n.ui-poptip-white .ui-poptip-arrow-3 em {\n    border-left-color: #b1b1b1;\n}\n.ui-poptip-white .ui-poptip-arrow-5 em,\n.ui-poptip-white .ui-poptip-arrow-6 em,\n.ui-poptip-white .ui-poptip-arrow-7 em {\n    border-top-color: #b1b1b1;\n}\n\n.ui-poptip-white .ui-poptip-arrow-10 span,\n.ui-poptip-white .ui-poptip-arrow-9 span {\n    border-right-color: #fff;\n}\n.ui-poptip-white .ui-poptip-arrow-11 span,\n.ui-poptip-white .ui-poptip-arrow-12 span,\n.ui-poptip-white .ui-poptip-arrow-1 span {\n    border-bottom-color: #fff;\n}\n.ui-poptip-white .ui-poptip-arrow-2 span,\n.ui-poptip-white .ui-poptip-arrow-3 span {\n    border-left-color: #fff;\n}\n.ui-poptip-white .ui-poptip-arrow-5 span,\n.ui-poptip-white .ui-poptip-arrow-6 span,\n.ui-poptip-white .ui-poptip-arrow-7 span {\n    border-top-color: #fff;\n}\n", ""]);
	
	// exports


/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/*! define select-debug.css */\n/* alice.select 样式模块 */\n.ui-select a,\n.ui-select-trigger {\n  color: #7d7d7d;\n  font-size: 14px;\n  text-decoration: none;\n}\n.ui-select a:hover,\n.ui-select-trigger:hover {\n  text-decoration: none;\n}\n.ui-select {\n  display: inline-block;\n  *display: inline;\n  *zoom: 1;\n  background: #fff;\n  color: #7d7d7d;\n  font-size: 14px;\n}\n.ui-select-content {\n  margin: -1px 0 0;\n  padding: 0;\n  overflow: auto;\n  height: 100%;\n  list-style: none;\n  border: 1px solid #ccc;\n  _float: left;\n}\n.ui-select-content ul {\n  list-style: none;\n  padding: 0;\n  margin: 0;\n}\n.ui-select-item {\n  display: block;\n  padding: 10px 15px;\n  cursor: pointer;\n  overflow: hidden;\n  white-space: nowrap;\n}\n.ui-select-item:hover,\n.ui-select-item-hover {\n  background: #f2f2f2;\n}\n.ui-select-item-disabled,\n.ui-select-item-disabled a {\n  cursor: not-allowed;\n  color: #ccc;\n}\n.ui-select-item-disabled:hover,\n.ui-select-item-disabled a:hover {\n  background: #fff;\n}\n.ui-select-trigger {\n  position: relative;\n  display: inline-block;\n  *display: inline;\n  *zoom: 1;\n  border: 1px solid #ccc;\n  height: 30px;\n  line-height: 30px;\n  text-indent: 15px;\n  background: -webkit-linear-gradient(top, #fbfbfb, #f3f3f3);\n  background: -moz-linear-gradient(top, #fbfbfb, #f3f3f3);\n  filter: progid:DXImageTransform.Microsoft.Gradient(startColorstr=#fbfbfb, endColorstr=#f3f3f3);\n}\n.ui-select-trigger i {\n  position: absolute;\n  top: 0px;\n  right: 15px;\n  line-height: 28px;\n  text-indent: 0;\n  font-size: 14px;\n  cursor: pointer;\n}\n.ui-select-trigger:hover {\n  border: 1px solid #999;\n}\n.ui-select .ui-select-trigger {\n  display: block;\n}\n.ui-select-disabled,\n.ui-select .ui-select-disabled {\n  color: #aaa;\n  cursor: not-allowed;\n}\n", ""]);
	
	// exports


/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.HandlebarsEnvironment = HandlebarsEnvironment;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utils = __webpack_require__(3);
	
	var _exception = __webpack_require__(8);
	
	var _exception2 = _interopRequireDefault(_exception);
	
	var _helpers = __webpack_require__(98);
	
	var _decorators = __webpack_require__(96);
	
	var _logger = __webpack_require__(106);
	
	var _logger2 = _interopRequireDefault(_logger);
	
	var VERSION = '4.0.10';
	exports.VERSION = VERSION;
	var COMPILER_REVISION = 7;
	
	exports.COMPILER_REVISION = COMPILER_REVISION;
	var REVISION_CHANGES = {
	  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
	  2: '== 1.0.0-rc.3',
	  3: '== 1.0.0-rc.4',
	  4: '== 1.x.x',
	  5: '== 2.0.0-alpha.x',
	  6: '>= 2.0.0-beta.1',
	  7: '>= 4.0.0'
	};
	
	exports.REVISION_CHANGES = REVISION_CHANGES;
	var objectType = '[object Object]';
	
	function HandlebarsEnvironment(helpers, partials, decorators) {
	  this.helpers = helpers || {};
	  this.partials = partials || {};
	  this.decorators = decorators || {};
	
	  _helpers.registerDefaultHelpers(this);
	  _decorators.registerDefaultDecorators(this);
	}
	
	HandlebarsEnvironment.prototype = {
	  constructor: HandlebarsEnvironment,
	
	  logger: _logger2['default'],
	  log: _logger2['default'].log,
	
	  registerHelper: function registerHelper(name, fn) {
	    if (_utils.toString.call(name) === objectType) {
	      if (fn) {
	        throw new _exception2['default']('Arg not supported with multiple helpers');
	      }
	      _utils.extend(this.helpers, name);
	    } else {
	      this.helpers[name] = fn;
	    }
	  },
	  unregisterHelper: function unregisterHelper(name) {
	    delete this.helpers[name];
	  },
	
	  registerPartial: function registerPartial(name, partial) {
	    if (_utils.toString.call(name) === objectType) {
	      _utils.extend(this.partials, name);
	    } else {
	      if (typeof partial === 'undefined') {
	        throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
	      }
	      this.partials[name] = partial;
	    }
	  },
	  unregisterPartial: function unregisterPartial(name) {
	    delete this.partials[name];
	  },
	
	  registerDecorator: function registerDecorator(name, fn) {
	    if (_utils.toString.call(name) === objectType) {
	      if (fn) {
	        throw new _exception2['default']('Arg not supported with multiple decorators');
	      }
	      _utils.extend(this.decorators, name);
	    } else {
	      this.decorators[name] = fn;
	    }
	  },
	  unregisterDecorator: function unregisterDecorator(name) {
	    delete this.decorators[name];
	  }
	};
	
	var log = _logger2['default'].log;
	
	exports.log = log;
	exports.createFrame = _utils.createFrame;
	exports.logger = _logger2['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	var Handlebars = __webpack_require__(13);
	module.exports = (Handlebars["default"] || Handlebars).template({"1":function(container,depth0,helpers,partials,data,blockParams,depths) {
	    var stack1;
	
	  return "      <li data-role=\"item\" class=\""
	    + container.escapeExpression(container.lambda((depths[1] != null ? depths[1].classPrefix : depths[1]), depth0))
	    + "-item\">\n        "
	    + ((stack1 = (helpers.include || (depth0 && depth0.include) || helpers.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"include","hash":{"parent":depths[1]},"fn":container.program(2, data, 0, blockParams, depths),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + "\n      </li>\n";
	},"2":function(container,depth0,helpers,partials,data) {
	    var stack1;
	
	  return ((stack1 = container.invokePartial(partials.html,depth0,{"name":"html","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "");
	},"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data,blockParams,depths) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function", alias4=container.escapeExpression;
	
	  return "<div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "\">\n  <div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-content\">\n"
	    + ((stack1 = container.invokePartial(partials.header,depth0,{"name":"header","data":data,"indent":"    ","helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "")
	    + "    <ul data-role=\"items\">\n"
	    + ((stack1 = helpers.each.call(alias1,(depth0 != null ? depth0.items : depth0),{"name":"each","hash":{},"fn":container.program(1, data, 0, blockParams, depths),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + "    </ul>\n"
	    + ((stack1 = container.invokePartial(partials.footer,depth0,{"name":"footer","data":data,"indent":"    ","helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "")
	    + "  </div>\n</div>\n";
	},"usePartial":true,"useData":true,"useDepths":true});


/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	var Handlebars = __webpack_require__(13);
	module.exports = (Handlebars["default"] || Handlebars).template({"1":function(container,depth0,helpers,partials,data) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function";
	
	  return "<div class=\""
	    + container.escapeExpression(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-title\" data-role=\"title\">"
	    + ((stack1 = ((helper = (helper = helpers.title || (depth0 != null ? depth0.title : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"title","hash":{},"data":data}) : helper))) != null ? stack1 : "")
	    + "</div>\n";
	},"3":function(container,depth0,helpers,partials,data) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {});
	
	  return "    <div class=\""
	    + container.escapeExpression(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : helpers.helperMissing),(typeof helper === "function" ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-operation\" data-role=\"foot\">\n"
	    + ((stack1 = helpers["if"].call(alias1,(depth0 != null ? depth0.confirmTpl : depth0),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + ((stack1 = helpers["if"].call(alias1,(depth0 != null ? depth0.cancelTpl : depth0),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + "    </div>\n";
	},"4":function(container,depth0,helpers,partials,data) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function";
	
	  return "        <div class=\""
	    + container.escapeExpression(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-confirm\" data-role=\"confirm\">\n            "
	    + ((stack1 = ((helper = (helper = helpers.confirmTpl || (depth0 != null ? depth0.confirmTpl : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"confirmTpl","hash":{},"data":data}) : helper))) != null ? stack1 : "")
	    + "\n        </div>\n";
	},"6":function(container,depth0,helpers,partials,data) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function";
	
	  return "        <div class=\""
	    + container.escapeExpression(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-cancel\" data-role=\"cancel\">\n            "
	    + ((stack1 = ((helper = (helper = helpers.cancelTpl || (depth0 != null ? depth0.cancelTpl : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"cancelTpl","hash":{},"data":data}) : helper))) != null ? stack1 : "")
	    + "\n        </div>\n";
	},"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
	    var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function", alias4=container.escapeExpression;
	
	  return ((stack1 = helpers["if"].call(alias1,(depth0 != null ? depth0.title : depth0),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + "<div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-container\">\n    <div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-message\" data-role=\"message\">"
	    + ((stack1 = ((helper = (helper = helpers.message || (depth0 != null ? depth0.message : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"message","hash":{},"data":data}) : helper))) != null ? stack1 : "")
	    + "</div>\n"
	    + ((stack1 = helpers["if"].call(alias1,(depth0 != null ? depth0.hasFoot : depth0),{"name":"if","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data})) != null ? stack1 : "")
	    + "</div>\n";
	},"useData":true});


/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	var Handlebars = __webpack_require__(13);
	module.exports = (Handlebars["default"] || Handlebars).template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
	    var helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=helpers.helperMissing, alias3="function", alias4=container.escapeExpression;
	
	  return "<div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "\">\n    <a class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-close\" title=\"Close\" href=\"javascript:;\" data-role=\"close\"></a>\n    <div class=\""
	    + alias4(((helper = (helper = helpers.classPrefix || (depth0 != null ? depth0.classPrefix : depth0)) != null ? helper : alias2),(typeof helper === alias3 ? helper.call(alias1,{"name":"classPrefix","hash":{},"data":data}) : helper)))
	    + "-content\" data-role=\"content\"></div>\n</div>\n";
	},"useData":true});


/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(35);


/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var Overlay = __webpack_require__(10);
	var Templatable = __webpack_require__(19);
	var DataSource = __webpack_require__(36);
	var Filter = __webpack_require__(37);
	var Input = __webpack_require__(38);
	
	var IE678 = /\bMSIE [678]\.0\b/.test(navigator.userAgent);
	var template = __webpack_require__(31);
	
	var AutoComplete = Overlay.extend({
	
	  Implements: Templatable,
	
	  attrs: {
	    // 触发元素
	    trigger: null,
	    classPrefix: 'ui-select',
	    align: {
	      baseXY: [0, '100%']
	    },
	    submitOnEnter: true,
	    // 回车是否会提交表单
	    dataSource: { //数据源，支持 Array, URL, Object, Function
	      value: [],
	      getter: function (val) {
	        var that = this;
	        if ($.isFunction(val)) {
	          return function () {
	            return val.apply(that, arguments);
	          };
	        }
	        return val;
	      }
	    },
	    locator: 'data',
	    // 输出过滤
	    filter: null,
	    disabled: false,
	    selectFirst: false,
	    delay: 100,
	    // 以下为模板相关
	    model: {
	      value: {
	        items: []
	      },
	      getter: function (val) {
	        val.classPrefix || (val.classPrefix = this.get('classPrefix'));
	        return val;
	      }
	    },
	    template: template,
	    footer: '',
	    header: '',
	    html: '{{{label}}}',
	    // 以下仅为组件使用
	    selectedIndex: null,
	    data: []
	  },
	
	  events: {
	    'mousedown [data-role=items]': '_handleMouseDown',
	    'click [data-role=item]': '_handleSelection',
	    'mouseenter [data-role=item]': '_handleMouseMove',
	    'mouseleave [data-role=item]': '_handleMouseMove'
	  },
	
	  templateHelpers: {
	    // 将匹配的高亮文字加上 hl 的样式
	    highlightItem: highlightItem,
	    include: include
	  },
	
	  parseElement: function () {
	    var that = this;
	    this.templatePartials || (this.templatePartials = {});
	    $.each(['header', 'footer', 'html'], function (index, item) {
	      that.templatePartials[item] = that.get(item);
	    });
	    AutoComplete.superclass.parseElement.call(this);
	  },
	
	  setup: function () {
	    AutoComplete.superclass.setup.call(this);
	
	    this._isOpen = false;
	    this._initInput(); // 初始化输入框
	    this._initDataSource(); // 初始化数据源
	    this._initFilter(); // 初始化过滤器
	    this._bindHandle(); // 绑定事件
	    this._blurHide([$(this.get('trigger'))]);
	    this._tweakAlignDefaultValue();
	
	    this.on('indexChanged', function (index) {
	      // scroll current item into view
	      //this.currentItem.scrollIntoView();
	      var containerHeight = parseInt(this.get('height'), 10);
	      if (!containerHeight) return;
	
	      var itemHeight = this.items.parent().height() / this.items.length,
	          itemTop = Math.max(0, itemHeight * (index + 1) - containerHeight);
	      this.element.children().scrollTop(itemTop);
	    });
	  },
	
	  show: function () {
	    this._isOpen = true;
	    // 无数据则不显示
	    if (this._isEmpty()) return;
	    AutoComplete.superclass.show.call(this);
	  },
	
	  hide: function () {
	    // 隐藏的时候取消请求或回调
	    if (this._timeout) clearTimeout(this._timeout);
	    this.dataSource.abort();
	    this._hide();
	  },
	
	  destroy: function () {
	    this._clear();
	    if (this.input) {
	      this.input.destroy();
	      this.input = null;
	    }
	    AutoComplete.superclass.destroy.call(this);
	  },
	
	
	  // Public Methods
	  // --------------
	  selectItem: function (index) {
	    if (this.items) {
	      if (index && this.items.length > index && index >= -1) {
	        this.set('selectedIndex', index);
	      }
	      this._handleSelection();
	    }
	  },
	
	  setInputValue: function (val) {
	    this.input.setValue(val);
	  },
	
	  // Private Methods
	  // ---------------
	
	  // 数据源返回，过滤数据
	  _filterData: function (data) {
	    var filter = this.get('filter'),
	        locator = this.get('locator');
	
	    // 获取目标数据
	    data = locateResult(locator, data);
	
	    // 进行过滤
	    data = filter.call(this, normalize(data), this.input.get('query'));
	
	    this.set('data', data);
	  },
	
	  // 通过数据渲染模板
	  _onRenderData: function (data) {
	    data || (data = []);
	
	    // 渲染下拉
	    this.set('model', {
	      items: data,
	      query: this.input.get('query'),
	      length: data.length
	    });
	
	    this.renderPartial();
	
	    // 初始化下拉的状态
	    this.items = this.$('[data-role=items]').children();
	
	    if (this.get('selectFirst')) {
	      this.set('selectedIndex', 0);
	    }
	
	    // 选中后会修改 input 的值并触发下一次渲染，但第二次渲染的结果不应该显示出来。
	    this._isOpen && this.show();
	  },
	
	  // 键盘控制上下移动
	  _onRenderSelectedIndex: function (index) {
	    var hoverClass = this.get('classPrefix') + '-item-hover';
	    this.items && this.items.removeClass(hoverClass);
	
	    // -1 什么都不选
	    if (index === -1) return;
	
	    this.items.eq(index).addClass(hoverClass);
	    this.trigger('indexChanged', index, this.lastIndex);
	    this.lastIndex = index;
	  },
	
	  // 初始化
	  // ------------
	  _initDataSource: function () {
	    this.dataSource = new DataSource({
	      source: this.get('dataSource')
	    });
	  },
	
	  _initInput: function () {
	    this.input = new Input({
	      element: this.get('trigger'),
	      delay: this.get('delay')
	    });
	  },
	
	  _initFilter: function () {
	    var filter = this.get('filter');
	    filter = initFilter(filter, this.dataSource);
	    this.set('filter', filter);
	  },
	
	  // 事件绑定
	  // ------------
	  _bindHandle: function () {
	    this.dataSource.on('data', this._filterData, this);
	
	    this.input.on('blur', this.hide, this).on('focus', this._handleFocus, this).on('keyEnter', this._handleSelection, this).on('keyEsc', this.hide, this).on('keyUp keyDown', this.show, this).on('keyUp keyDown', this._handleStep, this).on('queryChanged', this._clear, this).on('queryChanged', this._hide, this).on('queryChanged', this._handleQueryChange, this).on('queryChanged', this.show, this);
	
	    this.after('hide', function () {
	      this.set('selectedIndex', -1);
	    });
	
	    // 选中后隐藏浮层
	    this.on('itemSelected', function () {
	      this._hide();
	    });
	  },
	
	  // 选中的处理器
	  // 1. 鼠标点击触发
	  // 2. 回车触发
	  // 3. selectItem 触发
	  _handleSelection: function (e) {
	    if (!this.items) return;
	    var isMouse = e ? e.type === 'click' : false;
	    var index = isMouse ? this.items.index(e.currentTarget) : this.get('selectedIndex');
	    var item = this.items.eq(index);
	    var data = this.get('data')[index];
	
	    if (index >= 0 && item && data) {
	      this.input.setValue(data.label);
	      this.set('selectedIndex', index, {
	        silent: true
	      });
	
	      // 是否阻止回车提交表单
	      if (e && !isMouse && !this.get('submitOnEnter')) e.preventDefault();
	
	      this.trigger('itemSelected', data, item);
	    }
	  },
	
	  _handleFocus: function () {
	    this._isOpen = true;
	  },
	
	  _handleMouseMove: function (e) {
	    var hoverClass = this.get('classPrefix') + '-item-hover';
	    this.items.removeClass(hoverClass);
	    if (e.type === 'mouseenter') {
	      var index = this.items.index(e.currentTarget);
	      this.set('selectedIndex', index, {
	        silent: true
	      });
	      this.items.eq(index).addClass(hoverClass);
	    }
	  },
	
	  _handleMouseDown: function (e) {
	    if (IE678) {
	      var trigger = this.input.get('element')[0];
	      trigger.onbeforedeactivate = function () {
	        window.event.returnValue = false;
	        trigger.onbeforedeactivate = null;
	      };
	    }
	    e.preventDefault();
	  },
	
	  _handleStep: function (e) {
	    e.preventDefault();
	    this.get('visible') && this._step(e.type === 'keyUp' ? -1 : 1);
	  },
	
	  _handleQueryChange: function (val, prev) {
	    if (this.get('disabled')) return;
	
	    this.dataSource.abort();
	    this.dataSource.getData(val);
	  },
	
	  // 选项上下移动
	  _step: function (direction) {
	    var currentIndex = this.get('selectedIndex');
	    if (direction === -1) { // 反向
	      if (currentIndex > -1) {
	        this.set('selectedIndex', currentIndex - 1);
	      } else {
	        this.set('selectedIndex', this.items.length - 1);
	      }
	    } else if (direction === 1) { // 正向
	      if (currentIndex < this.items.length - 1) {
	        this.set('selectedIndex', currentIndex + 1);
	      } else {
	        this.set('selectedIndex', -1);
	      }
	    }
	  },
	
	  _clear: function () {
	    this.$('[data-role=items]').empty();
	    this.set('selectedIndex', -1);
	    delete this.items;
	    delete this.lastIndex;
	  },
	
	  _hide: function () {
	    this._isOpen = false;
	    AutoComplete.superclass.hide.call(this);
	  },
	
	  _isEmpty: function () {
	    var data = this.get('data');
	    return !(data && data.length > 0);
	  },
	
	  // 调整 align 属性的默认值
	  _tweakAlignDefaultValue: function () {
	    var align = this.get('align');
	    align.baseElement = this.get('trigger');
	    this.set('align', align);
	  }
	});
	
	module.exports = AutoComplete;
	
	function isString(str) {
	  return Object.prototype.toString.call(str) === '[object String]';
	}
	
	function isObject(obj) {
	  return Object.prototype.toString.call(obj) === '[object Object]';
	}
	
	// 通过 locator 找到 data 中的某个属性的值
	// 1. locator 支持 function，函数返回值为结果
	// 2. locator 支持 string，而且支持点操作符寻址
	//     data {
	//       a: {
	//         b: 'c'
	//       }
	//     }
	//     locator 'a.b'
	// 最后的返回值为 c
	
	function locateResult(locator, data) {
	  if (locator) {
	    if ($.isFunction(locator)) {
	      return locator.call(this, data);
	    } else if (!$.isArray(data) && isString(locator)) {
	      var s = locator.split('.'),
	          p = data;
	      while (s.length) {
	        var v = s.shift();
	        if (!p[v]) {
	          break;
	        }
	        p = p[v];
	      }
	      return p;
	    }
	  }
	  return data;
	}
	
	// 标准格式，不匹配则忽略
	//
	//   {
	//     label: '', 显示的字段
	//     value: '', 匹配的字段
	//     alias: []  其他匹配的字段
	//   }
	
	function normalize(data) {
	  var result = [];
	  $.each(data, function (index, item) {
	    if (isString(item)) {
	      result.push({
	        label: item,
	        value: item,
	        alias: []
	      });
	    } else if (isObject(item)) {
	      if (!item.value && !item.label) return;
	      item.value || (item.value = item.label);
	      item.label || (item.label = item.value);
	      item.alias || (item.alias = []);
	      result.push(item);
	    }
	  });
	  return result;
	}
	
	// 初始化 filter
	// 支持的格式
	//   1. null: 使用默认的 startsWith
	//   2. string: 从 Filter 中找，如果不存在则用 default
	//   3. function: 自定义
	
	function initFilter(filter, dataSource) {
	  // 字符串
	  if (isString(filter)) {
	    // 从组件内置的 FILTER 获取
	    if (Filter[filter]) {
	      filter = Filter[filter];
	    } else {
	      filter = Filter['default'];
	    }
	  }
	  // 非函数为默认值
	  else if (!$.isFunction(filter)) {
	    // 异步请求的时候不需要过滤器
	    if (dataSource.get('type') === 'url') {
	      filter = Filter['default'];
	    } else {
	      filter = Filter['startsWith'];
	    }
	  }
	  return filter;
	}
	
	function include(options) {
	  var context = {};
	
	  mergeContext(this);
	  mergeContext(options.hash);
	  return options.fn(context);
	
	  function mergeContext(obj) {
	    for (var k in obj) context[k] = obj[k];
	  }
	}
	
	function highlightItem(label) {
	  var index = this.highlightIndex,
	      classPrefix = this.parent ? this.parent.classPrefix : '',
	      cursor = 0,
	      v = label || this.label || '',
	      h = '';
	  if ($.isArray(index)) {
	    for (var i = 0, l = index.length; i < l; i++) {
	      var j = index[i],
	          start, length;
	      if ($.isArray(j)) {
	        start = j[0];
	        length = j[1] - j[0];
	      } else {
	        start = j;
	        length = 1;
	      }
	
	      if (start > cursor) {
	        h += v.substring(cursor, start);
	      }
	      if (start < v.length) {
	        var className = classPrefix ? ('class="' + classPrefix + '-item-hl"') : '';
	        h += '<span ' + className + '>' + v.substr(start, length) + '</span>';
	      }
	      cursor = start + length;
	      if (cursor >= v.length) {
	        break;
	      }
	    }
	    if (v.length > cursor) {
	      h += v.substring(cursor, v.length);
	    }
	    return h;
	  }
	  return v;
	}


/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	var Base = __webpack_require__(9);
	var $ = __webpack_require__(2);
	
	var DataSource = Base.extend({
	
	  attrs: {
	    source: null,
	    type: 'array'
	  },
	
	  initialize: function (config) {
	    DataSource.superclass.initialize.call(this, config);
	
	    // 每次发送请求会将 id 记录到 callbacks 中，返回后会从中删除
	    // 如果 abort 会清空 callbacks，之前的请求结果都不会执行
	    this.id = 0;
	    this.callbacks = [];
	
	    var source = this.get('source');
	    if (isString(source)) {
	      this.set('type', 'url');
	    } else if ($.isArray(source)) {
	      this.set('type', 'array');
	    } else if ($.isPlainObject(source)) {
	      this.set('type', 'object');
	    } else if ($.isFunction(source)) {
	      this.set('type', 'function');
	    } else {
	      throw new Error('Source Type Error');
	    }
	  },
	
	  getData: function (query) {
	    return this['_get' + capitalize(this.get('type') || '') + 'Data'](query);
	  },
	
	  abort: function () {
	    this.callbacks = [];
	  },
	
	  // 完成数据请求，getData => done
	  _done: function (data) {
	    this.trigger('data', data);
	  },
	
	  _getUrlData: function (query) {
	    var that = this,
	        options;
	    var obj = {
	      query: query ? encodeURIComponent(query) : '',
	      timestamp: new Date().getTime()
	    };
	    var url = this.get('source').replace(/\{\{(.*?)\}\}/g, function (all, match) {
	      return obj[match];
	    });
	
	    var callbackId = 'callback_' + this.id++;
	    this.callbacks.push(callbackId);
	
	    if (/^(https?:\/\/)/.test(url)) {
	      options = {
	        dataType: 'jsonp'
	      };
	    } else {
	      options = {
	        dataType: 'json'
	      };
	    }
	    $.ajax(url, options).success(function (data) {
	      if ($.inArray(callbackId, that.callbacks) > -1) {
	        delete that.callbacks[callbackId];
	        that._done(data);
	      }
	    }).error(function () {
	      if ($.inArray(callbackId, that.callbacks) > -1) {
	        delete that.callbacks[callbackId];
	        that._done({});
	      }
	    });
	  },
	
	  _getArrayData: function () {
	    var source = this.get('source');
	    this._done(source);
	    return source;
	  },
	
	  _getObjectData: function () {
	    var source = this.get('source');
	    this._done(source);
	    return source;
	  },
	
	  _getFunctionData: function (query) {
	    var that = this,
	        func = this.get('source');
	
	    // 如果返回 false 可阻止执行
	    var data = func.call(this, query, done);
	    if (data) {
	      this._done(data);
	    }
	
	    function done(data) {
	      that._done(data);
	    }
	  }
	});
	
	module.exports = DataSource;
	
	function isString(str) {
	  return Object.prototype.toString.call(str) === '[object String]';
	}
	
	function capitalize(str) {
	  return str.replace(/^([a-z])/, function (f, m) {
	    return m.toUpperCase();
	  });
	}


/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	
	var Filter = {
	  'default': function (data) {
	    return data;
	  },
	
	  'startsWith': function (data, query) {
	    query = query || '';
	    var result = [],
	        l = query.length,
	        reg = new RegExp('^' + escapeKeyword(query));
	
	    if (!l) return [];
	
	    $.each(data, function (index, item) {
	      var a, matchKeys = [item.value].concat(item.alias);
	
	      // 匹配 value 和 alias 中的
	      while (a = matchKeys.shift()) {
	        if (reg.test(a)) {
	          // 匹配和显示相同才有必要高亮
	          if (item.label === a) {
	            item.highlightIndex = [
	              [0, l]
	            ];
	          }
	          result.push(item);
	          break;
	        }
	      }
	    });
	    return result;
	  },
	
	
	  'stringMatch': function (data, query) {
	    query = query || '';
	    var result = [],
	        l = query.length;
	
	    if (!l) return [];
	
	    $.each(data, function (index, item) {
	      var a, matchKeys = [item.value].concat(item.alias);
	
	      // 匹配 value 和 alias 中的
	      while (a = matchKeys.shift()) {
	        if (a.indexOf(query) > -1) {
	          // 匹配和显示相同才有必要高亮
	          if (item.label === a) {
	            item.highlightIndex = stringMatch(a, query);
	          }
	          result.push(item);
	          break;
	        }
	      }
	    });
	    return result;
	  }
	};
	
	module.exports = Filter;
	
	// 转义正则关键字
	var keyword = /(\[|\[|\]|\^|\$|\||\(|\)|\{|\}|\+|\*|\?|\\)/g;
	
	function escapeKeyword(str) {
	  return (str || '').replace(keyword, '\\$1');
	}
	
	function stringMatch(matchKey, query) {
	  var r = [],
	      a = matchKey.split('');
	  var queryIndex = 0,
	      q = query.split('');
	  for (var i = 0, l = a.length; i < l; i++) {
	    var v = a[i];
	    if (v === q[queryIndex]) {
	      if (queryIndex === q.length - 1) {
	        r.push([i - q.length + 1, i + 1]);
	        queryIndex = 0;
	        continue;
	      }
	      queryIndex++;
	    } else {
	      queryIndex = 0;
	    }
	  }
	  return r;
	}

/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var Base = __webpack_require__(9);
	
	var lteIE9 = /\bMSIE [6789]\.0\b/.test(navigator.userAgent);
	var specialKeyCodeMap = {
	  9: 'tab',
	  27: 'esc',
	  37: 'left',
	  39: 'right',
	  13: 'enter',
	  38: 'up',
	  40: 'down'
	};
	
	var Input = Base.extend({
	
	  attrs: {
	    element: {
	      value: null,
	      setter: function (val) {
	        return $(val);
	      }
	    },
	    query: null,
	    delay: 100
	  },
	
	  initialize: function () {
	    Input.superclass.initialize.apply(this, arguments);
	
	    // bind events
	    this._bindEvents();
	
	    // init query
	    this.set('query', this.getValue());
	  },
	
	  focus: function () {
	    this.get('element').focus();
	  },
	
	  getValue: function () {
	    return this.get('element').val();
	  },
	
	  setValue: function (val, silent) {
	    this.get('element').val(val);
	    !silent && this._change();
	  },
	
	  destroy: function () {
	    Input.superclass.destroy.call(this);
	  },
	
	  _bindEvents: function () {
	    var timer, input = this.get('element');
	
	    input.attr('autocomplete', 'off').on('focus.autocomplete', wrapFn(this._handleFocus, this)).on('blur.autocomplete', wrapFn(this._handleBlur, this)).on('keydown.autocomplete', wrapFn(this._handleKeydown, this));
	
	    // IE678 don't support input event
	    // IE 9 does not fire an input event when the user removes characters from input filled by keyboard, cut, or drag operations.
	    if (!lteIE9) {
	      input.on('input.autocomplete', wrapFn(this._change, this));
	    } else {
	      var that = this,
	          events = ['keydown.autocomplete', 'keypress.autocomplete', 'cut.autocomplete', 'paste.autocomplete'].join(' ');
	
	      input.on(events, wrapFn(function (e) {
	        if (specialKeyCodeMap[e.which]) return;
	
	        clearTimeout(timer);
	        timer = setTimeout(function () {
	          that._change.call(that, e);
	        }, this.get('delay'));
	      }, this));
	    }
	  },
	
	  _change: function () {
	    var newVal = this.getValue();
	    var oldVal = this.get('query');
	    var isSame = compare(oldVal, newVal);
	    var isSameExpectWhitespace = isSame ? (newVal.length !== oldVal.length) : false;
	
	    if (isSameExpectWhitespace) {
	      this.trigger('whitespaceChanged', oldVal);
	    }
	    if (!isSame) {
	      this.set('query', newVal);
	      this.trigger('queryChanged', newVal, oldVal);
	    }
	  },
	
	  _handleFocus: function (e) {
	    this.trigger('focus', e);
	  },
	
	  _handleBlur: function (e) {
	    this.trigger('blur', e);
	  },
	
	  _handleKeydown: function (e) {
	    var keyName = specialKeyCodeMap[e.which];
	    if (keyName) {
	      var eventKey = 'key' + ucFirst(keyName);
	      this.trigger(e.type = eventKey, e);
	    }
	  }
	});
	
	module.exports = Input;
	
	function wrapFn(fn, context) {
	  return function () {
	    fn.apply(context, arguments);
	  };
	}
	
	function compare(a, b) {
	  a = (a || '').replace(/^\s*/g, '').replace(/\s{2,}/g, ' ');
	  b = (b || '').replace(/^\s*/g, '').replace(/\s{2,}/g, ' ');
	  return a === b;
	}
	
	function ucFirst(str) {
	  return str.charAt(0).toUpperCase() + str.substring(1);
	}

/***/ },
/* 39 */
/***/ function(module, exports) {

	// Aspect
	// ---------------------
	// Thanks to:
	//  - http://yuilibrary.com/yui/docs/api/classes/Do.html
	//  - http://code.google.com/p/jquery-aop/
	//  - http://lazutkin.com/blog/2008/may/18/aop-aspect-javascript-dojo/
	
	
	// 在指定方法执行前，先执行 callback
	exports.before = function(methodName, callback, context) {
	  return weave.call(this, 'before', methodName, callback, context);
	};
	
	
	// 在指定方法执行后，再执行 callback
	exports.after = function(methodName, callback, context) {
	  return weave.call(this, 'after', methodName, callback, context);
	};
	
	
	// Helpers
	// -------
	
	var eventSplitter = /\s+/;
	
	function weave(when, methodName, callback, context) {
	  var names = methodName.split(eventSplitter);
	  var name, method;
	
	  while (name = names.shift()) {
	    method = getMethod(this, name);
	    if (!method.__isAspected) {
	      wrap.call(this, name);
	    }
	    this.on(when + ':' + name, callback, context);
	  }
	
	  return this;
	}
	
	
	function getMethod(host, methodName) {
	  var method = host[methodName];
	  if (!method) {
	    throw new Error('Invalid method name: ' + methodName);
	  }
	  return method;
	}
	
	
	function wrap(methodName) {
	  var old = this[methodName];
	
	  this[methodName] = function() {
	    var args = Array.prototype.slice.call(arguments);
	    var beforeArgs = ['before:' + methodName].concat(args);
	
	    // prevent if trigger return false
	    if (this.trigger.apply(this, beforeArgs) === false) return;
	
	    var ret = old.apply(this, arguments);
	    var afterArgs = ['after:' + methodName, ret].concat(args);
	    this.trigger.apply(this, afterArgs);
	
	    return ret;
	  };
	
	  this[methodName].__isAspected = true;
	}


/***/ },
/* 40 */
/***/ function(module, exports) {

	// Attribute
	// -----------------
	// Thanks to:
	//  - http://documentcloud.github.com/backbone/#Model
	//  - http://yuilibrary.com/yui/docs/api/classes/AttributeCore.html
	//  - https://github.com/berzniz/backbone.getters.setters
	
	
	// 负责 attributes 的初始化
	// attributes 是与实例相关的状态信息，可读可写，发生变化时，会自动触发相关事件
	exports.initAttrs = function(config) {
	  // initAttrs 是在初始化时调用的，默认情况下实例上肯定没有 attrs，不存在覆盖问题
	  var attrs = this.attrs = {};
	
	  // Get all inherited attributes.
	  var specialProps = this.propsInAttrs || [];
	  mergeInheritedAttrs(attrs, this, specialProps);
	
	  // Merge user-specific attributes from config.
	  if (config) {
	    mergeUserValue(attrs, config);
	  }
	
	  // 对于有 setter 的属性，要用初始值 set 一下，以保证关联属性也一同初始化
	  setSetterAttrs(this, attrs, config);
	
	  // Convert `on/before/afterXxx` config to event handler.
	  parseEventsFromAttrs(this, attrs);
	
	  // 将 this.attrs 上的 special properties 放回 this 上
	  copySpecialProps(specialProps, this, attrs, true);
	};
	
	
	// Get the value of an attribute.
	exports.get = function(key) {
	  var attr = this.attrs[key] || {};
	  var val = attr.value;
	  return attr.getter ? attr.getter.call(this, val, key) : val;
	};
	
	
	// Set a hash of model attributes on the object, firing `"change"` unless
	// you choose to silence it.
	exports.set = function(key, val, options) {
	  var attrs = {};
	
	  // set("key", val, options)
	  if (isString(key)) {
	    attrs[key] = val;
	  }
	  // set({ "key": val, "key2": val2 }, options)
	  else {
	    attrs = key;
	    options = val;
	  }
	
	  options || (options = {});
	  var silent = options.silent;
	  var override = options.override;
	
	  var now = this.attrs;
	  var changed = this.__changedAttrs || (this.__changedAttrs = {});
	
	  for (key in attrs) {
	    if (!attrs.hasOwnProperty(key)) continue;
	
	    var attr = now[key] || (now[key] = {});
	    val = attrs[key];
	
	    if (attr.readOnly) {
	      throw new Error('This attribute is readOnly: ' + key);
	    }
	
	    // invoke setter
	    if (attr.setter) {
	      val = attr.setter.call(this, val, key);
	    }
	
	    // 获取设置前的 prev 值
	    var prev = this.get(key);
	
	    // 获取需要设置的 val 值
	    // 如果设置了 override 为 true，表示要强制覆盖，就不去 merge 了
	    // 都为对象时，做 merge 操作，以保留 prev 上没有覆盖的值
	    if (!override && isPlainObject(prev) && isPlainObject(val)) {
	      val = merge(merge({}, prev), val);
	    }
	
	    // set finally
	    now[key].value = val;
	
	    // invoke change event
	    // 初始化时对 set 的调用，不触发任何事件
	    if (!this.__initializingAttrs && !isEqual(prev, val)) {
	      if (silent) {
	        changed[key] = [val, prev];
	      }
	      else {
	        this.trigger('change:' + key, val, prev, key);
	      }
	    }
	  }
	
	  return this;
	};
	
	
	// Call this method to manually fire a `"change"` event for triggering
	// a `"change:attribute"` event for each changed attribute.
	exports.change = function() {
	  var changed = this.__changedAttrs;
	
	  if (changed) {
	    for (var key in changed) {
	      if (changed.hasOwnProperty(key)) {
	        var args = changed[key];
	        this.trigger('change:' + key, args[0], args[1], key);
	      }
	    }
	    delete this.__changedAttrs;
	  }
	
	  return this;
	};
	
	// for test
	exports._isPlainObject = isPlainObject;
	
	// Helpers
	// -------
	
	var toString = Object.prototype.toString;
	var hasOwn = Object.prototype.hasOwnProperty;
	
	/**
	 * Detect the JScript [[DontEnum]] bug:
	 * In IE < 9 an objects own properties, shadowing non-enumerable ones, are
	 * made non-enumerable as well.
	 * https://github.com/bestiejs/lodash/blob/7520066fc916e205ef84cb97fbfe630d7c154158/lodash.js#L134-L144
	 */
	/** Detect if own properties are iterated after inherited properties (IE < 9) */
	var iteratesOwnLast;
	(function() {
	  var props = [];
	  function Ctor() { this.x = 1; }
	  Ctor.prototype = { 'valueOf': 1, 'y': 1 };
	  for (var prop in new Ctor()) { props.push(prop); }
	  iteratesOwnLast = props[0] !== 'x';
	}());
	
	var isArray = Array.isArray || function(val) {
	  return toString.call(val) === '[object Array]';
	};
	
	function isString(val) {
	  return toString.call(val) === '[object String]';
	}
	
	function isFunction(val) {
	  return toString.call(val) === '[object Function]';
	}
	
	function isWindow(o) {
	  return o != null && o == o.window;
	}
	
	function isPlainObject(o) {
	  // Must be an Object.
	  // Because of IE, we also have to check the presence of the constructor
	  // property. Make sure that DOM nodes and window objects don't
	  // pass through, as well
	  if (!o || toString.call(o) !== "[object Object]" ||
	      o.nodeType || isWindow(o)) {
	    return false;
	  }
	
	  try {
	    // Not own constructor property must be Object
	    if (o.constructor &&
	        !hasOwn.call(o, "constructor") &&
	        !hasOwn.call(o.constructor.prototype, "isPrototypeOf")) {
	      return false;
	    }
	  } catch (e) {
	    // IE8,9 Will throw exceptions on certain host objects #9897
	    return false;
	  }
	
	  var key;
	
	  // Support: IE<9
	  // Handle iteration over inherited properties before own properties.
	  // http://bugs.jquery.com/ticket/12199
	  if (iteratesOwnLast) {
	    for (key in o) {
	      return hasOwn.call(o, key);
	    }
	  }
	
	  // Own properties are enumerated firstly, so to speed up,
	  // if last one is own, then all properties are own.
	  for (key in o) {}
	
	  return key === undefined || hasOwn.call(o, key);
	}
	
	function isEmptyObject(o) {
	  if (!o || toString.call(o) !== "[object Object]" ||
	      o.nodeType || isWindow(o) || !o.hasOwnProperty) {
	    return false;
	  }
	
	  for (var p in o) {
	    if (o.hasOwnProperty(p)) return false;
	  }
	  return true;
	}
	
	function merge(receiver, supplier) {
	  var key, value;
	
	  for (key in supplier) {
	    if (supplier.hasOwnProperty(key)) {
	      receiver[key] = cloneValue(supplier[key], receiver[key]);
	    }
	  }
	
	  return receiver;
	}
	
	// 只 clone 数组和 plain object，其他的保持不变
	function cloneValue(value, prev){
	  if (isArray(value)) {
	    value = value.slice();
	  }
	  else if (isPlainObject(value)) {
	    isPlainObject(prev) || (prev = {});
	
	    value = merge(prev, value);
	  }
	
	  return value;
	}
	
	var keys = Object.keys;
	
	if (!keys) {
	  keys = function(o) {
	    var result = [];
	
	    for (var name in o) {
	      if (o.hasOwnProperty(name)) {
	        result.push(name);
	      }
	    }
	    return result;
	  };
	}
	
	function mergeInheritedAttrs(attrs, instance, specialProps) {
	  var inherited = [];
	  var proto = instance.constructor.prototype;
	
	  while (proto) {
	    // 不要拿到 prototype 上的
	    if (!proto.hasOwnProperty('attrs')) {
	      proto.attrs = {};
	    }
	
	    // 将 proto 上的特殊 properties 放到 proto.attrs 上，以便合并
	    copySpecialProps(specialProps, proto.attrs, proto);
	
	    // 为空时不添加
	    if (!isEmptyObject(proto.attrs)) {
	      inherited.unshift(proto.attrs);
	    }
	
	    // 向上回溯一级
	    proto = proto.constructor.superclass;
	  }
	
	  // Merge and clone default values to instance.
	  for (var i = 0, len = inherited.length; i < len; i++) {
	    mergeAttrs(attrs, normalize(inherited[i]));
	  }
	}
	
	function mergeUserValue(attrs, config) {
	  mergeAttrs(attrs, normalize(config, true), true);
	}
	
	function copySpecialProps(specialProps, receiver, supplier, isAttr2Prop) {
	  for (var i = 0, len = specialProps.length; i < len; i++) {
	    var key = specialProps[i];
	
	    if (supplier.hasOwnProperty(key)) {
	      receiver[key] = isAttr2Prop ? receiver.get(key) : supplier[key];
	    }
	  }
	}
	
	
	var EVENT_PATTERN = /^(on|before|after)([A-Z].*)$/;
	var EVENT_NAME_PATTERN = /^(Change)?([A-Z])(.*)/;
	
	function parseEventsFromAttrs(host, attrs) {
	  for (var key in attrs) {
	    if (attrs.hasOwnProperty(key)) {
	      var value = attrs[key].value, m;
	
	      if (isFunction(value) && (m = key.match(EVENT_PATTERN))) {
	        host[m[1]](getEventName(m[2]), value);
	        delete attrs[key];
	      }
	    }
	  }
	}
	
	// Converts `Show` to `show` and `ChangeTitle` to `change:title`
	function getEventName(name) {
	  var m = name.match(EVENT_NAME_PATTERN);
	  var ret = m[1] ? 'change:' : '';
	  ret += m[2].toLowerCase() + m[3];
	  return ret;
	}
	
	
	function setSetterAttrs(host, attrs, config) {
	  var options = { silent: true };
	  host.__initializingAttrs = true;
	
	  for (var key in config) {
	    if (config.hasOwnProperty(key)) {
	      if (attrs[key].setter) {
	        host.set(key, config[key], options);
	      }
	    }
	  }
	
	  delete host.__initializingAttrs;
	}
	
	
	var ATTR_SPECIAL_KEYS = ['value', 'getter', 'setter', 'readOnly'];
	
	// normalize `attrs` to
	//
	//   {
	//      value: 'xx',
	//      getter: fn,
	//      setter: fn,
	//      readOnly: boolean
	//   }
	//
	function normalize(attrs, isUserValue) {
	  var newAttrs = {};
	
	  for (var key in attrs) {
	    var attr = attrs[key];
	
	    if (!isUserValue &&
	        isPlainObject(attr) &&
	        hasOwnProperties(attr, ATTR_SPECIAL_KEYS)) {
	      newAttrs[key] = attr;
	      continue;
	    }
	
	    newAttrs[key] = {
	      value: attr
	    };
	  }
	
	  return newAttrs;
	}
	
	var ATTR_OPTIONS = ['setter', 'getter', 'readOnly'];
	// 专用于 attrs 的 merge 方法
	function mergeAttrs(attrs, inheritedAttrs, isUserValue){
	  var key, value;
	  var attr;
	
	  for (key in inheritedAttrs) {
	    if (inheritedAttrs.hasOwnProperty(key)) {
	      value = inheritedAttrs[key];
	      attr = attrs[key];
	
	      if (!attr) {
	        attr = attrs[key] = {};
	      }
	
	      // 从严谨上来说，遍历 ATTR_SPECIAL_KEYS 更好
	      // 从性能来说，直接 人肉赋值 更快
	      // 这里还是选择 性能优先
	
	      // 只有 value 要复制原值，其他的直接覆盖即可
	      (value['value'] !== undefined) && (attr['value'] = cloneValue(value['value'], attr['value']));
	
	      // 如果是用户赋值，只要考虑value
	      if (isUserValue) continue;
	
	      for (var i in ATTR_OPTIONS) {
	        var option = ATTR_OPTIONS[i];
	        if (value[option] !== undefined) {
	          attr[option] = value[option];
	        }
	      }
	    }
	  }
	
	  return attrs;
	}
	
	function hasOwnProperties(object, properties) {
	  for (var i = 0, len = properties.length; i < len; i++) {
	    if (object.hasOwnProperty(properties[i])) {
	      return true;
	    }
	  }
	  return false;
	}
	
	
	// 对于 attrs 的 value 来说，以下值都认为是空值： null, undefined, '', [], {}
	function isEmptyAttrValue(o) {
	  return o == null || // null, undefined
	      (isString(o) || isArray(o)) && o.length === 0 || // '', []
	      isEmptyObject(o); // {}
	}
	
	// 判断属性值 a 和 b 是否相等，注意仅适用于属性值的判断，非普适的 === 或 == 判断。
	function isEqual(a, b) {
	  if (a === b) return true;
	
	  if (isEmptyAttrValue(a) && isEmptyAttrValue(b)) return true;
	
	  // Compare `[[Class]]` names.
	  var className = toString.call(a);
	  if (className != toString.call(b)) return false;
	
	  switch (className) {
	
	    // Strings, numbers, dates, and booleans are compared by value.
	    case '[object String]':
	      // Primitives and their corresponding object wrappers are
	      // equivalent; thus, `"5"` is equivalent to `new String("5")`.
	      return a == String(b);
	
	    case '[object Number]':
	      // `NaN`s are equivalent, but non-reflexive. An `equal`
	      // comparison is performed for other numeric values.
	      return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
	
	    case '[object Date]':
	    case '[object Boolean]':
	      // Coerce dates and booleans to numeric primitive values.
	      // Dates are compared by their millisecond representations.
	      // Note that invalid dates with millisecond representations
	      // of `NaN` are not equivalent.
	      return +a == +b;
	
	    // RegExps are compared by their source patterns and flags.
	    case '[object RegExp]':
	      return a.source == b.source &&
	          a.global == b.global &&
	          a.multiline == b.multiline &&
	          a.ignoreCase == b.ignoreCase;
	
	    // 简单判断数组包含的 primitive 值是否相等
	    case '[object Array]':
	      var aString = a.toString();
	      var bString = b.toString();
	
	      // 只要包含非 primitive 值，为了稳妥起见，都返回 false
	      return aString.indexOf('[object') === -1 &&
	          bString.indexOf('[object') === -1 &&
	          aString === bString;
	  }
	
	  if (typeof a != 'object' || typeof b != 'object') return false;
	
	  // 简单判断两个对象是否相等，只判断第一层
	  if (isPlainObject(a) && isPlainObject(b)) {
	
	    // 键值不相等，立刻返回 false
	    if (!isEqual(keys(a), keys(b))) {
	      return false;
	    }
	
	    // 键相同，但有值不等，立刻返回 false
	    for (var p in a) {
	      if (a[p] !== b[p]) return false;
	    }
	
	    return true;
	  }
	
	  // 其他情况返回 false, 以避免误判导致 change 事件没发生
	  return false;
	}


/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	// Base
	// ---------
	// Base 是一个基础类，提供 Class、Events、Attrs 和 Aspect 支持。
	
	var Class = __webpack_require__(42);
	var Events = __webpack_require__(15);
	var Aspect = __webpack_require__(39);
	var Attribute = __webpack_require__(40);
	
	
	module.exports = Class.create({
	  Implements: [Events, Aspect, Attribute],
	
	  initialize: function(config) {
	    this.initAttrs(config);
	
	    // Automatically register `this._onChangeAttr` method as
	    // a `change:attr` event handler.
	    parseEventsFromInstance(this, this.attrs);
	  },
	
	  destroy: function() {
	    this.off();
	
	    for (var p in this) {
	      if (this.hasOwnProperty(p)) {
	        delete this[p];
	      }
	    }
	
	    // Destroy should be called only once, generate a fake destroy after called
	    // https://github.com/aralejs/widget/issues/50
	    this.destroy = function() {};
	  }
	});
	
	
	function parseEventsFromInstance(host, attrs) {
	  for (var attr in attrs) {
	    if (attrs.hasOwnProperty(attr)) {
	      var m = '_onChange' + ucfirst(attr);
	      if (host[m]) {
	        host.on('change:' + attr, host[m]);
	      }
	    }
	  }
	}
	
	function ucfirst(str) {
	  return str.charAt(0).toUpperCase() + str.substring(1);
	}


/***/ },
/* 42 */
/***/ function(module, exports) {

	// Class
	// -----------------
	// Thanks to:
	//  - http://mootools.net/docs/core/Class/Class
	//  - http://ejohn.org/blog/simple-javascript-inheritance/
	//  - https://github.com/ded/klass
	//  - http://documentcloud.github.com/backbone/#Model-extend
	//  - https://github.com/joyent/node/blob/master/lib/util.js
	//  - https://github.com/kissyteam/kissy/blob/master/src/seed/src/kissy.js
	
	
	// The base Class implementation.
	function Class(o) {
	  // Convert existed function to Class.
	  if (!(this instanceof Class) && isFunction(o)) {
	    return classify(o)
	  }
	}
	
	module.exports = Class
	
	
	// Create a new Class.
	//
	//  var SuperPig = Class.create({
	//    Extends: Animal,
	//    Implements: Flyable,
	//    initialize: function() {
	//      SuperPig.superclass.initialize.apply(this, arguments)
	//    },
	//    Statics: {
	//      COLOR: 'red'
	//    }
	// })
	//
	Class.create = function(parent, properties) {
	  if (!isFunction(parent)) {
	    properties = parent
	    parent = null
	  }
	
	  properties || (properties = {})
	  parent || (parent = properties.Extends || Class)
	  properties.Extends = parent
	
	  // The created class constructor
	  function SubClass() {
	    // Call the parent constructor.
	    parent.apply(this, arguments)
	
	    // Only call initialize in self constructor.
	    if (this.constructor === SubClass && this.initialize) {
	      this.initialize.apply(this, arguments)
	    }
	  }
	
	  // Inherit class (static) properties from parent.
	  if (parent !== Class) {
	    mix(SubClass, parent, parent.StaticsWhiteList)
	  }
	
	  // Add instance properties to the subclass.
	  implement.call(SubClass, properties)
	
	  // Make subclass extendable.
	  return classify(SubClass)
	}
	
	
	function implement(properties) {
	  var key, value
	
	  for (key in properties) {
	    value = properties[key]
	
	    if (Class.Mutators.hasOwnProperty(key)) {
	      Class.Mutators[key].call(this, value)
	    } else {
	      this.prototype[key] = value
	    }
	  }
	}
	
	
	// Create a sub Class based on `Class`.
	Class.extend = function(properties) {
	  properties || (properties = {})
	  properties.Extends = this
	
	  return Class.create(properties)
	}
	
	
	function classify(cls) {
	  cls.extend = Class.extend
	  cls.implement = implement
	  return cls
	}
	
	
	// Mutators define special properties.
	Class.Mutators = {
	
	  'Extends': function(parent) {
	    var existed = this.prototype
	    var proto = createProto(parent.prototype)
	
	    // Keep existed properties.
	    mix(proto, existed)
	
	    // Enforce the constructor to be what we expect.
	    proto.constructor = this
	
	    // Set the prototype chain to inherit from `parent`.
	    this.prototype = proto
	
	    // Set a convenience property in case the parent's prototype is
	    // needed later.
	    this.superclass = parent.prototype
	  },
	
	  'Implements': function(items) {
	    isArray(items) || (items = [items])
	    var proto = this.prototype, item
	
	    while (item = items.shift()) {
	      mix(proto, item.prototype || item)
	    }
	  },
	
	  'Statics': function(staticProperties) {
	    mix(this, staticProperties)
	  }
	}
	
	
	// Shared empty constructor function to aid in prototype-chain creation.
	function Ctor() {
	}
	
	// See: http://jsperf.com/object-create-vs-new-ctor
	var createProto = Object.__proto__ ?
	    function(proto) {
	      return { __proto__: proto }
	    } :
	    function(proto) {
	      Ctor.prototype = proto
	      return new Ctor()
	    }
	
	
	// Helpers
	// ------------
	
	function mix(r, s, wl) {
	  // Copy "all" properties including inherited ones.
	  for (var p in s) {
	    if (s.hasOwnProperty(p)) {
	      if (wl && indexOf(wl, p) === -1) continue
	
	      // 在 iPhone 1 代等设备的 Safari 中，prototype 也会被枚举出来，需排除
	      if (p !== 'prototype') {
	        r[p] = s[p]
	      }
	    }
	  }
	}
	
	
	var toString = Object.prototype.toString
	
	var isArray = Array.isArray || function(val) {
	    return toString.call(val) === '[object Array]'
	}
	
	var isFunction = function(val) {
	  return toString.call(val) === '[object Function]'
	}
	
	var indexOf = Array.prototype.indexOf ?
	    function(arr, item) {
	      return arr.indexOf(item)
	    } :
	    function(arr, item) {
	      for (var i = 0, len = arr.length; i < len; i++) {
	        if (arr[i] === item) {
	          return i
	        }
	      }
	      return -1
	    }


/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(14);
	module.exports.ConfirmBox = __webpack_require__(44);


/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2),
	    Dialog = __webpack_require__(14);
	
	var template = __webpack_require__(32);
	
	// ConfirmBox
	// -------
	// ConfirmBox 是一个有基础模板和样式的对话框组件。
	var ConfirmBox = Dialog.extend({
	
	  attrs: {
	    title: '默认标题',
	
	    confirmTpl: '<a class="ui-dialog-button-orange" href="javascript:;">确定</a>',
	
	    cancelTpl: '<a class="ui-dialog-button-white" href="javascript:;">取消</a>',
	
	    message: '默认内容'
	  },
	
	  setup: function () {
	    ConfirmBox.superclass.setup.call(this);
	
	    var model = {
	      classPrefix: this.get('classPrefix'),
	      message: this.get('message'),
	      title: this.get('title'),
	      confirmTpl: this.get('confirmTpl'),
	      cancelTpl: this.get('cancelTpl'),
	      hasFoot: this.get('confirmTpl') || this.get('cancelTpl')
	    };
	    this.set('content', template(model));
	  },
	
	  events: {
	    'click [data-role=confirm]': function (e) {
	      e.preventDefault();
	      this.trigger('confirm');
	    },
	    'click [data-role=cancel]': function (e) {
	      e.preventDefault();
	      this.trigger('cancel');
	      this.hide();
	    }
	  },
	
	  _onChangeMessage: function (val) {
	    this.$('[data-role=message]').html(val);
	  },
	
	  _onChangeTitle: function (val) {
	    this.$('[data-role=title]').html(val);
	  },
	
	  _onChangeConfirmTpl: function (val) {
	    this.$('[data-role=confirm]').html(val);
	  },
	
	  _onChangeCancelTpl: function (val) {
	    this.$('[data-role=cancel]').html(val);
	  }
	
	});
	
	ConfirmBox.alert = function (message, callback, options) {
	  var defaults = {
	    message: message,
	    title: '',
	    cancelTpl: '',
	    closeTpl: '',
	    onConfirm: function () {
	      callback && callback();
	      this.hide();
	    }
	  };
	  new ConfirmBox($.extend(null, defaults, options)).show().after('hide', function () {
	    this.destroy();
	  });
	};
	
	ConfirmBox.confirm = function (message, title, onConfirm, onCancel, options) {
	  // support confirm(message, title, onConfirm, options)
	  if (typeof onCancel === 'object' && !options) {
	    options = onCancel;
	  }
	
	  var defaults = {
	    message: message,
	    title: title || '确认框',
	    closeTpl: '',
	    onConfirm: function () {
	      onConfirm && onConfirm();
	      this.hide();
	    },
	    onCancel: function () {
	      onCancel && onCancel();
	      this.hide();
	    }
	  };
	  new ConfirmBox($.extend(null, defaults, options)).show().after('hide', function () {
	    this.destroy();
	  });
	};
	
	ConfirmBox.show = function (message, callback, options) {
	  var defaults = {
	    message: message,
	    title: '',
	    confirmTpl: false,
	    cancelTpl: false
	  };
	  new ConfirmBox($.extend(null, defaults, options)).show().before('hide', function () {
	    callback && callback();
	  }).after('hide', function () {
	    this.destroy();
	  });
	};
	
	module.exports = ConfirmBox;


/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {

	// Based on Easing Equations (c) 2003 Robert Penner, all rights reserved.
	// This work is subject to the terms in
	// http://www.robertpenner.com/easing_terms_of_use.html
	// Preview: http://www.robertpenner.com/Easing/easing_demo.html
	//
	// Thanks to:
	//  - https://github.com/yui/yui3/blob/master/src/anim/js/anim-easing.js
	//  - https://github.com/gilmoreorless/jquery-easing-molecules
	
	
	var PI = Math.PI;
	var pow = Math.pow;
	var sin = Math.sin;
	var MAGIC_NUM = 1.70158; // Penner's magic number
	
	
	/**
	 * 和 YUI 的 Easing 相比，这里的 Easing 进行了归一化处理，参数调整为：
	 * @param {Number} t Time value used to compute current value 0 =< t <= 1
	 * @param {Number} b Starting value  b = 0
	 * @param {Number} c Delta between start and end values  c = 1
	 * @param {Number} d Total length of animation d = 1
	 */
	var Easing = {
	
	    /**
	     * Uniform speed between points.
	     */
	    easeNone: function(t) {
	        return t;
	    },
	
	    /**
	     * Begins slowly and accelerates towards end. (quadratic)
	     */
	    easeIn: function(t) {
	        return t * t;
	    },
	
	    /**
	     * Begins quickly and decelerates towards end.  (quadratic)
	     */
	    easeOut: function(t) {
	        return (2 - t) * t;
	    },
	
	    /**
	     * Begins slowly and decelerates towards end. (quadratic)
	     */
	    easeBoth: function(t) {
	        return (t *= 2) < 1 ?
	                .5 * t * t :
	                .5 * (1 - (--t) * (t - 2));
	    },
	
	    /**
	     * Begins slowly and accelerates towards end. (quartic)
	     */
	    easeInStrong: function(t) {
	        return t * t * t * t;
	    },
	    /**
	     * Begins quickly and decelerates towards end.  (quartic)
	     */
	    easeOutStrong: function(t) {
	        return 1 - (--t) * t * t * t;
	    },
	
	    /**
	     * Begins slowly and decelerates towards end. (quartic)
	     */
	    easeBothStrong: function(t) {
	        return (t *= 2) < 1 ?
	                .5 * t * t * t * t :
	                .5 * (2 - (t -= 2) * t * t * t);
	    },
	
	    /**
	     * Backtracks slightly, then reverses direction and moves to end.
	     */
	    backIn: function(t) {
	        if (t === 1) t -= .001;
	        return t * t * ((MAGIC_NUM + 1) * t - MAGIC_NUM);
	    },
	
	    /**
	     * Overshoots end, then reverses and comes back to end.
	     */
	    backOut: function(t) {
	        return (t -= 1) * t * ((MAGIC_NUM + 1) * t + MAGIC_NUM) + 1;
	    },
	
	    /**
	     * Backtracks slightly, then reverses direction, overshoots end,
	     * then reverses and comes back to end.
	     */
	    backBoth: function(t) {
	        var s = MAGIC_NUM;
	        var m = (s *= 1.525) + 1;
	
	        if ((t *= 2 ) < 1) {
	            return .5 * (t * t * (m * t - s));
	        }
	        return .5 * ((t -= 2) * t * (m * t + s) + 2);
	    },
	
	    /**
	     * Snap in elastic effect.
	     */
	    elasticIn: function(t) {
	        var p = .3, s = p / 4;
	        if (t === 0 || t === 1) return t;
	        return -(pow(2, 10 * (t -= 1)) * sin((t - s) * (2 * PI) / p));
	    },
	
	    /**
	     * Snap out elastic effect.
	     */
	    elasticOut: function(t) {
	        var p = .3, s = p / 4;
	        if (t === 0 || t === 1) return t;
	        return pow(2, -10 * t) * sin((t - s) * (2 * PI) / p) + 1;
	    },
	
	    /**
	     * Snap both elastic effect.
	     */
	    elasticBoth: function(t) {
	        var p = .45, s = p / 4;
	        if (t === 0 || (t *= 2) === 2) return t;
	
	        if (t < 1) {
	            return -.5 * (pow(2, 10 * (t -= 1)) *
	                    sin((t - s) * (2 * PI) / p));
	        }
	        return pow(2, -10 * (t -= 1)) *
	                sin((t - s) * (2 * PI) / p) * .5 + 1;
	    },
	
	    /**
	     * Bounce off of start.
	     */
	    bounceIn: function(t) {
	        return 1 - Easing.bounceOut(1 - t);
	    },
	
	    /**
	     * Bounces off end.
	     */
	    bounceOut: function(t) {
	        var s = 7.5625, r;
	
	        if (t < (1 / 2.75)) {
	            r = s * t * t;
	        }
	        else if (t < (2 / 2.75)) {
	            r = s * (t -= (1.5 / 2.75)) * t + .75;
	        }
	        else if (t < (2.5 / 2.75)) {
	            r = s * (t -= (2.25 / 2.75)) * t + .9375;
	        }
	        else {
	            r = s * (t -= (2.625 / 2.75)) * t + .984375;
	        }
	
	        return r;
	    },
	
	    /**
	     * Bounces off start and end.
	     */
	    bounceBoth: function(t) {
	        if (t < .5) {
	            return Easing.bounceIn(t * 2) * .5;
	        }
	        return Easing.bounceOut(t * 2 - 1) * .5 + .5;
	    }
	};
	
	// 可以通过 require 获取
	module.exports = Easing;
	
	
	// 也可以直接通过 jQuery.easing 来使用
	var $ = __webpack_require__(2);
	$.extend($.easing, Easing);


/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var Position = __webpack_require__(24);
	
	var isIE6 = (window.navigator.userAgent || '').toLowerCase().indexOf('msie 6') !== -1;
	
	// target 是需要添加垫片的目标元素，可以传 `DOM Element` 或 `Selector`
	function Shim(target) {
	    // 如果选择器选了多个 DOM，则只取第一个
	    this.target = $(target).eq(0);
	}
	
	// 根据目标元素计算 iframe 的显隐、宽高、定位
	Shim.prototype.sync = function() {
	    var target = this.target;
	    var iframe = this.iframe;
	
	    // 如果未传 target 则不处理
	    if (!target.length) return this;
	
	    var height = target.outerHeight();
	    var width = target.outerWidth();
	
	    // 如果目标元素隐藏，则 iframe 也隐藏
	    // jquery 判断宽高同时为 0 才算隐藏，这里判断宽高其中一个为 0 就隐藏
	    // http://api.jquery.com/hidden-selector/
	    if (!height || !width || target.is(':hidden')) {
	        iframe && iframe.hide();
	    } else {
	        // 第一次显示时才创建：as lazy as possible
	        iframe || (iframe = this.iframe = createIframe(target));
	
	        iframe.css({
	            'height': height,
	            'width': width
	        });
	
	        Position.pin(iframe[0], target[0]);
	        iframe.show();
	    }
	
	    return this;
	};
	
	// 销毁 iframe 等
	Shim.prototype.destroy = function() {
	    if (this.iframe) {
	        this.iframe.remove();
	        delete this.iframe;
	    }
	    delete this.target;
	};
	
	if (isIE6) {
	    module.exports = Shim;
	} else {
	    // 除了 IE6 都返回空函数
	    function Noop() {}
	
	    Noop.prototype.sync = function() {return this};
	    Noop.prototype.destroy = Noop;
	
	    module.exports = Noop;
	}
	
	// Helpers
	
	// 在 target 之前创建 iframe，这样就没有 z-index 问题
	// iframe 永远在 target 下方
	function createIframe(target) {
	    var css = {
	        display: 'none',
	        border: 'none',
	        opacity: 0,
	        position: 'absolute'
	    };
	
	    // 如果 target 存在 zIndex 则设置
	    var zIndex = target.css('zIndex');
	    if (zIndex && zIndex > 0) {
	        css.zIndex = zIndex - 1;
	    }
	
	    return $('<iframe>', {
	        src: 'javascript:\'\'', // 不加的话，https 下会弹警告
	        frameborder: 0,
	        css: css
	    }).insertBefore(target);
	}


/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2),
	    Overlay = __webpack_require__(16),
	    
	    
	    ua = (window.navigator.userAgent || "").toLowerCase(),
	    isIE6 = ua.indexOf("msie 6") !== -1,
	    
	    
	    body = $(document.body),
	    doc = $(document);
	
	
	// Mask
	// ----------
	// 全屏遮罩层组件
	var Mask = Overlay.extend({
	
	  attrs: {
	    width: isIE6 ? doc.outerWidth(true) : '100%',
	    height: isIE6 ? doc.outerHeight(true) : '100%',
	
	    className: 'ui-mask',
	    opacity: 0.2,
	    backgroundColor: '#000',
	    style: {
	      position: isIE6 ? 'absolute' : 'fixed',
	      top: 0,
	      left: 0
	    },
	
	    align: {
	      // undefined 表示相对于当前可视范围定位
	      baseElement: isIE6 ? body : undefined
	    }
	  },
	
	  show: function () {
	    if (isIE6) {
	      this.set('width', doc.outerWidth(true));
	      this.set('height', doc.outerHeight(true));
	    }
	    return Mask.superclass.show.call(this);
	  },
	
	  _onRenderBackgroundColor: function (val) {
	    this.element.css('backgroundColor', val);
	  },
	
	  _onRenderOpacity: function (val) {
	    this.element.css('opacity', val);
	  }
	});
	
	// 单例
	module.exports = new Mask();

/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var Overlay = __webpack_require__(10);
	
	
	// Popup 是可触发 Overlay 型 UI 组件
	var Popup = Overlay.extend({
	
	  attrs: {
	    // 触发元素
	    trigger: {
	      value: null,
	      // required
	      getter: function (val) {
	        return $(val);
	      }
	    },
	
	    // 触发类型
	    triggerType: 'hover',
	    // or click or focus
	    // 触发事件委托的对象
	    delegateNode: {
	      value: null,
	      getter: function (val) {
	        return $(val);
	      }
	    },
	
	    // 默认的定位参数
	    align: {
	      value: {
	        baseXY: [0, '100%'],
	        selfXY: [0, 0]
	      },
	      setter: function (val) {
	        if (!val) {
	          return;
	        }
	        if (val.baseElement) {
	          this._specifiedBaseElement = true;
	        } else if (this.activeTrigger) {
	          // 若给的定位元素未指定基准元素
	          // 就给一个...
	          val.baseElement = this.activeTrigger;
	        }
	        return val;
	      },
	      getter: function (val) {
	        // 若未指定基准元素，则按照当前的触发元素进行定位
	        return $.extend({}, val, this._specifiedBaseElement ? {} : {
	          baseElement: this.activeTrigger
	        });
	      }
	    },
	
	    // 延迟触发和隐藏时间
	    delay: 70,
	
	    // 是否能够触发
	    // 可以通过set('disabled', true)关闭
	    disabled: false,
	
	    // 基本的动画效果，可选 fade|slide
	    effect: '',
	
	    // 动画的持续时间
	    duration: 250
	
	  },
	
	  setup: function () {
	    Popup.superclass.setup.call(this);
	    this._bindTrigger();
	    this._blurHide(this.get('trigger'));
	
	    // 默认绑定activeTrigger为第一个元素
	    // for https://github.com/aralejs/popup/issues/6
	    this.activeTrigger = this.get('trigger').eq(0);
	
	    // 当使用委托事件时，_blurHide 方法对于新添加的节点会失效
	    // 这时需要重新绑定
	    var that = this;
	    if (this.get('delegateNode')) {
	      this.before('show', function () {
	        that._relativeElements = that.get('trigger');
	        that._relativeElements.push(that.element);
	      });
	    }
	  },
	
	  render: function () {
	    Popup.superclass.render.call(this);
	
	    // 通过 template 生成的元素默认也应该是不可见的
	    // 所以插入元素前强制隐藏元素，#20
	    this.element.hide();
	    return this;
	  },
	
	  show: function () {
	    if (this.get('disabled')) {
	      return;
	    }
	    return Popup.superclass.show.call(this);
	  },
	
	  // triggerShimSync 为 true 时
	  // 表示什么都不做，只是触发 hide 的 before/after 绑定方法
	  hide: function (triggerShimSync) {
	    if (!triggerShimSync) {
	      return Popup.superclass.hide.call(this);
	    }
	    return this;
	  },
	
	  _bindTrigger: function () {
	    var triggerType = this.get('triggerType');
	
	    if (triggerType === 'click') {
	      this._bindClick();
	    } else if (triggerType === 'focus') {
	      this._bindFocus();
	    } else {
	      // 默认是 hover
	      this._bindHover();
	    }
	  },
	
	  _bindClick: function () {
	    var that = this;
	
	    bindEvent('click', this.get('trigger'), function (e) {
	      // this._active 这个变量表明了当前触发元素是激活状态
	      if (this._active === true) {
	        that.hide();
	      } else {
	        // 将当前trigger标为激活状态
	        makeActive(this);
	        that.show();
	      }
	    }, this.get('delegateNode'), this);
	
	    // 隐藏前清空激活状态
	    this.before('hide', function () {
	      makeActive();
	    });
	
	    // 处理所有trigger的激活状态
	    // 若 trigger 为空，相当于清除所有元素的激活状态
	
	
	    function makeActive(trigger) {
	      if (that.get('disabled')) {
	        return;
	      }
	      that.get('trigger').each(function (i, item) {
	        if (trigger == item) {
	          item._active = true;
	          // 标识当前点击的元素
	          that.activeTrigger = $(item);
	        } else {
	          item._active = false;
	        }
	      });
	    }
	  },
	
	  _bindFocus: function () {
	    var that = this;
	
	    bindEvent('focus', this.get('trigger'), function () {
	      // 标识当前点击的元素
	      that.activeTrigger = $(this);
	      that.show();
	    }, this.get('delegateNode'), this);
	
	    bindEvent('blur', this.get('trigger'), function () {
	      setTimeout(function () {
	        (!that._downOnElement) && that.hide();
	        that._downOnElement = false;
	      }, that.get('delay'));
	    }, this.get('delegateNode'), this);
	
	    // 为了当input blur时能够选择和操作弹出层上的内容
	    this.delegateEvents("mousedown", function (e) {
	      this._downOnElement = true;
	    });
	  },
	
	  _bindHover: function () {
	    var trigger = this.get('trigger');
	    var delegateNode = this.get('delegateNode');
	    var delay = this.get('delay');
	
	    var showTimer, hideTimer;
	    var that = this;
	
	    // 当 delay 为负数时
	    // popup 变成 tooltip 的效果
	    if (delay < 0) {
	      this._bindTooltip();
	      return;
	    }
	
	    bindEvent('mouseenter', trigger, function () {
	      clearTimeout(hideTimer);
	      hideTimer = null;
	
	      // 标识当前点击的元素
	      that.activeTrigger = $(this);
	      showTimer = setTimeout(function () {
	        that.show();
	      }, delay);
	    }, delegateNode, this);
	
	    bindEvent('mouseleave', trigger, leaveHandler, delegateNode, this);
	
	    // 鼠标在悬浮层上时不消失
	    this.delegateEvents("mouseenter", function () {
	      clearTimeout(hideTimer);
	    });
	    this.delegateEvents("mouseleave", leaveHandler);
	
	    this.element.on('mouseleave', 'select', function (e) {
	      e.stopPropagation();
	    });
	
	    function leaveHandler(e) {
	      clearTimeout(showTimer);
	      showTimer = null;
	
	      if (that.get('visible')) {
	        hideTimer = setTimeout(function () {
	          that.hide();
	        }, delay);
	      }
	    }
	  },
	
	  _bindTooltip: function () {
	    var trigger = this.get('trigger');
	    var delegateNode = this.get('delegateNode');
	    var that = this;
	
	    bindEvent('mouseenter', trigger, function () {
	      // 标识当前点击的元素
	      that.activeTrigger = $(this);
	      that.show();
	    }, delegateNode, this);
	
	    bindEvent('mouseleave', trigger, function () {
	      that.hide();
	    }, delegateNode, this);
	  },
	
	  _onRenderVisible: function (val, originVal) {
	    // originVal 为 undefined 时不继续执行
	    if (val === !! originVal) {
	      return;
	    }
	
	    var fade = (this.get('effect').indexOf('fade') !== -1);
	    var slide = (this.get('effect').indexOf('slide') !== -1);
	    var animConfig = {};
	    slide && (animConfig.height = (val ? 'show' : 'hide'));
	    fade && (animConfig.opacity = (val ? 'show' : 'hide'));
	
	    // 需要在回调时强制调一下 hide
	    // 来触发 iframe-shim 的 sync 方法
	    // 修复 ie6 下 shim 未隐藏的问题
	    // visible 只有从 true 变为 false 时，才调用这个 hide
	    var that = this;
	    var hideComplete = val ?
	    function () {
	      that.trigger('animated');
	    } : function () {
	      // 参数 true 代表只是为了触发 shim 方法
	      that.hide(true);
	      that.trigger('animated');
	    };
	
	    if (fade || slide) {
	      this.element.stop(true, true).animate(animConfig, this.get('duration'), hideComplete).css({
	        'visibility': 'visible'
	      });
	    } else {
	      this.element[val ? 'show' : 'hide']();
	    }
	  }
	
	});
	
	module.exports = Popup;
	
	// 一个绑定事件的简单封装
	
	
	function bindEvent(type, element, fn, delegateNode, context) {
	  var hasDelegateNode = delegateNode && delegateNode[0];
	
	  context.delegateEvents(
	  hasDelegateNode ? delegateNode : element, hasDelegateNode ? type + " " + element.selector : type, function (e) {
	    fn.call(e.currentTarget, e);
	  });
	}

/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2),
	    doc = $(document),
	    stickyPrefix = ["-webkit-", "-ms-", "-o-", "-moz-", ""],
	    guid = 0,
	
	    ua = (window.navigator.userAgent || "").toLowerCase(),
	    isIE = ua.indexOf("msie") !== -1,
	    isIE6 = ua.indexOf("msie 6") !== -1;
	
	var isPositionStickySupported = checkPositionStickySupported(),
	    isPositionFixedSupported = checkPositionFixedSupported();
	
	
	// Sticky
	// position: sticky simulator
	function Sticky(options) {
	    this.options = options || {};
	    this.elem = $(this.options.element);        
	    this.callback = options.callback || function() {};
	    this.position = options.position;
	    this._stickyId = guid++;
	}
	
	Sticky.prototype._prepare = function() {
	    // save element's origin position
	    var offset = this.elem.offset();
	    this._originTop = offset.top;
	    this._originLeft = offset.left;
	
	    // if is fixed, force to call this_supportFixed
	    if (this.position.top === Number.MAX_VALUE) {
	        this._callFix = true;
	        this.position.top = this._originTop;
	    }
	
	    // save element's origin style
	    this._originStyles = {
	        position: null,
	        top: null,
	        bottom: null,
	        left: null
	    };
	    for (var style in this._originStyles) {
	        if (this._originStyles.hasOwnProperty(style)) {
	            this._originStyles[style] = this.elem.css(style);
	        }
	    }
	};
	
	Sticky.prototype.render = function () {
	    var self = this;
	
	    // only bind once
	    if (!this.elem.length || this.elem.data('bind-sticked')) {
	        return this;
	    }
	
	    this._prepare();
	
	    // if other element change height in one page,
	    // or if resize window,
	    // need adjust sticky element's status
	    this.adjust = function() {
	        self._restore();
	
	        var offset = self.elem.offset();
	        self._originTop = offset.top;
	        self._originLeft = offset.left;
	
	        scrollFn.call(self);
	    };
	
	    var scrollFn;
	    if (sticky.isPositionStickySupported && !this._callFix) {
	        scrollFn = this._supportSticky;
	
	        // set position: sticky directly
	        var tmp = "";
	        for (var i = 0; i < stickyPrefix.length; i++) {
	            tmp += "position:" + stickyPrefix[i] + "sticky;";
	        }
	        if (this.position.top !== undefined) {
	            tmp += "top: " + this.position.top + "px;";
	        }
	        if (this.position.bottom !== undefined) {
	            tmp += "bottom: " + this.position.bottom + "px;";
	        }
	        this.elem[0].style.cssText += tmp;
	
	        this.adjust = function() {
	            scrollFn.call(self);
	        };
	    } else if (sticky.isPositionFixedSupported) {
	        scrollFn = this._supportFixed;
	    } else {
	        scrollFn = this._supportAbsolute;   // ie6
	        // avoid floatImage Shake for IE6
	        // see: https://github.com/lifesinger/lifesinger.
	        //      github.com/blob/master/lab/2009/ie6sticked_position_v4.html
	        $("<style type='text/css'> * html" +
	          "{ background:url(null) no-repeat fixed; } </style>").appendTo("head");
	    }
	
	    // first run after document ready
	    scrollFn.call(this);
	
	    // stickyX is event namespace
	    $(window).on('scroll.sticky' + this._stickyId, function () {
	        if (!self.elem.is(':visible')) return;
	        scrollFn.call(self);
	    });
	
	    $(window).on('resize.sticky' + this._stickyId, debounce(function() {
	        self.adjust();
	    }, 120));
	
	    this.elem.data('bind-sticked', true);
	
	    return this;
	};
	
	Sticky.prototype._getTopBottom = function(scrollTop, offsetTop) {
	    var top;
	    var bottom;
	
	    // top is true when the distance from element to top of window <= position.top
	    if (this.position.top !== undefined) {
	        top = offsetTop - scrollTop <= this.position.top;
	    }
	    // bottom is true when the distance is from bottom of element to bottom of window <= position.bottom
	    if (this.position.bottom !== undefined) {
	        bottom = scrollTop + $(window).height() - offsetTop - this.elem.outerHeight() <= this.position.bottom;
	    }
	
	    return {
	        top: top,
	        bottom: bottom
	    };
	};
	
	Sticky.prototype._supportFixed = function () {
	    var _sticky = this.elem.data('sticked');
	    var distance = this._getTopBottom(doc.scrollTop(), this._originTop);
	
	    if (!_sticky &&
	        (distance.top !== undefined && distance.top ||
	            distance.bottom !== undefined && distance.bottom)) {
	        this._addPlaceholder();
	
	        this.elem.css($.extend({
	            position: 'fixed',
	            left: this._originLeft
	        }, distance.top ? { top: this.position.top } : { bottom: this.position.bottom }));
	        this.elem.data('sticked', true);
	        this.callback.call(this, true);
	    } else if (_sticky && !distance.top && !distance.bottom) {
	        this._restore();
	    }
	};
	
	Sticky.prototype._supportAbsolute = function () {
	    var scrollTop = doc.scrollTop();
	    var _sticky = this.elem.data('sticked');
	    var distance = this._getTopBottom(scrollTop, this.elem.offset().top);
	
	    if (distance.top || distance.bottom || this._callFix) {
	        // sticky status change only one time
	        if (!_sticky) {
	            this._addPlaceholder();
	            this.elem.data('sticked', true);
	            this.callback.call(this, true);
	        }
	        // update element's position
	        this.elem.css({
	            position: 'absolute',
	            top: this._callFix ? this._originTop + scrollTop: (distance.top ? this.position.top + scrollTop :
	                scrollTop + $(window).height() - this.position.bottom - this.elem.outerHeight())
	        });
	    } else if (_sticky && !distance.top && !distance.bottom) {
	        this._restore();
	    }
	};
	
	Sticky.prototype._supportSticky = function () {
	    // sticky status change for callback
	    var _sticky = this.elem.data('sticked');
	    var distance = this._getTopBottom(doc.scrollTop(), this.elem.offset().top);
	
	    if (!_sticky &&
	        (distance.top !== undefined && distance.top ||
	            distance.bottom !== undefined && distance.bottom)) {
	        this.elem.data('sticked', true);
	        this.callback.call(this, true);
	    } else if (_sticky && !distance.top && !distance.bottom){
	        // don't need restore style and remove placeholder
	        this.elem.data('sticked', false);
	        this.callback.call(this, false);
	    }
	};
	
	Sticky.prototype._restore = function () {
	    this._removePlaceholder();
	
	    // set origin style
	    this.elem.css(this._originStyles);
	
	    this.elem.data('sticked', false);
	
	    this.callback.call(this, false);
	};
	
	// need placeholder when: 1) position: static or relative, but expect for display != block
	Sticky.prototype._addPlaceholder = function() {
	    var need = false;
	    var position = this.elem.css("position");
	
	    if (position === 'static' || position === 'relative') {
	        need = true;
	    }
	    if (this.elem.css("display") !== "block") {
	        need = false;
	    }
	
	    if (need) {
	        this._placeholder = $('<div style="visibility:hidden;margin:0;padding:0;"></div>');
	        this._placeholder.width(this.elem.outerWidth(true))
	            .height(this.elem.outerHeight(true))
	            .css("float", this.elem.css("float")).insertAfter(this.elem);
	    }
	};
	
	Sticky.prototype._removePlaceholder = function() {
	    // remove placeholder if has
	    this._placeholder && this._placeholder.remove();
	};
	
	Sticky.prototype.destroy = function () {
	    this._restore();
	    this.elem.data("bind-sticked", false);
	    $(window).off('scroll.sticky' + this._stickyId);
	    $(window).off('resize.sticky' + this._stickyId);
	};
	
	// APIs
	// ---
	
	module.exports = sticky;
	
	function sticky(elem, position, callback) {
	    if (!$.isPlainObject(position)) {
	        position = {
	            top: position
	        };
	    }
	    if (position.top === undefined && position.bottom === undefined) {
	        position.top = 0;
	    }
	    return (new Sticky({
	        element: elem,
	        position: position,
	        callback: callback
	    })).render();
	}
	
	// sticky.stick(elem, position, callback)
	sticky.stick = sticky;
	
	// sticky.fix(elem)
	sticky.fix =  function (elem) {
	    return (new Sticky({
	        element: elem,
	        // position.top is Number.MAX_VALUE means fixed
	        position: {
	            top: Number.MAX_VALUE
	        }
	    })).render();
	};
	
	// for tc
	sticky.isPositionStickySupported = isPositionStickySupported;
	sticky.isPositionFixedSupported = isPositionFixedSupported;
	
	// Helper
	// ---
	function checkPositionFixedSupported() {
	    return !isIE6;
	}
	
	function checkPositionStickySupported() {
	    if (isIE) return false;
	
	    var container = doc[0].body;
	
	    if (doc[0].createElement && container && container.appendChild && container.removeChild) {
	        var isSupported,
	            el = doc[0].createElement("div"),
	            getStyle = function (st) {
	                if (window.getComputedStyle) {
	                    return window.getComputedStyle(el).getPropertyValue(st);
	                } else {
	                    return el.currentStyle.getAttribute(st);
	                }
	            };
	
	        container.appendChild(el);
	
	        for (var i = 0; i < stickyPrefix.length; i++) {
	            el.style.cssText = "position:" + stickyPrefix[i] + "sticky;visibility:hidden;";
	            if (isSupported = getStyle("position").indexOf("sticky") !== -1) break;
	        }
	
	        el.parentNode.removeChild(el);
	        return isSupported;
	    }
	}
	
	// https://github.com/jashkenas/underscore/blob/master/underscore.js#L699
	function getTime() {
	    return (Date.now || function() {
	        return new Date().getTime();
	    })()
	}
	function debounce(func, wait, immediate) {
	    var timeout, args, context, timestamp, result;
	    return function() {
	        context = this;
	        args = arguments;
	        timestamp = getTime();
	        var later = function() {
	            var last = getTime() - timestamp;
	            if (last < wait) {
	                timeout = setTimeout(later, wait - last);
	            } else {
	                timeout = null;
	                if (!immediate) result = func.apply(context, args);
	            }
	        };
	        var callNow = immediate && !timeout;
	        if (!timeout) {
	            timeout = setTimeout(later, wait);
	        }
	        if (callNow) result = func.apply(context, args);
	        return result;
	    };
	}


/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

	var Switchable = __webpack_require__(7);
	
	
	// 手风琴组件
	var Accordion = Switchable.extend({
	  attrs: {
	    triggerType: 'click',
	
	    // 是否运行展开多个
	    multiple: false,
	
	    autoplay: false
	  },
	  switchTo: function (toIndex) {
	    if (this.get('multiple')) {
	      this._switchTo(toIndex, toIndex);
	    } else {
	      Switchable.prototype.switchTo.call(this, toIndex);
	    }
	  },
	
	  _switchTrigger: function (toIndex, fromIndex) {
	    if (this.get('multiple')) {
	      this.get('triggers').eq(toIndex).toggleClass(this.get('activeTriggerClass'));
	    } else {
	      Switchable.prototype._switchTrigger.call(this, toIndex, fromIndex);
	    }
	  },
	
	  _switchPanel: function (panelInfo) {
	    if (this.get('multiple')) {
	      panelInfo.toPanels.toggle();
	    } else {
	      Switchable.prototype._switchPanel.call(this, panelInfo);
	    }
	  }
	});
	
	module.exports = Accordion;

/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {

	var Switchable = __webpack_require__(7);
	var $ = __webpack_require__(2);
	
	// 旋转木马组件
	module.exports = Switchable.extend({
	
	  attrs: {
	    circular: true,
	
	    prevBtn: {
	      getter: function (val) {
	        return $(val).eq(0);
	      }
	    },
	
	    nextBtn: {
	      getter: function (val) {
	        return $(val).eq(0);
	      }
	    },
	    disabledBtnClass: {
	      getter: function (val) {
	        return val ? val : this.get("classPrefix") + '-disabled-btn';
	      }
	    }
	  },
	
	  _initTriggers: function (role) {
	    Switchable.prototype._initTriggers.call(this, role);
	
	    // attr 里没找到时，才根据 data-role 来解析
	    var prevBtn = this.get('prevBtn');
	    var nextBtn = this.get('nextBtn');
	
	    if (!prevBtn[0] && role.prev) {
	      prevBtn = role.prev;
	      this.set('prevBtn', prevBtn);
	    }
	
	    if (!nextBtn[0] && role.next) {
	      nextBtn = role.next;
	      this.set('nextBtn', nextBtn);
	    }
	
	    prevBtn.addClass(this.CONST.PREV_BTN_CLASS);
	    nextBtn.addClass(this.CONST.NEXT_BTN_CLASS);
	  },
	
	  _getDatasetRole: function () {
	    var role = Switchable.prototype._getDatasetRole.call(this);
	
	    var self = this;
	    var roles = ['next', 'prev'];
	    $.each(roles, function (index, key) {
	      var elems = self.$('[data-role=' + key + ']');
	      if (elems.length) {
	        role[key] = elems;
	      }
	    });
	    return role;
	  },
	
	  _bindTriggers: function () {
	    Switchable.prototype._bindTriggers.call(this);
	
	    var that = this;
	    var circular = this.get('circular');
	
	    this.get('prevBtn').click(function (ev) {
	      ev.preventDefault();
	      if (circular || that.get('activeIndex') > 0) {
	        that.prev();
	      }
	    });
	
	    this.get('nextBtn').click(function (ev) {
	      ev.preventDefault();
	      var len = that.get('length') - 1;
	      if (circular || that.get('activeIndex') < len) {
	        that.next();
	      }
	    });
	
	    // 注册 switch 事件，处理 prevBtn/nextBtn 的 disable 状态
	    // circular = true 时，无需处理
	    if (!circular) {
	      this.on('switch', function (toIndex) {
	        that._updateButtonStatus(toIndex);
	      });
	    }
	  },
	
	  _updateButtonStatus: function (toIndex) {
	    var prevBtn = this.get('prevBtn');
	    var nextBtn = this.get('nextBtn');
	    var disabledBtnClass = this.get("disabledBtnClass");
	
	    prevBtn.removeClass(disabledBtnClass);
	    nextBtn.removeClass(disabledBtnClass);
	
	    if (toIndex === 0) {
	      prevBtn.addClass(disabledBtnClass);
	    }
	    else if (toIndex === this.get('length') - 1) {
	      nextBtn.addClass(disabledBtnClass);
	    }
	  }
	});

/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var win = $(window);
	
	// 自动播放插件
	module.exports = {
	
	  attrs: {
	    autoplay: false,
	
	    // 自动播放的间隔时间
	    interval: 5000
	  },
	
	  isNeeded: function () {
	    return this.get('autoplay');
	  },
	
	  install: function () {
	    var element = this.element;
	    var EVENT_NS = '.' + this.cid;
	    var timer;
	    var interval = this.get('interval');
	    var that = this;
	
	    // start autoplay
	    start();
	
	    function start() {
	      // 停止之前的
	      stop();
	
	      // 设置状态
	      that.paused = false;
	
	      // 开始现在的
	      timer = setInterval(function () {
	        if (that.paused) return;
	        that.next();
	      }, interval);
	    }
	
	    function stop() {
	      if (timer) {
	        clearInterval(timer);
	        timer = null;
	      }
	      that.paused = true;
	    }
	
	    // public api
	    this.stop = stop;
	    this.start = start;
	
	    // 滚出可视区域后，停止自动播放
	    this._scrollDetect = throttle(function () {
	      that[isInViewport(element) ? 'start' : 'stop']();
	    });
	    win.on('scroll' + EVENT_NS, this._scrollDetect);
	
	    // 鼠标悬停时，停止自动播放
	    this.element.hover(stop, start);
	  },
	
	  destroy: function () {
	    var EVENT_NS = '.' + this.cid;
	
	    this.stop && this.stop();
	
	    if (this._scrollDetect) {
	      this._scrollDetect.stop();
	      win.off('scroll' + EVENT_NS);
	    }
	  }
	};
	
	
	// Helpers
	// -------
	
	function throttle(fn, ms) {
	  ms = ms || 200;
	  var throttleTimer;
	
	  function f() {
	    f.stop();
	    throttleTimer = setTimeout(fn, ms);
	  }
	
	  f.stop = function () {
	    if (throttleTimer) {
	      clearTimeout(throttleTimer);
	      throttleTimer = 0;
	    }
	  };
	
	  return f;
	}
	
	
	function isInViewport(element) {
	  var scrollTop = win.scrollTop();
	  var scrollBottom = scrollTop + win.height();
	  var elementTop = element.offset().top;
	  var elementBottom = elementTop + element.height();
	
	  // 只判断垂直位置是否在可视区域，不判断水平。只有要部分区域在可视区域，就返回 true
	  return elementTop < scrollBottom && elementBottom > scrollTop;
	}

/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	
	var SCROLLX = 'scrollx';
	var SCROLLY = 'scrolly';
	var Effects = __webpack_require__(18).Effects;
	
	
	// 无缝循环滚动插件
	module.exports = {
	  // 仅在开启滚动效果时需要
	  isNeeded: function () {
	    var effect = this.get('effect');
	    var circular = this.get('circular');
	    return circular && (effect === SCROLLX || effect === SCROLLY);
	  },
	
	  install: function () {
	    this._scrollType = this.get('effect');
	    this.set('effect', 'scrollCircular');
	  }
	};
	
	Effects.scrollCircular = function (panelInfo) {
	  var toIndex = panelInfo.toIndex;
	  var fromIndex = panelInfo.fromIndex;
	  var isX = this._scrollType === SCROLLX;
	  var prop = isX ? 'left' : 'top';
	  var viewDiff = this.get('viewSize')[isX ? 0 : 1];
	  var diff = -viewDiff * toIndex;
	
	  var props = {};
	  props[prop] = diff + 'px';
	
	  // 开始动画
	  if (fromIndex > -1) {
	
	    // 开始动画前，先停止掉上一动画
	    if (this.anim) {
	      this.anim.stop(false, true);
	    }
	
	    var len = this.get('length');
	    // scroll 的 0 -> len-1 应该是正常的从 0->1->2->.. len-1 的切换
	    var isBackwardCritical = fromIndex === 0 && toIndex === len - 1;
	    // len-1 -> 0
	    var isForwardCritical = fromIndex === len - 1 && toIndex === 0;
	    var isBackward = this._isBackward === undefined ? toIndex < fromIndex : this._isBackward;
	    // isBackward 使用下面的判断方式, 会在 nav 上 trigger 从 0 -> len-1 切换时,
	    // 不经过 0->1->2->...-> len-1, 而是 0 反向切换到 len-1;
	    // 而上面的判断方式, nav 上的 trigger 切换是正常的, 只有调用 prev 才从 0 反向切换到 len-1;
	    //var isBackward = isBackwardCritical ||
	    //    (!isForwardCritical && toIndex < fromIndex);
	    // 从第一个反向滚动到最后一个 or 从最后一个正向滚动到第一个
	    var isCritical = (isBackward && isBackwardCritical) || (!isBackward && isForwardCritical);
	
	    // 在临界点时，先调整 panels 位置
	    if (isCritical) {
	      diff = adjustPosition.call(this, isBackward, prop, viewDiff);
	      props[prop] = diff + 'px';
	    }
	
	    var duration = this.get('duration');
	    var easing = this.get('easing');
	    var that = this;
	
	    this.anim = this.content.animate(props, duration, easing, function () {
	      that.anim = null; // free
	      // 复原位置
	      if (isCritical) {
	        resetPosition.call(that, isBackward, prop, viewDiff);
	      }
	    });
	  }
	  // 初始化
	  else {
	    this.content.css(props);
	  }
	};
	
	// 调整位置
	
	
	function adjustPosition(isBackward, prop, viewDiff) {
	  var step = this.get('step');
	  var len = this.get('length');
	  var start = isBackward ? len - 1 : 0;
	  var from = start * step;
	  var to = (start + 1) * step;
	  var diff = isBackward ? viewDiff : -viewDiff * len;
	  var panelDiff = isBackward ? -viewDiff * len : viewDiff * len;
	
	  // 调整 panels 到下一个视图中
	  var toPanels = $(this.get('panels').get().slice(from, to));
	  toPanels.css('position', 'relative');
	  toPanels.css(prop, panelDiff + 'px');
	
	  // 返回偏移量
	  return diff;
	}
	
	// 复原位置
	
	
	function resetPosition(isBackward, prop, viewDiff) {
	  var step = this.get('step');
	  var len = this.get('length');
	  var start = isBackward ? len - 1 : 0;
	  var from = start * step;
	  var to = (start + 1) * step;
	
	  // 滚动完成后，复位到正常状态
	  var toPanels = $(this.get('panels').get().slice(from, to));
	  toPanels.css('position', '');
	  toPanels.css(prop, '');
	
	  // 瞬移到正常位置
	  this.content.css(prop, isBackward ? -viewDiff * (len - 1) : '');
	}

/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {

	var Switchable = __webpack_require__(7);
	
	// 卡盘轮播组件
	module.exports = Switchable.extend({
	  attrs: {
	    autoplay: true,
	    circular: true
	  }
	});

/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {

	var Switchable = __webpack_require__(7);
	
	// 展现型标签页组件
	module.exports = Switchable.extend({});

/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(7);
	module.exports.Slide = __webpack_require__(54);
	module.exports.Accordion = __webpack_require__(50);
	module.exports.Carousel = __webpack_require__(51);
	module.exports.Tabs = __webpack_require__(55);


/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {

	var Popup = __webpack_require__(17);
	
	// 通用提示组件
	// 兼容站内各类样式
	module.exports = Popup.extend({
	
	  attrs: {
	    // 提示内容
	    content: null,
	
	    // 提示框在目标的位置方向 [up|down|left|right]
	    direction: 'up',
	
	    // 提示框离目标距离(px)
	    distance: 8,
	
	    // 箭头偏移位置(px)，负数表示箭头位置从最右边或最下边开始算
	    arrowShift: 22,
	
	    // 箭头指向 trigger 的水平或垂直的位置
	    pointPos: '50%'
	  },
	
	  _setAlign: function () {
	    var alignObject = {},
	        arrowShift = this.get('arrowShift'),
	        distance = this.get('distance'),
	        pointPos = this.get('pointPos'),
	        direction = this.get('direction');
	
	    if (arrowShift < 0) {
	      arrowShift = '100%' + arrowShift;
	    }
	
	    if (direction === 'up') {
	      alignObject.baseXY = [pointPos, 0];
	      alignObject.selfXY = [arrowShift, '100%+' + distance];
	    }
	    else if (direction === 'down') {
	      alignObject.baseXY = [pointPos, '100%+' + distance];
	      alignObject.selfXY = [arrowShift, 0];
	    }
	    else if (direction === 'left') {
	      alignObject.baseXY = [0, pointPos];
	      alignObject.selfXY = ['100%+' + distance, arrowShift];
	    }
	    else if (direction === 'right') {
	      alignObject.baseXY = ['100%+' + distance, pointPos];
	      alignObject.selfXY = [0, arrowShift];
	    }
	
	    alignObject.comeFromArrowPosition = true;
	    this.set('align', alignObject);
	  },
	
	  // 用于 set 属性后的界面更新
	  _onRenderContent: function (val) {
	    var ctn = this.$('[data-role="content"]');
	    if (typeof val !== 'string') {
	      val = val.call(this);
	    }
	    ctn && ctn.html(val);
	  }
	
	});


/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2);
	var BasicTip = __webpack_require__(57);
	
	// 依赖样式 alice/poptip@1.1.1
	__webpack_require__(118);
	
	// 气泡提示弹出组件
	// ---
	var Tip = BasicTip.extend({
	
	  attrs: {
	    template: __webpack_require__(112),
	
	    // 提示内容
	    content: 'A TIP BOX',
	
	    // 箭头位置
	    // 按钟表点位置，目前支持1、2、5、7、10、11点位置
	    // https://i.alipayobjects.com/e/201307/jBty06lQT.png
	    arrowPosition: 7,
	
	    align: {
	      setter: function (val) {
	        // 用户初始化时主动设置了 align
	        // 且并非来自 arrowPosition 的设置
	        if (val && !val.comeFromArrowPosition) {
	          this._specifiedAlign = true;
	        }
	        return val;
	      }
	    },
	
	    // 颜色 [yellow|blue|white]
	    theme: 'yellow',
	
	    // 当弹出层显示在屏幕外时，是否自动转换浮层位置
	    inViewport: false
	  },
	
	  setup: function () {
	    BasicTip.superclass.setup.call(this);
	    this._originArrowPosition = this.get('arrowPosition');
	
	    this.after('show', function () {
	      this._makesureInViewport();
	    });
	  },
	
	  _makesureInViewport: function () {
	    if (!this.get('inViewport')) {
	      return;
	    }
	    var ap = this._originArrowPosition,
	        scrollTop = $(window).scrollTop(),
	        viewportHeight = $(window).outerHeight(),
	        elemHeight = this.element.height() + this.get('distance'),
	        triggerTop = this.get('trigger').offset().top,
	        triggerHeight = this.get('trigger').height(),
	        arrowMap = {
	        '1': 5,
	        '5': 1,
	        '7': 11,
	        '11': 7
	        };
	
	    if ((ap == 11 || ap == 1) && (triggerTop + triggerHeight > scrollTop + viewportHeight - elemHeight)) {
	      // tip 溢出屏幕下方
	      this.set('arrowPosition', arrowMap[ap]);
	    } else if ((ap == 7 || ap == 5) && (triggerTop < scrollTop + elemHeight)) {
	      // tip 溢出屏幕上方
	      this.set('arrowPosition', arrowMap[ap]);
	    } else {
	      // 复原
	      this.set('arrowPosition', this._originArrowPosition);
	    }
	  },
	
	  // 用于 set 属性后的界面更新
	  _onRenderArrowPosition: function (val, prev) {
	    val = parseInt(val, 10);
	    var arrow = this.$('.ui-poptip-arrow');
	    arrow.removeClass('ui-poptip-arrow-' + prev).addClass('ui-poptip-arrow-' + val);
	
	    // 用户设置了 align
	    // 则直接使用 align 表示的位置信息，忽略 arrowPosition
	    if (this._specifiedAlign) {
	      return;
	    }
	
	    var direction = '',
	        arrowShift = 0;
	    if (val === 10) {
	      direction = 'right';
	      arrowShift = 20;
	    }
	    else if (val === 11) {
	      direction = 'down';
	      arrowShift = 22;
	    }
	    else if (val === 1) {
	      direction = 'down';
	      arrowShift = -22;
	    }
	    else if (val === 2) {
	      direction = 'left';
	      arrowShift = 20;
	    }
	    else if (val === 5) {
	      direction = 'up';
	      arrowShift = -22;
	    }
	    else if (val === 7) {
	      direction = 'up';
	      arrowShift = 22;
	    }
	    this.set('direction', direction);
	    this.set('arrowShift', arrowShift);
	    this._setAlign();
	  },
	
	  _onRenderWidth: function (val) {
	    this.$('[data-role="content"]').css('width', val);
	  },
	
	  _onRenderHeight: function (val) {
	    this.$('[data-role="content"]').css('height', val);
	  },
	
	  _onRenderTheme: function (val, prev) {
	    this.element.removeClass('ui-poptip-' + prev);
	    this.element.addClass('ui-poptip-' + val);
	  }
	
	});
	
	module.exports = Tip;


/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(58);


/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {

	var $ = __webpack_require__(2)
	var DATA_WIDGET_AUTO_RENDERED = 'data-widget-auto-rendered'
	
	
	// 自动渲染接口，子类可根据自己的初始化逻辑进行覆盖
	exports.autoRender = function(config) {
	  return new this(config).render()
	}
	
	
	// 根据 data-widget 属性，自动渲染所有开启了 data-api 的 widget 组件
	exports.autoRenderAll = function(root, callback) {
	  if (typeof root === 'function') {
	    callback = root
	    root = null
	  }
	
	  root = $(root || document.body)
	  var modules = []
	  var elements = []
	
	  root.find('[data-widget]').each(function(i, element) {
	    if (!exports.isDataApiOff(element)) {
	      modules.push(element.getAttribute('data-widget').toLowerCase())
	      elements.push(element)
	    }
	  })
	
	  if (modules.length) {
	    seajs.use(modules, function() {
	
	      for (var i = 0; i < arguments.length; i++) {
	        var SubWidget = arguments[i]
	        var element = $(elements[i])
	
	        // 已经渲染过
	        if (element.attr(DATA_WIDGET_AUTO_RENDERED)) continue
	
	        var config = {
	          initElement: element,
	          renderType: 'auto'
	        };
	
	        // data-widget-role 是指将当前的 DOM 作为 role 的属性去实例化，默认的 role 为 element
	        var role = element.attr('data-widget-role')
	        config[role ? role : 'element'] = element
	
	        // 调用自动渲染接口
	        SubWidget.autoRender && SubWidget.autoRender(config)
	
	        // 标记已经渲染过
	        element.attr(DATA_WIDGET_AUTO_RENDERED, 'true')
	      }
	
	      // 在所有自动渲染完成后，执行回调
	      callback && callback()
	    })
	  }
	}
	
	
	var isDefaultOff = $(document.body).attr('data-api') === 'off'
	
	// 是否没开启 data-api
	exports.isDataApiOff = function(element) {
	  var elementDataApi = $(element).attr('data-api')
	
	  // data-api 默认开启，关闭只有两种方式：
	  //  1. element 上有 data-api="off"，表示关闭单个
	  //  2. document.body 上有 data-api="off"，表示关闭所有
	  return  elementDataApi === 'off' ||
	      (elementDataApi !== 'on' && isDefaultOff)
	}
	


/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {

	// DAParser
	// --------
	// data api 解析器，提供对单个 element 的解析，可用来初始化页面中的所有 Widget 组件。
	
	var $ = __webpack_require__(2)
	
	
	// 得到某个 DOM 元素的 dataset
	exports.parseElement = function(element, raw) {
	  element = $(element)[0]
	  var dataset = {}
	
	  // ref: https://developer.mozilla.org/en/DOM/element.dataset
	  if (element.dataset) {
	    // 转换成普通对象
	    dataset = $.extend({}, element.dataset)
	  }
	  else {
	    var attrs = element.attributes
	
	    for (var i = 0, len = attrs.length; i < len; i++) {
	      var attr = attrs[i]
	      var name = attr.name
	
	      if (name.indexOf('data-') === 0) {
	        name = camelCase(name.substring(5))
	        dataset[name] = attr.value
	      }
	    }
	  }
	
	  return raw === true ? dataset : normalizeValues(dataset)
	}
	
	
	// Helpers
	// ------
	
	var RE_DASH_WORD = /-([a-z])/g
	var JSON_LITERAL_PATTERN = /^\s*[\[{].*[\]}]\s*$/
	var parseJSON = this.JSON ? JSON.parse : $.parseJSON
	
	// 仅处理字母开头的，其他情况转换为小写："data-x-y-123-_A" --> xY-123-_a
	function camelCase(str) {
	  return str.toLowerCase().replace(RE_DASH_WORD, function(all, letter) {
	    return (letter + '').toUpperCase()
	  })
	}
	
	// 解析并归一化配置中的值
	function normalizeValues(data) {
	  for (var key in data) {
	    if (data.hasOwnProperty(key)) {
	
	      var val = data[key]
	      if (typeof val !== 'string') continue
	
	      if (JSON_LITERAL_PATTERN.test(val)) {
	        val = val.replace(/'/g, '"')
	        data[key] = normalizeValues(parseJSON(val))
	      }
	      else {
	        data[key] = normalizeValue(val)
	      }
	    }
	  }
	
	  return data
	}
	
	// 将 'false' 转换为 false
	// 'true' 转换为 true
	// '3253.34' 转换为 3253.34
	function normalizeValue(val) {
	  if (val.toLowerCase() === 'false') {
	    val = false
	  }
	  else if (val.toLowerCase() === 'true') {
	    val = true
	  }
	  else if (/\d/.test(val) && /[^a-z]/i.test(val)) {
	    var number = parseFloat(val)
	    if (number + '' === val) {
	      val = number
	    }
	  }
	
	  return val
	}


/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

	// Widget
	// ---------
	// Widget 是与 DOM 元素相关联的非工具类组件，主要负责 View 层的管理。
	// Widget 组件具有四个要素：描述状态的 attributes 和 properties，描述行为的 events
	// 和 methods。Widget 基类约定了这四要素创建时的基本流程和最佳实践。
	
	var Base = __webpack_require__(9)
	var $ = __webpack_require__(2)
	var DAParser = __webpack_require__(61)
	var AutoRender = __webpack_require__(60)
	
	var DELEGATE_EVENT_NS = '.delegate-events-'
	var ON_RENDER = '_onRender'
	var DATA_WIDGET_CID = 'data-widget-cid'
	
	// 所有初始化过的 Widget 实例
	var cachedInstances = {}
	
	var Widget = Base.extend({
	
	  // config 中的这些键值会直接添加到实例上，转换成 properties
	  propsInAttrs: ['initElement', 'element', 'events'],
	
	  // 与 widget 关联的 DOM 元素
	  element: null,
	
	  // 事件代理，格式为：
	  //   {
	  //     'mousedown .title': 'edit',
	  //     'click {{attrs.saveButton}}': 'save'
	  //     'click .open': function(ev) { ... }
	  //   }
	  events: null,
	
	  // 属性列表
	  attrs: {
	    // 基本属性
	    id: null,
	    className: null,
	    style: null,
	
	    // 默认模板
	    template: '<div></div>',
	
	    // 默认数据模型
	    model: null,
	
	    // 组件的默认父节点
	    parentNode: document.body
	  },
	
	  // 初始化方法，确定组件创建时的基本流程：
	  // 初始化 attrs --》 初始化 props --》 初始化 events --》 子类的初始化
	  initialize: function(config) {
	    this.cid = uniqueCid()
	
	    // 初始化 attrs
	    var dataAttrsConfig = this._parseDataAttrsConfig(config)
	    Widget.superclass.initialize.call(this, config ? $.extend(dataAttrsConfig, config) : dataAttrsConfig)
	
	    // 初始化 props
	    this.parseElement()
	    this.initProps()
	
	    // 初始化 events
	    this.delegateEvents()
	
	    // 子类自定义的初始化
	    this.setup()
	
	    // 保存实例信息
	    this._stamp()
	
	    // 是否由 template 初始化
	    this._isTemplate = !(config && config.element)
	  },
	
	  // 解析通过 data-attr 设置的 api
	  _parseDataAttrsConfig: function(config) {
	    var element, dataAttrsConfig
	    if (config) {
	      element = config.initElement ? $(config.initElement) : $(config.element)
	    }
	
	    // 解析 data-api 时，只考虑用户传入的 element，不考虑来自继承或从模板构建的
	    if (element && element[0] && !AutoRender.isDataApiOff(element)) {
	      dataAttrsConfig = DAParser.parseElement(element)
	    }
	
	    return dataAttrsConfig
	  },
	
	  // 构建 this.element
	  parseElement: function() {
	    var element = this.element
	
	    if (element) {
	      this.element = $(element)
	    }
	    // 未传入 element 时，从 template 构建
	    else if (this.get('template')) {
	      this.parseElementFromTemplate()
	    }
	
	    // 如果对应的 DOM 元素不存在，则报错
	    if (!this.element || !this.element[0]) {
	      throw new Error('element is invalid')
	    }
	  },
	
	  // 从模板中构建 this.element
	  parseElementFromTemplate: function() {
	    this.element = $(this.get('template'))
	  },
	
	  // 负责 properties 的初始化，提供给子类覆盖
	  initProps: function() {
	  },
	
	  // 注册事件代理
	  delegateEvents: function(element, events, handler) {
	    var argus = trimRightUndefine(Array.prototype.slice.call(arguments));
	    // widget.delegateEvents()
	    if (argus.length === 0) {
	      events = getEvents(this)
	      element = this.element
	    }
	
	    // widget.delegateEvents({
	    //   'click p': 'fn1',
	    //   'click li': 'fn2'
	    // })
	    else if (argus.length === 1) {
	      events = element
	      element = this.element
	    }
	
	    // widget.delegateEvents('click p', function(ev) { ... })
	    else if (argus.length === 2) {
	      handler = events
	      events = element
	      element = this.element
	    }
	
	    // widget.delegateEvents(element, 'click p', function(ev) { ... })
	    else {
	      element || (element = this.element)
	      this._delegateElements || (this._delegateElements = [])
	      this._delegateElements.push($(element))
	    }
	
	    // 'click p' => {'click p': handler}
	    if (isString(events) && isFunction(handler)) {
	      var o = {}
	      o[events] = handler
	      events = o
	    }
	
	    // key 为 'event selector'
	    for (var key in events) {
	      if (!events.hasOwnProperty(key)) continue
	
	      var args = parseEventKey(key, this)
	      var eventType = args.type
	      var selector = args.selector
	
	      ;(function(handler, widget) {
	
	        var callback = function(ev) {
	          if (isFunction(handler)) {
	            handler.call(widget, ev)
	          } else {
	            widget[handler](ev)
	          }
	        }
	
	        // delegate
	        if (selector) {
	          $(element).on(eventType, selector, callback)
	        }
	        // normal bind
	        // 分开写是为了兼容 zepto，zepto 的判断不如 jquery 强劲有力
	        else {
	          $(element).on(eventType, callback)
	        }
	
	      })(events[key], this)
	    }
	
	    return this
	  },
	
	  // 卸载事件代理
	  undelegateEvents: function(element, eventKey) {
	    var argus = trimRightUndefine(Array.prototype.slice.call(arguments));
	
	    if (!eventKey) {
	      eventKey = element
	      element = null
	    }
	
	    // 卸载所有
	    // .undelegateEvents()
	    if (argus.length === 0) {
	      var type = DELEGATE_EVENT_NS + this.cid
	
	      this.element && this.element.off(type)
	
	      // 卸载所有外部传入的 element
	      if (this._delegateElements) {
	        for (var de in this._delegateElements) {
	          if (!this._delegateElements.hasOwnProperty(de)) continue
	          this._delegateElements[de].off(type)
	        }
	      }
	
	    } else {
	      var args = parseEventKey(eventKey, this)
	
	      // 卸载 this.element
	      // .undelegateEvents(events)
	      if (!element) {
	        this.element && this.element.off(args.type, args.selector)
	      }
	
	      // 卸载外部 element
	      // .undelegateEvents(element, events)
	      else {
	        $(element).off(args.type, args.selector)
	      }
	    }
	    return this
	  },
	
	  // 提供给子类覆盖的初始化方法
	  setup: function() {
	  },
	
	  // 将 widget 渲染到页面上
	  // 渲染不仅仅包括插入到 DOM 树中，还包括样式渲染等
	  // 约定：子类覆盖时，需保持 `return this`
	  render: function() {
	
	    // 让渲染相关属性的初始值生效，并绑定到 change 事件
	    if (!this.rendered) {
	      this._renderAndBindAttrs()
	      this.rendered = true
	    }
	
	    // 插入到文档流中
	    var parentNode = this.get('parentNode')
	    if (parentNode && !isInDocument(this.element[0])) {
	      // 隔离样式，添加统一的命名空间
	      // https://github.com/aliceui/aliceui.org/issues/9
	      var outerBoxClass = this.constructor.outerBoxClass
	      if (outerBoxClass) {
	        var outerBox = this._outerBox = $('<div></div>').addClass(outerBoxClass)
	        outerBox.append(this.element).appendTo(parentNode)
	      } else {
	        this.element.appendTo(parentNode)
	      }
	    }
	
	    return this
	  },
	
	  // 让属性的初始值生效，并绑定到 change:attr 事件上
	  _renderAndBindAttrs: function() {
	    var widget = this
	    var attrs = widget.attrs
	
	    for (var attr in attrs) {
	      if (!attrs.hasOwnProperty(attr)) continue
	      var m = ON_RENDER + ucfirst(attr)
	
	      if (this[m]) {
	        var val = this.get(attr)
	
	        // 让属性的初始值生效。注：默认空值不触发
	        if (!isEmptyAttrValue(val)) {
	          this[m](val, undefined, attr)
	        }
	
	        // 将 _onRenderXx 自动绑定到 change:xx 事件上
	        (function(m) {
	          widget.on('change:' + attr, function(val, prev, key) {
	            widget[m](val, prev, key)
	          })
	        })(m)
	      }
	    }
	  },
	
	  _onRenderId: function(val) {
	    this.element.attr('id', val)
	  },
	
	  _onRenderClassName: function(val) {
	    this.element.addClass(val)
	  },
	
	  _onRenderStyle: function(val) {
	    this.element.css(val)
	  },
	
	  // 让 element 与 Widget 实例建立关联
	  _stamp: function() {
	    var cid = this.cid;
	
	    (this.initElement || this.element).attr(DATA_WIDGET_CID, cid)
	    cachedInstances[cid] = this
	  },
	
	  // 在 this.element 内寻找匹配节点
	  $: function(selector) {
	    return this.element.find(selector)
	  },
	
	  destroy: function() {
	    this.undelegateEvents()
	    delete cachedInstances[this.cid]
	
	    // For memory leak
	    if (this.element && this._isTemplate) {
	      this.element.off()
	      // 如果是 widget 生成的 element 则去除
	      if (this._outerBox) {
	        this._outerBox.remove()
	      } else {
	        this.element.remove()
	      }
	    }
	    this.element = null
	
	    Widget.superclass.destroy.call(this)
	  }
	})
	
	// For memory leak
	$(window).unload(function() {
	  for(var cid in cachedInstances) {
	    cachedInstances[cid].destroy()
	  }
	})
	
	// 查询与 selector 匹配的第一个 DOM 节点，得到与该 DOM 节点相关联的 Widget 实例
	Widget.query = function(selector) {
	  var element = $(selector).eq(0)
	  var cid
	
	  element && (cid = element.attr(DATA_WIDGET_CID))
	  return cachedInstances[cid]
	}
	
	
	Widget.autoRender = AutoRender.autoRender
	Widget.autoRenderAll = AutoRender.autoRenderAll
	Widget.StaticsWhiteList = ['autoRender']
	
	module.exports = Widget
	
	
	// Helpers
	// ------
	
	var toString = Object.prototype.toString
	var cidCounter = 0
	
	function uniqueCid() {
	  return 'widget-' + cidCounter++
	}
	
	function isString(val) {
	  return toString.call(val) === '[object String]'
	}
	
	function isFunction(val) {
	  return toString.call(val) === '[object Function]'
	}
	
	// Zepto 上没有 contains 方法
	var contains = $.contains || function(a, b) {
	  //noinspection JSBitwiseOperatorUsage
	  return !!(a.compareDocumentPosition(b) & 16)
	}
	
	function isInDocument(element) {
	  return contains(document.documentElement, element)
	}
	
	function ucfirst(str) {
	  return str.charAt(0).toUpperCase() + str.substring(1)
	}
	
	
	var EVENT_KEY_SPLITTER = /^(\S+)\s*(.*)$/
	var EXPRESSION_FLAG = /{{([^}]+)}}/g
	var INVALID_SELECTOR = 'INVALID_SELECTOR'
	
	function getEvents(widget) {
	  if (isFunction(widget.events)) {
	    widget.events = widget.events()
	  }
	  return widget.events
	}
	
	function parseEventKey(eventKey, widget) {
	  var match = eventKey.match(EVENT_KEY_SPLITTER)
	  var eventType = match[1] + DELEGATE_EVENT_NS + widget.cid
	
	  // 当没有 selector 时，需要设置为 undefined，以使得 zepto 能正确转换为 bind
	  var selector = match[2] || undefined
	
	  if (selector && selector.indexOf('{{') > -1) {
	    selector = parseExpressionInEventKey(selector, widget)
	  }
	
	  return {
	    type: eventType,
	    selector: selector
	  }
	}
	
	// 解析 eventKey 中的 {{xx}}, {{yy}}
	function parseExpressionInEventKey(selector, widget) {
	
	  return selector.replace(EXPRESSION_FLAG, function(m, name) {
	    var parts = name.split('.')
	    var point = widget, part
	
	    while (part = parts.shift()) {
	      if (point === widget.attrs) {
	        point = widget.get(part)
	      } else {
	        point = point[part]
	      }
	    }
	
	    // 已经是 className，比如来自 dataset 的
	    if (isString(point)) {
	      return point
	    }
	
	    // 不能识别的，返回无效标识
	    return INVALID_SELECTOR
	  })
	}
	
	
	// 对于 attrs 的 value 来说，以下值都认为是空值： null, undefined
	function isEmptyAttrValue(o) {
	  return o == null || o === undefined
	}
	
	function trimRightUndefine(argus) {
	  for (var i = argus.length - 1; i >= 0; i--) {
	    if (argus[i] === undefined) {
	      argus.pop();
	    } else {
	      break;
	    }
	  }
	  return argus;
	}


/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/*globals Handlebars: true */
	var Handlebars = __webpack_require__(64)["default"];
	
	// Compiler imports
	var AST = __webpack_require__(21)["default"];
	var Parser = __webpack_require__(22).parser;
	var parse = __webpack_require__(22).parse;
	var Compiler = __webpack_require__(11).Compiler;
	var compile = __webpack_require__(11).compile;
	var precompile = __webpack_require__(11).precompile;
	var JavaScriptCompiler = __webpack_require__(65)["default"];
	
	var _create = Handlebars.create;
	var create = function() {
	  var hb = _create();
	
	  hb.compile = function(input, options) {
	    return compile(input, options, hb);
	  };
	  hb.precompile = function (input, options) {
	    return precompile(input, options, hb);
	  };
	
	  hb.AST = AST;
	  hb.Compiler = Compiler;
	  hb.JavaScriptCompiler = JavaScriptCompiler;
	  hb.Parser = Parser;
	  hb.parse = parse;
	
	  return hb;
	};
	
	Handlebars = create();
	Handlebars.create = create;
	
	exports["default"] = Handlebars;

/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/*globals Handlebars: true */
	var base = __webpack_require__(4);
	
	// Each of these augment the Handlebars object. No need to setup here.
	// (This is done to easily share code between commonjs and browse envs)
	var SafeString = __webpack_require__(23)["default"];
	var Exception = __webpack_require__(5)["default"];
	var Utils = __webpack_require__(12);
	var runtime = __webpack_require__(67);
	
	// For compatibility and usage outside of module systems, make the Handlebars object a namespace
	var create = function() {
	  var hb = new base.HandlebarsEnvironment();
	
	  Utils.extend(hb, base);
	  hb.SafeString = SafeString;
	  hb.Exception = Exception;
	  hb.Utils = Utils;
	
	  hb.VM = runtime;
	  hb.template = function(spec) {
	    return runtime.template(spec, hb);
	  };
	
	  return hb;
	};
	
	var Handlebars = create();
	Handlebars.create = create;
	
	exports["default"] = Handlebars;

/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var COMPILER_REVISION = __webpack_require__(4).COMPILER_REVISION;
	var REVISION_CHANGES = __webpack_require__(4).REVISION_CHANGES;
	var log = __webpack_require__(4).log;
	var Exception = __webpack_require__(5)["default"];
	
	function Literal(value) {
	  this.value = value;
	}
	
	function JavaScriptCompiler() {}
	
	JavaScriptCompiler.prototype = {
	  // PUBLIC API: You can override these methods in a subclass to provide
	  // alternative compiled forms for name lookup and buffering semantics
	  nameLookup: function(parent, name /* , type*/) {
	    var wrap,
	        ret;
	    if (parent.indexOf('depth') === 0) {
	      wrap = true;
	    }
	
	    if (/^[0-9]+$/.test(name)) {
	      ret = parent + "[" + name + "]";
	    } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
	      ret = parent + "." + name;
	    }
	    else {
	      ret = parent + "['" + name + "']";
	    }
	
	    if (wrap) {
	      return '(' + parent + ' && ' + ret + ')';
	    } else {
	      return ret;
	    }
	  },
	
	  compilerInfo: function() {
	    var revision = COMPILER_REVISION,
	        versions = REVISION_CHANGES[revision];
	    return "this.compilerInfo = ["+revision+",'"+versions+"'];\n";
	  },
	
	  appendToBuffer: function(string) {
	    if (this.environment.isSimple) {
	      return "return " + string + ";";
	    } else {
	      return {
	        appendToBuffer: true,
	        content: string,
	        toString: function() { return "buffer += " + string + ";"; }
	      };
	    }
	  },
	
	  initializeBuffer: function() {
	    return this.quotedString("");
	  },
	
	  namespace: "Handlebars",
	  // END PUBLIC API
	
	  compile: function(environment, options, context, asObject) {
	    this.environment = environment;
	    this.options = options || {};
	
	    log('debug', this.environment.disassemble() + "\n\n");
	
	    this.name = this.environment.name;
	    this.isChild = !!context;
	    this.context = context || {
	      programs: [],
	      environments: [],
	      aliases: { }
	    };
	
	    this.preamble();
	
	    this.stackSlot = 0;
	    this.stackVars = [];
	    this.registers = { list: [] };
	    this.hashes = [];
	    this.compileStack = [];
	    this.inlineStack = [];
	
	    this.compileChildren(environment, options);
	
	    var opcodes = environment.opcodes, opcode;
	
	    this.i = 0;
	
	    for(var l=opcodes.length; this.i<l; this.i++) {
	      opcode = opcodes[this.i];
	
	      if(opcode.opcode === 'DECLARE') {
	        this[opcode.name] = opcode.value;
	      } else {
	        this[opcode.opcode].apply(this, opcode.args);
	      }
	
	      // Reset the stripNext flag if it was not set by this operation.
	      if (opcode.opcode !== this.stripNext) {
	        this.stripNext = false;
	      }
	    }
	
	    // Flush any trailing content that might be pending.
	    this.pushSource('');
	
	    if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
	      throw new Exception('Compile completed with content left on stack');
	    }
	
	    return this.createFunctionContext(asObject);
	  },
	
	  preamble: function() {
	    var out = [];
	
	    if (!this.isChild) {
	      var namespace = this.namespace;
	
	      var copies = "helpers = this.merge(helpers, " + namespace + ".helpers);";
	      if (this.environment.usePartial) { copies = copies + " partials = this.merge(partials, " + namespace + ".partials);"; }
	      if (this.options.data) { copies = copies + " data = data || {};"; }
	      out.push(copies);
	    } else {
	      out.push('');
	    }
	
	    if (!this.environment.isSimple) {
	      out.push(", buffer = " + this.initializeBuffer());
	    } else {
	      out.push("");
	    }
	
	    // track the last context pushed into place to allow skipping the
	    // getContext opcode when it would be a noop
	    this.lastContext = 0;
	    this.source = out;
	  },
	
	  createFunctionContext: function(asObject) {
	    var locals = this.stackVars.concat(this.registers.list);
	
	    if(locals.length > 0) {
	      this.source[1] = this.source[1] + ", " + locals.join(", ");
	    }
	
	    // Generate minimizer alias mappings
	    if (!this.isChild) {
	      for (var alias in this.context.aliases) {
	        if (this.context.aliases.hasOwnProperty(alias)) {
	          this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
	        }
	      }
	    }
	
	    if (this.source[1]) {
	      this.source[1] = "var " + this.source[1].substring(2) + ";";
	    }
	
	    // Merge children
	    if (!this.isChild) {
	      this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
	    }
	
	    if (!this.environment.isSimple) {
	      this.pushSource("return buffer;");
	    }
	
	    var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
	
	    for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
	      params.push("depth" + this.environment.depths.list[i]);
	    }
	
	    // Perform a second pass over the output to merge content when possible
	    var source = this.mergeSource();
	
	    if (!this.isChild) {
	      source = this.compilerInfo()+source;
	    }
	
	    if (asObject) {
	      params.push(source);
	
	      return Function.apply(this, params);
	    } else {
	      var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + source + '}';
	      log('debug', functionSource + "\n\n");
	      return functionSource;
	    }
	  },
	  mergeSource: function() {
	    // WARN: We are not handling the case where buffer is still populated as the source should
	    // not have buffer append operations as their final action.
	    var source = '',
	        buffer;
	    for (var i = 0, len = this.source.length; i < len; i++) {
	      var line = this.source[i];
	      if (line.appendToBuffer) {
	        if (buffer) {
	          buffer = buffer + '\n    + ' + line.content;
	        } else {
	          buffer = line.content;
	        }
	      } else {
	        if (buffer) {
	          source += 'buffer += ' + buffer + ';\n  ';
	          buffer = undefined;
	        }
	        source += line + '\n  ';
	      }
	    }
	    return source;
	  },
	
	  // [blockValue]
	  //
	  // On stack, before: hash, inverse, program, value
	  // On stack, after: return value of blockHelperMissing
	  //
	  // The purpose of this opcode is to take a block of the form
	  // `{{#foo}}...{{/foo}}`, resolve the value of `foo`, and
	  // replace it on the stack with the result of properly
	  // invoking blockHelperMissing.
	  blockValue: function() {
	    this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
	
	    var params = ["depth0"];
	    this.setupParams(0, params);
	
	    this.replaceStack(function(current) {
	      params.splice(1, 0, current);
	      return "blockHelperMissing.call(" + params.join(", ") + ")";
	    });
	  },
	
	  // [ambiguousBlockValue]
	  //
	  // On stack, before: hash, inverse, program, value
	  // Compiler value, before: lastHelper=value of last found helper, if any
	  // On stack, after, if no lastHelper: same as [blockValue]
	  // On stack, after, if lastHelper: value
	  ambiguousBlockValue: function() {
	    this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
	
	    var params = ["depth0"];
	    this.setupParams(0, params);
	
	    var current = this.topStack();
	    params.splice(1, 0, current);
	
	    this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
	  },
	
	  // [appendContent]
	  //
	  // On stack, before: ...
	  // On stack, after: ...
	  //
	  // Appends the string value of `content` to the current buffer
	  appendContent: function(content) {
	    if (this.pendingContent) {
	      content = this.pendingContent + content;
	    }
	    if (this.stripNext) {
	      content = content.replace(/^\s+/, '');
	    }
	
	    this.pendingContent = content;
	  },
	
	  // [strip]
	  //
	  // On stack, before: ...
	  // On stack, after: ...
	  //
	  // Removes any trailing whitespace from the prior content node and flags
	  // the next operation for stripping if it is a content node.
	  strip: function() {
	    if (this.pendingContent) {
	      this.pendingContent = this.pendingContent.replace(/\s+$/, '');
	    }
	    this.stripNext = 'strip';
	  },
	
	  // [append]
	  //
	  // On stack, before: value, ...
	  // On stack, after: ...
	  //
	  // Coerces `value` to a String and appends it to the current buffer.
	  //
	  // If `value` is truthy, or 0, it is coerced into a string and appended
	  // Otherwise, the empty string is appended
	  append: function() {
	    // Force anything that is inlined onto the stack so we don't have duplication
	    // when we examine local
	    this.flushInline();
	    var local = this.popStack();
	    this.pushSource("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
	    if (this.environment.isSimple) {
	      this.pushSource("else { " + this.appendToBuffer("''") + " }");
	    }
	  },
	
	  // [appendEscaped]
	  //
	  // On stack, before: value, ...
	  // On stack, after: ...
	  //
	  // Escape `value` and append it to the buffer
	  appendEscaped: function() {
	    this.context.aliases.escapeExpression = 'this.escapeExpression';
	
	    this.pushSource(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
	  },
	
	  // [getContext]
	  //
	  // On stack, before: ...
	  // On stack, after: ...
	  // Compiler value, after: lastContext=depth
	  //
	  // Set the value of the `lastContext` compiler value to the depth
	  getContext: function(depth) {
	    if(this.lastContext !== depth) {
	      this.lastContext = depth;
	    }
	  },
	
	  // [lookupOnContext]
	  //
	  // On stack, before: ...
	  // On stack, after: currentContext[name], ...
	  //
	  // Looks up the value of `name` on the current context and pushes
	  // it onto the stack.
	  lookupOnContext: function(name) {
	    this.push(this.nameLookup('depth' + this.lastContext, name, 'context'));
	  },
	
	  // [pushContext]
	  //
	  // On stack, before: ...
	  // On stack, after: currentContext, ...
	  //
	  // Pushes the value of the current context onto the stack.
	  pushContext: function() {
	    this.pushStackLiteral('depth' + this.lastContext);
	  },
	
	  // [resolvePossibleLambda]
	  //
	  // On stack, before: value, ...
	  // On stack, after: resolved value, ...
	  //
	  // If the `value` is a lambda, replace it on the stack by
	  // the return value of the lambda
	  resolvePossibleLambda: function() {
	    this.context.aliases.functionType = '"function"';
	
	    this.replaceStack(function(current) {
	      return "typeof " + current + " === functionType ? " + current + ".apply(depth0) : " + current;
	    });
	  },
	
	  // [lookup]
	  //
	  // On stack, before: value, ...
	  // On stack, after: value[name], ...
	  //
	  // Replace the value on the stack with the result of looking
	  // up `name` on `value`
	  lookup: function(name) {
	    this.replaceStack(function(current) {
	      return current + " == null || " + current + " === false ? " + current + " : " + this.nameLookup(current, name, 'context');
	    });
	  },
	
	  // [lookupData]
	  //
	  // On stack, before: ...
	  // On stack, after: data, ...
	  //
	  // Push the data lookup operator
	  lookupData: function() {
	    this.pushStackLiteral('data');
	  },
	
	  // [pushStringParam]
	  //
	  // On stack, before: ...
	  // On stack, after: string, currentContext, ...
	  //
	  // This opcode is designed for use in string mode, which
	  // provides the string value of a parameter along with its
	  // depth rather than resolving it immediately.
	  pushStringParam: function(string, type) {
	    this.pushStackLiteral('depth' + this.lastContext);
	
	    this.pushString(type);
	
	    // If it's a subexpression, the string result
	    // will be pushed after this opcode.
	    if (type !== 'sexpr') {
	      if (typeof string === 'string') {
	        this.pushString(string);
	      } else {
	        this.pushStackLiteral(string);
	      }
	    }
	  },
	
	  emptyHash: function() {
	    this.pushStackLiteral('{}');
	
	    if (this.options.stringParams) {
	      this.push('{}'); // hashContexts
	      this.push('{}'); // hashTypes
	    }
	  },
	  pushHash: function() {
	    if (this.hash) {
	      this.hashes.push(this.hash);
	    }
	    this.hash = {values: [], types: [], contexts: []};
	  },
	  popHash: function() {
	    var hash = this.hash;
	    this.hash = this.hashes.pop();
	
	    if (this.options.stringParams) {
	      this.push('{' + hash.contexts.join(',') + '}');
	      this.push('{' + hash.types.join(',') + '}');
	    }
	
	    this.push('{\n    ' + hash.values.join(',\n    ') + '\n  }');
	  },
	
	  // [pushString]
	  //
	  // On stack, before: ...
	  // On stack, after: quotedString(string), ...
	  //
	  // Push a quoted version of `string` onto the stack
	  pushString: function(string) {
	    this.pushStackLiteral(this.quotedString(string));
	  },
	
	  // [push]
	  //
	  // On stack, before: ...
	  // On stack, after: expr, ...
	  //
	  // Push an expression onto the stack
	  push: function(expr) {
	    this.inlineStack.push(expr);
	    return expr;
	  },
	
	  // [pushLiteral]
	  //
	  // On stack, before: ...
	  // On stack, after: value, ...
	  //
	  // Pushes a value onto the stack. This operation prevents
	  // the compiler from creating a temporary variable to hold
	  // it.
	  pushLiteral: function(value) {
	    this.pushStackLiteral(value);
	  },
	
	  // [pushProgram]
	  //
	  // On stack, before: ...
	  // On stack, after: program(guid), ...
	  //
	  // Push a program expression onto the stack. This takes
	  // a compile-time guid and converts it into a runtime-accessible
	  // expression.
	  pushProgram: function(guid) {
	    if (guid != null) {
	      this.pushStackLiteral(this.programExpression(guid));
	    } else {
	      this.pushStackLiteral(null);
	    }
	  },
	
	  // [invokeHelper]
	  //
	  // On stack, before: hash, inverse, program, params..., ...
	  // On stack, after: result of helper invocation
	  //
	  // Pops off the helper's parameters, invokes the helper,
	  // and pushes the helper's return value onto the stack.
	  //
	  // If the helper is not found, `helperMissing` is called.
	  invokeHelper: function(paramSize, name, isRoot) {
	    this.context.aliases.helperMissing = 'helpers.helperMissing';
	    this.useRegister('helper');
	
	    var helper = this.lastHelper = this.setupHelper(paramSize, name, true);
	    var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
	
	    var lookup = 'helper = ' + helper.name + ' || ' + nonHelper;
	    if (helper.paramsInit) {
	      lookup += ',' + helper.paramsInit;
	    }
	
	    this.push(
	      '('
	        + lookup
	        + ',helper '
	          + '? helper.call(' + helper.callParams + ') '
	          + ': helperMissing.call(' + helper.helperMissingParams + '))');
	
	    // Always flush subexpressions. This is both to prevent the compounding size issue that
	    // occurs when the code has to be duplicated for inlining and also to prevent errors
	    // due to the incorrect options object being passed due to the shared register.
	    if (!isRoot) {
	      this.flushInline();
	    }
	  },
	
	  // [invokeKnownHelper]
	  //
	  // On stack, before: hash, inverse, program, params..., ...
	  // On stack, after: result of helper invocation
	  //
	  // This operation is used when the helper is known to exist,
	  // so a `helperMissing` fallback is not required.
	  invokeKnownHelper: function(paramSize, name) {
	    var helper = this.setupHelper(paramSize, name);
	    this.push(helper.name + ".call(" + helper.callParams + ")");
	  },
	
	  // [invokeAmbiguous]
	  //
	  // On stack, before: hash, inverse, program, params..., ...
	  // On stack, after: result of disambiguation
	  //
	  // This operation is used when an expression like `{{foo}}`
	  // is provided, but we don't know at compile-time whether it
	  // is a helper or a path.
	  //
	  // This operation emits more code than the other options,
	  // and can be avoided by passing the `knownHelpers` and
	  // `knownHelpersOnly` flags at compile-time.
	  invokeAmbiguous: function(name, helperCall) {
	    this.context.aliases.functionType = '"function"';
	    this.useRegister('helper');
	
	    this.emptyHash();
	    var helper = this.setupHelper(0, name, helperCall);
	
	    var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
	
	    var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
	    var nextStack = this.nextStack();
	
	    if (helper.paramsInit) {
	      this.pushSource(helper.paramsInit);
	    }
	    this.pushSource('if (helper = ' + helperName + ') { ' + nextStack + ' = helper.call(' + helper.callParams + '); }');
	    this.pushSource('else { helper = ' + nonHelper + '; ' + nextStack + ' = typeof helper === functionType ? helper.call(' + helper.callParams + ') : helper; }');
	  },
	
	  // [invokePartial]
	  //
	  // On stack, before: context, ...
	  // On stack after: result of partial invocation
	  //
	  // This operation pops off a context, invokes a partial with that context,
	  // and pushes the result of the invocation back.
	  invokePartial: function(name) {
	    var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"];
	
	    if (this.options.data) {
	      params.push("data");
	    }
	
	    this.context.aliases.self = "this";
	    this.push("self.invokePartial(" + params.join(", ") + ")");
	  },
	
	  // [assignToHash]
	  //
	  // On stack, before: value, hash, ...
	  // On stack, after: hash, ...
	  //
	  // Pops a value and hash off the stack, assigns `hash[key] = value`
	  // and pushes the hash back onto the stack.
	  assignToHash: function(key) {
	    var value = this.popStack(),
	        context,
	        type;
	
	    if (this.options.stringParams) {
	      type = this.popStack();
	      context = this.popStack();
	    }
	
	    var hash = this.hash;
	    if (context) {
	      hash.contexts.push("'" + key + "': " + context);
	    }
	    if (type) {
	      hash.types.push("'" + key + "': " + type);
	    }
	    hash.values.push("'" + key + "': (" + value + ")");
	  },
	
	  // HELPERS
	
	  compiler: JavaScriptCompiler,
	
	  compileChildren: function(environment, options) {
	    var children = environment.children, child, compiler;
	
	    for(var i=0, l=children.length; i<l; i++) {
	      child = children[i];
	      compiler = new this.compiler();
	
	      var index = this.matchExistingProgram(child);
	
	      if (index == null) {
	        this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
	        index = this.context.programs.length;
	        child.index = index;
	        child.name = 'program' + index;
	        this.context.programs[index] = compiler.compile(child, options, this.context);
	        this.context.environments[index] = child;
	      } else {
	        child.index = index;
	        child.name = 'program' + index;
	      }
	    }
	  },
	  matchExistingProgram: function(child) {
	    for (var i = 0, len = this.context.environments.length; i < len; i++) {
	      var environment = this.context.environments[i];
	      if (environment && environment.equals(child)) {
	        return i;
	      }
	    }
	  },
	
	  programExpression: function(guid) {
	    this.context.aliases.self = "this";
	
	    if(guid == null) {
	      return "self.noop";
	    }
	
	    var child = this.environment.children[guid],
	        depths = child.depths.list, depth;
	
	    var programParams = [child.index, child.name, "data"];
	
	    for(var i=0, l = depths.length; i<l; i++) {
	      depth = depths[i];
	
	      if(depth === 1) { programParams.push("depth0"); }
	      else { programParams.push("depth" + (depth - 1)); }
	    }
	
	    return (depths.length === 0 ? "self.program(" : "self.programWithDepth(") + programParams.join(", ") + ")";
	  },
	
	  register: function(name, val) {
	    this.useRegister(name);
	    this.pushSource(name + " = " + val + ";");
	  },
	
	  useRegister: function(name) {
	    if(!this.registers[name]) {
	      this.registers[name] = true;
	      this.registers.list.push(name);
	    }
	  },
	
	  pushStackLiteral: function(item) {
	    return this.push(new Literal(item));
	  },
	
	  pushSource: function(source) {
	    if (this.pendingContent) {
	      this.source.push(this.appendToBuffer(this.quotedString(this.pendingContent)));
	      this.pendingContent = undefined;
	    }
	
	    if (source) {
	      this.source.push(source);
	    }
	  },
	
	  pushStack: function(item) {
	    this.flushInline();
	
	    var stack = this.incrStack();
	    if (item) {
	      this.pushSource(stack + " = " + item + ";");
	    }
	    this.compileStack.push(stack);
	    return stack;
	  },
	
	  replaceStack: function(callback) {
	    var prefix = '',
	        inline = this.isInline(),
	        stack,
	        createdStack,
	        usedLiteral;
	
	    // If we are currently inline then we want to merge the inline statement into the
	    // replacement statement via ','
	    if (inline) {
	      var top = this.popStack(true);
	
	      if (top instanceof Literal) {
	        // Literals do not need to be inlined
	        stack = top.value;
	        usedLiteral = true;
	      } else {
	        // Get or create the current stack name for use by the inline
	        createdStack = !this.stackSlot;
	        var name = !createdStack ? this.topStackName() : this.incrStack();
	
	        prefix = '(' + this.push(name) + ' = ' + top + '),';
	        stack = this.topStack();
	      }
	    } else {
	      stack = this.topStack();
	    }
	
	    var item = callback.call(this, stack);
	
	    if (inline) {
	      if (!usedLiteral) {
	        this.popStack();
	      }
	      if (createdStack) {
	        this.stackSlot--;
	      }
	      this.push('(' + prefix + item + ')');
	    } else {
	      // Prevent modification of the context depth variable. Through replaceStack
	      if (!/^stack/.test(stack)) {
	        stack = this.nextStack();
	      }
	
	      this.pushSource(stack + " = (" + prefix + item + ");");
	    }
	    return stack;
	  },
	
	  nextStack: function() {
	    return this.pushStack();
	  },
	
	  incrStack: function() {
	    this.stackSlot++;
	    if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
	    return this.topStackName();
	  },
	  topStackName: function() {
	    return "stack" + this.stackSlot;
	  },
	  flushInline: function() {
	    var inlineStack = this.inlineStack;
	    if (inlineStack.length) {
	      this.inlineStack = [];
	      for (var i = 0, len = inlineStack.length; i < len; i++) {
	        var entry = inlineStack[i];
	        if (entry instanceof Literal) {
	          this.compileStack.push(entry);
	        } else {
	          this.pushStack(entry);
	        }
	      }
	    }
	  },
	  isInline: function() {
	    return this.inlineStack.length;
	  },
	
	  popStack: function(wrapped) {
	    var inline = this.isInline(),
	        item = (inline ? this.inlineStack : this.compileStack).pop();
	
	    if (!wrapped && (item instanceof Literal)) {
	      return item.value;
	    } else {
	      if (!inline) {
	        if (!this.stackSlot) {
	          throw new Exception('Invalid stack pop');
	        }
	        this.stackSlot--;
	      }
	      return item;
	    }
	  },
	
	  topStack: function(wrapped) {
	    var stack = (this.isInline() ? this.inlineStack : this.compileStack),
	        item = stack[stack.length - 1];
	
	    if (!wrapped && (item instanceof Literal)) {
	      return item.value;
	    } else {
	      return item;
	    }
	  },
	
	  quotedString: function(str) {
	    return '"' + str
	      .replace(/\\/g, '\\\\')
	      .replace(/"/g, '\\"')
	      .replace(/\n/g, '\\n')
	      .replace(/\r/g, '\\r')
	      .replace(/\u2028/g, '\\u2028')   // Per Ecma-262 7.3 + 7.8.4
	      .replace(/\u2029/g, '\\u2029') + '"';
	  },
	
	  setupHelper: function(paramSize, name, missingParams) {
	    var params = [],
	        paramsInit = this.setupParams(paramSize, params, missingParams);
	    var foundHelper = this.nameLookup('helpers', name, 'helper');
	
	    return {
	      params: params,
	      paramsInit: paramsInit,
	      name: foundHelper,
	      callParams: ["depth0"].concat(params).join(", "),
	      helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ")
	    };
	  },
	
	  setupOptions: function(paramSize, params) {
	    var options = [], contexts = [], types = [], param, inverse, program;
	
	    options.push("hash:" + this.popStack());
	
	    if (this.options.stringParams) {
	      options.push("hashTypes:" + this.popStack());
	      options.push("hashContexts:" + this.popStack());
	    }
	
	    inverse = this.popStack();
	    program = this.popStack();
	
	    // Avoid setting fn and inverse if neither are set. This allows
	    // helpers to do a check for `if (options.fn)`
	    if (program || inverse) {
	      if (!program) {
	        this.context.aliases.self = "this";
	        program = "self.noop";
	      }
	
	      if (!inverse) {
	        this.context.aliases.self = "this";
	        inverse = "self.noop";
	      }
	
	      options.push("inverse:" + inverse);
	      options.push("fn:" + program);
	    }
	
	    for(var i=0; i<paramSize; i++) {
	      param = this.popStack();
	      params.push(param);
	
	      if(this.options.stringParams) {
	        types.push(this.popStack());
	        contexts.push(this.popStack());
	      }
	    }
	
	    if (this.options.stringParams) {
	      options.push("contexts:[" + contexts.join(",") + "]");
	      options.push("types:[" + types.join(",") + "]");
	    }
	
	    if(this.options.data) {
	      options.push("data:data");
	    }
	
	    return options;
	  },
	
	  // the params and contexts arguments are passed in arrays
	  // to fill in
	  setupParams: function(paramSize, params, useRegister) {
	    var options = '{' + this.setupOptions(paramSize, params).join(',') + '}';
	
	    if (useRegister) {
	      this.useRegister('options');
	      params.push('options');
	      return 'options=' + options;
	    } else {
	      params.push(options);
	      return '';
	    }
	  }
	};
	
	var reservedWords = (
	  "break else new var" +
	  " case finally return void" +
	  " catch for switch while" +
	  " continue function this with" +
	  " default if throw" +
	  " delete in try" +
	  " do instanceof typeof" +
	  " abstract enum int short" +
	  " boolean export interface static" +
	  " byte extends long super" +
	  " char final native synchronized" +
	  " class float package throws" +
	  " const goto private transient" +
	  " debugger implements protected volatile" +
	  " double import public let yield"
	).split(" ");
	
	var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
	
	for(var i=0, l=reservedWords.length; i<l; i++) {
	  compilerWords[reservedWords[i]] = true;
	}
	
	JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
	  if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)) {
	    return true;
	  }
	  return false;
	};
	
	exports["default"] = JavaScriptCompiler;

/***/ },
/* 66 */
/***/ function(module, exports) {

	"use strict";
	/* jshint ignore:start */
	/* Jison generated parser */
	var handlebars = (function(){
	var parser = {trace: function trace() { },
	yy: {},
	symbols_: {"error":2,"root":3,"statements":4,"EOF":5,"program":6,"simpleInverse":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"sexpr":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"CLOSE_UNESCAPED":24,"OPEN_PARTIAL":25,"partialName":26,"partial_option0":27,"sexpr_repetition0":28,"sexpr_option0":29,"dataName":30,"param":31,"STRING":32,"INTEGER":33,"BOOLEAN":34,"OPEN_SEXPR":35,"CLOSE_SEXPR":36,"hash":37,"hash_repetition_plus0":38,"hashSegment":39,"ID":40,"EQUALS":41,"DATA":42,"pathSegments":43,"SEP":44,"$accept":0,"$end":1},
	terminals_: {2:"error",5:"EOF",14:"CONTENT",15:"COMMENT",16:"OPEN_BLOCK",18:"CLOSE",19:"OPEN_INVERSE",20:"OPEN_ENDBLOCK",22:"OPEN",23:"OPEN_UNESCAPED",24:"CLOSE_UNESCAPED",25:"OPEN_PARTIAL",32:"STRING",33:"INTEGER",34:"BOOLEAN",35:"OPEN_SEXPR",36:"CLOSE_SEXPR",40:"ID",41:"EQUALS",42:"DATA",44:"SEP"},
	productions_: [0,[3,2],[3,1],[6,2],[6,3],[6,2],[6,1],[6,1],[6,0],[4,1],[4,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,4],[7,2],[17,3],[17,1],[31,1],[31,1],[31,1],[31,1],[31,1],[31,3],[37,1],[39,3],[26,1],[26,1],[26,1],[30,2],[21,1],[43,3],[43,1],[27,0],[27,1],[28,0],[28,2],[29,0],[29,1],[38,1],[38,2]],
	performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
	
	var $0 = $$.length - 1;
	switch (yystate) {
	case 1: return new yy.ProgramNode($$[$0-1], this._$); 
	break;
	case 2: return new yy.ProgramNode([], this._$); 
	break;
	case 3:this.$ = new yy.ProgramNode([], $$[$0-1], $$[$0], this._$);
	break;
	case 4:this.$ = new yy.ProgramNode($$[$0-2], $$[$0-1], $$[$0], this._$);
	break;
	case 5:this.$ = new yy.ProgramNode($$[$0-1], $$[$0], [], this._$);
	break;
	case 6:this.$ = new yy.ProgramNode($$[$0], this._$);
	break;
	case 7:this.$ = new yy.ProgramNode([], this._$);
	break;
	case 8:this.$ = new yy.ProgramNode([], this._$);
	break;
	case 9:this.$ = [$$[$0]];
	break;
	case 10: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
	break;
	case 11:this.$ = new yy.BlockNode($$[$0-2], $$[$0-1].inverse, $$[$0-1], $$[$0], this._$);
	break;
	case 12:this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0-1].inverse, $$[$0], this._$);
	break;
	case 13:this.$ = $$[$0];
	break;
	case 14:this.$ = $$[$0];
	break;
	case 15:this.$ = new yy.ContentNode($$[$0], this._$);
	break;
	case 16:this.$ = new yy.CommentNode($$[$0], this._$);
	break;
	case 17:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$);
	break;
	case 18:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$);
	break;
	case 19:this.$ = {path: $$[$0-1], strip: stripFlags($$[$0-2], $$[$0])};
	break;
	case 20:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$);
	break;
	case 21:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$);
	break;
	case 22:this.$ = new yy.PartialNode($$[$0-2], $$[$0-1], stripFlags($$[$0-3], $$[$0]), this._$);
	break;
	case 23:this.$ = stripFlags($$[$0-1], $$[$0]);
	break;
	case 24:this.$ = new yy.SexprNode([$$[$0-2]].concat($$[$0-1]), $$[$0], this._$);
	break;
	case 25:this.$ = new yy.SexprNode([$$[$0]], null, this._$);
	break;
	case 26:this.$ = $$[$0];
	break;
	case 27:this.$ = new yy.StringNode($$[$0], this._$);
	break;
	case 28:this.$ = new yy.IntegerNode($$[$0], this._$);
	break;
	case 29:this.$ = new yy.BooleanNode($$[$0], this._$);
	break;
	case 30:this.$ = $$[$0];
	break;
	case 31:$$[$0-1].isHelper = true; this.$ = $$[$0-1];
	break;
	case 32:this.$ = new yy.HashNode($$[$0], this._$);
	break;
	case 33:this.$ = [$$[$0-2], $$[$0]];
	break;
	case 34:this.$ = new yy.PartialNameNode($$[$0], this._$);
	break;
	case 35:this.$ = new yy.PartialNameNode(new yy.StringNode($$[$0], this._$), this._$);
	break;
	case 36:this.$ = new yy.PartialNameNode(new yy.IntegerNode($$[$0], this._$));
	break;
	case 37:this.$ = new yy.DataNode($$[$0], this._$);
	break;
	case 38:this.$ = new yy.IdNode($$[$0], this._$);
	break;
	case 39: $$[$0-2].push({part: $$[$0], separator: $$[$0-1]}); this.$ = $$[$0-2]; 
	break;
	case 40:this.$ = [{part: $$[$0]}];
	break;
	case 43:this.$ = [];
	break;
	case 44:$$[$0-1].push($$[$0]);
	break;
	case 47:this.$ = [$$[$0]];
	break;
	case 48:$$[$0-1].push($$[$0]);
	break;
	}
	},
	table: [{3:1,4:2,5:[1,3],8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],25:[1,15]},{1:[3]},{5:[1,16],8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],25:[1,15]},{1:[2,2]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],25:[2,9]},{4:20,6:18,7:19,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,8],22:[1,13],23:[1,14],25:[1,15]},{4:20,6:22,7:19,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,8],22:[1,13],23:[1,14],25:[1,15]},{5:[2,13],14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],25:[2,13]},{5:[2,14],14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],25:[2,14]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],25:[2,15]},{5:[2,16],14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],25:[2,16]},{17:23,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:29,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:30,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:31,21:24,30:25,40:[1,28],42:[1,27],43:26},{21:33,26:32,32:[1,34],33:[1,35],40:[1,28],43:26},{1:[2,1]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],25:[2,10]},{10:36,20:[1,37]},{4:38,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,7],22:[1,13],23:[1,14],25:[1,15]},{7:39,8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,6],22:[1,13],23:[1,14],25:[1,15]},{17:23,18:[1,40],21:24,30:25,40:[1,28],42:[1,27],43:26},{10:41,20:[1,37]},{18:[1,42]},{18:[2,43],24:[2,43],28:43,32:[2,43],33:[2,43],34:[2,43],35:[2,43],36:[2,43],40:[2,43],42:[2,43]},{18:[2,25],24:[2,25],36:[2,25]},{18:[2,38],24:[2,38],32:[2,38],33:[2,38],34:[2,38],35:[2,38],36:[2,38],40:[2,38],42:[2,38],44:[1,44]},{21:45,40:[1,28],43:26},{18:[2,40],24:[2,40],32:[2,40],33:[2,40],34:[2,40],35:[2,40],36:[2,40],40:[2,40],42:[2,40],44:[2,40]},{18:[1,46]},{18:[1,47]},{24:[1,48]},{18:[2,41],21:50,27:49,40:[1,28],43:26},{18:[2,34],40:[2,34]},{18:[2,35],40:[2,35]},{18:[2,36],40:[2,36]},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],25:[2,11]},{21:51,40:[1,28],43:26},{8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,3],22:[1,13],23:[1,14],25:[1,15]},{4:52,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,5],22:[1,13],23:[1,14],25:[1,15]},{14:[2,23],15:[2,23],16:[2,23],19:[2,23],20:[2,23],22:[2,23],23:[2,23],25:[2,23]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],25:[2,12]},{14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],25:[2,18]},{18:[2,45],21:56,24:[2,45],29:53,30:60,31:54,32:[1,57],33:[1,58],34:[1,59],35:[1,61],36:[2,45],37:55,38:62,39:63,40:[1,64],42:[1,27],43:26},{40:[1,65]},{18:[2,37],24:[2,37],32:[2,37],33:[2,37],34:[2,37],35:[2,37],36:[2,37],40:[2,37],42:[2,37]},{14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],25:[2,17]},{5:[2,20],14:[2,20],15:[2,20],16:[2,20],19:[2,20],20:[2,20],22:[2,20],23:[2,20],25:[2,20]},{5:[2,21],14:[2,21],15:[2,21],16:[2,21],19:[2,21],20:[2,21],22:[2,21],23:[2,21],25:[2,21]},{18:[1,66]},{18:[2,42]},{18:[1,67]},{8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],25:[1,15]},{18:[2,24],24:[2,24],36:[2,24]},{18:[2,44],24:[2,44],32:[2,44],33:[2,44],34:[2,44],35:[2,44],36:[2,44],40:[2,44],42:[2,44]},{18:[2,46],24:[2,46],36:[2,46]},{18:[2,26],24:[2,26],32:[2,26],33:[2,26],34:[2,26],35:[2,26],36:[2,26],40:[2,26],42:[2,26]},{18:[2,27],24:[2,27],32:[2,27],33:[2,27],34:[2,27],35:[2,27],36:[2,27],40:[2,27],42:[2,27]},{18:[2,28],24:[2,28],32:[2,28],33:[2,28],34:[2,28],35:[2,28],36:[2,28],40:[2,28],42:[2,28]},{18:[2,29],24:[2,29],32:[2,29],33:[2,29],34:[2,29],35:[2,29],36:[2,29],40:[2,29],42:[2,29]},{18:[2,30],24:[2,30],32:[2,30],33:[2,30],34:[2,30],35:[2,30],36:[2,30],40:[2,30],42:[2,30]},{17:68,21:24,30:25,40:[1,28],42:[1,27],43:26},{18:[2,32],24:[2,32],36:[2,32],39:69,40:[1,70]},{18:[2,47],24:[2,47],36:[2,47],40:[2,47]},{18:[2,40],24:[2,40],32:[2,40],33:[2,40],34:[2,40],35:[2,40],36:[2,40],40:[2,40],41:[1,71],42:[2,40],44:[2,40]},{18:[2,39],24:[2,39],32:[2,39],33:[2,39],34:[2,39],35:[2,39],36:[2,39],40:[2,39],42:[2,39],44:[2,39]},{5:[2,22],14:[2,22],15:[2,22],16:[2,22],19:[2,22],20:[2,22],22:[2,22],23:[2,22],25:[2,22]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],25:[2,19]},{36:[1,72]},{18:[2,48],24:[2,48],36:[2,48],40:[2,48]},{41:[1,71]},{21:56,30:60,31:73,32:[1,57],33:[1,58],34:[1,59],35:[1,61],40:[1,28],42:[1,27],43:26},{18:[2,31],24:[2,31],32:[2,31],33:[2,31],34:[2,31],35:[2,31],36:[2,31],40:[2,31],42:[2,31]},{18:[2,33],24:[2,33],36:[2,33],40:[2,33]}],
	defaultActions: {3:[2,2],16:[2,1],50:[2,42]},
	parseError: function parseError(str, hash) {
	    throw new Error(str);
	},
	parse: function parse(input) {
	    var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
	    this.lexer.setInput(input);
	    this.lexer.yy = this.yy;
	    this.yy.lexer = this.lexer;
	    this.yy.parser = this;
	    if (typeof this.lexer.yylloc == "undefined")
	        this.lexer.yylloc = {};
	    var yyloc = this.lexer.yylloc;
	    lstack.push(yyloc);
	    var ranges = this.lexer.options && this.lexer.options.ranges;
	    if (typeof this.yy.parseError === "function")
	        this.parseError = this.yy.parseError;
	    function popStack(n) {
	        stack.length = stack.length - 2 * n;
	        vstack.length = vstack.length - n;
	        lstack.length = lstack.length - n;
	    }
	    function lex() {
	        var token;
	        token = self.lexer.lex() || 1;
	        if (typeof token !== "number") {
	            token = self.symbols_[token] || token;
	        }
	        return token;
	    }
	    var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
	    while (true) {
	        state = stack[stack.length - 1];
	        if (this.defaultActions[state]) {
	            action = this.defaultActions[state];
	        } else {
	            if (symbol === null || typeof symbol == "undefined") {
	                symbol = lex();
	            }
	            action = table[state] && table[state][symbol];
	        }
	        if (typeof action === "undefined" || !action.length || !action[0]) {
	            var errStr = "";
	            if (!recovering) {
	                expected = [];
	                for (p in table[state])
	                    if (this.terminals_[p] && p > 2) {
	                        expected.push("'" + this.terminals_[p] + "'");
	                    }
	                if (this.lexer.showPosition) {
	                    errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
	                } else {
	                    errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'");
	                }
	                this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
	            }
	        }
	        if (action[0] instanceof Array && action.length > 1) {
	            throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
	        }
	        switch (action[0]) {
	        case 1:
	            stack.push(symbol);
	            vstack.push(this.lexer.yytext);
	            lstack.push(this.lexer.yylloc);
	            stack.push(action[1]);
	            symbol = null;
	            if (!preErrorSymbol) {
	                yyleng = this.lexer.yyleng;
	                yytext = this.lexer.yytext;
	                yylineno = this.lexer.yylineno;
	                yyloc = this.lexer.yylloc;
	                if (recovering > 0)
	                    recovering--;
	            } else {
	                symbol = preErrorSymbol;
	                preErrorSymbol = null;
	            }
	            break;
	        case 2:
	            len = this.productions_[action[1]][1];
	            yyval.$ = vstack[vstack.length - len];
	            yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column};
	            if (ranges) {
	                yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
	            }
	            r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
	            if (typeof r !== "undefined") {
	                return r;
	            }
	            if (len) {
	                stack = stack.slice(0, -1 * len * 2);
	                vstack = vstack.slice(0, -1 * len);
	                lstack = lstack.slice(0, -1 * len);
	            }
	            stack.push(this.productions_[action[1]][0]);
	            vstack.push(yyval.$);
	            lstack.push(yyval._$);
	            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
	            stack.push(newState);
	            break;
	        case 3:
	            return true;
	        }
	    }
	    return true;
	}
	};
	
	
	function stripFlags(open, close) {
	  return {
	    left: open.charAt(2) === '~',
	    right: close.charAt(0) === '~' || close.charAt(1) === '~'
	  };
	}
	
	/* Jison generated lexer */
	var lexer = (function(){
	var lexer = ({EOF:1,
	parseError:function parseError(str, hash) {
	        if (this.yy.parser) {
	            this.yy.parser.parseError(str, hash);
	        } else {
	            throw new Error(str);
	        }
	    },
	setInput:function (input) {
	        this._input = input;
	        this._more = this._less = this.done = false;
	        this.yylineno = this.yyleng = 0;
	        this.yytext = this.matched = this.match = '';
	        this.conditionStack = ['INITIAL'];
	        this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
	        if (this.options.ranges) this.yylloc.range = [0,0];
	        this.offset = 0;
	        return this;
	    },
	input:function () {
	        var ch = this._input[0];
	        this.yytext += ch;
	        this.yyleng++;
	        this.offset++;
	        this.match += ch;
	        this.matched += ch;
	        var lines = ch.match(/(?:\r\n?|\n).*/g);
	        if (lines) {
	            this.yylineno++;
	            this.yylloc.last_line++;
	        } else {
	            this.yylloc.last_column++;
	        }
	        if (this.options.ranges) this.yylloc.range[1]++;
	
	        this._input = this._input.slice(1);
	        return ch;
	    },
	unput:function (ch) {
	        var len = ch.length;
	        var lines = ch.split(/(?:\r\n?|\n)/g);
	
	        this._input = ch + this._input;
	        this.yytext = this.yytext.substr(0, this.yytext.length-len-1);
	        //this.yyleng -= len;
	        this.offset -= len;
	        var oldLines = this.match.split(/(?:\r\n?|\n)/g);
	        this.match = this.match.substr(0, this.match.length-1);
	        this.matched = this.matched.substr(0, this.matched.length-1);
	
	        if (lines.length-1) this.yylineno -= lines.length-1;
	        var r = this.yylloc.range;
	
	        this.yylloc = {first_line: this.yylloc.first_line,
	          last_line: this.yylineno+1,
	          first_column: this.yylloc.first_column,
	          last_column: lines ?
	              (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length:
	              this.yylloc.first_column - len
	          };
	
	        if (this.options.ranges) {
	            this.yylloc.range = [r[0], r[0] + this.yyleng - len];
	        }
	        return this;
	    },
	more:function () {
	        this._more = true;
	        return this;
	    },
	less:function (n) {
	        this.unput(this.match.slice(n));
	    },
	pastInput:function () {
	        var past = this.matched.substr(0, this.matched.length - this.match.length);
	        return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
	    },
	upcomingInput:function () {
	        var next = this.match;
	        if (next.length < 20) {
	            next += this._input.substr(0, 20-next.length);
	        }
	        return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
	    },
	showPosition:function () {
	        var pre = this.pastInput();
	        var c = new Array(pre.length + 1).join("-");
	        return pre + this.upcomingInput() + "\n" + c+"^";
	    },
	next:function () {
	        if (this.done) {
	            return this.EOF;
	        }
	        if (!this._input) this.done = true;
	
	        var token,
	            match,
	            tempMatch,
	            index,
	            col,
	            lines;
	        if (!this._more) {
	            this.yytext = '';
	            this.match = '';
	        }
	        var rules = this._currentRules();
	        for (var i=0;i < rules.length; i++) {
	            tempMatch = this._input.match(this.rules[rules[i]]);
	            if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
	                match = tempMatch;
	                index = i;
	                if (!this.options.flex) break;
	            }
	        }
	        if (match) {
	            lines = match[0].match(/(?:\r\n?|\n).*/g);
	            if (lines) this.yylineno += lines.length;
	            this.yylloc = {first_line: this.yylloc.last_line,
	                           last_line: this.yylineno+1,
	                           first_column: this.yylloc.last_column,
	                           last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length};
	            this.yytext += match[0];
	            this.match += match[0];
	            this.matches = match;
	            this.yyleng = this.yytext.length;
	            if (this.options.ranges) {
	                this.yylloc.range = [this.offset, this.offset += this.yyleng];
	            }
	            this._more = false;
	            this._input = this._input.slice(match[0].length);
	            this.matched += match[0];
	            token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]);
	            if (this.done && this._input) this.done = false;
	            if (token) return token;
	            else return;
	        }
	        if (this._input === "") {
	            return this.EOF;
	        } else {
	            return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(),
	                    {text: "", token: null, line: this.yylineno});
	        }
	    },
	lex:function lex() {
	        var r = this.next();
	        if (typeof r !== 'undefined') {
	            return r;
	        } else {
	            return this.lex();
	        }
	    },
	begin:function begin(condition) {
	        this.conditionStack.push(condition);
	    },
	popState:function popState() {
	        return this.conditionStack.pop();
	    },
	_currentRules:function _currentRules() {
	        return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
	    },
	topState:function () {
	        return this.conditionStack[this.conditionStack.length-2];
	    },
	pushState:function begin(condition) {
	        this.begin(condition);
	    }});
	lexer.options = {};
	lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
	
	
	function strip(start, end) {
	  return yy_.yytext = yy_.yytext.substr(start, yy_.yyleng-end);
	}
	
	
	var YYSTATE=YY_START
	switch($avoiding_name_collisions) {
	case 0:
	                                   if(yy_.yytext.slice(-2) === "\\\\") {
	                                     strip(0,1);
	                                     this.begin("mu");
	                                   } else if(yy_.yytext.slice(-1) === "\\") {
	                                     strip(0,1);
	                                     this.begin("emu");
	                                   } else {
	                                     this.begin("mu");
	                                   }
	                                   if(yy_.yytext) return 14;
	                                 
	break;
	case 1:return 14;
	break;
	case 2:
	                                   this.popState();
	                                   return 14;
	                                 
	break;
	case 3:strip(0,4); this.popState(); return 15;
	break;
	case 4:return 35;
	break;
	case 5:return 36;
	break;
	case 6:return 25;
	break;
	case 7:return 16;
	break;
	case 8:return 20;
	break;
	case 9:return 19;
	break;
	case 10:return 19;
	break;
	case 11:return 23;
	break;
	case 12:return 22;
	break;
	case 13:this.popState(); this.begin('com');
	break;
	case 14:strip(3,5); this.popState(); return 15;
	break;
	case 15:return 22;
	break;
	case 16:return 41;
	break;
	case 17:return 40;
	break;
	case 18:return 40;
	break;
	case 19:return 44;
	break;
	case 20:// ignore whitespace
	break;
	case 21:this.popState(); return 24;
	break;
	case 22:this.popState(); return 18;
	break;
	case 23:yy_.yytext = strip(1,2).replace(/\\"/g,'"'); return 32;
	break;
	case 24:yy_.yytext = strip(1,2).replace(/\\'/g,"'"); return 32;
	break;
	case 25:return 42;
	break;
	case 26:return 34;
	break;
	case 27:return 34;
	break;
	case 28:return 33;
	break;
	case 29:return 40;
	break;
	case 30:yy_.yytext = strip(1,2); return 40;
	break;
	case 31:return 'INVALID';
	break;
	case 32:return 5;
	break;
	}
	};
	lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\()/,/^(?:\))/,/^(?:\{\{(~)?>)/,/^(?:\{\{(~)?#)/,/^(?:\{\{(~)?\/)/,/^(?:\{\{(~)?\^)/,/^(?:\{\{(~)?\s*else\b)/,/^(?:\{\{(~)?\{)/,/^(?:\{\{(~)?&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{(~)?)/,/^(?:=)/,/^(?:\.\.)/,/^(?:\.(?=([=~}\s\/.)])))/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}(~)?\}\})/,/^(?:(~)?\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=([~}\s)])))/,/^(?:false(?=([~}\s)])))/,/^(?:-?[0-9]+(?=([~}\s)])))/,/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)]))))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/];
	lexer.conditions = {"mu":{"rules":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[3],"inclusive":false},"INITIAL":{"rules":[0,1,32],"inclusive":true}};
	return lexer;})()
	parser.lexer = lexer;
	function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser;
	return new Parser;
	})();exports["default"] = handlebars;
	/* jshint ignore:end */

/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	var Utils = __webpack_require__(12);
	var Exception = __webpack_require__(5)["default"];
	var COMPILER_REVISION = __webpack_require__(4).COMPILER_REVISION;
	var REVISION_CHANGES = __webpack_require__(4).REVISION_CHANGES;
	
	function checkRevision(compilerInfo) {
	  var compilerRevision = compilerInfo && compilerInfo[0] || 1,
	      currentRevision = COMPILER_REVISION;
	
	  if (compilerRevision !== currentRevision) {
	    if (compilerRevision < currentRevision) {
	      var runtimeVersions = REVISION_CHANGES[currentRevision],
	          compilerVersions = REVISION_CHANGES[compilerRevision];
	      throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
	            "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
	    } else {
	      // Use the embedded version info since the runtime doesn't know about this revision yet
	      throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
	            "Please update your runtime to a newer version ("+compilerInfo[1]+").");
	    }
	  }
	}
	
	exports.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial
	
	function template(templateSpec, env) {
	  if (!env) {
	    throw new Exception("No environment passed to template");
	  }
	
	  // Note: Using env.VM references rather than local var references throughout this section to allow
	  // for external users to override these as psuedo-supported APIs.
	  var invokePartialWrapper = function(partial, name, context, helpers, partials, data) {
	    var result = env.VM.invokePartial.apply(this, arguments);
	    if (result != null) { return result; }
	
	    if (env.compile) {
	      var options = { helpers: helpers, partials: partials, data: data };
	      partials[name] = env.compile(partial, { data: data !== undefined }, env);
	      return partials[name](context, options);
	    } else {
	      throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
	    }
	  };
	
	  // Just add water
	  var container = {
	    escapeExpression: Utils.escapeExpression,
	    invokePartial: invokePartialWrapper,
	    programs: [],
	    program: function(i, fn, data) {
	      var programWrapper = this.programs[i];
	      if(data) {
	        programWrapper = program(i, fn, data);
	      } else if (!programWrapper) {
	        programWrapper = this.programs[i] = program(i, fn);
	      }
	      return programWrapper;
	    },
	    merge: function(param, common) {
	      var ret = param || common;
	
	      if (param && common && (param !== common)) {
	        ret = {};
	        Utils.extend(ret, common);
	        Utils.extend(ret, param);
	      }
	      return ret;
	    },
	    programWithDepth: env.VM.programWithDepth,
	    noop: env.VM.noop,
	    compilerInfo: null
	  };
	
	  return function(context, options) {
	    options = options || {};
	    var namespace = options.partial ? options : env,
	        helpers,
	        partials;
	
	    if (!options.partial) {
	      helpers = options.helpers;
	      partials = options.partials;
	    }
	    var result = templateSpec.call(
	          container,
	          namespace, context,
	          helpers,
	          partials,
	          options.data);
	
	    if (!options.partial) {
	      env.VM.checkRevision(container.compilerInfo);
	    }
	
	    return result;
	  };
	}
	
	exports.template = template;function programWithDepth(i, fn, data /*, $depth */) {
	  var args = Array.prototype.slice.call(arguments, 3);
	
	  var prog = function(context, options) {
	    options = options || {};
	
	    return fn.apply(this, [context, options.data || data].concat(args));
	  };
	  prog.program = i;
	  prog.depth = args.length;
	  return prog;
	}
	
	exports.programWithDepth = programWithDepth;function program(i, fn, data) {
	  var prog = function(context, options) {
	    options = options || {};
	
	    return fn(context, options.data || data);
	  };
	  prog.program = i;
	  prog.depth = 0;
	  return prog;
	}
	
	exports.program = program;function invokePartial(partial, name, context, helpers, partials, data) {
	  var options = { partial: true, helpers: helpers, partials: partials, data: data };
	
	  if(partial === undefined) {
	    throw new Exception("The partial " + name + " could not be found");
	  } else if(partial instanceof Function) {
	    return partial(context, options);
	  }
	}
	
	exports.invokePartial = invokePartial;function noop() { return ""; }
	
	exports.noop = noop;

/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     Underscore.js 1.6.0
	//     http://underscorejs.org
	//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	//     Underscore may be freely distributed under the MIT license.
	
	(function() {
	
	  // Baseline setup
	  // --------------
	
	  // Establish the root object, `window` in the browser, or `exports` on the server.
	  var root = this;
	
	  // Save the previous value of the `_` variable.
	  var previousUnderscore = root._;
	
	  // Establish the object that gets returned to break out of a loop iteration.
	  var breaker = {};
	
	  // Save bytes in the minified (but not gzipped) version:
	  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
	
	  // Create quick reference variables for speed access to core prototypes.
	  var
	    push             = ArrayProto.push,
	    slice            = ArrayProto.slice,
	    concat           = ArrayProto.concat,
	    toString         = ObjProto.toString,
	    hasOwnProperty   = ObjProto.hasOwnProperty;
	
	  // All **ECMAScript 5** native function implementations that we hope to use
	  // are declared here.
	  var
	    nativeIsArray      = Array.isArray,
	    nativeKeys         = Object.keys,
	    nativeBind         = FuncProto.bind;
	
	  // Create a safe reference to the Underscore object for use below.
	  var _ = function(obj) {
	    if (obj instanceof _) return obj;
	    if (!(this instanceof _)) return new _(obj);
	    this._wrapped = obj;
	  };
	
	  // Export the Underscore object for **Node.js**, with
	  // backwards-compatibility for the old `require()` API. If we're in
	  // the browser, add `_` as a global object via a string identifier,
	  // for Closure Compiler "advanced" mode.
	  if (true) {
	    if (typeof module !== 'undefined' && module.exports) {
	      exports = module.exports = _;
	    }
	    exports._ = _;
	  } else {
	    root._ = _;
	  }
	
	  // Current version.
	  _.VERSION = '1.6.0';
	
	  // Collection Functions
	  // --------------------
	
	  // The cornerstone, an `each` implementation, aka `forEach`.
	  // Handles raw objects in addition to array-likes. Treats all
	  // sparse array-likes as if they were dense.
	  _.each = _.forEach = function(obj, iterator, context) {
	    if (obj == null) return obj;
	    if (obj.length === +obj.length) {
	      for (var i = 0, length = obj.length; i < length; i++) {
	        if (iterator.call(context, obj[i], i, obj) === breaker) return;
	      }
	    } else {
	      var keys = _.keys(obj);
	      for (var i = 0, length = keys.length; i < length; i++) {
	        if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
	      }
	    }
	    return obj;
	  };
	
	  // Return the results of applying the iterator to each element.
	  _.map = _.collect = function(obj, iterator, context) {
	    var results = [];
	    if (obj == null) return results;
	    _.each(obj, function(value, index, list) {
	      results.push(iterator.call(context, value, index, list));
	    });
	    return results;
	  };
	
	  var reduceError = 'Reduce of empty array with no initial value';
	
	  // **Reduce** builds up a single result from a list of values, aka `inject`,
	  // or `foldl`.
	  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
	    var initial = arguments.length > 2;
	    if (obj == null) obj = [];
	    _.each(obj, function(value, index, list) {
	      if (!initial) {
	        memo = value;
	        initial = true;
	      } else {
	        memo = iterator.call(context, memo, value, index, list);
	      }
	    });
	    if (!initial) throw new TypeError(reduceError);
	    return memo;
	  };
	
	  // The right-associative version of reduce, also known as `foldr`.
	  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
	    var initial = arguments.length > 2;
	    if (obj == null) obj = [];
	    var length = obj.length;
	    if (length !== +length) {
	      var keys = _.keys(obj);
	      length = keys.length;
	    }
	    _.each(obj, function(value, index, list) {
	      index = keys ? keys[--length] : --length;
	      if (!initial) {
	        memo = obj[index];
	        initial = true;
	      } else {
	        memo = iterator.call(context, memo, obj[index], index, list);
	      }
	    });
	    if (!initial) throw new TypeError(reduceError);
	    return memo;
	  };
	
	  // Return the first value which passes a truth test. Aliased as `detect`.
	  _.find = _.detect = function(obj, predicate, context) {
	    var result;
	    _.some(obj, function(value, index, list) {
	      if (predicate.call(context, value, index, list)) {
	        result = value;
	        return true;
	      }
	    });
	    return result;
	  };
	
	  // Return all the elements that pass a truth test.
	  // Aliased as `select`.
	  _.filter = _.select = function(obj, predicate, context) {
	    var results = [];
	    if (obj == null) return results;
	    _.each(obj, function(value, index, list) {
	      if (predicate.call(context, value, index, list)) results.push(value);
	    });
	    return results;
	  };
	
	  // Return all the elements for which a truth test fails.
	  _.reject = function(obj, predicate, context) {
	    return _.filter(obj, _.negate(predicate), context);
	  };
	
	  // Determine whether all of the elements match a truth test.
	  // Aliased as `all`.
	  _.every = _.all = function(obj, predicate, context) {
	    predicate || (predicate = _.identity);
	    var result = true;
	    if (obj == null) return result;
	    _.each(obj, function(value, index, list) {
	      if (!(result = result && predicate.call(context, value, index, list))) return breaker;
	    });
	    return !!result;
	  };
	
	  // Determine if at least one element in the object matches a truth test.
	  // Aliased as `any`.
	  _.some = _.any = function(obj, predicate, context) {
	    predicate || (predicate = _.identity);
	    var result = false;
	    if (obj == null) return result;
	    _.each(obj, function(value, index, list) {
	      if (result || (result = predicate.call(context, value, index, list))) return breaker;
	    });
	    return !!result;
	  };
	
	  // Determine if the array or object contains a given value (using `===`).
	  // Aliased as `include`.
	  _.contains = _.include = function(obj, target) {
	    if (obj == null) return false;
	    if (obj.length === +obj.length) return _.indexOf(obj, target) >= 0;
	    return _.some(obj, function(value) {
	      return value === target;
	    });
	  };
	
	  // Invoke a method (with arguments) on every item in a collection.
	  _.invoke = function(obj, method) {
	    var args = slice.call(arguments, 2);
	    var isFunc = _.isFunction(method);
	    return _.map(obj, function(value) {
	      return (isFunc ? method : value[method]).apply(value, args);
	    });
	  };
	
	  // Convenience version of a common use case of `map`: fetching a property.
	  _.pluck = function(obj, key) {
	    return _.map(obj, _.property(key));
	  };
	
	  // Convenience version of a common use case of `filter`: selecting only objects
	  // containing specific `key:value` pairs.
	  _.where = function(obj, attrs) {
	    return _.filter(obj, _.matches(attrs));
	  };
	
	  // Convenience version of a common use case of `find`: getting the first object
	  // containing specific `key:value` pairs.
	  _.findWhere = function(obj, attrs) {
	    return _.find(obj, _.matches(attrs));
	  };
	
	  // Return the maximum element or (element-based computation).
	  _.max = function(obj, iterator, context) {
	    var result = -Infinity, lastComputed = -Infinity,
	        value, computed;
	    if (!iterator && _.isArray(obj)) {
	      for (var i = 0, length = obj.length; i < length; i++) {
	        value = obj[i];
	        if (value > result) {
	          result = value;
	        }
	      }
	    } else {
	      _.each(obj, function(value, index, list) {
	        computed = iterator ? iterator.call(context, value, index, list) : value;
	        if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {
	          result = value;
	          lastComputed = computed;
	        }
	      });
	    }
	    return result;
	  };
	
	  // Return the minimum element (or element-based computation).
	  _.min = function(obj, iterator, context) {
	    var result = Infinity, lastComputed = Infinity,
	        value, computed;
	    if (!iterator && _.isArray(obj)) {
	      for (var i = 0, length = obj.length; i < length; i++) {
	        value = obj[i];
	        if (value < result) {
	          result = value;
	        }
	      }
	    } else {
	      _.each(obj, function(value, index, list) {
	        computed = iterator ? iterator.call(context, value, index, list) : value;
	        if (computed < lastComputed || (computed === Infinity && result === Infinity)) {
	          result = value;
	          lastComputed = computed;
	        }
	      });
	    }
	    return result;
	  };
	
	  // Shuffle an array, using the modern version of the
	  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
	  _.shuffle = function(obj) {
	    var rand;
	    var index = 0;
	    var shuffled = [];
	    _.each(obj, function(value) {
	      rand = _.random(index++);
	      shuffled[index - 1] = shuffled[rand];
	      shuffled[rand] = value;
	    });
	    return shuffled;
	  };
	
	  // Sample **n** random values from a collection.
	  // If **n** is not specified, returns a single random element.
	  // The internal `guard` argument allows it to work with `map`.
	  _.sample = function(obj, n, guard) {
	    if (n == null || guard) {
	      if (obj.length !== +obj.length) obj = _.values(obj);
	      return obj[_.random(obj.length - 1)];
	    }
	    return _.shuffle(obj).slice(0, Math.max(0, n));
	  };
	
	  // An internal function to generate lookup iterators.
	  var lookupIterator = function(value, context) {
	    if (value == null) return _.identity;
	    if (!_.isFunction(value)) return _.property(value);
	    if (!context) return value;
	    return function() {
	      return value.apply(context, arguments);
	    };
	  };
	
	  // Sort the object's values by a criterion produced by an iterator.
	  _.sortBy = function(obj, iterator, context) {
	    iterator = lookupIterator(iterator, context);
	    return _.pluck(_.map(obj, function(value, index, list) {
	      return {
	        value: value,
	        index: index,
	        criteria: iterator(value, index, list)
	      };
	    }).sort(function(left, right) {
	      var a = left.criteria;
	      var b = right.criteria;
	      if (a !== b) {
	        if (a > b || a === void 0) return 1;
	        if (a < b || b === void 0) return -1;
	      }
	      return left.index - right.index;
	    }), 'value');
	  };
	
	  // An internal function used for aggregate "group by" operations.
	  var group = function(behavior) {
	    return function(obj, iterator, context) {
	      var result = {};
	      iterator = lookupIterator(iterator, context);
	      _.each(obj, function(value, index) {
	        var key = iterator(value, index, obj);
	        behavior(result, value, key);
	      });
	      return result;
	    };
	  };
	
	  // Groups the object's values by a criterion. Pass either a string attribute
	  // to group by, or a function that returns the criterion.
	  _.groupBy = group(function(result, value, key) {
	    _.has(result, key) ? result[key].push(value) : result[key] = [value];
	  });
	
	  // Indexes the object's values by a criterion, similar to `groupBy`, but for
	  // when you know that your index values will be unique.
	  _.indexBy = group(function(result, value, key) {
	    result[key] = value;
	  });
	
	  // Counts instances of an object that group by a certain criterion. Pass
	  // either a string attribute to count by, or a function that returns the
	  // criterion.
	  _.countBy = group(function(result, value, key) {
	    _.has(result, key) ? result[key]++ : result[key] = 1;
	  });
	
	  // Use a comparator function to figure out the smallest index at which
	  // an object should be inserted so as to maintain order. Uses binary search.
	  _.sortedIndex = function(array, obj, iterator, context) {
	    iterator = lookupIterator(iterator, context);
	    var value = iterator(obj);
	    var low = 0, high = array.length;
	    while (low < high) {
	      var mid = (low + high) >>> 1;
	      iterator(array[mid]) < value ? low = mid + 1 : high = mid;
	    }
	    return low;
	  };
	
	  // Safely create a real, live array from anything iterable.
	  _.toArray = function(obj) {
	    if (!obj) return [];
	    if (_.isArray(obj)) return slice.call(obj);
	    if (obj.length === +obj.length) return _.map(obj, _.identity);
	    return _.values(obj);
	  };
	
	  // Return the number of elements in an object.
	  _.size = function(obj) {
	    if (obj == null) return 0;
	    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
	  };
	
	  // Array Functions
	  // ---------------
	
	  // Get the first element of an array. Passing **n** will return the first N
	  // values in the array. Aliased as `head` and `take`. The **guard** check
	  // allows it to work with `_.map`.
	  _.first = _.head = _.take = function(array, n, guard) {
	    if (array == null) return void 0;
	    if ((n == null) || guard) return array[0];
	    if (n < 0) return [];
	    return slice.call(array, 0, n);
	  };
	
	  // Returns everything but the last entry of the array. Especially useful on
	  // the arguments object. Passing **n** will return all the values in
	  // the array, excluding the last N. The **guard** check allows it to work with
	  // `_.map`.
	  _.initial = function(array, n, guard) {
	    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
	  };
	
	  // Get the last element of an array. Passing **n** will return the last N
	  // values in the array. The **guard** check allows it to work with `_.map`.
	  _.last = function(array, n, guard) {
	    if (array == null) return void 0;
	    if ((n == null) || guard) return array[array.length - 1];
	    return slice.call(array, Math.max(array.length - n, 0));
	  };
	
	  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
	  // Especially useful on the arguments object. Passing an **n** will return
	  // the rest N values in the array. The **guard**
	  // check allows it to work with `_.map`.
	  _.rest = _.tail = _.drop = function(array, n, guard) {
	    return slice.call(array, (n == null) || guard ? 1 : n);
	  };
	
	  // Trim out all falsy values from an array.
	  _.compact = function(array) {
	    return _.filter(array, _.identity);
	  };
	
	  // Internal implementation of a recursive `flatten` function.
	  var flatten = function(input, shallow, strict, output) {
	    if (shallow && _.every(input, _.isArray)) {
	      return concat.apply(output, input);
	    }
	    for (var i = 0, length = input.length; i < length; i++) {
	      var value = input[i];
	      if (!_.isArray(value) && !_.isArguments(value)) {
	        if (!strict) output.push(value);
	      } else if (shallow) {
	        push.apply(output, value);
	      } else {
	        flatten(value, shallow, strict, output);
	      }
	    }
	    return output;
	  };
	
	  // Flatten out an array, either recursively (by default), or just one level.
	  _.flatten = function(array, shallow) {
	    return flatten(array, shallow, false, []);
	  };
	
	  // Return a version of the array that does not contain the specified value(s).
	  _.without = function(array) {
	    return _.difference(array, slice.call(arguments, 1));
	  };
	
	  // Split an array into two arrays: one whose elements all satisfy the given
	  // predicate, and one whose elements all do not satisfy the predicate.
	  _.partition = function(obj, predicate, context) {
	    predicate = lookupIterator(predicate, context);
	    var pass = [], fail = [];
	    _.each(obj, function(value, key, obj) {
	      (predicate(value, key, obj) ? pass : fail).push(value);
	    });
	    return [pass, fail];
	  };
	
	  // Produce a duplicate-free version of the array. If the array has already
	  // been sorted, you have the option of using a faster algorithm.
	  // Aliased as `unique`.
	  _.uniq = _.unique = function(array, isSorted, iterator, context) {
	    if (array == null) return [];
	    if (_.isFunction(isSorted)) {
	      context = iterator;
	      iterator = isSorted;
	      isSorted = false;
	    }
	    var result = [];
	    var seen = [];
	    for (var i = 0, length = array.length; i < length; i++) {
	      var value = array[i];
	      if (iterator) value = iterator.call(context, value, i, array);
	      if (isSorted ? (!i || seen !== value) : !_.contains(seen, value)) {
	        if (isSorted) seen = value;
	        else seen.push(value);
	        result.push(array[i]);
	      }
	    }
	    return result;
	  };
	
	  // Produce an array that contains the union: each distinct element from all of
	  // the passed-in arrays.
	  _.union = function() {
	    return _.uniq(flatten(arguments, true, true, []));
	  };
	
	  // Produce an array that contains every item shared between all the
	  // passed-in arrays.
	  _.intersection = function(array) {
	    if (array == null) return [];
	    var result = [];
	    var argsLength = arguments.length;
	    for (var i = 0, length = array.length; i < length; i++) {
	      var item = array[i];
	      if (_.contains(result, item)) continue;
	      for (var j = 1; j < argsLength; j++) {
	        if (!_.contains(arguments[j], item)) break;
	      }
	      if (j === argsLength) result.push(item);
	    }
	    return result;
	  };
	
	  // Take the difference between one array and a number of other arrays.
	  // Only the elements present in just the first array will remain.
	  _.difference = function(array) {
	    var rest = flatten(slice.call(arguments, 1), true, true, []);
	    return _.filter(array, function(value){ return !_.contains(rest, value); });
	  };
	
	  // Zip together multiple lists into a single array -- elements that share
	  // an index go together.
	  _.zip = function() {
	    var length = _.max(_.pluck(arguments, 'length').concat(0));
	    var results = new Array(length);
	    for (var i = 0; i < length; i++) {
	      results[i] = _.pluck(arguments, '' + i);
	    }
	    return results;
	  };
	
	  // Converts lists into objects. Pass either a single array of `[key, value]`
	  // pairs, or two parallel arrays of the same length -- one of keys, and one of
	  // the corresponding values.
	  _.object = function(list, values) {
	    if (list == null) return {};
	    var result = {};
	    for (var i = 0, length = list.length; i < length; i++) {
	      if (values) {
	        result[list[i]] = values[i];
	      } else {
	        result[list[i][0]] = list[i][1];
	      }
	    }
	    return result;
	  };
	
	  // Return the position of the first occurrence of an item in an array,
	  // or -1 if the item is not included in the array.
	  // If the array is large and already in sort order, pass `true`
	  // for **isSorted** to use binary search.
	  _.indexOf = function(array, item, isSorted) {
	    if (array == null) return -1;
	    var i = 0, length = array.length;
	    if (isSorted) {
	      if (typeof isSorted == 'number') {
	        i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
	      } else {
	        i = _.sortedIndex(array, item);
	        return array[i] === item ? i : -1;
	      }
	    }
	    for (; i < length; i++) if (array[i] === item) return i;
	    return -1;
	  };
	
	  _.lastIndexOf = function(array, item, from) {
	    if (array == null) return -1;
	    var i = from == null ? array.length : from;
	    while (i--) if (array[i] === item) return i;
	    return -1;
	  };
	
	  // Generate an integer Array containing an arithmetic progression. A port of
	  // the native Python `range()` function. See
	  // [the Python documentation](http://docs.python.org/library/functions.html#range).
	  _.range = function(start, stop, step) {
	    if (arguments.length <= 1) {
	      stop = start || 0;
	      start = 0;
	    }
	    step = arguments[2] || 1;
	
	    var length = Math.max(Math.ceil((stop - start) / step), 0);
	    var idx = 0;
	    var range = new Array(length);
	
	    while(idx < length) {
	      range[idx++] = start;
	      start += step;
	    }
	
	    return range;
	  };
	
	  // Function (ahem) Functions
	  // ------------------
	
	  // Reusable constructor function for prototype setting.
	  var ctor = function(){};
	
	  // Create a function bound to a given object (assigning `this`, and arguments,
	  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
	  // available.
	  _.bind = function(func, context) {
	    var args, bound;
	    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
	    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
	    args = slice.call(arguments, 2);
	    return bound = function() {
	      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
	      ctor.prototype = func.prototype;
	      var self = new ctor;
	      ctor.prototype = null;
	      var result = func.apply(self, args.concat(slice.call(arguments)));
	      if (Object(result) === result) return result;
	      return self;
	    };
	  };
	
	  // Partially apply a function by creating a version that has had some of its
	  // arguments pre-filled, without changing its dynamic `this` context. _ acts
	  // as a placeholder, allowing any combination of arguments to be pre-filled.
	  _.partial = function(func) {
	    var boundArgs = slice.call(arguments, 1);
	    return function() {
	      var position = 0;
	      var args = boundArgs.slice();
	      for (var i = 0, length = args.length; i < length; i++) {
	        if (args[i] === _) args[i] = arguments[position++];
	      }
	      while (position < arguments.length) args.push(arguments[position++]);
	      return func.apply(this, args);
	    };
	  };
	
	  // Bind a number of an object's methods to that object. Remaining arguments
	  // are the method names to be bound. Useful for ensuring that all callbacks
	  // defined on an object belong to it.
	  _.bindAll = function(obj) {
	    var funcs = slice.call(arguments, 1);
	    if (funcs.length === 0) throw new Error('bindAll must be passed function names');
	    _.each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
	    return obj;
	  };
	
	  // Memoize an expensive function by storing its results.
	  _.memoize = function(func, hasher) {
	    var memo = {};
	    hasher || (hasher = _.identity);
	    return function() {
	      var key = hasher.apply(this, arguments);
	      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
	    };
	  };
	
	  // Delays a function for the given number of milliseconds, and then calls
	  // it with the arguments supplied.
	  _.delay = function(func, wait) {
	    var args = slice.call(arguments, 2);
	    return setTimeout(function(){ return func.apply(null, args); }, wait);
	  };
	
	  // Defers a function, scheduling it to run after the current call stack has
	  // cleared.
	  _.defer = function(func) {
	    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
	  };
	
	  // Returns a function, that, when invoked, will only be triggered at most once
	  // during a given window of time. Normally, the throttled function will run
	  // as much as it can, without ever going more than once per `wait` duration;
	  // but if you'd like to disable the execution on the leading edge, pass
	  // `{leading: false}`. To disable execution on the trailing edge, ditto.
	  _.throttle = function(func, wait, options) {
	    var context, args, result;
	    var timeout = null;
	    var previous = 0;
	    options || (options = {});
	    var later = function() {
	      previous = options.leading === false ? 0 : _.now();
	      timeout = null;
	      result = func.apply(context, args);
	      context = args = null;
	    };
	    return function() {
	      var now = _.now();
	      if (!previous && options.leading === false) previous = now;
	      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 && options.trailing !== false) {
	        timeout = setTimeout(later, remaining);
	      }
	      return result;
	    };
	  };
	
	  // Returns a function, that, as long as it continues to be invoked, will not
	  // be triggered. The function will be called after it stops being called for
	  // N milliseconds. If `immediate` is passed, trigger the function on the
	  // leading edge, instead of the trailing.
	  _.debounce = function(func, wait, immediate) {
	    var timeout, args, context, timestamp, result;
	
	    var later = function() {
	      var last = _.now() - timestamp;
	
	      if (last < wait && last > 0) {
	        timeout = setTimeout(later, wait - last);
	      } else {
	        timeout = null;
	        if (!immediate) {
	          result = func.apply(context, args);
	          context = args = null;
	        }
	      }
	    };
	
	    return function() {
	      context = this;
	      args = arguments;
	      timestamp = _.now();
	      var callNow = immediate && !timeout;
	      if (!timeout) {
	        timeout = setTimeout(later, wait);
	      }
	      if (callNow) {
	        result = func.apply(context, args);
	        context = args = null;
	      }
	
	      return result;
	    };
	  };
	
	  // Returns a function that will be executed at most one time, no matter how
	  // often you call it. Useful for lazy initialization.
	  _.once = function(func) {
	    var ran = false, memo;
	    return function() {
	      if (ran) return memo;
	      ran = true;
	      memo = func.apply(this, arguments);
	      func = null;
	      return memo;
	    };
	  };
	
	  // Returns the first function passed as an argument to the second,
	  // allowing you to adjust arguments, run code before and after, and
	  // conditionally execute the original function.
	  _.wrap = function(func, wrapper) {
	    return _.partial(wrapper, func);
	  };
	
	  // Returns a negated version of the passed-in predicate.
	  _.negate = function(predicate) {
	    return function() {
	      return !predicate.apply(this, arguments);
	    };
	  };
	
	  // Returns a function that is the composition of a list of functions, each
	  // consuming the return value of the function that follows.
	  _.compose = function() {
	    var funcs = arguments;
	    return function() {
	      var args = arguments;
	      for (var i = funcs.length - 1; i >= 0; i--) {
	        args = [funcs[i].apply(this, args)];
	      }
	      return args[0];
	    };
	  };
	
	  // Returns a function that will only be executed after being called N times.
	  _.after = function(times, func) {
	    return function() {
	      if (--times < 1) {
	        return func.apply(this, arguments);
	      }
	    };
	  };
	
	  // Object Functions
	  // ----------------
	
	  // Retrieve the names of an object's properties.
	  // Delegates to **ECMAScript 5**'s native `Object.keys`
	  _.keys = function(obj) {
	    if (!_.isObject(obj)) return [];
	    if (nativeKeys) return nativeKeys(obj);
	    var keys = [];
	    for (var key in obj) if (_.has(obj, key)) keys.push(key);
	    return keys;
	  };
	
	  // Retrieve the values of an object's properties.
	  _.values = function(obj) {
	    var keys = _.keys(obj);
	    var length = keys.length;
	    var values = new Array(length);
	    for (var i = 0; i < length; i++) {
	      values[i] = obj[keys[i]];
	    }
	    return values;
	  };
	
	  // Convert an object into a list of `[key, value]` pairs.
	  _.pairs = function(obj) {
	    var keys = _.keys(obj);
	    var length = keys.length;
	    var pairs = new Array(length);
	    for (var i = 0; i < length; i++) {
	      pairs[i] = [keys[i], obj[keys[i]]];
	    }
	    return pairs;
	  };
	
	  // Invert the keys and values of an object. The values must be serializable.
	  _.invert = function(obj) {
	    var result = {};
	    var keys = _.keys(obj);
	    for (var i = 0, length = keys.length; i < length; i++) {
	      result[obj[keys[i]]] = keys[i];
	    }
	    return result;
	  };
	
	  // Return a sorted list of the function names available on the object.
	  // Aliased as `methods`
	  _.functions = _.methods = function(obj) {
	    var names = [];
	    for (var key in obj) {
	      if (_.isFunction(obj[key])) names.push(key);
	    }
	    return names.sort();
	  };
	
	  // Extend a given object with all the properties in passed-in object(s).
	  _.extend = function(obj) {
	    if (!_.isObject(obj)) return obj;
	    _.each(slice.call(arguments, 1), function(source) {
	      for (var prop in source) {
	        obj[prop] = source[prop];
	      }
	    });
	    return obj;
	  };
	
	  // Return a copy of the object only containing the whitelisted properties.
	  _.pick = function(obj, iterator, context) {
	    var result = {};
	    if (_.isFunction(iterator)) {
	      for (var key in obj) {
	        var value = obj[key];
	        if (iterator.call(context, value, key, obj)) result[key] = value;
	      }
	    } else {
	      var keys = concat.apply([], slice.call(arguments, 1));
	      for (var i = 0, length = keys.length; i < length; i++) {
	        var key = keys[i];
	        if (key in obj) result[key] = obj[key];
	      }
	    }
	    return result;
	  };
	
	   // Return a copy of the object without the blacklisted properties.
	  _.omit = function(obj, iterator, context) {
	    var keys;
	    if (_.isFunction(iterator)) {
	      iterator = _.negate(iterator);
	    } else {
	      keys = _.map(concat.apply([], slice.call(arguments, 1)), String);
	      iterator = function(value, key) { return !_.contains(keys, key); };
	    }
	    return _.pick(obj, iterator, context);
	  };
	
	  // Fill in a given object with default properties.
	  _.defaults = function(obj) {
	    if (!_.isObject(obj)) return obj;
	    _.each(slice.call(arguments, 1), function(source) {
	      for (var prop in source) {
	        if (obj[prop] === void 0) obj[prop] = source[prop];
	      }
	    });
	    return obj;
	  };
	
	  // Create a (shallow-cloned) duplicate of an object.
	  _.clone = function(obj) {
	    if (!_.isObject(obj)) return obj;
	    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
	  };
	
	  // Invokes interceptor with the obj, and then returns obj.
	  // The primary purpose of this method is to "tap into" a method chain, in
	  // order to perform operations on intermediate results within the chain.
	  _.tap = function(obj, interceptor) {
	    interceptor(obj);
	    return obj;
	  };
	
	  // Internal recursive comparison function for `isEqual`.
	  var eq = function(a, b, aStack, bStack) {
	    // Identical objects are equal. `0 === -0`, but they aren't identical.
	    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
	    if (a === b) return a !== 0 || 1 / a == 1 / b;
	    // A strict comparison is necessary because `null == undefined`.
	    if (a == null || b == null) return a === b;
	    // Unwrap any wrapped objects.
	    if (a instanceof _) a = a._wrapped;
	    if (b instanceof _) b = b._wrapped;
	    // Compare `[[Class]]` names.
	    var className = toString.call(a);
	    if (className != toString.call(b)) return false;
	    switch (className) {
	      // Strings, numbers, dates, and booleans are compared by value.
	      case '[object String]':
	        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
	        // equivalent to `new String("5")`.
	        return a == String(b);
	      case '[object Number]':
	        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
	        // other numeric values.
	        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
	      case '[object Date]':
	      case '[object Boolean]':
	        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
	        // millisecond representations. Note that invalid dates with millisecond representations
	        // of `NaN` are not equivalent.
	        return +a == +b;
	      // RegExps are compared by their source patterns and flags.
	      case '[object RegExp]':
	        return a.source == b.source &&
	               a.global == b.global &&
	               a.multiline == b.multiline &&
	               a.ignoreCase == b.ignoreCase;
	    }
	    if (typeof a != 'object' || typeof b != 'object') return false;
	    // Assume equality for cyclic structures. The algorithm for detecting cyclic
	    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
	    var length = aStack.length;
	    while (length--) {
	      // Linear search. Performance is inversely proportional to the number of
	      // unique nested structures.
	      if (aStack[length] == a) return bStack[length] == b;
	    }
	    // Objects with different constructors are not equivalent, but `Object`s
	    // from different frames are.
	    var aCtor = a.constructor, bCtor = b.constructor;
	    if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
	                             _.isFunction(bCtor) && (bCtor instanceof bCtor))
	                        && ('constructor' in a && 'constructor' in b)) {
	      return false;
	    }
	    // Add the first object to the stack of traversed objects.
	    aStack.push(a);
	    bStack.push(b);
	    var size = 0, result = true;
	    // Recursively compare objects and arrays.
	    if (className == '[object Array]') {
	      // Compare array lengths to determine if a deep comparison is necessary.
	      size = a.length;
	      result = size == b.length;
	      if (result) {
	        // Deep compare the contents, ignoring non-numeric properties.
	        while (size--) {
	          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
	        }
	      }
	    } else {
	      // Deep compare objects.
	      for (var key in a) {
	        if (_.has(a, key)) {
	          // Count the expected number of properties.
	          size++;
	          // Deep compare each member.
	          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
	        }
	      }
	      // Ensure that both objects contain the same number of properties.
	      if (result) {
	        for (key in b) {
	          if (_.has(b, key) && !(size--)) break;
	        }
	        result = !size;
	      }
	    }
	    // Remove the first object from the stack of traversed objects.
	    aStack.pop();
	    bStack.pop();
	    return result;
	  };
	
	  // Perform a deep comparison to check if two objects are equal.
	  _.isEqual = function(a, b) {
	    return eq(a, b, [], []);
	  };
	
	  // Is a given array, string, or object empty?
	  // An "empty" object has no enumerable own-properties.
	  _.isEmpty = function(obj) {
	    if (obj == null) return true;
	    if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;
	    for (var key in obj) if (_.has(obj, key)) return false;
	    return true;
	  };
	
	  // Is a given value a DOM element?
	  _.isElement = function(obj) {
	    return !!(obj && obj.nodeType === 1);
	  };
	
	  // Is a given value an array?
	  // Delegates to ECMA5's native Array.isArray
	  _.isArray = nativeIsArray || function(obj) {
	    return toString.call(obj) == '[object Array]';
	  };
	
	  // Is a given variable an object?
	  _.isObject = function(obj) {
	    return obj === Object(obj);
	  };
	
	  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
	  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
	    _['is' + name] = function(obj) {
	      return toString.call(obj) == '[object ' + name + ']';
	    };
	  });
	
	  // Define a fallback version of the method in browsers (ahem, IE), where
	  // there isn't any inspectable "Arguments" type.
	  if (!_.isArguments(arguments)) {
	    _.isArguments = function(obj) {
	      return !!(obj && _.has(obj, 'callee'));
	    };
	  }
	
	  // Optimize `isFunction` if appropriate.
	  if (true) {
	    _.isFunction = function(obj) {
	      return typeof obj === 'function';
	    };
	  }
	
	  // Is a given object a finite number?
	  _.isFinite = function(obj) {
	    return isFinite(obj) && !isNaN(parseFloat(obj));
	  };
	
	  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
	  _.isNaN = function(obj) {
	    return _.isNumber(obj) && obj != +obj;
	  };
	
	  // Is a given value a boolean?
	  _.isBoolean = function(obj) {
	    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
	  };
	
	  // Is a given value equal to null?
	  _.isNull = function(obj) {
	    return obj === null;
	  };
	
	  // Is a given variable undefined?
	  _.isUndefined = function(obj) {
	    return obj === void 0;
	  };
	
	  // Shortcut function for checking if an object has a given property directly
	  // on itself (in other words, not on a prototype).
	  _.has = function(obj, key) {
	    return hasOwnProperty.call(obj, key);
	  };
	
	  // Utility Functions
	  // -----------------
	
	  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
	  // previous owner. Returns a reference to the Underscore object.
	  _.noConflict = function() {
	    root._ = previousUnderscore;
	    return this;
	  };
	
	  // Keep the identity function around for default iterators.
	  _.identity = function(value) {
	    return value;
	  };
	
	  _.constant = function(value) {
	    return function() {
	      return value;
	    };
	  };
	
	  _.noop = function(){};
	
	  _.property = function(key) {
	    return function(obj) {
	      return obj[key];
	    };
	  };
	
	  // Returns a predicate for checking whether an object has a given set of `key:value` pairs.
	  _.matches = function(attrs) {
	    return function(obj) {
	      if (obj == null) return _.isEmpty(attrs);
	      if (obj === attrs) return true;
	      for (var key in attrs) if (attrs[key] !== obj[key]) return false;
	      return true;
	    }
	  };
	
	  // Run a function **n** times.
	  _.times = function(n, iterator, context) {
	    var accum = Array(Math.max(0, n));
	    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
	    return accum;
	  };
	
	  // Return a random integer between min and max (inclusive).
	  _.random = function(min, max) {
	    if (max == null) {
	      max = min;
	      min = 0;
	    }
	    return min + Math.floor(Math.random() * (max - min + 1));
	  };
	
	  // A (possibly faster) way to get the current timestamp as an integer.
	  _.now = Date.now || function() { return new Date().getTime(); };
	
	  // List of HTML entities for escaping.
	  var entityMap = {
	    escape: {
	      '&': '&amp;',
	      '<': '&lt;',
	      '>': '&gt;',
	      '"': '&quot;',
	      "'": '&#x27;'
	    }
	  };
	  entityMap.unescape = _.invert(entityMap.escape);
	
	  // Regexes containing the keys and values listed immediately above.
	  var entityRegexes = {
	    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
	    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
	  };
	
	  // Functions for escaping and unescaping strings to/from HTML interpolation.
	  _.each(['escape', 'unescape'], function(method) {
	    _[method] = function(string) {
	      if (string == null) return '';
	      return ('' + string).replace(entityRegexes[method], function(match) {
	        return entityMap[method][match];
	      });
	    };
	  });
	
	  // If the value of the named `property` is a function then invoke it with the
	  // `object` as context; otherwise, return it.
	  _.result = function(object, property) {
	    if (object == null) return void 0;
	    var value = object[property];
	    return _.isFunction(value) ? object[property]() : value;
	  };
	
	  // Add your own custom functions to the Underscore object.
	  _.mixin = function(obj) {
	    _.each(_.functions(obj), function(name) {
	      var func = _[name] = obj[name];
	      _.prototype[name] = function() {
	        var args = [this._wrapped];
	        push.apply(args, arguments);
	        return result.call(this, func.apply(_, args));
	      };
	    });
	  };
	
	  // Generate a unique integer id (unique within the entire client session).
	  // Useful for temporary DOM ids.
	  var idCounter = 0;
	  _.uniqueId = function(prefix) {
	    var id = ++idCounter + '';
	    return prefix ? prefix + id : id;
	  };
	
	  // By default, Underscore uses ERB-style template delimiters, change the
	  // following template settings to use alternative delimiters.
	  _.templateSettings = {
	    evaluate    : /<%([\s\S]+?)%>/g,
	    interpolate : /<%=([\s\S]+?)%>/g,
	    escape      : /<%-([\s\S]+?)%>/g
	  };
	
	  // When customizing `templateSettings`, if you don't want to define an
	  // interpolation, evaluation or escaping regex, we need one that is
	  // guaranteed not to match.
	  var noMatch = /(.)^/;
	
	  // Certain characters need to be escaped so that they can be put into a
	  // string literal.
	  var escapes = {
	    "'":      "'",
	    '\\':     '\\',
	    '\r':     'r',
	    '\n':     'n',
	    '\u2028': 'u2028',
	    '\u2029': 'u2029'
	  };
	
	  var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
	
	  var escapeChar = function(match) {
	    return '\\' + escapes[match];
	  };
	
	  // JavaScript micro-templating, similar to John Resig's implementation.
	  // Underscore templating handles arbitrary delimiters, preserves whitespace,
	  // and correctly escapes quotes within interpolated code.
	  _.template = function(text, data, settings) {
	    settings = _.defaults({}, settings, _.templateSettings);
	
	    // Combine delimiters into one regular expression via alternation.
	    var matcher = new RegExp([
	      (settings.escape || noMatch).source,
	      (settings.interpolate || noMatch).source,
	      (settings.evaluate || noMatch).source
	    ].join('|') + '|$', 'g');
	
	    // Compile the template source, escaping string literals appropriately.
	    var index = 0;
	    var source = "__p+='";
	    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
	      source += text.slice(index, offset).replace(escaper, escapeChar);
	      index = offset + match.length;
	
	      if (escape) {
	        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
	      } else if (interpolate) {
	        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
	      } else if (evaluate) {
	        source += "';\n" + evaluate + "\n__p+='";
	      }
	
	      // Adobe VMs need the match returned to produce the correct offest.
	      return match;
	    });
	    source += "';\n";
	
	    // If a variable is not specified, place data values in local scope.
	    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
	
	    source = "var __t,__p='',__j=Array.prototype.join," +
	      "print=function(){__p+=__j.call(arguments,'');};\n" +
	      source + "return __p;\n";
	
	    try {
	      var render = new Function(settings.variable || 'obj', '_', source);
	    } catch (e) {
	      e.source = source;
	      throw e;
	    }
	
	    if (data) return render(data, _);
	    var template = function(data) {
	      return render.call(this, data, _);
	    };
	
	    // Provide the compiled source as a convenience for precompilation.
	    var argument = settings.variable || 'obj';
	    template.source = 'function(' + argument + '){\n' + source + '}';
	
	    return template;
	  };
	
	  // Add a "chain" function, which will delegate to the wrapper.
	  _.chain = function(obj) {
	    return _(obj).chain();
	  };
	
	  // OOP
	  // ---------------
	  // If Underscore is called as a function, it returns a wrapped object that
	  // can be used OO-style. This wrapper holds altered versions of all the
	  // underscore functions. Wrapped objects may be chained.
	
	  // Helper function to continue chaining intermediate results.
	  var result = function(obj) {
	    return this._chain ? _(obj).chain() : obj;
	  };
	
	  // Add all of the Underscore functions to the wrapper object.
	  _.mixin(_);
	
	  // Add all mutator Array functions to the wrapper.
	  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
	    var method = ArrayProto[name];
	    _.prototype[name] = function() {
	      var obj = this._wrapped;
	      method.apply(obj, arguments);
	      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
	      return result.call(this, obj);
	    };
	  });
	
	  // Add all accessor Array functions to the wrapper.
	  _.each(['concat', 'join', 'slice'], function(name) {
	    var method = ArrayProto[name];
	    _.prototype[name] = function() {
	      return result.call(this, method.apply(this._wrapped, arguments));
	    };
	  });
	
	  _.extend(_.prototype, {
	
	    // Start chaining a wrapped Underscore object.
	    chain: function() {
	      this._chain = true;
	      return this;
	    },
	
	    // Extracts the result from a wrapped and chained object.
	    value: function() {
	      return this._wrapped;
	    }
	
	  });
	
	  // AMD registration happens at the end for compatibility with AMD loaders
	  // that may not enforce next-turn semantics on modules. Even though general
	  // practice for AMD registration is to be anonymous, underscore registers
	  // as a named module because, like jQuery, it is a base library that is
	  // popular enough to be bundled in a third party lib, but not be part of
	  // an AMD load request. Those cases could generate an error when an
	  // anonymous define() is called outside of a loader request.
	  if (true) {
	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
	      return _;
	    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  }
	}).call(this);


/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(70), "");
	exports.i(__webpack_require__(25), "");
	exports.i(__webpack_require__(79), "");
	exports.i(__webpack_require__(26), "");
	exports.i(__webpack_require__(82), "");
	exports.i(__webpack_require__(84), "");
	exports.i(__webpack_require__(85), "");
	exports.i(__webpack_require__(28), "");
	exports.i(__webpack_require__(90), "");
	exports.i(__webpack_require__(91), "");
	exports.i(__webpack_require__(92), "");
	exports.i(__webpack_require__(29), "");
	exports.i(__webpack_require__(83), "");
	exports.i(__webpack_require__(86), "");
	
	// module
	exports.push([module.id, "\n", ""]);
	
	// exports


/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.box 样式模块 */\n\n.ui-box {\n    border: 1px solid #ccc;\n    zoom: 1;\n    font-size: 12px;\n    margin: 0;\n    padding: 0;\n    border-bottom: none;\n}\n\n.ui-box: after {\n    clear: both;\n    content: \" \";\n    display: block;\n    font-size: 0;\n    height: 0;\n    visibility: hidden;\n}\n\n.ui-box-follow /*--使用在box和上面的box相连的情况下 --*/ {\n    border-top: none;\n}\n\n.ui-box-head {\n    border-bottom: 1px solid #ccc;\n    position: relative;\n    padding: 10px;\n    height: 16px;\n    line-height: 16px;\n    background: -webkit-gradient(linear, left top, left bottom, from(#fcfcfc), to(#f9f9f9));\n    background: -moz-linear-gradient(top, #fcfcfc, #f9f9f9);\n    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fcfcfc', endColorstr='#f9f9f9');\n    background: -o-linear-gradient(top, #fcfcfc, #f9f9f9);\n    background: linear-gradient(top, #fcfcfc, #f9f9f9);\n    zoom: 1;\n}\n\n\n.ui-box-head .ui-box-head-title {\n    color: #656565;\n    font-size: 14px;\n    font-weight: bold;\n    float: left;\n    display: inline;\n    margin: 0;\n    padding: 0;\n}\n\n.ui-box-head .ui-box-head-more {\n    float: right;\n}\n\n.ui-box-head .ui-box-head-text {\n    margin-left: 10px;\n    color: #808080;\n    float: left;\n}\n\n.ui-box-container {\n    background: #fff;\n    border-bottom: 1px solid #ccc;\n}\n\n.ui-box-content /* 可选，用于默认有内边距的box */ {\n    padding: 10px;\n}\n", ""]);
	
	// exports


/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-dbutton {\n    padding: 0;\n}\n\n.ui-dbutton:active {\n    box-shadow: none;\n}\n\n.ui-dbutton-self,\n.ui-dbutton-arrow {\n    float: left;\n    font-weight: normal;\n    cursor: pointer;\n}\n\n.ui-dbutton-self {\n    border-radius: 2px 0 0 2px;\n}\n\n.ui-dbutton-arrow {\n    border-radius: 0 2px 2px 0; \n}\n\n/* 橙色 */\n\n.ui-dbutton-orange:hover {\n    color: #fff;\n    background-color: #f57403;\n}\n\n.ui-dbutton-orange .ui-dbutton-self:hover,\n.ui-dbutton-orange .ui-dbutton-arrow:hover {\n    background-color: #fb8318;\n}\n\n.ui-dbutton-orange .ui-dbutton-self {\n    border-right: 1px solid #e8720b;\n}\n\n.ui-dbutton-orange .ui-dbutton-arrow {\n    border-left: 1px solid #fd8a27;\n    color: #fff;\n}\n\n/* 大橙色按钮 */\n\n.ui-button-lorange .ui-dbutton-self {\n    padding: 0 12px;\n}\n\n.ui-button-lorange .ui-dbutton-arrow {\n    width: 24px;\n}\n\n/* 中橙色按钮 */\n\n.ui-button-morange .ui-dbutton-self {\n    padding: 0 10px;\n}\n\n.ui-button-morange .ui-dbutton-arrow {\n    width: 20px;\n}\n\n/* 小橙色按钮 */\n\n.ui-button-sorange .ui-dbutton-self {\n    padding: 0 8px;\n}\n\n.ui-button-sorange .ui-dbutton-arrow {\n    width:18px;\n    font-size: 10px;\n}\n\n/* 白色 */\n\n.ui-dbutton-white:hover {\n    background-color: #f3f3f3;\n}\n\n.ui-dbutton-white .ui-dbutton-self:hover,\n.ui-dbutton-white .ui-dbutton-arrow:hover {\n    background-color: #fcfbfb;\n    color: #666;\n}\n\n.ui-dbutton-white .ui-dbutton-self {\n    border-right: 1px solid #cdcdcd;\n}\n\n.ui-dbutton-white .ui-dbutton-arrow {\n    border-left: 1px solid #fff;\n    color: #999;\n}\n\n\n/* 大白色按钮 */\n\n.ui-button-lwhite .ui-dbutton-self {\n    padding: 0 12px;\n}\n\n.ui-button-lwhite .ui-dbutton-arrow {\n    width: 24px;\n}\n\n/* 中白色按钮 */\n\n.ui-button-mwhite .ui-dbutton-self {\n    padding: 0 10px;\n}\n\n.ui-button-mwhite .ui-dbutton-arrow {\n    width: 20px;\n}\n\n/* 小白色按钮 */\n\n.ui-button-swhite .ui-dbutton-self {\n    padding: 0 8px;\n}\n\n.ui-button-swhite .ui-dbutton-arrow {\n    width:18px;\n    font-size: 10px;\n}\n", ""]);
	
	// exports


/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-dropdown {\n    position: relative;\n    display: inline-block;\n    *display: inline;\n    *zoom: 1;\n}\n\n.ui-button-dropdown-large,\n.ui-button-dropdown-middle,\n.ui-button-dropdown-small {\n    border: 1px solid #ddd;\n    border-top: none;\n    border-bottom: none;\n    box-shadow: 0 0 4px #d9d9d9;\n    zoom: 1;\n    position: absolute;\n    left: 0;\n    width: 98%;\n    background: #fff;\n    margin: 0;\n    padding: 0;\n    list-style: none;\n}\n.ui-button-dropdown-large {\n    top: 33px;\n    font-size: 14px;    \n}\n.ui-button-dropdown-middle {\n    top: 29px;\n    font-size: 14px;    \n}\n.ui-button-dropdown-small {\n    top: 25px;\n    font-size: 12px;\n}\n.ui-button-dropdown-item {\n    zoom: 1;\n    border-bottom: 1px solid #E6E6E6;    \n}\n.ui-button-dropdown-item a {\n    padding: 5px 10px;\n    display: block;\n    zoom: 1;\n    color: #08c;\n}\n.ui-button-dropdown-item a:hover {\n    background-color: #DFE9F2;\n    text-decoration:none;\n}\n\n", ""]);
	
	// exports


/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button * {\n    margin:0;\n    padding:0;\n}\n\n.ui-button {\n    display: inline-block;\n    *display: inline;\n    text-align: center;\n    text-decoration: none;\n    vertical-align: middle;\n    cursor: pointer;\n    font-size: 14px;\n    font-family: inherit; /* Correct font family not being inherited in all browsers for <button> <input> */\n    font-weight: bold;\n    border-radius: 2px;\n    padding: 0 20px;\n    *zoom: 1;\n    *overflow: visible; /* for a ie6/7 bug http://blog.csdn.net/jyy_12/article/details/6636099 */    \n    background-image: none; /* for old alice button style conflict */\n}\n\n.ui-button .ui-button-text {\n    background: none;\n    padding: 0;\n    height: auto;\n    line-height: auto;\n}\n\n.ui-button:hover {\n    text-decoration: none;\n    background-image: none; /* for old alice button style conflict */    \n}\n\ninput.ui-button-text, button.ui-button-text {\n    *vertical-align: top; /* for a ie7 bug */\n}\n\n.ui-button:active {\n    position: relative;\n    top: 1px;\n    box-shadow: 1px 1px 3px #999 inset;\n}\n", ""]);
	
	// exports


/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-lblue,\n.ui-button-mblue,\n.ui-button-sblue {\n    color:#fff;\n    border: 1px solid #00aaee;\n    background-color: #00aaee;\n}\n\n.ui-button-lblue:hover,\n.ui-button-mblue:hover,\n.ui-button-sblue:hover {\n    background-color: #00a3d2;\n}\n\na.ui-button-lblue,\na.ui-button-mblue,\na.ui-button-sblue,\na.ui-button-lblue:active,\na.ui-button-mblue:active,\na.ui-button-sblue:active,\na.ui-button-lblue:hover,\na.ui-button-mblue:hover,\na.ui-button-sblue:hover {\n    color:#fff;\n}\n\n.ui-button-lblue {\n    height:32px;\n}\n\n.ui-button-mblue {\n    height:28px;\n}\n\n.ui-button-sblue {\n    padding: 0 12px;\n    height:24px;\n    font-size:12px;\n}\n\na.ui-button-lblue {\n    line-height:30px;\n    height:30px;\n}\n\na.ui-button-mblue {\n    line-height:26px;\n    height:26px;\n}\n\na.ui-button-sblue {\n    line-height:22px;\n    height:22px;\n}\n", ""]);
	
	// exports


/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-ldisable,\n.ui-button-mdisable,\n.ui-button-sdisable {\n    color:#999;    \n    border: none;\n    background: #cacccd;\n    cursor: default;\n}\n\na.ui-button-ldisable,\na.ui-button-mdisable,\na.ui-button-sdisable,\n.ui-button-ldisable:active,\n.ui-button-mdisable:active,\n.ui-button-sdisable:active,\n.ui-button-ldisable:hover,\n.ui-button-mdisable:hover,\n.ui-button-sdisable:hover {\n    color:#999; \n    border: none;\n    background: #cacccd;\n}\n\n.ui-button-ldisable {\n    height:32px;\n}\n\n.ui-button-mdisable {\n    height:28px;\n}\n\n.ui-button-sdisable {\n    height:24px;\n    padding:0 12px;\n    font-size:12px;\n}\n\n.ui-button-ldisable,\n.ui-button-mdisable,\n.ui-button-sdisable {\n    cursor: default!important;\n}\n\n.ui-button-ldisable:active,\n.ui-button-mdisable:active,\n.ui-button-sdisable:active {\n    position: static;\n    top: 0;\n    box-shadow: none;\n}\n", ""]);
	
	// exports


/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-lgreen,\n.ui-button-mgreen,\n.ui-button-sgreen {\n    color: #fff;\n    border:1px solid #379000;\n    background-color: #4BB402;\n}\n\n.ui-button-lgreen:hover,\n.ui-button-mgreen:hover,\n.ui-button-sgreen:hover {\n    background-color: #66BC2A;\n}\n\na.ui-button-lgreen,\na.ui-button-mgreen,\na.ui-button-sgreen,\na.ui-button-lgreen:hover,\na.ui-button-mgreen:hover,\na.ui-button-sgreen:hover,\na.ui-button-lgreen:active,\na.ui-button-mgreen:active,\na.ui-button-sgreen:active {\n    color:#fff;\n}\n\n.ui-button-lgreen {\n    height:32px;\n}\n\n.ui-button-mgreen {\n    height:28px;\n}\n\n.ui-button-sgreen {\n    padding: 0 12px;\n    height:24px;\n    font-size:12px;\n}\n\na.ui-button-lgreen {\n    line-height:30px;\n    height:30px;\n}\n\na.ui-button-mgreen {\n    line-height:26px;\n    height:26px;\n}\n\na.ui-button-sgreen {\n    line-height:22px;\n    height:22px;\n}\n", ""]);
	
	// exports


/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-lorange,\n.ui-button-morange,\n.ui-button-sorange {\n    color: #fff;\n    border:1px solid #d66500;\n    background-color: #f57403;\n}\n\n.ui-button-lorange:hover,\n.ui-button-morange:hover,\n.ui-button-sorange:hover {\n    background-color: #fb8318;\n}\n\na.ui-button-lorange,\na.ui-button-morange,\na.ui-button-sorange,\na.ui-button-lorange:hover,\na.ui-button-morange:hover,\na.ui-button-sorange:hover,\na.ui-button-lorange:active,\na.ui-button-morange:active,\na.ui-button-sorange:active {\n    color:#fff;\n}\n\n.ui-button-lorange {\n    height:32px;\n}\n\n.ui-button-morange {\n    height:28px;\n}\n\n.ui-button-sorange {\n    padding: 0 12px;\n    height:24px;\n    font-size:12px;\n}\n\na.ui-button-lorange {\n    line-height:30px;\n    height:30px;\n}\n\na.ui-button-morange {\n    line-height:26px;\n    height:26px;\n}\n\na.ui-button-sorange {\n    line-height:22px;\n    height:22px;\n}\n", ""]);
	
	// exports


/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-button-lwhite,\n.ui-button-mwhite,\n.ui-button-swhite {\n    border:1px solid #afafaf;\n    background-color: #f3f3f3;\n    color: #777;\n}\n\n.ui-button-lwhite:hover,\n.ui-button-mwhite:hover,\n.ui-button-swhite:hover {\n    border: 1px solid #8e8e8e;\n    background-color: #fcfbfb;\n    color: #676d70;\n}\n\na.ui-button-lwhite,\na.ui-button-mwhite,\na.ui-button-swhite,\na.ui-button-lwhite:active,\na.ui-button-mwhite:active,\na.ui-button-swhite:active {\n    color: #777;\n}\na.ui-button-lwhite:hover,\na.ui-button-mwhite:hover,\na.ui-button-swhite:hover {\n    color:#676d70;\n}\n\n.ui-button-lwhite {\n    height:32px;\n}\n\n.ui-button-mwhite {\n    height:28px;\n}\n\n.ui-button-swhite {\n    height:24px;\n    padding:0 12px;\n    font-size:12px;\n}\n\na.ui-button-lwhite {\n    line-height:30px;\n    height:30px;\n}\n\na.ui-button-mwhite {\n    line-height:26px;\n    height:26px;\n}\n\na.ui-button-swhite {\n    line-height:22px;\n    height:22px;\n}\n", ""]);
	
	// exports


/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(80), "");
	exports.i(__webpack_require__(81), "");
	
	// module
	exports.push([module.id, "/* alice.form 样式模块 */\n\n.ui-form {\n    font-size: 12px;\n    line-height: 1.5;\n}\n\n.ui-form, .ui-form * {\n    list-style: none;\n}\n\n.ui-form fieldset {\n    border:0;\n}\n\n.ui-form legend {\n    display: none;\n}\n\n.ui-form-explain {\n    margin: 0;\n    padding: 8px 0 0;\n    font-size: 12px;\n    color: #B2B2B2;\n}\n\n.ui-form-other {\n    margin-left: 8px;\n}\n\n.ui-form-text {\n    display: inline-block;\n    margin-top: 6px;\n    *display: inline;\n    *zoom: 1;\n}\n\n.ui-form-item:after {\n    clear: both;\n    content: '.';\n    display: block;\n    height: 0;\n    visibility: hidden;\n}\n\n.ui-form-item {\n    padding: 0 5px 20px 170px;\n    zoom: 1;\n}\n\n.ui-form-item select {\n    vertical-align: middle;\n    margin: 4px 0 0;\n}\n\n.ui-form-item input {\n    vertical-align: middle;\n}\n\n.ui-form-item .ui-input {\n    color: #595959;\n    vertical-align: middle;\n    *vertical-align: -5px;\n}\n\n.ui-form-item-error .ui-input,\n.ui-form-item-error .ui-textarea {\n    border: 1px #F00 solid;\n    color: #F00;\n}\n\n.ui-form-item-error .ui-input-reset {\n    border: 1px #9C9C9C solid;\n    color: #000;\n}\n\n.ui-form-item-error .ui-form-explain {\n    color: #FF5243;\n}\n\n.ui-form-large .ui-input {\n    font-size: 14px;\n    height: 18px;\n    line-height: 18px;\n    padding: 11px 10px;\n}\n\n.ui-form-large .ui-label {\n    padding-top: 12px;\n}\n", ""]);
	
	// exports


/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-input {\n    padding: 7px 9px;\n    line-height: 18px;\n    border: 1px solid #c1c1c1;\n    color: #595959;\n    font-size: 12px;\n}\n\n.ui-input:hover,\n.ui-textarea:hover,\n.ui-input-hover {\n    border: 1px #727272 solid;\n    border-top-color: #808080;\n}\n\n.ui-input:focus,\n.ui-textarea:focus,\n.ui-input-focus {\n    border: 1px #07f solid;\n    box-shadow: 0 0 3px #8cddff;\n    color: #595959;\n}\n\n.ui-textarea {\n    line-height: 15px;\n    border: 1px #9C9C9C solid;\n    padding: 1px 3px 0 4px;\n    overflow: auto;\n    font-family: Arial;\n    font-size: 12px;\n}\n\n.ui-input[disabled],\n.ui-textarea[disabled] {\n    border: 1px solid #ccc;\n    background: #f2f2f2;\n}\n\n.ui-input:disabled,\n.ui-textarea:disabled {\n    border: 1px solid #ccc;\n    background: #f2f2f2;\n}\n\n.placeholder {\n    color: #ccc;\n}\n\n.ui-input-checkcode {\n    width: 100px;\n    height: 24px;\n    line-height: 28px;\n    margin: 0;\n    padding: 2px 5px;\n}\n\n.ui-form-item-hover .ui-input,\n.ui-form-item-hover .ui-textarea {\n    border:1px #727272 solid;\n}\n\n.ui-form-item-focus .ui-input,\n.ui-form-item-focus .ui-textarea {\n    border: 1px #07f solid;\n    box-shadow: 0 0 3px #8cddff;\n}\n\n.ui-form-item-focus .ui-form-explain,\n.ui-form-item-hover .ui-form-explain {\n    color:#333;\n}\n\n", ""]);
	
	// exports


/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-label {\n    float: left;\n    width: 170px;\n    margin-left: -180px;\n    padding-top: 5px;\n    text-align: right;\n    font-size: 14px;\n}\n\n.ui-form-required {\n    color: #FF0000;\n    font-family: SimSun;\n    font-size: 14px;\n    margin-right: 6px;\n}\n\ninput.ui-checkbox {\n    vertical-align: baseline;\n}\n\n", ""]);
	
	// exports


/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.list 样式模块 */\n\n.ui-list {\n    margin: 0;\n    padding: 10px;\n    list-style: square inside;\n}\n/* 默认有方角 */\n.ui-list-item {\n    font-size: 9px;\n    line-height: 20px;\n}\n.ui-list-item a {\n    line-height: 20px;\n    text-decoration: none;\n    color: #08c;    \n}\n\n.ui-list-item a,\n.ui-list-item span.ui-list-item-text {\n    font-size: 12px;\n    vertical-align: middle;    \n}\n\n.ui-list-item a:hover {\n    text-decoration: underline;    \n}\n\n/* 灰色小方角 */\n.ui-list-gray .ui-list-item {\n    color: #808080;\n}\n\n/* 灰色小方角＋灰色链接 */\n.ui-list-graylink .ui-list-item {\n    color: #808080;    \n}\n\n.ui-list-graylink .ui-list-item a {\n    color: #666;\n}\n\n/* 没有小图标的 */\n.ui-list-nosquare {\n    list-style: none;    \n}\n\n/* ui-dlist */\n\n.ui-dlist {\n    display: inline-block;\n    color: #808080;\n    font-size: 12px;\n    line-height: 2.2;\n}\n\n.ui-dlist-tit {\n    float: left;\n    width: 20%;/* 默认值, 具体根据视觉可改 */\n    text-align: right;\n    margin: 0;\n}\n\n.ui-dlist-det {\n    float: left;\n    width: 80%;/* 默认值，具体根据视觉可改 */\n    text-align: left;\n    margin: 0;\n}\n\n", ""]);
	
	// exports


/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.loading 样式模块 */\n\n.ui-loading {\n    width: 50px;\n    height: 50px;\n    background-repeat: no-repeat;\n    background-image: url('data:image/gif;base64,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');\n    text-align:center;\n    line-height: 50px;\n    font-size: 11px;\n    color: #777;\n}\n", ""]);
	
	// exports


/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/*! define alice/nav/1.0.0/nav-debug.css */\n.ui-nav{position:relative;}\n.ui-nav a{text-decoration:none;}\n.ui-nav a:hover{text-decoration:none}\n.ui-nav ul,.ui-nav li{list-style-type:none}\n.ui-nav-main{zoom:1;margin:0;padding-left:10px;-webkit-border-radius:2px 2px 0 0;border-radius:2px 2px 0 0;background:-webkit-linear-gradient(top,#F39100,#F17A00);background:-moz-linear-gradient(top,#F39100,#F17A00);background:-ms-linear-gradient(#F39100,#F17A00);background:-o-linear-gradient(#F39100,#F17A00);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#FFF39100, endColorstr=#FFF17A00)}\n.ui-nav-main:before,.ui-nav-main:after{content:\"\";display:table}\n.ui-nav-main:after{clear:both}\n.ui-nav-item{float:left;margin:7px 5px 0 0;}\n.ui-nav-item a{display:inline-block;_display:inline;_zoom:1;height:35px;padding:0 15px;line-height:35px;color:#fff;font-weight:bold;font-size:14px;}\n.ui-nav-item a:hover{color:#fff;background:-webkit-linear-gradient(top,#F49C25,#F49726);background:-moz-linear-gradient(top,#F49C25,#F49726);background:-ms-linear-gradient(#F49C25,#F49726);background:-o-linear-gradient(#F49C25,#F49726);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#FFF49C25, endColorstr=#FFF49726);-webkit-border-radius:2px 2px 0 0;border-radius:2px 2px 0 0}\n.ui-nav-item-current a,.ui-nav-item-current a:hover{background:#fff;filter:none;color:#6d6969;-webkit-border-radius:2px 2px 0 0;border-radius:2px 2px 0 0}\n.ui-nav-submain{display:none;position:absolute;left:10px;top:42px;margin:0;padding:0}\n.ui-nav-subitem{float:left;margin:5px 10px 0 0;}\n.ui-nav-subitem a{display:inline-block;*display:inline;zoom:1;padding:0 15px;height:26px;line-height:26px;background:transparent;color:#868686;font-weight:normal;font-size:12px;-webkit-border-radius:3px;border-radius:3px;}\n.ui-nav-subitem a:hover{height:24px;line-height:24px;padding:0 14px;background:transparent;-webkit-box-shadow:0 -1px 0 #f6f6f6;box-shadow:0 -1px 0 #f6f6f6;border:1px solid #cecece;-webkit-border-radius:3px;border-radius:3px}\n.ui-nav-subitem-current a,.ui-nav-subitem-current a:hover{height:24px;line-height:24px;padding:0 14px;border-left:1px solid #dadada;border-right:1px solid #dadada;border-top:1px solid #bebebe;border-bottom:1px solid transparent;_border-bottom:1px solid #dadada;-webkit-box-shadow:inset 0 1px 0 #dadada;box-shadow:inset 0 1px 0 #dadada;background:#e7e7e7}\n.ui-nav-subcontainer{height:37px;border-left:1px solid #ccc;border-right:1px solid #ccc;border-bottom:1px solid #ccc;background:-webkit-linear-gradient(top,#FEFEFE,#F7F7F7);background:-moz-linear-gradient(top,#FEFEFE,#F7F7F7);background:-ms-linear-gradient(#FEFEFE,#F7F7F7);background:-o-linear-gradient(#FEFEFE,#F7F7F7);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#FFFEFEFE, endColorstr=#FFF7F7F7)}\n.ui-nav-item-current .ui-nav-submain{display:block}\n.ui-nav-nosub .ui-nav-subcontainer,.ui-nav-nosub .ui-nav-subitem{display:none}\n", ""]);
	
	// exports


/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.paging 样式模块 */\n\n@charset \"utf-8\";\n\n.ui-paging, .ui-paging input {\n    color:#808080;\n    margin: 0;\n    padding: 0;\n    zoom: 1;\n    font-size: 12px;\n    vertical-align: middle;\n}\n\n.ui-paging:after {\n    clear: both;\n    content: \" \";\n    display: block;\n    font-size: 0;\n    height: 0;\n    visibility: hidden;\n}\n\n.ui-paging a,\n.ui-paging span.ui-paging-prev,\n.ui-paging span.ui-paging-next {\n    text-decoration:none;\n    color:#808080;\n    margin:0 3px;\n    display: inline-block;\n    *display: inline;\n    *zoom: 1;\n    vertical-align: middle;\n    height:22px;\n    line-height:22px;\n}\n\n.ui-paging-prev,\n.ui-paging-next,\n.ui-paging-goto {\n    background-color: #f6f6f6;\n    padding:0 8px;\n    border: 1px solid #ccc;\n    border-radius: 3px;\n}\n\n.ui-paging-prev:hover,\n.ui-paging-next:hover,\n.ui-paging-goto:hover {\n    border-color: #999;\n    color: #666;\n}\n\n.ui-paging-prev:hover .iconfont,\n.ui-paging-next:hover .iconfont {\n    color: #666;\n}\n\n.ui-paging .ui-paging-prev {\n    margin: 0 3px 0 0;\n}\n\n.ui-paging .iconfont {\n    font-size: 10px;\n    color: #787878;\n}\n\n.ui-paging a.ui-paging-item {\n    background-color:#f3f3f3;\n    font-weight:bold;\n    padding:0 8px;\n    border:none;    \n}\n\n.ui-paging a.ui-paging-current, .ui-paging a.ui-paging-item:hover {\n    color:#fff;\n    background:#ff9c00;\n}\n\na.ui-paging-prev:hover,\na.ui-paging-next:hover {    \n    text-decoration:none;\n    color:#666;\n}\n\n.ui-paging-info {\n    line-height:24px;\n    margin-right:5px;\n    height:24px;\n}\n\n.ui-paging-ellipsis {\n    margin:0 5px;\n    line-height: 16px;\n    font-weight:bold;\n}\n\n.ui-paging-which input {\n    height: 20px;\n    line-height: 20px;\n    padding: 0 6px;\n    width:22px;\n    border:1px solid;\n    border-color:#aaa #d1d1d1 #d1d1d1 #aaa;\n}\n\n.ui-paging-which input:hover {\n    border-color:#999;\n    color:#666;\n}\n\n.ui-paging-bold {\n    font-weight:bold;\n    padding:0 8px;\n}\n\n.ui-paging span.ui-paging-prev,\n.ui-paging span.ui-paging-next,\n.ui-paging span.ui-paging-prev .iconfont,\n.ui-paging span.ui-paging-next .iconfont {    \n    color:#fff;\n    box-shadow:none;\n    background: #d4d4d4;\n    border-color: #d4d4d4;\n    filter: none;\n}\n", ""]);
	
	// exports


/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(27), "");
	exports.i(__webpack_require__(88), "");
	exports.i(__webpack_require__(87), "");
	
	// module
	exports.push([module.id, "\n", ""]);
	
	// exports


/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-ministep {\n    list-style: none;\n    font-size: 12px;\n    font-family: tahoma;\n    line-height: 1.5;\n    margin: 0;\n    padding: 0;\n    color: #b7b7b7;\n}\n\n.ui-ministep-item {\n    position: relative;\n    display: inline-block;\n    *display: inline;\n    *zoom: 1;\n    margin-right: 36px;\n}\n\n.ui-ministep .iconfont {\n    color: #b7b7b7;\n    font-size: 18px;\n}\n\n.ui-ministep .ui-ministep-number {\n    position: absolute;\n    top: 6px;\n    left: 5px;\n    color: #fff;\n    line-height: 12px;\n    font-style: normal;\n}\n\n.ui-ministep .ui-ministep-text {\n    position: relative;\n    top: -2px;\n}\n\n.ui-ministep-active,\n.ui-ministep-active .iconfont {\n    color: #FF6700;    \n}\n", ""]);
	
	// exports


/***/ },
/* 88 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* bug: http://www.aiubug.com/?p=523 */\n\n.ui-step {\n    padding: 0 40px;\n    margin: 0 auto;\n    font-size: 14px;\n    list-style: none;\n    zoom: 1;\n    position: relative;\n    color: #b7b7b7;\n    overflow: hidden;\n}\n\n.ui-step:after {\n    clear: both;\n    content: \" \";\n    display: block;\n    font-size: 0;\n    height: 0;\n    visibility: hidden;\n}\n\n.ui-step li {\n    float: left;\n    height: 54px;\n    margin: 0;\n    width: 50%;\n    position: relative;\n}\n\n.ui-step li .ui-step-icon {\n    height: 50px;\n    position: absolute;\n    top: 0;\n    width: 150px;\n    text-align: center;\n    left: -25px;\n    font-family: tahoma;    \n}\n\n.ui-step-icon .iconfont {\n    font-size: 30px;\n    margin: 0;\n    color: #b7b7b7;\n    color: rgba(0, 0, 0, 0.25);\n    *color: #b7b7b7;    \n    line-height: 30px;\n    background: #fff;\n    padding: 0 10px;\n    position: absolute;\n    top: 0;\n    left: 0;\n    text-shadow: 1px 1px 2px #fff, 0 0 0 #ccc, 1px 1px 2px #fff;\n}\n\n.ui-step-icon .ui-step-number {\n    line-height:14px;\n    font-style:normal;\n    position: absolute;\n    top: 7px;\n    left: 0;\n    padding: 0 20px;\n    font-weight: bold;\n    color: #fff;\n}\n\n.ui-step .ui-step-active i.ui-step-number {\n    color:#FFF;\n}\n\n.ui-step-end .ui-step-number {\n    background: transparent;\n    font-size: 12px;\n    font-style: normal;\n    left: 17px;\n    line-height: 12px;\n    padding: 0;\n    text-shadow: none;\n    top: 9px;\n}\n\n.ui-step-icon .ui-step-text {\n    height: 20px;\n    line-height: 20px;\n    position: relative;\n    text-shadow: 0 1px 0 white;\n    top: 34px;\n    left: -50px;\n}\n\n.ui-step li .ui-step-line {\n    height: 3px;\n    background: #b9b9b9;\n    display: block;\n    margin-top: 14px;\n    line-height: 1;\n    overflow: hidden;\n}\n\n.ui-step li.ui-step-end {\n    position: absolute;\n    top: 0;\n    right: -110px;\n    width: 150px;\n    zoom: 1;\n    _clear: both;   /* 修复ie6下最后一步莫名其妙显示不出来的问题 */\n}\n\n.ui-step li.ui-step-end .ui-step-line {\n    display: none;\n}\n\n/* 步骤长度 */\n\n.ui-step-2 li {\n    width: 100%;\n}\n\n.ui-step-3 li {\n    width: 50%;\n}\n\n.ui-step-4 li {\n    width: 33%;\n}\n\n.ui-step-5 li {\n    width: 25%;\n}\n\n/* 修改颜色 */\n\n.ui-step .ui-step-active {\n    color: #f16f20;\n}\n\n.ui-step .ui-step-active .iconfont {\n    color:#ff7001;\n}\n\n.ui-step .ui-step-done .iconfont {\n    color:#ff9a00;\n}\n\n.ui-step .ui-step-done .ui-step-line {\n    background: #fc9c27;\n}\n\n.ui-step-blue .ui-step-active {\n    color: #3b7cb8;\n}\n.ui-step-blue .ui-step-active .iconfont {\n    color:#1e6bb3;\n}\n.ui-step-blue .ui-step-done .iconfont {\n    color:#428fd6;\n}\n.ui-step-blue .ui-step-done .ui-step-line {\n    background: #418cd6;\n}\n", ""]);
	
	// exports


/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.tab 样式模块 */\n\n@charset \"utf-8\";\n\n.ui-tab {\n    margin: 0;\n    padding: 0;\n}\n\n.ui-tab ul {\n    list-style: none;\n    margin: 0;\n    padding: 0;\n}\n\n.ui-tab li {\n    list-style: none;\n    vertical-align: top;\n    position: relative;\n    top: 1px;\n}\n\n.ui-tab-items {\n    border-bottom: 1px solid #E5E5E5;\n    font-size: 14px;\n}\n\n.ui-tab-item {\n    display: inline-block;\n    display: inline\\0; /* fix https://github.com/aliceui/tab/issues/1 */\n    *display: inline;\n    *zoom: 1;\n    *margin-right: 4px;\n}\n\n.ui-tab-item a {\n    border-radius: 3px 3px 0 0;\n    background: #fff;\n    line-height: 32px;\n    height: 32px;\n    padding: 0 10px;\n    border: 1px solid #E5E5E5;\n    border-bottom: none;\n    color: #4D4D4D;\n    display: inline-block;\n    *display: inline;\n    *zoom: 1;\n    transition: background-color 0.4s ease-out, color 0.4s ease-out;\n}\n\n.ui-tab-item a,\n.ui-tab-item a:hover,\n.ui-tab-item a:active {\n    color: #4D4D4D;\n}\n\n.ui-tab-item-current a {\n    font-weight: bold;\n    height: 33px;\n}\n\n.ui-tab-item a:hover {\n    background: #f6f6f6;\n    text-decoration: none;\n}\n\n.ui-tab-item-current a:hover {\n    background: #fff;\n}\n", ""]);
	
	// exports


/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice/table 样式模块 */\n.ui-table {\n    border-collapse:collapse;\n    border:1px solid #ccc;\n    width:100%;\n    font-size: 12px;\n    text-align: left;\n}\n\n.ui-table-layout-fixed {\n    table-layout:fixed;\n}\n\n.ui-table tr:nth-child(even),\n.ui-table-split, /* 隔行换色效果 */\n.ui-table-hover /* 用作表格行hover效果 */ {\n    background-color:#FBFBFB;\n}\n\n.ui-table tr {\n    color:#808080;\n}\n\n.ui-table thead tr {\n    color:#666;\n}\n\n.ui-table thead {\n    color:#666;\n    background-color: #F6F6F6;\n    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#F8F8F8', endColorstr='#F2F2F2');\n    background: -webkit-gradient(linear, left top, left bottom, from(#F8F8F8), to(#F2F2F2));\n    background: -moz-linear-gradient(top, #F8F8F8, #F2F2F2);\n    background: -o-linear-gradient(top, #F8F8F8, #F2F2F2);\n    background: linear-gradient(top, #F8F8F8, #F2F2F2);\n}\n\n.ui-table th {\n    padding:7px 9px;\n    border-bottom:1px solid #d9d9d9;\n    text-align: left;\n}\n\n.ui-table td {\n    padding:8px 9px 7px;\n    border-bottom:1px solid #d9d9d9;\n}\n\n.ui-table th {\n    padding:7px 9px;\n}\n\n.ui-table tfoot td {\n    border-bottom:none;\n}\n\n/* 无边框table加上ui-table-noborder */\n.ui-table-noborder, .ui-table-noborder td, .ui-table-noborder tr, .ui-table-noborder th {\n    border:none;\n    outline:none;\n}\n\n.ui-table-noborder .ui-table-split, .ui-table-noborder .ui-table-hover {\n    background-color:#f7f7f7;\n}\n\n/* 当table放在一个有边框的容器中时，比如ui-box，需要添加类名ui-table-inbox去掉本身的外框 */\n.ui-table-inbox {\n    border:none;\n    outline:none;\n}\n", ""]);
	
	// exports


/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.tipbox 样式模块 */\n\n.ui-tipbox {\n    position: relative;\n    zoom: 1;\n    font-size: 12px;\n    line-height: 22px;\n}\n\n.ui-tipbox .ui-tipbox-icon {\n    background: #fff;\n    width: 20px;\n    height: 20px;\n    position: absolute;\n    top: 22px;\n    left: 48px;\n}\n\n.ui-tipbox-icon .iconfont {\n    font-size: 36px;\n    position: absolute;\n    top: -7px;\n    left: -7px;\n    width: 32px;\n    height: 32px;\n    line-height: 36px;\n    text-shadow: 0 1px 0 #fff;\n}\n\n.ui-tipbox-message {\n    border: 1px solid #b2e2ea;\n    background: #e5f2f8;\n}\n\n.ui-tipbox-message .ui-tipbox-icon .iconfont {\n    color: #68b5e2;\n}\n\n.ui-tipbox-success {\n    border: 1px solid #E1E1CA;\n    background: #edfed0;\n}\n\n.ui-tipbox-success .ui-tipbox-icon .iconfont {\n    color: #b5de70;\n}\n\n.ui-tipbox-error {\n    background: #FDEEE9;\n    border: 1px solid #fadcd3;\n}\n\n.ui-tipbox-error .ui-tipbox-icon .iconfont {\n    color: #f17975;\n}\n\n.ui-tipbox-warning {\n    background: #fefea4;\n    border: 1px solid #e6e098;\n}\n\n.ui-tipbox-warning .ui-tipbox-icon .iconfont {\n    color: #ff9966;\n}\n\n.ui-tipbox-question {\n    border: 1px solid #b2e2ea;\n    background: #e0f4ff;\n}\n\n.ui-tipbox-question .ui-tipbox-icon .iconfont {\n    color: #66cae2;\n}\n\n.ui-tipbox-stop {\n    background: #FDEEE9;\n    border: 1px solid #fadcd3;\n}\n\n.ui-tipbox-stop .ui-tipbox-icon .iconfont {\n    color: #f17975;\n}\n\n.ui-tipbox-wait {\n    border: 1px solid #fae3cc;\n    background: #FFF9D9;\n}\n\n.ui-tipbox-wait .ui-tipbox-icon .iconfont {\n    color: #d1a066;\n}\n\n.ui-tipbox-content {\n    margin: 14px 0 14px 87px;\n}\n\n.ui-tipbox-content .ui-tipbox-title {\n    margin: 0;\n    padding: 0;\n}\n\n.ui-tipbox-content h3.ui-tipbox-title,\n.ui-tipbox-content-simple h3.ui-tipbox-title {\n    color: #333;\n    font-size: 14px;\n    font-weight: bold;\n}\n\n.ui-tipbox-content-simple {\n    margin: 22px 0 22px 88px;\n}\n\n.ui-tipbox-explain {\n    margin: 0;\n    padding: 0;\n    color: #808080;\n}\n\n.ui-tipbox-white  {\n    background: #fff;\n    border: 1px solid transparent;\n    _border-color:tomato;   /* fix ie6 dont support border transparent */\n    _filter:chroma(color=tomato);\n}\n", ""]);
	
	// exports


/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, "/* alice.tiptext 样式模块 */\n\n.ui-tiptext {\n    margin: 0;\n    color: #4D4D4D;\n    position:relative;\n    font-size: 12px;\n    zoom:1;\n}\n\n.ui-tiptext-follow {\n    padding-left: 21px;\n}\n\n.ui-tiptext-container {\n    padding: 8px 12px;\n    position:relative;\n    zoom:1;\n}\n.ui-tiptext .iconfont {\n    font-size: 1.33em;\n    line-height: 1em;\n    text-shadow: 0 1px 0 #fff;\n    position: relative;\n    top: 2px;\n    margin-right: 2px;\n}\n.ui-tiptext-icon {\n    display:inline-block;\n    *display:inline;\n    *zoom:1;\n}\n.ui-tiptext-message .ui-tiptext-icon {\n    color: #68b5e2;\n}\n.ui-tiptext-container-message {\n    border: 1px solid #b2e2ea;\n    background: #e5f2f8;\n}\n.ui-tiptext-success .ui-tiptext-icon {\n    color: #b5de70;\n}\n.ui-tiptext-container-success {\n    background: #E7FFCE;\n    border: 1px solid #B9E2A0;\n}\n.ui-tiptext-error .ui-tiptext-icon {\n    color: #f17975;\n}\n.ui-tiptext-container-error {\n    background: #FDEEE9;\n    border: 1px solid #fadcd3;\n}\n.ui-tiptext-warning .ui-tiptext-icon {\n    color: #ff9966;    \n}\n.ui-tiptext-container-warning {\n    background: #fefea4;\n    border: 1px solid #e6e098;\n}\n.ui-tiptext-question .ui-tiptext-icon {\n    color: #66cae2;    \n}\n.ui-tiptext-container-question {\n    border: 1px solid #b2e2ea;\n    background: #e0f4ff;\n}\n.ui-tiptext-stop .ui-tiptext-icon {\n    color: #f17975;\n}\n.ui-tiptext-container-stop {\n    background: #FDEEE9;\n    border: 1px solid #fadcd3;\n}\n.ui-tiptext-wait .ui-tiptext-icon {\n    color: #d1a066;\n}\n.ui-tiptext-container-wait{\n    border: 1px solid #fae3cc;\n    background: #FFF9D9;\n}\n\n/* arrow */\n.ui-tiptext-arrowup, .ui-tiptext-arrowup em, .ui-tiptext-arrowup span,\n.ui-tiptext-arrowleft, .ui-tiptext-arrowleft em, .ui-tiptext-arrowleft span,\n.ui-tiptext-arrowdown, .ui-tiptext-arrowdown em, .ui-tiptext-arrowdown span {\n    position: absolute;\n    font-size: 14px;  \n    font-family: \"SimSun\";\n    font-style: normal;\n    line-height: 1;\n}\n\n.ui-tiptext-arrowup, .ui-tiptext-arrowleft, .ui-tiptext-arrowdown {\n    height: 10px;\n    width: 16px;\n}\n\n.ui-tiptext-arrowup {\n    left: 32px;\n    top:-7px;\n}\n.ui-tiptext-arrowup em {\n    top: -1px;\n}\n\n.ui-tiptext-arrowleft {\n    left: -6px;\n    top:10px;\n}\n.ui-tiptext-arrowleft em {\n    left:-1px;\n}\n\n.ui-tiptext-arrowdown {\n    left: 32px;\n    bottom: -3px;\n}\n\n.ui-tiptext-arrowdown em {\n    top: 1px;\n}\n\n/* arrow color*/\n.ui-tiptext-container-message .ui-tiptext-arrow em {\n    color:#b2e2ea;\n}\n.ui-tiptext-container-message .ui-tiptext-arrow span {\n    color:#e5f2f8;\n}\n.ui-tiptext-container-success .ui-tiptext-arrow em {\n    color:#E1E1CA;\n}\n.ui-tiptext-container-success .ui-tiptext-arrow span {\n    color:#edfed0;\n}\n.ui-tiptext-container-error .ui-tiptext-arrow em {\n    color:#fadcd3;\n}\n.ui-tiptext-container-error .ui-tiptext-arrow span {\n    color:#FDEEE9;\n}\n.ui-tiptext-container-warning .ui-tiptext-arrow em {\n    color:#e6e098;\n}\n.ui-tiptext-container-warning .ui-tiptext-arrow span {\n    color:#fefea4;\n}\n.ui-tiptext-container-question .ui-tiptext-arrow em {\n    color:#b2e2ea;\n}\n.ui-tiptext-container-question .ui-tiptext-arrow span {\n    color:#e0f4ff;\n}\n.ui-tiptext-container-stop .ui-tiptext-arrow em {\n    color:#fadcd3;\n}\n.ui-tiptext-container-stop .ui-tiptext-arrow span {\n    color:#FDEEE9;\n}\n.ui-tiptext-container-wait .ui-tiptext-arrow em {\n    color:#fae3cc;\n}\n.ui-tiptext-container-wait .ui-tiptext-arrow span {\n    color:#FFF9D9;\n}\n\n.ui-tiptext-close {\n    position: absolute;\n    right: 10px;\n    top: 8px;\n    color: #60A2C5;\n    cursor: pointer;\n}\n", ""]);
	
	// exports


/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	
	
	// module
	exports.push([module.id, ".ui-dialog {\n    background-color: rgba(0, 0, 0, 0.5);\n    border: none;\n    FILTER: progid:DXImageTransform.Microsoft.Gradient(startColorstr=#88000000, endColorstr=#88000000);\n    padding: 6px;\n    outline: none;\n    /* http://ued.taobao.com/blog/2011/04/onfocus-this-blur/ */\n}\n\n.ui-dialog-content {\n    background: #fff;\n}\n\n:root .ui-dialog {\n    FILTER: none\\9;\n}\n\n.ui-dialog-close {\n    color: #999;\n    cursor: pointer;\n    display: block;\n    font-family: tahoma;\n    font-size: 24px;\n    font-weight: bold;\n    height: 18px;\n    line-height: 14px;\n    position: absolute;\n    right: 16px;\n    text-decoration: none;\n    top: 16px;\n    z-index: 10;\n}\n.ui-dialog-close:hover {\n    color: #666;\n    text-shadow: 0 0 2px #aaa;\n}\n\n.ui-dialog-title {\n    height:45px;\n    font-size:16px;\n    font-family:'\\5FAE\\8F6F\\96C5\\9ED1', '\\9ED1\\4F53', Arial;\n    line-height:46px;\n    border-bottom:1px solid #E1E1E1;\n    color:#4d4d4d;\n    text-indent: 20px;\n    background-color: #f9f9f9;\n    background: -webkit-gradient(linear, left top, left bottom, from(#fcfcfc), to(#f9f9f9));\n    background: -moz-linear-gradient(top, #fcfcfc, #f9f9f9);\n    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fcfcfc', endColorstr='#f9f9f9');\n    background:-o-linear-gradient(top, #fcfcfc, #f9f9f9);\n    background: -ms-linear-gradient(top, #fcfcfc, #f9f9f9);\n    background: linear-gradient(top, #fcfcfc, #f9f9f9);\n}\n\n.ui-dialog-container {\n    padding:15px 20px 20px;\n    font-size: 12px;\n}\n\n.ui-dialog-message {\n    margin-bottom:15px;\n}\n\n.ui-dialog-operation {\n    zoom:1;\n}\n\n.ui-dialog-confirm, .ui-dialog-cancel {\n    display: inline;\n}\n\n.ui-dialog-operation .ui-dialog-confirm {\n    margin-right: 4px;\n}\n\n.ui-dialog-button-orange,\n.ui-dialog-button-white {\n    display: inline-block;\n    *display: inline;\n    *zoom: 1;\n    text-align: center;\n    text-decoration: none;\n    vertical-align: middle;\n    cursor: pointer;\n    font-size: 12px;\n    font-weight: bold;\n    border-radius: 2px;\n    padding: 0 12px;\n    line-height:24px;\n    height:23px;\n    *overflow: visible; /* for a ie6/7 bug http://blog.csdn.net/jyy_12/article/details/6636099 */ \n    background-image: none;\n}\n\na.ui-dialog-button-orange:hover,\na.ui-dialog-button-white:hover {\n    text-decoration: none;\n}\n\n.ui-dialog-button-orange {\n    color: #fff;\n    border:1px solid #d66500;\n    background-color: #f57403;\n}\n\n.ui-dialog-button-orange:hover {\n    background-color: #fb8318;\n}\n\n.ui-dialog-button-white {\n    border:1px solid #afafaf;\n    background-color: #f3f3f3;\n    color: #777;\n}\n\n.ui-dialog-button-white:hover {\n    border: 1px solid #8e8e8e;\n    background-color: #fcfbfb;\n    color: #676d70;\n}\n", ""]);
	
	// exports


/***/ },
/* 94 */
/***/ function(module, exports, __webpack_require__) {

	exports = module.exports = __webpack_require__(1)();
	// imports
	exports.i(__webpack_require__(28), "");
	
	// module
	exports.push([module.id, ".ui-poptip {\n    top: 0;\n    left: 0;\n}\n", ""]);
	
	// exports


/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// istanbul ignore next
	
	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
	
	var _handlebarsBase = __webpack_require__(30);
	
	var base = _interopRequireWildcard(_handlebarsBase);
	
	// Each of these augment the Handlebars object. No need to setup here.
	// (This is done to easily share code between commonjs and browse envs)
	
	var _handlebarsSafeString = __webpack_require__(109);
	
	var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString);
	
	var _handlebarsException = __webpack_require__(8);
	
	var _handlebarsException2 = _interopRequireDefault(_handlebarsException);
	
	var _handlebarsUtils = __webpack_require__(3);
	
	var Utils = _interopRequireWildcard(_handlebarsUtils);
	
	var _handlebarsRuntime = __webpack_require__(108);
	
	var runtime = _interopRequireWildcard(_handlebarsRuntime);
	
	var _handlebarsNoConflict = __webpack_require__(107);
	
	var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict);
	
	// For compatibility and usage outside of module systems, make the Handlebars object a namespace
	function create() {
	  var hb = new base.HandlebarsEnvironment();
	
	  Utils.extend(hb, base);
	  hb.SafeString = _handlebarsSafeString2['default'];
	  hb.Exception = _handlebarsException2['default'];
	  hb.Utils = Utils;
	  hb.escapeExpression = Utils.escapeExpression;
	
	  hb.VM = runtime;
	  hb.template = function (spec) {
	    return runtime.template(spec, hb);
	  };
	
	  return hb;
	}
	
	var inst = create();
	inst.create = create;
	
	_handlebarsNoConflict2['default'](inst);
	
	inst['default'] = inst;
	
	exports['default'] = inst;
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.registerDefaultDecorators = registerDefaultDecorators;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _decoratorsInline = __webpack_require__(97);
	
	var _decoratorsInline2 = _interopRequireDefault(_decoratorsInline);
	
	function registerDefaultDecorators(instance) {
	  _decoratorsInline2['default'](instance);
	}
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Z0NBQTJCLHFCQUFxQjs7OztBQUV6QyxTQUFTLHlCQUF5QixDQUFDLFFBQVEsRUFBRTtBQUNsRCxnQ0FBZSxRQUFRLENBQUMsQ0FBQztDQUMxQiIsImZpbGUiOiJkZWNvcmF0b3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHJlZ2lzdGVySW5saW5lIGZyb20gJy4vZGVjb3JhdG9ycy9pbmxpbmUnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVnaXN0ZXJEZWZhdWx0RGVjb3JhdG9ycyhpbnN0YW5jZSkge1xuICByZWdpc3RlcklubGluZShpbnN0YW5jZSk7XG59XG5cbiJdfQ==


/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _utils = __webpack_require__(3);
	
	exports['default'] = function (instance) {
	  instance.registerDecorator('inline', function (fn, props, container, options) {
	    var ret = fn;
	    if (!props.partials) {
	      props.partials = {};
	      ret = function (context, options) {
	        // Create a new partials stack frame prior to exec.
	        var original = container.partials;
	        container.partials = _utils.extend({}, original, props.partials);
	        var ret = fn(context, options);
	        container.partials = original;
	        return ret;
	      };
	    }
	
	    props.partials[options.args[0]] = options.fn;
	
	    return ret;
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2RlY29yYXRvcnMvaW5saW5lLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQXFCLFVBQVU7O3FCQUVoQixVQUFTLFFBQVEsRUFBRTtBQUNoQyxVQUFRLENBQUMsaUJBQWlCLENBQUMsUUFBUSxFQUFFLFVBQVMsRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFO0FBQzNFLFFBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQztBQUNiLFFBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFO0FBQ25CLFdBQUssQ0FBQyxRQUFRLEdBQUcsRUFBRSxDQUFDO0FBQ3BCLFNBQUcsR0FBRyxVQUFTLE9BQU8sRUFBRSxPQUFPLEVBQUU7O0FBRS9CLFlBQUksUUFBUSxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQUM7QUFDbEMsaUJBQVMsQ0FBQyxRQUFRLEdBQUcsY0FBTyxFQUFFLEVBQUUsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUMxRCxZQUFJLEdBQUcsR0FBRyxFQUFFLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQy9CLGlCQUFTLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztBQUM5QixlQUFPLEdBQUcsQ0FBQztPQUNaLENBQUM7S0FDSDs7QUFFRCxTQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsRUFBRSxDQUFDOztBQUU3QyxXQUFPLEdBQUcsQ0FBQztHQUNaLENBQUMsQ0FBQztDQUNKIiwiZmlsZSI6ImlubGluZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZXh0ZW5kfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uKGluc3RhbmNlKSB7XG4gIGluc3RhbmNlLnJlZ2lzdGVyRGVjb3JhdG9yKCdpbmxpbmUnLCBmdW5jdGlvbihmbiwgcHJvcHMsIGNvbnRhaW5lciwgb3B0aW9ucykge1xuICAgIGxldCByZXQgPSBmbjtcbiAgICBpZiAoIXByb3BzLnBhcnRpYWxzKSB7XG4gICAgICBwcm9wcy5wYXJ0aWFscyA9IHt9O1xuICAgICAgcmV0ID0gZnVuY3Rpb24oY29udGV4dCwgb3B0aW9ucykge1xuICAgICAgICAvLyBDcmVhdGUgYSBuZXcgcGFydGlhbHMgc3RhY2sgZnJhbWUgcHJpb3IgdG8gZXhlYy5cbiAgICAgICAgbGV0IG9yaWdpbmFsID0gY29udGFpbmVyLnBhcnRpYWxzO1xuICAgICAgICBjb250YWluZXIucGFydGlhbHMgPSBleHRlbmQoe30sIG9yaWdpbmFsLCBwcm9wcy5wYXJ0aWFscyk7XG4gICAgICAgIGxldCByZXQgPSBmbihjb250ZXh0LCBvcHRpb25zKTtcbiAgICAgICAgY29udGFpbmVyLnBhcnRpYWxzID0gb3JpZ2luYWw7XG4gICAgICAgIHJldHVybiByZXQ7XG4gICAgICB9O1xuICAgIH1cblxuICAgIHByb3BzLnBhcnRpYWxzW29wdGlvbnMuYXJnc1swXV0gPSBvcHRpb25zLmZuO1xuXG4gICAgcmV0dXJuIHJldDtcbiAgfSk7XG59XG4iXX0=


/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.registerDefaultHelpers = registerDefaultHelpers;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _helpersBlockHelperMissing = __webpack_require__(99);
	
	var _helpersBlockHelperMissing2 = _interopRequireDefault(_helpersBlockHelperMissing);
	
	var _helpersEach = __webpack_require__(100);
	
	var _helpersEach2 = _interopRequireDefault(_helpersEach);
	
	var _helpersHelperMissing = __webpack_require__(101);
	
	var _helpersHelperMissing2 = _interopRequireDefault(_helpersHelperMissing);
	
	var _helpersIf = __webpack_require__(102);
	
	var _helpersIf2 = _interopRequireDefault(_helpersIf);
	
	var _helpersLog = __webpack_require__(103);
	
	var _helpersLog2 = _interopRequireDefault(_helpersLog);
	
	var _helpersLookup = __webpack_require__(104);
	
	var _helpersLookup2 = _interopRequireDefault(_helpersLookup);
	
	var _helpersWith = __webpack_require__(105);
	
	var _helpersWith2 = _interopRequireDefault(_helpersWith);
	
	function registerDefaultHelpers(instance) {
	  _helpersBlockHelperMissing2['default'](instance);
	  _helpersEach2['default'](instance);
	  _helpersHelperMissing2['default'](instance);
	  _helpersIf2['default'](instance);
	  _helpersLog2['default'](instance);
	  _helpersLookup2['default'](instance);
	  _helpersWith2['default'](instance);
	}
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7eUNBQXVDLGdDQUFnQzs7OzsyQkFDOUMsZ0JBQWdCOzs7O29DQUNQLDBCQUEwQjs7Ozt5QkFDckMsY0FBYzs7OzswQkFDYixlQUFlOzs7OzZCQUNaLGtCQUFrQjs7OzsyQkFDcEIsZ0JBQWdCOzs7O0FBRWxDLFNBQVMsc0JBQXNCLENBQUMsUUFBUSxFQUFFO0FBQy9DLHlDQUEyQixRQUFRLENBQUMsQ0FBQztBQUNyQywyQkFBYSxRQUFRLENBQUMsQ0FBQztBQUN2QixvQ0FBc0IsUUFBUSxDQUFDLENBQUM7QUFDaEMseUJBQVcsUUFBUSxDQUFDLENBQUM7QUFDckIsMEJBQVksUUFBUSxDQUFDLENBQUM7QUFDdEIsNkJBQWUsUUFBUSxDQUFDLENBQUM7QUFDekIsMkJBQWEsUUFBUSxDQUFDLENBQUM7Q0FDeEIiLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCByZWdpc3RlckJsb2NrSGVscGVyTWlzc2luZyBmcm9tICcuL2hlbHBlcnMvYmxvY2staGVscGVyLW1pc3NpbmcnO1xuaW1wb3J0IHJlZ2lzdGVyRWFjaCBmcm9tICcuL2hlbHBlcnMvZWFjaCc7XG5pbXBvcnQgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nIGZyb20gJy4vaGVscGVycy9oZWxwZXItbWlzc2luZyc7XG5pbXBvcnQgcmVnaXN0ZXJJZiBmcm9tICcuL2hlbHBlcnMvaWYnO1xuaW1wb3J0IHJlZ2lzdGVyTG9nIGZyb20gJy4vaGVscGVycy9sb2cnO1xuaW1wb3J0IHJlZ2lzdGVyTG9va3VwIGZyb20gJy4vaGVscGVycy9sb29rdXAnO1xuaW1wb3J0IHJlZ2lzdGVyV2l0aCBmcm9tICcuL2hlbHBlcnMvd2l0aCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckRlZmF1bHRIZWxwZXJzKGluc3RhbmNlKSB7XG4gIHJlZ2lzdGVyQmxvY2tIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJFYWNoKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJIZWxwZXJNaXNzaW5nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJJZihpbnN0YW5jZSk7XG4gIHJlZ2lzdGVyTG9nKGluc3RhbmNlKTtcbiAgcmVnaXN0ZXJMb29rdXAoaW5zdGFuY2UpO1xuICByZWdpc3RlcldpdGgoaW5zdGFuY2UpO1xufVxuIl19


/***/ },
/* 99 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _utils = __webpack_require__(3);
	
	exports['default'] = function (instance) {
	  instance.registerHelper('blockHelperMissing', function (context, options) {
	    var inverse = options.inverse,
	        fn = options.fn;
	
	    if (context === true) {
	      return fn(this);
	    } else if (context === false || context == null) {
	      return inverse(this);
	    } else if (_utils.isArray(context)) {
	      if (context.length > 0) {
	        if (options.ids) {
	          options.ids = [options.name];
	        }
	
	        return instance.helpers.each(context, options);
	      } else {
	        return inverse(this);
	      }
	    } else {
	      if (options.data && options.ids) {
	        var data = _utils.createFrame(options.data);
	        data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name);
	        options = { data: data };
	      }
	
	      return fn(context, options);
	    }
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utils = __webpack_require__(3);
	
	var _exception = __webpack_require__(8);
	
	var _exception2 = _interopRequireDefault(_exception);
	
	exports['default'] = function (instance) {
	  instance.registerHelper('each', function (context, options) {
	    if (!options) {
	      throw new _exception2['default']('Must pass iterator to #each');
	    }
	
	    var fn = options.fn,
	        inverse = options.inverse,
	        i = 0,
	        ret = '',
	        data = undefined,
	        contextPath = undefined;
	
	    if (options.data && options.ids) {
	      contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
	    }
	
	    if (_utils.isFunction(context)) {
	      context = context.call(this);
	    }
	
	    if (options.data) {
	      data = _utils.createFrame(options.data);
	    }
	
	    function execIteration(field, index, last) {
	      if (data) {
	        data.key = field;
	        data.index = index;
	        data.first = index === 0;
	        data.last = !!last;
	
	        if (contextPath) {
	          data.contextPath = contextPath + field;
	        }
	      }
	
	      ret = ret + fn(context[field], {
	        data: data,
	        blockParams: _utils.blockParams([context[field], field], [contextPath + field, null])
	      });
	    }
	
	    if (context && typeof context === 'object') {
	      if (_utils.isArray(context)) {
	        for (var j = context.length; i < j; i++) {
	          if (i in context) {
	            execIteration(i, i, i === context.length - 1);
	          }
	        }
	      } else {
	        var priorKey = undefined;
	
	        for (var key in context) {
	          if (context.hasOwnProperty(key)) {
	            // We're running the iterations one step out of sync so we can detect
	            // the last iteration without have to scan the object twice and create
	            // an itermediate keys array.
	            if (priorKey !== undefined) {
	              execIteration(priorKey, i - 1);
	            }
	            priorKey = key;
	            i++;
	          }
	        }
	        if (priorKey !== undefined) {
	          execIteration(priorKey, i - 1, true);
	        }
	      }
	    }
	
	    if (i === 0) {
	      ret = inverse(this);
	    }
	
	    return ret;
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _exception = __webpack_require__(8);
	
	var _exception2 = _interopRequireDefault(_exception);
	
	exports['default'] = function (instance) {
	  instance.registerHelper('helperMissing', function () /* [args, ]options */{
	    if (arguments.length === 1) {
	      // A missing field in a {{foo}} construct.
	      return undefined;
	    } else {
	      // Someone is actually trying to call something, blow up.
	      throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
	    }
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvaGVscGVyLW1pc3NpbmcuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozt5QkFBc0IsY0FBYzs7OztxQkFFckIsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxlQUFlLEVBQUUsaUNBQWdDO0FBQ3ZFLFFBQUksU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7O0FBRTFCLGFBQU8sU0FBUyxDQUFDO0tBQ2xCLE1BQU07O0FBRUwsWUFBTSwyQkFBYyxtQkFBbUIsR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDLENBQUM7S0FDdkY7R0FDRixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJoZWxwZXItbWlzc2luZy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBFeGNlcHRpb24gZnJvbSAnLi4vZXhjZXB0aW9uJztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2hlbHBlck1pc3NpbmcnLCBmdW5jdGlvbigvKiBbYXJncywgXW9wdGlvbnMgKi8pIHtcbiAgICBpZiAoYXJndW1lbnRzLmxlbmd0aCA9PT0gMSkge1xuICAgICAgLy8gQSBtaXNzaW5nIGZpZWxkIGluIGEge3tmb299fSBjb25zdHJ1Y3QuXG4gICAgICByZXR1cm4gdW5kZWZpbmVkO1xuICAgIH0gZWxzZSB7XG4gICAgICAvLyBTb21lb25lIGlzIGFjdHVhbGx5IHRyeWluZyB0byBjYWxsIHNvbWV0aGluZywgYmxvdyB1cC5cbiAgICAgIHRocm93IG5ldyBFeGNlcHRpb24oJ01pc3NpbmcgaGVscGVyOiBcIicgKyBhcmd1bWVudHNbYXJndW1lbnRzLmxlbmd0aCAtIDFdLm5hbWUgKyAnXCInKTtcbiAgICB9XG4gIH0pO1xufVxuIl19


/***/ },
/* 102 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _utils = __webpack_require__(3);
	
	exports['default'] = function (instance) {
	  instance.registerHelper('if', function (conditional, options) {
	    if (_utils.isFunction(conditional)) {
	      conditional = conditional.call(this);
	    }
	
	    // Default behavior is to render the positive path if the value is truthy and not empty.
	    // The `includeZero` option may be set to treat the condtional as purely not empty based on the
	    // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
	    if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) {
	      return options.inverse(this);
	    } else {
	      return options.fn(this);
	    }
	  });
	
	  instance.registerHelper('unless', function (conditional, options) {
	    return instance.helpers['if'].call(this, conditional, { fn: options.inverse, inverse: options.fn, hash: options.hash });
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 103 */
/***/ function(module, exports) {

	'use strict';
	
	exports.__esModule = true;
	
	exports['default'] = function (instance) {
	  instance.registerHelper('log', function () /* message, options */{
	    var args = [undefined],
	        options = arguments[arguments.length - 1];
	    for (var i = 0; i < arguments.length - 1; i++) {
	      args.push(arguments[i]);
	    }
	
	    var level = 1;
	    if (options.hash.level != null) {
	      level = options.hash.level;
	    } else if (options.data && options.data.level != null) {
	      level = options.data.level;
	    }
	    args[0] = level;
	
	    instance.log.apply(instance, args);
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxLQUFLLEVBQUUsa0NBQWlDO0FBQzlELFFBQUksSUFBSSxHQUFHLENBQUMsU0FBUyxDQUFDO1FBQ2xCLE9BQU8sR0FBRyxTQUFTLENBQUMsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztBQUM5QyxTQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUU7QUFDN0MsVUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztLQUN6Qjs7QUFFRCxRQUFJLEtBQUssR0FBRyxDQUFDLENBQUM7QUFDZCxRQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxJQUFJLElBQUksRUFBRTtBQUM5QixXQUFLLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7S0FDNUIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxJQUFJLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksSUFBSSxFQUFFO0FBQ3JELFdBQUssR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztLQUM1QjtBQUNELFFBQUksQ0FBQyxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUM7O0FBRWhCLFlBQVEsQ0FBQyxHQUFHLE1BQUEsQ0FBWixRQUFRLEVBQVMsSUFBSSxDQUFDLENBQUM7R0FDeEIsQ0FBQyxDQUFDO0NBQ0oiLCJmaWxlIjoibG9nLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oaW5zdGFuY2UpIHtcbiAgaW5zdGFuY2UucmVnaXN0ZXJIZWxwZXIoJ2xvZycsIGZ1bmN0aW9uKC8qIG1lc3NhZ2UsIG9wdGlvbnMgKi8pIHtcbiAgICBsZXQgYXJncyA9IFt1bmRlZmluZWRdLFxuICAgICAgICBvcHRpb25zID0gYXJndW1lbnRzW2FyZ3VtZW50cy5sZW5ndGggLSAxXTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGFyZ3VtZW50cy5sZW5ndGggLSAxOyBpKyspIHtcbiAgICAgIGFyZ3MucHVzaChhcmd1bWVudHNbaV0pO1xuICAgIH1cblxuICAgIGxldCBsZXZlbCA9IDE7XG4gICAgaWYgKG9wdGlvbnMuaGFzaC5sZXZlbCAhPSBudWxsKSB7XG4gICAgICBsZXZlbCA9IG9wdGlvbnMuaGFzaC5sZXZlbDtcbiAgICB9IGVsc2UgaWYgKG9wdGlvbnMuZGF0YSAmJiBvcHRpb25zLmRhdGEubGV2ZWwgIT0gbnVsbCkge1xuICAgICAgbGV2ZWwgPSBvcHRpb25zLmRhdGEubGV2ZWw7XG4gICAgfVxuICAgIGFyZ3NbMF0gPSBsZXZlbDtcblxuICAgIGluc3RhbmNlLmxvZyguLi4gYXJncyk7XG4gIH0pO1xufVxuIl19


/***/ },
/* 104 */
/***/ function(module, exports) {

	'use strict';
	
	exports.__esModule = true;
	
	exports['default'] = function (instance) {
	  instance.registerHelper('lookup', function (obj, field) {
	    return obj && obj[field];
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL2hlbHBlcnMvbG9va3VwLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWUsVUFBUyxRQUFRLEVBQUU7QUFDaEMsVUFBUSxDQUFDLGNBQWMsQ0FBQyxRQUFRLEVBQUUsVUFBUyxHQUFHLEVBQUUsS0FBSyxFQUFFO0FBQ3JELFdBQU8sR0FBRyxJQUFJLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztHQUMxQixDQUFDLENBQUM7Q0FDSiIsImZpbGUiOiJsb29rdXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBmdW5jdGlvbihpbnN0YW5jZSkge1xuICBpbnN0YW5jZS5yZWdpc3RlckhlbHBlcignbG9va3VwJywgZnVuY3Rpb24ob2JqLCBmaWVsZCkge1xuICAgIHJldHVybiBvYmogJiYgb2JqW2ZpZWxkXTtcbiAgfSk7XG59XG4iXX0=


/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _utils = __webpack_require__(3);
	
	exports['default'] = function (instance) {
	  instance.registerHelper('with', function (context, options) {
	    if (_utils.isFunction(context)) {
	      context = context.call(this);
	    }
	
	    var fn = options.fn;
	
	    if (!_utils.isEmpty(context)) {
	      var data = options.data;
	      if (options.data && options.ids) {
	        data = _utils.createFrame(options.data);
	        data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]);
	      }
	
	      return fn(context, {
	        data: data,
	        blockParams: _utils.blockParams([context], [data && data.contextPath])
	      });
	    } else {
	      return options.inverse(this);
	    }
	  });
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _utils = __webpack_require__(3);
	
	var logger = {
	  methodMap: ['debug', 'info', 'warn', 'error'],
	  level: 'info',
	
	  // Maps a given level value to the `methodMap` indexes above.
	  lookupLevel: function lookupLevel(level) {
	    if (typeof level === 'string') {
	      var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase());
	      if (levelMap >= 0) {
	        level = levelMap;
	      } else {
	        level = parseInt(level, 10);
	      }
	    }
	
	    return level;
	  },
	
	  // Can be overridden in the host environment
	  log: function log(level) {
	    level = logger.lookupLevel(level);
	
	    if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
	      var method = logger.methodMap[level];
	      if (!console[method]) {
	        // eslint-disable-line no-console
	        method = 'log';
	      }
	
	      for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	        message[_key - 1] = arguments[_key];
	      }
	
	      console[method].apply(console, message); // eslint-disable-line no-console
	    }
	  }
	};
	
	exports['default'] = logger;
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,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


/***/ },
/* 107 */
/***/ function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {/* global window */
	'use strict';
	
	exports.__esModule = true;
	
	exports['default'] = function (Handlebars) {
	  /* istanbul ignore next */
	  var root = typeof global !== 'undefined' ? global : window,
	      $Handlebars = root.Handlebars;
	  /* istanbul ignore next */
	  Handlebars.noConflict = function () {
	    if (root.Handlebars === Handlebars) {
	      root.Handlebars = $Handlebars;
	    }
	    return Handlebars;
	  };
	};
	
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL25vLWNvbmZsaWN0LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O3FCQUNlLFVBQVMsVUFBVSxFQUFFOztBQUVsQyxNQUFJLElBQUksR0FBRyxPQUFPLE1BQU0sS0FBSyxXQUFXLEdBQUcsTUFBTSxHQUFHLE1BQU07TUFDdEQsV0FBVyxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7O0FBRWxDLFlBQVUsQ0FBQyxVQUFVLEdBQUcsWUFBVztBQUNqQyxRQUFJLElBQUksQ0FBQyxVQUFVLEtBQUssVUFBVSxFQUFFO0FBQ2xDLFVBQUksQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDO0tBQy9CO0FBQ0QsV0FBTyxVQUFVLENBQUM7R0FDbkIsQ0FBQztDQUNIIiwiZmlsZSI6Im5vLWNvbmZsaWN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIHdpbmRvdyAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24oSGFuZGxlYmFycykge1xuICAvKiBpc3RhbmJ1bCBpZ25vcmUgbmV4dCAqL1xuICBsZXQgcm9vdCA9IHR5cGVvZiBnbG9iYWwgIT09ICd1bmRlZmluZWQnID8gZ2xvYmFsIDogd2luZG93LFxuICAgICAgJEhhbmRsZWJhcnMgPSByb290LkhhbmRsZWJhcnM7XG4gIC8qIGlzdGFuYnVsIGlnbm9yZSBuZXh0ICovXG4gIEhhbmRsZWJhcnMubm9Db25mbGljdCA9IGZ1bmN0aW9uKCkge1xuICAgIGlmIChyb290LkhhbmRsZWJhcnMgPT09IEhhbmRsZWJhcnMpIHtcbiAgICAgIHJvb3QuSGFuZGxlYmFycyA9ICRIYW5kbGViYXJzO1xuICAgIH1cbiAgICByZXR1cm4gSGFuZGxlYmFycztcbiAgfTtcbn1cbiJdfQ==
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 108 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.checkRevision = checkRevision;
	exports.template = template;
	exports.wrapProgram = wrapProgram;
	exports.resolvePartial = resolvePartial;
	exports.invokePartial = invokePartial;
	exports.noop = noop;
	// istanbul ignore next
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// istanbul ignore next
	
	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
	
	var _utils = __webpack_require__(3);
	
	var Utils = _interopRequireWildcard(_utils);
	
	var _exception = __webpack_require__(8);
	
	var _exception2 = _interopRequireDefault(_exception);
	
	var _base = __webpack_require__(30);
	
	function checkRevision(compilerInfo) {
	  var compilerRevision = compilerInfo && compilerInfo[0] || 1,
	      currentRevision = _base.COMPILER_REVISION;
	
	  if (compilerRevision !== currentRevision) {
	    if (compilerRevision < currentRevision) {
	      var runtimeVersions = _base.REVISION_CHANGES[currentRevision],
	          compilerVersions = _base.REVISION_CHANGES[compilerRevision];
	      throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
	    } else {
	      // Use the embedded version info since the runtime doesn't know about this revision yet
	      throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
	    }
	  }
	}
	
	function template(templateSpec, env) {
	  /* istanbul ignore next */
	  if (!env) {
	    throw new _exception2['default']('No environment passed to template');
	  }
	  if (!templateSpec || !templateSpec.main) {
	    throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
	  }
	
	  templateSpec.main.decorator = templateSpec.main_d;
	
	  // Note: Using env.VM references rather than local var references throughout this section to allow
	  // for external users to override these as psuedo-supported APIs.
	  env.VM.checkRevision(templateSpec.compiler);
	
	  function invokePartialWrapper(partial, context, options) {
	    if (options.hash) {
	      context = Utils.extend({}, context, options.hash);
	      if (options.ids) {
	        options.ids[0] = true;
	      }
	    }
	
	    partial = env.VM.resolvePartial.call(this, partial, context, options);
	    var result = env.VM.invokePartial.call(this, partial, context, options);
	
	    if (result == null && env.compile) {
	      options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
	      result = options.partials[options.name](context, options);
	    }
	    if (result != null) {
	      if (options.indent) {
	        var lines = result.split('\n');
	        for (var i = 0, l = lines.length; i < l; i++) {
	          if (!lines[i] && i + 1 === l) {
	            break;
	          }
	
	          lines[i] = options.indent + lines[i];
	        }
	        result = lines.join('\n');
	      }
	      return result;
	    } else {
	      throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
	    }
	  }
	
	  // Just add water
	  var container = {
	    strict: function strict(obj, name) {
	      if (!(name in obj)) {
	        throw new _exception2['default']('"' + name + '" not defined in ' + obj);
	      }
	      return obj[name];
	    },
	    lookup: function lookup(depths, name) {
	      var len = depths.length;
	      for (var i = 0; i < len; i++) {
	        if (depths[i] && depths[i][name] != null) {
	          return depths[i][name];
	        }
	      }
	    },
	    lambda: function lambda(current, context) {
	      return typeof current === 'function' ? current.call(context) : current;
	    },
	
	    escapeExpression: Utils.escapeExpression,
	    invokePartial: invokePartialWrapper,
	
	    fn: function fn(i) {
	      var ret = templateSpec[i];
	      ret.decorator = templateSpec[i + '_d'];
	      return ret;
	    },
	
	    programs: [],
	    program: function program(i, data, declaredBlockParams, blockParams, depths) {
	      var programWrapper = this.programs[i],
	          fn = this.fn(i);
	      if (data || depths || blockParams || declaredBlockParams) {
	        programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
	      } else if (!programWrapper) {
	        programWrapper = this.programs[i] = wrapProgram(this, i, fn);
	      }
	      return programWrapper;
	    },
	
	    data: function data(value, depth) {
	      while (value && depth--) {
	        value = value._parent;
	      }
	      return value;
	    },
	    merge: function merge(param, common) {
	      var obj = param || common;
	
	      if (param && common && param !== common) {
	        obj = Utils.extend({}, common, param);
	      }
	
	      return obj;
	    },
	    // An empty object to use as replacement for null-contexts
	    nullContext: Object.seal({}),
	
	    noop: env.VM.noop,
	    compilerInfo: templateSpec.compiler
	  };
	
	  function ret(context) {
	    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	
	    var data = options.data;
	
	    ret._setup(options);
	    if (!options.partial && templateSpec.useData) {
	      data = initData(context, data);
	    }
	    var depths = undefined,
	        blockParams = templateSpec.useBlockParams ? [] : undefined;
	    if (templateSpec.useDepths) {
	      if (options.depths) {
	        depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
	      } else {
	        depths = [context];
	      }
	    }
	
	    function main(context /*, options*/) {
	      return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
	    }
	    main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
	    return main(context, options);
	  }
	  ret.isTop = true;
	
	  ret._setup = function (options) {
	    if (!options.partial) {
	      container.helpers = container.merge(options.helpers, env.helpers);
	
	      if (templateSpec.usePartial) {
	        container.partials = container.merge(options.partials, env.partials);
	      }
	      if (templateSpec.usePartial || templateSpec.useDecorators) {
	        container.decorators = container.merge(options.decorators, env.decorators);
	      }
	    } else {
	      container.helpers = options.helpers;
	      container.partials = options.partials;
	      container.decorators = options.decorators;
	    }
	  };
	
	  ret._child = function (i, data, blockParams, depths) {
	    if (templateSpec.useBlockParams && !blockParams) {
	      throw new _exception2['default']('must pass block params');
	    }
	    if (templateSpec.useDepths && !depths) {
	      throw new _exception2['default']('must pass parent depths');
	    }
	
	    return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
	  };
	  return ret;
	}
	
	function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
	  function prog(context) {
	    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	
	    var currentDepths = depths;
	    if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) {
	      currentDepths = [context].concat(depths);
	    }
	
	    return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
	  }
	
	  prog = executeDecorators(fn, prog, container, depths, data, blockParams);
	
	  prog.program = i;
	  prog.depth = depths ? depths.length : 0;
	  prog.blockParams = declaredBlockParams || 0;
	  return prog;
	}
	
	function resolvePartial(partial, context, options) {
	  if (!partial) {
	    if (options.name === '@partial-block') {
	      partial = options.data['partial-block'];
	    } else {
	      partial = options.partials[options.name];
	    }
	  } else if (!partial.call && !options.name) {
	    // This is a dynamic partial that returned a string
	    options.name = partial;
	    partial = options.partials[partial];
	  }
	  return partial;
	}
	
	function invokePartial(partial, context, options) {
	  // Use the current closure context to save the partial-block if this partial
	  var currentPartialBlock = options.data && options.data['partial-block'];
	  options.partial = true;
	  if (options.ids) {
	    options.data.contextPath = options.ids[0] || options.data.contextPath;
	  }
	
	  var partialBlock = undefined;
	  if (options.fn && options.fn !== noop) {
	    (function () {
	      options.data = _base.createFrame(options.data);
	      // Wrapper function to get access to currentPartialBlock from the closure
	      var fn = options.fn;
	      partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
	        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	
	        // Restore the partial-block from the closure for the execution of the block
	        // i.e. the part inside the block of the partial call.
	        options.data = _base.createFrame(options.data);
	        options.data['partial-block'] = currentPartialBlock;
	        return fn(context, options);
	      };
	      if (fn.partials) {
	        options.partials = Utils.extend({}, options.partials, fn.partials);
	      }
	    })();
	  }
	
	  if (partial === undefined && partialBlock) {
	    partial = partialBlock;
	  }
	
	  if (partial === undefined) {
	    throw new _exception2['default']('The partial ' + options.name + ' could not be found');
	  } else if (partial instanceof Function) {
	    return partial(context, options);
	  }
	}
	
	function noop() {
	  return '';
	}
	
	function initData(context, data) {
	  if (!data || !('root' in data)) {
	    data = data ? _base.createFrame(data) : {};
	    data.root = context;
	  }
	  return data;
	}
	
	function executeDecorators(fn, prog, container, depths, data, blockParams) {
	  if (fn.decorator) {
	    var props = {};
	    prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
	    Utils.extend(prog, props);
	  }
	  return prog;
	}
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/handlebars/runtime.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;qBAAuB,SAAS;;IAApB,KAAK;;yBACK,aAAa;;;;oBAC8B,QAAQ;;AAElE,SAAS,aAAa,CAAC,YAAY,EAAE;AAC1C,MAAM,gBAAgB,GAAG,YAAY,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;MACvD,eAAe,0BAAoB,CAAC;;AAE1C,MAAI,gBAAgB,KAAK,eAAe,EAAE;AACxC,QAAI,gBAAgB,GAAG,eAAe,EAAE;AACtC,UAAM,eAAe,GAAG,uBAAiB,eAAe,CAAC;UACnD,gBAAgB,GAAG,uBAAiB,gBAAgB,CAAC,CAAC;AAC5D,YAAM,2BAAc,yFAAyF,GACvG,qDAAqD,GAAG,eAAe,GAAG,mDAAmD,GAAG,gBAAgB,GAAG,IAAI,CAAC,CAAC;KAChK,MAAM;;AAEL,YAAM,2BAAc,wFAAwF,GACtG,iDAAiD,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;KACnF;GACF;CACF;;AAEM,SAAS,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;;AAE1C,MAAI,CAAC,GAAG,EAAE;AACR,UAAM,2BAAc,mCAAmC,CAAC,CAAC;GAC1D;AACD,MAAI,CAAC,YAAY,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE;AACvC,UAAM,2BAAc,2BAA2B,GAAG,OAAO,YAAY,CAAC,CAAC;GACxE;;AAED,cAAY,CAAC,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC;;;;AAIlD,KAAG,CAAC,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;;AAE5C,WAAS,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;AACvD,QAAI,OAAO,CAAC,IAAI,EAAE;AAChB,aAAO,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;AAClD,UAAI,OAAO,CAAC,GAAG,EAAE;AACf,eAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;OACvB;KACF;;AAED,WAAO,GAAG,GAAG,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACtE,QAAI,MAAM,GAAG,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;;AAExE,QAAI,MAAM,IAAI,IAAI,IAAI,GAAG,CAAC,OAAO,EAAE;AACjC,aAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;AACzF,YAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;KAC3D;AACD,QAAI,MAAM,IAAI,IAAI,EAAE;AAClB,UAAI,OAAO,CAAC,MAAM,EAAE;AAClB,YAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC/B,aAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC5C,cAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AAC5B,kBAAM;WACP;;AAED,eAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;SACtC;AACD,cAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAC3B;AACD,aAAO,MAAM,CAAC;KACf,MAAM;AACL,YAAM,2BAAc,cAAc,GAAG,OAAO,CAAC,IAAI,GAAG,0DAA0D,CAAC,CAAC;KACjH;GACF;;;AAGD,MAAI,SAAS,GAAG;AACd,UAAM,EAAE,gBAAS,GAAG,EAAE,IAAI,EAAE;AAC1B,UAAI,EAAE,IAAI,IAAI,GAAG,CAAA,AAAC,EAAE;AAClB,cAAM,2BAAc,GAAG,GAAG,IAAI,GAAG,mBAAmB,GAAG,GAAG,CAAC,CAAC;OAC7D;AACD,aAAO,GAAG,CAAC,IAAI,CAAC,CAAC;KAClB;AACD,UAAM,EAAE,gBAAS,MAAM,EAAE,IAAI,EAAE;AAC7B,UAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;AAC1B,WAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AAC5B,YAAI,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE;AACxC,iBAAO,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SACxB;OACF;KACF;AACD,UAAM,EAAE,gBAAS,OAAO,EAAE,OAAO,EAAE;AACjC,aAAO,OAAO,OAAO,KAAK,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;KACxE;;AAED,oBAAgB,EAAE,KAAK,CAAC,gBAAgB;AACxC,iBAAa,EAAE,oBAAoB;;AAEnC,MAAE,EAAE,YAAS,CAAC,EAAE;AACd,UAAI,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAC1B,SAAG,CAAC,SAAS,GAAG,YAAY,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AACvC,aAAO,GAAG,CAAC;KACZ;;AAED,YAAQ,EAAE,EAAE;AACZ,WAAO,EAAE,iBAAS,CAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,EAAE;AACnE,UAAI,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;UACjC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACpB,UAAI,IAAI,IAAI,MAAM,IAAI,WAAW,IAAI,mBAAmB,EAAE;AACxD,sBAAc,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;OAC3F,MAAM,IAAI,CAAC,cAAc,EAAE;AAC1B,sBAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;OAC9D;AACD,aAAO,cAAc,CAAC;KACvB;;AAED,QAAI,EAAE,cAAS,KAAK,EAAE,KAAK,EAAE;AAC3B,aAAO,KAAK,IAAI,KAAK,EAAE,EAAE;AACvB,aAAK,GAAG,KAAK,CAAC,OAAO,CAAC;OACvB;AACD,aAAO,KAAK,CAAC;KACd;AACD,SAAK,EAAE,eAAS,KAAK,EAAE,MAAM,EAAE;AAC7B,UAAI,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC;;AAE1B,UAAI,KAAK,IAAI,MAAM,IAAK,KAAK,KAAK,MAAM,AAAC,EAAE;AACzC,WAAG,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;OACvC;;AAED,aAAO,GAAG,CAAC;KACZ;;AAED,eAAW,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;;AAE5B,QAAI,EAAE,GAAG,CAAC,EAAE,CAAC,IAAI;AACjB,gBAAY,EAAE,YAAY,CAAC,QAAQ;GACpC,CAAC;;AAEF,WAAS,GAAG,CAAC,OAAO,EAAgB;QAAd,OAAO,yDAAG,EAAE;;AAChC,QAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;;AAExB,OAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACpB,QAAI,CAAC,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE;AAC5C,UAAI,GAAG,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;KAChC;AACD,QAAI,MAAM,YAAA;QACN,WAAW,GAAG,YAAY,CAAC,cAAc,GAAG,EAAE,GAAG,SAAS,CAAC;AAC/D,QAAI,YAAY,CAAC,SAAS,EAAE;AAC1B,UAAI,OAAO,CAAC,MAAM,EAAE;AAClB,cAAM,GAAG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;OAC3F,MAAM;AACL,cAAM,GAAG,CAAC,OAAO,CAAC,CAAC;OACpB;KACF;;AAED,aAAS,IAAI,CAAC,OAAO,gBAAe;AAClC,aAAO,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;KACrH;AACD,QAAI,GAAG,iBAAiB,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AACtG,WAAO,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;GAC/B;AACD,KAAG,CAAC,KAAK,GAAG,IAAI,CAAC;;AAEjB,KAAG,CAAC,MAAM,GAAG,UAAS,OAAO,EAAE;AAC7B,QAAI,CAAC,OAAO,CAAC,OAAO,EAAE;AACpB,eAAS,CAAC,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;;AAElE,UAAI,YAAY,CAAC,UAAU,EAAE;AAC3B,iBAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;OACtE;AACD,UAAI,YAAY,CAAC,UAAU,IAAI,YAAY,CAAC,aAAa,EAAE;AACzD,iBAAS,CAAC,UAAU,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;OAC5E;KACF,MAAM;AACL,eAAS,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;AACpC,eAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACtC,eAAS,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;KAC3C;GACF,CAAC;;AAEF,KAAG,CAAC,MAAM,GAAG,UAAS,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE;AAClD,QAAI,YAAY,CAAC,cAAc,IAAI,CAAC,WAAW,EAAE;AAC/C,YAAM,2BAAc,wBAAwB,CAAC,CAAC;KAC/C;AACD,QAAI,YAAY,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE;AACrC,YAAM,2BAAc,yBAAyB,CAAC,CAAC;KAChD;;AAED,WAAO,WAAW,CAAC,SAAS,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;GACjF,CAAC;AACF,SAAO,GAAG,CAAC;CACZ;;AAEM,SAAS,WAAW,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,EAAE;AAC5F,WAAS,IAAI,CAAC,OAAO,EAAgB;QAAd,OAAO,yDAAG,EAAE;;AACjC,QAAI,aAAa,GAAG,MAAM,CAAC;AAC3B,QAAI,MAAM,IAAI,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK,SAAS,CAAC,WAAW,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA,AAAC,EAAE;AAChG,mBAAa,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KAC1C;;AAED,WAAO,EAAE,CAAC,SAAS,EACf,OAAO,EACP,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,QAAQ,EACrC,OAAO,CAAC,IAAI,IAAI,IAAI,EACpB,WAAW,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,EACxD,aAAa,CAAC,CAAC;GACpB;;AAED,MAAI,GAAG,iBAAiB,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;;AAEzE,MAAI,CAAC,OAAO,GAAG,CAAC,CAAC;AACjB,MAAI,CAAC,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;AACxC,MAAI,CAAC,WAAW,GAAG,mBAAmB,IAAI,CAAC,CAAC;AAC5C,SAAO,IAAI,CAAC;CACb;;AAEM,SAAS,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;AACxD,MAAI,CAAC,OAAO,EAAE;AACZ,QAAI,OAAO,CAAC,IAAI,KAAK,gBAAgB,EAAE;AACrC,aAAO,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;KACzC,MAAM;AACL,aAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1C;GACF,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;;AAEzC,WAAO,CAAC,IAAI,GAAG,OAAO,CAAC;AACvB,WAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;GACrC;AACD,SAAO,OAAO,CAAC;CAChB;;AAEM,SAAS,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE;;AAEvD,MAAM,mBAAmB,GAAG,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;AAC1E,SAAO,CAAC,OAAO,GAAG,IAAI,CAAC;AACvB,MAAI,OAAO,CAAC,GAAG,EAAE;AACf,WAAO,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;GACvE;;AAED,MAAI,YAAY,YAAA,CAAC;AACjB,MAAI,OAAO,CAAC,EAAE,IAAI,OAAO,CAAC,EAAE,KAAK,IAAI,EAAE;;AACrC,aAAO,CAAC,IAAI,GAAG,kBAAY,OAAO,CAAC,IAAI,CAAC,CAAC;;AAEzC,UAAI,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;AACpB,kBAAY,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,SAAS,mBAAmB,CAAC,OAAO,EAAgB;YAAd,OAAO,yDAAG,EAAE;;;;AAI/F,eAAO,CAAC,IAAI,GAAG,kBAAY,OAAO,CAAC,IAAI,CAAC,CAAC;AACzC,eAAO,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,mBAAmB,CAAC;AACpD,eAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;OAC7B,CAAC;AACF,UAAI,EAAE,CAAC,QAAQ,EAAE;AACf,eAAO,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC;OACpE;;GACF;;AAED,MAAI,OAAO,KAAK,SAAS,IAAI,YAAY,EAAE;AACzC,WAAO,GAAG,YAAY,CAAC;GACxB;;AAED,MAAI,OAAO,KAAK,SAAS,EAAE;AACzB,UAAM,2BAAc,cAAc,GAAG,OAAO,CAAC,IAAI,GAAG,qBAAqB,CAAC,CAAC;GAC5E,MAAM,IAAI,OAAO,YAAY,QAAQ,EAAE;AACtC,WAAO,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;GAClC;CACF;;AAEM,SAAS,IAAI,GAAG;AAAE,SAAO,EAAE,CAAC;CAAE;;AAErC,SAAS,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE;AAC/B,MAAI,CAAC,IAAI,IAAI,EAAE,MAAM,IAAI,IAAI,CAAA,AAAC,EAAE;AAC9B,QAAI,GAAG,IAAI,GAAG,kBAAY,IAAI,CAAC,GAAG,EAAE,CAAC;AACrC,QAAI,CAAC,IAAI,GAAG,OAAO,CAAC;GACrB;AACD,SAAO,IAAI,CAAC;CACb;;AAED,SAAS,iBAAiB,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE;AACzE,MAAI,EAAE,CAAC,SAAS,EAAE;AAChB,QAAI,KAAK,GAAG,EAAE,CAAC;AACf,QAAI,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;AAC5F,SAAK,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;GAC3B;AACD,SAAO,IAAI,CAAC;CACb","file":"runtime.js","sourcesContent":["import * as Utils from './utils';\nimport Exception from './exception';\nimport { COMPILER_REVISION, REVISION_CHANGES, createFrame } from './base';\n\nexport function checkRevision(compilerInfo) {\n  const compilerRevision = compilerInfo && compilerInfo[0] || 1,\n        currentRevision = COMPILER_REVISION;\n\n  if (compilerRevision !== currentRevision) {\n    if (compilerRevision < currentRevision) {\n      const runtimeVersions = REVISION_CHANGES[currentRevision],\n            compilerVersions = REVISION_CHANGES[compilerRevision];\n      throw new Exception('Template was precompiled with an older version of Handlebars than the current runtime. ' +\n            'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');\n    } else {\n      // Use the embedded version info since the runtime doesn't know about this revision yet\n      throw new Exception('Template was precompiled with a newer version of Handlebars than the current runtime. ' +\n            'Please update your runtime to a newer version (' + compilerInfo[1] + ').');\n    }\n  }\n}\n\nexport function template(templateSpec, env) {\n  /* istanbul ignore next */\n  if (!env) {\n    throw new Exception('No environment passed to template');\n  }\n  if (!templateSpec || !templateSpec.main) {\n    throw new Exception('Unknown template object: ' + typeof templateSpec);\n  }\n\n  templateSpec.main.decorator = templateSpec.main_d;\n\n  // Note: Using env.VM references rather than local var references throughout this section to allow\n  // for external users to override these as psuedo-supported APIs.\n  env.VM.checkRevision(templateSpec.compiler);\n\n  function invokePartialWrapper(partial, context, options) {\n    if (options.hash) {\n      context = Utils.extend({}, context, options.hash);\n      if (options.ids) {\n        options.ids[0] = true;\n      }\n    }\n\n    partial = env.VM.resolvePartial.call(this, partial, context, options);\n    let result = env.VM.invokePartial.call(this, partial, context, options);\n\n    if (result == null && env.compile) {\n      options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);\n      result = options.partials[options.name](context, options);\n    }\n    if (result != null) {\n      if (options.indent) {\n        let lines = result.split('\\n');\n        for (let i = 0, l = lines.length; i < l; i++) {\n          if (!lines[i] && i + 1 === l) {\n            break;\n          }\n\n          lines[i] = options.indent + lines[i];\n        }\n        result = lines.join('\\n');\n      }\n      return result;\n    } else {\n      throw new Exception('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');\n    }\n  }\n\n  // Just add water\n  let container = {\n    strict: function(obj, name) {\n      if (!(name in obj)) {\n        throw new Exception('\"' + name + '\" not defined in ' + obj);\n      }\n      return obj[name];\n    },\n    lookup: function(depths, name) {\n      const len = depths.length;\n      for (let i = 0; i < len; i++) {\n        if (depths[i] && depths[i][name] != null) {\n          return depths[i][name];\n        }\n      }\n    },\n    lambda: function(current, context) {\n      return typeof current === 'function' ? current.call(context) : current;\n    },\n\n    escapeExpression: Utils.escapeExpression,\n    invokePartial: invokePartialWrapper,\n\n    fn: function(i) {\n      let ret = templateSpec[i];\n      ret.decorator = templateSpec[i + '_d'];\n      return ret;\n    },\n\n    programs: [],\n    program: function(i, data, declaredBlockParams, blockParams, depths) {\n      let programWrapper = this.programs[i],\n          fn = this.fn(i);\n      if (data || depths || blockParams || declaredBlockParams) {\n        programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);\n      } else if (!programWrapper) {\n        programWrapper = this.programs[i] = wrapProgram(this, i, fn);\n      }\n      return programWrapper;\n    },\n\n    data: function(value, depth) {\n      while (value && depth--) {\n        value = value._parent;\n      }\n      return value;\n    },\n    merge: function(param, common) {\n      let obj = param || common;\n\n      if (param && common && (param !== common)) {\n        obj = Utils.extend({}, common, param);\n      }\n\n      return obj;\n    },\n    // An empty object to use as replacement for null-contexts\n    nullContext: Object.seal({}),\n\n    noop: env.VM.noop,\n    compilerInfo: templateSpec.compiler\n  };\n\n  function ret(context, options = {}) {\n    let data = options.data;\n\n    ret._setup(options);\n    if (!options.partial && templateSpec.useData) {\n      data = initData(context, data);\n    }\n    let depths,\n        blockParams = templateSpec.useBlockParams ? [] : undefined;\n    if (templateSpec.useDepths) {\n      if (options.depths) {\n        depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;\n      } else {\n        depths = [context];\n      }\n    }\n\n    function main(context/*, options*/) {\n      return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);\n    }\n    main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);\n    return main(context, options);\n  }\n  ret.isTop = true;\n\n  ret._setup = function(options) {\n    if (!options.partial) {\n      container.helpers = container.merge(options.helpers, env.helpers);\n\n      if (templateSpec.usePartial) {\n        container.partials = container.merge(options.partials, env.partials);\n      }\n      if (templateSpec.usePartial || templateSpec.useDecorators) {\n        container.decorators = container.merge(options.decorators, env.decorators);\n      }\n    } else {\n      container.helpers = options.helpers;\n      container.partials = options.partials;\n      container.decorators = options.decorators;\n    }\n  };\n\n  ret._child = function(i, data, blockParams, depths) {\n    if (templateSpec.useBlockParams && !blockParams) {\n      throw new Exception('must pass block params');\n    }\n    if (templateSpec.useDepths && !depths) {\n      throw new Exception('must pass parent depths');\n    }\n\n    return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);\n  };\n  return ret;\n}\n\nexport function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {\n  function prog(context, options = {}) {\n    let currentDepths = depths;\n    if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) {\n      currentDepths = [context].concat(depths);\n    }\n\n    return fn(container,\n        context,\n        container.helpers, container.partials,\n        options.data || data,\n        blockParams && [options.blockParams].concat(blockParams),\n        currentDepths);\n  }\n\n  prog = executeDecorators(fn, prog, container, depths, data, blockParams);\n\n  prog.program = i;\n  prog.depth = depths ? depths.length : 0;\n  prog.blockParams = declaredBlockParams || 0;\n  return prog;\n}\n\nexport function resolvePartial(partial, context, options) {\n  if (!partial) {\n    if (options.name === '@partial-block') {\n      partial = options.data['partial-block'];\n    } else {\n      partial = options.partials[options.name];\n    }\n  } else if (!partial.call && !options.name) {\n    // This is a dynamic partial that returned a string\n    options.name = partial;\n    partial = options.partials[partial];\n  }\n  return partial;\n}\n\nexport function invokePartial(partial, context, options) {\n  // Use the current closure context to save the partial-block if this partial\n  const currentPartialBlock = options.data && options.data['partial-block'];\n  options.partial = true;\n  if (options.ids) {\n    options.data.contextPath = options.ids[0] || options.data.contextPath;\n  }\n\n  let partialBlock;\n  if (options.fn && options.fn !== noop) {\n    options.data = createFrame(options.data);\n    // Wrapper function to get access to currentPartialBlock from the closure\n    let fn = options.fn;\n    partialBlock = options.data['partial-block'] = function partialBlockWrapper(context, options = {}) {\n\n      // Restore the partial-block from the closure for the execution of the block\n      // i.e. the part inside the block of the partial call.\n      options.data = createFrame(options.data);\n      options.data['partial-block'] = currentPartialBlock;\n      return fn(context, options);\n    };\n    if (fn.partials) {\n      options.partials = Utils.extend({}, options.partials, fn.partials);\n    }\n  }\n\n  if (partial === undefined && partialBlock) {\n    partial = partialBlock;\n  }\n\n  if (partial === undefined) {\n    throw new Exception('The partial ' + options.name + ' could not be found');\n  } else if (partial instanceof Function) {\n    return partial(context, options);\n  }\n}\n\nexport function noop() { return ''; }\n\nfunction initData(context, data) {\n  if (!data || !('root' in data)) {\n    data = data ? createFrame(data) : {};\n    data.root = context;\n  }\n  return data;\n}\n\nfunction executeDecorators(fn, prog, container, depths, data, blockParams) {\n  if (fn.decorator) {\n    let props = {};\n    prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);\n    Utils.extend(prog, props);\n  }\n  return prog;\n}\n"]}


/***/ },
/* 109 */
/***/ function(module, exports) {

	// Build out our basic SafeString type
	'use strict';
	
	exports.__esModule = true;
	function SafeString(string) {
	  this.string = string;
	}
	
	SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
	  return '' + this.string;
	};
	
	exports['default'] = SafeString;
	module.exports = exports['default'];
	//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9oYW5kbGViYXJzL3NhZmUtc3RyaW5nLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFDQSxTQUFTLFVBQVUsQ0FBQyxNQUFNLEVBQUU7QUFDMUIsTUFBSSxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUM7Q0FDdEI7O0FBRUQsVUFBVSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEdBQUcsVUFBVSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsWUFBVztBQUN2RSxTQUFPLEVBQUUsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO0NBQ3pCLENBQUM7O3FCQUVhLFVBQVUiLCJmaWxlIjoic2FmZS1zdHJpbmcuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBCdWlsZCBvdXQgb3VyIGJhc2ljIFNhZmVTdHJpbmcgdHlwZVxuZnVuY3Rpb24gU2FmZVN0cmluZyhzdHJpbmcpIHtcbiAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG59XG5cblNhZmVTdHJpbmcucHJvdG90eXBlLnRvU3RyaW5nID0gU2FmZVN0cmluZy5wcm90b3R5cGUudG9IVE1MID0gZnVuY3Rpb24oKSB7XG4gIHJldHVybiAnJyArIHRoaXMuc3RyaW5nO1xufTtcblxuZXhwb3J0IGRlZmF1bHQgU2FmZVN0cmluZztcbiJdfQ==


/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {

	var Sticky = __webpack_require__(49);
	var $ = __webpack_require__(2);
	
	exports.init = function() {
	
	  Sticky('.side-area', 20);
	
	  var titles = $('.content-area > .content > h2, h2.alice-module-title');
	  var doc = $(document);
	  if (titles.length <= 0) {
	      return;
	  }
	
	  $(window).scroll(function() {
	    var top = doc.scrollTop(), i;
	    if (top >= doc.height()- $(window).height() - 20) {
	      i = titles.length - 1;
	    } else {
	      for (i=0; i<titles.length; i++) {
	        if (top < titles.eq(i).offset().top - 20) {
	          break;
	        }
	      }
	      i--;
	      i = (i<0) ? 0 : i;
	    }
	    $('.side-area .side-highlight').removeClass('side-highlight');
	    $('.side-area > ul > li').eq(i).addClass('side-highlight');
	  });
	
	};


/***/ },
/* 111 */
/***/ function(module, exports) {

	module.exports = function(module) {
		if(!module.webpackPolyfill) {
			module.deprecate = function() {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	}


/***/ },
/* 112 */
/***/ function(module, exports) {

	module.exports = '<div class="ui-poptip">    <div class="ui-poptip-shadow">    <div class="ui-poptip-container">        <div class="ui-poptip-arrow">            <em></em>            <span></span>        </div>        <div class="ui-poptip-content" data-role="content">        </div>    </div>    </div></div>'

/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(69);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/docs/widget.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/docs/widget.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(25);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-button-dropdown/1.4.0/index.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-button-dropdown/1.4.0/index.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(29);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-select/1.1.0/dist/select-debug.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-select/1.1.0/dist/select-debug.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(89);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-tab/1.1.0/index.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/alice-tab/1.1.0/index.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ },
/* 117 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(93);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/arale-dialog/1.4.0/src/dialog.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/arale-dialog/1.4.0/src/dialog.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(94);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(6)(content, {});
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		module.hot.accept("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/arale-tip/1.4.1/src/tip.css", function() {
			var newContent = require("!!/usr/local/lib/node_modules/spm/node_modules/_css-loader@0.19.0@css-loader/index.js!!/Users/afc163/Projects/aliceui.github.io/spm_modules/arale-tip/1.4.1/src/tip.css");
			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
			update(newContent);
		});
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

/***/ }
/******/ ]);
//# sourceMappingURL=bundle.js.map