/* Zepto v1.0-1-ga3cab6c - polyfill zepto detect event ajax form fx - zeptojs.com/license */

;(function(undefined){

if (String.prototype.trim === undefined) // fix for iOS 3.2

String.prototype.trim = function(){ return this.replace(/^\s+|\s+$/g, '') }

// For iOS 3.x

// from https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce

if (Array.prototype.reduce === undefined)

Array.prototype.reduce = function(fun){

if(this === void 0 || this === null) throw new TypeError()

var t = Object(this), len = t.length >>> 0, k = 0, accumulator

if(typeof fun != 'function') throw new TypeError()

if(len == 0 && arguments.length == 1) throw new TypeError()

if(arguments.length >= 2)

accumulator = arguments[1]

else

do{

if(k in t){

accumulator = t[k++]

break

}

if(++k >= len) throw new TypeError()

} while (true)

while (k < len){

if(k in t) accumulator = fun.call(undefined, accumulator, t[k], k, t)

k++

}

return accumulator

}

})()

var Zepto = (function() {

var undefined, key, $, classList, emptyArray = [], slice = emptyArray.slice, filter = emptyArray.filter,

document = window.document,

elementDisplay = {}, classCache = {},

getComputedStyle = document.defaultView.getComputedStyle,

cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 },

fragmentRE = /^\s*<(\w+|!)[^>]*>/,

tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,

rootNodeRE = /^(?:body|html)$/i,

// special attributes that should be get/set via method calls

methodAttributes = ['val', 'css', 'html', 'text', 'data', 'width', 'height', 'offset'],

adjacencyOperators = [ 'after', 'prepend', 'before', 'append' ],

table = document.createElement('table'),

tableRow = document.createElement('tr'),

containers = {

'tr': document.createElement('tbody'),

'tbody': table, 'thead': table, 'tfoot': table,

'td': tableRow, 'th': tableRow,

'*': document.createElement('div')

},

readyRE = /complete|loaded|interactive/,

classSelectorRE = /^\.([\w-]+)$/,

idSelectorRE = /^#([\w-]*)$/,

tagSelectorRE = /^[\w-]+$/,

class2type = {},

toString = class2type.toString,

zepto = {},

camelize, uniq,

tempParent = document.createElement('div')

zepto.matches = function(element, selector) {

if (!element || element.nodeType !== 1) return false

var matchesSelector = element.webkitMatchesSelector || element.mozMatchesSelector ||

element.oMatchesSelector || element.matchesSelector

if (matchesSelector) return matchesSelector.call(element, selector)

// fall back to performing a selector:

var match, parent = element.parentNode, temp = !parent

if (temp) (parent = tempParent).appendChild(element)

match = ~zepto.qsa(parent, selector).indexOf(element)

temp && tempParent.removeChild(element)

return match

}

function type(obj) {

return obj == null ? String(obj) :

class2type[toString.call(obj)] || "object"

}

function isFunction(value) { return type(value) == "function" }

function isWindow(obj) { return obj != null && obj == obj.window }

function isDocument(obj) { return obj != null && obj.nodeType == obj.DOCUMENT_NODE }

function isObject(obj) { return type(obj) == "object" }

function isPlainObject(obj) {

return isObject(obj) && !isWindow(obj) && obj.__proto__ == Object.prototype

}

function isArray(value) { return value instanceof Array }

function likeArray(obj) { return typeof obj.length == 'number' }

function compact(array) { return filter.call(array, function(item){ return item != null }) }

function flatten(array) { return array.length > 0 ? $.fn.concat.apply([], array) : array }

camelize = function(str){ return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) }

function dasherize(str) {

return str.replace(/::/g, '/')

.replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')

.replace(/([a-z\d])([A-Z])/g, '$1_$2')

.replace(/_/g, '-')

.toLowerCase()

}

uniq = function(array){ return filter.call(array, function(item, idx){ return array.indexOf(item) == idx }) }

function classRE(name) {

return name in classCache ?

classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)'))

}

function maybeAddPx(name, value) {

return (typeof value == "number" && !cssNumber[dasherize(name)]) ? value + "px" : value

}

function defaultDisplay(nodeName) {

var element, display

if (!elementDisplay[nodeName]) {

element = document.createElement(nodeName)

document.body.appendChild(element)

display = getComputedStyle(element, '').getPropertyValue("display")

element.parentNode.removeChild(element)

display == "none" && (display = "block")

elementDisplay[nodeName] = display

}

return elementDisplay[nodeName]

}

function children(element) {

return 'children' in element ?

slice.call(element.children) :

$.map(element.childNodes, function(node){ if (node.nodeType == 1) return node })

}

// `$.zepto.fragment` takes a html string and an optional tag name

// to generate DOM nodes nodes from the given html string.

// The generated DOM nodes are returned as an array.

// This function can be overriden in plugins for example to make

// it compatible with browsers that don't support the DOM fully.

zepto.fragment = function(html, name, properties) {

if (html.replace) html = html.replace(tagExpanderRE, "<$1></$2>")

if (name === undefined) name = fragmentRE.test(html) && RegExp.$1

if (!(name in containers)) name = '*'

var nodes, dom, container = containers[name]

container.innerHTML = '' + html

dom = $.each(slice.call(container.childNodes), function(){

container.removeChild(this)

})

if (isPlainObject(properties)) {

nodes = $(dom)

$.each(properties, function(key, value) {

if (methodAttributes.indexOf(key) > -1) nodes[key](value)

else nodes.attr(key, value)

})

}

return dom

}

// `$.zepto.Z` swaps out the prototype of the given `dom` array

// of nodes with `$.fn` and thus supplying all the Zepto functions

// to the array. Note that `__proto__` is not supported on Internet

// Explorer. This method can be overriden in plugins.

zepto.Z = function(dom, selector) {

dom = dom || []

dom.__proto__ = $.fn

dom.selector = selector || ''

return dom

}

// `$.zepto.isZ` should return `true` if the given object is a Zepto

// collection. This method can be overriden in plugins.

zepto.isZ = function(object) {

return object instanceof zepto.Z

}

// `$.zepto.init` is Zepto's counterpart to jQuery's `$.fn.init` and

// takes a CSS selector and an optional context (and handles various

// special cases).

// This method can be overriden in plugins.

zepto.init = function(selector, context) {

// If nothing given, return an empty Zepto collection

if (!selector) return zepto.Z()

// If a function is given, call it when the DOM is ready

else if (isFunction(selector)) return $(document).ready(selector)

// If a Zepto collection is given, juts return it

else if (zepto.isZ(selector)) return selector

else {

var dom

// normalize array if an array of nodes is given

if (isArray(selector)) dom = compact(selector)

// Wrap DOM nodes. If a plain object is given, duplicate it.

else if (isObject(selector))

dom = [isPlainObject(selector) ? $.extend({}, selector) : selector], selector = null

// If it's a html fragment, create nodes from it

else if (fragmentRE.test(selector))

dom = zepto.fragment(selector.trim(), RegExp.$1, context), selector = null

// If there's a context, create a collection on that context first, and select

// nodes from there

else if (context !== undefined) return $(context).find(selector)

// And last but no least, if it's a CSS selector, use it to select nodes.

else dom = zepto.qsa(document, selector)

// create a new Zepto collection from the nodes found

return zepto.Z(dom, selector)

}

}

// `$` will be the base `Zepto` object. When calling this

// function just call `$.zepto.init, which makes the implementation

// details of selecting nodes and creating Zepto collections

// patchable in plugins.

$ = function(selector, context){

return zepto.init(selector, context)

}

function extend(target, source, deep) {

for (key in source)

if (deep && (isPlainObject(source[key]) || isArray(source[key]))) {

if (isPlainObject(source[key]) && !isPlainObject(target[key]))

target[key] = {}

if (isArray(source[key]) && !isArray(target[key]))

target[key] = []

extend(target[key], source[key], deep)

}

else if (source[key] !== undefined) target[key] = source[key]

}

// Copy all but undefined properties from one or more

// objects to the `target` object.

$.extend = function(target){

var deep, args = slice.call(arguments, 1)

if (typeof target == 'boolean') {

deep = target

target = args.shift()

}

args.forEach(function(arg){ extend(target, arg, deep) })

return target

}

// `$.zepto.qsa` is Zepto's CSS selector implementation which

// uses `document.querySelectorAll` and optimizes for some special cases, like `#id`.

// This method can be overriden in plugins.

zepto.qsa = function(element, selector){

var found

return (isDocument(element) && idSelectorRE.test(selector)) ?

( (found = element.getElementById(RegExp.$1)) ? [found] : [] ) :

(element.nodeType !== 1 && element.nodeType !== 9) ? [] :

slice.call(

classSelectorRE.test(selector) ? element.getElementsByClassName(RegExp.$1) :

tagSelectorRE.test(selector) ? element.getElementsByTagName(selector) :

element.querySelectorAll(selector)

)

}

function filtered(nodes, selector) {

return selector === undefined ? $(nodes) : $(nodes).filter(selector)

}

$.contains = function(parent, node) {

return parent !== node && parent.contains(node)

}

function funcArg(context, arg, idx, payload) {

return isFunction(arg) ? arg.call(context, idx, payload) : arg

}

function setAttribute(node, name, value) {

value == null ? node.removeAttribute(name) : node.setAttribute(name, value)

}

// access className property while respecting SVGAnimatedString

function className(node, value){

var klass = node.className,

svg = klass && klass.baseVal !== undefined

if (value === undefined) return svg ? klass.baseVal : klass

svg ? (klass.baseVal = value) : (node.className = value)

}

// "true" => true

// "false" => false

// "null" => null

// "42" => 42

// "42.5" => 42.5

// JSON => parse if valid

// String => self

function deserializeValue(value) {

var num

try {

return value ?

value == "true" ||

( value == "false" ? false :

value == "null" ? null :

!isNaN(num = Number(value)) ? num :

/^[\[\{]/.test(value) ? $.parseJSON(value) :

value )

: value

} catch(e) {

return value

}

}

$.type = type

$.isFunction = isFunction

$.isWindow = isWindow

$.isArray = isArray

$.isPlainObject = isPlainObject

$.isEmptyObject = function(obj) {

var name

for (name in obj) return false

return true

}

$.inArray = function(elem, array, i){

return emptyArray.indexOf.call(array, elem, i)

}

$.camelCase = camelize

$.trim = function(str) { return str.trim() }

// plugin compatibility

$.uuid = 0

$.support = { }

$.expr = { }

$.map = function(elements, callback){

var value, values = [], i, key

if (likeArray(elements))

for (i = 0; i < elements.length; i++) {

value = callback(elements[i], i)

if (value != null) values.push(value)

}

else

for (key in elements) {

value = callback(elements[key], key)

if (value != null) values.push(value)

}

return flatten(values)

}

$.each = function(elements, callback){

var i, key

if (likeArray(elements)) {

for (i = 0; i < elements.length; i++)

if (callback.call(elements[i], i, elements[i]) === false) return elements

} else {

for (key in elements)

if (callback.call(elements[key], key, elements[key]) === false) return elements

}

return elements

}

$.grep = function(elements, callback){

return filter.call(elements, callback)

}

if (window.JSON) $.parseJSON = JSON.parse

// Populate the class2type map

$.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {

class2type[ "[object " + name + "]" ] = name.toLowerCase()

})

// Define methods that will be available on all

// Zepto collections

$.fn = {

// Because a collection acts like an array

// copy over these useful array functions.

forEach: emptyArray.forEach,

reduce: emptyArray.reduce,

push: emptyArray.push,

sort: emptyArray.sort,

indexOf: emptyArray.indexOf,

concat: emptyArray.concat,

// `map` and `slice` in the jQuery API work differently

// from their array counterparts

map: function(fn){

return $($.map(this, function(el, i){ return fn.call(el, i, el) }))

},

slice: function(){

return $(slice.apply(this, arguments))

},

ready: function(callback){

if (readyRE.test(document.readyState)) callback($)

else document.addEventListener('DOMContentLoaded', function(){ callback($) }, false)

return this

},

get: function(idx){

return idx === undefined ? slice.call(this) : this[idx >= 0 ? idx : idx + this.length]

},

toArray: function(){ return this.get() },

size: function(){

return this.length

},

remove: function(){

return this.each(function(){

if (this.parentNode != null)

this.parentNode.removeChild(this)

})

},

each: function(callback){

emptyArray.every.call(this, function(el, idx){

return callback.call(el, idx, el) !== false

})

return this

},

filter: function(selector){

if (isFunction(selector)) return this.not(this.not(selector))

return $(filter.call(this, function(element){

return zepto.matches(element, selector)

}))

},

add: function(selector,context){

return $(uniq(this.concat($(selector,context))))

},

is: function(selector){

return this.length > 0 && zepto.matches(this[0], selector)

},

not: function(selector){

var nodes=[]

if (isFunction(selector) && selector.call !== undefined)

this.each(function(idx){

if (!selector.call(this,idx)) nodes.push(this)

})

else {

var excludes = typeof selector == 'string' ? this.filter(selector) :

(likeArray(selector) && isFunction(selector.item)) ? slice.call(selector) : $(selector)

this.forEach(function(el){

if (excludes.indexOf(el) < 0) nodes.push(el)

})

}

return $(nodes)

},

has: function(selector){

return this.filter(function(){

return isObject(selector) ?

$.contains(this, selector) :

$(this).find(selector).size()

})

},

eq: function(idx){

return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1)

},

first: function(){

var el = this[0]

return el && !isObject(el) ? el : $(el)

},

last: function(){

var el = this[this.length - 1]

return el && !isObject(el) ? el : $(el)

},

find: function(selector){

var result, $this = this

if (typeof selector == 'object')

result = $(selector).filter(function(){

var node = this

return emptyArray.some.call($this, function(parent){

return $.contains(parent, node)

})

})

else if (this.length == 1) result = $(zepto.qsa(this[0], selector))

else result = this.map(function(){ return zepto.qsa(this, selector) })

return result

},

closest: function(selector, context){

var node = this[0], collection = false

if (typeof selector == 'object') collection = $(selector)

while (node && !(collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector)))

node = node !== context && !isDocument(node) && node.parentNode

return $(node)

},

parents: function(selector){

var ancestors = [], nodes = this

while (nodes.length > 0)

nodes = $.map(nodes, function(node){

if ((node = node.parentNode) && !isDocument(node) && ancestors.indexOf(node) < 0) {

ancestors.push(node)

return node

}

})

return filtered(ancestors, selector)

},

parent: function(selector){

return filtered(uniq(this.pluck('parentNode')), selector)

},

children: function(selector){

return filtered(this.map(function(){ return children(this) }), selector)

},

contents: function() {

return this.map(function() { return slice.call(this.childNodes) })

},

siblings: function(selector){

return filtered(this.map(function(i, el){

return filter.call(children(el.parentNode), function(child){ return child!==el })

}), selector)

},

empty: function(){

return this.each(function(){ this.innerHTML = '' })

},

// `pluck` is borrowed from Prototype.js

pluck: function(property){

return $.map(this, function(el){ return el[property] })

},

show: function(){

return this.each(function(){

this.style.display == "none" && (this.style.display = null)

if (getComputedStyle(this, '').getPropertyValue("display") == "none")

this.style.display = defaultDisplay(this.nodeName)

})

},

replaceWith: function(newContent){

return this.before(newContent).remove()

},

wrap: function(structure){

var func = isFunction(structure)

if (this[0] && !func)

var dom = $(structure).get(0),

clone = dom.parentNode || this.length > 1

return this.each(function(index){

$(this).wrapAll(

func ? structure.call(this, index) :

clone ? dom.cloneNode(true) : dom

)

})

},

wrapAll: function(structure){

if (this[0]) {

$(this[0]).before(structure = $(structure))

var children

// drill down to the inmost element

while ((children = structure.children()).length) structure = children.first()

$(structure).append(this)

}

return this

},

wrapInner: function(structure){

var func = isFunction(structure)

return this.each(function(index){

var self = $(this), contents = self.contents(),

dom = func ? structure.call(this, index) : structure

contents.length ? contents.wrapAll(dom) : self.append(dom)

})

},

unwrap: function(){

this.parent().each(function(){

$(this).replaceWith($(this).children())

})

return this

},

clone: function(){

return this.map(function(){ return this.cloneNode(true) })

},

hide: function(){

return this.css("display", "none")

},

toggle: function(setting){

return this.each(function(){

var el = $(this)

;(setting === undefined ? el.css("display") == "none" : setting) ? el.show() : el.hide()

})

},

prev: function(selector){ return $(this.pluck('previousElementSibling')).filter(selector || '*') },

next: function(selector){ return $(this.pluck('nextElementSibling')).filter(selector || '*') },

html: function(html){

return html === undefined ?

(this.length > 0 ? this[0].innerHTML : null) :

this.each(function(idx){

var originHtml = this.innerHTML

$(this).empty().append( funcArg(this, html, idx, originHtml) )

})

},

text: function(text){

return text === undefined ?

(this.length > 0 ? this[0].textContent : null) :

this.each(function(){ this.textContent = text })

},

attr: function(name, value){

var result

return (typeof name == 'string' && value === undefined) ?

(this.length == 0 || this[0].nodeType !== 1 ? undefined :

(name == 'value' && this[0].nodeName == 'INPUT') ? this.val() :

(!(result = this[0].getAttribute(name)) && name in this[0]) ? this[0][name] : result

) :

this.each(function(idx){

if (this.nodeType !== 1) return

if (isObject(name)) for (key in name) setAttribute(this, key, name[key])

else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name)))

})

},

removeAttr: function(name){

return this.each(function(){ this.nodeType === 1 && setAttribute(this, name) })

},

prop: function(name, value){

return (value === undefined) ?

(this[0] && this[0][name]) :

this.each(function(idx){

this[name] = funcArg(this, value, idx, this[name])

})

},

data: function(name, value){

var data = this.attr('data-' + dasherize(name), value)

return data !== null ? deserializeValue(data) : undefined

},

val: function(value){

return (value === undefined) ?

(this[0] && (this[0].multiple ?

$(this[0]).find('option').filter(function(o){ return this.selected }).pluck('value') :

this[0].value)

) :

this.each(function(idx){

this.value = funcArg(this, value, idx, this.value)

})

},

offset: function(coordinates){

if (coordinates) return this.each(function(index){

var $this = $(this),

coords = funcArg(this, coordinates, index, $this.offset()),

parentOffset = $this.offsetParent().offset(),

props = {

top: coords.top - parentOffset.top,

left: coords.left - parentOffset.left

}

if ($this.css('position') == 'static') props['position'] = 'relative'

$this.css(props)

})

if (this.length==0) return null

var obj = this[0].getBoundingClientRect()

return {

left: obj.left + window.pageXOffset,

top: obj.top + window.pageYOffset,

width: Math.round(obj.width),

height: Math.round(obj.height)

}

},

css: function(property, value){

if (arguments.length < 2 && typeof property == 'string')

return this[0] && (this[0].style[camelize(property)] || getComputedStyle(this[0], '').getPropertyValue(property))

var css = ''

if (type(property) == 'string') {

if (!value && value !== 0)

this.each(function(){ this.style.removeProperty(dasherize(property)) })

else

css = dasherize(property) + ":" + maybeAddPx(property, value)

} else {

for (key in property)

if (!property[key] && property[key] !== 0)

this.each(function(){ this.style.removeProperty(dasherize(key)) })

else

css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';'

}

return this.each(function(){ this.style.cssText += ';' + css })

},

index: function(element){

return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0])

},

hasClass: function(name){

return emptyArray.some.call(this, function(el){

return this.test(className(el))

}, classRE(name))

},

addClass: function(name){

return this.each(function(idx){

classList = []

var cls = className(this), newName = funcArg(this, name, idx, cls)

newName.split(/\s+/g).forEach(function(klass){

if (!$(this).hasClass(klass)) classList.push(klass)

}, this)

classList.length && className(this, cls + (cls ? " " : "") + classList.join(" "))

})

},

removeClass: function(name){

return this.each(function(idx){

if (name === undefined) return className(this, '')

classList = className(this)

funcArg(this, name, idx, classList).split(/\s+/g).forEach(function(klass){

classList = classList.replace(classRE(klass), " ")

})

className(this, classList.trim())

})

},

toggleClass: function(name, when){

return this.each(function(idx){

var $this = $(this), names = funcArg(this, name, idx, className(this))

names.split(/\s+/g).forEach(function(klass){

(when === undefined ? !$this.hasClass(klass) : when) ?

$this.addClass(klass) : $this.removeClass(klass)

})

})

},

scrollTop: function(){

if (!this.length) return

return ('scrollTop' in this[0]) ? this[0].scrollTop : this[0].scrollY

},

position: function() {

if (!this.length) return

var elem = this[0],

// Get *real* offsetParent

offsetParent = this.offsetParent(),

// Get correct offsets

offset = this.offset(),

parentOffset = rootNodeRE.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( $(elem).css('margin-top') ) || 0

offset.left -= parseFloat( $(elem).css('margin-left') ) || 0

// Add offsetParent borders

parentOffset.top += parseFloat( $(offsetParent[0]).css('border-top-width') ) || 0

parentOffset.left += parseFloat( $(offsetParent[0]).css('border-left-width') ) || 0

// Subtract the two offsets

return {

top: offset.top - parentOffset.top,

left: offset.left - parentOffset.left

}

},

offsetParent: function() {

return this.map(function(){

var parent = this.offsetParent || document.body

while (parent && !rootNodeRE.test(parent.nodeName) && $(parent).css("position") == "static")

parent = parent.offsetParent

return parent

})

}

}

// for now

$.fn.detach = $.fn.remove

// Generate the `width` and `height` functions

;['width', 'height'].forEach(function(dimension){

$.fn[dimension] = function(value){

var offset, el = this[0],

Dimension = dimension.replace(/./, function(m){ return m[0].toUpperCase() })

if (value === undefined) return isWindow(el) ? el['inner' + Dimension] :

isDocument(el) ? el.documentElement['offset' + Dimension] :

(offset = this.offset()) && offset[dimension]

else return this.each(function(idx){

el = $(this)

el.css(dimension, funcArg(this, value, idx, el[dimension]()))

})

}

})

function traverseNode(node, fun) {

fun(node)

for (var key in node.childNodes) traverseNode(node.childNodes[key], fun)

}

// Generate the `after`, `prepend`, `before`, `append`,

// `insertAfter`, `insertBefore`, `appendTo`, and `prependTo` methods.

adjacencyOperators.forEach(function(operator, operatorIndex) {

var inside = operatorIndex % 2 //=> prepend, append

$.fn[operator] = function(){

// arguments can be nodes, arrays of nodes, Zepto objects and HTML strings

var argType, nodes = $.map(arguments, function(arg) {

argType = type(arg)

return argType == "object" || argType == "array" || arg == null ?

arg : zepto.fragment(arg)

}),

parent, copyByClone = this.length > 1

if (nodes.length < 1) return this

return this.each(function(_, target){

parent = inside ? target : target.parentNode

// convert all methods to a "before" operation

target = operatorIndex == 0 ? target.nextSibling :

operatorIndex == 1 ? target.firstChild :

operatorIndex == 2 ? target :

null

nodes.forEach(function(node){

if (copyByClone) node = node.cloneNode(true)

else if (!parent) return $(node).remove()

traverseNode(parent.insertBefore(node, target), function(el){

if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&

(!el.type || el.type === 'text/javascript') && !el.src)

window['eval'].call(window, el.innerHTML)

})

})

})

}

// after => insertAfter

// prepend => prependTo

// before => insertBefore

// append => appendTo

$.fn[inside ? operator+'To' : 'insert'+(operatorIndex ? 'Before' : 'After')] = function(html){

$(html)[operator](this)

return this

}

})

zepto.Z.prototype = $.fn

// Export internal API functions in the `$.zepto` namespace

zepto.uniq = uniq

zepto.deserializeValue = deserializeValue

$.zepto = zepto

return $

})()

window.Zepto = Zepto

'$' in window || (window.$ = Zepto)

;(function($){

function detect(ua){

var os = this.os = {}, browser = this.browser = {},

webkit = ua.match(/WebKit\/([\d.]+)/),

android = ua.match(/(Android)\s+([\d.]+)/),

ipad = ua.match(/(iPad).*OS\s([\d_]+)/),

iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/),

webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/),

touchpad = webos && ua.match(/TouchPad/),

kindle = ua.match(/Kindle\/([\d.]+)/),

silk = ua.match(/Silk\/([\d._]+)/),

blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/),

bb10 = ua.match(/(BB10).*Version\/([\d.]+)/),

rimtabletos = ua.match(/(RIM\sTablet\sOS)\s([\d.]+)/),

playbook = ua.match(/PlayBook/),

chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/),

firefox = ua.match(/Firefox\/([\d.]+)/)

// Todo: clean this up with a better OS/browser seperation:

// - discern (more) between multiple browsers on android

// - decide if kindle fire in silk mode is android or not

// - Firefox on Android doesn't specify the Android version

// - possibly devide in os, device and browser hashes

if (browser.webkit = !!webkit) browser.version = webkit[1]

if (android) os.android = true, os.version = android[2]

if (iphone) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.')

if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.')

if (webos) os.webos = true, os.version = webos[2]

if (touchpad) os.touchpad = true

if (blackberry) os.blackberry = true, os.version = blackberry[2]

if (bb10) os.bb10 = true, os.version = bb10[2]

if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2]

if (playbook) browser.playbook = true

if (kindle) os.kindle = true, os.version = kindle[1]

if (silk) browser.silk = true, browser.version = silk[1]

if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true

if (chrome) browser.chrome = true, browser.version = chrome[1]

if (firefox) browser.firefox = true, browser.version = firefox[1]

os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) || (firefox && ua.match(/Tablet/)))

os.phone = !!(!os.tablet && (android || iphone || webos || blackberry || bb10 ||

(chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\/([\d.]+)/)) || (firefox && ua.match(/Mobile/))))

}

detect.call($, navigator.userAgent)

// make available to unit tests

$.__detect = detect

})(Zepto)

;(function($){

var $$ = $.zepto.qsa, handlers = {}, _zid = 1, specialEvents={},

hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' }

specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents'

function zid(element) {

return element._zid || (element._zid = _zid++)

}

function findHandlers(element, event, fn, selector) {

event = parse(event)

if (event.ns) var matcher = matcherFor(event.ns)

return (handlers[zid(element)] || []).filter(function(handler) {

return handler

&& (!event.e || handler.e == event.e)

&& (!event.ns || matcher.test(handler.ns))

&& (!fn || zid(handler.fn) === zid(fn))

&& (!selector || handler.sel == selector)

})

}

function parse(event) {

var parts = ('' + event).split('.')

return {e: parts[0], ns: parts.slice(1).sort().join(' ')}

}

function matcherFor(ns) {

return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)')

}

function eachEvent(events, fn, iterator){

if ($.type(events) != "string") $.each(events, iterator)

else events.split(/\s/).forEach(function(type){ iterator(type, fn) })

}

function eventCapture(handler, captureSetting) {

return handler.del &&

(handler.e == 'focus' || handler.e == 'blur') ||

!!captureSetting

}

function realEvent(type) {

return hover[type] || type

}

function add(element, events, fn, selector, getDelegate, capture){

var id = zid(element), set = (handlers[id] || (handlers[id] = []))

eachEvent(events, fn, function(event, fn){

var handler = parse(event)

handler.fn = fn

handler.sel = selector

// emulate mouseenter, mouseleave

if (handler.e in hover) fn = function(e){

var related = e.relatedTarget

if (!related || (related !== this && !$.contains(this, related)))

return handler.fn.apply(this, arguments)

}

handler.del = getDelegate && getDelegate(fn, event)

var callback = handler.del || fn

handler.proxy = function (e) {

var result = callback.apply(element, [e].concat(e.data))

if (result === false) e.preventDefault(), e.stopPropagation()

return result

}

handler.i = set.length

set.push(handler)

element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))

})

}

function remove(element, events, fn, selector, capture){

var id = zid(element)

eachEvent(events || '', fn, function(event, fn){

findHandlers(element, event, fn, selector).forEach(function(handler){

delete handlers[id][handler.i]

element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))

})

})

}

$.event = { add: add, remove: remove }

$.proxy = function(fn, context) {

if ($.isFunction(fn)) {

var proxyFn = function(){ return fn.apply(context, arguments) }

proxyFn._zid = zid(fn)

return proxyFn

} else if (typeof context == 'string') {

return $.proxy(fn[context], fn)

} else {

throw new TypeError("expected function")

}

}

$.fn.bind = function(event, callback){

return this.each(function(){

add(this, event, callback)

})

}

$.fn.unbind = function(event, callback){

return this.each(function(){

remove(this, event, callback)

})

}

$.fn.one = function(event, callback){

return this.each(function(i, element){

add(this, event, callback, null, function(fn, type){

return function(){

var result = fn.apply(element, arguments)

remove(element, type, fn)

return result

}

})

})

}

var returnTrue = function(){return true},

returnFalse = function(){return false},

ignoreProperties = /^([A-Z]|layer[XY]$)/,

eventMethods = {

preventDefault: 'isDefaultPrevented',

stopImmediatePropagation: 'isImmediatePropagationStopped',

stopPropagation: 'isPropagationStopped'

}

function createProxy(event) {

var key, proxy = { originalEvent: event }

for (key in event)

if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key]