Repository: madrobby/zepto
Branch: main
Commit: e1ecb3d70b2a
Files: 68
Total size: 442.4 KB

Directory structure:
gitextract_k6qzt7fr/

├── .gitignore
├── .npmignore
├── .travis.yml
├── CONTRIBUTING.md
├── MIT-LICENSE
├── README.md
├── examples/
│   ├── anim.html
│   ├── iphone/
│   │   ├── index.html
│   │   └── iphone.css
│   ├── load_jquery_on_ie.html
│   ├── snow/
│   │   └── index.html
│   └── touch_events.html
├── make
├── package.json
├── script/
│   ├── bootstrap
│   ├── guard
│   ├── lint
│   └── test
├── src/
│   ├── ajax.js
│   ├── amd_layout.js
│   ├── assets.js
│   ├── callbacks.js
│   ├── data.js
│   ├── deferred.js
│   ├── detect.js
│   ├── event.js
│   ├── form.js
│   ├── fx.js
│   ├── fx_methods.js
│   ├── gesture.js
│   ├── ie.js
│   ├── ios3.js
│   ├── selector.js
│   ├── stack.js
│   ├── touch.js
│   └── zepto.js
├── test/
│   ├── ajax.html
│   ├── ajax_deferred.html
│   ├── callbacks.html
│   ├── data.html
│   ├── deferred.html
│   ├── detect.html
│   ├── event.html
│   ├── evidence_runner.js
│   ├── fixtures/
│   │   ├── ajax_load_javascript.js
│   │   ├── ajax_load_selector.html
│   │   ├── ajax_load_selector_javascript.html
│   │   ├── ajax_load_simple.html
│   │   ├── iframe_document.html
│   │   └── zepto.json
│   ├── form.html
│   ├── functional/
│   │   ├── assets.html
│   │   ├── fx.html
│   │   ├── gesture.html
│   │   ├── touch.html
│   │   └── touchcancel.html
│   ├── fx.html
│   ├── ie.html
│   ├── index.html
│   ├── ios3.html
│   ├── runner.js
│   ├── selector.html
│   ├── server.coffee
│   ├── stack.html
│   ├── test.css
│   ├── touch.html
│   └── zepto.html
└── vendor/
    └── evidence.js

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
.DS_Store
dist/
dist/zepto.min.js
dist/zepto.js
pkg
*.swp
docs/*
.jhw-cache
.rbenv-version
public
node_modules
temp/
npm-debug.log

================================================
FILE: .npmignore
================================================
*
!README.md
!MIT-LICENSE
!dist/zepto.js
!dist/zepto.min.js
!src/*.js
src/amd_layout.js


================================================
FILE: .travis.yml
================================================
language: node_js

node_js: '0.10'

sudo: false

script: script/test

notifications:
  campfire:
    template: '%{message} [%{branch}] %{repository}/%{commit} %{author} %{build_url}'
    rooms:
      secure: VR6rWk0YhezBWnD8jPjSD8h/Q83S3NT0F34Au1vswt+/+Ku19S8X44vGVUG+NYdYyhg7uOqUaPN1Jr3KCpdcXgHEpUYiyBGJ8ebltavcjeHYWqK6ghcqgSnbDkifuC7Eu/9LcrOMOXgt+zkXjiVXW3+zyGVDcrs4cQ2vGY2DTYA=


================================================
FILE: CONTRIBUTING.md
================================================
## Contributing to Zepto

**Thanks for helping out!**

In order for your code to make it in, several conditions must be met:

* It's more likely your pull request will make it in if you adhere to **Zepto's
  project goals**. Be sure to read the README in its entirety before setting out
  to code.
* Please talk to the maintainers (@madrobby and @mislav) first if you want
  to write a plugin, those are better kept in their own repositories.
* Fix only ONE thing or have only ONE feature in your pull request. 
  If you have multiple unrelated code updates, please submit a separate pull request for each one.
* **Your pull request must be written in English and be accompanied by a
  detailed description**, ideally something we can use as documentation.
  If you're not fluent in English, try your best and let us know so we'll help!
* Changes to jQuery-based API methods **must match their jQuery counterparts**.
* Please **do not just copy code from jQuery**. Zepto strives for API compatibility,
  but has different goals for code style and size and target platforms.
  In case you do copy code, you must clearly indicate the origin of the code, and
  which license applies to it. However, it is likely your patch will be denied.
* **All code must have tests, and all tests must pass.** See the README on running the test suite.
* Please **also test manually** on as many target platforms you have access to,
  but at least on latest Chrome (desktop) and Firefox (desktop).
  See http://zeptojs.com for a full list of platforms.
* It's required that you follow Zepto's **code style guidelines** (see below)

Whew, now that we have that out of the way thanks again!

## Code style guidelines

* Two spaces "soft tabs" indentation
* Remove any trailing whitespace from the end of lines
* `function name() { }` for named functions
* `function(){ }` for anonymous functions
* No curly braces for single-line control flow statements such as `if` & friends
* Don't write [semicolons that are optional][optional]
* Put a single semicolon _before_ statements that start with `(` or `[`
  (see above article as for why it's needed)
* Use long, descriptive variable and method names
* Use blank lines to separate "paragraphs" of code for readability
* Use comments to describe non-obvious code behavior


  [optional]: http://mislav.uniqpath.com/2010/05/semicolons/


================================================
FILE: MIT-LICENSE
================================================
Copyright (c) 2010-2025 Thomas Fuchs
http://zeptojs.com/

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


================================================
FILE: README.md
================================================
# Zepto.js – a minimalist JavaScript library

Zepto is a minimalist JavaScript library for modern browsers with a
largely jQuery-compatible API. If you use jQuery, you already know how to use Zepto.

See [zeptojs.com][] for an extended introduction, downloads
and documentation.

Zepto.js is licensed under the terms of the MIT License.

Want to give us money or a tip? Don't.
Instead please donate to [charity: water](http://charitywater.org/).

## Building

[![Build Status](https://secure.travis-ci.org/madrobby/zepto.svg?branch=master)](http://travis-ci.org/madrobby/zepto)

The official site offers a download of the default distribution of Zepto. This
is good for starting out. However, at some point you might want to add some
optional modules and remove some of the default ones you don't need, to keep the
size at a minimum. That's when you need to check out Zepto's source code and use
the build commands.

You will need Node.js installed on your system.

~~~ sh
$ npm install
$ npm run-script dist

# do a custom build
$ MODULES="zepto event data" npm run-script dist

# on Windows
c:\zepto> SET MODULES=zepto event data
c:\zepto> npm run-script dist
~~~

The resulting files are:

1. `dist/zepto.js`
2. `dist/zepto.min.js`

If you install CoffeeScript globally, you can run `make` directly:

~~~ sh
# one-time operation
$ npm install coffee-script --global

$ coffee make dist
$ MODULES="zepto event data ..." ./make dist

# on Windows
c:\zepto> SET MODULES=zepto event data
c:\zepto> coffee make dist
~~~

## Zepto modules

Zepto modules are individual files in the "src/" directory.

<table>
<thead><tr>
  <th>module</th> <th>default</th> <th>description</th>
</tr></thead>
<tbody>
  <tr>
    <th><a href="src/zepto.js#files">zepto</a></th>
    <td>✔</td>
    <td>Core module; contains most methods</td>
  </tr>
  <tr>
    <th><a href="src/event.js#files">event</a></th>
    <td>✔</td>
    <td>Event handling via <code>on()</code> &amp; <code>off()</code></td>
  </tr>
  <tr>
    <th><a href="src/ajax.js#files">ajax</a></th>
    <td>✔</td>
    <td>XMLHttpRequest and JSONP functionality</td>
  </tr>
  <tr>
    <th><a href="src/form.js#files">form</a></th>
    <td>✔</td>
    <td>Serialize &amp; submit web forms</td>
  </tr>
  <tr>
    <th><a href="src/ie.js#files">ie</a></th>
    <td>✔</td>
    <td>Support for Internet Explorer 10+ on the desktop and Windows Phone 8</td>
  </tr>
  <tr>
    <th><a href="src/detect.js#files">detect</a></th>
    <td></td>
    <td>Provides <code>$.os</code> and <code>$.browser</code> information</td>
  </tr>
  <tr>
    <th><a href="src/fx.js#files">fx</a></th>
    <td></td>
    <td>The <code>animate()</code> method</td>
  </tr>
  <tr>
    <th><a href="src/fx_methods.js#files">fx_methods</a></th>
    <td></td>
    <td>
      Animated <code>show</code>, <code>hide</code>, <code>toggle</code>,
      and <code>fade*()</code> methods.
    </td>
  </tr>
  <tr>
    <th><a href="src/assets.js#files">assets</a></th>
    <td></td>
    <td>
      Experimental support for cleaning up iOS memory after removing
      image elements from the DOM.
    </td>
  </tr>
  <tr>
    <th><a href="src/data.js#files">data</a></th>
    <td></td>
    <td>
      A full-blown <code>data()</code> method, capable of storing arbitrary
      objects in memory.
    </td>
  </tr>
  <tr>
    <th><a href="src/deferred.js#files">deferred</a></th>
    <td></td>
    <td>
      Provides <code>$.Deferred</code> promises API.
      Depends on the "callbacks" module.
    </td>
  </tr>
  <tr>
    <th><a href="src/callbacks.js#files">callbacks</a></th>
    <td></td>
    <td>
      Provides <code>$.Callbacks</code> for use in "deferred" module.
    </td>
  </tr>
  <tr>
    <th><a href="src/selector.js#files">selector</a></th>
    <td></td>
    <td>
      Experimental <a href="http://api.jquery.com/category/selectors/jquery-selector-extensions/">jQuery
      CSS extensions</a> support for functionality such as <code>$('div:first')</code> and
      <code>el.is(':visible')</code>.
    </td>
  </tr>
  <tr>
    <th><a href="src/touch.js#files">touch</a></th>
    <td></td>
    <td>
      Fires tap– and swipe–related events on touch devices. This works with both
      `touch` (iOS, Android) and `pointer` events (Windows Phone).
    </td>
  </tr>
  <tr>
    <th><a href="src/gesture.js#files">gesture</a></th>
    <td></td>
    <td>Fires pinch gesture events on touch devices</td>
  </tr>
  <tr>
    <th><a href="src/stack.js#files">stack</a></th>
    <td></td>
    <td>Provides <code>andSelf</code> &amp; <code>end()</code> chaining methods</td>
  </tr>
  <tr>
    <th><a href="src/ios3.js#files">ios3</a></th>
    <td></td>
    <td>
      String.prototype.trim and Array.prototype.reduce methods
      (if they are missing) for compatibility with iOS 3.x.
    </td>
  </tr>
</tbody>
</table>

## Contributing

Please read our [contribution guidelines](https://github.com/madrobby/zepto/blob/master/CONTRIBUTING.md)
for information on how to contribute.

Get in touch:

* @[zeptojs](http://twitter.com/zeptojs)

### Write documentation

Zepto docs are written in Markdown and live in the ["gh-pages" branch][docs].
They are published on [zeptojs.com][zeptojs.com].

You can use GitHub's web interface to make quick changes to documentation for
specific Zepto features
([example: ajaxSettings](https://github.com/madrobby/zepto/blob/gh-pages/ajax/_posts/1900-01-01-Z-ajaxSettings.md)).
This will submit a pull request to us that we can review.

### Report a bug

1. Check if the bug is already fixed in the master branch since the last release.
2. Check [existing issues][issues]. Open a new one, including exact browser &
   platform information. For better formatting of your report, see
   [GitHub-flavored Markdown][mkd].

### Running tests

You will need to install [PhantomJS][phantomjs]. On OS X, that's easy:

~~~ sh
$ brew install phantomjs
~~~

To run the automated tests:

~~~ sh
$ npm test
~~~

To run a test server, which you can hit with your browsers and devices:

~~~ sh
$ npm start
~~~

Go to `http://your-ip-address:3000/` on your browser and follow the
instructions. For your convenience test failures and exceptions will be
reported to the the console you started the test server in (as well as
the browser console if available).

  [zeptojs.com]: http://zeptojs.com
  [issues]: https://github.com/madrobby/zepto/issues
  [docs]: https://github.com/madrobby/zepto/tree/gh-pages#readme
  [mkd]: https://help.github.com/articles/creating-and-highlighting-code-blocks/
  [evidence.js]: https://github.com/tobie/Evidence
  [phantomjs]: http://phantomjs.org/download.html


================================================
FILE: examples/anim.html
================================================
<div style="width:100px;height:100px;border:1px solid black">HELLO WORLD</div>

<script src="../src/zepto.js"></script>
<script src="../src/event.js"></script>
<script src="../src/fx.js"></script>

<script>
  $('div').anim({ rotate: '720deg', opacity: .5 }, 2, 'ease-out')
</script>


================================================
FILE: examples/iphone/index.html
================================================
<!DOCTYPE html>
<html>
    <head>
      <title>iPhone.Zepto</title>
      <link href="iphone.css" media="screen" rel="stylesheet" type="text/css" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0"/>
      <meta name="apple-mobile-web-app-capable" content="yes" />
      <meta name="format-detection" content="telephone=no" />
    </head>
    <body>
      <section id="menu">
        <div class="toolbar">
          <h1>Title</h1>
        </div>
        <ul class="menu">
          <li class="arrow"><a href="#menu_1">Menu 1</a></li>
          <li>Menu 1</li>
          <li>Menu 1</li>
          <li>Menu 1</li>
          <li>Menu 1</li>
        </ul>
      </section>
      <section id="menu_1">
        <div class="toolbar">
          <h1>Menu 1</h1>
        </div>
        <ul class="menu">
          <li>SubMenu 1</li>
          <li>SubMenu 2</li>
        </ul>
      </section>
      <script src="../../src/zepto.js"></script>
      <script src="../../src/event.js"></script>
      <script src="../../src/touch.js"></script>
      <script>
        $(document).ready(function(){
          var activate = ('createTouch' in document) ? 'touchstart' : 'click'

          $("body > section").first().addClass("current")

          $("a.back").live(activate, function(event) {
            var current = $(this).attr("href")
            $(".current").removeClass("current").addClass("reverse")
            $(current).addClass("current")
          })

          $(".menu a[href]").live(activate, function(event) {
            var link = $(this), section = link.closest('section'),
              prev_element = "#"+(section.removeClass("current").addClass("reverse").attr("id"))
            $(link.attr("href")).addClass("current")
            $(".current .back").remove()
            $(".current .toolbar").prepend("<a href=\""+prev_element+"\" class=\"back\">Back</a>")
          })
        })
      </script>
    </body>
</html>


================================================
FILE: examples/iphone/iphone.css
================================================
* {
  margin: 0px;
  padding: 0px;
}
.toolbar {
  -webkit-box-sizing: border-box;
  background: #6D84A2 url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAArCAIAAAA2QHWOAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAEpJREFUeNpNjCEOgEAQA5v9/9eQaAQCd57L0WXTDSmimXZEse1HnNcIIINZYTPVv7Ac4/EWe7OTsC/ec+nDgcj/dpcH7EXt8up4AfRWcOjLIqWFAAAAAElFTkSuQmCC) repeat-x;
  border-bottom: 1px solid #2D3642;
  height: 45px;
  padding: 10px;
  position: relative;
}
body {
  -webkit-perspective: 800;
  -webkit-text-size-adjust: none;
  -webkit-transform-style: preserve-3d;
  -webkit-user-select: none;
  font-family: Helvetica;
  overflow-x: hidden;
  height: 100%;
  width: 100%;
}

body > section {
  background: #C5CCD3 url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAABCAIAAACdaSOZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABdJREFUeNpiPHrmCgMC/GNjYwNSAAEGADdNA3dnzPlQAAAAAElFTkSuQmCC);
  display: block;
  left: 0px;
  position: absolute;
  width: 100%;
  -webkit-transform: translate3d(100%,0%,0%);
  opacity: 0;
  -webkit-transition: all 0.25s ease-in-out;
  -webkit-transform-style: preserve-3d;
  z-index: -10;
}

.reverse {
  -webkit-transform: translate3d(-100%, 0%, 0%);
  opacity: 0;
}

.current {
  -webkit-transform: translate3d(0%,0%, 0%);
  opacity: 1;
  z-index: 1;
}
h1, h2 {
  color: #4C566C;
  font: normal normal bold 18px/normal Helvetica;
  margin: 10px 20px 6px;
  text-shadow: rgba(255, 255, 255, 0.19)
}
body.landscape .toolbar > h1 {
  margin-left: -125px;
  width: 250px;
}

.toolbar > h1 {
  color: white;
  font-size: 20px;
  font-weight: bold;
  height: 40px;
  left: 50%;
  line-height: 1em;
  margin: 1px 0px 0px -75px;
  overflow: hidden;
  position: absolute;
  text-align: center;
  text-overflow: ellipsis;
  text-shadow: rgba(0, 0, 0, 0.398438) 0px -1px 0px;
  top: 10px;
  white-space: nowrap;
  width: 150px;
}

ul {
  background: white;
  border: 1px solid #B4B4B4;
  border-bottom-left-radius: 8px 8px;
  border-bottom-right-radius: 8px 8px;
  border-top-left-radius: 8px 8px;
  border-top-right-radius: 8px 8px;
  color: black;
  font: normal normal bold 17px/normal Helvetica;
  margin: 15px 10px 17px;
  padding: 0px;
}

ul li {
  color: black;
  font-size: 14px;
  border-top: 1px solid #B4B4B4;
  color: #666;
  list-style-type: none;
  padding: 10px;
}

li:first-child, li:first-child a {
  border-top: 0px;
  border-top-left-radius: 8px 8px;
  border-top-right-radius: 8px 8px;
}

ul li.arrow {
  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAUCAYAAAB4d5a9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAKVJREFUeNpi/P//PwOtARMDHcDwsYQFRJSXl8P4dVC6CZvizs5O8i1BsqARid9Ei+BiQ2KDLKumhSU1QNyKxG+hlkXoEQ+yqAPNogpapK5KNIvaKbUIVxKeAsTvkPg5QCxETUukgfgAkqFPgdgBzVKKLIFZoIJmwR1qBRdNLEC2BJQpV9LCAmRL/gBxAtRwqlqAXqzcgRrOQE0LQIBxtNIiBQAEGAA7xCa2yF9zEgAAAABJRU5ErkJggg==);
  background-position: 100% 50%;
  background-repeat: no-repeat;
}

body > .current {
  display: block !important;
}

body.landscape > * {
  min-height: 320px;
}


ul li a, li.img a + a {
  color: black;
  display: block;
  margin: -10px;
  overflow: hidden;
  padding: 12px 10px;
  text-decoration: none;
  text-overflow: ellipsis;
  white-space: nowrap;
}


.button, .back, .cancel, .add {
-webkit-border-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAeCAIAAACqmwlGAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAatJREFUeNqVlMtKw0AUhqfJSRpTk5Za1FAvxS6sgrVeFrpQdOcT+IpuBVHcuVBQpCDYjeAdkSpavDTGNJkz43FpFZz8DISZ+b75J5tJbWwfMsZuby7rh/vN5v1H+539TMZxPa84v7g0WirTFISQR/t7jdOTcqVaGp+ze50uIfDbL62H3a3NqerMwtIqXF9dnF+dL6+t9/S6hmFqut4luHns80aKpcrxwY43PKK7+f6J2ZVcYTCl6ZIxKuwatEhbpmU72UKjfgCakXFz/TwW7L8QlgIbTNtBwVAgU0g644IGZoycqYVgQGRRLBQFggEpHJUFBI4iUhYIBhSSPooCwUB0zEWiBsERlRsECJSIUlEgOHmDH3TM909FgWBgqe8oCgRrLGGADlcvIDB5A2nfQ7kD6D5J/jn5lZILBoAUQgWVUgDoWi5r8zhUEXgU5nOOVp0sB+0W+f8WEDY9MabpYNUqQ29Pd1Hoi79eA1qkLQIIY5CGIOwUvYHBQr5xdvn4/BSGnS7BstIDhexUbVo3jNarD1Ky5xfftszF+WqPZcKvp5IjfoYRoYHv0/QLHvXjAb8xkEMAAAAASUVORK5CYII=) 0 5 0 5 stretch stretch;
background: none;
border-width: 0px 5px;
color: white;
font-family: inherit;
font-size: 12px;
font-weight: bold;
height: 30px;
line-height: 30px;
margin: 0px;
overflow: ;
padding: 0px 3px;
position: absolute;
right: 6px;
text-decoration: none;
text-overflow: ellipsis;
text-shadow: rgba(0, 0, 0, 0.496094) 0px -1px 0px;
top: 8px;
white-space: nowrap;
width: auto;
}

.back {
  -webkit-border-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACsAAAAeCAIAAAA6iHCJAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAArFJREFUeNrF0mtPE2EQBeB5t9vSRqEUKiAFkasggmC5x3CRECHx8sH/qMHEoKkiMUQTNJIIaAjeiFGUcEsotN22u9vtOzMKogYL39rlyfkBk3NG3HsyC8dLJhOzM8+/fvkcjexAtghRXVN/dXCkvOIcAKhEDMdY+7ESejgeqKpv7x3J9/ogS5hoc33l0YPxju6+YFefSkRwlI311cnQRM/gbd+ZUpfb43CokD2nCv2lFbVvZib9JaUqMUEGTYtNPZ7oHLpZXBJQFIUYSCJkj3A4830lrd3Di2/nVcxYwTSMift3m4LXCovKCYGQIDe8vrJveNQfTE+Fys9f8pdVSSTILeFyF/z/B8uflnSLG+qakRlRQo45XO5DHejJxOtXLzsG7yA7ME2Qe0hw6A+mn4ZqLvY4XR6UCLZAxH8rfFx6Z6BaXVJlSQS7SKSDC+JabGFurrnvBvJ+NXZBYpX4oP9AQ5eietKSAMDuDt4vLkhHfr6/XCKCvZBIjezuLMzPN/XcIhIADPYiZPXFs8lAQ7dwOA8KsL8Dr7/CoDzSDDgJCT2ljI0OOzBGKMVJACGUXU2/3h/Uo5vMDCdBQSRLcn9nox7bEgLsDoDCDKYli4p89ZXFZjJ6Ah3wvlhcb2mqPa1a0jIBhJ1RiPl3wpH4QG+bTGwDo51DKPwHMccS5mBvSzyyCcB2rgB/k5aoqK72xgo9FrbxgsMSulkZOBvwu1O6BjnGhO48p8IZfj1EsPWCR+jSMiCX0pbh9xXsrZCZrW1toOcy6mFMpyA3mNnUwi2NtQoxZwaZwzF9bKhTpHaN+C7KNGQPobTMhBZe7Wyts1iox729RNyOJkeHOj4sf19Z3YgmsraI251X6ve2BYMEIqIlVebjd0rj2la0rrrySkuDU1UhSySiYVrbkbiZ2qv2J5+53J2yzo3SAAAAAElFTkSuQmCC) 0 8 0 14 stretch stretch;
border-width: 0px 8px 0px 14px;
left: 6px;
max-width: 55px;
padding: 0px;
right: auto;
}


================================================
FILE: examples/load_jquery_on_ie.html
================================================
<!DOCTYPE html>
<html>
<head>
  <title>Load jQuery if Zepto is not supported</title>
</head>
<body>
  <h1>Load jQuery if Zepto is not supported</h1>
</body>
<script>document.write('<script src='+('__proto__' in {} ? '../dist/zepto' : 'https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery')+'.js><\/script>')</script>
<script>
  $('body').append('<p>Hello from '+('Zepto' in window ? 'Zepto' : 'jQuery')+'!</p>')

  $('script').each(function(index,script){
    if (script.src)
      $('<p>&lt;script src="'+script.src+'"&gt;</p>').appendTo('body')
  })
</script>
</html>


================================================
FILE: examples/snow/index.html
================================================
<!DOCTYPE html>
<html>
  <head>
    <title>Let it snow with Zepto.js</title>
    <meta name="name" content="content">
    <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
    <style>
      body { background: #000; color: #fff; overflow: hidden }
      div { position: absolute; }
    </style>
  </head>
  <body>

  <script src="../../src/zepto.js"></script>
  <script src="../../src/event.js"></script>
  <script src="../../src/fx.js"></script>

  <a href="https://twitter.com/share" class="twitter-share-button" data-url="http://zeptojs.com/let-it-snow" data-text="Let it snow with Zepto.js" data-via="zeptojs" data-lang="en">Tweet</a>
  <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs")</script>

  <script>
    $(document).ready(function(){
      var i = 100, glyphs = '❄❅❆'.split('')

      function rand(max){ return Math.floor(Math.random()*max) }

      function addFlake(){
        var el = $('<div><div>' + glyphs[rand(glyphs.length)] + '</div></div>')
        $('body').append(el)
        el.css({ left: rand(100)+'%', top: -100-rand(500), fontSize: 20+rand(30) })
        el.anim(
          { translateY: 1500+rand(500)+'px', translateX: 50-rand(100)+'px', rotate: (2e3-rand(4e3))+'deg' },
          6+rand(10),
          'linear',
          function(){
            addFlake()
            el.remove() // garbage collect
          }
        )
      }

      while(i--) addFlake()

      // enable for extra fun
      //window.ondeviceorientation = function(event){
      //  ('alpha' in event) && $('body').css({ '-webkit-transform': 'rotate('+event.alpha+'deg)'})
      //}
    })
  </script>
  </body>
</html>


================================================
FILE: examples/touch_events.html
================================================
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0"/>

<script src="../src/zepto.js"></script>
<script src="../src/event.js"></script>
<script src="../src/touch.js"></script>

<style>
  .delete {
    display: none;
    color: red;
  }
</style>

<ul id=items>
  <li>List item 1 <span class=delete>DELETE</span></li>
  <li>List item 2 <span class=delete>DELETE</span></li>
  <li>List item 3 <span class=delete>DELETE</span></li>
  <li>List item 4 <span class=delete>DELETE</span></li>
</ul>

<script>
$('#items li').swipe(function(){
  $('.delete').hide()
  $('.delete', this).show()
})

$('.delete').tap(function(){
  $(this).parent('li').remove()
})
</script>


================================================
FILE: make
================================================
#!/usr/bin/env coffee
require 'shelljs/make'
fs = require 'fs'

zepto_js  = 'dist/zepto.js'
zepto_min = 'dist/zepto.min.js'
zepto_gz  = 'dist/zepto.min.gz'

port = 3999
root = __dirname + '/'

target.all = ->
  target[zepto_js]()
  target.test()

## TASKS ##

target.test = ->
  test_app = require './test/server'
  server = test_app.listen port
  exec "phantomjs --disk-cache=true test/runner.js 'http://localhost:#{port}/'", (code) ->
    server.close -> exit(code)

target[zepto_js] = ->
  target.build() unless test('-e', zepto_js)

target[zepto_min] = ->
  target.minify() if stale(zepto_min, zepto_js)

target[zepto_gz] = ->
  target.compress() if stale(zepto_gz, zepto_min)

target.dist = ->
  target.build()
  target.minify()
  target.compress()

target.build = ->
  cd __dirname
  mkdir '-p', 'dist'
  modules = (env['MODULES'] || 'zepto event ajax form ie').split(' ')
  module_files = ( "src/#{module}.js" for module in modules )
  intro = "/* Zepto #{describe_version()} - #{modules.join(' ')} - zeptojs.com/license */\n"
  dist = cat(module_files).replace(/^\/[\/*].*$/mg, '').replace(/\n{3,}/g, "\n\n")
  dist = cat('src/amd_layout.js').replace(/YIELD/, -> dist.trim()) unless env['NOAMD']
  (intro + dist).to(zepto_js)
  report_size(zepto_js)

target.minify = ->
  target.build() unless test('-e', zepto_js)
  zepto_code = cat(zepto_js)
  intro = zepto_code.slice(0, zepto_code.indexOf("\n") + 1)
  (intro + minify(zepto_code)).to(zepto_min)
  report_size(zepto_min)

target.compress = ->
  gzip = require('zlib').createGzip()
  inp = fs.createReadStream(zepto_min)
  out = fs.createWriteStream(zepto_gz)
  inp.pipe(gzip).pipe(out)
  out.on 'close', ->
    report_size(zepto_gz)
    factor = fsize(zepto_js) / fsize(zepto_gz)
    echo "compression factor: #{format_number(factor)}"

target.publish = ->
  tag = 'v' + package_version()
  if git_version() == tag
    rm '-f', zepto_js
    env['MODULES'] = env['NOAMD'] = ''
    target.dist()
    res = exec 'npm publish'
    exit res.code
  else
    console.error 'error: latest commit should be tagged with ' + tag
    exit 1

## HELPERS ##

stale = (file, source) ->
  target[source]()
  !test('-e', file) || mtime(file) < mtime(source)

mtime = (file) ->
  fs.statSync(file).mtime.getTime()

fsize = (file) ->
  fs.statSync(file).size

format_number = (size, precision = 1) ->
  factor = Math.pow(10, precision)
  decimal = Math.round(size * factor) % factor
  parseInt(size) + "." + decimal

report_size = (file) ->
  echo "#{file}: #{format_number(fsize(file) / 1024)} KiB"

package_version = ->
  JSON.parse(cat('package.json')).version

git_version = ->
  desc = exec "git --git-dir='#{root + '.git'}' describe --tags HEAD", silent: true
  desc.output.replace(/\s+$/, '') if desc.code is 0

describe_version = ->
  git_version() || package_version()

minify = (source_code) ->
  uglify = require('uglify-js')
  compressor = uglify.Compressor()
  ast = uglify.parse(source_code)
  ast.figure_out_scope()
  ast.compute_char_frequency()
  ast.mangle_names()
  ast = ast.transform(compressor)
  return ast.print_to_string()


================================================
FILE: package.json
================================================
{
    "name": "zepto",
    "version": "1.2.0",
    "main": "dist/zepto.js",
    "homepage": "http://zeptojs.com",
    "scripts": {
        "test": "coffee make test",
        "dist": "coffee make dist",
        "start": "coffee test/server.coffee"
    },
    "repository": "madrobby/zepto",
    "license": "MIT",
    "devDependencies": {
        "uglify-js": "2.4.x",
        "express": "3.1.x",
        "coffee-script": "1.5.x",
        "shelljs": "0.1.x"
    }
}


================================================
FILE: script/bootstrap
================================================
#!/usr/bin/env bash
set -e

npm install

if phantom_version="$(phantomjs --version)"; then
  echo "phantomjs ${phantom_version}"
else
  echo "You should install PhantomJS for \`script/test' to work." >&2
fi


================================================
FILE: script/guard
================================================
#!/bin/sh
if [ -z "$BUNDLE_GEMFILE" ]; then
  export BUNDLE_GEMFILE=shutup
fi

exec guard --no-notify "$@"


================================================
FILE: script/lint
================================================
#!/usr/bin/awk -f

BEGIN { if (length(ARGV) < 2) exit 0 }

/<script/ { script=FILENAME }
/<\/script/ { script="" }

/;\s*$/ && (FILENAME !~ /.html$/ || script == FILENAME) {
  printf("%s:%d: no semicolons, please\n", FILENAME, FNR)
  warns++
}
/\t/ {
  printf("%s:%d: use spaces instead of tabs\n", FILENAME, FNR)
  warns++
}

END { if (warns) exit 1 }


================================================
FILE: script/test
================================================
#!/usr/bin/env bash
set -e

port=3999
test_url="http://localhost:${port}/"

export PATH=node_modules/.bin:"$PATH"

git ls-files \*.js \*.html | grep -v ^vendor/ | xargs script/lint

coffee test/server.coffee $port &
pid=$!

check_test_server() {
  curl -fsI "$test_url" >/dev/null
}

terminate_test_server() {
  kill $pid
}

tries=1
while ! check_test_server; do
  if [ $((tries++)) -eq 20 ]; then
    echo "error: timed out while waiting for test server" >&2
    exit 1
  fi
  sleep .05
done

trap terminate_test_server EXIT

phantomjs --disk-cache=true \
  test/runner.js "$test_url" "$@" \
  2> >(grep -v "CoreText performance note" >&2)


================================================
FILE: src/ajax.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  var jsonpID = +new Date(),
      document = window.document,
      key,
      name,
      rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
      scriptTypeRE = /^(?:text|application)\/javascript/i,
      xmlTypeRE = /^(?:text|application)\/xml/i,
      jsonType = 'application/json',
      htmlType = 'text/html',
      blankRE = /^\s*$/,
      originAnchor = document.createElement('a')

  originAnchor.href = window.location.href

  // trigger a custom event and return false if it was cancelled
  function triggerAndReturn(context, eventName, data) {
    var event = $.Event(eventName)
    $(context).trigger(event, data)
    return !event.isDefaultPrevented()
  }

  // trigger an Ajax "global" event
  function triggerGlobal(settings, context, eventName, data) {
    if (settings.global) return triggerAndReturn(context || document, eventName, data)
  }

  // Number of active Ajax requests
  $.active = 0

  function ajaxStart(settings) {
    if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
  }
  function ajaxStop(settings) {
    if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
  }

  // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
  function ajaxBeforeSend(xhr, settings) {
    var context = settings.context
    if (settings.beforeSend.call(context, xhr, settings) === false ||
        triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
      return false

    triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
  }
  function ajaxSuccess(data, xhr, settings, deferred) {
    var context = settings.context, status = 'success'
    settings.success.call(context, data, status, xhr)
    if (deferred) deferred.resolveWith(context, [data, status, xhr])
    triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
    ajaxComplete(status, xhr, settings)
  }
  // type: "timeout", "error", "abort", "parsererror"
  function ajaxError(error, type, xhr, settings, deferred) {
    var context = settings.context
    settings.error.call(context, xhr, type, error)
    if (deferred) deferred.rejectWith(context, [xhr, type, error])
    triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
    ajaxComplete(type, xhr, settings)
  }
  // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
  function ajaxComplete(status, xhr, settings) {
    var context = settings.context
    settings.complete.call(context, xhr, status)
    triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
    ajaxStop(settings)
  }

  function ajaxDataFilter(data, type, settings) {
    if (settings.dataFilter == empty) return data
    var context = settings.context
    return settings.dataFilter.call(context, data, type)
  }

  // Empty function, used as default callback
  function empty() {}

  $.ajaxJSONP = function(options, deferred){
    if (!('type' in options)) return $.ajax(options)

    var _callbackName = options.jsonpCallback,
      callbackName = ($.isFunction(_callbackName) ?
        _callbackName() : _callbackName) || ('Zepto' + (jsonpID++)),
      script = document.createElement('script'),
      originalCallback = window[callbackName],
      responseData,
      abort = function(errorType) {
        $(script).triggerHandler('error', errorType || 'abort')
      },
      xhr = { abort: abort }, abortTimeout

    if (deferred) deferred.promise(xhr)

    $(script).on('load error', function(e, errorType){
      clearTimeout(abortTimeout)
      $(script).off().remove()

      if (e.type == 'error' || !responseData) {
        ajaxError(null, errorType || 'error', xhr, options, deferred)
      } else {
        ajaxSuccess(responseData[0], xhr, options, deferred)
      }

      window[callbackName] = originalCallback
      if (responseData && $.isFunction(originalCallback))
        originalCallback(responseData[0])

      originalCallback = responseData = undefined
    })

    if (ajaxBeforeSend(xhr, options) === false) {
      abort('abort')
      return xhr
    }

    window[callbackName] = function(){
      responseData = arguments
    }

    script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
    document.head.appendChild(script)

    if (options.timeout > 0) abortTimeout = setTimeout(function(){
      abort('timeout')
    }, options.timeout)

    return xhr
  }

  $.ajaxSettings = {
    // Default type of request
    type: 'GET',
    // Callback that is executed before request
    beforeSend: empty,
    // Callback that is executed if the request succeeds
    success: empty,
    // Callback that is executed the the server drops error
    error: empty,
    // Callback that is executed on request complete (both: error and success)
    complete: empty,
    // The context for the callbacks
    context: null,
    // Whether to trigger "global" Ajax events
    global: true,
    // Transport
    xhr: function () {
      return new window.XMLHttpRequest()
    },
    // MIME types mapping
    // IIS returns Javascript as "application/x-javascript"
    accepts: {
      script: 'text/javascript, application/javascript, application/x-javascript',
      json:   jsonType,
      xml:    'application/xml, text/xml',
      html:   htmlType,
      text:   'text/plain'
    },
    // Whether the request is to another domain
    crossDomain: false,
    // Default timeout
    timeout: 0,
    // Whether data should be serialized to string
    processData: true,
    // Whether the browser should be allowed to cache GET responses
    cache: true,
    //Used to handle the raw response data of XMLHttpRequest.
    //This is a pre-filtering function to sanitize the response.
    //The sanitized response should be returned
    dataFilter: empty
  }

  function mimeToDataType(mime) {
    if (mime) mime = mime.split(';', 2)[0]
    return mime && ( mime == htmlType ? 'html' :
      mime == jsonType ? 'json' :
      scriptTypeRE.test(mime) ? 'script' :
      xmlTypeRE.test(mime) && 'xml' ) || 'text'
  }

  function appendQuery(url, query) {
    if (query == '') return url
    return (url + '&' + query).replace(/[&?]{1,2}/, '?')
  }

  // serialize payload and append it to the URL for GET requests
  function serializeData(options) {
    if (options.processData && options.data && $.type(options.data) != "string")
      options.data = $.param(options.data, options.traditional)
    if (options.data && (!options.type || options.type.toUpperCase() == 'GET' || 'jsonp' == options.dataType))
      options.url = appendQuery(options.url, options.data), options.data = undefined
  }

  $.ajax = function(options){
    var settings = $.extend({}, options || {}),
        deferred = $.Deferred && $.Deferred(),
        urlAnchor, hashIndex
    for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]

    ajaxStart(settings)

    if (!settings.crossDomain) {
      urlAnchor = document.createElement('a')
      urlAnchor.href = settings.url
      // cleans up URL for .href (IE only), see https://github.com/madrobby/zepto/pull/1049
      urlAnchor.href = urlAnchor.href
      settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)
    }

    if (!settings.url) settings.url = window.location.toString()
    if ((hashIndex = settings.url.indexOf('#')) > -1) settings.url = settings.url.slice(0, hashIndex)
    serializeData(settings)

    var dataType = settings.dataType, hasPlaceholder = /\?.+=\?/.test(settings.url)
    if (hasPlaceholder) dataType = 'jsonp'

    if (settings.cache === false || (
         (!options || options.cache !== true) &&
         ('script' == dataType || 'jsonp' == dataType)
        ))
      settings.url = appendQuery(settings.url, '_=' + Date.now())

    if ('jsonp' == dataType) {
      if (!hasPlaceholder)
        settings.url = appendQuery(settings.url,
          settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
      return $.ajaxJSONP(settings, deferred)
    }

    var mime = settings.accepts[dataType],
        headers = { },
        setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
        protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
        xhr = settings.xhr(),
        nativeSetHeader = xhr.setRequestHeader,
        abortTimeout

    if (deferred) deferred.promise(xhr)

    if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
    setHeader('Accept', mime || '*/*')
    if (mime = settings.mimeType || mime) {
      if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
      xhr.overrideMimeType && xhr.overrideMimeType(mime)
    }
    if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
      setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')

    if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
    xhr.setRequestHeader = setHeader

    xhr.onreadystatechange = function(){
      if (xhr.readyState == 4) {
        xhr.onreadystatechange = empty
        clearTimeout(abortTimeout)
        var result, error = false
        if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
          dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))

          if (xhr.responseType == 'arraybuffer' || xhr.responseType == 'blob')
            result = xhr.response
          else {
            result = xhr.responseText

            try {
              // http://perfectionkills.com/global-eval-what-are-the-options/
              // sanitize response accordingly if data filter callback provided
              result = ajaxDataFilter(result, dataType, settings)
              if (dataType == 'script')    (1,eval)(result)
              else if (dataType == 'xml')  result = xhr.responseXML
              else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
            } catch (e) { error = e }

            if (error) return ajaxError(error, 'parsererror', xhr, settings, deferred)
          }

          ajaxSuccess(result, xhr, settings, deferred)
        } else {
          ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
        }
      }
    }

    if (ajaxBeforeSend(xhr, settings) === false) {
      xhr.abort()
      ajaxError(null, 'abort', xhr, settings, deferred)
      return xhr
    }

    var async = 'async' in settings ? settings.async : true
    xhr.open(settings.type, settings.url, async, settings.username, settings.password)

    if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]

    for (name in headers) nativeSetHeader.apply(xhr, headers[name])

    if (settings.timeout > 0) abortTimeout = setTimeout(function(){
        xhr.onreadystatechange = empty
        xhr.abort()
        ajaxError(null, 'timeout', xhr, settings, deferred)
      }, settings.timeout)

    // avoid sending empty string (#319)
    xhr.send(settings.data ? settings.data : null)
    return xhr
  }

  // handle optional data/success arguments
  function parseArguments(url, data, success, dataType) {
    if ($.isFunction(data)) dataType = success, success = data, data = undefined
    if (!$.isFunction(success)) dataType = success, success = undefined
    return {
      url: url
    , data: data
    , success: success
    , dataType: dataType
    }
  }

  $.get = function(/* url, data, success, dataType */){
    return $.ajax(parseArguments.apply(null, arguments))
  }

  $.post = function(/* url, data, success, dataType */){
    var options = parseArguments.apply(null, arguments)
    options.type = 'POST'
    return $.ajax(options)
  }

  $.getJSON = function(/* url, data, success */){
    var options = parseArguments.apply(null, arguments)
    options.dataType = 'json'
    return $.ajax(options)
  }

  $.fn.load = function(url, data, success){
    if (!this.length) return this
    var self = this, parts = url.split(/\s/), selector,
        options = parseArguments(url, data, success),
        callback = options.success
    if (parts.length > 1) options.url = parts[0], selector = parts[1]
    options.success = function(response){
      self.html(selector ?
        $('<div>').html(response.replace(rscript, "")).find(selector)
        : response)
      callback && callback.apply(self, arguments)
    }
    $.ajax(options)
    return this
  }

  var escape = encodeURIComponent

  function serialize(params, obj, traditional, scope){
    var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
    $.each(obj, function(key, value) {
      type = $.type(value)
      if (scope) key = traditional ? scope :
        scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
      // handle data in serializeArray() format
      if (!scope && array) params.add(value.name, value.value)
      // recurse into nested objects
      else if (type == "array" || (!traditional && type == "object"))
        serialize(params, value, traditional, key)
      else params.add(key, value)
    })
  }

  $.param = function(obj, traditional){
    var params = []
    params.add = function(key, value) {
      if ($.isFunction(value)) value = value()
      if (value == null) value = ""
      this.push(escape(key) + '=' + escape(value))
    }
    serialize(params, obj, traditional)
    return params.join('&').replace(/%20/g, '+')
  }
})(Zepto)


================================================
FILE: src/amd_layout.js
================================================
(function(global, factory) {
  if (typeof define === 'function' && define.amd)
    define(function() { return factory(global) })
  else
    factory(global)
}(window, function(window) {
  YIELD
  return Zepto
}))


================================================
FILE: src/assets.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  var cache = [], timeout

  $.fn.remove = function(){
    return this.each(function(){
      if(this.parentNode){
        if(this.tagName === 'IMG'){
          cache.push(this)
          this.src = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
          if (timeout) clearTimeout(timeout)
          timeout = setTimeout(function(){ cache = [] }, 60000)
        }
        this.parentNode.removeChild(this)
      }
    })
  }
})(Zepto)


================================================
FILE: src/callbacks.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  // Create a collection of callbacks to be fired in a sequence, with configurable behaviour
  // Option flags:
  //   - once: Callbacks fired at most one time.
  //   - memory: Remember the most recent context and arguments
  //   - stopOnFalse: Cease iterating over callback list
  //   - unique: Permit adding at most one instance of the same callback
  $.Callbacks = function(options) {
    options = $.extend({}, options)

    var memory, // Last fire value (for non-forgettable lists)
        fired,  // Flag to know if list was already fired
        firing, // Flag to know if list is currently firing
        firingStart, // First callback to fire (used internally by add and fireWith)
        firingLength, // End of the loop when firing
        firingIndex, // Index of currently firing callback (modified by remove if needed)
        list = [], // Actual callback list
        stack = !options.once && [], // Stack of fire calls for repeatable lists
        fire = function(data) {
          memory = options.memory && data
          fired = true
          firingIndex = firingStart || 0
          firingStart = 0
          firingLength = list.length
          firing = true
          for ( ; list && firingIndex < firingLength ; ++firingIndex ) {
            if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
              memory = false
              break
            }
          }
          firing = false
          if (list) {
            if (stack) stack.length && fire(stack.shift())
            else if (memory) list.length = 0
            else Callbacks.disable()
          }
        },

        Callbacks = {
          add: function() {
            if (list) {
              var start = list.length,
                  add = function(args) {
                    $.each(args, function(_, arg){
                      if (typeof arg === "function") {
                        if (!options.unique || !Callbacks.has(arg)) list.push(arg)
                      }
                      else if (arg && arg.length && typeof arg !== 'string') add(arg)
                    })
                  }
              add(arguments)
              if (firing) firingLength = list.length
              else if (memory) {
                firingStart = start
                fire(memory)
              }
            }
            return this
          },
          remove: function() {
            if (list) {
              $.each(arguments, function(_, arg){
                var index
                while ((index = $.inArray(arg, list, index)) > -1) {
                  list.splice(index, 1)
                  // Handle firing indexes
                  if (firing) {
                    if (index <= firingLength) --firingLength
                    if (index <= firingIndex) --firingIndex
                  }
                }
              })
            }
            return this
          },
          has: function(fn) {
            return !!(list && (fn ? $.inArray(fn, list) > -1 : list.length))
          },
          empty: function() {
            firingLength = list.length = 0
            return this
          },
          disable: function() {
            list = stack = memory = undefined
            return this
          },
          disabled: function() {
            return !list
          },
          lock: function() {
            stack = undefined
            if (!memory) Callbacks.disable()
            return this
          },
          locked: function() {
            return !stack
          },
          fireWith: function(context, args) {
            if (list && (!fired || stack)) {
              args = args || []
              args = [context, args.slice ? args.slice() : args]
              if (firing) stack.push(args)
              else fire(args)
            }
            return this
          },
          fire: function() {
            return Callbacks.fireWith(this, arguments)
          },
          fired: function() {
            return !!fired
          }
        }

    return Callbacks
  }
})(Zepto)


================================================
FILE: src/data.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

// The following code is heavily inspired by jQuery's $.fn.data()

;(function($){
  var data = {}, dataAttr = $.fn.data, camelize = $.camelCase,
    exp = $.expando = 'Zepto' + (+new Date()), emptyArray = []

  // Get value from node:
  // 1. first try key as given,
  // 2. then try camelized key,
  // 3. fall back to reading "data-*" attribute.
  function getData(node, name) {
    var id = node[exp], store = id && data[id]
    if (name === undefined) return store || setData(node)
    else {
      if (store) {
        if (name in store) return store[name]
        var camelName = camelize(name)
        if (camelName in store) return store[camelName]
      }
      return dataAttr.call($(node), name)
    }
  }

  // Store value under camelized key on node
  function setData(node, name, value) {
    var id = node[exp] || (node[exp] = ++$.uuid),
      store = data[id] || (data[id] = attributeData(node))
    if (name !== undefined) store[camelize(name)] = value
    return store
  }

  // Read all "data-*" attributes from a node
  function attributeData(node) {
    var store = {}
    $.each(node.attributes || emptyArray, function(i, attr){
      if (attr.name.indexOf('data-') == 0)
        store[camelize(attr.name.replace('data-', ''))] =
          $.zepto.deserializeValue(attr.value)
    })
    return store
  }

  $.fn.data = function(name, value) {
    return value === undefined ?
      // set multiple values via object
      $.isPlainObject(name) ?
        this.each(function(i, node){
          $.each(name, function(key, value){ setData(node, key, value) })
        }) :
        // get value from first element
        (0 in this ? getData(this[0], name) : undefined) :
      // set value on all elements
      this.each(function(){ setData(this, name, value) })
  }

  $.data = function(elem, name, value) {
    return $(elem).data(name, value)
  }

  $.hasData = function(elem) {
    var id = elem[exp], store = id && data[id]
    return store ? !$.isEmptyObject(store) : false
  }

  $.fn.removeData = function(names) {
    if (typeof names == 'string') names = names.split(/\s+/)
    return this.each(function(){
      var id = this[exp], store = id && data[id]
      if (store) $.each(names || store, function(key){
        delete store[names ? camelize(this) : key]
      })
    })
  }

  // Generate extended `remove` and `empty` functions
  ;['remove', 'empty'].forEach(function(methodName){
    var origFn = $.fn[methodName]
    $.fn[methodName] = function() {
      var elements = this.find('*')
      if (methodName === 'remove') elements = elements.add(this)
      elements.removeData()
      return origFn.call(this)
    }
  })
})(Zepto)


================================================
FILE: src/deferred.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.
//
//     Some code (c) 2005, 2013 jQuery Foundation, Inc. and other contributors

;(function($){
  var slice = Array.prototype.slice

  function Deferred(func) {
    var tuples = [
          // action, add listener, listener list, final state
          [ "resolve", "done", $.Callbacks({once:1, memory:1}), "resolved" ],
          [ "reject", "fail", $.Callbacks({once:1, memory:1}), "rejected" ],
          [ "notify", "progress", $.Callbacks({memory:1}) ]
        ],
        state = "pending",
        promise = {
          state: function() {
            return state
          },
          always: function() {
            deferred.done(arguments).fail(arguments)
            return this
          },
          then: function(/* fnDone [, fnFailed [, fnProgress]] */) {
            var fns = arguments
            return Deferred(function(defer){
              $.each(tuples, function(i, tuple){
                var fn = $.isFunction(fns[i]) && fns[i]
                deferred[tuple[1]](function(){
                  var returned = fn && fn.apply(this, arguments)
                  if (returned && $.isFunction(returned.promise)) {
                    returned.promise()
                      .done(defer.resolve)
                      .fail(defer.reject)
                      .progress(defer.notify)
                  } else {
                    var context = this === promise ? defer.promise() : this,
                        values = fn ? [returned] : arguments
                    defer[tuple[0] + "With"](context, values)
                  }
                })
              })
              fns = null
            }).promise()
          },

          promise: function(obj) {
            return obj != null ? $.extend( obj, promise ) : promise
          }
        },
        deferred = {}

    $.each(tuples, function(i, tuple){
      var list = tuple[2],
          stateString = tuple[3]

      promise[tuple[1]] = list.add

      if (stateString) {
        list.add(function(){
          state = stateString
        }, tuples[i^1][2].disable, tuples[2][2].lock)
      }

      deferred[tuple[0]] = function(){
        deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments)
        return this
      }
      deferred[tuple[0] + "With"] = list.fireWith
    })

    promise.promise(deferred)
    if (func) func.call(deferred, deferred)
    return deferred
  }

  $.when = function(sub) {
    var resolveValues = slice.call(arguments),
        len = resolveValues.length,
        i = 0,
        remain = len !== 1 || (sub && $.isFunction(sub.promise)) ? len : 0,
        deferred = remain === 1 ? sub : Deferred(),
        progressValues, progressContexts, resolveContexts,
        updateFn = function(i, ctx, val){
          return function(value){
            ctx[i] = this
            val[i] = arguments.length > 1 ? slice.call(arguments) : value
            if (val === progressValues) {
              deferred.notifyWith(ctx, val)
            } else if (!(--remain)) {
              deferred.resolveWith(ctx, val)
            }
          }
        }

    if (len > 1) {
      progressValues = new Array(len)
      progressContexts = new Array(len)
      resolveContexts = new Array(len)
      for ( ; i < len; ++i ) {
        if (resolveValues[i] && $.isFunction(resolveValues[i].promise)) {
          resolveValues[i].promise()
            .done(updateFn(i, resolveContexts, resolveValues))
            .fail(deferred.reject)
            .progress(updateFn(i, progressContexts, progressValues))
        } else {
          --remain
        }
      }
    }
    if (!remain) deferred.resolveWith(resolveContexts, resolveValues)
    return deferred.promise()
  }

  $.Deferred = Deferred
})(Zepto)


================================================
FILE: src/detect.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  function detect(ua, platform){
    var os = this.os = {}, browser = this.browser = {},
      webkit = ua.match(/Web[kK]it[\/]{0,1}([\d.]+)/),
      android = ua.match(/(Android);?[\s\/]+([\d.]+)?/),
      osx = !!ua.match(/\(Macintosh\; Intel /),
      ipad = ua.match(/(iPad).*OS\s([\d_]+)/),
      ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/),
      iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/),
      webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/),
      win = /Win\d{2}|Windows/.test(platform),
      wp = ua.match(/Windows Phone ([\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.]+)/),
      firefoxos = ua.match(/\((?:Mobile|Tablet); rv:([\d.]+)\).*Firefox\/[\d.]+/),
      ie = ua.match(/MSIE\s([\d.]+)/) || ua.match(/Trident\/[\d](?=[^\?]+).*rv:([0-9.].)/),
      webview = !chrome && ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/),
      safari = webview || ua.match(/Version\/([\d.]+)([^S](Safari)|[^M]*(Mobile)[^S]*(Safari))/)

    // 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 && !ipod) 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 (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null
    if (wp) os.wp = true, os.version = wp[1]
    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]
    if (firefoxos) os.firefoxos = true, os.version = firefoxos[1]
    if (ie) browser.ie = true, browser.version = ie[1]
    if (safari && (osx || os.ios || win)) {
      browser.safari = true
      if (!os.ios) browser.version = safari[1]
    }
    if (webview) browser.webview = true

    os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||
      (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)))
    os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos || blackberry || bb10 ||
      (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\/([\d.]+)/)) ||
      (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))))
  }

  detect.call($, navigator.userAgent, navigator.platform)
  // make available to unit tests
  $.__detect = detect

})(Zepto)


================================================
FILE: src/event.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  var _zid = 1, undefined,
      slice = Array.prototype.slice,
      isFunction = $.isFunction,
      isString = function(obj){ return typeof obj == 'string' },
      handlers = {},
      specialEvents={},
      focusinSupported = 'onfocusin' in window,
      focus = { focus: 'focusin', blur: 'focusout' },
      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 eventCapture(handler, captureSetting) {
    return handler.del &&
      (!focusinSupported && (handler.e in focus)) ||
      !!captureSetting
  }

  function realEvent(type) {
    return hover[type] || (focusinSupported && focus[type]) || type
  }

  function add(element, events, fn, data, selector, delegator, capture){
    var id = zid(element), set = (handlers[id] || (handlers[id] = []))
    events.split(/\s/).forEach(function(event){
      if (event == 'ready') return $(document).ready(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   = delegator
      var callback  = delegator || fn
      handler.proxy = function(e){
        e = compatible(e)
        if (e.isImmediatePropagationStopped()) return
        e.data = data
        var result = callback.apply(element, e._args == undefined ? [e] : [e].concat(e._args))
        if (result === false) e.preventDefault(), e.stopPropagation()
        return result
      }
      handler.i = set.length
      set.push(handler)
      if ('addEventListener' in element)
        element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
    })
  }
  function remove(element, events, fn, selector, capture){
    var id = zid(element)
    ;(events || '').split(/\s/).forEach(function(event){
      findHandlers(element, event, fn, selector).forEach(function(handler){
        delete handlers[id][handler.i]
      if ('removeEventListener' in element)
        element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
      })
    })
  }

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

  $.proxy = function(fn, context) {
    var args = (2 in arguments) && slice.call(arguments, 2)
    if (isFunction(fn)) {
      var proxyFn = function(){ return fn.apply(context, args ? args.concat(slice.call(arguments)) : arguments) }
      proxyFn._zid = zid(fn)
      return proxyFn
    } else if (isString(context)) {
      if (args) {
        args.unshift(fn[context], fn)
        return $.proxy.apply(null, args)
      } else {
        return $.proxy(fn[context], fn)
      }
    } else {
      throw new TypeError("expected function")
    }
  }

  $.fn.bind = function(event, data, callback){
    return this.on(event, data, callback)
  }
  $.fn.unbind = function(event, callback){
    return this.off(event, callback)
  }
  $.fn.one = function(event, selector, data, callback){
    return this.on(event, selector, data, callback, 1)
  }

  var returnTrue = function(){return true},
      returnFalse = function(){return false},
      ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$|webkitMovement[XY]$)/,
      eventMethods = {
        preventDefault: 'isDefaultPrevented',
        stopImmediatePropagation: 'isImmediatePropagationStopped',
        stopPropagation: 'isPropagationStopped'
      }

  function compatible(event, source) {
    if (source || !event.isDefaultPrevented) {
      source || (source = event)

      $.each(eventMethods, function(name, predicate) {
        var sourceMethod = source[name]
        event[name] = function(){
          this[predicate] = returnTrue
          return sourceMethod && sourceMethod.apply(source, arguments)
        }
        event[predicate] = returnFalse
      })

      try {
        event.timeStamp || (event.timeStamp = Date.now())
      } catch (ignored) { }

      if (source.defaultPrevented !== undefined ? source.defaultPrevented :
          'returnValue' in source ? source.returnValue === false :
          source.getPreventDefault && source.getPreventDefault())
        event.isDefaultPrevented = returnTrue
    }
    return event
  }

  function createProxy(event) {
    var key, proxy = { originalEvent: event }
    for (key in event)
      if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key]

    return compatible(proxy, event)
  }

  $.fn.delegate = function(selector, event, callback){
    return this.on(event, selector, callback)
  }
  $.fn.undelegate = function(selector, event, callback){
    return this.off(event, selector, callback)
  }

  $.fn.live = function(event, callback){
    $(document.body).delegate(this.selector, event, callback)
    return this
  }
  $.fn.die = function(event, callback){
    $(document.body).undelegate(this.selector, event, callback)
    return this
  }

  $.fn.on = function(event, selector, data, callback, one){
    var autoRemove, delegator, $this = this
    if (event && !isString(event)) {
      $.each(event, function(type, fn){
        $this.on(type, selector, data, fn, one)
      })
      return $this
    }

    if (!isString(selector) && !isFunction(callback) && callback !== false)
      callback = data, data = selector, selector = undefined
    if (callback === undefined || data === false)
      callback = data, data = undefined

    if (callback === false) callback = returnFalse

    return $this.each(function(_, element){
      if (one) autoRemove = function(e){
        remove(element, e.type, callback)
        return callback.apply(this, arguments)
      }

      if (selector) delegator = function(e){
        var evt, match = $(e.target).closest(selector, element).get(0)
        if (match && match !== element) {
          evt = $.extend(createProxy(e), {currentTarget: match, liveFired: element})
          return (autoRemove || callback).apply(match, [evt].concat(slice.call(arguments, 1)))
        }
      }

      add(element, event, callback, data, selector, delegator || autoRemove)
    })
  }
  $.fn.off = function(event, selector, callback){
    var $this = this
    if (event && !isString(event)) {
      $.each(event, function(type, fn){
        $this.off(type, selector, fn)
      })
      return $this
    }

    if (!isString(selector) && !isFunction(callback) && callback !== false)
      callback = selector, selector = undefined

    if (callback === false) callback = returnFalse

    return $this.each(function(){
      remove(this, event, callback, selector)
    })
  }

  $.fn.trigger = function(event, args){
    event = (isString(event) || $.isPlainObject(event)) ? $.Event(event) : compatible(event)
    event._args = args
    return this.each(function(){
      // handle focus(), blur() by calling them directly
      if (event.type in focus && typeof this[event.type] == "function") this[event.type]()
      // items in the collection might not be DOM elements
      else if ('dispatchEvent' in this) this.dispatchEvent(event)
      else $(this).triggerHandler(event, args)
    })
  }

  // triggers event handlers on current element just as if an event occurred,
  // doesn't trigger an actual event, doesn't bubble
  $.fn.triggerHandler = function(event, args){
    var e, result
    this.each(function(i, element){
      e = createProxy(isString(event) ? $.Event(event) : event)
      e._args = args
      e.target = element
      $.each(findHandlers(element, event.type || event), function(i, handler){
        result = handler.proxy(e)
        if (e.isImmediatePropagationStopped()) return false
      })
    })
    return result
  }

  // shortcut methods for `.bind(event, fn)` for each event type
  ;('focusin focusout focus blur load resize scroll unload click dblclick '+
  'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '+
  'change select keydown keypress keyup error').split(' ').forEach(function(event) {
    $.fn[event] = function(callback) {
      return (0 in arguments) ?
        this.bind(event, callback) :
        this.trigger(event)
    }
  })

  $.Event = function(type, props) {
    if (!isString(type)) props = type, type = props.type
    var event = document.createEvent(specialEvents[type] || 'Events'), bubbles = true
    if (props) for (var name in props) (name == 'bubbles') ? (bubbles = !!props[name]) : (event[name] = props[name])
    event.initEvent(type, bubbles, true)
    return compatible(event)
  }

})(Zepto)


================================================
FILE: src/form.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  $.fn.serializeArray = function() {
    var name, type, result = [],
      add = function(value) {
        if (value.forEach) return value.forEach(add)
        result.push({ name: name, value: value })
      }
    if (this[0]) $.each(this[0].elements, function(_, field){
      type = field.type, name = field.name
      if (name && field.nodeName.toLowerCase() != 'fieldset' &&
        !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
        ((type != 'radio' && type != 'checkbox') || field.checked))
          add($(field).val())
    })
    return result
  }

  $.fn.serialize = function(){
    var result = []
    this.serializeArray().forEach(function(elm){
      result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
    })
    return result.join('&')
  }

  $.fn.submit = function(callback) {
    if (0 in arguments) this.bind('submit', callback)
    else if (this.length) {
      var event = $.Event('submit')
      this.eq(0).trigger(event)
      if (!event.isDefaultPrevented()) this.get(0).submit()
    }
    return this
  }

})(Zepto)


================================================
FILE: src/fx.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($, undefined){
  var prefix = '', eventPrefix,
    vendors = { Webkit: 'webkit', Moz: '', O: 'o' },
    testEl = document.createElement('div'),
    supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i,
    transform,
    transitionProperty, transitionDuration, transitionTiming, transitionDelay,
    animationName, animationDuration, animationTiming, animationDelay,
    cssReset = {}

  function dasherize(str) { return str.replace(/([A-Z])/g, '-$1').toLowerCase() }
  function normalizeEvent(name) { return eventPrefix ? eventPrefix + name : name.toLowerCase() }

  if (testEl.style.transform === undefined) $.each(vendors, function(vendor, event){
    if (testEl.style[vendor + 'TransitionProperty'] !== undefined) {
      prefix = '-' + vendor.toLowerCase() + '-'
      eventPrefix = event
      return false
    }
  })

  transform = prefix + 'transform'
  cssReset[transitionProperty = prefix + 'transition-property'] =
  cssReset[transitionDuration = prefix + 'transition-duration'] =
  cssReset[transitionDelay    = prefix + 'transition-delay'] =
  cssReset[transitionTiming   = prefix + 'transition-timing-function'] =
  cssReset[animationName      = prefix + 'animation-name'] =
  cssReset[animationDuration  = prefix + 'animation-duration'] =
  cssReset[animationDelay     = prefix + 'animation-delay'] =
  cssReset[animationTiming    = prefix + 'animation-timing-function'] = ''

  $.fx = {
    off: (eventPrefix === undefined && testEl.style.transitionProperty === undefined),
    speeds: { _default: 400, fast: 200, slow: 600 },
    cssPrefix: prefix,
    transitionEnd: normalizeEvent('TransitionEnd'),
    animationEnd: normalizeEvent('AnimationEnd')
  }

  $.fn.animate = function(properties, duration, ease, callback, delay){
    if ($.isFunction(duration))
      callback = duration, ease = undefined, duration = undefined
    if ($.isFunction(ease))
      callback = ease, ease = undefined
    if ($.isPlainObject(duration))
      ease = duration.easing, callback = duration.complete, delay = duration.delay, duration = duration.duration
    if (duration) duration = (typeof duration == 'number' ? duration :
                    ($.fx.speeds[duration] || $.fx.speeds._default)) / 1000
    if (delay) delay = parseFloat(delay) / 1000
    return this.anim(properties, duration, ease, callback, delay)
  }

  $.fn.anim = function(properties, duration, ease, callback, delay){
    var key, cssValues = {}, cssProperties, transforms = '',
        that = this, wrappedCallback, endEvent = $.fx.transitionEnd,
        fired = false

    if (duration === undefined) duration = $.fx.speeds._default / 1000
    if (delay === undefined) delay = 0
    if ($.fx.off) duration = 0

    if (typeof properties == 'string') {
      // keyframe animation
      cssValues[animationName] = properties
      cssValues[animationDuration] = duration + 's'
      cssValues[animationDelay] = delay + 's'
      cssValues[animationTiming] = (ease || 'linear')
      endEvent = $.fx.animationEnd
    } else {
      cssProperties = []
      // CSS transitions
      for (key in properties)
        if (supportedTransforms.test(key)) transforms += key + '(' + properties[key] + ') '
        else cssValues[key] = properties[key], cssProperties.push(dasherize(key))

      if (transforms) cssValues[transform] = transforms, cssProperties.push(transform)
      if (duration > 0 && typeof properties === 'object') {
        cssValues[transitionProperty] = cssProperties.join(', ')
        cssValues[transitionDuration] = duration + 's'
        cssValues[transitionDelay] = delay + 's'
        cssValues[transitionTiming] = (ease || 'linear')
      }
    }

    wrappedCallback = function(event){
      if (typeof event !== 'undefined') {
        if (event.target !== event.currentTarget) return // makes sure the event didn't bubble from "below"
        $(event.target).unbind(endEvent, wrappedCallback)
      } else
        $(this).unbind(endEvent, wrappedCallback) // triggered by setTimeout

      fired = true
      $(this).css(cssReset)
      callback && callback.call(this)
    }
    if (duration > 0){
      this.bind(endEvent, wrappedCallback)
      // transitionEnd is not always firing on older Android phones
      // so make sure it gets fired
      setTimeout(function(){
        if (fired) return
        wrappedCallback.call(that)
      }, ((duration + delay) * 1000) + 25)
    }

    // trigger page reflow so new elements can animate
    this.size() && this.get(0).clientLeft

    this.css(cssValues)

    if (duration <= 0) setTimeout(function() {
      that.each(function(){ wrappedCallback.call(this) })
    }, 0)

    return this
  }

  testEl = null
})(Zepto)


================================================
FILE: src/fx_methods.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($, undefined){
  var document = window.document,
    origShow = $.fn.show, origHide = $.fn.hide, origToggle = $.fn.toggle

  function anim(el, speed, opacity, scale, callback) {
    if (typeof speed == 'function' && !callback) callback = speed, speed = undefined
    var props = { opacity: opacity }
    if (scale) {
      props.scale = scale
      el.css($.fx.cssPrefix + 'transform-origin', '0 0')
    }
    return el.animate(props, speed, null, callback)
  }

  function hide(el, speed, scale, callback) {
    return anim(el, speed, 0, scale, function(){
      origHide.call($(this))
      callback && callback.call(this)
    })
  }

  $.fn.show = function(speed, callback) {
    origShow.call(this)
    if (speed === undefined) speed = 0
    else this.css('opacity', 0)
    return anim(this, speed, 1, '1,1', callback)
  }

  $.fn.hide = function(speed, callback) {
    if (speed === undefined) return origHide.call(this)
    else return hide(this, speed, '0,0', callback)
  }

  $.fn.toggle = function(speed, callback) {
    if (speed === undefined || typeof speed == 'boolean')
      return origToggle.call(this, speed)
    else return this.each(function(){
      var el = $(this)
      el[el.css('display') == 'none' ? 'show' : 'hide'](speed, callback)
    })
  }

  $.fn.fadeTo = function(speed, opacity, callback) {
    return anim(this, speed, opacity, null, callback)
  }

  $.fn.fadeIn = function(speed, callback) {
    var target = this.css('opacity')
    if (target > 0) this.css('opacity', 0)
    else target = 1
    return origShow.call(this).fadeTo(speed, target, callback)
  }

  $.fn.fadeOut = function(speed, callback) {
    return hide(this, speed, null, callback)
  }

  $.fn.fadeToggle = function(speed, callback) {
    return this.each(function(){
      var el = $(this)
      el[
        (el.css('opacity') == 0 || el.css('display') == 'none') ? 'fadeIn' : 'fadeOut'
      ](speed, callback)
    })
  }

})(Zepto)


================================================
FILE: src/gesture.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  if ($.os.ios) {
    var gesture = {}, gestureTimeout

    function parentIfText(node){
      return 'tagName' in node ? node : node.parentNode
    }

    $(document).bind('gesturestart', function(e){
      var now = Date.now(), delta = now - (gesture.last || now)
      gesture.target = parentIfText(e.target)
      gestureTimeout && clearTimeout(gestureTimeout)
      gesture.e1 = e.scale
      gesture.last = now
    }).bind('gesturechange', function(e){
      gesture.e2 = e.scale
    }).bind('gestureend', function(e){
      if (gesture.e2 > 0) {
        Math.abs(gesture.e1 - gesture.e2) != 0 && $(gesture.target).trigger('pinch') &&
          $(gesture.target).trigger('pinch' + (gesture.e1 - gesture.e2 > 0 ? 'In' : 'Out'))
        gesture.e1 = gesture.e2 = gesture.last = 0
      } else if ('last' in gesture) {
        gesture = {}
      }
    })

    ;['pinch', 'pinchIn', 'pinchOut'].forEach(function(m){
      $.fn[m] = function(callback){ return this.bind(m, callback) }
    })
  }
})(Zepto)


================================================
FILE: src/ie.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function(){
  // getComputedStyle shouldn't freak out when called
  // without a valid element as argument
  try {
    getComputedStyle(undefined)
  } catch(e) {
    var nativeGetComputedStyle = getComputedStyle
    window.getComputedStyle = function(element, pseudoElement){
      try {
        return nativeGetComputedStyle(element, pseudoElement)
      } catch(e) {
        return null
      }
    }
  }
})()


================================================
FILE: src/ios3.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT 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
    }

})()


================================================
FILE: src/selector.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  var zepto = $.zepto, oldQsa = zepto.qsa, oldMatches = zepto.matches

  function visible(elem){
    elem = $(elem)
    return !!(elem.width() || elem.height()) && elem.css("display") !== "none"
  }

  // Implements a subset from:
  // http://api.jquery.com/category/selectors/jquery-selector-extensions/
  //
  // Each filter function receives the current index, all nodes in the
  // considered set, and a value if there were parentheses. The value
  // of `this` is the node currently being considered. The function returns the
  // resulting node(s), null, or undefined.
  //
  // Complex selectors are not supported:
  //   li:has(label:contains("foo")) + li:has(label:contains("bar"))
  //   ul.inner:first > li
  var filters = $.expr[':'] = {
    visible:  function(){ if (visible(this)) return this },
    hidden:   function(){ if (!visible(this)) return this },
    selected: function(){ if (this.selected) return this },
    checked:  function(){ if (this.checked) return this },
    parent:   function(){ return this.parentNode },
    first:    function(idx){ if (idx === 0) return this },
    last:     function(idx, nodes){ if (idx === nodes.length - 1) return this },
    eq:       function(idx, _, value){ if (idx === value) return this },
    contains: function(idx, _, text){ if ($(this).text().indexOf(text) > -1) return this },
    has:      function(idx, _, sel){ if (zepto.qsa(this, sel).length) return this }
  }

  var filterRe = new RegExp('(.*):(\\w+)(?:\\(([^)]+)\\))?$\\s*'),
      childRe  = /^\s*>/,
      classTag = 'Zepto' + (+new Date())

  function process(sel, fn) {
    // quote the hash in `a[href^=#]` expression
    sel = sel.replace(/=#\]/g, '="#"]')
    var filter, arg, match = filterRe.exec(sel)
    if (match && match[2] in filters) {
      filter = filters[match[2]], arg = match[3]
      sel = match[1]
      if (arg) {
        var num = Number(arg)
        if (isNaN(num)) arg = arg.replace(/^["']|["']$/g, '')
        else arg = num
      }
    }
    return fn(sel, filter, arg)
  }

  zepto.qsa = function(node, selector) {
    return process(selector, function(sel, filter, arg){
      try {
        var taggedParent
        if (!sel && filter) sel = '*'
        else if (childRe.test(sel))
          // support "> *" child queries by tagging the parent node with a
          // unique class and prepending that classname onto the selector
          taggedParent = $(node).addClass(classTag), sel = '.'+classTag+' '+sel

        var nodes = oldQsa(node, sel)
      } catch(e) {
        console.error('error performing selector: %o', selector)
        throw e
      } finally {
        if (taggedParent) taggedParent.removeClass(classTag)
      }
      return !filter ? nodes :
        zepto.uniq($.map(nodes, function(n, i){ return filter.call(n, i, nodes, arg) }))
    })
  }

  zepto.matches = function(node, selector){
    return process(selector, function(sel, filter, arg){
      return (!sel || oldMatches(node, sel)) &&
        (!filter || filter.call(node, null, arg) === node)
    })
  }
})(Zepto)


================================================
FILE: src/stack.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  $.fn.end = function(){
    return this.prevObject || $()
  }

  $.fn.andSelf = function(){
    return this.add(this.prevObject || $())
  }

  'filter,add,not,eq,first,last,find,closest,parents,parent,children,siblings'.split(',').forEach(function(property){
    var fn = $.fn[property]
    $.fn[property] = function(){
      var ret = fn.apply(this, arguments)
      ret.prevObject = this
      return ret
    }
  })
})(Zepto)


================================================
FILE: src/touch.js
================================================
//     Zepto.js
//     (c) 2010-2016 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

;(function($){
  var touch = {},
    touchTimeout, tapTimeout, swipeTimeout, longTapTimeout,
    longTapDelay = 750,
    gesture,
    down, up, move,
    eventMap,
    initialized = false

  function swipeDirection(x1, x2, y1, y2) {
    return Math.abs(x1 - x2) >=
      Math.abs(y1 - y2) ? (x1 - x2 > 0 ? 'Left' : 'Right') : (y1 - y2 > 0 ? 'Up' : 'Down')
  }

  function longTap() {
    longTapTimeout = null
    if (touch.last) {
      touch.el.trigger('longTap')
      touch = {}
    }
  }

  function cancelLongTap() {
    if (longTapTimeout) clearTimeout(longTapTimeout)
    longTapTimeout = null
  }

  function cancelAll() {
    if (touchTimeout) clearTimeout(touchTimeout)
    if (tapTimeout) clearTimeout(tapTimeout)
    if (swipeTimeout) clearTimeout(swipeTimeout)
    if (longTapTimeout) clearTimeout(longTapTimeout)
    touchTimeout = tapTimeout = swipeTimeout = longTapTimeout = null
    touch = {}
  }

  function isPrimaryTouch(event){
    return (event.pointerType == 'touch' ||
      event.pointerType == event.MSPOINTER_TYPE_TOUCH)
      && event.isPrimary
  }

  function isPointerEventType(e, type){
    return (e.type == 'pointer'+type ||
      e.type.toLowerCase() == 'mspointer'+type)
  }

  // helper function for tests, so they check for different APIs
  function unregisterTouchEvents(){
    if (!initialized) return
    $(document).off(eventMap.down, down)
      .off(eventMap.up, up)
      .off(eventMap.move, move)
      .off(eventMap.cancel, cancelAll)
    $(window).off('scroll', cancelAll)
    cancelAll()
    initialized = false
  }

  function setup(__eventMap){
    var now, delta, deltaX = 0, deltaY = 0, firstTouch, _isPointerType

    unregisterTouchEvents()

    eventMap = (__eventMap && ('down' in __eventMap)) ? __eventMap :
      ('ontouchstart' in document ?
      { 'down': 'touchstart', 'up': 'touchend',
        'move': 'touchmove', 'cancel': 'touchcancel' } :
      'onpointerdown' in document ?
      { 'down': 'pointerdown', 'up': 'pointerup',
        'move': 'pointermove', 'cancel': 'pointercancel' } :
       'onmspointerdown' in document ?
      { 'down': 'MSPointerDown', 'up': 'MSPointerUp',
        'move': 'MSPointerMove', 'cancel': 'MSPointerCancel' } : false)

    // No API availables for touch events
    if (!eventMap) return

    if ('MSGesture' in window) {
      gesture = new MSGesture()
      gesture.target = document.body

      $(document)
        .bind('MSGestureEnd', function(e){
          var swipeDirectionFromVelocity =
            e.velocityX > 1 ? 'Right' : e.velocityX < -1 ? 'Left' : e.velocityY > 1 ? 'Down' : e.velocityY < -1 ? 'Up' : null
          if (swipeDirectionFromVelocity) {
            touch.el.trigger('swipe')
            touch.el.trigger('swipe'+ swipeDirectionFromVelocity)
          }
        })
    }

    down = function(e){
      if((_isPointerType = isPointerEventType(e, 'down')) &&
        !isPrimaryTouch(e)) return
      firstTouch = _isPointerType ? e : e.touches[0]
      if (e.touches && e.touches.length === 1 && touch.x2) {
        // Clear out touch movement data if we have it sticking around
        // This can occur if touchcancel doesn't fire due to preventDefault, etc.
        touch.x2 = undefined
        touch.y2 = undefined
      }
      now = Date.now()
      delta = now - (touch.last || now)
      touch.el = $('tagName' in firstTouch.target ?
        firstTouch.target : firstTouch.target.parentNode)
      touchTimeout && clearTimeout(touchTimeout)
      touch.x1 = firstTouch.pageX
      touch.y1 = firstTouch.pageY
      if (delta > 0 && delta <= 250) touch.isDoubleTap = true
      touch.last = now
      longTapTimeout = setTimeout(longTap, longTapDelay)
      // adds the current touch contact for IE gesture recognition
      if (gesture && _isPointerType) gesture.addPointer(e.pointerId)
    }

    move = function(e){
      if((_isPointerType = isPointerEventType(e, 'move')) &&
        !isPrimaryTouch(e)) return
      firstTouch = _isPointerType ? e : e.touches[0]
      cancelLongTap()
      touch.x2 = firstTouch.pageX
      touch.y2 = firstTouch.pageY

      deltaX += Math.abs(touch.x1 - touch.x2)
      deltaY += Math.abs(touch.y1 - touch.y2)
    }

    up = function(e){
      if((_isPointerType = isPointerEventType(e, 'up')) &&
        !isPrimaryTouch(e)) return
      cancelLongTap()

      // swipe
      if ((touch.x2 && Math.abs(touch.x1 - touch.x2) > 30) ||
          (touch.y2 && Math.abs(touch.y1 - touch.y2) > 30))

        swipeTimeout = setTimeout(function() {
          if (touch.el){
            touch.el.trigger('swipe')
            touch.el.trigger('swipe' + (swipeDirection(touch.x1, touch.x2, touch.y1, touch.y2)))
          }
          touch = {}
        }, 0)

      // normal tap
      else if ('last' in touch)
        // don't fire tap when delta position changed by more than 30 pixels,
        // for instance when moving to a point and back to origin
        if (deltaX < 30 && deltaY < 30) {
          // delay by one tick so we can cancel the 'tap' event if 'scroll' fires
          // ('tap' fires before 'scroll')
          tapTimeout = setTimeout(function() {

            // trigger universal 'tap' with the option to cancelTouch()
            // (cancelTouch cancels processing of single vs double taps for faster 'tap' response)
            var event = $.Event('tap')
            event.cancelTouch = cancelAll
            // [by paper] fix -> "TypeError: 'undefined' is not an object (evaluating 'touch.el.trigger'), when double tap
            if (touch.el) touch.el.trigger(event)

            // trigger double tap immediately
            if (touch.isDoubleTap) {
              if (touch.el) touch.el.trigger('doubleTap')
              touch = {}
            }

            // trigger single tap after 250ms of inactivity
            else {
              touchTimeout = setTimeout(function(){
                touchTimeout = null
                if (touch.el) touch.el.trigger('singleTap')
                touch = {}
              }, 250)
            }
          }, 0)
        } else {
          touch = {}
        }
        deltaX = deltaY = 0
    }

    $(document).on(eventMap.up, up)
      .on(eventMap.down, down)
      .on(eventMap.move, move)

    // when the browser window loses focus,
    // for example when a modal dialog is shown,
    // cancel all ongoing events
    $(document).on(eventMap.cancel, cancelAll)

    // scrolling the window indicates intention of the user
    // to scroll, not tap or swipe, so cancel all ongoing events
    $(window).on('scroll', cancelAll)

    initialized = true
  }

  ;['swipe', 'swipeLeft', 'swipeRight', 'swipeUp', 'swipeDown',
    'doubleTap', 'tap', 'singleTap', 'longTap'].forEach(function(eventName){
    $.fn[eventName] = function(callback){ return this.on(eventName, callback) }
  })

  $.touch = { setup: setup }

  $(document).ready(setup)
})(Zepto)


================================================
FILE: src/zepto.js
================================================
//     Zepto.js
//     (c) 2010-2017 Thomas Fuchs
//     Zepto.js may be freely distributed under the MIT license.

var Zepto = (function() {
  var undefined, key, $, classList, emptyArray = [], concat = emptyArray.concat, filter = emptyArray.filter, slice = emptyArray.slice,
    document = window.document,
    elementDisplay = {}, classCache = {},
    cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 },
    fragmentRE = /^\s*<(\w+|!)[^>]*>/,
    singleTagRE = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
    tagExpanderRE = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
    rootNodeRE = /^(?:body|html)$/i,
    capitalRE = /([A-Z])/g,

    // 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')
    },
    simpleSelectorRE = /^[\w-]*$/,
    class2type = {},
    toString = class2type.toString,
    zepto = {},
    camelize, uniq,
    tempParent = document.createElement('div'),
    propMap = {
      'tabindex': 'tabIndex',
      'readonly': 'readOnly',
      'for': 'htmlFor',
      'class': 'className',
      'maxlength': 'maxLength',
      'cellspacing': 'cellSpacing',
      'cellpadding': 'cellPadding',
      'rowspan': 'rowSpan',
      'colspan': 'colSpan',
      'usemap': 'useMap',
      'frameborder': 'frameBorder',
      'contenteditable': 'contentEditable'
    },
    isArray = Array.isArray ||
      function(object){ return object instanceof Array }

  zepto.matches = function(element, selector) {
    if (!selector || !element || element.nodeType !== 1) return false
    var matchesSelector = element.matches || 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) && Object.getPrototypeOf(obj) == Object.prototype
  }

  function likeArray(obj) {
    var length = !!obj && 'length' in obj && obj.length,
      type = $.type(obj)

    return 'function' != type && !isWindow(obj) && (
      'array' == type || length === 0 ||
        (typeof length == 'number' && length > 0 && (length - 1) in obj)
    )
  }

  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 })
  }

  function Z(dom, selector) {
    var i, len = dom ? dom.length : 0
    for (i = 0; i < len; i++) this[i] = dom[i]
    this.length = len
    this.selector = selector || ''
  }

  // `$.zepto.fragment` takes a html string and an optional tag name
  // to generate DOM nodes from the given html string.
  // The generated DOM nodes are returned as an array.
  // This function can be overridden in plugins for example to make
  // it compatible with browsers that don't support the DOM fully.
  zepto.fragment = function(html, name, properties) {
    var dom, nodes, container

    // A special case optimization for a single tag
    if (singleTagRE.test(html)) dom = $(document.createElement(RegExp.$1))

    if (!dom) {
      if (html.replace) html = html.replace(tagExpanderRE, "<$1></$2>")
      if (name === undefined) name = fragmentRE.test(html) && RegExp.$1
      if (!(name in containers)) name = '*'

      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. This method can be overridden in plugins.
  zepto.Z = function(dom, selector) {
    return new Z(dom, selector)
  }

  // `$.zepto.isZ` should return `true` if the given object is a Zepto
  // collection. This method can be overridden 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 overridden in plugins.
  zepto.init = function(selector, context) {
    var dom
    // If nothing given, return an empty Zepto collection
    if (!selector) return zepto.Z()
    // Optimize for string selectors
    else if (typeof selector == 'string') {
      selector = selector.trim()
      // If it's a html fragment, create nodes from it
      // Note: In both Chrome 21 and Firefox 15, DOM error 12
      // is thrown if the fragment doesn't begin with <
      if (selector[0] == '<' && fragmentRE.test(selector))
        dom = zepto.fragment(selector, 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)
      // If it's a CSS selector, use it to select nodes.
      else dom = zepto.qsa(document, selector)
    }
    // 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, just return it
    else if (zepto.isZ(selector)) return selector
    else {
      // normalize array if an array of nodes is given
      if (isArray(selector)) dom = compact(selector)
      // Wrap DOM nodes.
      else if (isObject(selector))
        dom = [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 overridden in plugins.
  zepto.qsa = function(element, selector){
    var found,
        maybeID = selector[0] == '#',
        maybeClass = !maybeID && selector[0] == '.',
        nameOnly = maybeID || maybeClass ? selector.slice(1) : selector, // Ensure that a 1 char tag name still gets checked
        isSimple = simpleSelectorRE.test(nameOnly)
    return (element.getElementById && isSimple && maybeID) ? // Safari DocumentFragment doesn't have getElementById
      ( (found = element.getElementById(nameOnly)) ? [found] : [] ) :
      (element.nodeType !== 1 && element.nodeType !== 9 && element.nodeType !== 11) ? [] :
      slice.call(
        isSimple && !maybeID && element.getElementsByClassName ? // DocumentFragment doesn't have getElementsByClassName/TagName
          maybeClass ? element.getElementsByClassName(nameOnly) : // If it's simple, it could be a class
          element.getElementsByTagName(selector) : // Or a tag
          element.querySelectorAll(selector) // Or it's not simple, and we need to query all
      )
  }

  function filtered(nodes, selector) {
    return selector == null ? $(nodes) : $(nodes).filter(selector)
  }

  $.contains = document.documentElement.contains ?
    function(parent, node) {
      return parent !== node && parent.contains(node)
    } :
    function(parent, node) {
      while (node && (node = node.parentNode))
        if (node === parent) return true
      return false
    }

  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
  // "08"    => "08"
  // JSON    => parse if valid
  // String  => self
  function deserializeValue(value) {
    try {
      return value ?
        value == "true" ||
        ( value == "false" ? false :
          value == "null" ? null :
          +value + "" == value ? +value :
          /^[\[\{]/.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
  }

  $.isNumeric = function(val) {
    var num = Number(val), type = typeof val
    return val != null && type != 'boolean' &&
      (type != 'string' || val.length) &&
      !isNaN(num) && isFinite(num) || false
  }

  $.inArray = function(elem, array, i){
    return emptyArray.indexOf.call(array, elem, i)
  }

  $.camelCase = camelize
  $.trim = function(str) {
    return str == null ? "" : String.prototype.trim.call(str)
  }

  // plugin compatibility
  $.uuid = 0
  $.support = { }
  $.expr = { }
  $.noop = function() {}

  $.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 = {
    constructor: zepto.Z,
    length: 0,

    // 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,
    splice: emptyArray.splice,
    indexOf: emptyArray.indexOf,
    concat: function(){
      var i, value, args = []
      for (i = 0; i < arguments.length; i++) {
        value = arguments[i]
        args[i] = zepto.isZ(value) ? value.toArray() : value
      }
      return concat.apply(zepto.isZ(this) ? this.toArray() : this, args)
    },

    // `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){
      // don't use "interactive" on IE <= 10 (it can fired premature)
      if (document.readyState === "complete" ||
          (document.readyState !== "loading" && !document.documentElement.doScroll))
        setTimeout(function(){ callback($) }, 0)
      else {
        var handler = function() {
          document.removeEventListener("DOMContentLoaded", handler, false)
          window.removeEventListener("load", handler, false)
          callback($)
        }
        document.addEventListener("DOMContentLoaded", handler, false)
        window.addEventListener("load", handler, 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 typeof selector == 'string' ? this.length > 0 && zepto.matches(this[0], selector) : 
          selector && this.selector == selector.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 (!selector) result = $()
      else 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 nodes = [], collection = typeof selector == 'object' && $(selector)
      this.each(function(_, node){
        while (node && !(collection ? collection.indexOf(node) >= 0 : zepto.matches(node, selector)))
          node = node !== context && !isDocument(node) && node.parentNode
        if (node && nodes.indexOf(node) < 0) nodes.push(node)
      })
      return $(nodes)
    },
    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 this.contentDocument || 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 = '')
        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 0 in arguments ?
        this.each(function(idx){
          var originHtml = this.innerHTML
          $(this).empty().append( funcArg(this, html, idx, originHtml) )
        }) :
        (0 in this ? this[0].innerHTML : null)
    },
    text: function(text){
      return 0 in arguments ?
        this.each(function(idx){
          var newText = funcArg(this, text, idx, this.textContent)
          this.textContent = newText == null ? '' : ''+newText
        }) :
        (0 in this ? this.pluck('textContent').join("") : null)
    },
    attr: function(name, value){
      var result
      return (typeof name == 'string' && !(1 in arguments)) ?
        (0 in this && this[0].nodeType == 1 && (result = this[0].getAttribute(name)) != null ? result : undefined) :
        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 && name.split(' ').forEach(function(attribute){
        setAttribute(this, attribute)
      }, this)})
    },
    prop: function(name, value){
      name = propMap[name] || name
      return (typeof name == 'string' && !(1 in arguments)) ?
        (this[0] && this[0][name]) :
        this.each(function(idx){
          if (isObject(name)) for (key in name) this[propMap[key] || key] = name[key]
          else this[name] = funcArg(this, value, idx, this[name])
        })
    },
    removeProp: function(name){
      name = propMap[name] || name
      return this.each(function(){ delete this[name] })
    },
    data: function(name, value){
      var attrName = 'data-' + name.replace(capitalRE, '-$1').toLowerCase()

      var data = (1 in arguments) ?
        this.attr(attrName, value) :
        this.attr(attrName)

      return data !== null ? deserializeValue(data) : undefined
    },
    val: function(value){
      if (0 in arguments) {
        if (value == null) value = ""
        return this.each(function(idx){
          this.value = funcArg(this, value, idx, this.value)
        })
      } else {
        return this[0] && (this[0].multiple ?
           $(this[0]).find('option').filter(function(){ return this.selected }).pluck('value') :
           this[0].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) return null
      if (document.documentElement !== this[0] && !$.contains(document.documentElement, this[0]))
        return {top: 0, left: 0}
      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) {
        var element = this[0]
        if (typeof property == 'string') {
          if (!element) return
          return element.style[camelize(property)] || getComputedStyle(element, '').getPropertyValue(property)
        } else if (isArray(property)) {
          if (!element) return
          var props = {}
          var computedStyle = getComputedStyle(element, '')
          $.each(property, function(_, prop){
            props[prop] = (element.style[camelize(prop)] || computedStyle.getPropertyValue(prop))
          })
          return props
        }
      }

      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){
      if (!name) return false
      return emptyArray.some.call(this, function(el){
        return this.test(className(el))
      }, classRE(name))
    },
    addClass: function(name){
      if (!name) return this
      return this.each(function(idx){
        if (!('className' in this)) return
        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 (!('className' in this)) return
        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){
      if (!name) return this
      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(value){
      if (!this.length) return
      var hasScrollTop = 'scrollTop' in this[0]
      if (value === undefined) return hasScrollTop ? this[0].scrollTop : this[0].pageYOffset
      return this.each(hasScrollTop ?
        function(){ this.scrollTop = value } :
        function(){ this.scrollTo(this.scrollX, value) })
    },
    scrollLeft: function(value){
      if (!this.length) return
      var hasScrollLeft = 'scrollLeft' in this[0]
      if (value === undefined) return hasScrollLeft ? this[0].scrollLeft : this[0].pageXOffset
      return this.each(hasScrollLeft ?
        function(){ this.scrollLeft = value } :
        function(){ this.scrollTo(value, this.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){
    var dimensionProperty =
      dimension.replace(/./, function(m){ return m[0].toUpperCase() })

    $.fn[dimension] = function(value){
      var offset, el = this[0]
      if (value === undefined) return isWindow(el) ? el['inner' + dimensionProperty] :
        isDocument(el) ? el.documentElement['scroll' + dimensionProperty] :
        (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 i = 0, len = node.childNodes.length; i < len; i++)
      traverseNode(node.childNodes[i], 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) {
            var arr = []
            argType = type(arg)
            if (argType == "array") {
              arg.forEach(function(el) {
                if (el.nodeType !== undefined) return arr.push(el)
                else if ($.zepto.isZ(el)) return arr = arr.concat(el.get())
                arr = arr.concat(zepto.fragment(el))
              })
              return arr
            }
            return argType == "object" || 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

        var parentInDocument = $.contains(document.documentElement, parent)

        nodes.forEach(function(node){
          if (copyByClone) node = node.cloneNode(true)
          else if (!parent) return $(node).remove()

          parent.insertBefore(node, target)
          if (parentInDocument) traverseNode(node, function(el){
            if (el.nodeName != null && el.nodeName.toUpperCase() === 'SCRIPT' &&
               (!el.type || el.type === 'text/javascript') && !el.src){
              var target = el.ownerDocument ? el.ownerDocument.defaultView : window
              target['eval'].call(target, 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 = Z.prototype = $.fn

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

  return $
})()

// If `$` is not yet defined, point it to `Zepto`
window.Zepto = Zepto
window.$ === undefined && (window.$ = Zepto)


================================================
FILE: test/ajax.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Ajax unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event ajax ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Ajax unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">
    <div id="ajax_load"></div>
  </div>

  <script>
  (function(){

    function deferredResume(t, fn) {
      setTimeout(function() { t.resume(fn || function(){}) }, 5)
    }

    function resumeOnAjaxError(t) {
      $(document).on('ajaxError', function(e, xhr){
        deferredResume(t, function(){
          t.assert(false, "request errored out: " + xhr.responseText)
        })
      })
    }

    function toArray(list) {
      if ($.type(list) == "string") return list.split(/(?:\s*,\s*|\s+)/)
      else return list
    }

    Evidence.Assertions.assertEqualList = function(expected, actual, message) {
      var expectedList = toArray(expected),
          actualList   = toArray(actual)

      this._assertExpression(
        expectedList.join(' ') == actualList.join(' '),
        message || "Lists don't match.",
        'Expected %o, got %o.', expectedList, actualList
      )
    }

    Evidence.Assertions.assertLine = function(line, string, message) {
      var lines = string.split("\n")

      this._assertExpression(
        $.inArray(line, lines) >= 0,
        message || "Line not found.",
        'Expected line %s in %s.', line, string
      )
    }

    Evidence.Assertions.assertLinePattern = function(pattern, string, message) {
      var lines = string.split("\n")

      var i, match = false
      if (lines.length) {
        for (i = 0; i < lines.length; i++) {
          if (lines[i].search(pattern) !== -1) {
            match = true
            break
          }
        }
      }

      this._assertExpression(
        match === true,
        message || "Pattern not found.",
        'Expected pattern %s in %s.', pattern, string
      )
    }

    var slice = [].slice

    function CallbackRegistry(t) {
      this.testCase = t
      this.called = []
    }
    $.extend(CallbackRegistry.prototype, {
      register: function(name, context, args){
        this.called.push([name, context, args])
      },
      handler: function(name, fn){
        var that = this
        return function(){
          that.register(name, this, slice.call(arguments))
          if (fn) return fn.apply(this, arguments)
        }
      },
      resumeHandler: function(name, fn){
        var that = this
        return this.handler(name, function(){
          var context = this, args = arguments
          setTimeout(function(){
            that.testCase.resume(function(){
              if (fn) fn.apply(context, args)
            })
          }, 5)
        })
      },
      handlers: function(){
        var that = this, hash = {}
        $.each(arguments, function(i, name){
          hash[name] = that.handler(name)
        })
        return hash
      },
      events: function(){
        return $.map(this.called, function(item){ return item[0] })
      },
      context: function(name){
        return this.find(name, function(item){ return item[1] })
      },
      args: function(name){
        return this.find(name, function(item){ return item[2] })
      },
      target: function(name){
        var args = this.args(name)
        return args && args[0].target
      },
      find: function(name, fn){
        var obj
        $.each(this.called, function(i, item){
          if (item[0] == name) {
            obj = fn(item)
            return false
          }
        })
        return obj
      }
    })

    Evidence('ZeptoAjaxTest', {

      setUp: function() {
        var reg = new CallbackRegistry(this),
            globals = toArray('ajaxBeforeSend ajaxSend ajaxSuccess ajaxError ajaxComplete')

        $(document).on(reg.handlers.apply(reg, globals))
        this.reg = reg
        window.jsonpDummy = $.noop
      },

      tearDown: function() {
        $(document).off()
        for (var key in window)
          if (/^(Zepto\d+|blah)$/.test(key) && window[key] === undefined)
            delete window[key]
      },

      testAjaxBase: function(t){
        t.pause()
        var xhr = $.ajax({
          url: 'fixtures/ajax_load_simple.html',
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess complete ajaxComplete', t.reg.events())
          })
        })
        t.assert($.isFunction(xhr.getResponseHeader))
      },

      testAjaxGet: function(t){
        t.pause()
        var xhr = $.get('echo', t.reg.resumeHandler('success', function(response){
          t.assertIdentical(window, this)
          t.assertLine("GET ?{}", response)
          t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess ajaxComplete', t.reg.events())
        }))
        t.assertIn('abort', xhr)
      },

      testAjaxGetWithParams: function(t){
        t.pause()
        $.get('echo', { sample: 'data' }, t.reg.resumeHandler('success', function(response){
          t.assertLine('GET ?{"sample":"data"}', response)
          t.assertLine("accept: */*", response)
        }))
      },

      testAjaxGetWithParamsAndType: function(t){
        t.pause()
        $.get('echo', { sample: 'plain' }, t.reg.resumeHandler('success', function(response){
          t.assertLine('GET ?{"sample":"plain"}', response)
          t.assertLine("accept: text/plain", response)
        }), 'text')
      },

      testAjaxGetWithParamsAndTypeNoCallback: function(t){
        t.pause()
        $(document).on('ajaxSuccess', function(e, xhr, settings, response){
          deferredResume(t, function(){
            t.assertLine('GET ?{"sample":"plain"}', response)
            t.assertLine("accept: text/plain", response)
            t.assertEqualList('ajaxBeforeSend ajaxSend ajaxSuccess ajaxComplete', t.reg.events())
          })
        })
        $.get('echo', { sample: 'plain' }, 'text')
      },

      testAjaxGetWithParamsAutoParsesJSON: function(t) {
        t.pause()
        $.get('json', { sample: 'data' }, t.reg.resumeHandler('success', function(data){
          t.assertEqual('data', data.query.sample)
          t.assertEqual('world', data.hello)
        }))
      },

      testAjaxGetNoParamsAutoParsesJSON: function(t) {
        t.pause()
        $.get('json', t.reg.resumeHandler('success', function(data){
          t.assertIdentical(0, $.map(data.query).length)
          t.assertEqual('world', data.hello)
        }))
      },

      testAjaxGetNullParamsAutoParsesJSON: function(t) {
        t.pause()
        $.get('json', null, t.reg.resumeHandler('success', function(data){
          t.assertIdentical(0, $.map(data.query).length)
          t.assertEqual('world', data.hello)
        }))
      },

      testAjaxBeforeSendSetRequestHeader: function(t){
        t.pause()
        $.ajax({
          url: 'echo',
          beforeSend: function(xhr, settings){
            xhr.setRequestHeader('Accept', 'text/plain')
            t.assertUndefined(settings.headers)
          },
          success: t.reg.resumeHandler('success', function(response){
            t.assertLine("accept: text/plain", response)
          })
        })
      },

      testAjaxPost: function(t){
        t.pause()
        var xhr = $.post('echo', t.reg.resumeHandler('success', function(response){
          t.assertIdentical(window, this)
          t.assertLine("POST ?{}", response)
          t.assertLine("accept: */*", response)
          t.assertLine('{}', response)
          t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess ajaxComplete', t.reg.events())
        }))
        t.assertIn('abort', xhr)
      },

      testAjaxPostWithPayloadAndType: function(t) {
        t.pause()
        var payload = { sample: 'data' }
        $.post('echo', payload, t.reg.resumeHandler('success', function(response){
          t.assertLine("content-type: application/x-www-form-urlencoded", response)
          t.assertLine("accept: text/plain", response)
          t.assertLine('{"sample":"data"}', response)
        }), 'text')
      },

      testAjaxPostAutoParsesJSON: function(t) {
        t.pause()
        var payload = { sample: 'data' }
        $.post('create', payload, t.reg.resumeHandler('success', function(data){
          t.assertEqual('data', data.payload.sample)
        }))
      },

      testNumberOfActiveRequests: function(t) {
        var maxActive = 0, ajaxStarted = 0, ajaxEnded = 0, requestsCompleted = 0
        t.assertIdentical(0, $.active, 'initial count mismatch')
        $(document)
          .on('ajaxStart', function() { ajaxStarted++ })
          .on('ajaxEnd', function() { ajaxEnded++ })
          .on('ajaxSend', function() {
            if ($.active > maxActive) maxActive = $.active
          })
          .on('ajaxComplete', function() {
            if (++requestsCompleted == 3)
              deferredResume(t, function() {
                this.assertEqual(3, maxActive)
                this.assertIdentical(0, $.active)
              })
          })

        t.pause()
        $.ajax({ url: 'echo' })
        $.ajax({ url: 'echo' })
        $.ajax({ url: 'echo' })
      },

      testAjaxJSON: function(t){
        t.pause()
        resumeOnAjaxError(t)

        $.ajax({
          url: 'json',
          headers: { accept: 'application/json' },
          success: t.reg.resumeHandler('success', function(data){
            t.assertEqual('world', data.hello)
          })
        })
      },

      testAjaxDataFilterJSON: function(t){
        t.pause()
        resumeOnAjaxError(t)

        $.ajax({
          url: 'taintedJSON',
          dataFilter: function(data, type) {
            if (!data) return
            return data.replace(/^\s*while\(1\);\s*/, '')
          },
          headers: { accept: 'application/json' },
          success: t.reg.resumeHandler('success', function(data){
            t.assertEqual('world', data.hello)
          })
        })
      },

      testAjaxGetJSON: function(t){
        t.pause()
        resumeOnAjaxError(t)

        var xhr = $.getJSON(
          'json',
          t.reg.resumeHandler('success', function(data){
            t.assertEqual('world', data.hello)
            t.assert($.isEmptyObject(data.query))
            t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess ajaxComplete', t.reg.events())
          })
        )
        t.assertIn('abort', xhr)
      },

      testAjaxGetJSONWithParams: function(t){
        t.pause()
        resumeOnAjaxError(t)

        $.getJSON(
          'json', { sample: 'data' },
          t.reg.resumeHandler('success', function(data){
            t.assertEqual('data', data.query.sample)
          }),
          'text' // ignored
        )
      },

      testAjaxJSONParserError: function(t){
        t.pause()
        $.ajax({
          url:      'json',
          dataType: 'json',
          data:     { invalid: true },
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend error ajaxError complete ajaxComplete', t.reg.events())
            var errorArgs = t.reg.args('error')
            t.assertEqual('parsererror', errorArgs[1])
            t.assert(errorArgs[2] instanceof SyntaxError)
            var globalErrorArgs = t.reg.args('ajaxError')
            t.assert(globalErrorArgs[3] instanceof SyntaxError)
            t.assertEqual(0, $('script[src^=slow]').size())
          })
        })
      },

      testAjaxEqualQuestionmarkIsNotAlwaysJSONP: function(t){
        t.pause()
        resumeOnAjaxError(t)
        $.ajax({
          url: 'echo=?',
          dataType: 'text',
          success: t.reg.resumeHandler('success', function(data){
            t.assertLine('GET ?{}', data)
            t.assertLine("accept: text/plain", data)
          })
        })
      },

      testAjaxGetJSONP: function(t){
        t.pause()
        $.getJSON(
          'jsonp?callback=?&timestamp='+(+new Date),
          t.reg.resumeHandler('success', function(data){
            t.assertEqual('world', data.hello)
            t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess ajaxComplete', t.reg.events())
            t.assertEqual(0, $('script[src^=jsonp]').size())
          })
        )
        t.assertEqual(1, $('script[src^=jsonp]').size())
      },

      testAjaxGetJSONPWithParams: function(t){
        t.pause()
        $.getJSON(
          'jsonp?callback=?&timestamp='+(+new Date),
          { sample: 'data' },
          t.reg.resumeHandler('success', function(data){
            t.assertEqual('data', data.query.sample)
          })
        )
      },

      testAjaxJSONP: function(t){
        t.pause()
        var xhr = $.ajaxJSONP({
          url: 'jsonp?callback=?&timestamp='+(+new Date),
          success:  t.reg.handler('success'),
          complete: t.reg.resumeHandler('complete', function(data){
            var successArgs = t.reg.args('success')
            t.assertEqual('world', successArgs[0].hello)
            t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess complete ajaxComplete', t.reg.events())
            t.assertEqual(0, $('script[src^=jsonp]').size())
          })
        })
        t.assertIn('abort', xhr)
      },

      testAjaxJSONPBeforeSend: function(t){
        t.pause()
        $(document).on('ajaxBeforeSend', function(){ return false })

        $.ajax({
          url: 'jsonp?callback=?&timestamp='+(+new Date),
          beforeSend: t.reg.resumeHandler('beforeSend', function(){
            t.assertEqualList('beforeSend ajaxBeforeSend ajaxError complete ajaxComplete', t.reg.events())
          }),
          success:  t.reg.handler('success'),
          complete: t.reg.handler('complete')
        })
      },

      testAjaxGetJSONPErrorCallback: function(t){
        t.pause()
        $.ajax({
          type:     'GET',
          url:      'fixtures/404.js?timestamp='+(+new Date),
          dataType: 'jsonp',
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend error ajaxError complete ajaxComplete', t.reg.events())
            t.assertEqual(0, $('script[src^=fixtures]').size())
          })
        })
      },

      testAjaxGetJSONPErrorWithoutCallback: function(t){
        t.pause()
        $.ajax({
          type:     'GET',
          url:      'fixtures/404.js?timestamp='+(+new Date),
          dataType: 'jsonp',
          success:  t.reg.handler('success'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend ajaxError complete ajaxComplete', t.reg.events())
            t.assertEqual(0, $('script[src^=fixtures]').size())
          })
        })
      },

      testAjaxJSONPTimeout: function(t){
        t.pause()
        $.ajax({
          url:      'slow?timestamp='+(+new Date),
          dataType: 'jsonp',
          jsonpCallback: 'jsonpDummy',
          timeout:  20,
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend error ajaxError complete ajaxComplete', t.reg.events())
            var errorArgs = t.reg.args('error')
            t.assertEqual('timeout', errorArgs[1])
            var globalErrorArgs = t.reg.args('ajaxError')
            t.assertEqual('timeout', globalErrorArgs[3])
            t.assertEqual(0, $('script[src^=slow]').size())
          })
        })
      },

      testAjaxJSONPAbort: function(t){
        t.pause()
        var xhr = $.ajax({
          url:      'slow?timestamp='+(+new Date),
          dataType: 'jsonp',
          jsonpCallback: 'jsonpDummy',
          timeout:  30,
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.handler('complete')
        })
        setTimeout(function(){ xhr.abort() }, 10)

        setTimeout(function(){
          t.resume(function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend error ajaxError complete ajaxComplete', t.reg.events())
            var errorArgs = t.reg.args('error')
            t.assertEqual('abort', errorArgs[1])
            var globalErrorArgs = t.reg.args('ajaxError')
            t.assertEqual('abort', globalErrorArgs[3])
            t.assertEqual(0, $('script[src^=slow]').size())
          })
        }, 50)
      },

      testAjaxJSONPError: function(t){
        t.pause()
        var xhr = $.ajax({
          url:      'error?timestamp='+(+new Date),
          dataType: 'jsonp',
          success:  t.reg.handler('success'),
          error:    t.reg.handler('error'),
          complete: t.reg.resumeHandler('complete', function(){
            t.assertEqualList('ajaxBeforeSend ajaxSend error ajaxError complete ajaxComplete', t.reg.events())
            var errorArgs = t.reg.args('error')
            t.assertEqual('error', errorArgs[1])
            t.assertEqual(0, $('script[src^=error]').size())
          })
        })
      },

      testAjaxJSONPWithDataSupport: function(t) {
        t.pause()
        var xhr = $.ajax({
          url: 'jsonp?callback=?&timestamp='+(+new Date),
          data: {
            param1: 'val1',
            param2: 'val2'
          },
          success: t.reg.resumeHandler('success', function(data){
            t.assertEqual('val1', data.query.param1)
            t.assertEqual('val2', data.query.param2)
          })
        })
      },

      testAjaxJSONPWithCallbackName: function(t) {
        var xhr = $.ajax({
          url: 'jsonp',
          dataType: 'jsonp',
          jsonpCallback: 'blah',
          success: t.reg.resumeHandler('success', function(data){
            t.assertUndefined(window.blah)
          })
        })

        t.assert($.isFunction(window.blah))
        t.pause()
      },

      testAjaxJSONPWithCallbackNameAsFunction: function(t) {
        var xhr = $.ajax({
          url: 'jsonp',
          dataType: 'jsonp',
          jsonpCallback: function(){ return 'blah' },
          success: t.reg.resumeHandler('success', function(data){
            t.assertUndefined(window.blah)
          })
        })

        t.assert($.isFunction(window.blah))
        t.pause()
      },

      testAjaxJSONPWithCallbackNameAndJSONPsetToFalse: function(t) {
        var xhr = $.ajax({
          url: 'jsonpBlah',
          dataType: 'jsonp',
          jsonp: false,
          jsonpCallback: 'blah',
          success: t.reg.resumeHandler('success', function(data){
            t.assertUndefined(window.blah)
          })
        })

        var scriptSrc = $('head script:last-child').attr('src')
        t.assert(/^jsonpBlah\?_=[\d]{13}$/.test(scriptSrc), scriptSrc)
        t.assert($.isFunction(window.blah))
        t.pause()
      },

      testAjaxJSONPWithCallbackNameAsFunctionAndJSONPsetToFalse: function(t) {
        var xhr = $.ajax({
          url: 'jsonpBlah',
          dataType: 'jsonp',
          jsonp: false,
          jsonpCallback: function(){ return 'blah' },
          success: t.reg.resumeHandler('success', function(data){
            t.assertUndefined(window.blah)
          })
        })

        var scriptSrc = $('head script:last-child').attr('src')
        t.assert(/^jsonpBlah\?_=[\d]{13}$/.test(scriptSrc), scriptSrc)
        t.assert($.isFunction(window.blah))
        t.pause()
      },

      testAjaxJSONPWithData: function(t) {
        t.pause()
        $.ajax({
          url: 'jsonp',
          type: 'post',
          data: { foo: 'bar' },
          dataType: 'jsonp',
          success: t.reg.resumeHandler('success', function(data){
            t.assertEqual('bar', data.query.foo)
          })
        })
      },

      testNoCacheParam: function(t) {
        t.pause()
        var xhr = $.ajax({
          url:'echo',
          cache: false,
          success: t.reg.resumeHandler('success', function(response){
            // check that the no-cache param (or an element of it) looks like a timestamp
            t.assertLinePattern(/"_":(\[".*",)?"[\d]{13}"/g, response)
          })
        })
      },

      testNoCacheParameterWithParam: function(t) {
        t.pause()
        var xhr = $.ajax({
          url:'echo',
          data:{ data: 'sample' },
          cache: false,
          success: t.reg.resumeHandler('success', function(response){
            // check that the no-cache param (or an element of it) looks like a timestamp
            t.assertLinePattern(/"_":(\[".*",)?"[\d]{13}"/g, response)
          })
        })
      },

      testNoCacheParameterAlreadyPresent: function(t) {
        t.pause()
        var xhr = $.ajax({
          url:'echo',
          data:{ _: 'test' },
          cache: false,
          success: t.reg.resumeHandler('success', function(response){
            // check that the no-cache param (or an element of it) looks like a timestamp
            t.assertLinePattern(/"_":(\[".*",)?"[\d]{13}"/g, response)
          })
        })
      },

      testNoCacheParameterAlreadyPresentWithParam: function(t) {
        t.pause()
        var xhr = $.ajax({
          url:'echo',
          data:{ _: 'test', data: 'sample' },
          cache: false,
          success: t.reg.resumeHandler('success', function(response){
            // check that the no-cache param (or an element of it) looks like a timestamp
            t.assertLinePattern(/"_":(\[".*",)?"[\d]{13}"/g, response)
          })
        })
      },

      testJSONPCacheBustingByDefault: function(t) {
        $.ajax({
          url: 'jsonp?callback=?',
          success: t.reg.resumeHandler('success')
        })

        var scriptSrc = $('head script:last-child').attr('src')
        t.assert(/^jsonp\?callback=Zepto\d+&_=[\d]{13}$/.test(scriptSrc), scriptSrc)
        t.pause()
      },

      testJSONPCacheBustingDisabled: function(t) {
        $.ajax({
          url: 'jsonp?callback=?',
          cache: true,
          success: t.reg.resumeHandler('success')
        })

        var scriptSrc = $('head script:last-child').attr('src')
        t.assert(/^jsonp\?callback=Zepto\d+$/.test(scriptSrc), scriptSrc)
        t.pause()
      },

      testBrowserCaching: function(t) {
        t.pause()
        resumeOnAjaxError(t)
        $.ajax({
          url: 'cached',
          cache: true,
          success: function(firstResponse){
            $.ajax({
              url: 'cached',
              cache: true,
              success: t.reg.resumeHandler('success', function(secondResponse){
                t.assertEqual(secondResponse, firstResponse)
              })
            })
          }
        })
      },

      testAjaxLoad: function(t) {
        t.pause()
        var testEl = $('#ajax_load')
        var el = testEl.load(
          'fixtures/ajax_load_simple.html',
          t.reg.resumeHandler('success', function(response, status, xhr){
            t.assertIdentical(testEl, this)
            t.assertEqual("simple ajax load\n", response.replace(/\r\n|\r/,"\n"))
            t.assertEqual('simple ajax load', testEl.html().trim())
            t.assertEqual('success', status)
            t.assertIn('abort', xhr)
            t.assertEqualList('ajaxBeforeSend ajaxSend success ajaxSuccess ajaxComplete', t.reg.events())
          })
        )
        t.assertIdentical(testEl, el)
      },

      testAjaxLoadWithSelector: function(t) {
        t.pause()
        var testEl = $('#ajax_load')
        testEl.load(
          'fixtures/ajax_load_selector.html #ajax_load_test_div',
          t.reg.resumeHandler('success', function(){
            t.assertEqual(
              '<div id="ajax_load_test_div">ajax load with selector</div>',
              testEl.html().trim()
            )
          })
        )
      },

      testAjaxLoadWithJavaScript: function (t) {
        var testEl = $('#ajax_load')
        t.pause()
        window.testValue = 0
        testEl.load('fixtures/ajax_load_selector_javascript.html', function(){
          deferredResume(t, function(){
            this.assertEqual(window.testValue, 1)
            delete window.testValue
          })
        })
      },

      testAjaxLoadWithSelectorAndJavaScript: function (t) {
        var testEl = $('#ajax_load')
        t.pause()
        window.testValue = 0
        testEl.load('fixtures/ajax_load_selector_javascript.html #ajax_load_test_div', function() {
          deferredResume(t, function(){
            this.assertEqual(window.testValue, 0)
            delete window.testValue
          })
        })
      },

      testAjaxWithContext: function(t) {
        t.pause()
        var body = $('body')
        $.ajax({
          url:        'fixtures/ajax_load_simple.html',
          context:    body,
          beforeSend: t.reg.handler('beforeSend'),
          success:    t.reg.handler('success'),
          complete:   t.reg.resumeHandler('complete', function(){
            t.assertIdentical(body, this)
            t.assertIdentical(body, t.reg.context('beforeSend'))
            t.assertIdentical(body, t.reg.context('success'))
            t.assertIdentical(document.body, t.reg.target('ajaxBeforeSend'))
            t.assertIdentical(document.body, t.reg.target('ajaxSuccess'))
          })
        })
      },

      testAjaxWithContextPlainObject: function(t) {
        t.pause()
        var obj = {}
        $.ajax({
          url:        'fixtures/ajax_load_simple.html',
          context:    obj,
          beforeSend: t.reg.handler('beforeSend'),
          success:    t.reg.handler('success'),
          complete:   t.reg.resumeHandler('complete', function(){
            t.assertIdentical(obj, this)
            t.assertIdentical(obj, t.reg.context('beforeSend'))
            t.assertIdentical(obj, t.reg.context('success'))
            t.assertUndefined(t.reg.target('ajaxBeforeSend'))
            t.assertUndefined(t.reg.target('ajaxSuccess'))
          })
        })
      },

      testAjaxLoadJavaScript: function (t) {
        t.pause()
        window.testValue = 0
        var xhr = $.ajax({
          url:'fixtures/ajax_load_javascript.js',
          success: t.reg.resumeHandler('success', function(response){
            // check that the javascript has loaded and executed.
            t.assertEqual(window.testValue, 1)
            delete window.testValue
          })
        })
      },

      testAjaxBasicAuth: function(t) {
        t.pause()
        resumeOnAjaxError(t)
        $.ajax({
          url: 'auth?realm=zepto',
          username: 'zepto',
          password: 'doge',
          success: t.reg.resumeHandler('success')
        })
      }
    })

    var OriginalXHR = $.ajaxSettings.xhr

    function MockXHR() {
      this.headers = []
      this.responseHeaders = {}
      MockXHR.last = this
    }
    MockXHR.prototype = {
      open: function(method, url, async) {
        this.method = method
        this.url = url
        this.async = async
      },
      setRequestHeader: function(name, value) {
        if (!this.method) throw "setRequestHeader() called before open()"
        this.headers.push({ name: name, value: value })
      },
      getResponseHeader: function(name) {
        return this.responseHeaders[name]
      },
      overrideMimeType: function(type) {
        this.responseHeaders['content-type'] = type
      },
      withCredentials: false,
      send: function(data) {
        this.data = data
      },
      abort: function() {
        this.aborted = true
      },
      ready: function(readyState, status, responseText, headers) {
        this.readyState = readyState
        this.status = status
        this.responseText = responseText
        $.extend(this.responseHeaders, headers)
        this.onreadystatechange()
      },
      onreadystatechange: function() {}
    }

    function matchHeader(name, value) {
      return function(header) {
        return header.name == name && (!value || header.value == value)
      }
    }

    Evidence('ZeptoAjaxTest2', {
      setUp: function() {
        $.ajaxSettings.xhr = function(){ return new MockXHR }
      },

      tearDown: function() {
        $.ajaxSettings.xhr = OriginalXHR
        $(document).off()
        $.active = 0
      },

      testTypeDefaultsToGET: function(t) {
        $.ajax({
          url: '/foo',
          beforeSend: function(xhr, settings) {
            t.assertFalse(settings.crossDomain)
          }
        })
        t.assertEqual('GET', MockXHR.last.method)
      },

      testURLDefaultsToWindowLocation: function(t) {
        $.ajax()
        t.assertEqual(window.location, MockXHR.last.url)
      },

      testCrossDomainCrossOrigin: function(t) {
        $.ajax({
          url: 'http://example.com/foo',
          beforeSend: function(xhr, settings) {
            t.assertTrue(settings.crossDomain)
          }
        })
      },

      testCrossDomainSameOrigin: function(t) {
        $.ajax({
          url: window.location.href,
          beforeSend: function(xhr, settings) {
            t.assertFalse(settings.crossDomain)
          }
        })
      },

      testCrossDomainLeadingSpace: function(t) {
        $.ajax({
          url: ' http://example.com/foo',
          beforeSend: function(xhr, settings) {
            t.assertTrue(settings.crossDomain)
          }
        })
      },

      testCrossDomainTrippleSlash: function(t) {
        $.ajax({
          url: 'http:///example.com/foo',
          beforeSend: function(xhr, settings) {
            t.assertTrue(settings.crossDomain)
          }
        })
      },

      testCrossDomainWithQuery: function(t) {
        $.ajax({
          url: window.location.href + "?foo=bar",
          beforeSend: function(xhr, settings) {
            t.assertFalse(settings.crossDomain)
          }
        })
      },

      testCrossDomainDifferentScheme: function(t) {
        $.ajax({
          url: "foo://" + window.location.host,
          beforeSend: function(xhr, settings) {
            t.assertTrue(settings.crossDomain)
          }
        })
      },

      testCrossDomainPeriodInScheme: function(t) {
        $.ajax({
          url: "foo.bar://example.com/foo",
          beforeSend: function(xhr, settings) {
            t.assertTrue(settings.crossDomain)
          }
        })
      },

      testDefaultAcceptHeader: function(t) {
        $.ajax()
        t.assert(MockXHR.last.headers.some(matchHeader('Accept', '*/*')))
      },

      testDataTypeOptionSetsAcceptHeader: function(t) {
        $.ajax({ dataType: 'json' })
        t.assert(MockXHR.last.headers.some(matchHeader('Accept', 'application/json')))
        // verifies overrideMimeType:
        t.assertEqual('application/json', MockXHR.last.getResponseHeader('content-type'))

        $.ajax({ dataType: 'script' })
        //check that the head matches all of those required for loading scripts.
        t.assert(MockXHR.last.headers.some(matchHeader('Accept', 'text/javascript, application/javascript, application/x-javascript')))
      },

      testMimeTypeOptionOverride: function(t) {
        $.ajax({ mimeType: 'text/plain' })
        t.assertEqual('text/plain', MockXHR.last.getResponseHeader('content-type'))
      },

      testContentTypeOptionSetsContentTypeHeader: function(t) {
        $.ajax()
        t.assert(!MockXHR.last.headers.some(matchHeader('Content-Type')))

        $.ajax({ contentType: 'text/html' })
        t.assert(MockXHR.last.headers.some(matchHeader('Content-Type', 'text/html')))

        $.ajax({ type: 'POST', data: [], contentType: 'application/x-foo' })
        t.assert(MockXHR.last.headers.some(matchHeader('Content-Type', 'application/x-foo')))
      },

      testHeadersOptionCanSetContentType: function(t) {
        $.ajax({ type: 'POST', data: [], headers: { 'Content-Type': 'application/hal+json' }})
        t.assert(MockXHR.last.headers.some(matchHeader('Content-Type', 'application/hal+json')))
      },

      testContentTypeDefaultsToUrlEncoded: function(t) {
        $.ajax({ type: 'GET', data: 'x' })
        t.refute(MockXHR.last.headers.some(matchHeader('Content-Type', 'application/x-www-form-urlencoded')))
        $.ajax({ type: 'POST', data: 'x' })
        t.assert(MockXHR.last.headers.some(matchHeader('Content-Type', 'application/x-www-form-urlencoded')))
      },

      testDefaultContentTypeDisabled: function(t) {
        $.ajax({ type: 'POST', data: {a:1}, contentType: false })
        t.refute(MockXHR.last.headers.some(matchHeader('Content-Type')))
      },

      testCustomHeader: function(t) {
        $.ajax({ headers: {'X-Awesome': 'true'} })
        t.assert(MockXHR.last.headers.some(matchHeader('X-Requested-With', 'XMLHttpRequest')))
        t.assert(MockXHR.last.headers.some(matchHeader('X-Awesome', 'true')))
      },

      testXhrFieldsOptionSetsWithCredentialsProperty: function(t) {
        var xhr = $.ajax({
          url: 'http://example.com/foo',
          xhrFields: { withCredentials: true }
        })
        t.assert(xhr.withCredentials)
      },

      testScriptDataTypeCacheBustByDefault: function(t) {
        $.ajax({ url: '/', dataType: 'script' })
        var xhr = MockXHR.last
        t.assert(/^\/\?_=[\d]{13}$/.test(xhr.url), xhr.url)
      },

      testScriptDataTypeCacheBustDisable: function(t) {
        $.ajax({ url: '/', dataType: 'script', cache: true })
        var xhr = MockXHR.last
        t.assertEqual('/', xhr.url)
      },

      testJSONdataType: function(t) {
        var result = {}
        $.ajax({ dataType: 'json', success: function(json) {result = json } })
        MockXHR.last.ready(4, 200, '{"hello":"world"}')
        t.assertEqual("world", result.hello)
      },

      testJSONcontentType: function(t) {
        var result = {}
        $.ajax({ success: function(json) {result = json } })
        MockXHR.last.ready(4, 200, '{"hello":"world"}', {'content-type': 'application/json'})
        t.assertEqual("world", result.hello)
      },

      testJSONResponseBodiesAreNotParsedWhenDataTypeOptionIsJSONButResponseIsEmptyString: function(t) {
        var result, success = false
        $.ajax({ dataType: 'json', success: function(json) {result = json; success = true } })
        MockXHR.last.ready(4, 200, '')
        t.assert(success)
        t.assertNull(result)
      },

      testJSONResponseBodiesAreNotParsedWhenDataTypeOptionIsJSONButResponseIsSingleSpace: function(t) {
        var result, success = false
        $.ajax({ dataType: 'json', success: function(json) {result = json; success = true } })
        MockXHR.last.ready(4, 200, ' ')
        t.assert(success)
        t.assertNull(result)
      },

      testDataIsNotSentAsBodyForGetRequests: function(t) {
        $.ajax({ type: 'GET', data: {a:'b'} })
        t.assertNull(MockXHR.last.data)
      },

      testDataOptionIsConvertedToSerializedForm: function(t) {
        $.ajax({
          type: 'POST',
          data: {hello: 'world', array: [1,2,3], object: { prop1: 'val', prop2: 2 } }
        })
        var data = decodeURIComponent(MockXHR.last.data)
        t.assertEqual('hello=world&array[]=1&array[]=2&array[]=3&object[prop1]=val&object[prop2]=2', data)
      },

      testDataOptionIsConvertedToSerializedTraditionalForm: function(t) {
        $.ajax({
          type: 'POST',
          data: {hello: 'world', array: [1,2,3], object: { prop1: 'val', prop2: 2 } },
          traditional: true
        })
        var data = decodeURIComponent(MockXHR.last.data)
        t.assertEqual('hello=world&array=1&array=2&array=3&object=[object+Object]', data)
      },

      testQueryParamsTraditional: function(t) {
        $.ajax({
          url: '/',
          data: {hello: 'world', array: [1,2,3], object: { prop1: 'val', prop2: 2 } },
          traditional: true
        })
        var url = decodeURIComponent(MockXHR.last.url)
        t.assertEqual('/?hello=world&array=1&array=2&array=3&object=[object+Object]', url)
      },

      testProcessDataDisabled: function(t) {
        var data = { country: 'Ecuador' }
        $.ajax({
          data: data,
          processData: false,
          type: "POST"
        })
        t.assertIdentical(data, MockXHR.last.data)
      },

      testDataIsAppendedToGETURL: function(t) {
        $.ajax({ url:'test.html', data:'foo=bar' })
        t.assertEqual('test.html?foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html', data:'?foo=bar' })
        t.assertEqual('test.html?foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html?', data:'foo=bar' })
        t.assertEqual('test.html?foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html?baz', data:'foo=bar' })
        t.assertEqual('test.html?baz&foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html?bar=baz', data:'foo=bar' })
        t.assertEqual('test.html?bar=baz&foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html', data:{foo:'bar'} })
        t.assertEqual('test.html?foo=bar', MockXHR.last.url)
      },

      testDataIsAppendedToGETURLWithHashStripped: function(t) {
        $.ajax({ url:'test.html#?ignore=me', data:'foo=bar' })
        t.assertEqual('test.html?foo=bar', MockXHR.last.url)

        $.ajax({ url:'test.html?a=b#?ignore=me', data:'foo=bar' })
        t.assertEqual('test.html?a=b&foo=bar', MockXHR.last.url)
      },

      testScriptResponseIsEvald: function(t) {
        var result
        $.ajax({ success: function(text){ result = text } })
        MockXHR.last.ready(4, 200, 'this.testValue = 42', {'content-type': 'application/javascript'})
        t.assertEqual('this.testValue = 42', result)
        t.assertIdentical(42, window.testValue)
        delete window.testValue
      },

      testErrorCallback: function(t) {
        var successFired = false, xhr, status
        $.ajax({
          success: function() { successFired = true },
          error: function(x, s) { xhr = x, status = s }
        })

        MockXHR.last.ready(4, 500, '500 Internal Server Error')
        t.assert(!successFired)
        t.assertEqual(MockXHR.last, xhr)
        t.assertEqual('error', status)
      },

      testErrorCallbackWithInvalidJSON: function(t) {
        var successFired = false, xhr, status, exception
        $.ajax({
          dataType: 'json',
          succes: function() { successFired = true },
          error: function(x, s, e) { xhr = x, status = s, exception = e }
        })

        MockXHR.last.ready(4, 200, '{invalid')
        t.assert(!successFired)
        t.assertEqual(MockXHR.last, xhr)
        t.assertEqual('parsererror', status)
        t.assert(exception.toString().match(/SyntaxError/))
      },

      test201ResponseIsSuccess: function(t) {
        var successFired, errorFired
        $.ajax({
          success: function() { successFired = true },
          error: function() { errorFired = true }
        })

        MockXHR.last.ready(4, 201, 'Created')
        t.assert(successFired)
        t.refute(errorFired)
      },

      test304ResponseIsSuccess: function(t) {
        var successFired, errorFired
        $.ajax({
          success: function() { successFired = true },
          error: function() { errorFired = true }
        })

        MockXHR.last.ready(4, 304, 'Not Modified')
        t.assert(successFired)
        t.refute(errorFired)
      },
      testXHRParameterInSuccessCallback: function(t) {
        var body, status, xhr
        $.ajax({
          success: function(b, s, x) { body = b, status = s, xhr = x }
        })

        MockXHR.last.ready(4, 200, 'Hello')
        t.assertEqual('Hello', body)
        t.assertEqual('success', status)
        t.assertEqual(MockXHR.last, xhr)

        body = status = xhr = null
        $.ajax({
          dataType: 'json',
          success: function(b, s, x) { body = b, status = s, xhr = x }
        })

        MockXHR.last.ready(4, 200, '{"message":"Hello"}')
        t.assertEqual('Hello', body.message)
        t.assertEqual('success', status)
        t.assertEqual(MockXHR.last, xhr)
      },

      testBeforeSendCanChangeUrl: function(t) {
        var xhr = $.ajax({
          url: 'one',
          beforeSend: function(x, s) {
            s.url = 'two'
          }
        })
        t.assertEqual('two', xhr.url)
      },

      testBeforeSendCanChangeMethod: function(t) {
        var xhr = $.ajax({
          type: 'POST',
          beforeSend: function(x, s) {
            s.type = 'PUT'
          }
        })
        t.assertEqual('PUT', xhr.method)
      },

      testBeforeSendCanAccessSerializedPostData: function(t) {
        var xhr = $.ajax({
          type: 'POST',
          data: { a:'b' },
          beforeSend: function(x, s) {
            s.data = s.data.toUpperCase()
          }
        })
        t.assertEqual('A=B', xhr.data)
      },

      testBeforeSendCannotAccessRawQueryParams: function(t) {
        var url, data
        $.ajax({
          url: '/',
          type: 'GET',
          data: { a:'b' },
          beforeSend: function(x, s) {
            url = s.url
            data = s.data
          }
        })
        t.assertEqual('/?a=b', url)
        t.assertUndefined(data)
      },

      testBeforeSendCannotChangeOrAddHeadersViaObject: function(t) {
        var xhr = $.ajax({
          headers: { a:'b', c:'d' },
          beforeSend: function(x, s) {
            s.headers['a'] = 'B'
            s.headers['e'] = 'f'
          }
        })
        t.assert(xhr.headers.some(matchHeader('a', 'b')))
        t.assert(xhr.headers.some(matchHeader('c', 'd')))
        t.refute(xhr.headers.some(matchHeader('e', 'f')))
      },

      testBeforeSendCanChangeAndAddHeadersViaXhr: function(t) {
        var xhr = $.ajax({
          headers: { a:'b', c:'d' },
          beforeSend: function(x, s) {
            x.setRequestHeader('a', 'B')
            x.setRequestHeader('e', 'f')
          }
        })
        t.assert(xhr.headers.some(matchHeader('a', 'B')))
        t.assert(xhr.headers.some(matchHeader('c', 'd')))
        t.assert(xhr.headers.some(matchHeader('e', 'f')))
      },

      testBeforeSendAbortCallback: function(t) {
        var xhr, settings
        $.ajax({
          beforeSend: function(x, s) {
            settings = s, xhr = x
          }
        })

        t.assertEqual(MockXHR.last, xhr)
        t.assertEqual('GET', settings.type)
      },

      testBeforeSendAbort: function(t) {
        var xhr
        $.ajax({ beforeSend: function(x) { xhr = x; return false } })

        t.assert(xhr.aborted)
      },

      testGlobalBeforeSendAbort: function(t) {
        $(document).on('ajaxBeforeSend', false)
        var xhr = $.ajax()
        t.assert(xhr.aborted)
      },

      testGlobalAjaxSendCantAbort: function(t) {
        var xhr
        $(document).on('ajaxSend', function(e, x) { xhr = x; return false })
        t.assert($.ajax())
        t.assert(!xhr.aborted)
      },

      testCompleteCallback: function(t) {
        var status, xhr
        $.ajax({ complete: function(x, s) { status = s, xhr = x } })

        MockXHR.last.ready(4, 200, 'OK')
        t.assertEqual(MockXHR.last, xhr)
        t.assertEqual('success', status)
      },

      testCallbackOrder: function(t) {
        var order = []
        $.ajax({
          beforeSend: function() { order.push('beforeSend') },
          success: function() { order.push('success') },
          complete: function() { order.push('complete') }
        })

        MockXHR.last.ready(4, 200, 'OK')
        t.assertEqual('beforeSend,success,complete', order.join(','))
      },

      testGlobalCallbacks: function(t) {
        var fired = []
        $(document).on('ajaxStart ajaxBeforeSend ajaxSend ajaxSuccess ajaxError ajaxComplete ajaxStop', function(e) {
          fired.push(e.type)
        })

        $.ajax({
          beforeSend: function() { fired.push('beforeSend') },
          success:    function() { fired.push('success') },
          error:      function() { fired.push('error') },
          complete:   function() { fired.push('complete') }
        })
        t.assertEqual('ajaxStart beforeSend ajaxBeforeSend ajaxSend', fired.join(' '))

        fired = []
        MockXHR.last.ready(4, 200, 'OK')
        t.assertEqual('success ajaxSuccess complete ajaxComplete ajaxStop', fired.join(' '))
      },

      testGlobalCallbacksOff: function(t) {
        var fired = []
        $(document).on('ajaxStart ajaxBeforeSend ajaxSend ajaxSuccess ajaxError ajaxComplete ajaxStop', function(e) {
          fired.push(e.type)
        })

        $.ajax({
          global:     false,
          beforeSend: function() { fired.push('beforeSend') },
          success:    function() { fired.push('success') },
          error:      function() { fired.push('error') },
          complete:   function() { fired.push('complete') }
        })
        t.assertEqual('beforeSend', fired.join(' '))

        fired = []
        MockXHR.last.ready(4, 200, 'OK')
        t.assertEqual('success complete', fired.join(' '))
      },

      testTimeout: function(t) {
        var successFired = false, xhr, status, globalStatus
        t.pause()
        $(document).on('ajaxError', function (e, x, o, s) {
          globalStatus = s
        })

        $.ajax({
          timeout: 30,
          success: function() { successFired = true },
          error: function(x, s) { xhr = x, status = s }
        })

        setTimeout(function(){
          t.assertFalse(successFired)
          t.assertUndefined(status)
        }, 20)

        setTimeout(function(){
          t.resume(function(){
            t.assertFalse(successFired)
            t.assertTrue(xhr.aborted)
            t.assertEqual('timeout', status)
            t.assertEqual('timeout', globalStatus)
          })
        }, 40)
      },

      testAbort: function(t) {
        var successFired = false, xhr, status, globalStatus
        t.pause()
        $(document).on('ajaxError', function (e, x, o, s) {
          globalStatus = s
        })

        $.ajax({
          success: function() { successFired = true },
          error: function(x, s) { xhr = x, status = s }
        })
        MockXHR.last.abort()
        MockXHR.last.ready(4, 0, 'Aborted')

        setTimeout(function(){
          t.resume(function(){
            t.assertFalse(successFired)
            t.assertTrue(xhr.aborted)
            t.assertEqual('abort', status)
            t.assertEqual('abort', globalStatus)
          })
        }, 20)
      },

      testAsyncDefaultsToTrue: function(t) {
        $.ajax({ url: '/foo' })
        t.assertTrue(MockXHR.last.async)
      },

      testAsyncFalse: function(t) {
        $.ajax({ url: '/foo', async: false })
        t.assertFalse(MockXHR.last.async)
      }
    })

    Evidence('ZeptoAjaxHelperMethodsTest', {

      testParamMethod: function(t) {
        var result = $.param({ libs: ['jQuery', 'script.aculo.us', 'Prototype', 'Dojo'] })
        result = decodeURIComponent(result)
        t.assertEqual(result, "libs[]=jQuery&libs[]=script.aculo.us&libs[]=Prototype&libs[]=Dojo")

        result = $.param({ jquery: 'Javascript', rails: 'Ruby', django: 'Python' })
        result = decodeURIComponent(result)
        t.assertEqual(result, "jquery=Javascript&rails=Ruby&django=Python")

        result = $.param({
          title: "Some Countries",
          list: ['Ecuador', 'Austria', 'England'],
          capitals: { ecuador: 'Quito', austria: 'Vienna', GB: { england: 'London', scotland: 'Edinburgh'} }
        })
        result = decodeURIComponent(result)
        t.assertEqual(result, "title=Some+Countries&list[]=Ecuador&list[]=Austria&list[]=England&capitals[ecuador]=Quito&capitals[austria]=Vienna&capitals[GB][england]=London&capitals[GB][scotland]=Edinburgh")
      },

      testParamNullValues: function(t) {
        t.assertEqual("x=&a[b]=&a[c]=",
          decodeURIComponent($.param({ x: null, a: { b: null, c: undefined }})))
        t.assertEqual("x=",
          decodeURIComponent($.param([{ name: "x", value: null }])))
      },

      testParamFunctionValues: function(t) {
        t.assertEqual("x=&a[b]=B",
          decodeURIComponent($.param({ x: function(){}, a: { b: function(){ return "B" }}})))
        t.assertEqual("x=&a[b]=B",
          decodeURIComponent($.param([{ name: "x", value: null }, { name: "a[b]", value: function(){ return "B" }}])))
      },

      testParamEscaping: function(t) {
        var result = $.param({ 'equation[1]': 'bananas+peaches=smoothie' })
        t.assertEqual("equation%5B1%5D=bananas%2Bpeaches%3Dsmoothie", result)
      },

      testParamSpaces: function(t) {
        var result = $.param({ "foo bar": "baz kuux" })
        t.assertEqual("foo+bar=baz+kuux", result)
      },

      testParamComplex: function(t) {
        var data = {
          a: ['b', 'c', { d:'e', f:['g','h'] }]
        }
        var result = $.param(data)
        result = decodeURIComponent(result)
        t.assertEqual("a[]=b&a[]=c&a[2][d]=e&a[2][f][]=g&a[2][f][]=h", result)
      },

      testParamComplexIssue850: function(t) {
        var data = {
          $push: { _:[ { name: 'bob', members:['aaa'] } ] }
        }
        var result = $.param(data)
        result = decodeURIComponent(result)
        t.assertEqual("$push[_][0][name]=bob&$push[_][0][members][]=aaa", result)
      },

      testParamComplexNested: function(t) {
        var data = {
          x: [
            [1, { attr1: 2 } ],
            3,
            { attr1: 4 },
            { attr1: 5, attr2: [ 6 ] },
            [ 7, [8, 9] ],
            { attr1: { attr2: [ [ 10 ] ] } }
          ]
        }
        var result = $.param(data)
        result = decodeURIComponent(result)
        t.assertEqual(
          [ "x[0][]=1"
          , "x[0][1][attr1]=2"
          , "x[]=3"
          , "x[2][attr1]=4"
          , "x[3][attr1]=5"
          , "x[3][attr2][]=6"
          , "x[4][]=7"
          , "x[4][1][]=8"
          , "x[4][1][]=9"
          , "x[5][attr1][attr2][0][]=10"
          ].join('&'), result)
      },

      testParamShallow: function(t) {
        var data = {
          libs: ['jQuery', 'Prototype', 'Dojo'],
          nested: { will: 'be ignored' }
        }
        var result = $.param(data, true)
        result = decodeURIComponent(result)
        t.assertEqual("libs=jQuery&libs=Prototype&libs=Dojo&nested=[object+Object]", result)
      },

      testParamArray: function(t) {
        var data = [
          {name:'country', value:'Ecuador'},
          {name:'capital', value:'Quito'}
        ]
        var result = $.param(data)
        t.assertEqual(result, "country=Ecuador&capital=Quito")
      }

    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/ajax_deferred.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Ajax deferred</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event ajax ie callbacks deferred')
    })()
  </script>
</head>
<body>
  <h1>Zepto Ajax deferred</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">
  </div>

  <script>
  (function(){

    function toArray(list) {
      if ($.type(list) == "string") return list.split(/(?:\s*,\s*|\s+)/)
      else return list
    }

    Evidence.Assertions.assertEqualList = function(expected, actual, message) {
      var expectedList = toArray(expected),
          actualList   = toArray(actual)

      this._assertExpression(
        expectedList.join(' ') == actualList.join(' '),
        message || "Lists don't match.",
        'Expected %o, got %o.', expectedList, actualList
      )
    }

    var OriginalXHR = $.ajaxSettings.xhr

    function MockXHR() {
      this.requestHeaders = {}
      this.responseHeaders = {}
      MockXHR.last = this
    }
    MockXHR.prototype = {
      open: function(method, url) {
        this.method = method
        this.url = url
      },
      setRequestHeader: function(name, value) {
        this.requestHeaders[name.toLowerCase()] = value
      },
      getResponseHeader: function(name) {
        return this.responseHeaders[name]
      },
      send: function(data) {
        this.data = data
      },
      abort: function() {
        this.aborted = true
      },
      ready: function(readyState, status, responseText, headers) {
        this.readyState = readyState
        this.status = status
        this.responseText = responseText
        $.extend(this.responseHeaders, headers)
        this.onreadystatechange()
      },
      onreadystatechange: function() {}
    }

    Evidence('ZeptoAjaxDeferred', {
      setUp: function() {
        $.ajaxSettings.xhr = function(){ return new MockXHR }
      },

      tearDown: function() {
        $.ajaxSettings.xhr = OriginalXHR
        $(document).off()
        $.active = 0

        for (var key in window)
          if (/^Zepto\d+$/.test(key) && window[key] === undefined)
            delete window[key]
      },

      testDone: function(t) {
        var log = []

        var xhr = $.ajax({
          success: function() { log.push('success') }
        })
          .done(function(response, status, gotXhr){
            t.assertEqual('hello', response)
            t.assertEqual('success', status)
            t.assertIdentical(xhr, gotXhr)
            log.push('done1')
          })
          .fail(function(){ log.push('fail') })
          .always(function(){ log.push('always') })
          .done(function(){ log.push('done2') })

        xhr.ready(3, 0)
        t.assertEqual(0, log.length)

        xhr.ready(4, 200, 'hello')
        t.assertEqualList('success done1 always done2', log)

        xhr.done(function(){ log.push('done3') })
        t.assertEqualList('success done1 always done2 done3', log)
      },

      testFail: function(t) {
        var log = []

        var xhr = $.ajax({
          error: function() { log.push('error') }
        })
          .done(function(){ log.push('done') })
          .fail(function(gotXhr, status, error){
            t.assertIdentical(xhr, gotXhr)
            t.assertEqual('error', status)
            log.push('fail1')
          })
          .always(function(){ log.push('always') })
          .fail(function(){ log.push('fail2') })

        xhr.ready(3, 0)
        t.assertEqual(0, log.length)

        xhr.ready(4, 404)
        t.assertEqualList('error fail1 always fail2', log)

        xhr.fail(function(){ log.push('fail3') })
        t.assertEqualList('error fail1 always fail2 fail3', log)
      },

      testAbortInBeforeSend: function(t) {
        var log = []

        var xhr = $.ajax({
          beforeSend: function() { return false }
        })

        xhr.done(function(){ log.push('done') })
          .fail(function(gotXhr, status, error){
            t.assertIdentical(xhr, gotXhr)
            t.assertEqual('abort', status)
            log.push('fail1')
          })

        t.assertEqualList('fail1', log)
      },

      testJSONP: function(t) {
        var log = []
        t.pause()

        var xhr = $.ajax({
          url: 'jsonp',
          dataType: 'jsonp',
          success: function() { log.push('success') }
        })
          .done(function(){ log.push('done1') })
          .always(function(){
            setTimeout(function(){
              t.resume(function(){
                t.assertEqualList('success done1', log)
                xhr.done(function(){ log.push('done2') })
                t.assertEqualList('success done1 done2', log)
              })
            }, 10)
          })

        t.assertEqual(0, log.length)
      },

      testJSONPAbortInBeforeSend: function(t) {
        var log = []

        var xhr = $.ajax({
          url: 'jsonp',
          dataType: 'jsonp',
          beforeSend: function() { return false }
        })

        xhr.done(function(){ log.push('done') })
          .fail(function(gotXhr, status, error){
            t.assertIdentical(xhr, gotXhr)
            t.assertEqual('abort', status)
            log.push('fail1')
          })

        t.assertEqualList('fail1', log)
      }

    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/callbacks.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Callbacks unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto callbacks')
    })()
  </script>
</head>
<body>
  <h1>Zepto Callbacks unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <script>
  (function(){
    var output = "", cb
    function a() { output += "A" }
    function b() { output += "B" }
    function c() { output += "C" }
    function str(str) { output += str }

    Evidence('ZeptoCallbacksTest', {

      testOptionsAreCopied: function(t) {
        var options = {"unique": true},
            cb = $.Callbacks(options),
            count = 0,
            fn = function() {
              t.assertTrue(!(count++), "called once")
            }
        options["unique"] = false
        cb.add(fn, fn)
        cb.fire()
      },

      testFireWithOptionsAreCopied: function(t) {
        var cb = $.Callbacks({memory:1}),
            args = ["hello"]

        cb.fireWith(null, args)
        args[0] = "world"

        cb.add(function(hello) {
          t.assertEqual("hello", hello, "arguments are copied internally")
        })
      },

      testRemoveDeletesAllInstances: function(t) {
        var cb = $.Callbacks()
        function fn() {
          t.fail("function wasn't removed")
        }
        cb.add( fn, fn, function() {
          t.assertTrue(true, "end of test")
        }).remove(fn).fire()
      },

      testCallbacksHas: function(t) {
        var cb = $.Callbacks()
        cb.add(a, b, c)
        t.assertTrue(cb.has(), "No arguments to .has() returns whether callback function(s) are attached or not")
        t.assertTrue(cb.has(a), "Check if a specific callback function is in the Callbacks list" )

        cb.remove(b)
        t.assertFalse(cb.has(b), "Remove a specific callback function and make sure its no longer there" )
        t.assertTrue(cb.has(a), "Remove a specific callback function and make sure other callback function is still there" )

        cb.empty()
        t.assertFalse(cb.has(), "Empty list and make sure there are no callback function(s)" )
        t.assertFalse(cb.has(a), "Check for a specific function in an empty() list" )

        cb.add(a, b, function(){
          t.assertTrue(cb.has(), "Check if list has callback function(s) from within a callback function" )
          t.assertTrue(cb.has(a), "Check if list has a specific callback from within a callback function" )
        }).fire()

        t.assertTrue(cb.has(), "Callbacks list has callback function(s) after firing" )

        cb.disable()
        t.assertFalse(cb.has(), "disabled() list has no callback functions (returns false)" )
        t.assertFalse(cb.has(a), "Check for a specific function in a disabled() list" )

        cb = $.Callbacks({unique:1})
        cb.add(a)
        cb.add(a)
        t.assertTrue(cb.has(), "Check if unique list has callback function(s) attached" )
        cb.lock()
        t.assertFalse(cb.has(), "locked() list is empty and returns false" )
      },

      testAddStringNoCrash: function(t) {
        $.Callbacks().add("hello world")
        t.assertTrue(true, "no crash adding string" )
      },

      testUniqueAddIdenticalFn: function(t) {
        output = "X"
        $.Callbacks({unique:1}).add(a, function() { output += "A" }).fire()
        t.assertEqual("XAA", output, "Unique can add different, identical definitions of same function")
      },

      testUniqueAddSameFn: function(t) {
        output = "X"
        $.Callbacks({unique:1}).add(a, a).fire()
        t.assertEqual("XA", output, "Unique can not add multiple functions with the same reference")
      },

      testUniqueAddSameFnMultiRef: function(t) {
        var x = a
        output = "X"
        $.Callbacks({unique:1}).add(a, x).fire()
        t.assertEqual("XA", output, "Unique can not add multiple references to the same function")
      }

    })

    var configs = {
      'Undefined': undefined,
      'Null': null,
      'Once': {once:1},
      'Memory': {memory:1},
      'Unique': {unique:1},
      'StopOnFalse': {stopOnFalse:1},
      'OnceMemory': {once:1, memory:1},
      'OnceUnique': {once:1, unique:1},
      'OnceStopOnFalse': {once:1, stopOnFalse:1},
      'MemoryUnique': {memory:1, unique:1},
      'MemoryStopOnFalse': {memory:1, stopOnFalse:1},
      'UniqueStopOnFalse': {unique:1, stopOnFalse:1}
    }
    var ordering = {
      "Undefined":         "XABC   X     XABCABCC  X  XBB X   XABA  X   XX",
      "Null":              "XABC   X     XABCABCC  X  XBB X   XABA  X   XX",
      "Once":              "XABC   X     X         X  X   X   XABA  X   XX",
      "Memory":            "XABC   XABC  XABCABCCC XA XBB XB  XABA  XC  XX",
      "Unique":            "XABC   X     XABCA     X  XB  X   XAB   X   X",
      "StopOnFalse":       "XABC   X     XABCABCC  X  XBB X   XA    X   XX",
      "OnceMemory":        "XABC   XABC  X         XA X   XA  XABA  XC  XX",
      "OnceUnique":        "XABC   X     X         X  X   X   XAB   X   X",
      "OnceStopOnFalse":   "XABC   X     X         X  X   X   XA    X   XX",
      "MemoryUnique":      "XABC   XA    XABCA     X  XB  X   XAB   XC  X",
      "MemoryStopOnFalse": "XABC   XABC  XABCABCCC XA XBB XB  XA    X   XX",
      "UniqueStopOnFalse": "XABC   X     XABCA     X  XB  X   XA    X   X"
    }

    $.each(configs, function(name, config) {
      var results = ordering[name].split(/\s+/)

      Evidence("ZeptoCallbacksTest#" + name, {

        testBindAndFire: function(t) {
          output = "X", cb = $.Callbacks(config).add(str).fire("A")
          t.assertEqual("XA", output, "Basic binding and firing")
          t.assertTrue(cb.fired(), ".fired() detects firing")
          output = "X"
          cb.disable().add(str)
          t.assertEqual( "X", output, "Adding a callback after disabling" )
          cb.fire("A")
          t.assertEqual( "X", output, "Firing after disabling" )
        },

        testNoEmptyWhileFiring: function(t) {
          var cb = $.Callbacks(config)
          cb.add(cb.empty, function() { t.fail("not emptied") }).fire()
        },

        testNoDisablingWhileFiring: function(t) {
          var cb = $.Callbacks(config)
          cb.add(cb.disable, function() { t.fail("not disabled") }).fire()
        },

        testBindFireWithContextAndArgs: function(t) {
          output = "X"
          $.Callbacks(config).add(function() {
            t.assertEqual(window, this, "Basic binding and firing (context)" )
            output += Array.prototype.join.call(arguments, "")
          }).fireWith(window, [ "A", "B" ])
          t.assertEqual( "XAB", output, "Basic binding and firing (arguments)" )
        },

        testFireWithNoArgs: function(t) {
          $.Callbacks(config).add(function() {
            t.assertEqual(window, this, "fireWith with no arguments (context is window)")
            t.assertEqual(0, arguments.length, "fireWith with no arguments (no arguments)")
          }).fireWith()
        },

        testBindRemoveFire: function(t) {
          output = "X"
          $.Callbacks(config).add(a, b, c).remove(b, c).fire()
          t.assertEqual("XA", output)
        },

        testEmpty: function(t) {
          output = "X"
          $.Callbacks(config).add(a, b, c).empty().fire()
          t.assertEqual( "X", output, "Empty" )
        },

        testLocking: function(t) {
          output = "X"
          $.Callbacks(config).add(str).lock().add(str).fire("A").add(str)
          t.assertEqual("X", output, "Lock early")
        },

        testOrdering: function(t) {
          output = "X", cb = $.Callbacks(config)
          cb.add(function() {
            cb.add(c)
            a()
          }, b).fire()
          t.assertEqual( results.shift(), output, "Proper ordering" )

          output = "X"
          cb.add(function() {
            cb.add(c)
            a()
          }, b)
          t.assertEqual(results.shift(), output, "Add after fire")
          output = "X"
          cb.fire()
          t.assertEqual(results.shift(), output, "Fire again")

          output = "X", cb = $.Callbacks(config)
          cb.add(str).fire("A")
          t.assertEqual("XA", output, "Multiple fire (first fire)")
          output = "X"
          cb.add(str)
          t.assertEqual(results.shift(), output, "Multiple fire (first new callback)")
          output = "X"
          cb.fire("B")
          t.assertEqual(results.shift(), output, "Multiple fire (second fire)")
          output = "X"
          cb.add(str)
          t.assertEqual(results.shift(), output, "Multiple fire (second new callback)")

          output = "X", cb = $.Callbacks(config).add(a, function() { return false }, b).add(a).fire()
          t.assertEqual(results.shift(), output, "Callback returning false")

          output = "X"
          cb.add(c)
          t.assertEqual(results.shift(), output, "Adding a callback after one returned false")

          output = ""
          function handler() { output += "X" }
          handler.method = function() { output += "!" }
          cb = $.Callbacks(config).add(handler).add(handler).fire()
          t.assertEqual(results.shift(), output, "No callback iteration")
        }

      })

    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/data.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Data unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto data ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Data unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">
  <div id="data_attr"
    data-one="uno"
    data-two="due"
    data-foo-bar="baz"
    data-under_score="kuuq"
    ></div>
  <div id="data_full" data-mode="awesome"></div>
  <div id="data_obj" data-mode="awesome"></div>
  <ol id="data_list">
    <li data-category="arts"></li>
    <li data-category="science"></li>
  </ol>
  <ol id="data_list2">
    <li></li>
    <li></li>
  </ol>
  </div>

  <script>
    Evidence('ZeptoExtendedDataTest', {
      testEmptyCollection: function(t){
        var el = $('#does_not_exist')
        t.assertUndefined(el.data('one'))
      },

      testAttributeDoesNotExist: function(t){
        var el = $('#data_attr')
        t.assertUndefined(el.data('missing'))
      },

      testReadingAttribute: function(t){
        var el = $('#data_attr')
        t.assertEqual('uno', el.data('one'))
      },

      testCamelized: function(t){
        var el = $('#data_attr')
        t.assertEqual('baz', el.data('foo-bar'))
        t.assertEqual('baz', el.data('fooBar'))

        el.data('fooBar', 'bam')
        t.assertEqual('bam', el.data('foo-bar'))
        t.assertEqual('bam', el.data('fooBar'))

        el.data('a-b', 'c')
        t.assertEqual('c', el.data().aB)
        t.assertUndefined(el.data()['a-b'])
      },

      testUnderscore: function(t){
        var el = $('#data_attr')
        t.assertEqual('kuuq', el.data('under_score'))
        t.assertUndefined(el.data('under-score'))
        t.assertUndefined(el.data('underScore'))
      },

      testNotChangingAttribute: function(t){
        var el = $('#data_attr')
        t.assertEqual('due', el.data('two'))
        el.data('two', 'changed')
        t.assertEqual('due', el.attr('data-two'))
      },

      testExtendedData: function(t){
        var els = $('#data_attr'),
          els2 = $('#data_attr'),
          obj  = { a: 'A', b: 'B' }

        els.data('obj', obj)
        t.assertIdentical(obj, els.data('obj'))
        t.assertIdentical(obj, els2.data('obj'))

        els2.data('els', els)
        t.assertIdentical(els, els.data('els'))
      },

      testMultipleElements: function(t){
        var items = $('#data_list li')

        items.data('each', 'mark')

        var values = items.map(function(){ return $(this).data('each') }).get()
        t.assertEqual('mark, mark', values.join(', '))
      },

      testFunctionArg: function(t){
        var els = $('#data_attr')

        var data = "hello"

        els.data("addio", function () {
          data = "goodbye"
        })

        t.assertEqual('hello', data)

        els.data("addio")()

        t.assertEqual('goodbye', data)
      },

      testAllData: function(t){
        var el = $('#data_full')

        el.data().samurai = 7
        el.data('one', 'ichi').data('two', 'ni')
        el.data('person', {name: 'Kurosawa'})

        var all = el.data()
        t.assertEqual(7, all.samurai)
        t.assertEqual('ichi', all.one)
        t.assertEqual('ni', all.two)
        t.assertEqual('Kurosawa', all.person.name)
      },

      testInitialDataFromAttributes: function(t){
        var el = $('<div data-foo=bar data-foo-bar=baz data-empty data-num=42 />'),
            store = el.data()

        t.assertEqual('bar', store.foo)
        t.assertEqual('baz', store.fooBar)
        t.assertUndefined(store['foo-bar'])
        t.assertIdentical('', store.empty)
        t.assertIdentical(42, store.num)
      },

      testGettingBlanks: function(t){
        var el = $('#data_attr'),
            store = el.data()

        store.nil = null
        store.undef = undefined
        store.blank = ''
        store.bool = false

        t.assertNull(el.data('nil'))
        t.assertUndefined(el.data('undef'))
        t.assertIdentical('', el.data('blank'))
        t.assertFalse(el.data('bool'))
      },

      testRemoveData: function(t){
        var el = $('<div data-foo=bar />')

        el.data('foo', 'bam').data('bar', 'baz')
        el.removeData('foo').removeData('bar')
        t.assertEqual('bar', el.data('foo'))
        t.assertUndefined(el.data('bar'))

        el.data('uno', 'one').data('due', 'two')
        el.removeData('uno due')
        t.assertUndefined(el.data('uno'))
        t.assertUndefined(el.data('due'))

        el.data('one', 1).data('twoThree', 23)
        el.removeData(['one', 'two-three'])
        t.assertUndefined(el.data('one'))
        t.assertUndefined(el.data('twoThree'))
      },

      testRemoveAllData: function(t){
        var el = $('<div data-attr-test=val />')

        el.data('one', { foo: 'bar' })
        el.data('two', 'two').data('three', 3)
        el.removeData()

        t.assertEqual('val', el.data('attrTest'))
        t.assertUndefined(el.data('one'))
        t.assertUndefined(el.data('two'))
        t.assertUndefined(el.data('three'))
      },

      testRemoveDataNoop: function(t){
        var empty = $(),
            vanilla = $('<div />')

        t.assertIdentical(empty, empty.removeData('foo'))
        t.assertIdentical(vanilla, vanilla.removeData('foo'))
      },

      testRemoveDataOnElementRemoval: function(t){
        var el = $('<div data-attr-test=val />'),
          childEl = $('<span />').appendTo(el),
          elData = { foo: 'bar' }

        el.data('test', elData)
        childEl.data('test', 1)

        el.remove()
        t.assertEqual('val', el.data('attrTest'))
        t.assertUndefined(el.data('test'))
        t.assertUndefined(childEl.data('test'))
      },

      testRemoveDataOnElementEmpty: function(t){
        var el = $('<div data-attr-test=val />'),
          childEl = $('<span />').appendTo(el),
          elData = { foo: 'bar' }

        el.data('test', elData)
        childEl.data('test', 1)

        el.empty()
        t.assertEqual('val', el.data('attrTest'))
        t.assertEqual(elData, el.data('test'))
        t.assertUndefined(childEl.data('test'))
      },

      testRemoveDataOnElementReplacement: function(t){
        var el = $('<div data-attr-test=val />'),
          childEl = $('<span />').appendTo(el),
          elData = { foo: 'bar' }

        el.data('test', elData)
        childEl.data('test', 1)

        el.replaceWith('<div />')
        t.assertEqual('val', el.data('attrTest'))
        t.assertUndefined(el.data('test'))
        t.assertUndefined(childEl.data('test'))
      },

      testRemoveDataOnElementReplacementHtml: function(t){
        var el = $('<div data-attr-test=val />'),
          childEl = $('<span />').appendTo(el),
          wrapper = $('<div />'),
          elData = { foo: 'bar' }

        el.wrap(wrapper).data('test', elData)
        childEl.data('test', 1)

        wrapper.html('<b>New content</b>')
        t.assertEqual('val', el.data('attrTest'))
        t.assertUndefined(el.data('test'))
        t.assertUndefined(childEl.data('test'))
      },

      testKeepDataOnElementDetach: function(t){
        var el = $('<div data-attr-test=val />'),
          childEl = $('<span />').appendTo(el),
          elData = { foo: 'bar' }

        el.data('test', elData)
        childEl.data('test', 1)

        el.detach()
        t.assertEqual('val', el.data('attrTest'))
        t.assertEqual(elData, el.data('test'))
        t.assertEqual(1, childEl.data('test'))
      },

      testSettingDataWithObj: function(t){
          var el = $('#data_obj')

          el.data({
              'foo': 'bar',
              'answer': 42,
              'color': 'blue'
          })

          var all = el.data()

          t.assertEqual(all.answer, 42)
          t.assertEqual(all.color, 'blue')
          t.assertEqual(all.foo, 'bar')

          el.data('foo', 'baz')

          t.assertEqual(all.foo, 'baz')
          t.assertEqual(all.answer, 42)
      },

      testSettingDataWithObjOnManyElements: function(t){
          var items = $('#data_list2 li')

          items.data({
              'foo': 'bar',
              'answer': 42,
              'color': 'purple'
          })

          var values = items.map(function(){ return $(this).data('foo') }).get()
          t.assertEqual('bar, bar', values.join(', '))

          var values2 = items.map(function(){ return $(this).data('answer') }).get()
          t.assertEqual('42, 42', values2.join(', '))
      },

      testSettingDataOnObjectWithoutAttributes: function(t) {
        var el = $(window)

        t.assertUndefined(el.data('foo'))
        el.data('foo', 'bar')
        t.assertEqual(el.data('foo'), 'bar')

        delete window[$.expando]
      },

      testDollarData: function(t) {
        var el = $('<div>')
        el.data('hello', 'world')
        t.assertEqual($.data(el, 'hello'), 'world')
        t.assertEqual($.data(el[0], 'hello'), 'world')

        $.data(el[0], 'hello', 'again')
        t.assertEqual($.data(el, 'hello'), 'again')
        t.assertEqual($.data(el[0], 'hello'), 'again')
      },

      testDollarHasData: function(t) {
        var el = $('<div>')
        t.assertFalse($.hasData(el[0]))

        el.data('hello', 'world')
        t.assertTrue($.hasData(el[0]))

        el.removeData()
        t.assertFalse($.hasData(el[0]))

        var error
        try {
          $.hasData()
        } catch (e) {
          error = e
        }
        t.assert(error)
      }

    })
  </script>
</body>
</html>


================================================
FILE: test/deferred.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Deferred unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto callbacks deferred')
    })()
  </script>
</head>
<body>
  <h1>Zepto Deferred unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <script>
  (function(){
    var promiseFns = "resolve reject notify resolveWith rejectWith notifyWith done fail progress always".split(/\s+/),
        deferredFns = "state always then promise done fail progress".split(/\s+/)

    $.each(['', 'WithNew'], function(_, withNew) {
      var createDeferred = function(fn) {
        return withNew ? new $.Deferred(fn) : $.Deferred(fn)
      }

      Evidence('ZeptoDeferredTest' + withNew, {

        testSuccessOnResolve: function(t) {
          var called = 0
          createDeferred().resolve().done(function() {
            t.assertEqual(0, called++)
            t.assertEqual("resolved", this.state(), "Deferred is resolved (state)")
          }).fail(function() {
            t.fail("Error on resolve")
          }).always(function() {
            t.assertEqual(1, called++)
          })
          t.assertEqual(2, called, "Success and Always handlers called")
        },

        testErrorOnReject: function(t) {
          var called = 0
          createDeferred().reject().done(function() {
            t.fail("Success on reject")
          }).fail(function() {
            t.assertEqual(0, called++)
            t.assertEqual( "rejected", this.state(), "Deferred is rejected (state)" )
          }).always(function() {
            t.assertEqual(1, called++)
          })
          t.assertEqual(2, called, "Error and Always handlers called")
        },

        testDeferredFnContextIsArg1: function(t) {
          var called
          createDeferred(function(defer) {
            called = true
            t.assertEqual(defer, this, "Defer passed as this & first argument")
          })
          t.assertTrue(called, "Deferred function was called")
        },

        testDoneWithResolvedValue: function(t) {
          var called
          createDeferred(function(defer) {
            defer.resolve("done")
          }).done(function(value) {
            called = true
            t.assertEqual("done", value, "Done() received resolved value")
          })
          t.assertTrue(called, "Deferred function was called")
        },

        testNoDoneOnReject: function(t) {
          var called = false
          createDeferred(function(defer) {
            defer.reject("done")
          }).done(function(value) {
            called = true
            t.fail("done() should not be called on error")
          })
          t.assertFalse(called, "Deferred function was called")
        },

        testIsChainable: function(t) {
          var deferred = createDeferred(), each = $.each
          // Ensure that each of the following methods are chainable
          each(promiseFns, function(_, method) {
            var object = {
              m: deferred[method]
            }
            t.assertEqual(object, object.m(), method + " is chainable" )
          })
        },

        testFilteringDone: function(t) {
          var value1, value2, value3,
              defer = createDeferred(),
              piped = defer.then(function(a, b) {
                return a * b
              })
          piped.done(function(result) { value3 = result })
          defer.done(function(a, b) { value1 = a, value2 = b }).resolve(2, 3)

          t.assertEqual(2, value1, "first resolve value ok")
          t.assertEqual(3, value2, "second resolve value ok")
          t.assertEqual(6, value3, "result of filter ok")

          createDeferred().reject().then(function() { t.fail("then should not be called on reject") })
          createDeferred().resolve().then($.noop).done(function(value) {
            t.assertEqual(undefined, value, "then done callback can return undefined/null")
          })
        },

        testSamePromise: function(t) {
          createDeferred(function(defer) {
            var promise = defer.promise()
            t.assertEqual(promise, defer.promise(), "promise is always the same")
          })
        },

        testExtendNonObject: function(t) {
          createDeferred(function(defer) {
            var func = function() {},
                funcPromise = defer.promise(func)
            t.assertEqual(func, funcPromise, "non objects get extended")
          })
        },

        testPromiseOnlyFns: function(t) {
          createDeferred(function(defer) {
            var promise = defer.promise()
            $.each(promise, function(key) {
              var type = typeof promise[key]
              t.assertEqual("function", type, key + " is a function (" + type + ")")
              t.assertTrue(deferredFns.indexOf(key) > -1, key + "() is a promise function")
            })
          })
        },

        testExtendObjectWithPromiseFns: function(t) {
          createDeferred(function(defer) {
            var promise = defer.promise(),
                func = function() {},
                funcPromise = defer.promise(func),
                fns = 0
            $.each(promise, function(key) {
              ++fns
              t.assertEqual(promise[key], func[key], key + " is the same")
            })
            t.assertEqual(deferredFns.length, fns, "should have all of the Deferred functions")
          })
        },

        testFilteringReject: function(t) {
          var value1, value2, value3,
              defer = createDeferred(),
              piped = defer.then(null, function(a, b) {
                return a * b
              })

          piped.fail(function(result) { value3 = result })
          defer.fail(function( a, b ) { value1 = a, value2 = b })
          defer.reject( 2, 3 )

          t.assertEqual(2, value1, "first reject value ok")
          t.assertEqual(3, value2, "second reject value ok")
          t.assertEqual(6, value3, "result of filter ok")

          createDeferred().resolve().then(null, function() {
            t.fail("then should not be called on resolve")
          })

          createDeferred().reject().then(null, $.noop).fail(function(value) {
            t.assertEqual(undefined, value, "then fail callback can return undefined/null")
          })
        },

        testFilteringProgress: function(t) {
          var value1, value2, value3,
              defer = createDeferred(),
              piped = defer.then(null, null, function(a, b) {
                return a * b
              })

          piped.progress(function(result) { value3 = result })
          defer.progress(function(a, b) { value1 = a, value2 = b })

          defer.notify( 2, 3 )

          t.assertEqual(2, value1, "first progress value ok")
          t.assertEqual(3, value2, "second progress value ok")
          t.assertEqual(6, value3, "result of filter ok")
        },

        testThenDeferredDone: function(t) {
          var value1, value2, value3,
              defer = createDeferred(),
              piped = defer.then(function(a, b) {
                return createDeferred(function(defer) {
                  defer.reject(a * b)
                })
              })

          piped.fail(function(result) { value3 = result })
          defer.done(function(a, b) { value1 = a, value2 = b })
          defer.resolve(2, 3)

          t.assertEqual(2, value1, "first resolve value ok")
          t.assertEqual(3, value2, "second resolve value ok")
          t.assertEqual(6, value3, "result of filter ok")
        },

        testThenDeferredFail: function(t) {
          var value1, value2, value3,
              defer = createDeferred(),
              piped = defer.then(null, function(a, b) {
                return createDeferred(function(defer) {
                  defer.resolve(a * b)
                })
              })

          piped.done(function(result) { value3 = result })
          defer.fail(function(a, b) { value1 = a, value2 = b })
          defer.reject(2, 3)

          t.assertEqual(2, value1, "first reject value ok")
          t.assertEqual(3, value2, "second reject value ok")
          t.assertEqual(6, value3, "result of filter ok")
        },

        testThenDeferredProgress: function(t) {
          var value1, value2, value3,
            defer = createDeferred(),
            piped = defer.then(null, null, function(a, b) {
              return createDeferred(function(defer) {
                defer.resolve( a * b )
              })
            })

          piped.done(function(result) { value3 = result })
          defer.progress(function(a, b) { value1 = a, value2 = b })
          defer.notify(2, 3)

          t.assertEqual(2, value1, "first progress value ok")
          t.assertEqual(3, value2, "second progress value ok")
          t.assertEqual(6, value3, "result of filter ok")
        },

        testThenWithContext: function(t) {
          var defer, piped, defer2, piped2, context = {}

          createDeferred().resolveWith(context, [2]).then(function(value) {
            return value * 3
          }).done(function(value) {
            t.assertEqual(context, this, "custom context correctly propagated")
            t.assertEqual(6, value, "proper value received")
          })

          createDeferred().resolve().then(function() {
            return createDeferred().resolveWith(context)
          }).done(function() {
            t.assertEqual(context, this, "custom context of returned deferred correctly propagated")
          })

          defer = createDeferred()
          piped = defer.then(function(value) {
            return value * 3
          })
          defer.resolve( 2 )

          piped.done(function(value) {
            t.assertEqual(piped, this, "default context gets updated to latest promise in the chain")
            t.assertEqual(6, value, "proper value received")
          })

          defer2 = createDeferred()
          piped2 = defer2.then()

          defer2.resolve(2)

          piped2.done(function(value) {
            t.assertEqual(piped2, this, "default context gets updated to latest promise in the chain (without passing function)")
            t.assertEqual(2, value, "proper value received (without passing function)")
          })
        },

        testWhenValueCreatesPromise: function(t) {
          $.each({
            "an empty string": "",
            "a non-empty string": "some string",
            "zero": 0,
            "a number other than zero": 1,
            "true": true,
            "false": false,
            "null": null,
            "undefined": undefined,
            "a plain object": {},
            "an array": [ 1, 2, 3 ]
          }, function(message, value) {
            t.assertTrue(
              $.isFunction($.when(value).done(function(resolveValue) {
                t.assertEqual(window, this, "Context is the global object with " + message)
                t.assertEqual(value, resolveValue, "Test the promise was resolved with " + message)
              }).promise), "Test " + message + " triggers the creation of a new Promise")
          })
        },

        testWhenNoValueCreatesPromise: function(t) {
          t.assertTrue(
            $.isFunction($.when().done(function(resolveValue) {
              t.assertEqual(window, this, "Context is the global object")
              t.assertEqual(undefined, resolveValue, "Test the promise was resolved with no parameter")
            }).promise), "Test calling when with no parameter triggers the creation of a new Promise")
        },

        testWhenPropagatesContext: function(t) {
          var context = {}, called = false
          $.when(createDeferred().resolveWith(context)).done(function() {
              called = true
              t.assertEqual(context, this, "when( promise ) propagates context")
            })
          t.assertTrue(called, "called done() after resolveWith")
        },

        testWhenDoneOnlyPromise: function(t) {
          var cache
          $.each([1,2,3], function(_, i) {
            $.when(cache || createDeferred(function() {
              this.resolve(i)
            })).done(function(value) {
              t.assertEqual(1, value, "Function executed" + (i > 1 ? " only once" : ""))
              cache = value
            })
          })
        },

        testWhenJoined: function(t) {
          var deferreds = {
                value: 1,
                success: createDeferred().resolve(1),
                error: createDeferred().reject(0),
                futureSuccess: createDeferred().notify(true),
                futureError: createDeferred().notify(true),
                notify: createDeferred().notify(true)
              },
              willSucceed = {
                value: true,
                success: true,
                futureSuccess: true
              },
              willError = {
                error: true,
                futureError: true
              },
              willNotify = {
                futureSuccess: true,
                futureError: true,
                notify: true
              }

          $.each(deferreds, function(id1, defer1) {
            $.each(deferreds, function(id2, defer2) {
              var shouldResolve = willSucceed[id1] && willSucceed[id2],
                  shouldError = willError[id1] || willError[id2],
                  shouldNotify = willNotify[id1] || willNotify[id2],
                  expected = shouldResolve ? [1, 1] : [0, undefined],
                  expectedNotify = shouldNotify && [willNotify[id1], willNotify[id2]],
                  code = id1 + '/' + id2,
                  context1 = defer1 && $.isFunction(defer1.promise) ? defer1.promise() : undefined,
                  context2 = defer2 && $.isFunction(defer2.promise) ? defer2.promise() : undefined
              $.when(defer1, defer2).done(function(a, b) {
                if (shouldResolve) {
                  t.assertEqual(expected[0], a, code + " => resolve" )
                  t.assertEqual(expected[1], b, code + " => resolve" )
                  t.assertIdentical(context1, this[0], code + " => first context OK")
                  t.assertIdentical(context2, this[1], code + " => second context OK")
                } else {
                  t.fail(code + " => resolve")
                }
              }).fail(function(a, b) {
                if (shouldError) {
                  t.assertIdentical(expected[0], a, code + " => reject")
                  t.assertIdentical(expected[1], b, code + " => reject")
                } else {
                  t.fail(code + " => reject")
                }
              }).progress(function(a, b) {
                t.assertIdentical( expectedNotify[0], a, code + " => progress")
                t.assertIdentical( expectedNotify[1], b, code + " => progress")
                t.assertIdentical(expectedNotify[0] ? context1 : undefined, this[0], code + " => first context OK")
                t.assertIdentical(expectedNotify[1] ? context2 : undefined, this[1], code + " => second context OK")
              })
            })
          })
          deferreds.futureSuccess.resolve(1)
          deferreds.futureError.reject(0)
        }

      })
    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/detect.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Detect unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto detect ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Detect unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <script>
  (function(){

    var UA = {
      Safari_OSX_7_0_1: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) AppleWebKit/537.73.11 (KHTML, like Gecko) Version/7.0.1 Safari/537.73.11",
      Safari_OSX_7_0: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9) AppleWebKit/537.71 (KHTML, like Gecko) Version/7.0 Safari/537.71",
      Safari_OSX_6_0: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8) AppleWebKit/536.25 (KHTML, like Gecko) Version/6.0 Safari/536.25",
      Safari_Windows_NT: "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27",

      WebOS_1_4_0_Pre: "Mozilla/5.0 (webOS/1.4.0; U; en-US) AppleWebKit/532.2 (KHTML, like Gecko) Version/1.0 Safari/532.2 Pre/1.1",
      WebOS_1_4_0_Pixi: "Mozilla/5.0 (webOS/1.4.0; U; en-US) AppleWebKit/532.2 (KHTML, like Gecko) Version/1.0 Safari/532.2 Pixi/1.1",
      WebOS_1_2_9_Pixi: "Mozilla/5.0 (webOS/Palm webOS 1.2.9; U; en-US) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/1.0 Safari/525.27.1 Pixi/1.0",
      WebOS_3_0_0_TouchPad: "Mozilla/5.0 (hp-tablet; Linux; hpwOS/3.0.0; U; en-US) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/233.70 Safari/534.6 TouchPad/1.0",

      iOS_3_0_iPhone: "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/420.1 (KHTML, like Gecko) Version/3.0 Mobile/1A542a Safari/419.3",
      iOS_4_0_iPhone: "Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_0 like Mac OS X; en-us) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8A293 Safari/6531.22.7",
      iOS_3_1_1_iPod: "Mozilla/5.0 (iPod; U; CPU iPhone OS 3_1_1 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Mobile/7C145",
      iOS_3_2_iPad: "Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B367 Safari/531.21.10",
      iOS_4_2_iPad: "Mozilla/5.0 (iPad; U; CPU OS 4_2 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8C134 Safari/6533.18.5",
      iOS_4_3_iPhone_Simulator: "Mozilla/5.0 (iPhone Simulator; U; CPU iPhone OS 4_3 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8F190 Safari/6533.18.5",
      iOS_5_0_iPhone: "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3",
      iOS_5_1_iPad_webView: "Mozilla/5.0 (iPad; CPU OS 5_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Mobile/98176",
      iOS_6_0_iPad_mini: "Mozilla/5.0 (iPad; CPU OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A406 Safari/8536.25",
      iOS_6_1_iPhone: "Mozilla/5.0 (iPhone; CPU iPhone OS 6_1 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10B143 Safari/8536.25",

      iOS_3_2_iPad_2: "Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B314 Safari/531.21.10",

      iOS_7_0_iPhone: "Mozilla 5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X) AppleWebKit/537.51.1 (KTHML, like Gecko) Version/7.0 Mobile/11A449d Safari/9537.53",
      iOS_7_0_iPhone_Chrome: "Mozilla 5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X) AppleWebKit/536.26 (KHTM, like Gecko) CriOS/28.0.1500.17 Mobile/11A4449d Safari/8536.25",

      Android_1_5: "Mozilla/5.0 (Linux; U; Android 1.5; de-; HTC Magic Build/PLAT-RC33) AppleWebKit/528.5+ (KHTML, like Gecko) Version/3.1.2 Mobile Safari/525.20.1",
      Android_2_1: "Mozilla/5.0 (Linux; U; Android 2.1-update1; en-us; Nexus One Build/ERE27) AppleWebKit/530.17 (KHTML, like Gecko) Version/4.0 Mobile Safari/530.17 Chrome/4.1.249.1025",
      Android_2_3: "Mozilla/5.0 (Linux; U; Android 2.3.7; en-us; Nexus One Build/GRK39F) AppleWebKit/533.1 (KTHML, like Gecko) Version/4.0 Mobile Safari/533.1",
      Android_2_3_Lenovo_A750: "Lenovo-A750/S102 Linux/2.6.35.7 Android/2.3 Release/12.12.2011 Browser AppleWebkit533.1 Profile/ Configuration/",
      Android_4_1_1: "Mozilla/5.0 (Linux; Android 4.1.1; Galaxy Nexus Build/JRO03O) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.166 Mobile Safari/535.19",
      Android_4_1_1_Tablet: "Mozilla/5.0 (Linux; Android 4.1.1; Nexus 7 Build/JRO03S) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.166 Safari/535.19",
      Android_4_3: "Mozilla/5.0 (Linux; Android 4.3; Nexus 4 Build/JWR66Y) AppleWebKit/537.36 (KTHML, like Gecko) Chrome/29.0.1547.59 Mobile Safari/537.36",

      BlackBerry_6_0_0_141: "Mozilla/5.0 (BlackBerry; U; BlackBerry 9800; en-GB) AppleWebKit/534.1+ (KHTML, like Gecko) Version/6.0.0.141 Mobile Safari/534.1+",
      PlayBook_1_0_0: "Mozilla/5.0 (PlayBook; U; RIM Tablet OS 1.0.0; en-US) AppleWebKit/534.8+ (KHTML, like Gecko) Version/0.0.1 Safari/534.8+",
      PlayBook_2_1_0: "Mozilla/5.0 (PlayBook; U; RIM Tablet OS 2.1.0; en-US) AppleWebKit/536.2+ (KHTML, like Gecko) Version/7.2.1.0 Safari/536.2+",
      BB10: "Mozilla/5.0 (BB10; Touch) AppleWebKit/537.1+ (KHTML, like Gecko) Version/10.0.0.1337 Mobile Safari/537.1+",

      Opera_11_51: "Opera/9.80 (Macintosh; Intel Mac OS X 10.7.1; U; en) Presto/2.9.168 Version/11.51",
      Opera_Mobile_Simulator: "Opera/9.80 (Macintosh; Intel Mac OS X; Opera Mobi/[BUILD_NR]; U; en) Presto/2.7.81 Version/11.00",

      Kindle: "Mozilla/5.0 (Linux; U; en-US) AppleWebKit/528.5+ (KHTML, like Gecko, Safari/528.5+) Version/4.0 Kindle/3.0 (screen 600×800; rotate)",
      Silk_1_0_accel: "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_3; en-us; Silk/1.0.13.328_10008910) AppleWebKit/533.16 (KHTML, like Gecko) Version/5.0 Safari/533.16 Silk-Accelerated=true",
      Silk_1_0: "Mozilla/5.0 (Linux; U; Android 2.3.4; en-us; Kindle Fire Build/GINGERBREAD) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",

      Chrome_Android_18_0: "Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19",
      Chrome_iOS_19_0: "Mozilla/5.0 (iPhone; U; CPU iPhone OS 5_1_1 like Mac OS X; en) AppleWebKit/534.46.0 (KHTML, like Gecko) CriOS/19.0.1084.60 Mobile/9B206 Safari/7534.48.3",
      Chrome_OSX_24_0: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.56 Safari/537.17",

      Firefox_13_Tablet: "Mozilla/5.0 (Android; Tablet; rv:13.0) Gecko/13.0 Firefox/13.0",
      Firefox_13_Phone: "Mozilla/5.0 (Android; Mobile; rv:13.0) Gecko/13.0 Firefox/13.0",
      Firefox_6_0_2: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:6.0.2) Gecko/20100101 Firefox/6.0.2",
      Firefox_Mobile_Simulator: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:2.1.1) Gecko/ Firefox/4.0.2pre Fennec/4.0.1",
      Firefox_Os_Phone: "Mozilla/5.0 (Mobile; rv:18.0) Gecko/18.0 Firefox/18.0",
      Firefox_Os_Tablet: "Mozilla/5.0 (Tablet; rv:18.0) Gecko/18.0 Firefox/18.0",

      Windows_IE_9: "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
      Windows_IE_9_Compat: "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; Trident/5.0)",
      Windows_IE_10: "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)",
      Windows_IE_11: "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
      Windows_RT_Surface: "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; ARM; Trident/6.0; Touch)",
      Windows_Phone_8: "Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; HTC; Windows Phone 8X by HTC)"
    }

    function detect(ua, platform, callback){
      if (!callback) callback = platform, platform = ""
      var obj = {}
      $.__detect.call(obj, ua, platform)
      callback.call(null, obj.os, obj.browser)
    }

    Evidence('ZeptoDetectTest', {
      testSafariOSX: function(t){
        detect(UA.Safari_OSX_7_0_1, function(os, browser){
          t.assertUndefined(os.osx)
          t.assert(!os.ipad)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.chrome)
          t.assertEqual("7.0.1",browser.version)
        })
        detect(UA.Safari_OSX_7_0, function(os, browser){
          t.assert(!os.ipad)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.chrome)
          t.assertEqual("7.0",browser.version)
        })
        detect(UA.Safari_OSX_6_0, function(os, browser){
          t.assert(!os.ipad)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.chrome)
          t.assertEqual("6.0",browser.version)
        })
      },

      testSafariWindows: function(t){
        detect(UA.Safari_Windows_NT, "Windows", function(os, browser){
          t.assertUndefined(os.osx)
          t.assertUndefined(os.ios)
          t.assertUndefined(os.wp)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.chrome)
          t.assertEqual("5.0.4", browser.version)
        })
      },

      testWebOS: function(t){
        detect(UA.WebOS_1_4_0_Pre, function(os, browser){
          t.assertTrue(os.webos)
          t.assert(!os.touchpad)
          t.assertTrue(browser.webkit)
          t.assertEqual("1.4.0", os.version)
        })
        detect(UA.WebOS_1_4_0_Pixi, function(os){
          t.assertTrue(os.webos)
          t.assertEqual("1.4.0", os.version)
        })
        detect(UA.WebOS_1_2_9_Pixi, function(os){
          t.assertTrue(os.webos)
          t.assertEqual("1.2.9", os.version)
        })
        detect(UA.WebOS_3_0_0_TouchPad, function(os){
          t.assertTrue(os.webos)
          t.assertTrue(os.touchpad)
          t.assertEqual("3.0.0", os.version)
        })
      },

      testAndroid: function(t){
        detect(UA.Android_1_5, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertEqual("1.5", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(!!browser.safari)
        })
        detect(UA.Android_2_1, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertEqual("2.1", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(!!browser.safari)
        })
        detect(UA.Android_2_3, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertEqual("2.3.7", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(!!browser.safari)
        })
        detect(UA.Android_2_3_Lenovo_A750, function(os, browser){
          t.assertTrue(os.android, 'Expected Android')
          t.assertTrue(browser.webkit, 'Expected WebKit')
          t.assertEqual("2.3", os.version)
          // FIXME: Unfortunately we can't detect if it's a phone, as there's
          // no "mobile" in the UA string.
          // t.assertTrue(os.phone, 'Expected phone')
          t.assertFalse(!!browser.safari, 'Expected browser to not be Safari')
        })
        detect(UA.Android_4_1_1, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertFalse(!!os.ios)
          t.assertEqual("4.1.1", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(!!os.iphone)
          t.assertTrue(browser.chrome)
          t.assertFalse(!!browser.safari)
        })
        detect(UA.Android_4_1_1_Tablet, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertEqual("4.1.1", os.version)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.chrome)
          t.assertFalse(!!browser.safari)
        })
        detect(UA.Android_4_3, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertFalse(!!os.ios)
          t.assertEqual("4.3", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(!!os.iphone)
          t.assertTrue(browser.chrome)
          t.assertFalse(!!browser.safari)
        })
      },

      testIOS: function(t){
        detect(UA.iOS_3_0_iPhone, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.iphone)
          t.assertTrue(browser.webkit)
          t.assertEqual("3.0", os.version)
          t.assertEqual("420.1", browser.version)
          t.assertTrue(os.phone)
          t.assertTrue(browser.safari)
          t.assertFalse(!!os.android)
          t.assertFalse(!!browser.ie)
          t.assertFalse(!!browser.firefox)
          t.assertFalse(!!browser.silk)
          t.assertFalse(!!browser.chrome)
          t.assertFalse(!!browser.playbook)
        })
        detect(UA.iOS_3_1_1_iPod, function(os, browser){
          t.assertTrue(os.ios)
          t.assertUndefined(os.iphone)
          t.assertTrue(os.ipod)
          t.assertEqual("3.1.1", os.version)
          t.assertFalse(!!os.phone)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_3_2_iPad, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.ipad)
          t.assertFalse(!!os.iphone)
          t.assertEqual("3.2", os.version)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_3_2_iPad_2, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.ipad)
          t.assert(!os.iphone)
          t.assertEqual("3.2", os.version)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_4_0_iPhone, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.iphone)
          t.assert(!os.ipad)
          t.assertEqual("4.0", os.version)
          t.assertTrue(os.phone)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_4_2_iPad, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.ipad)
          t.assertEqual("4.2", os.version)
          t.assertFalse(os.phone)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_4_3_iPhone_Simulator, function(os, browser){
          t.assertTrue(os.ios)
          t.assertTrue(os.iphone)
          t.assertEqual("4.3", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_5_0_iPhone, function(os, browser){
          t.assert(os.ios)
          t.assert(os.iphone)
          t.assertEqual("5.0", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_5_1_iPad_webView, function(os, browser){
          t.assert(os.ios)
          t.assert(os.ipad)
          t.assertEqual("5.1", os.version)
          t.assertTrue(browser.webview)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_6_1_iPhone, function(os, browser){
          t.assert(os.ios)
          t.assert(os.iphone)
          t.assertEqual("6.1", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.webview)
          t.assertFalse(!!browser.chrome)
          t.assertFalse(!!browser.firefox)
        })
        detect(UA.iOS_6_0_iPad_mini, function(os, browser){
          t.assert(os.ios)
          t.assert(os.ipad)
          t.assertEqual("6.0", os.version)
          t.assertFalse(os.phone)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.safari)
        })
        detect(UA.iOS_7_0_iPhone, function(os, browser){
          t.assert(os.ios)
          t.assert(os.iphone)
          t.assertEqual("7.0", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.safari)
          t.assertFalse(!!browser.chrome)
          t.assertFalse(!!browser.firefox)
        })
        detect(UA.iOS_7_0_iPhone_Chrome, function(os, browser){
          t.assert(os.ios)
          t.assert(os.iphone)
          t.assertEqual("7.0", os.version)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertFalse(!!browser.safari)
          t.assertTrue(browser.chrome)
          t.assertFalse(!!browser.firefox)
          t.assertFalse(!!browser.webview)
        })
      },

      testBlackBerry: function(t) {
        detect(UA.BlackBerry_6_0_0_141, function(os, browser){
          t.assertTrue(os.blackberry)
          t.assertTrue(browser.webkit)
          t.assertEqual("6.0.0.141", os.version)
        }),
        detect(UA.PlayBook_1_0_0, function(os, browser){
          t.assertTrue(os.rimtabletos)
          t.assertTrue(browser.webkit)
          t.assertTrue(os.tablet)
          t.assertEqual("1.0.0", os.version)
        })
        detect(UA.PlayBook_2_1_0, function(os, browser){
          t.assertTrue(os.rimtabletos)
          t.assertTrue(browser.webkit)
          t.assertTrue(os.tablet)
          t.assertEqual("2.1.0", os.version)
        })
        detect(UA.BB10, function(os, browser){
          t.assertTrue(os.bb10)
          t.assertTrue(browser.webkit)
          t.assertTrue(os.phone)
          t.assertEqual("10.0.0.1337", os.version)
        })
      },

      testKindle: function(t) {
        detect(UA.Kindle, function(os, browser){
          t.assertTrue(os.kindle)
          t.assertTrue(browser.webkit)
          t.assertEqual("3.0", os.version)
        })

        detect(UA.Silk_1_0, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.silk)
          t.assertEqual("2.3.4", os.version)
        })

        detect(UA.Silk_1_0_accel, function(os, browser){
          t.assert(!os.android)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.silk)
          t.assertEqual("1.0.13.328_10008910", browser.version)
        })
      },

      testFirefox: function(t) {
        detect(UA.Firefox_6_0_2, function(os, browser){
          t.assertFalse(browser.webkit)
          t.assertEqual('6.0.2', browser.version)

          t.assertTrue(browser.firefox)
          t.assertFalse(!!os.firefoxos)
        })

        detect(UA.Firefox_13_Tablet, function(os, browser){
          t.assertTrue(browser.firefox)
          t.assertFalse(browser.webkit)
          t.assertTrue(os.android)
          t.assertFalse(os.phone)
          t.assertTrue(os.tablet)
          t.assertFalse(!!os.firefoxos)
        })

        detect(UA.Firefox_13_Phone, function(os, browser){
          t.assertTrue(browser.firefox)
          t.assertFalse(browser.webkit)
          t.assertTrue(os.android)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertFalse(!!os.firefoxos)
        })

        detect(UA.Firefox_Os_Phone, function(os, browser){
          t.assertTrue(browser.firefox)
          t.assertFalse(browser.webkit)
          t.assertTrue(os.firefoxos)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertEqual('18.0', os.version)
        })

        detect(UA.Firefox_Os_Tablet, function(os, browser){
          t.assertTrue(browser.firefox)
          t.assertFalse(browser.webkit)
          t.assertTrue(os.firefoxos)
          t.assertTrue(os.tablet)
          t.assertFalse(os.phone)
          t.assertEqual('18.0', os.version)
        })
      },

      testOpera: function(t) {
        detect(UA.Opera_11_51, function(os, browser){
          t.assertFalse(browser.webkit)
          t.assertUndefined(browser.version)
        })
      },

      testChrome: function(t) {
        detect(UA.Chrome_Android_18_0, function(os, browser){
          t.assertTrue(os.android)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.chrome)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertEqual("18.0.1025.133", browser.version)
        })

        detect(UA.Chrome_iOS_19_0, function(os, browser){
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(os.ios)
          t.assertTrue(browser.webkit)
          t.assertTrue(browser.chrome)
          t.assertEqual("19.0.1084.60", browser.version)
        })

        detect(UA.Chrome_OSX_24_0, function(os, browser){
          t.assertFalse(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.chrome)
        })
      },

      testIE: function(t) {
        detect(UA.Windows_IE_11, function(os, browser){
          t.assertFalse(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("11", browser.version)
        })

        detect(UA.Windows_IE_10, function(os, browser){
          t.assertFalse(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("10.0", browser.version)
        })

        detect(UA.Windows_RT_Surface, function(os, browser){
          t.assertFalse(os.phone)
          t.assertTrue(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("10.0", browser.version)
        })

        detect(UA.Windows_Phone_8, function(os, browser){
          t.assertTrue(os.wp)
          t.assertTrue(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("10.0", browser.version)
        })

        detect(UA.Windows_IE_9, function(os, browser){
          t.assertFalse(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("9.0", browser.version)
        })

        detect(UA.Windows_IE_9_Compat, function(os, browser){
          t.assertFalse(os.phone)
          t.assertFalse(os.tablet)
          t.assertTrue(browser.ie)
          t.assertEqual("7.0", browser.version)
        })

      }
    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/event.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Event unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Event unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">
  </div><!-- fixtures -->

  <script>
  (function(){

    function click(el){
      var event = document.createEvent('MouseEvents')
      event.initMouseEvent('click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null)
      $(el).get(0).dispatchEvent(event)
    }

    Evidence('ProxyTest', {
      testProxyFnContext: function(t){
        var a = {name: 'A', fn: function(n, o){ return this.name + n + o }},
            b = {name: 'B'}

        t.assertEqual('A13', a.fn(1, 3))
        t.assertEqual('B52', $.proxy(a.fn, b)(5, 2))
      },

      testProxyInvalidFn: function(t){
        try {
          $.proxy(null)
          t.fail("shouldn't be here")
        } catch(e) {
          t.assertEqual('TypeError', e.name)
          t.assertEqual("expected function", e.message)
        }
      },

      testProxyContextName: function(t){
        var b = {name: 'B', fn: function(n, o){ return this.name + n + o }},
            oldFn = b.fn

        t.assertEqual('B52', $.proxy(b, 'fn')(5, 2))
        t.assertIdentical(oldFn, b.fn)
      },

      testProxyUndefinedProperty: function(t){
        try {
          $.proxy({}, 'nonexistent')
          t.fail("shouldn't be here")
        } catch(e) {
          t.assertEqual('TypeError', e.name)
          t.assertEqual("expected function", e.message)
        }
      },

      testProxyAdditionalArguments: function(t){
        var a = {name: 'A', fn: function(){ return this.name + [].slice.call(arguments).join('') }}
        t.assertEqual('A123', $.proxy(a.fn, a)(1, 2, 3))
        t.assertEqual('A456', $.proxy(a.fn, a, 4, 5, 6)())
        t.assertEqual('A456123', $.proxy(a.fn, a, 4, 5, 6)(1, 2, 3))
      },

      testProxyContextNameAdditionalArguments: function(t){
        var a = {name: 'A', fn: function(){ return this.name + [].slice.call(arguments).join('') }}
        t.assertEqual('A123', $.proxy(a, 'fn')(1, 2, 3))
        t.assertEqual('A456', $.proxy(a, 'fn', 4, 5, 6)())
        t.assertEqual('A456123', $.proxy(a, 'fn', 4, 5, 6)(1, 2, 3))
      },

      testProxyInvalidProperty: function(t){
        try {
          $.proxy({num:3}, 'num')
          t.fail("shouldn't be here")
        } catch(e) {
          t.assertEqual('TypeError', e.name)
          t.assertEqual("expected function", e.message)
        }
      }
    })

    Evidence('EventTest', {
      setUp: function(){
        this.el = $('<div />').appendTo('#fixtures')
      },

      tearDown: function(){
        this.el.off().remove()
        $([document, document.body]).off()
      },

      testProxiedHandlerCanBeUnboundWithOriginal: function(t){
        var obj = {times:0, fn: function(){ this.times++ }}

        this.el.on('click', $.proxy(obj, 'fn'))
        click(this.el)
        t.assertEqual(1, obj.times)

        this.el.off('click', obj.fn)
        click(this.el)
        t.assertEqual(1, obj.times)
      },

      testOneHandlerCanBeUnboundWithOriginal: function(t){
        var count = 0, fn = function(){ count++ }

        this.el.one('click', fn)
        this.el.off('click', fn)
        click(this.el)
        t.assertEqual(0, count)
      },

      testOneDelegation: function(t){
        var context, count = 0
        $(document).one('click', 'div', function(){ context = this; count++ })

        click(this.el)
        click(this.el)
        t.assertEqual(1, count)
        t.assertIdentical(this.el.get(0), context)
      },

      testOneWithData: function(t){
        var obj = {}, gotObj, count = 0
        $(document).one('click', obj, function(e){ gotObj = e.data; count++ })

        click(this.el)
        click(this.el)
        t.assertEqual(1, count)
        t.assertIdentical(obj, gotObj)
      },

      testHandlerArity: function(t){
        var numArgs
        this.el.on('click', function(){ numArgs = arguments.length })

        click(this.el)
        t.assertEqual(1, numArgs)
      },

      testOnWithObject: function(t){
        var log = []
        this.el.on({ click: function(){ log.push('a') } }).
                on({ click: function(){ log.push('b') } }, null)

        click(this.el)
        t.assertEqual('a b', log.sort().join(' '))
      },

      testOnWithBlankData: function(t){
        var log = [], fn = function(e){ log.push(e.data) }
        this.el
          .on('click', null, fn)
          .on('click', undefined, fn)

        click(this.el)
        t.assertEqual(2, log.length)
        t.assertIdentical(null, log[0])
        t.assertIdentical(undefined, log[1])
      },

      testOffWithObject: function(t){
        var log = [],
            fn = function(){ log.push('a') },
            fn2 = function(){ log.push('b') },
            fn3 = function(){ log.push('c') }

        this.el.on('click', fn).on('click', fn2).on('click', fn3)
        click(this.el)
        t.assertEqual('a b c', log.sort().join(' '))

        this.el.off({ click: fn }).off({ click: fn2 }, null)
        click(this.el)
        t.assertEqual('a b c c', log.sort().join(' '))
      },

      testDelegateEventProperties: function(t){
        var type, target, currentTarget
        $(document).on('click', 'div', function(e){
          type = e.type
          target = e.target
          currentTarget = e.currentTarget
        })
        click($('<span>').appendTo(this.el))
        t.assertEqual('click', type)
        t.assertIdentical(this.el.find('span').get(0), target)
        t.assertIdentical(this.el.get(0), currentTarget)
      },

      testDelegateEventTimestamp: function(t){
        var timestamp
        $(document).on('click', 'div', function(e){
          timestamp = e.timeStamp
        })
        click($('<span>').appendTo(this.el))
        t.assert(timestamp > 0, 'timestamp was ' + timestamp)
      },

      testPreventDefaultWithDelegatedEvent: function(t){
        var isDefaultPrevented, span = $('<span>').appendTo(this.el)

        span.on('click', function(event){
          event.preventDefault()
        })
        $(document).on('click', 'div', function(event){
          isDefaultPrevented = event.isDefaultPrevented()
        })

        click(span)
        t.assertTrue(isDefaultPrevented, "isDefaultPrevented() value invalid for delegate proxy")
      },

      testEventsOnPlainObjects: function (t){
        var obj = {},
          log = [],
          fn1 = function(){ log.push('a') },
          fn2 = function(evt, value){ log.push(value)    },
          fn3 = function(evt, value){ log.push("event2") }
        $(obj)
          .on('event', fn1)
          .on('event', fn2)
          .on('event2', fn3)

        $(obj).trigger('event', 'b')
        t.assertEqual('a b', log.join(' '))

        log = []
        $(obj).trigger('event', 'c')
        t.assertEqual('a c', log.join(' '))

        log = []
        $(obj).off('event', fn1)
        $(obj).trigger('event', 'd')
        t.assertEqual('d', log.join(' '))

        log = []
        $(obj).trigger('event2')
        t.assertEqual('event2', log.join(' '))
      },

      testHandlerWithoutData: function(t){
        var gotData

        $(document).on('click', function(event){
          gotData = event.data
        })
        t.assertUndefined(gotData)

        click(this.el)
        t.assertUndefined(gotData)
      },

      testHandlerWithData: function(t){
        var data = {}, gotData, numArgs

        $(document).on('click', data, function(event){
          gotData = event.data
          numArgs = arguments.length
        })
        t.assertUndefined(gotData)

        click(this.el)
        t.assertEqual(1, numArgs)
        t.assertIdentical(data, gotData)
      },
      
      testHandlerWithFunctionAsData: function(t){
        var data = function () { console.log('foo') },
            gotData, numArgs
        
        $(document).on('click', data, function(event){
          gotData = event.data
          numArgs = arguments.length
        })
        t.assertUndefined(gotData)

        click(this.el)
        t.assertEqual(1, numArgs)
        t.assertIdentical(data, gotData)
      },

      testDelegatedWithData: function(t){
        var data = {}, gotData, numArgs

        $(document).on('click', 'div', data, function(event){
          gotData = event.data
          numArgs = arguments.length
        })
        t.assertUndefined(gotData)

        click(this.el)
        t.assertEqual(1, numArgs)
        t.assertIdentical(data, gotData)
      },

      testTriggerWithData: function(t){
        var data = {}, gotData

        $(document).on('myevent', data, function(event){
          gotData = event.data
        })
        t.assertUndefined(gotData)

        this.el.trigger('myevent')
        t.assertIdentical(data, gotData)
      },

      testDelegateEventMethods: function(t){
        var methodName,
            eventMethods = {
              preventDefault: 'isDefaultPrevented',
              stopImmediatePropagation: 'isImmediatePropagationStopped',
              stopPropagation: 'isPropagationStopped'
            },
            eventMethodResults = {}

        $(document).on('click', 'div', function(event){
          $.each(eventMethods, function(methodName, predicate){
            if (event[methodName]) {
              event[methodName]()
              eventMethodResults[predicate] = event[predicate]()
            } else {
              console.warn("method not available: ", methodName)
            }
          })
        })

        click($('<span>').appendTo(this.el))

        $.each(eventMethodResults, function(predicate, value){
          t.assertTrue(value, predicate)
        })
      },

      testIsDefaultPreventedOnAllEvents: function(t){
        var isDefaultPrevented

        $(this.el).on('click', function(event){
          event.preventDefault()
        })
        $(document).on('click', function(event){
          isDefaultPrevented = event.isDefaultPrevented()
        })

        click(this.el)
        t.assertTrue(isDefaultPrevented)
      },

      testIsDefaultPreventedOnOriginalEventAfterDelegate: function(t){
        var isDefaultPrevented

        this.el.on('click', 'span', function(event){
          event.preventDefault()
        })
        $(document).on('click', function(event){
          isDefaultPrevented = event.isDefaultPrevented()
        })

        click($('<span>').appendTo(this.el))

        t.assertTrue(isDefaultPrevented)
      },

      testStopImmediatePropagation: function(t){
        var log = ''

        this.el
          .on('click', function(e){ log += 'A' })
          .on('click', function(e){ log += 'B'; e.stopImmediatePropagation() })
          .on('click', function(e){ log += 'C' })

        $(document).on('click', function(e){ log += 'D' })

        click(this.el)

        t.assertEqual('AB', log)
      },

      testDelegateSelectorLookupDoesNotIncludeParent: function(t){
        var fired = false

        this.el
          .addClass('offender')
          .on('click', '.offender', function(){ fired = true })

        click(this.el)

        t.assertFalse(fired)
      },

      testFalseLiteralAsCallback: function(t){
        var event = $.Event('click')

        this.el.on('click', false)

        this.el.trigger(event)
        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(event.isPropagationStopped())
      },

      testFalseLiteralAsCallbackForShorthand: function(t){
        var event = $.Event('click')

        this.el.click(false)

        this.el.trigger(event)
        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(event.isPropagationStopped())
      },

      testUnbindingFalseLiteral: function(t){
        var event = $.Event('click'), fired

        this.el
          .on('click', function() { fired = true })
          .on('click', false)
          .off('click', false)

        this.el.trigger(event)

        t.assertTrue(fired)
        t.assertFalse(event.isDefaultPrevented())
        t.assertFalse(event.isPropagationStopped())
      },

      testFalseLiteralAsCallbackWithDataArgument: function(t){
        var event = $.Event('click')

        this.el.on('click', null, false)

        this.el.trigger(event)
        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(event.isPropagationStopped())
      },

      testFalseLiteralAsCallbackForDelegation: function(t){
        var span = $('<span>').appendTo(this.el),
            event = $.Event('click')

        this.el.on('click', 'span', false)

        span.trigger(event)
        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(event.isPropagationStopped())
      },

      testFalseLiteralAsCallbackForDelegationWithDataArgument: function(t){
        var span = $('<span>').appendTo(this.el),
            event = $.Event('click')

        this.el.on('click', 'span', null, false)

        span.trigger(event)
        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(event.isPropagationStopped())
      }

    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/evidence_runner.js
================================================
(function(){
  var ConsoleTestRunner = Evidence.AutoRunner.RUNNERS.console,
      ConsoleTestResult = Evidence.UI.Console.TestResult,
      AutoRunner = Evidence.AutoRunner,
      printf = Evidence.UI.printf

  function inherit(superclass, extra) {
    var klass = function(){
      this.initialize.apply(this, arguments)
    }
    var tmp = function(){}
    tmp.prototype = superclass.prototype
    klass.prototype = new tmp()
    klass.prototype.constructor = klass
    klass.prototype.initialize = function(){
      superclass.apply(this, arguments)
    }

    if (extra) {
      var methods = extra.call(klass, superclass.prototype)
      for (var method in methods) klass.prototype[method] = methods[method]
    }
    return klass
  }

  var TestRunner = inherit(ConsoleTestRunner, function(_super) {
    AutoRunner.RUNNERS.zepto = this
    return {
      _makeResult: function() { return new TestResult(this.logger) }
    }
  })

  var TestResult = inherit(ConsoleTestResult, function(_super) {
    return {
      start: function(t0) {
        Evidence.TestResult.prototype.start.call(this, t0)
        this.logger.debug('Started tests.')
      },
      stop: function(t1) {
        _super.stop.call(this, t1)
        displayResults(this, (t1-this.t0)/1000)
        checkLeakedGlobals()
      },
      pauseTest: function(testcase) {
        this.logger.debug('Paused testcase ' + testcase + '.')
      },
      restartTest: function(testcase) {
        this.logger.debug('Restarted testcase ' + testcase + '.')
      },
      startSuite: function(suite) {
        this.logger.debug('Started suite ' + suite + '.')
      },
      addFailure: function(testcase, reason) {
        this.logToServer(testcase, reason)
        _super.addFailure.call(this, testcase, reason)
      },
      addError: function(testcase, error) {
        this.logToServer(testcase, error)
        _super.addError.call(this, testcase, error)
      },
      logToServer: function(testcase, error) {
        if (location.protocol == 'file:') return
        var name = testcase.parent.name + '#' + testcase.name,
            message = error.template ?
              Evidence.UI.printf(error.template, error.args) + (error.message ? ' ' + error.message : '') :
              error.message,
            body = 'name=' + encodeURIComponent(name) + '&' +
                   'message=' + encodeURIComponent(message) + '&' +
                   'trace=' + encodeURIComponent(error.stack || '')

        var xhr = new XMLHttpRequest()
        xhr.open('POST', '/test/log', true)
        xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded')
        xhr.send(body)
      }
    }
  })

  Evidence.TestCase.prototype.debug = function(message) {
    this._result.logToServer(this, { message: message })
  }

  // HACK: force our test runner as default
  ;(function(){
    var _super = AutoRunner.prototype.retrieveOptions
    AutoRunner.prototype.retrieveOptions = function() {
      var options = _super.call(this)
      if (!options.runner) options.runner = 'zepto'
      return options
    }
  })()

  function $(id) { return document.getElementById(id) }

  function displayResults(results, seconds) {
    var container = $('results')
    if (container) {
      if (results.failureCount || results.errorCount) {
        container.className = 'failed'
        container.innerHTML = printf("Finished in %d s. &ndash; <em>%d failures, %d errors</em> (%d assertions)",
                                     [seconds, results.failureCount, results.errorCount, results.assertionCount])
      } else {
        container.className = 'passed'
        container.innerHTML = printf("Finished in %d s. &ndash; <em>%d tests passed</em> (%d assertions)",
                                     [seconds, results.testCount, results.assertionCount])
      }
      container.className += ' finished'
    }
  }

  var globals = [], expected = ['Zepto', '$', 'Evidence', '_zid', 'jsonpDummy']
  for (var key in window) globals.push(key)

  function checkLeakedGlobals() {
    var opera = /^Opera\b/.test(navigator.userAgent)
    for (var key in window)
      if ( globals.indexOf(key) < 0 && expected.indexOf(key) < 0 &&
          (!opera || typeof window[key] != 'object' || window[key].id != key) &&
          window.console && console.warn
          )
        console.warn("unexpected global: " + key)
  }
})()


================================================
FILE: test/fixtures/ajax_load_javascript.js
================================================
window.testValue = 1


================================================
FILE: test/fixtures/ajax_load_selector.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>testAjaxLoad</title>
</head>
<body>
<div id="ajax_load_test_div">ajax load with selector</div>
<div>
  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
</div>
</body>
</html>


================================================
FILE: test/fixtures/ajax_load_selector_javascript.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>testAjaxLoad</title>
</head>
<body>
<div id="ajax_load_test_div">ajax load with selector</div>
<div>
  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
</div>
<script>
  window.testValue = 1
</script>
</body>
</html>


================================================
FILE: test/fixtures/ajax_load_simple.html
================================================
simple ajax load


================================================
FILE: test/fixtures/iframe_document.html
================================================
<b>Hello from iframe!</b>


================================================
FILE: test/fixtures/zepto.json
================================================
{
  "zepto": "awesomeness"
}


================================================
FILE: test/form.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Form unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event form ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Form unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <div id="fixtures">
  <form id="login_form" target="formtarget" action="./idontexist.html">
    <input name="email" value="koss@nocorp.me">
    <input name="password" value="123456">
    <input name="unchecked_hasValue" value="myValue" type="checkbox">
    <input name="unchecked_noValue" type="checkbox">
    <input name="checked_hasValue" checked value="myValue" type="checkbox">
    <input name="checked_disabled" checked value="ImDisabled" type="checkbox" disabled>
    <input name="checked_noValue" checked type="checkbox">
    <input type="text" id="no_name">
    <input type="file" name="file_upload">

    <fieldset>
      <input type="radio" name="radio1" value="r1">
      <input type="radio" name="radio1" checked value="r2">
      <input type="radio" name="radio1" value="r3">
    </fieldset>

    <select name="selectbox">
      <option value="selectopt1">select1</option>
      <option value="selectopt2">select2</option>
      <option value="selectopt3">select3</option>
    </select>

    <select name="users[id][]" multiple>
      <option value="1">a</option>
      <option value="2" selected>b</option>
      <option value="3" selected>c</option>
      <option value="4">d</option>
    </select>

    <div class="actions">
      <!--
        The name of the following element can't be "submit",
        as this breaks on IE 10 (the form's "submit" method
        is overwritten by an accessor to the input field
        with the "submit" name). Yes, that's a dumb bug.
      -->
      <input type="submit" name="submit_button" value="Save">

      <input type="button" name="preview" value="Preview">
      <input type="reset" name="clear" value="Clear form">
      <button name="button">I'm a button</button>
    </div>
  </form>

  <iframe name="formtarget"></iframe>
  </div>

  <script>
  (function(){

    // TODO: do we really need this function? This should be refactored.
    var isObjectEquals = function(obj1, obj2){
      for (var key in obj1)
        switch(typeof(obj1[key])) {
          case 'object':
            if (!isObjectEquals(obj1[key], obj2[key]))
              return false
            break

          case 'function':
            if (typeof(obj2[key]) == 'undefined' ||
              (obj1[key].toString() != obj2[key].toString()))
              return false
            break

          default:
            if (obj1[key] != obj2[key])
              return false
        }

      for (key in obj2)
        if (typeof(obj1[key]) == 'undefined')
          return false

      return true
    }

    Evidence.Assertions.assertEqualObject = function(expected, actual, message) {
      this._assertExpression(
        isObjectEquals(expected, actual),
        message || 'Failed assertion.',
        'Expected %o, got %o.', expected, actual
      )
    }

    Evidence('FormTest', {

      testSerializeArray: function(t){
        var loginForm = $('#login_form')
        t.assertEqualObject(
          [
              { name: 'email', value: 'koss@nocorp.me' },
              { name: 'password', value: '123456' },
              { name: 'checked_hasValue', value: 'myValue' },
              { name: 'checked_noValue', value: 'on' },
              { name: 'radio1', value: 'r2' },
              { name: 'selectbox', value: 'selectopt1' },
              { name: 'users[id][]', value: '2' },
              { name: 'users[id][]', value: '3' }
          ],
          loginForm.serializeArray()
        )
      },

      testSerialize: function(t){
        var loginForm = $('#login_form')
        t.assertEqual('email=koss%40nocorp.me&password=123456&checked_hasValue=myValue&checked_noValue=on&radio1=r2&selectbox=selectopt1&users%5Bid%5D%5B%5D=2&users%5Bid%5D%5B%5D=3', loginForm.serialize())
      },

      testFormSubmit: function(t){
        var eventTriggered = false
        $('#login_form').submit(function(event){
          eventTriggered = true
          event.preventDefault()
        })
        $('#login_form').submit()
        t.assert(eventTriggered)
      },

      testFormSubmitBindFalse: function(t){
        var eventPropagated = false
        $(document).on('submit', function(){
          eventPropagated = true
        })

        try {
          var form = $('#login_form')
          form.submit(false)
          form.submit()
          t.assertFalse(eventPropagated)
        } finally {
          $(document).off('submit')
        }
      },

      testSerializeEmptyCollection: function(t){
        t.assertIdentical(0, $().serializeArray().length)
        t.assertIdentical("", $().serialize())
      }

    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/functional/assets.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Zepto assets functional test</title>
  <link rel="stylesheet" href="../test.css">
  <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  <script src="../../src/zepto.js"></script>
  <script src="../../src/ie.js"></script>
  <style>
    #container div {
      margin: 2px;
      padding: 2px;
      display: block;
      background-color: #ccc;
    }
    img {
      margin: 0;
      height: 100px;
      vertical-align: middle;
    }
  </style>
</head>
<body>
  <h1>Zepto assets functional test</h1>

  <div id="browser"></div>

  <ul>
    <li><a href="?without">Run without the assets plugin</a></li>
    <li><a href="?with">Run with the assets plugin</a></li>
    <li><a href="?">Stop</a></li>
  </ul>

  <p>When you run this test without the assets plugin, Mobile Safari will stop loading after on average 8 images (that's on the iPad with 1 MB images). It might also crash.</p>
  <p><strong>PLEASE NOTE:</strong> You <strong>must restart Safari</strong> between runs (click the home button to return to the home screen, double-click the home button, tap-and-hold the Safari icon, then tap the minus badge).</p>

  <div id="container"></div>

  <script>
    var prefix = 'http://stuff.vandervossen.net/temporary/zepto_assets_test/sintel-',
        mode = window.location.search.slice(1),
        timeout,
        i
    if (mode === 'with') {
      document.write('<script src="../src/assets.js"></s'+'cript>')
      document.write('RUNNING WITH ASSETS PLUGIN')
    }
    if (mode !== '') {
      i = 1
      ;(function frame() {
        $('#image' + (i - 4)).remove()
        $('#container').prepend('<div>' + i + ': <img id="image' + i + '" src="' + prefix + i + '.jpg"></div>')
        if (i++ < 51) timeout = setTimeout(frame, 6000)
      })()
    }

    $('#browser').text(navigator.userAgent)
  </script>
</body>
</html>


================================================
FILE: test/functional/fx.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  <link rel="stylesheet" href="../test.css">
  <title>Zepto fx functional test</title>
  <script src="../../src/zepto.js"></script>
  <script src="../../src/event.js"></script>
  <script src="../../src/fx.js"></script>
  <script src="../../src/fx_methods.js"></script>
  <script src="../../src/ie.js"></script>
  <style>
    #fx_test, #fx_test_2  { text-align: center; background: darkred; color: white; font-size: x-large; }
    #fx_test_2 { background: darkblue; }
  </style>
</head>
<body>
  <h1>Zepto fx functional</h1>

  <div style="width: 280px; height: 180px; background: #ddd; -webkit-user-select: none; margin-bottom: 1em">
    <div id="fx_test" style="height: 100%; line-height: 170px">I  ♥ fx</div>
  </div>

  <div style="width: 280px; height: 180px; background: #ddd; -webkit-user-select: none; margin-bottom: 1em">
    <div id="fx_test_2" style="height: 100%; line-height: 170px">I  ♥ fx</div>
  </div>

  <button onclick="$('#fx_test').hide('slow')">Hide</button>
  <button onclick="$('#fx_test').show('slow')">Show</button>
  <button onclick="$('#fx_test').show()">Reg. show</button>
  <button onclick="$('#fx_test').toggle('slow')">Toggle</button>
  <button onclick="$('#fx_test, #fx_test_2').toggle('slow')">Both: Toggle ('slow')</button>
  <button onclick="$('#fx_test, #fx_test_2').toggle()">Both: Toggle</button>
  <br>
  <button onclick="$('#fx_test').fadeIn('slow')">Fade in</button>
  <button onclick="$('#fx_test').fadeOut('slow')">Fade out</button>
  <button onclick="$('#fx_test').fadeToggle('slow')">Fade toggle</button>
  <button onclick="$('#fx_test, #fx_test_2').fadeToggle('slow')">Both: Fade toggle</button>

  <div id="browser"> </div>

  <script>
    $('#browser').text(navigator.userAgent)
    $('#fx_test_2').toggle()
  </script>
</body>
</html>


================================================
FILE: test/functional/gesture.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Zepto gesture functional test</title>
  <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  <link rel="stylesheet" href="../test.css">
  <script src="../../src/zepto.js"></script>
  <script src="../../src/event.js"></script>
  <script src="../../src/detect.js"></script>
  <script src="../../src/gesture.js"></script>
  <script src="../../src/ie.js"></script>
</head>
<body>
  <h1>Zepto gestures functional test</h1>

  <div id="gesture_test" style="width: 200px; height: 200px; background: #ddd; -webkit-user-select: none">
    gesture events test
  </div>

  <div id="browser"> </div>

  <script>
    $('#browser').text(navigator.userAgent)

    $('#gesture_test')
      .pinch(function(){
        $(this).append(' | pinch!')
      })
      .pinchIn(function(){
        $(this).append(' | pinch in!')
      })
      .pinchOut(function(){
        $(this).append(' | pinch out!')
      })
  </script>
</body>
</html>


================================================
FILE: test/functional/touch.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Zepto touch functional test</title>
  <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  <link rel="stylesheet" href="../test.css">
  <script src="../../src/zepto.js"></script>
  <script src="../../src/event.js"></script>
  <script src="../../src/ie.js"></script>
  <script src="../../src/touch.js"></script>
</head>
<body>
  <h1>Zepto touch functional test</h1>

  <p>
    Browser supports touch events?
    <script>document.write('ontouchstart' in window)</script><br>

    Browser supports MS pointer events?
    <script>document.write(!!navigator.msPointerEnabled)</script>
  </p>

  <div id="touch_test" style="width: 200px; height: 200px; background: #cce; -webkit-user-select: none">
    touch events test
  </div>

  <div id='touch_test_scrollable' style="width: 200px; height: 200px; background: #cec; -webkit-user-select: none">
    touch events test (scrollable cancel)
  </div>

  <div id='touch_test_single' style="width: 200px; height: 200px; background: #ecc; -webkit-user-select: none">
    touch events test (scrollable cancel, single tap only)
  </div>

  <div id="browser"> </div>

  <script>
    $('#browser').text(navigator.userAgent)

    /**
     * #touch_test
     * Container that captures all touch events.
     *
     * Prevents default on touchmove, disabling scrolling.
     * Captures swipes in all directions.
     * Captures tap, singleTap (after delay), doubleTap, longTap
     */
    $('#touch_test').bind('touchmove', function(e) { e.preventDefault() })
    listen_to('#touch_test')

    /**
     * #touch_test_scrollable
     * Container that allows scrolling while capturing all events except swipes in the direction of scroll
     *
     * Captures swipes in non-scrolling directions
     * Captures tap, singleTap (after delay), doubleTap, longTap
     */
    listen_to('#touch_test_scrollable')

    /**
     * #touch_test_single
     * Container that allows scrolling and captures only simple, single taps
     * eg: a button or a tappable list item
     *
     * Cancels touch after tap, disabling other touch events (singleTap, doubleTap)
     * Captures tap
     */
    $('#touch_test_single').bind('tap', function(e) {
      e.cancelTouch()
    })
    listen_to('#touch_test_single')



    function listen_to(el) {
      $(el).tap(function(){
        $(this).append(' | tap!')
      })
      .doubleTap(function(){
        $(this).append(' | double tap!')
      })
      .swipe(function(){
        $(this).append(' | swipe!')
      })
      .swipeLeft(function(){
        $(this).append(' | swipe left!')
      })
      .swipeRight(function(){
        $(this).append(' | swipe right!')
      })
      .swipeUp(function(){
        $(this).append(' | swipe up!')
      })
      .swipeDown(function(){
        $(this).append(' | swipe down!')
      })
      .longTap(function(){
        $(this).append(' | long tap!')
      })
      .singleTap(function(){
        $(this).append(' | single tap!')
      })
    }
  </script>
</body>
</html>


================================================
FILE: test/functional/touchcancel.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Zepto touch functional test</title>
  <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  <link rel="stylesheet" href="../test.css">
  <script src="../../src/zepto.js"></script>
  <script src="../../src/event.js"></script>
  <script src="../../src/ie.js"></script>
  <script src="../../src/touch.js"></script>
</head>
<body>
  <h1>Zepto touch functional test</h1>

  <p>
    Double-tap and hold until the JavaScript alert occurs. After closing the
    alert, tap again. Without touchcancel you will see a double tap instead of a tap.
  </p>

  <div id="touch_test" style="width: 200px; height: 200px; background: #ddd">
    touch events test
  </div>

  <div id="browser"> </div>

  <script>
    $('#browser').text(navigator.userAgent)

    setTimeout(function(){
      alert("Alert! Now tap again, you should see a tap!, not a double tap!")
    }, 3000)

    $('body').bind('touchmove', function(e){ e.preventDefault() })
    $('#touch_test')
      .tap(function(){
        $(this).append(' | tap!')
      })
      .doubleTap(function(){
        $(this).append(' | double tap!')
      })
      .swipe(function(){
        $(this).append(' | swipe!')
      })
      .swipeLeft(function(){
        $(this).append(' | swipe left!')
      })
      .swipeRight(function(){
        $(this).append(' | swipe right!')
      })
      .swipeUp(function(){
        $(this).append(' | swipe up!')
      })
      .swipeDown(function(){
        $(this).append(' | swipe down!')
      })

  </script>
</body>
</html>


================================================
FILE: test/fx.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Fx unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event fx ie')
    })()
  </script>
  <style>
    @-webkit-keyframes animName {
      0% {
        -webkit-transform: rotate(180deg) scale(.8);
        opacity: 1;
      }
      100% {
        -webkit-transform: rotate(0deg) scale(1) translate3d(80px, 20px, 0);
        opacity: 0.5;
      }
    }
    @-moz-keyframes animName {
      from {
        -moz-transform: rotate(180deg) scale(.8) translate(0, 0);
        opacity: 1;
      }
      to {
        -moz-transform: rotate(0deg) scale(1) translate(80px, 20px);
        opacity: 0.5;
      }
    }
     @keyframes animName {
      from {
        transform: rotate(180deg) scale(.8) translate(0, 0);
        opacity: 1;
      }
      to {
        transform: rotate(0deg) scale(1) translate(80px, 20px);
        opacity: 0.5;
      }
    }

    #keyframetest {
      opacity: 0.5;
      -webkit-transform: translate3d(80px, 20px, 0);
      -moz-transform: translate3d(80px, 20px, 0);
      transform: translate3d(80px, 20px, 0);
    }

    .fixtures-left {
      width: 120px;
      float: left;
    }
    .fixtures-right {
      margin-left: 120px;
    }
  </style>
</head>
<body>
  <h1>Zepto Fx unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <div class=fixtures-left>
    <div id="animtest_1" style="width:40px;height:40px;background:red"></div>
    <div id="animtest_2" style="width:40px;height:40px;background:red"></div>
    <div id="durationtest_1" style="width:40px;height:40px;background:red"></div>
    <div id="durationtest_2" style="width:40px;height:40px;background:red"></div>
    <div id="delaytest" style="width:40px;height:40px;background:red"></div>
  </div>
  <div class=fixtures-right>
    <div id="durationtest_3" style="width:40px;height:40px;background:red"></div>
    <div id="callbacktest" style="width:40px;height:40px;background:red"><div style="width:40px;height:40px;background:blue"></div></div>
    <div id="keyframetest" style="width:40px;height:40px;background:red;"></div>
  </div>

  <div id="anim_zero_duration_callback_test"></div>

  <script>
  (function(){

    function colorToHex (color) {
      if (color.substr(0, 1) === '#') {
        return color
      }

      var digits = /(.*?)rgb\((\d+), (\d+), (\d+)\)/.exec( color.toLowerCase() ),
          red    = parseInt(digits[2]),
          green  = parseInt(digits[3]),
          blue   = parseInt(digits[4]),
          rgb = blue | (green << 8) | (red << 16)

      return digits[1] + '#' + rgb.toString(16)
    }

    function defer(delay, fn) {
      setTimeout(fn, delay || 0)
    }

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

    var stylePrefix = $.fx.cssPrefix

    Evidence.Assertions.assertStyle = function(expected, object, property, message) {
      if (/^(transform|transition|animation)/.test(property)) property = stylePrefix + property
      if (!('nodeName' in object)) object = object.get(0)

      var actual = object.style[camelize(property)],
        expression = expected instanceof RegExp ? expected.test(actual) : expected === actual

      this._assertExpression(expression, message || 'Failed assertion.',
        'Expected '+property+' to be '+expected+', got '+actual+'.\n'+
        $.fx.stylePrefix +':\n' +
        object.style.cssText)
    }

    Evidence('ZeptoFXTest', {

      testAnimate: function(t){
        var el = $('#animtest_1'), el2 = $('#animtest_2')

        el.animate({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          scale: '0.8',
          opacity: 0.5,
          backgroundColor: '#BADA55',
          backgroundPositionY: '50%'
        }, 200, 'ease-out')

        el2.animate({
          translate3d: '80px, 20px, 100px',
          rotateZ: '-90deg',
          backgroundColor: '#BADA55'
        }, {
          duration: 180,
          easing: 'ease-out'
        })

        t.assertStyle('ease-out', el, 'transition-timing-function')
        t.assertStyle('0.2s', el, 'transition-duration')
        t.assertStyle(/\bbackground-color\b/, el, 'transition-property')
        t.assertStyle(/\bbackground-position-y\b/, el, 'transition-property')
        t.assertStyle(/\btransform\b/, el, 'transition-property')
        t.assertStyle('0.18s', el2, 'transition-duration')

        t.pause()
        defer(250, function(){
          t.resume(function(){
            t.assertStyle('translate3d(80px, 20px, 100px) rotateZ(90deg) scale(0.8)', el, 'transform')
            t.assertStyle('0.5', el, 'opacity')
            t.assertStyle(/^(50%|center)$/, el, 'background-position-y')
            t.assertEqual('#BADA55', colorToHex(el.get(0).style.backgroundColor).toUpperCase())
          })
        })
      },

      testDuration: function(t){
        var el1 = $('#durationtest_1').anim({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          opacity: 0.5
        })

        var el2 = $('#durationtest_2').anim({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          opacity: 0.5
        }, 0)

        t.assertStyle('0.4s', el1, 'transition-duration', 'expected default duration')
        t.assertStyle('', el2, 'transition-duration', 'expected no animation')
      },

      testDurationString: function(t){
        var el = $('#durationtest_3').animate({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          opacity: 0.5
        }, 'fast')

        t.assertStyle('0.2s', el, 'transition-duration', 'expected fast duration')
      },

      testDelay: function(t){
        var duration = 100, delay = 50,
          start = new Date().getTime()

        t.pause()
        var el1 = $('#delaytest').animate({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          opacity: 0.5
        }, {
          duration: duration,
          delay: delay,
          complete: function() {
            t.resume(function(){
              var ms = new Date().getTime() - start
              t.assert(ms >= (duration + delay),
                'Fired too early (' + ms + ' ms) after having delay')
            })
          }
        })

        t.assertStyle('0.05s', el1, 'transition-delay', 'expected delay to be set')
      },

      testCallback: function(t){
        var duration = 250, start = new Date().getTime()

        t.pause()
        $('#callbacktest').animate({
          translate3d: '80px, 20px, 100px',
          rotateZ: '90deg',
          opacity: 0.5
        }, duration, 'linear',
        function(){
          var context = this
          t.resume(function(){
            t.assert($(context).is('#callbacktest'), "context for callback is wrong")
            t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
            t.assertStyle('', context, 'transition')
            t.assertStyle('', context, 'transition-property')
            t.assertStyle('', context, 'transition-timing-function')
            t.assertStyle('', context, 'transition-duration')
            t.assertStyle('', context, 'animation-name')
            t.assertStyle('', context, 'animation-duration')
          })
        })
      },

      testCallbackWithoutEasing: function(t){
        var duration = 250, start = new Date().getTime()

        t.pause()
        $('#callbacktest').animate({
          translate3d: '10px, 20px, 400px',
          rotateZ: '-90deg',
          opacity: 0.2
        }, duration,
        function(){
          var context = this
          t.resume(function(){
            t.assert($(context).is('#callbacktest'), "context for callback is wrong")
            t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
            t.assertStyle('', context, 'transition')
            t.assertStyle('', context, 'transition-property')
            t.assertStyle('', context, 'transition-timing-function')
            t.assertStyle('', context, 'transition-duration')
            t.assertStyle('', context, 'animation-name')
            t.assertStyle('', context, 'animation-duration')
          })
        })
      },

      testCallbackWithoutEasingAndWithoutDuration: function(t){
        var duration = 250, start = new Date().getTime()

        t.pause()
        $('#callbacktest').animate({
          translate3d: '30px, 220px, 40px',
          rotateZ: '180deg',
          opacity: 0.9
        },
        function(){
          var context = this
          t.resume(function(){
            t.assert($(context).is('#callbacktest'), "context for callback is wrong")
            t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
            t.assertStyle('', context, 'transition')
            t.assertStyle('', context, 'transition-property')
            t.assertStyle('', context, 'transition-timing-function')
            t.assertStyle('', context, 'transition-duration')
            t.assertStyle('', context, 'animation-name')
            t.assertStyle('', context, 'animation-duration')
          })
        })
      },

      testBubbling: function(t){
        $('#callbacktest div').anim({ opacity: 0.0 }, 0.1, 'linear')

        var el = $('#anim_zero_duration_callback_test'),
          callbackCalled = false

        el.anim({ opacity: 0.5 }, 0, 'linear', function () {
          t.assert($(this).is('#anim_zero_duration_callback_test'), "context for callback is wrong")
          t.assertStyle('0.5', this, 'opacity')
          callbackCalled = true
        })

        t.pause()
        defer(30, function(){
          t.resume(function(){
            t.assert(callbackCalled)
          })
        })
      },

      testKeyFrameAnimation: function(t){
        var el = $('#keyframetest').animate('animName', 200)

        t.assertStyle('animName', el, 'animation-name')
        t.assertStyle('0.2s',     el, 'animation-duration')
        t.assertStyle('linear',   el, 'animation-timing-function')
      },

      testEmptyCollection: function(t){
        t.assert($(null).animate({opacity:0}))
      }
    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/ie.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Touch unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('ie')
    })()
  </script>
  <style>
      body {
          height: 50px;
      }
      body:after {
          content: 'abc';
      }
  </style>
</head>
<body>
  <h1>Zepto ie unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <script>
    (function(){

      Evidence('getComputedStyle', {

        //Test to check if getComputedStyle does not blow up when no element are provided
        testGetComputedStyleNoElem: function(t){
          t.assertEqual(null, getComputedStyle())
        },

        //Test to check if computed styles for elements are returned correctly
        testGetComputedStyle: function(t){
          t.assertEqual('50px', getComputedStyle(document.body).height)
        },

        //Test to check if computed styles for pseudo-elements are returned correctly
        //Assertion a bit hacky as IE returns the value in double quotes
        testGetComputedStylePseudoElem: function(t){
          t.assert(getComputedStyle(document.body, ':after').content.indexOf('abc') >  -1)
        }

      })
    })()
  </script>

</body>
</html>


================================================
FILE: test/index.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto tests</title>
</head>
<body>
  <h1>Zepto tests</h1>
  <p>
    This file is provided for manual testing. If there's a test failure,
    please report the user agent:
    <b><script>document.write(navigator.userAgent)</script></b>
  </p>
  <p>
    Start a test server with (you'll need to have <a href="https://npmjs.org">npm</a> installed):<br>
    <br>
    <b>$ npm install</b> (if you haven't installed dependencies yet)<br>
    <b>$ npm run-script start</b>
    <br><br>
    On your device, go to<br>
    <b>http://your-ip-address:3000/test</b>
  </p>
  <p>
    To start a test, click or tap it. Use the back button of
    your browser to return to this index page.
    Functional tests may require manual interaction.
  </p>

  <h2>Default modules unit tests</h2>
  <ul>
    <li><a href="zepto.html">zepto</a> (core module, test this first!)</li>
    <li><a href="event.html">event</a></li>
    <li><a href="ajax.html">ajax</a></li>
    <li><a href="form.html">form</a></li>
  </ul>

  <h2>Other modules unit test</h2>
  <ul>
    <li><a href="fx.html">fx</a></li>
    <li><a href="detect.html">detect</a></li>
    <li><a href="data.html">data</a></li>
    <li><a href="selector.html">selector</a></li>
    <li><a href="stack.html">stack</a></li>
    <li><a href="touch.html">touch</a></li>
    <li><a href="deferred.html">deferred</a></li>
    <li><a href="ajax_deferred.html">ajax + deferred</a></li>
    <li><a href="callbacks.html">callbacks</a></li>
    <li><a href="ios3.html">ios3</a></li>
    <li><a href="ie.html">ie</a></li>
  </ul>

  <h2>Functional tests</h2>
  <ul>
    <li><a href="functional/assets.html">assets</a></li>
    <li><a href="functional/fx.html">fx</a></li>
    <li><a href="functional/gesture.html">gesture</a></li>
    <li><a href="functional/touch.html">touch</a></li>
    <li><a href="functional/touchcancel.html">touchcancel</a></li>
  </ul>

  <script>
    // avoid caching
    (function(){
      [].slice.apply(document.getElementsByTagName('a')).forEach(function(link){
        link.href += '?' + (+new Date)
      })
    })()
  </script>
</body>


================================================
FILE: test/ios3.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto iOS3 unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('ios3 zepto ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto iOS3 unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <script>
  (function(){

    Evidence('PolyfillTest', {

      // test to see if we augment String.prototype.trim if not supported natively
      testTrim: function(t){
        t.assertEqual("blah", " blah ".trim())
        t.assertEqual("bl \n ah", " bl \n ah ".trim())
      },

      // test to see if we augment Array.prototype.reduceif not supported natively
      testReduce: function(t){
        t.assertEqual(
          10,
          [0,1,2,3,4].reduce(function(p,c){ return p+c })
        )

        t.assertEqual(
          20,
          [0,1,2,3,4].reduce(function(p,c){ return p+c }, 10)
        )

        var flattened = [[0,1], [2,3], [4,5]].reduce(function(a,b){
          return a.concat(b)
        })

        t.assertEqual(6, flattened.length)

        for(var i=0;i<6;i++) t.assertEqual(i, flattened[i])
      }
    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/runner.js
================================================
(function() {
  var fs = require('fs')
  var system = require('system')
  var args = system.args.slice(1)

  var prefix = args.shift() || ("file://" + fs.workingDirectory + "/")

  var suites
  if (args.length > 0) {
    suites = args
  } else {
    var modules = 'zepto ajax callbacks data deferred ajax_deferred detect touch event form fx selector stack'.split(/\s+/)
    suites = modules.map(function(name) {
      return "test/" + name + ".html"
    })
  }

  var page = require('webpage').create()

  page.onConsoleMessage = function(msg) {
    console.log(msg)
  }

  page.onError = function(msg, trace) {
    console.log('ERROR: ' + msg)
  }

  function waitFor(testFn, onReady, timeout) {
    if (timeout == null) {
      timeout = 30000
    }
    var start = new Date()
    var interval = setInterval(function() {
      if (testFn()) {
        clearInterval(interval)
        onReady()
      } else if (new Date() - start > timeout) {
        console.log("timed out.")
        phantom.exit(1)
      }
    }, 100)
  }

  function loadNextSuite() {
    if (!suites.length) {
      phantom.exit()
    } else {
      var url = suites.shift() + "?verbosity=WARN"
      if (!/:\/\//.test(url)) {
        url = prefix + url
      }
      page.open(url, function(status) {
        if (status !== "success") {
          console.log("failed opening " + url)
          return phantom.exit(1)
        }
        waitFor(function() {
          return page.evaluate(function() {
            var res = document.getElementById('results')
            if (res) {
              return /finished/.test(res.className)
            }
          })
        }, function() {
          var passed = page.evaluate(function() {
            var res = document.getElementById('results')
            var paths = location.pathname.split('/')
            console.log((paths[paths.length - 1] + " - ") + res.textContent)
            return /passed/.test(res.className)
          })
          if (passed) {
            loadNextSuite()
          } else {
            phantom.exit(1)
          }
        })
      })
    }
  }

  loadNextSuite()

}).call(this)


================================================
FILE: test/selector.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Selector unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script src="../src/zepto.js"></script>
  <script src="../src/selector.js"></script>
  <script src="../src/ie.js"></script>
</head>
<body>
  <h1>Zepto Selector unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">
    <ul id=list><li>one</li><li>two</li></ul>
    <div class=visibility id=vis>look at me!</div>
    <div class=visibility id=invis style="display:none">can't see me</div>
    <ol id=child class=test>
      <li><span>child1</span></li>
      <li><span>child2</span>
        <ul>
          <li><span>child3</span></li>
          <li><span>child4</span></li>
        </ul>
      </li>
    </ol>
  </div><!-- fixtures -->

  <script>
  (function(){
    Evidence('SelectorTest', {
      testFirst: function(t) {
        var li = $('#list li:first')
        t.assertEqual(1, li.size())
        t.assertEqual('one', li.text())
        t.assertEqual('two', $('#list li:eq(1)').text())
      },
      testLast: function(t) {
        var li = $('#list li:last')
        t.assertEqual(1, li.size())
        t.assertEqual('two', li.text())
      },
      testParent: function(t) {
        var list = $('#list li:parent')
        t.assertEqual(1, list.size())
        t.assertEqual('list', list.attr('id'))
      },
      testContains: function(t) {
        t.assertEqual('two', $('#list li:contains("two")').text())
      },
      testVisibility: function(t) {
        t.assertEqual('vis', $('.visibility:visible').attr('id'))
        t.assertEqual('invis', $('.visibility:hidden').attr('id'))
      },
      testIs: function(t) {
        t.assert($('#list').is('ul'))
        t.assert($('#vis').is(':visible'))
        t.refute($('#invis').is(':visible'))
      },
      testChild: function(t) {
        var items = $('#child').find('> li'),
            results = items.map(function(){
              return $(this).find('> span').text()
            }).get()

        t.assertEqual('child1 child2', results.join(' '))
        t.assertEqual('test', $('#child').prop('class'))
      },
      testChildHas: function(t) {
        var items = $('#child').find('> li:has(ul)'),
            results = items.map(function(){
              return $(this).find('> span').text()
            }).get()

        t.assertEqual('child2', results.join(' '))
      },
      testEmptyHref: function(t) {
        var result, el = $('<div><a href="#">one</a><a href="#">two</a></div>')
        result = el.find('a[href=#]')
        t.assertEqual('one two', result.map(function(){ return $(this).text() }).get().join(' '))
      }
    })
  })()
  </script>
</body>
</html>


================================================
FILE: test/server.coffee
================================================
express = require 'express'
app     = express()
path    = require 'path'

module.exports = app

project_root = path.resolve(__dirname, '..')
app.use express.static(project_root)
app.use express.static(project_root + 'node_modules/mocha')
app.use express.static(project_root + 'node_modules/chai')

app.use express.bodyParser()

mime = (req) ->
  type = req.headers['content-type'] or ''
  type.split(';')[0]

dump = (obj) ->
  obj = '' unless obj
  obj = JSON.stringify(obj) if obj and typeof obj isnt "string"
  obj

cleanTrace = (traceStr) ->
  trace = traceStr.split("\n")
  filtered = []
  for line in trace
    if /\.html:/.test line
      line = line.replace(/^.+?@/, '')
      line = line.replace(/http:\/\/.+?\//, '')
      line = line.replace(/(:\d+):\d+$/, '$1')
      filtered.push line
  filtered

browser = (ua) ->
  if m = ua.match /(Android .+?);/
    m[1]
  else if m = ua.match /(iPhone|iPad|iPod).*?OS ([\d_]+)/
    'iOS ' + m[2].replace(/_/g, '.')
  else if m = ua.match /(Chrome\/[\d.]+)/
    m[1].replace '/', ' '
  else if m = ua.match /(Safari\/[\d.]+)/
    m[1].replace '/', ' '
  else if m = ua.match /(Firefox\/[\d.]+)/
    m[1].replace '/', ' '
  else if m = ua.match /\bMS(IE [\d.]+)/
    m[1]
  else
    ua

app.all '/', (req, res) ->
  res.redirect '/test'

app.all '/test/echo=?', (req, res) ->
  res.set 'Cache-Control', 'no-cache'
  res.send """
           #{req.method} ?#{dump(req.query)}
           content-type: #{mime(req)}
           accept: #{req.headers['accept']}
           #{dump(req.body)}
           """

app.get '/test/jsonp', (req, res) ->
  res.jsonp
    query: req.query
    hello: 'world'

# send JSONP response despite callback not being set
app.get '/test/jsonpBlah', (req, res) ->
  res.set 'Content-Type', 'text/javascript'
  res.send 'blah()'

app.get '/test/json', (req, res) ->
  res.set 'Cache-Control', 'no-cache'
  expectedType = req.headers['accept']
  if expectedType is '*/*' or /json/.test expectedType
    if req.query.invalid
      res.set 'Content-Type', 'application/json'
      res.send 'invalidJSON'
    else
      res.json
        query: req.query
        hello: 'world'
  else
    res.send 400, 'FAIL'

app.get '/test/taintedJSON', (req, res) ->
  res.set 'Content-Type', 'application/json'
  res.send 'while(1);{"hello" : "world"}'

app.post '/test/create', (req, res) ->
  res.json
    action: 'created'
    query: req.query
    payload: req.body

app.all '/test/slow', (req, res) ->
  setTimeout ->
    res.jsonp result: 'ok'
  , 200

app.get '/test/cached', (req, res) ->
  res.set 'Cache-Control', 'max-age=2'
  res.set 'Expires', new Date(Date.now() + 2000).toUTCString()
  now = new Date()
  res.send now.getTime().toString()

app.get '/test/auth', (req, res) ->
  if req.headers.authorization is 'Basic emVwdG86ZG9nZQ=='
    res.send 200
  else
    res.set 'WWW-Authenticate', "Basic realm=\"#{req.query.realm}\""
    res.send 401

app.post '/test/log', (req, res) ->
  params = req.body
  trace = cleanTrace params.trace
  console.log "[%s] %s: %s", browser(req.headers['user-agent']), params.name, params.message
  console.log trace.join("\n").replace(/^/mg, '  ') if trace.length
  res.send 200

app.all '/test/error', (req, res) ->
  res.send 500, 'BOOM'

if process.argv[1] is __filename
  port = process.argv[2]
  unless port
    port = 3000
    console.log "Listening on port #{port}"
  app.listen port


================================================
FILE: test/stack.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Stack unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto stack ie')
    })()
  </script>
</head>
<body>
  <h1>Zepto Stack unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">

  <div id="end_test">
    <div class="end_one"><b><span></span></b></div>
    <div class="end_two"><b><span>1</span><span>2</span></b></div>
  </div>

  <div id="andself_test">
    <div class="one"></div>
    <div class="two"></div>
    <div class="three"></div>
    <div class="four"></div>
  </div>

  </div><!-- fixtures -->

  <script>
  (function(){

    Evidence('ZeptoTest', {

      testEnd: function (t) {
        t.assert($().end().length == 0)

        var $endTest = $('#end_test')
        var $endTest2 = $('#end_test').find('div').find('span').end().end()
        t.assertEqual($endTest.length, $endTest2.length)
        t.assertEqual($endTest.get(0), $endTest2.get(0))
      },

      testAndSelf: function (t) {
        var testDiv  = $('#andself_test'),
            secondEl = $('.two', testDiv),
            thirdEl  = $('.three', testDiv),
            nextAndSelf = secondEl.next().andSelf()

        t.assert(secondEl.get(0), nextAndSelf.get(0))
        t.assert(thirdEl.get(0),  nextAndSelf.get(1))
      }

    })

  })()
  </script>
</body>
</html>


================================================
FILE: test/test.css
================================================
* {
  font-family: -apple-system-font, Helvetica, sans-serif;
}
body {
  padding: 1em;
}
a:link, a:visited { color: darkblue; }
#results.failed em { font-style: normal; color: crimson; }
#results.passed em { font-style: normal; color: darkgreen; }
#fixtures {
  position: absolute;
  top: -10000px;
  left: -10000px;
}
#nav {
  list-style: none;
  padding: 0;
  margin: 2em 0 0 0;
  font-size: 12px;
  max-width: 30em;
}
#nav a {
  padding: .8em 1.5em;
  background: #eee;
  border-top: 2px solid white;
  text-decoration: none;
  text-transform: uppercase;
  letter-spacing: .1em;
  display: block;
  color: #555;
}
#nav .current a { background: #ccc; color: black; }
#nav a:active { background: #555; color: white; }

ul {
  padding: 0;
}

li {
  list-style-type: none;
  padding: 0 0 15px;
}

li a {
  font-size: 16px;
  border: 1px solid darkblue;
  padding: 3px 10px;
  text-decoration: none;
}
li a:visited {
  border-color: #888;
  color: #aaa;
}

@media only screen and (max-device-width:480px) {
  body { margin: 7px; font-size: small; }
  h1 { margin: 0; }
  h1, #results { text-align: center; }
  #results { min-height: 3em; }
  #nav { font-size: 14px; max-width: auto; }
}


================================================
FILE: test/touch.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Touch unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event ie touch')
    })()
  </script>
</head>
<body>
  <h1>Zepto Touch unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>

  <style>
    #test {
      position: absolute;
      left: 0;
      top: 0;
      width: 100px;
      height: 50px;
    }
  </style>

  <script>
  (function(){
    var emitEvent, tests, lastLoaded

    // Fire a simulated touch event.
    // While it is possible to fire real touch events,
    // there are cross-browser issues, and this way we
    // can test touch events in browsers that don't
    // actually support touch input (like desktop Safari).
    //
    // Zepto's touch module only uses the `pageX/Y` and `target`
    // properties of the first touch in the `touches` TouchList
    function emitTouchEvent(type, element, x, y) {
      var event = document.createEvent('Event'),
        touch = { pageX: x, pageY: y, target: element }

      event.initEvent('touch'+type, true, true)
      event.touches = [touch]

      element.dispatchEvent(event)
    }

    // IE 10, Windows Phone 8
    // MSPointer events, same idea, different implementation.
    // For compatibility accepts the same arguments as `touchEvent`
    // (touch event names will be mapped to MSPointer event names)
    function emitMSPointerEvent(type, element, x, y) {
      var event = document.createEvent('Event'),
        eventMap = { start: 'Down', move: 'Move', end: 'Up'}

      event.initEvent('MSPointer'+eventMap[type], true, true)
      event.pageX = x
      event.pageY = y
      event.pointerType = 666
      event.MSPOINTER_TYPE_TOUCH = 666
      event.isPrimary = true

      element.dispatchEvent(event)
    }

    // IE 11
    // Pointer events, same idea again, yet different implementation.
    // For compatibility accepts the same arguments as `touchEvent`
    // (touch event names will be mapped to pointer event names)
    function emitPointerEvent(type, element, x, y) {
      var event = document.createEvent('Event'),
        eventMap = { start: 'down', move: 'move', end: 'up'}

      event.initEvent('pointer'+eventMap[type], true, true)
      event.pageX = x
      event.pageY = y
      event.pointerType = 'touch'
      event.isPrimary = true

      element.dispatchEvent(event)
    }

    function down(element, x, y) {
      emitEvent('start', element, x, y)
    }
    function move(element, x,y) {
      emitEvent('move', element, x, y)
    }
    function up(element) {
      emitEvent('end', element)
    }

    tests = {
      setUp: function(){
        emitEvent = this.emitEvent
        this.setupTouchLibrary()
        $('<div id=test>').appendTo('body')
      },

      tearDown: function(){
        $('#test').off()
        $('#test').remove()
      },

      testTap: function(t){
        var count = 0, element = $('#test').get(0)

        $('#test').on('tap', function(){
          count++
        })

        down(element, 10, 10)
        up(element)

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            t.assertEqual(1, count)
          })
        }, 50)
      },

      testOnlyOneTouchAPIIsActive: function(t){
        var count = 0, element = $('#test').get(0)

        $('#test').on('tap', function(){
          count++
        })

        emitTouchEvent('start', element, 10, 10)
        emitPointerEvent('start', element, 10, 10)
        emitMSPointerEvent('start', element, 10, 10)
        emitTouchEvent('end', element)
        emitPointerEvent('end', element)
        emitMSPointerEvent('end', element)

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            t.assertEqual(1, count)
          })
        }, 50)
      },

      testScrollDoesNotFireTap: function(t){
        var element = $('#test').get(0), count = 0

        $('#test').on('tap', function () {
          count++
        })

        down(element, 0, 0)
        move(element, 0, 20)
        move(element, 0, 20)
        up(element)

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            t.assertEqual(0, count)
          })
        }, 50)
      },

      testSingleTapDoesNotInterfereWithTappingTwice: function(t){
        var count = 0, element = $('#test').get(0)

        $('#test').on('tap', function(){
          count++
        })

        down(element, 10, 10)
        up(element)

        t.pause()
        setTimeout(function(){
          down(element, 10, 10)
          up(element)

          t.resume(function(){
            t.pause()

            setTimeout(function(){
              t.resume(function(){
                t.assertEqual(2, count)
              })
            }, 200)
          })
        }, 200)
      },

      // should be fired if there is one tap within 250ms
      testSingleTap: function(t){
        var singleCount = 0, doubleCount = 0, element = $('#test').get(0)

        $('#test').on('singleTap', function(){
          singleCount++
        }).on('doubleTap', function(){
          doubleCount++
        })

        down(element, 10, 10)
        up(element)

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            t.assertEqual(1, singleCount)
            t.assertEqual(0, doubleCount)
          })
        }, 300)
      },

      // should be fired if there are two taps within 250ms
      testDoubleTap: function(t){
        var singleCount = 0, doubleCount = 0, element = $('#test').get(0)

        $('#test').on('singleTap', function(){
          singleCount++
        }).on('doubleTap', function(){
          doubleCount++
        })

        down(element, 10, 10)
        up(element)

        t.pause()
        setTimeout(function(){
          down(element, 12, 12)
          up(element)

          t.resume(function(){
            t.pause()

            setTimeout(function(){
              t.resume(function(){
                t.assertEqual(0, singleCount)
                t.assertEqual(1, doubleCount)
              })
            }, 100)
          })
        }, 100)
      },

      // should be fired if the finger is down in the same location for >750ms
      testLongTap: function(t){
        var count = 0, element = $('#test').get(0)

        $('#test').on('longTap', function(){
          count++
        })

        down(element, 10, 10)

        t.pause()
        setTimeout(function(){
          up(element)

          t.resume(function(){
            t.assertEqual(1, count)
          })
        }, 900)
      },

      testLongTapDoesNotFireIfFingerIsMoved: function(t){
        var count = 0, element = $('#test').get(0)

        $('#test').on('longTap', function(){
          count++
        })

        down(element, 10, 10)

        t.pause()
        setTimeout(function(){
          move(element, 50, 10)
          t.resume(function(){
            t.pause()
            setTimeout(function(){
              up(element)
              t.resume(function(){
                t.assertEqual(0, count)
              })
            }, 450)
          })
        }, 450)
      },

      testSwipe: function(t){
        var swipeCount = 0, element = $('#test').get(0)

        $('#test').on('swipe', function(){
          swipeCount++
        })

        down(element, 10, 10)

        t.pause()
        setTimeout(function(){
          move(element, 70, 10)
          up(element)

          t.resume(function(){
            t.pause()

            setTimeout(function(){
              t.resume(function(){
                t.assertEqual(1, swipeCount)
              })
            }, 50)
          })
        }, 50)
      },

      testTapDoNotFireWhenMoveToPointAndBack: function (t) {
        var tapCount = 0, element = $('#test').get(0)

        $('#test').on('tap', function(){
          tapCount++
        })
        down(element, 10, 10)
        move(element, 60, 10)

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            move(element, 10, 10)
            up(element)
            t.pause()
            setTimeout(function(){
              t.resume( function () {
                t.assertEqual(0, tapCount)
              })
            }, 100)
          })
        }, 100)
      }

      // TODO: test swipes in specific directions
    }

    Evidence('TouchTest', $.extend({
      setupTouchLibrary: function(){
        console.info('Setting up touch library for TouchEvent test')
        $.touch.setup({
          'down': 'touchstart', 'up': 'touchend',
          'move': 'touchmove', 'cancel': 'touchcancel'
        })
      },
      emitEvent: emitTouchEvent
    }, tests))

    Evidence('PointerTest', $.extend({
      setupTouchLibrary: function(){
        console.info('Setting up touch library for PointerEvent test')
        $.touch.setup({
          'down': 'pointerdown', 'up': 'pointerup',
          'move': 'pointermove', 'cancel': 'pointercancel'
        })
      },
      emitEvent: emitPointerEvent
    }, tests))

    Evidence('MSPointerTest', $.extend({
      setupTouchLibrary: function(){
        console.info('Setting up touch library for MSPointerEvent test')
        $.touch.setup({
          'down': 'MSPointerDown', 'up': 'MSPointerUp',
          'move': 'MSPointerMove', 'cancel': 'MSPointerCancel'
        })
      },
      emitEvent: emitMSPointerEvent
    }, tests))

  })()
  </script>
</body>
</html>


================================================
FILE: test/zepto.html
================================================
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  <link rel="stylesheet" href="test.css">
  <title>Zepto Core unit tests</title>
  <script src="../vendor/evidence.js"></script>
  <script src="evidence_runner.js"></script>
  <script>
    // avoid caching
    (function(){
      function load(scripts){
        scripts.split(' ').forEach(function(script){
          document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
        })
      }

      load('zepto event ie')
    })()
  </script>
  <style>
    #get_style_element {
      font-size: 48px;
      color: black;
    }
  </style>
</head>
<body>
  <h1>Zepto Core unit tests</h1>
  <p id="results">
    Running… see browser console for results
  </p>
  <div id="fixtures">

  <div id="some_element"></div>
  <p>
    <span class="yay">yay</span>
    <span></span>
    <span class="nay" id="nay">nay</span>
  </p>

  <div id="toggle_element"></div>

  <div id="get_style_wrapper" style="font-size: 16px;">
    <div id="get_style_element">Derp</div>
  </div>

  <div class="replacewith">
    <div class="inner first">Hello</div>
    <div class="inner second">And</div>
    <div class="inner third">Goodbye</div>
  </div>

  <div id="attr_1" data-id="someId1" data-name="someName1"></div>
  <div id="attr_2" data-id="someId2" data-name="someName2"></div>
  <div id="attr_remove" data-name="boom"></div>
  <div id="attr_remove_multi" data-id="someId1" data-name="someName1"></div>
  <form><input id="attr_val" value="Hello World"></form>

  <div id="data_attr" data-foo="bar" data-foo-bar="baz" data-empty></div>

  <form id="attr_with_text_input">
  </form>

  <label for="prop_test2" id="prop_test1"></label>
  <input id="prop_test2" type="text" tabindex="-1" maxlength="10" readonly class="propTest" />
  <table id="prop_test3" cellspacing="10" cellpadding="5">
    <tr>
      <td id="prop_test4" rowspan="2"></td>
      <td></td>
    </tr>
    <tr>
      <td></td>
    </tr>
    <tr>
      <td id="prop_test5" colspan="2"></td>
    </tr>
  </table>
  <img id="prop_test6" usemap="#imgMap" />
  <map name="imgMap">
  </map>
  <div id="prop_test7" contenteditable="true"></div>
  <input id="prop_test8" type="checkbox" checked />

  <div class="htmltest" id="htmltest1"></div>
  <div class="htmltest" id="htmltest2"></div>
  <div id="htmltest3"></div>
  <table id="htmltest4"></table>

  <div id="texttest1" class="texttest"><span>Here <strong>is</strong> some text</span></div>
  <div id="texttest2" class="texttest">And <em>some more</em></div>
  <div id="texttest3" class="texttest"></div>

  <div id="beforeafter_container"><div id="beforeafter"></div></div>
  <div id="appendtoprependto_container"><div id="appendtoprependto"></div></div>
  <div id="insertbeforeinsertafter_container"><div id="insertbeforeinsertafter"></div></div>

  <div id="empty_test">
    <div id="empty_1"></div>
    <div id="empty_2"></div>
    <div id="empty_3"></div>
    <span id="empty_4">test</span>
  </div>

  <p id="find1">
    <span class="findme">1</span>
    <span class="findme">2</span>
    <b>3<span class="findme">4</span></b>
    <span class="findme">5<span>6</span></span>
  </p>

  <p id="find2">
    <span>1</span>
    <span>2</span>
    <span>3<span>4</span></span>
    <span>5<span>6</span></span>
  </p>

  <div id="eachtest">
    <span></span><b></b><br>
  </div>

  <div style="position:absolute;width:100px;height:50px" id="offset">test</div>

  <ul id="parents">
    <li id="li1">
      <ul id="nested">
        <li id="li2">one</li>
        <li>two</li>
        <li>three</li>
      </ul>
      <ul>
        <li></li>
      </ul>
    </li>
  </ul>

  <ul id="childrenTest">
    <li class="child one"><a class="childOfOne" href="#">gchild1</a></li>
    <li class="child two"><a class="childOfTwo" href="#">gchild2</a></li>
    <li class="child three"><a class="childOfThree" href="#">gchild3</a></li>
    <li class="child four"><a class="childOfFour" href="#">gchild4</a></li>
  </ul>

  <ul id="contentsTest">1<span>2</span><span id="contentsEmptyTest"></span></ul>

  <iframe id="contentsIframeTest" src="fixtures/iframe_document.html"></iframe>

  <ul id="siblingsTest">
    <li class="child one"><span class="b"></span><em></em><b></b></li>
    <li class="child two"><span class="c"></span><em></em><b></b></li>
    <li class="child three"><span class="d"></span><em></em><b></b></li>
    <li class="child four"><span class="e"></span></li>
  </ul>

  <ul id="notTest">
    <li class="child one"><span class="b"></span></li>
    <li class="child two"><span class="c"></span></li>
    <li class="child three"><span class="d" id="notTestExclude"></span></li>
    <li class="child four"><span class="e"></span></li>
  </ul>

  <div id="addTest">
    <span class="add_span"></span>
    <span class="add_span"></span>
    <span class="add_span"></span>
    <span class="add_span_exclude"></span>
    <div id="addTestDiv"></div>
  </div>

  <style>
    .hidden {
      display: none;
    }

    #show_hide_span1,
    #show_hide_span2 {
      display: block;
    }

    #show_hide_div1 {
      display: inline-block;
    }
  </style>

  <div id="show_hide_div1" style="display:none"></div>
  <div id="show_hide_div2" class="hidden"></div>
  <div id="show_hide_div3"></div>

  <span id="show_hide_span1" style="display:none"></span>
  <span id="show_hide_span2" class="hidden"></span>
  <span id="show_hide_span3"></span>

  <div class="filtertest" id="filtertest1"></div>
  <div class="filtertest" id="filtertest2"></div>

  <div id="delegate_test"><span class="first-level"><span class="second-level">hi</span></span></div>
  <div id="undelegate_test"><span class="first-level"><span class="second-level">hi</span></span></div>

  <div id="delegate_blur_test"><input type="text"></div>
  <div id="delegate_focus_test"><input type="text"></div>

  <div id="another_element"></div>

  <div id="namespace_test"></div>

  <input type="text" id="BooleanInput" required />

  <form id="some_form"></form>

  <div class="replace_test_div">test</div>

  <div id="wrap_test"><span>hi</span><a></a><span>hello</span></div>

  <div id="wrapall_test"><b></b><span>hi</span><span>hello</span><i></i></div>

  <div id="wrapinner_test">1<span>2</span><span id="wrapinner_empty_test"></span></div>

  <div id="unwrap_test">
    <div class="unwrap_one"><b><span></span></b></div>
    <div class="unwrap_two"><b><span>1</span><span>2</span></b></div>
  </div>

  <div id="slice_test">
    <div class="slice1"></div>
    <div class="slice2"></div>
    <div class="slice3"></div>
  </div>

  <div id="eq_test">
    <div class="eq0"></div>
    <div class="eq1"></div>
    <div class="eq2"></div>
  </div>

  <div id="end_test">
    <div class="end_one"><b><span></span></b></div>
    <div class="end_two"><b><span>1</span><span>2</span></b></div>
  </div>

  <div id="andself_test">
    <div class="one"></div>
    <div class="two"></div>
    <div class="three"></div>
    <div class="four"></div>
  </div>

  <div id="index_test">
    <div class="index0"></div>
    <div class="index1"></div>
  </div>

  <div id="trigger_handler">
    <form method="get">
    </form>
  </div>

  <svg></svg>

  <iframe src="fixtures/iframe_document.html"></iframe>

  <iframe id="link_target_iframe" name="link_target_iframe" width="10" height="10"></iframe>
  <a id="link_that_will_be_prevented" href="fixtures/iframe_document.html" target="link_target_iframe"></a>

  <div id="test_dollar_with_shadow_root" style="display:none;"></div>

  </div><!-- fixtures -->

  <script>
  (function(){

    function click(el){
      var event = document.createEvent('MouseEvents')
      event.initMouseEvent('click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null)
      el.dispatchEvent(event)
    }

    function mousedown(el){
      var event = document.createEvent('MouseEvents')
      event.initMouseEvent('mousedown', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null)
      el.dispatchEvent(event)
    }

    function outerHTML(node) {
      return node.outerHTML || (function(n) {
        var div = document.createElement('div')
        div.appendChild(n.cloneNode(true))
        var html = div.innerHTML
        div = null
        return html
      })(node)
    }

    function testDocumentFragmentOrShadowRootContext($fragment, t) {
      t.assertLength(1, $fragment)
      t.assertEqual(Node.DOCUMENT_FRAGMENT_NODE, $fragment.get(0).nodeType)

      var fragment = $fragment[0]
      var $div = $('<div id="child"><div class="inner"></div></div>')

      t.assertLength(0, $('#child', fragment))

      fragment.appendChild($div[0])

      var expectedElement = fragment.querySelector('#child')

      t.assertLength(1, $('#child', fragment))
      t.assertEqual($div[0], $('#child', fragment).get(0))
      t.assertEqual(expectedElement, $('#child', fragment).get(0))

      expectedElement = fragment.querySelector('.inner')

      t.assertLength(1, $('.inner', fragment))
      t.assertEqual(expectedElement, $('.inner', fragment).get(0))

      var expectedElements = fragment.querySelectorAll('div')

      t.assertLength(2, $('div', fragment))
      t.assertEqual(expectedElements[0], $('div', fragment).get(0))
      t.assertEqual(expectedElements[1], $('div', fragment).get(1))
    }

    var globalVarSetFromReady = ""
    $(document).ready(function(){ globalVarSetFromReady = 'hi!' })

    var globalVarSetFromReady2 = ""
    $(function(){ globalVarSetFromReady2 = 'hi!' })

    var globalVarSetFromReady3 = ""
    $(document).on('ready', function(){ globalVarSetFromReady3 = 'hi!' })

    var globalVarSetFromReady4 = ""
    $(document).on('foo ready bar', function(){ globalVarSetFromReady4 = 'hi!' })

    Evidence.Assertions.assertSame = function(expected, actual, message) {
      var expectedKeyCount = 0, actualKeyCount = 0, key, passed = true
      for (key in expected) expectedKeyCount++
      for (key in actual) actualKeyCount++

      if (expectedKeyCount == actualKeyCount)
        for (key in expected)
          passed &= expected[key] == actual[key]
      else
        passed = false

      this._assertExpression(passed, message || 'Failed assertion.',
        'Expected %o to be the same as %o.', actual, expected)
    }

    Evidence.Assertions.assertLength = function(expected, object, message) {
      var actual = object.length
      this._assertExpression(expected === actual, message || 'Failed assertion.',
        'Expected length %d, got %d.', expected, actual)
    }

    Evidence.Assertions.assertZeptoCollection = function(expectedLength, object, message) {
      if (!$.zepto.isZ(object))
        this._assertExpression(false, message || 'Failed assertion.',
          'Expected %o to be a Zepto collection.', object)
      else
        this.assertLength(expectedLength, object, message)
    }

    Evidence.Assertions.assertEqualCollection = function(expectedCollection, actualCollection, message) {
      var expected = expectedCollection, actual = actualCollection,
          passed = expected.length == actual.length

      if (typeof expected.get == 'function') expected = expected.get()
      if (typeof actual.get == 'function') actual = actual.get()

      if (passed) for (var i=0; i<expected.length; i++) passed &= expected[i] == actual[i]

      this._assertExpression(passed, message || 'Failed assertion.',
        'Expected %o, got %o.', expected, actual)
    }

    Evidence('ZeptoTest', {

      testIsFunction: function(t) {
        t.assertTrue($.isFunction(function(){}))
        t.assertTrue($.isFunction(new Function()))

        var f1 = function(){}
        function f2(){}

        t.assertTrue($.isFunction(f1))
        t.assertTrue($.isFunction(f2))

        t.assertFalse($.isFunction())
        t.assertFalse($.isFunction(undefined))
        t.assertFalse($.isFunction({}))
        t.assertFalse($.isFunction(new Object()))
        t.assertFalse($.isFunction(null))
        t.assertFalse($.isFunction([]))
        t.assertFalse($.isFunction(1))
        t.assertFalse($.isFunction('a'))
        t.assertFalse($.isFunction(new Date()))
        t.assertFalse($.isFunction(window))
        t.assertFalse($.isFunction($('body')))
      },

      testIsPlainObject: function(t) {
        t.assertTrue($.isPlainObject(new Object()), 'Object is plain object')
        t.assertTrue($.isPlainObject({}), '{} is plain object')
        t.assertTrue($.isPlainObject({one : 1}), '{one : 1} is plain object')
        t.assertTrue($.isPlainObject({one : 1, two: [1,2]}), '{one : 1, two: [1,2]} is plain object')

        t.assertFalse($.isPlainObject(new Array()), 'Array object is not plain object')
        t.assertFalse($.isPlainObject([]), '[] is not plain object')
        t.assertFalse($.isPlainObject(null), 'null is not plain object')
        t.assertFalse($.isPlainObject(), 'undefined is not plain object')
        t.assertFalse($.isPlainObject(new String()), 'empty String object is not plain object')
        t.assertFalse($.isPlainObject(new String('moe')), 'String object is not plain object')
        t.assertFalse($.isPlainObject(''), 'the empty string is not plain object')
        t.assertFalse($.isPlainObject('moe'), 'a string is not plain object')
        t.assertFalse($.isPlainObject(new RegExp('test')), 'RegExp object is not plain object')
        t.assertFalse($.isPlainObject(/test/), 'regex is not plain object')
        t.assertFalse($.isPlainObject(new Boolean(true)), 'Boolean object is not plain object')
        t.assertFalse($.isPlainObject(true), 'a boolean is not plain object')
        t.assertFalse($.isPlainObject(new Number(2)), 'Number object is not plain object')
        t.assertFalse($.isPlainObject(2), 'a number is not plain object')
        t.assertFalse($.isPlainObject(new Function()), 'Function object is not plain object')
        t.assertFalse($.isPlainObject(function() {}), 'a function is not plain object')
        t.assertFalse($.isPlainObject(new Date()), 'Date object is not plain object')

        t.assertFalse($.isPlainObject(window), 'window is not a plain object')
        t.assertFalse($.isPlainObject($("html")[0]), 'html node is not a plain object')

        var F = function(){}, obj
        F.prototype = {'a':1}
        obj = new F()
        t.assertFalse($.isPlainObject(obj), 'function with prototype is not a plain object')
      },

      testIsWindow: function(t){
        t.assertFalse($.isWindow())
        t.assertFalse($.isWindow({}))
        t.assertFalse($.isWindow(document.body))
        t.assertTrue($.isWindow(window))
        t.assertTrue($.isWindow($('iframe').get(0).contentWindow))
      },

      testDollarIsNumeric: function(t){
        t.assertTrue($.isNumeric( '-10' ))
        t.assertTrue($.isNumeric( '0' ))
        t.assertTrue($.isNumeric( 0xFF ))
        t.assertTrue($.isNumeric( '0xFF' ))
        t.assertTrue($.isNumeric( '8e5' ))
        t.assertTrue($.isNumeric( '3.1415' ))
        t.assertTrue($.isNumeric( +10 ))
        t.assertTrue($.isNumeric( 0144 ))

        t.assertFalse($.isNumeric( '-0x42' ), '-0x42')
        t.assertFalse($.isNumeric( '7.2acdgs' ), '7.2acdgs')
        t.assertFalse($.isNumeric( '' ), 'empty string')
        t.assertFalse($.isNumeric( {} ), 'empty hash')
        t.assertFalse($.isNumeric( NaN ), 'NaN')
        t.assertFalse($.isNumeric( null ), 'null')
        t.assertFalse($.isNumeric( true ), 'true')
        t.assertFalse($.isNumeric( Infinity ), 'Infinity')
        t.assertFalse($.isNumeric( undefined ), 'undefined')
      },

      // test to see if we augment iOS 3.2 with String#trim()
      testTrim: function(t){
        t.assertEqual("blah", " blah ".trim())
        t.assertIdentical("", $.trim(undefined))
        t.assertIdentical("", $.trim(null))
        t.assertIdentical("", $.trim(""))
        t.assertIdentical("0", $.trim(0))
      },

      testCamelCase: function(t){
        t.assertEqual("hello", $.camelCase("hello"))
        t.assertEqual("HELLO", $.camelCase("HELLO"))
        t.assertEqual("helloNiceWorld", $.camelCase("hello-nice-world"))
        t.assertEqual("helloWorld", $.camelCase("helloWorld"))
      },

      testExtend: function(t){
        t.assertSame({}, $.extend({}))
        t.assertSame(
          {a: "b", c: "d", e: "f"},
          $.extend({a: "1", e: "f"}, {a: "b", c: "d"})
        )
        var obj = {}
        t.assertIdentical(obj, $.extend(obj, {a: 1}))
        t.assertEqual(1, obj.a)

        obj = {}
        t.assertIdentical(obj, $.extend(obj, {a: 1}, {b: 2}))
        t.assertEqual(2, obj.b)

        // undefined values are not copied over
        t.assertSame({a:1}, $.extend({a:1}, {b:undefined}))

        // shallow by default
        obj = $.extend({ a:{b:"c"} }, { a:{d:"e"} })
        t.assertSame({d:"e"}, obj.a)
      },

      testExtendDeep: function(t){
        var obj = { a:{b:"c", x:{y:"z"}} }
        $.extend(true, obj, { a:{d:"e"} }, { a:{b:"B", f:"g", x:{q:"x"}} })

        t.assertEqual('a', Object.keys(obj).join(','))
        t.assertEqual('b,d,f,x', Object.keys(obj.a).sort().join(','))
        t.assertEqual('B', obj.a.b)
        t.assertEqual('e', obj.a.d)
        t.assertEqual('g', obj.a.f)
        t.assertEqual('z', obj.a.x.y)
        t.assertEqual('x', obj.a.x.q)

        // creates non-existing keys on target object
        obj = {}
        $.extend(true, obj, { a:{b:"c"} })
        t.assertEqual('a', Object.keys(obj).join(','))
        t.assertEqual('c', obj.a.b)

        // skips iterating over DOM elements
        obj = {}
        var dom = $('#some_element').get(0)
        $.extend(true, obj, { element: dom })
        t.assertIdentical(dom, obj.element)

        // can override DOM element
        $.extend(true, obj, { element:{a:'b'} })
        t.assertEqual('b', obj.element.a)

        // deep copy with array
        obj = {}
        var initial = { array: [1,2,3,4], object:{a:{b:["c","d"]}} }
        $.extend(true, obj, initial)
        t.assertTrue($.isArray(obj.array))
        t.assertEqual(JSON.stringify(obj), JSON.stringify(initial))
        t.refuteIdentical(obj, initial)
        t.refuteIdentical(obj.array, initial.array)
        t.refuteIdentical(obj.object, initial.object)
        t.refuteIdentical(obj.object.a, initial.object.a)
        t.refuteIdentical(obj.object.a.b, initial.object.a.b)
      },

      testExtensionAPI: function(t) {
        t.assert('init' in $.zepto)
        t.assert('fragment' in $.zepto)
        t.assert('Z' in $.zepto)
        t.assert('isZ' in $.zepto)

        // redefine Z and log some debug information
        var oldZ = $.zepto.Z, calls = []
        $.zepto.Z = function Z(dom, selector) {
          var value = oldZ(dom, selector)
          calls.push(dom)
          return value
        }

        // now select some stuff
        var Z1 = $(''), Z2 = $('#find1 .findme')

        // check if $.fn methods are still there
        t.assert('pluck' in Z1)
        t.assert('width' in Z2)

        // two calls should be logged
        t.assertLength(2, calls)

        // restore old Z
        $.zepto.Z = oldZ
        var Z3 = $('')
        t.assertLength(2, calls)

        t.assertFalse($.zepto.isZ())
        t.assertFalse($.zepto.isZ([]))
        t.assertTrue($.zepto.isZ($('body')))
      },

      testDollar: function(t){
        var expectedElement = document.getElementById('some_element')

        t.assertLength(1, $('#some_element'))
        t.assertEqual(expectedElement, $('#some_element').get(0))
        t.assertEqual(expectedElement, $(expectedElement).get(0))

        t.assertLength(4, $('p'))
        t.assertLength(1, $('p > span.yay'))
      },

      testDollarUnique: function(t){
        t.refuteIdentical($('#some_element'), $('#some_element'))
        t.refuteIdentical($('#nonexistent'), $('#nonexistent'))
      },

      testDollarWithNil: function(t){
        t.assertZeptoCollection(0, $(null))
        t.assertZeptoCollection(0, $(undefined))
        t.assertZeptoCollection(0, $(false))
        t.assertZeptoCollection(0, $(''))
        t.assertZeptoCollection(0, $('#'))

        var Z1 = $(null), Z2 = $(null)
        t.assert(Z1 !== Z2)
      },

      testDollarWithNonDOM: function(t){
        var zepto = $(['a', 'b', 'c'])
        t.assertZeptoCollection(3, zepto)
        t.assertEqualCollection(['a', 'b', 'c'], zepto)

        t.assert($({}))
        t.assertTrue($({ a: true })[0].a)

        // Plain objects wrapped by a Zepto collection
        // should still refer to the original object
        // This is required for events on plain objects
        var plainObject = { a: 1 }
        $(plainObject).get(0).a = 2
        t.assertEqual(2, plainObject.a)
        t.assertEqual(2, $(plainObject).get(0).a)
      },

      testGetWithoutIndex: function(t){
        var zepto = $('#find1 .findme')
        var array = zepto.get()
        t.assertFalse(zepto === array)
        t.assertTrue($.isArray(array))
        t.assertTrue(array.pop === ([]).pop)
      },

      testGetWithIndex: function(t){
        var zepto = $('#find1 .findme')
        t.assertEqual(zepto[0], zepto.get(0))
        t.assertEqual(zepto[zepto.length - 1], zepto.get(-1))
        t.assertUndefined(zepto.get(zepto.length))
      },

      testSize: function(t){
        t.assertEqual(4, $('#find1 .findme').size())
      },

      testDollarWithMultipleInstances: function(t){
        var instance1 = $('#some_element'),
            instance2 = $('p')

        t.assertLength(1, instance1)
        t.assertLength(4, instance2)
        t.refuteIdentical(instance1.get(0), instance2.get(0))
      },

      testDollarWithArrays: function(t){
        var element = document.getElementById('some_element')

        var z1 = $([element])
        t.assertLength(1, z1)
        t.assertEqual(element, z1.get(0))

        var z2 = $([element, null, undefined])
        t.assertLength(1, z2)
        t.assertEqual(element, z2.get(0))

        var z3 = $([null, element, null])
        t.assertLength(1, z3)
        t.assertEqual(element, z3.get(0))
      },

      testDollarWithContext: function(t){
        // Zepto object
        var zepto = $('p#find1, #find2')
        t.assertLength(11, $('span', zepto))

        // DOM Element
        var domElement = document.getElementById('find1')
        t.assertLength(4, $('span.findme', domElement))

        // Selector with DOM Element Context
        var domElement = document.getElementById('find1')
        t.assertLength(4, $('span.findme', domElement))

        // DOM Element with DOM Element Context
        t.assertLength(1, $(domElement, domElement))
      },

      testDollarWithDocument: function(t){
        var z = $(document)
        t.assertLength(1, z)
        t.assertEqual('', z.selector)
      },

      testDollarWithAppcache: function(t){
        if ('applicationCache' in window) {
          var z = $(window.applicationCache)
          t.assertLength(1, z)
          t.assertIdentical(window.applicationCache, z.get(0))
          t.assertEqual('', z.selector)
        }
      },

      testDollarWithDocumentFragment: function(t){
        var documentFragment = $(document.createDocumentFragment())
        t.assertLength(1, documentFragment)
        t.assertEqual(Node.DOCUMENT_FRAGMENT_NODE, documentFragment.get(0).nodeType)
      },

      testDollarWithElementInIframe: function(t){
        var iframe = $('#fixtures iframe').get(0),
            iframeWin = iframe.contentWindow,
            iframeDoc = iframe.contentDocument,
            iframeBody = iframeDoc.body,
            iframeEl = $(iframeBody).find('b')

        t.assertIdentical(iframeWin, $(iframeWin).get(0))
        t.assertIdentical(iframeDoc, $(iframeDoc).get(0))
        t.assertIdentical(iframeBody, $(iframeBody).get(0))
        t.assertEqual('B', iframeEl.pluck('tagName').join(','))
        t.assertEqual('Hello from iframe!', iframeEl.text())
      },

      testDollarWithFragment: function(t){
        var fragment = $("<div>")
        t.assertLength(1, fragment)
        t.assertEqual("<div></div>", outerHTML(fragment.get(0)))
        t.assertEqual('', fragment.selector)
        t.assertNull(fragment.get(0).parentNode)

        fragment = $("<div>hello world</div>")
        t.assertLength(1, fragment)
        t.assertEqual("<div>hello world</div>", outerHTML(fragment.get(0)))
        t.assertEqual('', fragment.selector)

        fragment = $("<div>hello</div> <span>world</span>")
        t.assertLength(3, fragment)
        t.assertEqual("<div>hello</div>", outerHTML(fragment.get(0)))
        t.assertEqual(Node.TEXT_NODE, fragment.get(1).nodeType)
        t.assertEqual("<span>world</span>", outerHTML(fragment.get(2)))
        t.assertEqual('', fragment.selector)

        fragment = $("<div>\nhello</div> \n<span>world</span>")
        t.assertLength(3, fragment)
        t.assertEqual("<div>\nhello</div>", outerHTML(fragment.get(0)))
        t.assertEqual(Node.TEXT_NODE, fragment.get(1).nodeType)
        t.assertEqual("<span>world</span>", outerHTML(fragment.get(2)))
        t.assertEqual('', fragment.selector)

        fragment = $("<div /><div />")
        t.assertLength(2, fragment)

        fragment = $("<div>hello</div> ")
        t.assertLength(1, fragment)
      },

      testDollarFragmentAndProperties: function(t){
        var el = $('<p id=hi />', {
          id: 'hello', 'class': 'one two',
          text: 'world', css: {color: 'red'}
        })

        t.assertEqual('hello', el.attr('id'))
        t.assert(el.hasClass('one'))
        t.assert(el.hasClass('two'))
        t.assertEqual('world', el.text())
        t.assertEqual('red', el.css('color'))
      },

      testDollarNonemptyFragmentAndProperties: function(t){
        var zepto = $('<a>Goodbye</a>', { text: "Hello", href: "http://zeptojs.com" })
        t.assertLength(1, zepto)
        t.assertEqual('Hello', zepto.text())
        t.assertEqual('http://zeptojs.com', zepto.attr("href"))
      },

      testDollarWithTextNode: function(t){
        var textNode = $(document.createTextNode('hi there'))
        t.assertLength(1, textNode)
        t.assertEqual(Node.TEXT_NODE, textNode.get(0).nodeType)
      },

      testDollarWithCommentInFragment: function(t){
        var comment = $('<!-- -->')
        t.assertLength(1, comment)
        t.assertEqual(Node.COMMENT_NODE, comment.get(0).nodeType)
      },

      testDollarWithDoctypeInFragment: function(t){
        t.assertZeptoCollection(0, $('<!DOCTYPE html>'))
      },

      testNodeCreationViaDollar: function (t) {
        t.assertEqual('<div></div>', outerHTML($('<div></div>').get(0)))
        t.assertEqual('<div></div>', outerHTML($('<div/>').get(0)))
        t.assertEqual('<div><div></div></div>', outerHTML($('<div><div></div></div>').get(0)))
        t.assertEqual('<div><div></div></div>', outerHTML($('<div><div/></div>').get(0)))
        t.assertEqual('<div><div></div><div></div></div>', outerHTML($('<div><div></div><div></div></div>').get(0)))
      },

      testCreateTableCell: function(t) {
        t.assertEqual('TD', $('<td></td>').pluck('nodeName').join(','))
      },

      testCreateTableHeaderCell: function(t) {
        t.assertEqual('TH', $('<th></th>').pluck('nodeName').join(','))
      },

      testCreateTableRow: function(t) {
        t.assertEqual('TR', $('<tr></tr>').pluck('nodeName').join(','))
      },

      testCreateTableHeader: function(t) {
        t.assertEqual('THEAD', $('<thead></thead>').pluck('nodeName').join(','))
      },

      testCreateTableBody: function(t) {
        t.assertEqual('TBODY', $('<tbody></tbody>').pluck('nodeName').join(','))
      },

      testCreateTableFooter: function(t) {
        t.assertEqual('TFOOT', $('<tfoot></tfoot>').pluck('nodeName').join(','))
      },

      testCreateSelectOptgroup: function(t) {
        t.assertEqual('OPTGROUP', $('<optgroup></optgroup>').pluck('nodeName').join(','))
      },

      testCreateSelectOption: function(t) {
        t.assertEqual('OPTION', $('<option></option>').pluck('nodeName').join(','))
      },

      testReady: function(t){
        t.assertEqual('hi!', globalVarSetFromReady)
        t.assertEqual('hi!', globalVarSetFromReady2)
        t.assertEqual('hi!', globalVarSetFromReady3)
        t.assertEqual('hi!', globalVarSetFromReady4)
      },

      testNext: function(t){
        t.assertEqual('P', $('#some_element').next().get(0).tagName)
        t.assertEqual('DIV', $('p').next().get(0).tagName)

        t.assertEqual(0, $('span.yay').next('.nay').size())
        t.assertEqual(1, $('span.yay').next().size())
        t.assertEqual(1, $('span.yay').next().next('.nay').size())
      },

      testPrev: function(t){
        t.assertEqual('H1', $('p').prev().get(0).tagName)
        t.assertEqual('DIV', $('ul').prev().get(0).tagName)

        t.assertEqual(0, $('span.nay').prev('.yay').size())
        t.assertEqual(1, $('span.nay').prev().size())
        t.assertEqual(1, $('span.nay').prev().prev('.yay').size())
      },

      testEach: function(t){
        var index, tagnames = []
        $('#eachtest > *').each(function(idx, el){
          index = idx
          t.assertIdentical(el, this)
          tagnames.push(el.tagName.toUpperCase())
        })
        t.assertEqual('SPAN, B, BR', tagnames.join(', '))
        t.assertEqual(2, index)
      },

      testEachBreak: function(t){
        var index, tagnames = []
        $('#eachtest > *').each(function(idx, el){
          index = idx
          t.assertIdentical(el, this)
          tagnames.push(el.tagName.toUpperCase())
          if (idx == 1) return false
        })
        t.assertEqual('SPAN, B', tagnames.join(', '))
        t.assertEqual(1, index)
      },

      testNoop: function(t){
        t.assertUndefined($.noop())
      },

      testConcat: function(t){
        var $collection1 = $('#eachtest > *')
        var $collection2 = $('#find1 .findme')
        var $collection3 = $('#some_element, #another_element')

        var result, array = $collection1.toArray().concat($collection2.toArray(), $collection3.toArray())

        result = $collection1.concat($collection2, $collection3.toArray())
        t.assertEqualCollection(array, result)

        result = $.fn.concat.apply($collection1.toArray(), [$collection2, $collection3.toArray()])
        t.assertEqualCollection(array, result)
      },

      testMap: function(t){
        var results = $('#eachtest > *').map(function(idx, el) {
          t.assertIdentical(el, this)
          return idx + ':' + this.nodeName.toUpperCase()
        })
        t.assertEqual(3, results.size())
        t.assertEqual('0:SPAN, 1:B, 2:BR', results.get().join(', '))
      },

      testDollarMap: function(t){
        var fruits = ['apples', 'oranges', 'pineapple', 'peach', ['grape', 'melon']]
        var results = $.map(fruits, function(item, i) {
          if (item instanceof Array) return item
          else if (!/apple/.test(item)) return i + ':' + item
        })
        t.assertEqual('1:oranges,3:peach,grape,melon', results.join(','))
      },

      testDollarMapObject: function(t){
        var fruit = { name: 'banana', taste: 'sweet' }
        var results = $.map(fruit, function(value, key) {
          return key + '=' + value
        })
        t.assertEqual('name=banana,taste=sweet', results.sort().join(','))
      },

      testDollarMapArrayLike: function(t){
        var results
        results = $.map({ length: 1, a: 'b' }, function(value, key) {
          return key + '=' + value
        })
        t.assertEqual('a=b,length=1', results.sort().join(','))

        results = $.map({ length: 0, a: 'b' }, function(value, key) {
          return key + '=' + value
        })
        t.assertEqual(0, results.length)

        results = $.map(function(){}, function(value, key) {
          return key + '=' + value
        })
        t.assertEqual(0, results.length)
      },

      testDollarGrep: function(t){
        var fruits = ['apples', 'oranges', 'pineapple', 'peach']
        var result = $.grep(fruits, function(name){ return /apple/.test(name) })
        t.assertEqualCollection(['apples', 'pineapple'], result)
      },

      testDollarEach: function(t){
        var array = ['a','b','c'], object = { a: 1, b: 2, c: 3 }, result

        result = []
        $.each(array, function(idx, val){
          result.push(idx)
          result.push(val)
        })
        t.assertEqual('0a1b2c', result.join(''))

        result = []
        $.each(object, function(key, val){
          result.push(key)
          result.push(val)
        })
        t.assertEqual('a1b2c3', result.join(''))

        result = []
        $.each(array, function(idx, val){
          result.push(idx)
          result.push(val)
          return idx<1
        })
        t.assertEqual('0a1b', result.join(''))

        t.assertEqual('abc', $.each(array, function(){}).join(''))
      },

      testDollarEachContext: function(t){
        $.each(['a'], function(key, val) {
          t.assertEqual(this, val)
        })
        $.each({a:'b'}, function(key, val) {
          t.assertEqual(this, val)
        })
      },

      testDollarInArray: function(t) {
        t.assertIdentical( 0,  $.inArray(1, [1,2,3]) )
        t.assertIdentical( 1,  $.inArray(2, [1,2,3]) )
        t.assertIdentical( -1, $.inArray(4, [1,2,3]) )
        t.assertIdentical( 3,  $.inArray(1, [1,2,3,1], 1) )
      },

      testDollarParseJSON: function(t) {
        t.assertSame({a:'b'}, $.parseJSON('{"a":"b"}'))
      },

      testDollarWithDocumentFragmentContext: function(t){
        testDocumentFragmentOrShadowRootContext($(document.createDocumentFragment()), t)
      },

      testDollarWithShadowRootContext: function(t){
        if ('createShadowRoot' in document.body) {
          var $subject = $('#test_dollar_with_shadow_root')
          t.assertLength(1, $subject)
          testDocumentFragmentOrShadowRootContext($($subject[0].createShadowRoot()), t)
        }
      },

      testEq: function(t){
        var $els = $('#eq_test div')
        t.assertZeptoCollection(1, $els.eq(0))
        t.assertZeptoCollection(1, $els.eq(-1))
        t.assertEqual($els.eq(-1)[0].className, 'eq2')
        t.assertUndefined($els.eq(-1).tagName)

        t.assertZeptoCollection(0, $('nonexistent').eq(0))
      },

      testFirst: function(t){
        var zepto = $('h1,p')
        t.assertLength(5, zepto)

        var zepto2 = zepto.first()
        t.refuteIdentical(zepto, zepto2)
        t.assertLength(5, zepto)

        t.assertLength(1, zepto2)
        t.assertEqual('H1', zepto2.get(0).tagName)

        t.assertLength(0, $('nonexistent').first())
      },

      testFirstNonDOM: function(t){
        t.assertEqual('a', $(['a', 'b', 'c']).first())
      },

      testLast: function(t){
        var zepto = $('h1,p')
        t.assertLength(5, zepto)

        var zepto2 = zepto.last()
        t.refuteIdentical(zepto, zepto2)
        t.assertLength(5, zepto)

        t.assertLength(1, zepto2)
        t.assertEqual('P', zepto2.get(0).tagName)

        t.assertLength(0, $('nonexistent').last())
      },

      testLastNonDOM: function(t){
        t.assertEqual('c', $(['a', 'b', 'c']).last())
      },

      testPluck: function(t){
        t.assertEqual('H1DIVDIV', $('h1,div.htmltest').pluck('tagName').join(''))
      },

      testShow: function(t){
        $('#show_hide_div1').show()
        t.assertEqual('inline-block', getComputedStyle($('#show_hide_div1').get(0)).display)

        $('#show_hide_div2').show()
        t.assertEqual('block', getComputedStyle($('#show_hide_div2').get(0)).display)

        $('#show_hide_div3').show()
        t.assertEqual('block', getComputedStyle($('#show_hide_div3').get(0)).display)

        $('#show_hide_span1').show()
        t.assertEqual('block', getComputedStyle($('#show_hide_span1').get(0)).display)

        $('#show_hide_span2').show()
        t.assertEqual('block', getComputedStyle($('#show_hide_span2').get(0)).display)

        $('#show_hide_span3').show()
        t.assertEqual('inline', getComputedStyle($('#show_hide_span3').get(0)).display)
      },

      testHide: function(t){
        $('#show_hide_div1').hide()
        t.assertEqual('none', $('#show_hide_div1').get(0).style.display)

        $('#show_hide_div2').hide()
        t.assertEqual('none', $('#show_hide_div2').get(0).style.display)

        $('#show_hide_div3').hide()
        t.assertEqual('none', $('#show_hide_div3').get(0).style.display)

        $('#show_hide_span1').hide()
        t.assertEqual('none', $('#show_hide_span1').get(0).style.display)

        $('#show_hide_span2').hide()
        t.assertEqual('none', $('#show_hide_span2').get(0).style.display)

        $('#show_hide_span3').hide()
        t.assertEqual('none', $('#show_hide_span3').get(0).style.display)
      },

      testToggle: function(t){
        var el = $('#show_hide_div1').hide(),
            domStyle = el.get(0).style

        t.assertEqual('none', domStyle.display)

        var result = el.toggle()
        t.assertIdentical(el, result, 'expected toggle() to return self')
        t.assertIdentical('', domStyle.display)

        el.toggle()
        t.assertEqual('none', domStyle.display)

        el.toggle(true)
        t.assertIdentical('', domStyle.display)

        el.toggle(true)
        t.assertIdentical('', domStyle.display)

        el.toggle(false)
        t.assertEqual('none', domStyle.display)

        el.toggle(false)
        t.assertEqual('none', domStyle.display)
      },

      testToggleMultiple: function(t){
        var el1  = $('#show_hide_div1').hide(),
            el2  = $('#show_hide_div2').show(),
            both = $('#show_hide_div1, #show_hide_div2')

        both.toggle()
        t.assertIdentical('', el1.get(0).style.display)
        t.assertEqual('none', el2.get(0).style.display)

        both.toggle()
        t.assertEqual('none', el1.get(0).style.display)
        t.assertEqual('block', el2.get(0).style.display)
      },

      testOffset: function(t){
        // TODO
        t.assertNull($('#doesnotexist').offset())
        var el = $('#some_element')
        t.assertIdentical(el, el.offset({}))
        t.assertSame($('<div>').offset(), {left: 0, top: 0})
      },

      testOffsetOnHTML: function(t){
        var offset = $('html').offset()
        t.assertEqual(offset.left, 0)
        t.assertEqual(offset.top, 0)
        t.assert('width' in offset)
        t.assert('height' in offset)
      },

      testWidth: function(t){
        t.assertNull($('#doesnotexist').width())
        // can't check values here, but make sure it doesn't error out
        var viewportWidth = $(window).width()
        t.assert(viewportWidth > 0 || viewportWidth === 0)
        t.assert($(document).width())

        t.assertIdentical(100, $('#offset').width())
        $('#offset').width('90px')
        t.assertIdentical(90, $('#offset').width())
        $('#offset').width(110)
        t.assertIdentical(110, $('#offset').width())
        $('#offset').width(function(i, oldWidth) { return oldWidth + 5 })
        t.assertIdentical(115, $('#offset').width())
      },

      testHeight: function(t){
        t.assertNull($('#doesnotexist').height())
        // can't check values here, but make sure it doesn't error out
        var viewportHeight = $(window).height()
        t.assert(viewportHeight > 0 || viewportHeight === 0)
        t.assert($(document).height())

        // with a tall element on the page,
        // the window (viewport) should be shorter than the total
        // document height
        $('<div style="height:9999px" id="very_high"></div>').appendTo('body')
        t.assert(
          $(window).height() < $(document).height(),
          "'window' height was not smaller than 'document' height?")
        $('#very_high').remove()

        t.assertIdentical(50, $('#offset').height())
        $('#offset').height('60px')
        t.assertIdentical(60, $('#offset').height())
        $('#offset').height(70)
        t.assertIdentical(70, $('#offset').height())
        $('#offset').height(function(i, oldHeight) { return oldHeight + 5 })
        t.assertIdentical(75, $('#offset').height())
      },

      testClosest: function(t){
        var el = $('#li2')
        t.assertEqualCollection(el, el.closest('li'))
        t.assertEqualCollection($('#nested'), el.closest('ul'))
        // with context
        t.assertEqualCollection($('#nested'), el.closest('ul', $('#li1').get(0)))
        t.assertLength(0, el.closest('#parents', $('#li1').get(0)))
        // no ancestor matched
        t.assertLength(0, el.closest('form'))
      },

      testClosestMultiple: function(t){
        var els = $('#parents ul li')
        var uls = els.closest('ul')
        t.assertEqualCollection($('#parents ul'), uls)
        t.assertEqualCollection($('#parents'), uls.closest('#parents'))
      },

      testClosestWithCollection: function(t){
        var targets = $('#parents > li')
        var result = $('#li2').closest(targets)
        t.assertLength(1, result)
        t.assertEqual('li1', result.get(0).id)

        t.assertLength(0, $('#li1').closest('#li2'))
      },

      testClosestWithElement: function(t){
        var target = $('#li1').get(0)
        var result = $('#li2').closest(target)
        t.assertLength(1, result)
        t.assertIdentical(target, result.get(0))

        t.assertLength(0, $('#li1').closest($('#li2').get(0)))
      },

      testClosestOnDetached: function(t){
        var el = $('<div><p><a></a></p></div>'),
            para = el.children(),
            link = para.children()

        t.assertEqualCollection(para, link.closest('p'))
        t.assertEqualCollection(el, link.closest('div'))
        t.assertEqualCollection(el, el.closest('div'))
      },

      testContains: function(t){
        var el1 = $('#li1'), el2 = $('#li2')

        t.assertTrue($.contains(el1.get(0), el2.get(0)))
        t.assertFalse($.contains(el1.get(0), $('#parents').get(0)))
      },

      testContainsOnDetached: function(t){
        var el = $('<div><p><a></a></p></div>'),
            para = el.children(),
            link = para.children()

        t.assertTrue($.contains(para.get(0), link.get(0)))
        t.assertFalse($.contains(document.body, el.get(0)))
      },

      testParents: function(t){
        var body = document.body, html = body.parentNode, container = $('#parents'),
          wrapper = $('#fixtures').get(0)
        t.assertEqualCollection($([wrapper, body, html]), container.parents())

        var expected = $('#li1 > ul').get()
        expected.push($('#li1').get(0))
        expected.push(container.get(0))
        expected = expected.concat([wrapper, body, html])
        t.assertEqualCollection($(expected), $('#li1').find('li').parents())

        expected = [$('#nested').get(0), $('#parents').get(0)]
        t.assertEqualCollection($(expected), $('#li2').parents('ul'))
      },

      testParentsIframe: function(t){
        var iframeBody = $('iframe').get(0).contentDocument.body
        t.assertEqualCollection(
          [iframeBody, iframeBody.parentNode],
          $(iframeBody).find('b').first().parents()
        )
      },

      testParent: function(t){
        var el = $('#li1')
        t.assertEqualCollection($('#parents'), el.parent())
        t.assertEqualCollection($('#li1 > ul'), el.find('li').parent())
        t.assertLength(0, $(document.createElement('div')).parent())
      },

      testParentOnDetached: function(t){
        t.assertLength(0, $('<ul />').parent())
      },

      testChildren: function(t){
        var el=$("#childrenTest"), lis=$("li.child",el)

        //basic form
        t.assertEqualCollection(lis, el.children())
        //filtered by selector
        t.assertEqualCollection(lis.filter(".two"), el.children(".two"))
        //children == null
        t.assertLength(4,lis.children(null))
        //across multiple parents
        t.assertEqualCollection(el.find("li a"), lis.children("a"))
        //chainabilty
        t.assertEqual(el.find("li a.childOfTwo").text(), lis.children(".childOfTwo").text())
        //non-existent children
        t.assertLength(0,lis.children(".childOfTwo").children())
      },

      testContents: function(t){
        var $contents = $("#contentsTest").contents()
        t.assertLength(3, $contents)
        t.assertLength(2, $contents.filter('span'))
        t.assertLength(0, $("#contentsEmptyTest").contents())
      },

      testIframeContents: function(t){
        var el = $("#contentsIframeTest")
        t.assertEqual("Hello from iframe!", el.contents().find("b").first().text())
      },

      testSiblings: function(t){
        var el=$("#siblingsTest")

        //basic form
        t.assertEqualCollection($("li.one,li.three,li.four",el), $("li.two",el).siblings())
        //filtered by selector
        t.assertEqualCollection($("li.three",el), $("li.two",el).siblings(".three"))
        //across multiple parents
        t.assertEqualCollection(el.find("li b"), $("li em",el).siblings("b"))
        t.assertLength(6,$("li span",el).siblings())
        //non-existent siblings
        t.assertLength(0,$("li span.e",el).siblings())
      },

      testNot: function(t){
        var el=$("#notTest")

        //selector form
        t.assertEqualCollection($("li.one,li.three,li.four",el), $("li",el).not(".two"))
        //element or NodeList form
        t.assertEqualCollection($("span.b,span.c,span.e",el), $("span",el).not(document.getElementById("notTestExclude")))
        t.assertEqualCollection($("li",el), $("li, span",el).not(document.getElementsByTagName("span")))
        //function form
        t.assertEqualCollection($("span.b,span.c",el),$("span",el).not(function(i){
          var $this=$(this)
          $this.html(i)
          return ($this.hasClass("d") || $this.hasClass("e")) ? true : false
        }))
        //test the index was passed in properly in previous test
        t.assertEqual("0",$("span.b",el).text())
        t.assertEqual("1",$("span.c",el).text())
      },

      testReplaceWith: function(t) {
        $('div.first').replaceWith('<h2 id="replace_test">New heading</h2>')
        t.assertUndefined($('div.first').get(0))
        t.assert(document.getElementById("replace_test").nodeType)
        t.assertEqual($('.replacewith h2#replace_test').get(0), document.getElementById("replace_test"))

        $('#replace_test').replaceWith($('.replace_test_div'))
        t.assertUndefined($('#replace_test').get(0))
        t.assert(document.getElementsByClassName("replace_test_div")[0].nodeType)
        t.assertEqual($('.replacewith h2#replace_test').get(0), document.getElementsByClassName("replace_test")[0])

        //Multiple elements
        $('.replacewith .replace_test_div').replaceWith('<div class="inner first">hi</div><div class="inner fourth">hello</div>')
        t.assertLength(4,$('.replacewith div'))
        t.assertEqual("inner first", $('.replacewith div')[0].className)
        t.assertEqual("inner fourth", $('.replacewith div')[1].className)
      },

      testReplaceWithFragment: function(t) {
        var orphanDiv = $("<div />")
        orphanDiv.replaceWith($("<div class='different' />"))
        t.assert(!orphanDiv.hasClass('different'))
      },

      testWrap: function(t) {
        var el = $('#wrap_test')
        el.find('span').wrap('<p><i/></p>')
        t.assertEqual(
          '<p><i><span>hi</span></i></p><a></a><p><i><span>hello</span></i></p>',
          el.html()
        )

        // avoids unnecessary cloning of dom structure for wrapping
        el = $('<div><a/></div>')
        var structure = $('<span/>')
        el.find('a').wrap(structure)
        t.assertIdentical(structure.get(0), el.find('span').get(0))
        t.assert(el.find('a').parent().is('span'))
      },

      testWrapFunction: function(t) {
        var el = $('<div><b>A</b><b>B</b></div>')
        el.find('b').wrap(function(index){
          return '<a class=link' + index + $(this).text() + ' />'
        })
        t.assertEqual(
          '<a class="link0A"><b>A</b></a><a class="link1B"><b>B</b></a>',
          el.html()
        )
      },

      testWrapAll: function(t) {
        var el = $('#wrapall_test')
        el.find('span').wrapAll('<p><a/></p>')
        t.assertEqual(
          '<b></b><p><a><span>hi</span><span>hello</span></a></p><i></i>',
          el.html()
        )
      },

      testWrapFragment: function(t) {
        var fragment = $('<div id="fragment" />')
        fragment.wrapAll('<div id="wrap_test" />')
        t.assertEqual('wrap_test', fragment.parent().attr('id'))
        t.assertEqual(0, fragment.children().length)

        fragment = $('<div id="fragment" />')
        fragment.wrap('<div id="wrap_test" />')
        t.assertEqual('wrap_test', fragment.parent().attr('id'))
        t.assertEqual(0, fragment.children().length)
      },

      testWrapInner: function(t) {
        var $el = $('#wrapinner_test')
        $el.wrapInner('<div>')
        t.assertLength(1, $el.children())
        t.assertLength(1, $el.children('div'))
        t.assertLength(3, $el.find('div').contents())

        $el = $('#wrapinner_empty_test')
        $el.wrapInner('<div>')
        t.assertLength(1, $el.children())
        t.assertLength(1, $el.children('div'))
        t.assertLength(0, $el.find('div').contents())
      },

      testWrapInnerFunction: function(t) {
        var el = $('<div><b>A</b><b>B</b></div>')
        el.find('b').wrapInner(function(index){
          return '<a class=link' + index + $(this).text() + ' />'
        })
        t.assertEqual(
          '<b><a class="link0A">A</a></b><b><a class="link1B">B</a></b>',
          el.html()
        )
      },

      testUnwrap: function(t){
        var context=$("#unwrap_test")

        //Element With no siblings
        $(".unwrap_one span",context).unwrap()
        t.assertLength(1,$("b",context))

        //Element with siblings
        $(".unwrap_two span",context).unwrap()
        t.assertLength(0,$("b",context))
        //make sure siblings are unaffected
        t.assertLength(3,$("span",context))
        //make sure parents are what they should be
        t.assertEqual($("span",context).parent().get(0), document.getElementsByClassName("unwrap_one")[0])
      },

      testUnwrapFragment: function(t){
        var fragment = $('<div id=outer><div id=inner></div><div id=uninvolved></div></div>'),
            innerFragment = fragment.find("#inner"),
            uninvolved = fragment.find("#uninvolved")

        innerFragment.unwrap()
        t.assertLength(0, innerFragment.parent(), '#inner should be orphan')
        t.assertLength(0, uninvolved.parent(),    '#uninvolved should be orphan')
        t.assertLength(0, fragment.children(),    'fragment should be empty')
      },

      testClone: function(t){
        var el = $('<div class=sheep><span></span></div>'),
            el2 = el.clone()

        t.assert(el2.hasClass('sheep'))
        el2.addClass('black')
        t.refute(el.hasClass('black'))

        el2.find('span').text('baa')
        t.assertIdentical('', el.find('span').text())
      },

      testFind: function(t){
        var found = $('p#find1').find('span.findme')
        t.assertLength(4, found)
        t.assertEqual('1', found.get(0).innerHTML)
        t.assertEqual('2', found.get(1).innerHTML)
        t.assertEqual('4', found.get(2).innerHTML)
        t.assertEqual('5<span>6</span>', found.get(3).innerHTML)

        var found = $('p#find1, #find2').find('span')
        t.assertLength(11, found)
      },

      testFindWithCollection: function(t){
        var targets = $('#find1 span span, #find1 b, #find2 span')
        var found = $('p#find1').find(targets)
        t.assertLength(2, found)
        t.assertEqual('B', found.get(0).tagName)
        t.assertEqual('6', found.get(1).innerHTML)
      },

      testFindWithElement: function(t){
        var target = $('#find1 span span').get(0)
        var found = $('p#find1').find(target)
        t.assertLength(1, found)
        t.assertEqual('6', found.get(0).innerHTML)

        found = $('p#find1').find(document.body)
        t.assertLength(0, found, "no elements should have matched")
      },

      testFindWithInvalidNode: function(t) {
        var found = $('<div><a>1</a></div>\n<div></div>').find('a')
        t.assertLength(1, found)
        t.assertEqual('1', found.get(0).innerHTML)
      },

      testFindWithFalsyValue: function(t){
        var element = '<div><a>1</a></div>'
        t.assertZeptoCollection(0, $(element).find(undefined))
        t.assertZeptoCollection(0, $(element).find(false))
        t.assertZeptoCollection(0, $(element).find(0))
        t.assertZeptoCollection(0, $(element).find(''))
      },

      testFilter: function(t){
        var found = $('div')
        t.assertLength(2, found.filter('.filtertest'))
        t.assertLength(0, found.filter('.doesnotexist'))
        t.assertLength(1, found.filter('.filtertest').filter(':nth-child(2n)'))

        var nodes = $('<select><option value=1>test1</option><option value=2>test2</option><option value=1>test1</option></select>')
        t.assertLength(2, nodes.find('option').filter(function(){ return this.value == '1' }))

        var indexes = []
        nodes.find('option').filter(function(index){ if (this.value=='1') indexes.push(index) })
        t.assertEqualCollection([0,2], indexes)
      },

      testFilterWithNonNativeArrayFilter: function(t){
        var nativeFilter = Array.prototype.filter
        try {
          // apply broken filter
          Array.prototype.filter = function(){ return [] }
          t.assertLength(2, $('div').filter('.filtertest'))
        } finally {
          Array.prototype.filter = nativeFilter
        }
      },

      testHas: function(t){
        var result, el = $('<b id=one><a></a></b><b id=two><i></i></b><b id=three><i></i></b>')
        result = el.has('a')
        t.assertEqual('one', result.pluck('id').join(' '))
        result = el.has('i')
        t.assertEqual('two three', result.pluck('id').join(' '))
        result = el.has(el.find('i').get(0))
        t.assertEqual('two', result.pluck('id').join(' '))
      },

      testAdd: function(t){
        var lis=$("li"),spans=$("span"),
        together=lis.add("span"),
        duplicates=spans.add("span"),
        disconnected=$("<div></div>").add("<span></span>"),
        mainContext=$("#addTest")

        //uniquness of collection
        t.assertLength(spans.length, duplicates)

        //selector only
        t.assertLength((lis.length + spans.length), together)

        //selector with context
        t.assertEqualCollection($("span",mainContext), $(".add_span").add(".add_span_exclude",mainContext))

        //DOM Element + Chaining test
        t.assertEqualCollection(mainContext.children(), $(".add_span").add(".add_span_exclude").add(document.getElementById("addTestDiv")))

        //Disconnected
        t.assert(!disconnected.get(0).parentNode)

        $("#addTestDiv").append(disconnected)
        t.assertEqual('<div></div><span></span>', document.getElementById("addTestDiv").innerHTML)
      },

      testIs: function(t){
        t.assert($('#find1').is('p'))
        t.assert($('#li2').is(':first-child'))
        t.assert(!$('#find1').is('doesnotexist'))
        t.assert(!$('#find1').is())
        t.assert($('#find1').is($('#find1')))
        t.assert(!$('#find1').is($('#find2')))

        t.assert($('#fixtures div').is('#some_element'))
        t.assert(!$('#doesnotexist').is('p'))
        t.assert(!$('#doesnotexist').is($('#find1')))

        t.assert(!$(window).is('p'))
      },

      testIsWithoutParent: function(t){
        var elem = $('<div id=outOfDOM />')
        t.assert(elem.is('div'))
        t.assert(elem.is('#outOfDOM'))
        t.assert(!elem.is('p'))
        t.assert(!elem.is())
      },

      testCSS: function(t){
        var el = $('#some_element').get(0)

        // single assignments
        $('#some_element').css('color', '#f00')
        $('#some_element').css('margin-top', '10px')
        $('#some_element').css('marginBottom', '5px')
        $('#some_element').css('left', 42)
        $('#some_element').css('z-index', 10)
        $('#some_element').css('fontWeight', 300)
        $('#some_element').css('border', '1px solid rgba(255,0,0,0)')
        t.assertEqual('rgb(255, 0, 0)', el.style.color)
        t.assertEqual('rgba(255, 0, 0, 0)', el.style.borderLeftColor)
        t.assertEqual('1px', el.style.borderLeftWidth)
        t.assertEqual('10px', el.style.marginTop)
        t.assertEqual('5px', el.style.marginBottom)
        t.assertEqual('42px', el.style.left)
        t.assertEqual(300, el.style.fontWeight)
        t.assertEqual(10, el.style.zIndex)

        // read single values, including shorthands
        t.assertEqual('rgb(255, 0, 0)',
          $('#some_element').css('color'))
        t.assertEqual('1px solid rgba(255, 0, 0, 0)',
          $('#some_element').css('border'))

        // multiple assignments
        $('#some_element').css({
          'border': '2px solid #000',
          'color': 'rgb(0,255,0)',
          'padding-left': '2px'
        })
        t.assertEqual('2px', $('#some_element').css('borderLeftWidth'))
        t.assertEqual('solid', $('#some_element').css('borderLeftStyle'))
        t.assertEqual('rgb(0, 0, 0)', $('#some_element').css('borderLeftColor'))
        t.assertEqual('rgb(0, 255, 0)', $('#some_element').css('color'))
        t.assertEqual('2px', $('#some_element').css('paddingLeft'))
        t.assertEqual('2px', $('#some_element').css('border-left-width'))
        t.assertEqual('solid', $('#some_element').css('border-left-style'))
        t.assertEqual('rgb(0, 0, 0)', $('#some_element').css('border-left-color'))
        t.assertEqual('rgb(0, 255, 0)', $('#some_element').css('color'))
        t.assertEqual('2px', $('#some_element').css('padding-left'))

        // read multiple values, camelCased CSS
        var arrCamelCss = $('#some_element').css(['borderLeftWidth', 'borderLeftStyle', 'borderLeftColor', 'color'])
        t.assertEqual('2px', arrCamelCss['borderLeftWidth'])
        t.assertEqual('solid', arrCamelCss['borderLeftStyle'])
        t.assertEqual('rgb(0, 0, 0)', arrCamelCss['borderLeftColor'])
        t.assertEqual('rgb(0, 255, 0)', arrCamelCss['color'])
        t.assertUndefined(arrCamelCss['paddingLeft'])

        // read multiple values, dashed CSS property names
        var arrDashedCss = $('#some_element').css(['border-left-width', 'border-left-style', 'border-left-color', 'color'])
        t.assertEqual('2px', arrDashedCss['border-left-width'])
        t.assertEqual('solid', arrDashedCss['border-left-style'])
        t.assertEqual('rgb(0, 0, 0)', arrDashedCss['border-left-color'])
        t.assertEqual('rgb(0, 255, 0)', arrDashedCss['color'])
        t.assertUndefined(arrDashedCss['padding-left'])

        // make sure reads from empty Zepto collections just return undefined
        t.assertUndefined($().css(['border-left-width']))

        var div = $('#get_style_element')
        t.assertEqual('48px', div.css('font-size'))
        t.assertEqual('rgb(0, 0, 0)', div.css('color'))
      },

      testCSSUnset: function (t) {
        var el = $('#some_element').css({ 'margin-top': '1px', 'margin-bottom': '1px' }),
            dom = el.get(0)

        el.css('color', '#000')
        el.css('color', '')
        t.assertIdentical('', dom.style.color)

        el.css('color', '#000')
        el.css('color', undefined)
        t.assertIdentical('', dom.style.color)

        el.css('color', '#000')
        el.css('color', null)
        t.assertIdentical('', dom.style.color)

        el.css('color', '#000')
        el.css({ color: '', 'margin-top': undefined, 'marginBottom': null })
        t.assertIdentical('', dom.style.color)
        t.assertIdentical('', dom.style.marginTop)
        t.assertIdentical('', dom.style.marginBottom)
      },

      testCSSZeroValue: function (t) {
        var el = $('#some_element'), dom = el.get(0)
        el.css('opacity', 0)
        t.assertIdentical('0', dom.style.opacity)

        el.css('opacity', 1)
        el.css({ opacity: 0 })
        t.assertIdentical('0', dom.style.opacity)
      },

      testCSSOnNonExistingElement: function (t) {
        var el = $('.some-non-exist-elm')
        t.assertUndefined(el.css('color'))
      },

      testCSSBatchSetOnNonExistingElementReturnsSelf: function (t) {
        var el = $('.some-non-exist-elm')
        var ret = el.css({
          'border': '2px solid #000',
          'color': 'rgb(0,255,0)'
        })
        t.assertIdentical(ret, el)
      },

      testHtml: function(t){
        var div = $('div.htmltest')

        div.text(undefined)
        t.assertEqual('', div.html())

        t.assertIdentical(div, div.html('yowza'))
        t.assertEqual('yowza', document.getElementById('htmltest1').innerHTML)
        t.assertEqual('yowza', document.getElementById('htmltest2').innerHTML)

        t.assertEqual('yowza', $('div.htmltest').html())

        div.html('')
        t.assertEqual('', document.getElementById('htmltest2').innerHTML)

        t.assertEqual("", $('#htmltest3').html())

        t.assertNull($('doesnotexist').html())

        div.html('yowza')
        div.html(function(idx, html){
          return html.toUpperCase()
        })
        t.assertEqual('YOWZA', div.html())

        div.html('<u>a</u><u>b</u><u>c</u>')

        $('u').html(function(idx,html){
          return idx+html
        })
        t.assertEqual('<u>0a</u><u>1b</u><u>2c</u>', div.html())

        var table = $('#htmltest4'),
          html = '<tbody><tr><td>ok</td></tr></tbody>'
        table.html('<tbody><tr><td>ok</td></tr></tbody>')
        t.assertEqual(html, table.html())
      },

      testText: function(t){
        // test basics with Zepto-created DOM elements
        t.assertEqual('',         $('<h1/>').text())
        t.assertEqual('',         $('<h1/>').text('').text())
        t.assertEqual('',         $('<h1/>').text(undefined).text())
        t.assertEqual('',         $('<h1/>').text(null).text())
        t.assertEqual('false',    $('<h1/>').text(false).text())
        t.assertEqual('1',        $('<h1/>').text(1).text())
        t.assertEqual('<b>a</b>', $('<h1/>').text('<b>a</b>').text())

        t.assertEqual('&lt;b&gt;a&lt;/b&gt;',
          $('<h1/>').text('<b>a</b>').html())

        // now test with some existing DOM elements
        $('#texttest3').text(undefined)
        t.assertEqual('', $('#texttest3').text())

        t.assertEqual('Here is some text', $('#texttest1').text())
        t.assertEqual('And some more', $('#texttest2').text())

        // gets all text of selectors matching
        t.assertEqual('Here is some textAnd some more', $('div.texttest').text())

        $('div.texttest').text("Let's set it")
        t.assertEqual("Let's set it", $('#texttest1').text())
        t.assertEqual("Let's set it", $('#texttest2').text())

        $('#texttest2').text('')
        t.assertEqual("Let's set it", $('#texttest1').text())
        t.assertEqual('', $('#texttest2').text())
      },

      testTextWithFunction: function(t) {
        var el = $('<div><span>hello</span> <span></span> <span>world</span> <span>again</span></div>'),
            els = el.find('span')

        els.text(function(idx, oldText){
          if (idx > 2) return null
          if (oldText) return oldText.toUpperCase() + ' ' + idx
        })

        t.assertEqual('HELLO 0', els[0].textContent)
        t.assertEqual('', els[1].textContent)
        t.assertEqual('WORLD 2', els[2].textContent)
        t.assertEqual('', els[3].textContent)
      },

      testEmpty: function(t) {
        $('#empty_test').empty()

        t.assertEqual(document.getElementById('empty_1'), null)
        t.assertEqual(document.getElementById('empty_2'), null)
        t.assertEqual(document.getElementById('empty_3'), null)
        t.assertEqual(document.getElementById('empty_4'), null)
      },

      testAttr: function(t){
        var els = $('#attr_1, #attr_2')

        t.assertEqual('someId1', els.attr("data-id"))
        t.assertEqual('someName1', els.attr("data-name"))

        els.attr("data-id","someOtherId")
        els.attr("data-name","someOtherName")

        t.assertEqual('someOtherId', els.attr("data-id"))
        t.assertEqual('someOtherName', els.attr("data-name"))
        t.assertEqual('someOtherId', $('#attr_2').attr('data-id'))

        t.assertUndefined(els.attr("nonExistentAttribute"))

        els.attr("data-id", false)
        t.assertEqual("false", els.attr("data-id"))

        els.attr("data-id", 0)
        t.assertEqual("0", els.attr("data-id"))

        els.attr({ 'data-id': 'id', 'data-name': 'name' })
        t.assertEqual('id', els.attr("data-id"))
        t.assertEqual('name', els.attr("data-name"))
        t.assertEqual('id', $('#attr_2').attr('data-id'))

        els.attr('data-id', function(idx,oldvalue){
          return idx+oldvalue
        })
        t.assertEqual('0id', els.attr('data-id'))
        t.assertEqual('1id', $('#attr_2').attr('data-id'))
      },

      testAttrSetterErase: function(t){
        var el = $('<div data-name="foo">')
        t.assertIdentical(el, el.attr('data-name', undefined), 'setter should return self')
        t.assertNull(el.get(0).getAttribute('data-name'), 'attribute should be erased')
        t.assertUndefined(el.attr('data-name'), 'attr should reflect erased attribute')
      },

      testProp: function(t){
        var label = $('#prop_test1')
        var input = $('#prop_test2')
        var table = $('#prop_test3')
        var td1 = $('#prop_test4')
        var td2 = $('#prop_test5')
        var img = $('#prop_test6')
        var div = $('#prop_test7')
        var checkbox = $('#prop_test8')

        t.assertEqual(input.prop('tabindex'), -1)
        t.assertEqual(input.prop('readonly'), true)
        t.assertEqual(label.prop('for'), 'prop_test2')
        t.assertEqual(input.prop('class'), 'propTest')
        t.assertEqual(input.prop('maxlength'), 10)
        t.assertEqual(table.prop('cellspacing'), 10)
        t.assertEqual(table.prop('cellpadding'), 5)
        t.assertEqual(td1.prop('rowspan'), 2)
        t.assertEqual(td2.prop('colspan'), 2)
        t.assertEqual(img.prop('usemap'), '#imgMap')
        t.assertEqual(div.prop('contenteditable'), 'true')

        checkbox.prop({'class': 'propTest', 'checked': false, 'disabled': true})
        t.assertEqual(checkbox.prop('class'), 'propTest')
        t.assertEqual(checkbox.prop('checked'), false)
        t.assertEqual(checkbox.prop('disabled'), true)
      },

      testRemoveProp: function(t){
        var el = $('<span>')
        el.prop('hello', 'world')
        t.assertEqual('world', el[0].hello)
        el.removeProp('hello')
        t.assertUndefined(el[0].hello)
      },

      testPropSetterErase: function(t){
        var input = $('<input readonly>')
        t.assertIdentical(input, input.prop('readonly', false))
        t.assertFalse(input.prop('readonly'))

        input.get(0)._foo = 'bar'
        t.assertIdentical(input, input.prop('_foo', undefined))
        t.assertUndefined(input.get(0)._foo, 'custom property should be cleared')
        t.assertUndefined(input.prop('_foo'), 'prop should reflect cleared property')
      },

      testAttrNoElement: function(t){
        t.assertUndefined($().attr('yo'))
        t.assertUndefined($(document.createTextNode('')).attr('yo'))
        t.assertUndefined($(document.createComment('')).attr('yo'))

        var els = $('<b></b> <i></i>').attr('id', function(i){ return this.nodeName + i })
        t.assertEqual('B0', els.eq(0).attr('id'))
        t.assertEqual('I2', els.eq(2).attr('id'))
        t.assertUndefined(els.eq(1).attr('id'))
      },

      testAttrEmpty: function(t){
        var el = $('#data_attr')
        t.assertIdentical('', el.attr('data-empty'))
      },

      testAttrOnTextInputField: function(t) {
        var inputs, values

        // HTML is set here because IE does not reset
        // values of input fields on page reload
        document.getElementById('attr_with_text_input').innerHTML =
          '<input value="Default input">'+
          '<input type="text" value="Text input">'+
          '<input type="email" value="Email input">'+
          '<input type="search" value="Search input">'

        inputs = $('#attr_with_text_input input')

        values = $.map(inputs, function(i){ return $(i).attr('value') })
        t.assertEqual('Default input, Text input, Email input, Search input', values.join(', '))

        // Only .attr('value', v) changes .attr('value')
        // rather than .val(v)
        inputs.attr('value', function(i, value){ return value.replace('input', 'changed') })

        values = $.map(inputs, function(i){ return $(i).attr('value') })
        t.assertEqual('Default changed, Text changed, Email changed, Search changed', values.join(', '))
      },

      testAttrNullUnset: function(t){
        var el = $('<div id=hi>')
        el.attr('id', null)
        t.assertUndefined(el.attr('id'))

        el.attr('id', 'hello')
        el.attr({ id:null })
        t.assertUndefined(el.attr('id'))
      },

      testRemoveAttr: function(t) {
        var el = $('#attr_remove')
        t.assertEqual('boom', el.attr('data-name'))
        el.removeAttr('data-name')
        t.assertUndefined(el.attr('data-name'))
      },

      testRemoveMultipleAttr: function(t) {
        var el = $('#attr_remove_multi')
        t.assertEqual('someId1', el.attr('data-id'))
        t.assertEqual('someName1', el.attr('data-name'))

        el.removeAttr('data-id data-name')
        t.assertUndefined(el.attr('data-id'))
        t.assertUndefined(el.attr('data-name'))
      },

      testRemoveAttrNoElement: function(t){
        t.assert($().removeAttr('rel'))
        t.assert($(document.createTextNode('')).removeAttr('rel'))

        var els = $('<b rel=up></b> <i rel=next></i>')
        t.assertIdentical(els, els.removeAttr('rel'))
        t.assertUndefined(els.eq(0).attr('rel'))
        t.assertUndefined(els.eq(1).attr('rel'))
        t.assertUndefined(els.eq(2).attr('rel'))
      },

      testData: function(t) {
        var el = $('#data_attr')
        // existing attribute
        t.assertEqual('bar', el.data('foo'))
        t.assertEqual('baz', el.data('foo-bar'))
        t.assertEqual('baz', el.data('fooBar'))

        // camelCase
        el.data('fooBar', 'bam')
        t.assertEqual('bam', el.data('fooBar'))
        t.assertEqual('bam', el.data('foo-bar'))

        // new attribute
        el.data('fun', 'hello')
        t.assertEqual('hello', el.attr('data-fun'))
        t.assertEqual('hello', el.data('fun'))

        // blank values
        t.assertIdentical('', el.data('empty'))
        t.assertUndefined(el.data('does-not-exist'))
      },

      testDataSetterErase: function(t) {
        var el = $('<div data-name="foo">')
        t.assertIdentical(el, el.data('name', undefined))
        t.assertUndefined(el.data('name'))
      },

      testDataNumberType: function(t){
        var el = $('<div data-num=42 />')
        t.assertIdentical(42, el.data('num'))

        t.assertIdentical(42.5,
          $('<div data-float=42.5 />').data('float'))

        t.assertIdentical("08",
          $('<div data-notnum=08 />').data('notnum'))

        t.assertIdentical("5903509451651483504",
          $('<div data-bignum="5903509451651483504" />').data('bignum'))
      },

      testDataBooleanType: function(t){
        var el = $('<div data-true=true data-false=false />')
        t.assertTrue(el.data('true'))
        t.assertFalse(el.data('false'))
      },

      testDataNullType: function(t){
        var el = $('<div data-nil=null />')
        t.assertNull(el.data('nil'))
      },

      testDataJsonType: function(t){
        var el = $('<div data-json=\'["one", "two"]\' data-invalid=\'[boom]\' />')
        var json = el.data('json')
        t.assertEqual(2, json.length)
        t.assertEqual("one", json[0])
        t.assertEqual("two", json[1])
        t.assertEqual('[boom]', el.data('invalid'))
      },

      testVal: function(t) {
        var input = $('#attr_val')

        // some browsers like IE don't reset input values on reload
        // which messes up repeated test runs, so set the start value
        // directly via the DOM API
        document.getElementById('attr_val').value = 'Hello World'

        t.assertEqual('Hello World', input.val())

        input.val(undefined)
        t.assertEqual('', input.val())

        input.val(null)
        t.assertEqual('', input.val())

        input.val('')
        t.assertEqual('', input.val())

        input.get(0).value = 'Hello again'
        t.assertEqual('Hello again', input.val())

        input.val(function(i, val){ return val.replace('Hello', 'Bye') })
        t.assertEqual('Bye again', input.val())

        t.assertUndefined($('non-existent').val())

        var multiple =
          $('<select multiple><option selected>1</option><option value=2 selected="selected">a</option><option>3</option></select>')
        t.assertEqualCollection(['1','2'], multiple.val())

        // FIXME
        // This is the "approved" way of de-selecting an option
        // Unfortunately, this fails on Chrome 29 for Android
        multiple.find('option')[0].selected = false

        t.assertEqualCollection(['2'], multiple.val(),
          "Expected val() to reflect changes to selected options in a <select multiple> element")
      },

      testValVsValueAttr: function(t) {
        var input

        input = $('<input type="text" value="Original">')
        input.val('By .val(v)')
        t.assertEqual('Original', input.attr('value'))
        t.assertEqual('By .val(v)', input.val())

        input.attr('value', 'By .attr("value", v)')
        t.assertEqual('By .attr("value", v)', input.attr('value'))
        t.assertEqual('By .val(v)', input.val())

        // .attr('value', v) will change both
        // without applying .val(v) first
        input = $('<input type="text" value="Original">')
        input.attr('value', 'By .attr("value", v)')
        t.assertEqual('By .attr("value", v)', input.attr('value'))
        t.assertEqual('By .attr("value", v)', input.val())
      },

      testChaining: function(t){
        t.assert(document.getElementById('nay').innerHTML == "nay")
        $('span.nay').css('color', 'red').html('test')
        t.assert(document.getElementById('nay').innerHTML == "test")
      },

      testCachingForLater: function(t){
        var one = $('div')
        var two = $('span')

        t.assert(one.get(0) !== two.get(0))
      },

      testPlugins: function(t){
        var el = $('#some_element').get(0)

        $.fn.plugin = function(){
          return this.each(function(){ this.innerHTML = 'plugin!' })
        }
        $('#some_element').plugin()
        t.assertEqual('plugin!', el.innerHTML)

        // test if existing Zepto objects receive new plugins
        if ('__proto__' in {}) {
          var $some_element = $('#some_element')
          $.fn.anotherplugin = function(){
            return this.each(function(){ this.innerHTML = 'anotherplugin!' })
          }
          t.assert(typeof $some_element.anotherplugin == 'function')
          $some_element.anotherplugin()
          t.assertEqual('anotherplugin!', el.innerHTML)
        } else
          window.console && console.warn &&
          console.warn("Browser doesn't support __proto__, skipping test of live extension of existing Zepto objects with plugins")
      },

      testAppendPrependBeforeAfter: function(t){
        $('#beforeafter').append('append')
        $('#beforeafter').prepend('prepend')
        $('#beforeafter').before('before')
        $('#beforeafter').after('after')

        t.assertEqual('before<div id="beforeafter">prependappend</div>after', $('#beforeafter_container').html())

        //testing with TextNode as parameter
        $('#beforeafter_container').html('<div id="beforeafter"></div>')

        function text(contents){
          return document.createTextNode(contents)
        }

        $('#beforeafter').append(text('append'))
        $('#beforeafter').prepend(text('prepend'))
        $('#beforeafter').before(text('before'))
        $('#beforeafter').after(text('after'))

        t.assertEqual('before<div id="beforeafter">prependappend</div>after', $('#beforeafter_container').html())

        $('#beforeafter_container').html('<div id="beforeafter"></div>')

        function div(contents){
          var el = document.createElement('div')
          el.innerHTML = contents
          return el
        }

        $('#beforeafter').append(div('append'))
        $('#beforeafter').prepend(div('prepend'))
        $('#beforeafter').before(div('before'))
        $('#beforeafter').after(div('after'))

        t.assertEqual(
          '<div>before</div><div id="beforeafter"><div>prepend</div>'+
          '<div>append</div></div><div>after</div>',
          $('#beforeafter_container').html()
        )

        //testing with Zepto object as parameter
        $('#beforeafter_container').html('<div id="beforeafter"></div>')

        $('#beforeafter').append($(div('append')))
        $('#beforeafter').prepend($(div('prepend')))
        $('#beforeafter').before($(div('before')))
        $('#beforeafter').after($(div('after')))

        t.assertEqual(
          '<div>before</div><div id="beforeafter"><div>prepend</div>'+
          '<div>append</div></div><div>after</div>',
          $('#beforeafter_container').html()
        )

        //testing with a zepto object of more than one element as parameter
        $(document.body).append('<div class="append">append1</div><div class="append">append2</div>')
        $(document.body).append('<div class="prepend">prepend1</div><div class="prepend">prepend2</div>')
        $(document.body).append('<div class="before">before1</div><div class="before">before2</div>')
        $(document.body).append('<div class="after">after1</div><div class="after">after2</div>')

        $('#beforeafter_container').html('<div id="beforeafter"></div>')

        $('#beforeafter').append($('.append'))
        $('#beforeafter').prepend($('.prepend'))
        $('#beforeafter').before($('.before'))
        $('#beforeafter').after($('.after'))

        t.assertEqual(
          '<div class="before">before1</div><div class="before">before2</div><div id="beforeafter"><div class="prepend">prepend1</div><div class="prepend">prepend2</div>'+
          '<div class="append">append1</div><div class="append">append2</div></div><div class="after">after1</div><div class="after">after2</div>',
          $('#beforeafter_container').html()
        )

        //

        var helloWorlds = [], appendContainer1 = $('<div> <div>Hello</div> <div>Hello</div> </div>'),
            helloDivs = appendContainer1.find('div')

        helloDivs.append(' world!')
        helloDivs.each(function() { helloWorlds.push($(this).text()) })
        t.assertEqual('Hello world!,Hello world!', helloWorlds.join(','))

        //

        var spans = [], appendContainer2 = $('<div> <div></div> <div></div> </div>'),
            appendDivs = appendContainer2.find('div')

        appendDivs.append($('<span>Test</span>'))
        appendDivs.each(function() { spans.push($(this).html()) })
        t.assertEqual('<span>Test</span>,<span>Test</span>', spans.join(','))
      },

      testAppendNull: function(t){
        var el = $(document.body)
        t.assertIdentical(el, el.append(null))
      },

      testBeforeAfterFragment: function(t){
        var fragment = $('<div class=fragment />')
        fragment.before('before').after('after')
        t.assertLength(1, fragment)
        t.assert(fragment.hasClass('fragment'))
      },

      testAppendMultipleArguments: function(t){
        var el = $('<div><span>original</span></div>')
        el.append(
          $('<b>one</b>').get(0),
          $('<b>two</b><b>three</b>').get(),
          $('<b>four</b><b>five</b>'),
          '<b>six</b>'
        )
        t.assertEqual('original one two three four five six',
          $.map(el.children(), function(c){ return $(c).text() }).join(' '))
      },

      testAppendWithArrayParams: function(t){
        var zpElement = $('<b>five</b>')
        var multElements = $('<b>six</b><b>seven</b>')
        var node = document.createElement('b')
        node.appendChild(document.createTextNode('four'))

        // append elements on this array
        var arrElements = ['<b>one</b><b>two</b>', '<b>three</b>', node, zpElement, multElements ]
        var el = $('<div></div>')
        el.append(arrElements)
        t.assertEqual('<b>one</b><b>two</b><b>three</b><b>four</b><b>five</b><b>six</b><b>seven</b>', el.html())
      },

      testAppendToPrependTo: function(t){
        // testing with Zepto object
        function div(contents){
          var el = document.createElement('div')
          el.innerHTML = contents
          return el
        }

        var ap = $(div('appendto'))
        var pr = $(div('prependto'))

        var ap2 = ap.appendTo($('#appendtoprependto'))
        var pr2 = pr.prependTo($('#appendtoprependto'))

        // the object returned is the correct one for method chaining
        t.assertSame(ap, ap2)
        t.assertSame(pr, pr2)

        t.assertEqual(
          '<div id="appendtoprependto"><div>prependto</div>'+
          '<div>appendto</div></div>',
          $('#appendtoprependto_container').html()
        )

        // zepto object with more than one element
        $(document.body).append('<div class="appendto">appendto1</div><div class="appendto">appendto2</div>')
        $(document.body).append('<div class="prependto">prependto1</div><div class="prependto">prependto2</div>')

        // selector

        // Note that on IE resetting the parent element to be empty will
        // cause inserted elements to be emptied out, so we have to re-create
        // them. This is the same behavior as on jQuery.
        // (Other browsers don't exhibit this problem.)
        ap = $(div('appendto'))
        pr = $(div('prependto'))

        $('#appendtoprependto_container').html('<div id="appendtoprependto"></div>')
        ap.appendTo('#appendtoprependto')
        pr.prependTo('#appendtoprependto')
        t.assertEqual(
          '<div id="appendtoprependto"><div>prependto</div>'+
          '<div>appendto</div></div>',
          $('#appendtoprependto_container').html()
        )

        // reset test elements
        ap = $(div('appendto'))
        pr = $(div('prependto'))
        $('#appendtoprependto_container').html('<div id="appendtoprependto"></div>')
        $('.appendto').appendTo($('#appendtoprependto'))
        $('.prependto').prependTo($('#appendtoprependto'))

        t.assertEqual(
          '<div id="appendtoprependto"><div class="prependto">prependto1</div><div class="prependto">prependto2</div><div class="appendto">appendto1</div><div class="appendto">appendto2</div></div>',
          $('#appendtoprependto_container').html()
        )
      },

      testInsertBeforeInsertAfter: function(t){
        // testing with Zepto object
        function div(contents){
          var el = document.createElement('div')
          el.innerHTML = contents
          return el
        }

        var ib = $(div('insertbefore'))
        var ia = $(div('insertafter'))

        var ibia = $('#insertbeforeinsertafter')
        var ib2 = ib.insertBefore(ibia)
        var ia2 = ia.insertAfter(ibia)

        // test the object returned is correct for method chaining
        t.assertEqual(
          '<div>insertbefore</div><div id="insertbeforeinsertafter">'+
          '</div><div>insertafter</div>',
          $('#insertbeforeinsertafter_container').html()
        )

        // testing with a zepto object of more than one element as parameter
        $(document.body).append('<div class="insertbefore">insertbefore1</div><div class="insertbefore">insertbefore2</div>')
        $(document.body).append('<div class="insertafter">insertafter1</div><div class="insertafter">insertafter2</div>')

        $('#insertbeforeinsertafter_container').html('<div id="insertbeforeinsertafter"></div>')

        $('.insertbefore').insertBefore($('#insertbeforeinsertafter'))
        $('.insertafter').insertAfter($('#insertbeforeinsertafter'))

        t.assertEqual(
          '<div class="insertbefore">insertbefore1</div><div class="insertbefore">insertbefore2</div>'+
          '<div id="insertbeforeinsertafter"></div><div class="insertafter">insertafter1</div>'+
          '<div class="insertafter">insertafter2</div>',
          $('#insertbeforeinsertafter_container').html()
        )

        // testing with a selector as parameter
        $('#insertbeforeinsertafter_container').html('<div id="insertbeforeinsertafter"></div>')

        // reset test elements
        ib = $(div('insertbefore'))
        ia = $(div('insertafter'))
        ib.insertBefore('#insertbeforeinsertafter')
        ia.insertAfter('#insertbeforeinsertafter')

        t.assertEqual(
          '<div>insertbefore</div><div id="insertbeforeinsertafter">'+
          '</div><div>insertafter</div>',
          $('#insertbeforeinsertafter_container').html()
        )
      },

      testAppendEval: function (t) {
        window.someGlobalVariable = 0
        try {
          $('#fixtures').append(
            '<div><b id="newByAppend">Hi</b>' +
            '<\script>this.someGlobalVariable += $("#newByAppend").size()<\/script></div>'
          )
          t.assertIdentical(1, window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testNoEvalWithSrc: function (t) {
        try {
          window.someGlobalVariable = false
          $('<\script src="remote.js">window.someGlobalVariable = true<\/script>').appendTo('body')
          t.assert(!window.someGlobalVariable, 'expected SCRIPT with src not to be evaled')
        } finally {
          delete window.someGlobalVariable
        }
      },

      testHtmlEval: function (t) {
        window.someGlobalVariable = 0
        try {
          $('<div>').appendTo('#fixtures').html(
            '<div><b id="newByHtml">Hi</b>' +
            '<\script>this.someGlobalVariable += $("#newByHtml").size()<\/script></div>'
          )
          t.assertIdentical(1, window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testPrependEval: function (t) {
        window.someGlobalVariable = 0
        try {
          $('<div>').appendTo('#fixtures').prepend(
            '<b id="newByPrepend">Hi</b>' +
            '<\script>this.someGlobalVariable += $("#newByPrepend").size()<\/script>'
          )
          t.assertIdentical(1, window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testAppendTemplateNonEval: function (t) {
        try {
          window.someGlobalVariable = true
          $('<' + 'script type="text/template">window.someGlobalVariable = false</script' + '>').appendTo('body')
          t.assert(window.someGlobalVariable)

          window.someGlobalVariable = true
          $('<' + 'script type="text/template">this.someGlobalVariable = false</script' + '>').appendTo('body')
          t.assert(window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testHtmlTemplateNonEval: function (t) {
        try {
          window.someGlobalVariable = true
          $('<div></div>').appendTo('body')
            .html('<' + 'script type="text/template">window.someGlobalVariable = false</script' + '>')
          t.assert(window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testRemove: function(t) {
        var el = $('<div>').appendTo(document.body)
        t.assertLength(1, el.parent())
        t.assertIdentical(el, el.remove())
        t.assertLength(0, el.parent())
        t.assertIdentical(el, el.remove())  //=> ensure an error isn't raised
      },

      testNotInDocumentNonEval: function (t) {
        try {
          window.someGlobalVariable = 0
          $('<div></div>')
            .html('<\script>window.someGlobalVariable += 1<\/script>')
            .appendTo('body')
          t.assertIdentical(1, window.someGlobalVariable)
        } finally {
          delete window.someGlobalVariable
        }
      },

      testAddRemoveClass: function(t){
        var el = $('#some_element').get(0)

        $('#some_element').addClass('green')
        t.assertEqual('green', el.className)
        $('#some_element').addClass('green')
        t.assertEqual('green', el.className)
        $('#some_element').addClass('red')
        t.assertEqual('green red', el.className)
        $('#some_element').addClass('blue red')
        t.assertEqual('green red blue', el.className)
        $('#some_element').removeClass('green blue')
        t.assertEqual('red', el.className)

        $('#some_element').attr('class', ' red green blue ')
        t.assertEqual(' red green blue ', el.className) // sanity check that WebKit doesn't change original input
        $('#some_element').removeClass('green')
        t.assertEqual('red blue', el.className)

        //addClass with function argument
        $('#some_element').addClass(function(idx,classes){
          //test the value of "this"
          t.assertEqualCollection($('#some_element'), $(this))
          //test original classes are being passed
          t.assertEqual('red blue', this.className)
          return "green"
        })
        t.assertEqual('red blue green', el.className)

        // addClass with no argument
        t.assertEqualCollection($('#some_element'), $('#some_element').addClass())
        t.assertEqual('red blue green', el.className)
        t.assertEqualCollection($('#some_element'), $('#some_element').addClass(''))
        t.assertEqual('red blue green', el.className)

        //removeClass with function argument
        $('#some_element').removeClass(function(idx,classes){
          //test the value of "this"
          t.assertEqualCollection($('#some_element'), $(this))
          //test original classes are being passed
          t.assertEqual('red blue green', this.className)
          return "blue"
        })
        t.assertEqual('red green', el.className)

        $('#some_element').removeClass()
        t.assertEqual('', el.className)
      },

      testWindowClasses: function(t){
        // check that window is agnostic to class related functions
        $(window).removeClass('non-existing-class')
        t.refute('className' in window)
        $(window).addClass('some-class')
        t.refute('className' in window)
        t.refute($(window).hasClass('some-class'))
        $(window).toggleClass('some-class')
        t.refute('className' in window)
      },

      testHasClass: function(t){
        var el = $('#some_element')
        el.addClass('green')

        t.assert(el.hasClass('green'))
        t.assert(!el.hasClass('orange'))

        el.addClass('orange')
        t.assert(el.hasClass('green'))
        t.assert(el.hasClass('orange'))

        el = $(document.body)
        t.assert(!el.hasClass('orange'), "body shouldn't have the class")
        el = el.add('#some_element')
        t.assert(el.hasClass('orange'), "an element in collection has the class")

        t.assertFalse(el.hasClass())
        t.assertFalse(el.hasClass(''))
      },

      testHasClassEmpty: function(t){
        var z = $('#doesnotexist')
        t.assertEqual(0, z.size())
        t.assertFalse(z.hasClass('a'))
      },

      testToggleClass: function(t){
        var el = $('#toggle_element').removeClass()

        t.assertIdentical(el, el.toggleClass('green'))
        t.assertTrue(el.hasClass('green'))
        t.assertFalse(el.hasClass('orange'))

        el.toggleClass('orange')
        t.assertTrue(el.hasClass('green'))
        t.assertTrue(el.hasClass('orange'))

        el.toggleClass('green')
        t.assertFalse(el.hasClass('green'))
        t.assertTrue(el.hasClass('orange'))

        el.toggleClass('orange')
        t.assertFalse(el.hasClass('green'))
        t.assertFalse(el.hasClass('orange'))

        el.toggleClass('orange green')
        t.assertTrue(el.hasClass('orange'))
        t.assertTrue(el.hasClass('green'))

        el.toggleClass('orange green blue')
        t.assertFalse(el.hasClass('orange'))
        t.assertFalse(el.hasClass('green'))
        t.assertTrue(el.hasClass('blue'))

        el.removeClass()

        el.toggleClass('orange', false)
        t.assertFalse(el.hasClass('orange'))
        el.toggleClass('orange', false)
        t.assertFalse(el.hasClass('orange'))

        el.toggleClass('orange', true)
        t.assertTrue(el.hasClass('orange'))
        el.toggleClass('orange', true)
        t.assertTrue(el.hasClass('orange'))

        //function argument
        el.toggleClass(function(idx,classes){
          t.assertIdentical(el.get(0), this)
          //test original classes are being passed
          t.assertEqual('orange', this.className)
          return "brown"
        })
        t.assertTrue(el.hasClass('brown'))

        el.toggleClass(function(idx,classes){
          return "yellow"
        }, false)
        t.assertFalse(el.hasClass('yellow'))

        el.toggleClass(function(idx,classes){
          return "yellow"
        }, true)
        t.assert(el.hasClass('yellow'))

        // no/empty argument
        t.assertIdentical(el, el.toggleClass())
        t.assertEqual('orange brown yellow', el.get(0).className)
        t.assertIdentical(el, el.toggleClass(''))
        t.assertEqual('orange brown yellow', el.get(0).className)
      },

      testClassSVG: function(t){
        var svg = $('svg')
        t.assert(!svg.hasClass('foo'))
        svg.addClass('foo bar')
        t.assert(svg.hasClass('foo'))
        t.assert(svg.hasClass('bar'))
        svg.removeClass('foo')
        t.assert(!svg.hasClass('foo'))
        t.assert(svg.hasClass('bar'))
        svg.toggleClass('bar')
        t.assert(!svg.hasClass('foo'))
        t.assert(!svg.hasClass('bar'))
      },

      testIndex: function(t){
        t.assertEqual($("p > span").index("#nay"), 2)
        t.assertEqual($("p > span").index(".yay"), 0)
        t.assertEqual($("span").index("span"), 0)
        t.assertEqual($("span").index("boo"), -1)

        t.assertEqual($('#index_test > *').eq(-1).index(), 1)
      },

      testBoolAttr: function (t) {
        var el = $('#BooleanInput')
        t.assertEqual('', el.attr('required'))
        t.assertUndefined(el.attr('non_existant_attr'))
      },

      testDocumentReady: function (t) {
        // Check that ready() callback fired and get Zepto as an argument
        var arg1, arg2, arg3, arg4

        t.pause()
        $(function (Z1) {
          arg1 = Z1
          $(document).ready(function (Z2) {
            arg2 = Z2
            $(document).on('ready', function (Z3) {
              arg3 = Z3
              $(document).on('foo ready bar', function (Z4) {
                arg4 = Z4
                t.resume(function(){
                  t.assertIdentical(Zepto, arg1)
                  t.assertIdentical(Zepto, arg2)
                  t.assertIdentical(Zepto, arg3)
                  t.assertIdentical(Zepto, arg4)
                })
              })
            })
          })
        })
      },

      testSlice: function (t) {
        var $els = $("#slice_test div")
        t.assertEqual($els.slice().length, 3)
        t.assertEqual(typeof $els.slice().ready, 'function')
        t.assertEqual($els.slice(-1)[0].className, 'slice3')
      },

      testScrollTop: function(t) {
        var $window = $(window), $body = $(document.body)
        t.assert($window.scrollTop() >= 0)
        t.assert($body.scrollTop() >= 0)

        t.assertIdentical($window.scrollTop(20), $window)
        t.assertIdentical($body.scrollTop(20),   $body)
      },

      testScrollLeft: function(t) {
        var $window = $(window), $body = $(document.body)
        t.assert($window.scrollLeft() >= 0)
        t.assert($body.scrollLeft() >= 0)

        t.assertIdentical($window.scrollLeft(20), $window)
        t.assertIdentical($body.scrollLeft(20),   $body)
      },

      testSort: function(t){
        var els = $(['eight', 'nine', 'ten', 'eleven'])
        var result = els.sort(function(a,b){ return b.length > a.length ? -1 : 1 })
        t.assertIdentical(els, result)
        t.assertEqual(4, result.size())
        t.assertEqualCollection(['ten', 'nine', 'eight', 'eleven'], result)
      }
    })

    Evidence('EventTest', {
      tearDown: function(){
        $('*').unbind()
      },

      testBind: function(t){
        var counter = 0
        $(document.body).bind('click', function(){ counter++ })
        click($('#some_element').get(0))
        t.assertEqual(1, counter)

        counter = 0
        $('#some_element').bind('click mousedown', function(){ counter++ })
        click($('#some_element').get(0))
        mousedown($('#some_element').get(0))
        t.assertEqual(3, counter) // 1 = body click, 2 = element click, 3 = element mousedown
      },

      testBindWithObject: function(t){
        var counter = 0, keyCounter = 0, el = $('#some_element'),
          eventData = {
            click: function(){ counter++ },
            keypress: function(){ keyCounter++ }
          }

        $(document.body).bind(eventData)

        el.trigger('click')
        el.trigger('click')
        t.assertEqual(2, counter)
        el.trigger('keypress')
        t.assertEqual(1, keyCounter)

        $(document.body).unbind({ keypress: eventData.keypress })

        el.trigger('click')
        t.assertEqual(3, counter)
        el.trigger('keypress')
        t.assertEqual(1, keyCounter)
      },

      testBindContext: function(t){
        var context, handler = function(){
          context = $(this)
        }
        $('#empty_test').bind("click",handler)
        $('#empty_test').bind("mousedown",handler)
        click($('#empty_test').get(0))
        t.assertEqualCollection($('#empty_test'), context)
        context = null
        mousedown($('#empty_test').get(0))
        t.assertEqualCollection($('#empty_test'), context)
      },

      testBindWithCustomArgument: function(t) {
        var data, numArgs, counter = 0,
            handler = function(ev, arg) {
              numArgs = arguments.length,
              data = ev.data
              counter = arg.counter
            }

        $('#some_element').bind('custom', handler)
        $('#some_element').trigger('custom', { counter: 10 })
        t.assertEqual(10, counter)
        t.assertEqual(2, numArgs)
        t.assertUndefined(data)
      },

      testBindPreventDefault: function (t) {
        var link = $('<a href="#"></a>'),
            prevented = false

        link
          .appendTo('body')
          .bind('click', function () {
            return false
          })
          .bind('click', function (e) {
            prevented = e.isDefaultPrevented()
          })
          .trigger('click')

        t.assert(prevented)
      },

      testCreateEventObject: function(t){
        var e = $.Event('custom')
        t.assertEqual('custom', e.type)

        var e2 = new $.Event('custom')
        t.assertEqual('custom', e2.type)

        var e3 = $.Event('custom', {customKey: 'customValue'})
        t.assertEqual('custom', e3.type)
        t.assertEqual('customValue', e3.customKey)

        var e4 = $.Event('custom', {bubbles: false})
        t.assertFalse(e4.bubbles)

        var e5 = $.Event({ type: 'keyup', keyCode: 40 })
        t.assertEqual('keyup', e5.type)
        t.assertEqual(40, e5.keyCode)
      },

      testTriggerObject: function(t){
        var el = $('#some_element'),
            eventType, eventCode

        el.on('keyup', function(e){
          eventType = e.type
          eventCode = e.keyCode
        })
        el.trigger({ type: 'keyup', keyCode: 40 })

        t.assertEqual('keyup', eventType)
        t.assertEqual(40, eventCode)
      },

      testTriggerEventObject: function(t){
        var data, counter = 0,
            customEventKey = 0

        var handler = function(ev,customData) {
          data = ev.data
          counter = customData.counter
          customEventKey = ev.customKey
        }

        var customEventObject = $.Event('custom', { customKey: 20 })

        $('#some_element').bind('custom', handler)
        $('#some_element').trigger(customEventObject, { counter: 10 })

        t.assertEqual(10, counter)
        t.assertEqual(20, customEventKey)
        t.assertUndefined(data)
      },

      testTriggerEventCancelled: function(t){
        var event = $.Event('custom'),
          element = $('<div/>'),
          isDefaultPrevented = false

        t.refute(event.isDefaultPrevented())

        element.bind('custom', function(e){
          e.preventDefault()
          isDefaultPrevented = e.isDefaultPrevented()
        })

        element.trigger(event)

        t.assertTrue(event.isDefaultPrevented())
        t.assertTrue(isDefaultPrevented)
      },

      testTriggerHandler: function(t){
        t.assertUndefined($('doesnotexist').triggerHandler('submit'))

        var form = $('#trigger_handler form').get(0)
        $('#trigger_handler').bind('submit', function(e) {
          t.fail("triggerHandler shouldn't bubble")
        })

        var executed = []
        $(form).bind('submit', function(e) {
          executed.push("1")
          t.assertEqual(form, e.target)
          return 1
        })
        $(form).bind('submit', function(e) {
          executed.push("2")
          t.assertEqual(form, e.target)
          e.stopImmediatePropagation()
          return 2
        })
        $(form).bind('submit', function(e) {
          t.fail("triggerHandler shouldn't continue after stopImmediatePropagation")
        })
        t.assertIdentical(2, $(form).triggerHandler('submit'))
        t.assertEqual('1 2', executed.join(' '))
      },

      testUnbind: function(t){
        var counter = 0, el = $('#another_element').get(0)
        var handler = function(){ counter++ }
        $('#another_element').bind('click mousedown', handler)
        click(el)
        mousedown(el)
        t.assertEqual(2, counter)

        $('#another_element').unbind('click', handler)
        click(el)
        t.assertEqual(2, counter)
        mousedown(el)
        t.assertEqual(3, counter)

        $('#another_element').unbind('mousedown')
        mousedown(el)
        t.assertEqual(3, counter)

        $('#another_element').bind('click mousedown', handler)
        click(el)
        mousedown(el)
        t.assertEqual(5, counter)

        $('#another_element').unbind()
        click(el)
        mousedown(el)
        t.assertEqual(5, counter)
      },

      testUnbindWithNamespace: function(t){
        var count = 0
        $("#namespace_test").bind("click.bar", function() { count++ })
        $("#namespace_test").bind("click.foo", function() { count++ })
        $("#namespace_test").bind("mousedown.foo.bar", function() { count++ })

        $("#namespace_test").trigger("click")
        t.assertEqual(2, count)

        $("#namespace_test").unbind("click.baz")
        $("#namespace_test").trigger("click")
        t.assertEqual(4, count)

        $("#namespace_test").unbind("click.foo")
        $("#namespace_test").trigger("click")
        t.assertEqual(5, count)

        $("#namespace_test").trigger("mousedown")
        t.assertEqual(6, count)

        $("#namespace_test").unbind(".bar")
        $("#namespace_test").trigger("click").trigger("mousedown")
        t.assertEqual(6, count)
      },

      testDelegate: function(t){
        var counter = 0, pcounter = 0
        $(document.body).delegate('#some_element', 'click', function(){ counter++ })
        $('p').delegate('span.yay', 'click', function(){ counter++ })
        $(document.body).delegate('p', 'click', function(){ pcounter++ })

        click($('#some_element').get(0))
        t.assertEqual(1, counter)

        click($('span.yay').get(0))
        t.assertEqual(2, counter)

        click($('span.nay').get(0))
        t.assertEqual(2, counter)

        click($('p').get(0))
        t.assertEqual(3, pcounter)
      },

      testDelegateBlurFocus: function(t) {
        var counter = 0
        $('#delegate_blur_test').delegate('input', 'blur', function(){ counter++ })

        $('#delegate_blur_test').find('input').focus()
        $('#delegate_blur_test').find('input').blur()
        t.assertEqual(1, counter)

        $('#delegate_blur_test').find('input').focus()
        $('#delegate_blur_test').find('input').blur()
        t.assertEqual(2, counter)

        $('#delegate_focus_test').delegate('input', 'focus', function(){ counter++ })

        $('#delegate_focus_test').find('input').focus()
        $('#delegate_focus_test').find('input').blur()
        t.assertEqual(3, counter)

        $('#delegate_focus_test').find('input').focus()
        $('#delegate_focus_test').find('input').blur()
        t.assertEqual(4, counter)
      },

      testDelegateNamespacedBlurFocus: function(t) {
        var counter = 0
        $('#delegate_blur_test').delegate('input', 'blur.namespace_test', function(){ counter++ })

        $('#delegate_blur_test').find('input').focus()
        $('#delegate_blur_test').find('input').blur()
        t.assertEqual(1, counter)

        $('#delegate_blur_test').find('input').focus()
        $('#delegate_blur_test').find('input').blur()
        t.assertEqual(2, counter)

        $('#delegate_focus_test').delegate('input', 'focus.namespace_test', function(){ counter++ })

        $('#delegate_focus_test').find('input').focus()
        $('#delegate_focus_test').find('input').blur()
        t.assertEqual(3, counter)

        $('#delegate_focus_test').find('input').focus()
        $('#delegate_focus_test').find('input').blur()
        t.assertEqual(4, counter)
      },

      testUndelegateNamespacedBlurFocus: function(t) {
        var el, counter = 0

        el = $('#delegate_blur_test')

        el.delegate('input', 'blur.test', function(){ counter++ })
        el.find('input').focus().blur()
        t.assertEqual(1, counter, 'expected handler to be triggered')

        el.undelegate('input', '.test')
        el.find('input').focus().blur()
        t.assertEqual(1, counter, 'expected handler to unbind')

        el = $('#delegate_focus_test')

        el.delegate('input', 'focus.test', function(){ counter++ })
        el.find('input').focus().blur()
        t.assertEqual(2, counter, 'expected handler to be triggered')

        el.undelegate('input', '.test')
        el.find('input').focus().blur()
        t.assertEqual(2, counter, 'expected handler to unbind')
      },

      testDelegateReturnFalse: function(t){
        $(document.body).delegate('#link_that_will_be_prevented', 'click', function(){
          return false
        })

        var event = $.Event('click')
        $('#link_that_will_be_prevented').trigger(event)

        t.assertTrue(event.isDefaultPrevented())

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            var text = $('#link_target_iframe')[0].contentDocument.body.textContent
            t.assert(!text.match(/Hello from iframe/))
          })
        }, 500)
      },

      testDelegateReturnValueShouldntPreventDefault: function(t){
        $(document.body).delegate('#link_that_will_be_prevented', 'click', function(){
        })

        var event = $.Event('click')
        $('#link_that_will_be_prevented').trigger(event)

        t.assertFalse(event.isDefaultPrevented())

        t.pause()
        setTimeout(function(){
          t.resume(function(){
            var text = $('#link_target_iframe')[0].contentDocument.body.textContent
            t.assert(text.match(/Hello from iframe/))
          })
        }, 500)
      },

      testDelegateWithObject: function(t){
        var counter = 0, received, el = $('p').first(),
          eventData = {
            click: function(){ counter++ },
            custom: function(e, arg){ received = arg }
          }

        $(document.body).delegate('p', eventData)

        el.trigger('click')
        t.assertEqual(1, counter)
        el.trigger('click')
        t.assertEqual(2, counter)
        el.trigger('custom', 'boo')
        t.assertEqual('boo', received)

        $(document.body).undelegate('p', {custom: eventData.custom})

        el.trigger('click')
        t.assertEqual(3, counter)
        el.trigger('custom', 'bam')
        t.assertEqual('boo', received)
      },

      testDelegateWithCustomArgument: function(t) {
        var received
        $(document).delegate('#some_element', 'custom', function(e, arg, more){ received = arg + more })
        $('p').delegate('span.yay', 'custom', function(e, arg){ received = arg })
        $(document).delegate('p', 'custom', function(e, arg){ received = arg })

        $('#some_element').trigger('custom', 'one')
        t.assertEqual('oneundefined', received)
        $('#some_element').trigger('custom', ['one', 'two'])
        t.assertEqual('onetwo', received)

        $('span.yay').trigger('custom', 'boom')
        t.assertEqual('boom', received)
        $('span.yay').trigger('custom', ['bam', 'boom'])
        t.assertEqual('bam', received)

        $('span.nay').trigger('custom', 'noes')
        t.assertEqual('noes', received)

        $('p').first().trigger('custom', 'para')
        t.assertEqual('para', received)
      },

      testDelegateEventProxy: function(t){
        var content
        $('div#delegate_test').delegate('span.second-level', 'click', function(e){
          t.assertEqual($('span.second-level').get(0), this)
          t.assertEqual($('span.second-level').get(0), e.currentTarget)
          t.refuteEqual($('span.second-level').get(0), e.originalEvent.currentTarget)
          t.assertEqual($('div#delegate_test').get(0), e.liveFired)
          content = $(this).html()
        })
        click($('span.second-level').get(0))
        t.assertEqual('hi', content)

        var fired = false
        if (window.location.hash.length) window.location.hash = ''
        $('div#delegate_test').html('<a href="#foo"></a>')
        $('div#delegate_test').delegate('a', 'click', function(e){
          e.preventDefault()
          fired = true
        })
        click($('div#delegate_test a').get(0))
        t.assert(fired)
        t.refuteEqual('#foo', window.location.hash)

        fired = false
        if (window.location.hash.length) window.location.hash = ''
        $('div#delegate_test').html('<a href="#bar"></a>')
        $('div#delegate_test a').trigger('click')
        t.assert(fired)
        t.refuteEqual('#bar', window.location.hash)
      },

      testUndelegate: function(t){
        var count = 0, handler = function() { count++ }
        $("#undelegate_test").bind("click mousedown", handler)
        $("#undelegate_test").delegate("span.first-level", "click mousedown", handler)
        $("#undelegate_test").delegate("span.second-level", "click mousedown", handler)
        $("#undelegate_test span.second-level").trigger("click")
        t.assertEqual(3, count)

        $("#undelegate_test").undelegate("span.second-level", "click", handler)
        $("#undelegate_test span.second-level").trigger("click")
        t.assertEqual(5, count)

        $("#undelegate_test").undelegate("span.first-level")
        $("#undelegate_test span.second-level").trigger("click")
        t.assertEqual(6, count)

        $("#undelegate_test").unbind("click")
        $("#undelegate_test span.second-level").trigger("click")
        t.assertEqual(6, count)

        $("#undelegate_test span.second-level").trigger("mousedown")
        t.assertEqual(8, count)

        $("#undelegate_test").undelegate()
        $("#undelegate_test span.second-level").trigger("mousedown")
        t.assertEqual(8, count)
      },

      testLive: function(t){
        var counter = 0
        $('p.live').live('click', function(){ counter++ })

        $(document.body).append('<p class="live" id="live_1"></p>')
        $(document.body).append('<p class="live" id="live_2"></p>')

        click($('#live_1').get(0))
        click($('#live_2').get(0))

        $('p.live').remove()
        $(document.body).append('<p class="live" id="live_this_test"></p>')

        $('p.live').live('click', function(){
          t.assertEqual(document.getElementById('live_this_test'), this)
        })
        click($('#live_this_test').get(0))

        t.assertEqual(3, counter)
      },

      testDie: function(t){
        var count = 0, handler = function() { count++ }
        $("#another_element").live("click mousedown", handler)
        $("#another_element").trigger("click")
        t.assertEqual(1, count)

        $("#another_element").die("click", handler)
        $("#another_element").trigger("click")
        t.assertEqual(1, count)

        $("#another_element").trigger("mousedown")
        t.assertEqual(2, count)

        $("#another_element").die()
        $("#another_element").trigger("mousedown")
        t.assertEqual(2, count)
      },

      testOn: function(t){
        var el = $('#some_element'), node = el.get(0), ret,
          bindTriggered = 0, delegateTriggered = 0

        ret = el.on('click', function(e){
          bindTriggered++
          t.assertIdentical(node, this)
        })
          .on({ click: function(){bindTriggered++} })
        t.assertIdentical(el, ret)

        ret = $(document.body).on('click', 'div', function(e){
          delegateTriggered++
          t.assertIdentical(node, this)
        })
          .on({ click: function(){delegateTriggered++} }, '*[id^=some]')
        t.assertIdentical(document.body, ret.get(0))

        click(node)
        t.assertEqual(2, bindTriggered, "bind handlers")
        t.assertEqual(2, delegateTriggered, "delegate handlers")
      },

      testOnReturnFalse: function(t){
        var el = $('#some_element')

        el.on('click', function(){
          setTimeout(function(){
            t.resume(function(){})
          }, 10)
          t.assert(true, "should have been called")
          return false
        })
        $(document.body).on('click', function(){
          t.refute(true, "the event should have been stopped")
        })

        t.pause()
        click(el.get(0))
      },

      testOff: function(t){
        var el = $('#some_element'), bindTriggered = 0, delegateTriggered = 0,
          handler = function(){ bindTriggered++ }

        el.bind('click', handler).bind('click', function(){ bindTriggered++ })
        el.live('click', function(){ delegateTriggered++ })

        click(el.get(0))
        t.assertEqual(2, bindTriggered, "bind handlers before unbind")
        t.assertEqual(1, delegateTriggered, "delegate handlers before unbind")

        el.off('click', handler)
        $(document.body).off('click', '#some_element')

        click(el.get(0))
        t.assertEqual(3, bindTriggered, "bind handlers")
        t.assertEqual(1, delegateTriggered, "delegate handlers")
      },

      testOne: function(t){
        var counter = 0, context, received, el = $('#some_element')
        $(document.body).one('click', function(e, arg, more){
          context = this
          counter++
          received = arg + more
          t.assertIn('preventDefault', e)
          return false
        })

        var evt = $.Event('click')
        el.trigger(evt, ['one', 'two'])
        t.assertEqual(1, counter)
        t.assertEqual('onetwo', received)
        t.assertIdentical(document.body, context)
        t.assertTrue(evt.isDefaultPrevented())

        el.trigger('click')
        t.assertEqual(1, counter, "the event handler didn't unbind itself")
      },

      testOneWithObject: function(t){
        var counter = 0, el = $('#some_element')
        $(document.body).one({
          click: function() { counter++ },
          custom: function() { counter-- }
        })

        el.trigger('click')
        t.assertEqual(1, counter)
        el.trigger('click')
        t.assertEqual(1, counter)

        el.trigger('custom')
        t.assertEqual(0, counter)
        el.trigger('custom')
        t.assertEqual(0, counter)
      },

      testDOMEventWrappers: function(t){
        var events = ('blur focus focusin focusout load resize scroll unload click dblclick '+
          'mousedown mouseup mousemove mouseover mouseout '+
          'change select keydown keypress keyup error').split(' ')

        var el = $('#another_element'), count = 0

        events.forEach(function(event){
          t.assertTrue($.isFunction(el[event]), 'event type: ' + event)
        })

        el.click(function(){ count++ })
        click(el.get(0))

        t.assertEqual(1, count)
      },

      testCustomEvents: function (t) {
        var el = $(document.body)

        el.bind('custom', function(evt, a, b) {
          t.assertEqual(a, 1)
          t.assertEqual(b, 2)
          el.unbind()
        })
        el.trigger('custom', [1, 2])

        el.bind('custom', function(evt, a) {
          t.assertEqual(a, 1)
          el.unbind()
        })
        el.trigger('custom', 1)

        var eventData = {z: 1}
        el.bind('custom', function(evt, a) {
          t.assertEqual(a, eventData)
          el.unbind()
        })
        el.trigger('custom', eventData)
      },

      testSpecialEvent: function (t) {
        var clickEvent     = $.Event('click'),
            mouseDownEvent = $.Event('mousedown'),
            mouseUpEvent   = $.Event('mouseup'),
            mouseMoveEvent = $.Event('mousemove'),
            submitEvent    = $.Event('submit')

        t.assertEqual(MouseEvent, clickEvent.constructor)
        t.assertEqual(MouseEvent, mouseDownEvent.constructor)
        t.assertEqual(MouseEvent, mouseUpEvent.constructor)
        t.assertEqual(MouseEvent, mouseMoveEvent.constructor)
        t.assertEqual(Event,      submitEvent.constructor)
      }
    })
  })()
  </script>
</body>
</html>


================================================
FILE: vendor/evidence.js
================================================
/*  evidence.js, version 0.6
 *
 *  Copyright (c) 2009 Tobie Langel (http://tobielangel.com)
 *
 *  evidence.js is freely distributable under the terms of an MIT-style license.
 *--------------------------------------------------------------------------*/

(function(global) {
  var originalEvidence = global.Evidence,
      originalOnload   = global.onload;

  function Evidence() {
    TestCase.extend.apply(TestCase, arguments);
  }

  function noConflict() {
    global.Evidence = originalEvidence;
    return Evidence;
  }

  Evidence.noConflict = noConflict;
  Evidence.VERSION    = '0.6';

var FILE_REGEXP = /.*?\/(\w+\.html)(.*)/;

function getNameFromFile() {
  return (global.location || '').toString().replace(FILE_REGEXP, '$1');
}

function chain(subclass, superclass) {
  function Subclass() {}
  Subclass.prototype = superclass.prototype;
  subclass.prototype = new Subclass();
  subclass.prototype.constructor = subclass;
  return subclass;
}

function defer(block, context) {
  if ('setTimeout' in global) {
    window.setTimeout(function() {
      block.call(context);
    }, 10);
  } else {
    block.call(context);
  }
}
function AssertionSkippedError(message) {
  this.message = message;
}

AssertionSkippedError.displayName = 'AssertionSkippedError';

(function(p) {
  p.name = 'AssertionSkippedError';
})(AssertionSkippedError.prototype);
Evidence.AssertionSkippedError = AssertionSkippedError;
function AssertionFailedError(message, template, args) {
  this.message = message;
  this.template = template || '';
  this.args = args;
}

AssertionFailedError.displayName = 'AssertionFailedError';

(function(p) {
  p.name = 'AssertionFailedError';
})(AssertionFailedError.prototype);
Evidence.AssertionFailedError = AssertionFailedError;
function AssertionMessage(message, template, args) {
  this.message = message.replace(/%/g, '%%');
  this.template = template || '';
  this.args = args;
}

AssertionMessage.displayName = 'AssertionMessage';

(function(p) {
  function toString() {
    return UI.printf(this.message + this.template, this.args);
  }
  p.toString = toString;
})(AssertionMessage.prototype);
Evidence.AssertionMessage = AssertionMessage;

var Assertions = (function() {
  function _assertExpression(expression, message, template) {
    /*for (var i=0; i < 100000; i++) {
      (function(){})()
    }*/
    if (expression) {
      this.addAssertion();
    } else {
      var args = Array.prototype.slice.call(arguments, 3);
      throw new AssertionFailedError(message, template, args);
    }
  }

  function skip(message) {
    throw new AssertionSkippedError(message || 'Skipped!');
  }

  function fail(message) {
    this._assertExpression(false, message || 'Flunked!');
  }

  function assert(test, message) {
    this._assertExpression(
      !!test,
      message || 'Failed assertion.',
      'Expected %o to evaluate to true.', test
    );
  }

  function refute(test, message) {
    this._assertExpression(
      !test,
      message || 'Failed refutation.',
      'Expected %o to evaluate to false.', test
    );
  }

  function assertTrue(test, message) {
    this._assertExpression(
      (test === true),
      message || 'Failed assertion.',
      'Expected %o to be true.', test
    );
  }

  function refuteTrue(test, message) {
    this._assertExpression(
      (test !== true),
      message || 'Failed refutation.',
      'Expected %o to not be true.', test
    );
  }

  function assertNull(test, message) {
    this._assertExpression(
      (test === null),
      message || 'Failed assertion.',
      'Expected %o to be null.', test
    );
  }

  function refuteNull(test, message) {
    this._assertExpression(
      (test !== null),
      message || 'Failed refutation.',
      'Expected %o to not be null.', test
    );
  }

  function assertUndefined(test, message) {
    this._assertExpression(
      (typeof test === 'undefined'),
      message || 'Failed assertion.',
      'Expected %o to be undefined.', test
    );
  }

  function refuteUndefined(test, message) {
    this._assertExpression(
      (typeof test !== 'undefined'),
      message || 'Failed refutation.',
      'Expected %o to not be undefined.', test
    );
  }

  function assertFalse(test, message) {
    this._assertExpression(
      (test === false),
      message || 'Failed assertion.',
      'Expected %o to be false.', test
    );
  }

  function refuteFalse(test, message) {
    this._assertExpression(
      (test !== false),
      message || 'Failed refutation.',
      'Expected %o to not be false.', test
    );
  }

  function assertEqual(expected, actual, message) {
    this._assertExpression(
      (expected == actual),
      message || 'Failed assertion.',
      'Expected %o to be == to %o.', actual, expected
    );
  }

  function refuteEqual(expected, actual, message) {
    this._assertExpression(
      (expected != actual),
      message || 'Failed refutation.',
      'Expected %o to be != to %o.', actual, expected
    );
  }

  function assertIdentical(expected, actual, message) {
    this._assertExpression(
      (expected === actual),
      message || 'Failed assertion.',
      'Expected %o to be === to %o.', actual, expected
    );
  }

  function refuteIdentical(expected, actual, message) {
    this._assertExpression(
      (expected !== actual),
      message || 'Failed refutation.',
      'Expected %o to be !== to %o.', actual, expected
    );
  }

  function assertIn(property, object, message) {
    this._assertExpression(
      (property in object),
      message || 'Failed assertion.',
      'Expected "%s" to be a property of %o.', property, object
    );
  }

  function refuteIn(property, object, message) {
    this._assertExpression(
      !(property in object),
      message || 'Failed refutation.',
      'Expected "%s" to not be a property of %o.', property, object
    );
  }

  return {
    _assertExpression: _assertExpression,
    skip: skip,
    assert: assert,
    refute: refute,
    assertNot: refute,
    assertTrue: assertTrue,
    assertNull: assertNull,
    assertUndefined: assertUndefined,
    assertFalse: assertFalse,
    assertIdentical: assertIdentical,
    refuteIdentical: refuteIdentical,
    assertEqual: assertEqual,
    refuteEqual: refuteEqual,
    assertIn: assertIn,
    refuteIn: refuteIn,
    fail: fail,
    flunk: fail
  };
})();
  Evidence.Assertions = Assertions;
function TestCase(methodName) {
  this._methodName = methodName;
  this.name = methodName;
}

(function() {
  function extend(name, methods) {
    function TestCaseSubclass(methodName) {
      TestCase.call(this, methodName);
    }

    if (!methods) {
      methods = name;
      name = getNameFromFile();
    }

    chain(TestCaseSubclass, this);
    TestCaseSubclass.displayName = name;
    TestCaseSubclass.extend = extend;

    for(var prop in methods) {
      TestCaseSubclass.prototype[prop] = methods[prop];
    }
    TestCase.subclasses.push(TestCaseSubclass);
    return TestCaseSubclass;
  }

  function AssertionsMixin() {}
  AssertionsMixin.prototype = Assertions;
  TestCase.prototype = new AssertionsMixin();
  TestCase.constructor = TestCase;

  TestCase.displayName = 'TestCase';
  TestCase.extend      = extend;
  TestCase.subclasses  = [];
  TestCase.defaultTimeout = 10000;
})();

(function(p) {
  function run(result) {
    if (result) { this._result = result; }
    try {
      if (this._nextAssertions) {
        this._result.restartTest(this);
        this._nextAssertions(this);
      } else {
        /*this._globalProperties = objectKeys(global);*/
        this._result.startTest(this);
        this.setUp(this);
        this[this._methodName](this);
      }
    } catch(e) {
      this._filterException(e);
    } finally {
      if (this._paused) {
        this._result.pauseTest(this);
      } else {
        try {
          this.tearDown(this);
        } catch(e) {
          this._filterException(e);
        } finally {
          this._nextAssertions = null;
          this._result.stopTest(this);
          defer(function() {
            this.parent.next();
          }, this);
        }
      }
    }
  }

  function _filterException(e) {
    var name = e.name;
    switch(name) {
      case 'AssertionFailedError':
        this._result.addFailure(this, e);
        break;
      case 'AssertionSkippedError':
        this._result.addSkip(this, e);
        break;
      default:
        this._result.addError(this, e + ('stack' in e ? "\n"+e.stack : ''));
    }
  }

  function pause(assertions) {
    this._paused = true;
    var self = this;
    if (assertions) { this._nextAssertions = assertions; }
    self._timeoutId = global.setTimeout(function() {
      self.resume(function() {
        self.fail('Test timed out. Testing was not resumed after being paused.');
      });
    }, TestCase.defaultTimeout);
  }

  function resume(assertions) {
    if (this._paused) { // avoid race conditions
      this._paused = false;
      global.clearTimeout(this._timeoutId);
      if (assertions) { this._nextAssertions = assertions; }
      this.run();
    }
  }

  function size() {
    return 1;
  }

  function toString() {
    return this.constructor.displayName + '#' + this.name;
  }

  function addAssertion() {
    this._result.addAssertion();
  }

  p.run              = run;
  p.addAssertion     = addAssertion;
  p._filterException = _filterException;
  p.pause            = pause;
  p.resume           = resume;
  p.size             = size;
  p.toString         = toString;
  p.setUp            = function() {};
  p.tearDown         = function() {};
})(TestCase.prototype);
  Evidence.TestCase = TestCase;
function TestSuite(name, tests) {
  this.name = name;
  this._tests = [];
  if (tests) {
    this.push.apply(this, tests);
  }
}

TestSuite.displayName = 'TestSuite';

(function(p) {
  function run(result) {
    this._index = 0;
    this._result = result;
    result.startSuite(this);
    this.next();
    return result;
  }

  function next() {
    var next = this._tests[this._index];
    if (next) {
      this._index++;
      next.run(this._result);
    } else {
      this._result.stopSuite(this);
      if (this.parent) {
        this.parent.next();
      } else {
        this._result.stop(new Date());
      }
    }
  }

  function push() {
    for (var i = 0, length = arguments.length; i < length; i++) {
      var test = arguments[i];
      test.parent = this;
      this._tests.push(test);
    }
  }

  function addTest(test) {
    test.parent = this;
    this._tests.push(test);
  }

  function addTests(tests) {
    for (var i = 0, length = tests.length; i < length; i++) {
      this.addTest(tests[i]);
    }
  }

  function size() {
    var tests  = this._tests,
        length = tests.length,
        sum    = 0;

    for (var i = 0; i < length; i++) {
      sum += tests[i].size();
    }
    return sum;
  }

  function isEmpty() {
    return this.size() === 0;
  }

  function toString() {
    return this.name;
  }
  p.run  = run;
  p.next = next;
  p.push = push;
  p.size = size;
  p.isEmpty = isEmpty;
  p.toString = toString;
})(TestSuite.prototype);
  Evidence.TestSuite = TestSuite;
function TestRunner() {
}

TestRunner.displayName = 'TestRunner';

(function(p) {
  function run(suite) {
    suite.parent = null;
    var result = this._makeResult();
    result.start(new Date());
    suite.run(result);
    return result;
  }

  function _makeResult() {
    return new TestResult();
  }

  p.run = run;
  p._makeResult = _makeResult;
})(TestRunner.prototype);
  Evidence.TestRunner = TestRunner;
function TestLoader() {
}

TestLoader.displayName = 'TestLoader';

(function(p) {
  function loadTestsFromTestCase(testcaseClass) {
    var suite = new TestSuite(testcaseClass.displayName),
        props = this.getTestCaseNames(testcaseClass);
    for (var i=0; i < props.length; i++) {
      suite.push(new testcaseClass(props[i]));
    }
    return suite;
  }

  function loadTestsFromTestCases(testcases) {
    var suite = new TestSuite(getNameFromFile());
    for (var i = 0; i < testcases.length; i++) {
      var testcase = testcases[i];
      var subSuite = defaultLoader.loadTestsFromTestCase(testcase);
      if (!subSuite.isEmpty()) { suite.push(subSuite); }
    }
    return suite;
  }

  function getTestCaseNames(testcaseClass) {
    var results = [],
        proto = testcaseClass.prototype,
        prefix = this.testMethodPrefix;

    for (var property in proto) {
      if (property.indexOf(prefix) === 0) {
        results.push(property);
      }
    }
    return results.sort();
  }

  function loadRegisteredTestCases() {
    return loadTestsFromTestCases(TestCase.subclasses);
  }

  p.loadTestsFromTestCase = loadTestsFromTestCase;
  p.loadRegisteredTestCases = loadRegisteredTestCases;
  p.loadTestsFromTestCases = loadTestsFromTestCases;
  p.testMethodPrefix = 'test';
  p.getTestCaseNames = getTestCaseNames;

})(TestLoader.prototype);
  Evidence.TestLoader = TestLoader;
function AutoRunner() {
  if (global.console && global.console.log) {
    this.logger = Logger;
  } else if (Object.prototype.toString.call(global.environment) === '[object Environment]' && global.print) {
    this.logger = CommandLineLogger;
  } else {
    this.logger = PopupLogger;
  }
  this.autoRun   = true;
  this.verbosity = Logger.INFO;
  this.runner    = ConsoleTestRunner;
}

(function() {
  function run(options) {
    var autoRunner = new this();
    options = options || autoRunner.retrieveOptions();
    autoRunner.processOptions(options);
    if (autoRunner.autoRun) { autoRunner.run() };
  }

  AutoRunner.run = run;
  AutoRunner.displayName = 'AutoRunner';
  AutoRunner.LOGGERS = {
    console:      Logger,
    popup:        PopupLogger,
    command_line: CommandLineLogger
  };

  AutoRunner.RUNNERS = {
    console: ConsoleTestRunner
  };
})();

(function(p) {
  function run() {
    var logger = new this.logger(this.verbosity),
        runner = new this.runner(logger),
        suite = defaultLoader.loadRegisteredTestCases();
    if (suite._tests.length <= 1) {
      suite = suite._tests[0];
    }
    return runner.run(suite);
  }

  function processQueryString(str) {
    var results = {};
    str = (str + '').match(/^(?:[^?#]*\?)([^#]+?)(?:#.*)?$/);
    str = str && str[1];

    if (!str) { return results; }

    var pairs = str.split('&'),
        length = pairs.length;
    if (!length) { return results; }

    for (var i = 0; i < length; i++) {
      var pair  = pairs[i].split('='),
          key   = decodeURIComponent(pair[0]),
          value = pair[1];
      value = value ? decodeURIComponent(value) : true;
      results[key] = value;
    }
    return results;
  }

  function processArguments(args) { // RHINO
    var results = {};

    for (var i = 0; i < args.length; i++) {
      var arg = args[i];
      if (arg.indexOf('-') === 0) {
        var value = args[i + 1];
        if (value && value.indexOf('-') !== 0) {
          i++;
        } else {
          value = true;
        }
        results[arg.substr(1)] = value;
      }
    }
    return results;
  }

  function retrieveOptions() {
    if (global.location) {
      return this.processQueryString(global.location);
    }
    if (global.arguments) {
      return this.processArguments(global.arguments);
    }
    return {};
  }

  function processOptions(options) {
    for(var key in options) {
      var value = options[key];
      switch(key) {
        case 'timeout':
          TestCase.defaultTimeout = global.parseFloat(value) * 1000;
          break;
        case 'run':
          this.autoRun = value === 'false' ? false : true;
          break;
        case 'logger':
          this.logger = AutoRunner.LOGGERS[value];
          break;
        case 'verbosity':
          var i = global.parseInt(value);
          this.verbosity = global.isNaN(i) ? Logger[value] : i;
          break;
        case 'runner':
          this.runner = AutoRunner.RUNNERS[value];
          break;
      }
    }
  }

  p.run = run;
  p.processQueryString = processQueryString;
  p.processArguments = processArguments;
  p.retrieveOptions = retrieveOptions;
  p.processOptions = processOptions;
})(AutoRunner.prototype);
  Evidence.AutoRunner = AutoRunner;
function TestResult() {
  this.testCount      = 0;
  this.assertionCount = 0;
  this.skipCount      = 0;
  this.skips          = [];
  this.failureCount   = 0;
  this.failures       = [];
  this.errors         = [];
  this.errorCount     = 0;
  this.testCount      = 0;
}

TestResult.displayName = 'TestResult';

(function(p) {
  function addAssertion() {
    this.assertionCount++;
  }

  function addSkip(testcase, reason) {
    this.skipCount++;
    this.skips.push(reason);
  }

  function addFailure(testcase, reason) {
    this.failureCount++;
    this.failures.push(reason);
  }

  function addError(testcase, error) {
    this.errorCount++;
    this.errors.push(error);
  }

  function startTest(testcase) {
    this.testCount++;
  }

  function stopTest(testcase) {}

  function pauseTest(testcase) {}

  function restartTest(testcase) {}

  function startSuite(suite) {}

  function stopSuite(suite) {}

  function start(t0) {
    this.t0 = t0;
  }

  function stop(t1) {
    this.t1 = t1;
  }

  function toString() {
    return this.testCount      + ' tests, ' +
           this.assertionCount + ' assertions, ' +
           this.failureCount   + ' failures, ' +
           this.errorCount     + ' errors, ' +
           this.skipCount      + ' skips';
  }

  p.addAssertion  = addAssertion;
  p.addSkip       = addSkip;
  p.addFailure    = addFailure;
  p.addError      = addError;
  p.startTest     = startTest;
  p.stopTest      = stopTest;
  p.pauseTest     = pauseTest;
  p.restartTest   = restartTest;
  p.startSuite    = startSuite;
  p.stopSuite     = stopSuite;
  p.start         = start;
  p.stop          = stop;
  p.toString      = toString;
})(TestResult.prototype);
  Evidence.TestResult = TestResult;
var Console = {};

function Logger(level) {
  if (typeof level !== 'undefined') {
    this.level = level;
  }
}

Logger.displayName = 'Logger';
Logger.LEVELS = ['NOTSET', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'];
Logger.CRITICAL = 5;
Logger.ERROR    = 4;
Logger.WARN     = 3;
Logger.INFO     = 2;
Logger.DEBUG    = 1;
Logger.NOTSET   = 0;

(function(p) {
  function critical(template, params) {
    this.log(Logger.CRITICAL, template, params);
  }

  function error(template, params) {
    this.log(Logger.ERROR, template, params);
  }

  function warn(template, params) {
    this.log(Logger.WARN, template, params);
  }

  function info(template, params) {
    this.log(Logger.INFO, template, params);
  }

  function debug(template, params) {
    this.log(Logger.DEBUG, template, params);
  }

  function log(level, template, params) {
    level = level || Logger.NOTSET;
    var c = global.console;

    var method = Logger.LEVELS[level].toLowerCase();
    if (method === 'critical') { method = 'error'; }
    method = (method in c) ? method : 'log';

    if (level >= this.level) {
      if (params) {
        params = params.slice(0);
        params.unshift(template);
        c[method].apply(c, params);
      } else {
        c[method](template);
      }
    }
  }

  p.log      = log;
  p.critical = critical;
  p.error    = error;
  p.warn     = warn;
  p.info     = info;
  p.debug    = debug;
  p.level    = 0;
})(Logger.prototype);
Console.Logger = Logger;
function PopupLogger(level) {
  Logger.call(this, level);
}

chain(PopupLogger, Logger);
PopupLogger.displayName = 'PopupLogger';

(function(p) {
  var BASIC_STYLES = 'color: #333; background-color: #fff; font-family: monospace; border-bottom: 1px solid #ccc;';
  var STYLES = {
    WARN:     'color: #000; background-color: #fc6;',
    ERROR:    'color: #f00; background-color: #fcc;',
    CRITICAL: 'color: #fff; background-color: #000;'
  };

  function _cleanup(html) {
    return html.replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&').replace(/[\n\r]+/, '<br />');
  }

  function _makePopup() {
    var popup = global.open('','popup','height=400,width=400');
    var doc = popup.document;
    doc.write('<!doctype html>\
               <html lang="en">\
                 <head>\
                   <meta charset="utf-8">\
                   <title>Console</title>\
                 </head>\
                 <body><div id="evidence_console"></div></body>\
               </html>');
    doc.close();
    popup.focus();
    return popup;
  }

  function _appendLine(level, msg) {
    this.popup = this.popup || this._makePopup();
    var levelName = Logger.LEVELS[level];

    var html = '<div style="';
    html += BASIC_STYLES;
    html += STYLES[levelName] || '';
    html += '">';
    if (level > Logger.INFO) {
      html += '<span style="font-weight: bold;">';
      html += levelName;
      html += ':</span> ';
    }
    html += _cleanup(msg);
    html += '</div>';
    var doc = this.popup.document,
        div = doc.createElement('div');
    div.innerHTML = html;
    html = div.firstChild;
    div = null;
    doc.getElementById('evidence_console').appendChild(html);
  }

  function log(level, msg, params) {
    level = level || Logger.NOTSET;
    if (level >= this.level) {
      if (params) {
        msg = UI.printf(msg, params);
      }
      this._appendLine(level, msg);
    }
  }

  p.log = log;
  p._makePopup = _makePopup;
  p._appendLine = _appendLine;
})(PopupLogger.prototype);
Console.PopupLogger = PopupLogger;
function CommandLineLogger(level) {
  Logger.call(this, level);
}

chain(CommandLineLogger, Logger);
CommandLineLogger.displayName = 'CommandLineLogger';

(function(p) {

  function log(level, msg, params) {
    level = level || Logger.NOTSET;
    if (level >= this.level) {
      var prefix = '';
      if (level > Logger.INFO) {
        prefix = Logger.LEVELS[level]+ ': ';
      }
      if (params) {
        msg = UI.printf(msg, params);
      }
      global.print(prefix + msg);
    }
  }

  p.log = log;
})(CommandLineLogger.prototype);
Console.CommandLineLogger = CommandLineLogger;
function ConsoleTestRunner(logger) {
  TestRunner.call(this);
  this.logger = logger;
}

chain(ConsoleTestRunner, TestRunner);
ConsoleTestRunner.displayName = 'ConsoleTestRunner';

(function(p) {
  function _makeResult() {
    return new ConsoleTestResult(this.logger);
  }

  p._makeResult = _makeResult;
})(ConsoleTestRunner.prototype);
Console.TestRunner = ConsoleTestRunner;
function ConsoleTestResult(logger) {
  TestResult.call(this);
  this.logger = logger;
}

chain(ConsoleTestResult, TestResult);
ConsoleTestResult.displayName = 'ConsoleTestResult';

(function(p) {
  var _super = TestResult.prototype;

  function addAssertion() {
    this.assertionCount++;
  }

  function addSkip(testcase, msg) {
    _super.addSkip.call(this, testcase, msg);
    this.logger.warn('Skipping testcase ' + testcase + ': ' + msg.message);
  }

  function addFailure(testcase, msg) {
    _super.addFailure.call(this, testcase, msg);
    this.logger.error(testcase + ': ' + msg.message + ' ' + msg.template, msg.args);
  }

  function addError(testcase, error) {
    _super.addError.call(this, testcase, error);
    this.logger.error(testcase + ' threw an error. ' + error);
  }

  function startTest(testcase) {
    _super.startTest.call(this, testcase);
    this.logger.debug('Started testcase ' + testcase + '.');
  }

  function stopTest(testcase) {
    this.logger.debug('Completed testcase ' + testcase + '.');
  }

  function pauseTest(testcase) {
    this.logger.info('Paused testcase ' + testcase + '.');
  }

  function restartTest(testcase) {
    this.logger.info('Restarted testcase ' + testcase + '.');
  }

  function startSuite(suite) {
    this.logger.info('Started suite ' + suite + '.');
  }

  function stopSuite(suite) {
    this.logger.info('Completed suite ' + suite + '.');
  }

  function start(t0) {
    _super.start.call(this, t0);
    this.logger.info('Started tests.');
  }

  function stop(t1) {
    _super.stop.call(this, t1);
    this.logger.info('Completed tests in ' + ((t1 - this.t0)/1000) + 's.');
    this.logger.info(this.toString() + '.');
  }

  p.addAssertion  = addAssertion;
  p.addSkip       = addSkip;
  p.addFailure    = addFailure;
  p.addError      = addError;
  p.startTest     = startTest;
  p.stopTest      = stopTest;
  p.pauseTest     = pauseTest;
  p.restartTest   = restartTest;
  p.startSuite    = startSuite;
  p.stopSuite     = stopSuite;
  p.start         = start;
  p.stop          = stop;
})(ConsoleTestResult.prototype);


Console.TestResult = ConsoleTestResult;
var UI = (function() {
  function printf(template, args, inspector) {
    var parts = [], m,
        regexp = /(^%|.%)([a-zA-Z])/,
        args = args.slice(0); // clone args

    inspector = inspector || String;

    if (template.length <= 0) {
      return '';
    }
    while (m = regexp.exec(template)) {
      var match = m[0], index = m.index, type, arg;

      if (match.indexOf('%%') === 0) {
        parts.push(template.substr(0, index));
        parts.push(match.substr(1));
      } else {
        parts.push(template.substr(0, match.indexOf('%' === 0) ? index + 1 : index));
        type = m[2];
        arg = args.shift();
        arg = inspector(arg, type);
        parts.push(arg);
      }
      template = template.substr(index + match.length);
    }
    parts.push(template);
    return parts.join('');
  }

   return {
     printf: printf,
     Console: Console
   };
})();
  Evidence.UI = UI;

  var defaultLoader = new TestLoader();
  Evidence.defaultLoader = defaultLoader;

  global.Evidence = Evidence;

  if (global.location) {
    global.onload = function() {
      if (typeof originalOnload === 'function') {
        originalOnload.call(global);
      }
      AutoRunner.run();
    };
  } else if (global.arguments) {
    var runtime = java.lang.Runtime.getRuntime();
    var thread = new java.lang.Thread(function() {
      AutoRunner.run();
    });
    runtime.addShutdownHook(thread);
  }

})(this);