deku 0.1.0

data/deps/node_modules/deku/LICENSE.md

@@ -0,0 +1,7 @@
+The MIT License (MIT) Copyright (c) 2015 Anthony Short
+
+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.

data/deps/node_modules/deku/Makefile

@@ -0,0 +1,91 @@
+
+#
+# Binaries.
+#
+
+export PATH := ./node_modules/.bin:${PATH}
+BIN := ./node_modules/.bin
+
+#
+# Wildcards.
+#
+
+lib = $(shell find lib/*.js)
+js = $(shell find lib/*.js test/*.js)
+
+#
+# Default.
+#
+
+default: index.js
+
+#
+# Targets.
+#
+
+build.js: node_modules $(js)
+	@browserify test/index.js -t babelify > build.js
+
+tests.js: node_modules $(js)
+	@browserify test/index.js -t babelify | bfc > tests.js
+
+index.js: node_modules $(js)
+	@browserify -s deku lib/index.js | bfc > index.js
+
+#
+# Tests.
+#
+
+test: build.js
+	@$(BIN)/duo-test browser --commands 'make build.js'
+
+test-phantom:
+	@$(BIN)/mochify --transform babelify --ui bdd ./test/index.js
+.PHONY: test
+
+test-cloud: tests.js
+	@TRAVIS_BUILD_NUMBER=$(CIRCLE_BUILD_NUM) zuul -- tests.js
+
+test-lint: $(lib)
+	@$(BIN)/standard lib/*
+.PHONY: test-lint
+
+test-watch:
+	@$(BIN)/mochify --watch
+.PHONY: watch
+
+test-coverage:
+	@$(BIN)/mochify --cover
+.PHONY: coverage
+
+test-size: index.js
+	$(BIN)/minify index.js | gzip -9 | wc -c
+.PHONY: test-size
+
+#
+# Tasks.
+#
+
+node_modules: package.json
+	@npm install
+
+clean:
+	@-rm -rf build.js index.js tests.js
+.PHONY: clean
+
+distclean: clean
+	@-rm -rf components node_modules
+.PHONY: distclean
+
+#
+# Releases.
+#
+
+release: clean index.js
+	bump $$VERSION && \
+	git changelog --tag $$VERSION && \
+	git commit --all -m "Release $$VERSION" && \
+	git tag $$VERSION && \
+	git push origin master --tags && \
+	npm publish
+.PHONY: release

data/deps/node_modules/deku/README.md

@@ -0,0 +1,293 @@
+<h1 align="center">
+	<br>
+	<img width="237" src="http://f.cl.ly/items/1s0T2Z3F2z190M1x1x1Y/deku-logo.png" alt="got">
+	<br>
+	<br>
+	<br>
+</h1>
+
+[![version](https://img.shields.io/npm/v/deku.svg?style=flat-square)](https://www.npmjs.com/package/deku) [![Circle CI](https://img.shields.io/circleci/project/BrightFlair/PHP.Gt.svg?style=flat-square)](https://circleci.com/gh/segmentio/deku) [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)
+
+A library for creating UI components using virtual DOM as an alternative to [React](https://github.com/facebook/react). Deku has a smaller footprint (~10kb), a functional API, and doesn't support legacy browsers.
+
+To install:
+
+```
+npm install deku
+```
+
+>  You can also use Duo, Bower or [download the files manually](https://github.com/segmentio/deku/releases).
+
+[Components](https://github.com/segmentio/deku/blob/master/docs/guides/components.md) are just plain objects that have a render function instead of using classes or constructors:
+
+```js
+// button.js
+let propTypes = {
+  kind: {
+    type: 'string',
+    expects: ['submit', 'button']
+  }
+}
+
+function render (component) {
+  let {props, state} = component
+  return <button class="Button" type={props.kind}>{props.children}</button>
+}
+
+function afterUpdate (component, prevProps, prevState, setState) {
+  let {props, state} = component
+  if (!state.clicked) {
+    setState({ clicked: true })
+  }
+}
+
+export default {propTypes, render, afterUpdate}
+```
+
+Components are then rendered by mounting it in a tree:
+
+```js
+import Button from './button'
+import {tree,render,renderString} from 'deku'
+
+let app = tree(
+  <Button kind="submit">Hello World!</Button>
+)
+
+render(app, document.body)
+```
+
+Trees can be rendered on the server too:
+
+```js
+let str = renderString(app)
+```
+
+## Docs
+
+* [Installing](https://github.com/segmentio/deku/blob/master/docs/guides/install.md)
+* [Component Spec](https://github.com/segmentio/deku/blob/master/docs/guides/components.md)
+* [Using JSX](https://github.com/segmentio/deku/blob/master/docs/guides/jsx.md)
+
+## Components
+
+Each element of your UI can be broken into encapsulated components. These components manage the state for the UI element and tell it how to render. In Deku components are just plain objects:
+
+```js
+function render (component) {
+  let {props, state} = component
+  return <button class="Button">{props.children}</button>
+}
+
+export default {render}
+```
+
+There is no concept of classes or use of `this`. We can import this component using the standard module syntax:
+
+```js
+import Button from './button'
+```
+
+[Read more about components](https://github.com/segmentio/deku/blob/master/docs/guides/components.md)
+
+## Rendering Components
+
+To render this to the DOM we need to create a `tree`. This is one of the other main differences between React and Deku. The `tree` will manage loading data, communicating between components and allows us to use plugins on the entire application.
+
+```js
+import {element,tree} from 'deku'
+var app = tree(<Button>Hello World</Button>)
+```
+
+The `app` object has only a couple of methods:
+
+* `.set(name, value)` to set environment data
+* `.option(name, value)` to set rendering options
+* `.mount(vnode)` to change the virtual element currently mounted
+* `.use(fn)` to use a plugin. The function is called with the `app` object.
+
+You can render this tree anyway you like, you just need a renderer for it. Let's use the DOM renderer for the client:
+
+```js
+import Button from './button'
+import {element,tree,render} from 'deku'
+
+var app = tree(<Button>Hello World</Button>)
+render(app, document.body)
+```
+
+And render the same thing to a string on the server:
+
+```js
+import koa from 'koa'
+import {element,tree,renderString} from 'deku'
+
+let app = koa()
+
+app.use(function *() {
+  this.body = renderString(tree(<Button>Hello World</Button>))
+})
+```
+
+And you can isolate functionality by using plugins. These plugins can call `set` to add data to the tree that your components can then access through their props:
+
+```js
+app.use(analytics)
+app.use(router)
+app.use(api(writeKey))
+```
+
+## Composition
+
+You can compose components easily by just requiring them and using them in the render function:
+
+```js
+import Button from './button'
+import Sheet from './sheet'
+
+function render (component) {
+  return (
+    <div class="MyCoolApp">
+      <Sheet>
+        <Button style="danger">One</Button>
+        <Button style="happy">Two</Button>
+      </Sheet>
+    </div>
+  )
+}
+```
+
+## Event handlers
+
+Deku doesn't use any form of synthetic events because we can just capture every event in newer browsers. There are special attributes you can add to virtual elements that act as hooks to add event listeners:
+
+```js
+function render (component) {
+  let {props, state} = component
+  return <button onClick={clicked}>{props.children}</button>
+}
+
+function clicked () {
+  alert('You clicked it')
+}
+```
+
+You can [view all event handlers](https://github.com/segmentio/deku/blob/master/lib/render.js#L25) in code.
+
+## Lifecycle hooks
+
+Just like the `render` function, component lifecycle hooks are just plain functions:
+
+```js
+function afterUpdate (component, prevProps, prevState, setState) {
+  let {props, state} = component
+  if (!state.clicked) {
+    setState({ clicked: true })
+  }
+}
+```
+
+We have hooks for `beforeMount`, `afterMount`, `beforeUpdate`, `afterUpdate`, `beforeUnmount` and two new hooks - `beforeRender` and `afterRender` that are called on every pass, unlike the update hooks. We've found that these extra hooks have allowed us to write cleaner code and worry less about the state of the component.
+
+[Learn more about the lifecycle hooks](https://github.com/segmentio/deku/blob/master/docs/guides/components.md)
+
+## Validation
+
+You can validate the props sent to your component by defining a `propTypes` object:
+
+```js
+let propTypes = {
+  style: {
+    type: 'string',
+    expects: ['submit', 'button']
+  },
+  danger: {
+    type: 'boolean',
+    optional: true
+  }
+}
+```
+
+To enable validation you just need to enable it on the tree:
+
+```js
+app.option('validateProps', true)
+```
+
+This is off by default and we've made it an option so that you can enable it just during development without needing a separate build.
+
+Props can originate from anywhere in the outside world, it's useful to validate them. When validation is enabled you'll only be able to pass in props that are defined and they must conform to the `propTypes` spec.
+
+## External data and communication
+
+It's often useful for components to have access to data from the outside world without needing to pass it down through components. You can set data on your `tree` and components can ask for it using `propTypes`.
+
+First we set some data on the app:
+
+```js
+app.set('currentUser', {
+  id: 12435,
+  username: 'anthonyshort',
+  name: 'Anthony Short'
+})
+```
+
+Then in our components we define the prop using the `source` option:
+
+```js
+let propTypes = {
+  user: {
+    source: 'currentUser'
+  }
+}
+```
+
+Whenever we change that value in our app all components that depend on it will be re-rendered with the latest value. We use this pattern to pass functions down to interact with the API:
+
+```js
+app.set('updateProject', function (project, updates) {
+  api.projects.update(project, updates)
+})
+```
+
+Which the component can access using `props.updateProject`. Although it may not be as complex or optimized as Relay and GraphQL it's extremely simple and covers most use cases we've run into so far. We even use this pattern to treat the router as a data source:
+
+```js
+router.on('/projects/:id', function (params) {
+  let project = api.projects.get(params.id)
+  app.set('currentRoute', {
+    name: 'view project',
+    project: project
+  })
+})
+```
+
+This means we don't need to use some complex routing library. We just treat it like all other types of external data and components will render as needed.
+
+## Keys
+
+Sometimes when you're rendering a list of items you want them to be moved instead of trashed during the diff. Deku supports this using the `key` attribute on components:
+
+```js
+function render (component) {
+  let {items} = component.props
+  let projects = items.map(function (project) {
+    return <ProjectItem key={project.id} project={project} />
+  })
+  return <div class="ProjectsList">{projects}</div>
+}
+```
+
+At the moment we only support the `key` attribute on components for simplicity. Things become slightly more hairy when moving elements around within components. So far we haven't ran into a case where this has been a major problem.
+
+## Tests
+
+[![Sauce Test Status](https://saucelabs.com/browser-matrix/deku.svg)](https://saucelabs.com/u/deku)
+
+## Developing
+
+Deku is built with Browserify. You can run the tests in a browser by running `make test`.
+
+## License
+
+MIT. See [LICENSE.md](http://github.com/segmentio/deku/blob/master/LICENSE.md)

data/deps/node_modules/deku/index.js

@@ -0,0 +1,4072 @@
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.deku=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _require=="function"&&_require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _require=="function"&&_require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_require,module,exports){
+/**
+ * Module dependencies.
+ */
+
+var Emitter = _require('component-emitter')
+
+/**
+ * Expose `scene`.
+ */
+
+module.exports = Application
+
+/**
+ * Create a new `Application`.
+ *
+ * @param {Object} element Optional initial element
+ */
+
+function Application (element) {
+  if (!(this instanceof Application)) return new Application(element)
+  this.options = {}
+  this.sources = {}
+  this.element = element
+}
+
+/**
+ * Mixin `Emitter`.
+ */
+
+Emitter(Application.prototype)
+
+/**
+ * Add a plugin
+ *
+ * @param {Function} plugin
+ */
+
+Application.prototype.use = function (plugin) {
+  plugin(this)
+  return this
+}
+
+/**
+ * Set an option
+ *
+ * @param {String} name
+ */
+
+Application.prototype.option = function (name, val) {
+  this.options[name] = val
+  return this
+}
+
+/**
+ * Set value used somewhere in the IO network.
+ */
+
+Application.prototype.set = function (name, data) {
+  this.sources[name] = data
+  this.emit('source', name, data)
+  return this
+}
+
+/**
+ * Mount a virtual element.
+ *
+ * @param {VirtualElement} element
+ */
+
+Application.prototype.mount = function (element) {
+  this.element = element
+  this.emit('mount', element)
+  return this
+}
+
+/**
+ * Remove the world. Unmount everything.
+ */
+
+Application.prototype.unmount = function () {
+  if (!this.element) return
+  this.element = null
+  this.emit('unmount')
+  return this
+}
+
+},{"component-emitter":9}],2:[function(_require,module,exports){
+/**
+ * Create the application.
+ */
+
+exports.tree =
+exports.scene =
+exports.deku = _require('./application')
+
+/**
+ * Render scenes to the DOM.
+ */
+
+if (typeof document !== 'undefined') {
+  exports.render = _require('./render')
+}
+
+/**
+ * Render scenes to a string
+ */
+
+exports.renderString = _require('./stringify')
+
+/**
+ * Create virtual elements.
+ */
+
+exports.element =
+exports.dom = _require('./virtual')
+
+},{"./application":1,"./render":3,"./stringify":4,"./virtual":7}],3:[function(_require,module,exports){
+/**
+ * Dependencies.
+ */
+
+var raf = _require('component-raf')
+var Pool = _require('dom-pool')
+var walk = _require('dom-walk')
+var isDom = _require('is-dom')
+var uid = _require('get-uid')
+var throttle = _require('per-frame')
+var keypath = _require('object-path')
+var type = _require('component-type')
+var fast = _require('fast.js')
+var utils = _require('./utils')
+var svg = _require('./svg')
+var defaults = utils.defaults
+var forEach = fast.forEach
+var assign = fast.assign
+var reduce = fast.reduce
+
+/**
+ * All of the events can bind to
+ */
+
+var events = {
+  onBlur: 'blur',
+  onChange: 'change',
+  onClick: 'click',
+  onContextMenu: 'contextmenu',
+  onCopy: 'copy',
+  onCut: 'cut',
+  onDoubleClick: 'dblclick',
+  onDrag: 'drag',
+  onDragEnd: 'dragend',
+  onDragEnter: 'dragenter',
+  onDragExit: 'dragexit',
+  onDragLeave: 'dragleave',
+  onDragOver: 'dragover',
+  onDragStart: 'dragstart',
+  onDrop: 'drop',
+  onFocus: 'focus',
+  onInput: 'input',
+  onKeyDown: 'keydown',
+  onKeyUp: 'keyup',
+  onMouseDown: 'mousedown',
+  onMouseMove: 'mousemove',
+  onMouseOut: 'mouseout',
+  onMouseOver: 'mouseover',
+  onMouseUp: 'mouseup',
+  onPaste: 'paste',
+  onScroll: 'scroll',
+  onSubmit: 'submit',
+  onTouchCancel: 'touchcancel',
+  onTouchEnd: 'touchend',
+  onTouchMove: 'touchmove',
+  onTouchStart: 'touchstart'
+}
+
+/**
+ * These elements won't be pooled
+ */
+
+var avoidPooling = ['input', 'textarea'];
+
+/**
+ * Expose `dom`.
+ */
+
+module.exports = render
+
+/**
+ * Render an app to the DOM
+ *
+ * @param {Application} app
+ * @param {HTMLElement} container
+ * @param {Object} opts
+ *
+ * @return {Object}
+ */
+
+function render (app, container, opts) {
+  var frameId
+  var isRendering
+  var rootId = 'root'
+  var currentElement
+  var currentNativeElement
+  var connections = {}
+  var entities = {}
+  var pools = {}
+  var handlers = {}
+  var children = {}
+  children[rootId] = {}
+
+  if (!isDom(container)) {
+    throw new Error('Container element must be a DOM element')
+  }
+
+  /**
+   * Rendering options. Batching is only ever really disabled
+   * when running tests, and pooling can be disabled if the user
+   * is doing something stupid with the DOM in their components.
+   */
+
+  var options = defaults(assign({}, app.options || {}, opts || {}), {
+    pooling: true,
+    batching: true,
+    validateProps: false
+  })
+
+  /**
+   * Listen to DOM events
+   */
+
+  addNativeEventListeners()
+
+  /**
+   * Watch for changes to the app so that we can update
+   * the DOM as needed.
+   */
+
+  app.on('unmount', onunmount)
+  app.on('mount', onmount)
+  app.on('source', onupdate)
+
+  /**
+   * If the app has already mounted an element, we can just
+   * render that straight away.
+   */
+
+  if (app.element) render()
+
+  /**
+   * Teardown the DOM rendering so that it stops
+   * rendering and everything can be garbage collected.
+   */
+
+  function teardown () {
+    removeNativeEventListeners()
+    removeNativeElement()
+    app.off('unmount', onunmount)
+    app.off('mount', onmount)
+    app.off('source', onupdate)
+  }
+
+  /**
+   * Swap the current rendered node with a new one that is rendered
+   * from the new virtual element mounted on the app.
+   *
+   * @param {VirtualElement} element
+   */
+
+  function onmount () {
+    invalidate()
+  }
+
+  /**
+   * If the app unmounts an element, we should clear out the current
+   * rendered element. This will remove all the entities.
+   */
+
+  function onunmount () {
+    removeNativeElement()
+    currentElement = null
+  }
+
+  /**
+   * Update all components that are bound to the source
+   *
+   * @param {String} name
+   * @param {*} data
+   */
+
+  function onupdate (name, data) {
+    connections[name](data)
+  }
+
+  /**
+   * Render and mount a component to the native dom.
+   *
+   * @param {Entity} entity
+   * @return {HTMLElement}
+   */
+
+  function mountEntity (entity) {
+    register(entity)
+    setSources(entity)
+    children[entity.id] = {}
+    entities[entity.id] = entity
+
+    // commit initial state and props.
+    commit(entity)
+
+    // callback before mounting.
+    trigger('beforeMount', entity, [entity.context])
+    trigger('beforeRender', entity, [entity.context])
+
+    // render virtual element.
+    var virtualElement = renderEntity(entity)
+    // create native element.
+    var nativeElement = toNative(entity.id, '0', virtualElement)
+
+    entity.virtualElement = virtualElement
+    entity.nativeElement = nativeElement
+
+    // callback after mounting.
+    trigger('afterRender', entity, [entity.context, nativeElement])
+    trigger('afterMount', entity, [entity.context, nativeElement, setState(entity)])
+
+    return nativeElement
+  }
+
+  /**
+   * Remove a component from the native dom.
+   *
+   * @param {Entity} entity
+   */
+
+  function unmountEntity (entityId) {
+    var entity = entities[entityId]
+    if (!entity) return
+    trigger('beforeUnmount', entity, [entity.context, entity.nativeElement])
+    unmountChildren(entityId)
+    removeAllEvents(entityId)
+    delete entities[entityId]
+    delete children[entityId]
+  }
+
+  /**
+   * Render the entity and make sure it returns a node
+   *
+   * @param {Entity} entity
+   *
+   * @return {VirtualTree}
+   */
+
+  function renderEntity (entity) {
+    var component = entity.component
+    if (!component.render) throw new Error('Component needs a render function')
+    var result = component.render(entity.context, setState(entity))
+    if (!result) throw new Error('Render function must return an element.')
+    return result
+  }
+
+  /**
+   * Whenever setState or setProps is called, we mark the entity
+   * as dirty in the renderer. This lets us optimize the re-rendering
+   * and skip components that definitely haven't changed.
+   *
+   * @param {Entity} entity
+   *
+   * @return {Function} A curried function for updating the state of an entity
+   */
+
+  function setState (entity) {
+    return function (nextState) {
+      updateEntityState(entity, nextState)
+    }
+  }
+
+  /**
+   * Tell the app it's dirty and needs to re-render. If batching is disabled
+   * we can just trigger a render immediately, otherwise we'll wait until
+   * the next available frame.
+   */
+
+  function invalidate () {
+    if (!options.batching) {
+      if (!isRendering) render()
+    } else {
+      if (!frameId) frameId = raf(render)
+    }
+  }
+
+  /**
+   * Update the DOM. If the update fails we stop the loop
+   * so we don't get errors on every frame.
+   *
+   * @api public
+   */
+
+  function render () {
+    // If this is called synchronously we need to
+    // cancel any pending future updates
+    clearFrame()
+
+    // If the rendering from the previous frame is still going,
+    // we'll just wait until the next frame. Ideally renders should
+    // not take over 16ms to stay within a single frame, but this should
+    // catch it if it does.
+    if (isRendering) {
+      frameId = raf(render)
+      return
+    } else {
+      isRendering = true
+    }
+
+    // 1. If there isn't a native element rendered for the current mounted element
+    // then we need to create it from scratch.
+    // 2. If a new element has been mounted, we should diff them.
+    // 3. We should update check all child components for changes.
+    if (!currentNativeElement) {
+      currentElement = app.element
+      currentNativeElement = toNative(rootId, '0', currentElement)
+      container.appendChild(currentNativeElement)
+    } else if (currentElement !== app.element) {
+      currentNativeElement = patch(rootId, currentElement, app.element, currentNativeElement)
+      currentElement = app.element
+      updateChildren(rootId)
+    } else {
+      updateChildren(rootId)
+    }
+
+    // Allow rendering again.
+    isRendering = false
+  }
+
+  /**
+   * Clear the current scheduled frame
+   */
+
+  function clearFrame () {
+    if (!frameId) return
+    raf.cancel(frameId)
+    frameId = 0
+  }
+
+  /**
+   * Update a component.
+   *
+   * The entity is just the data object for a component instance.
+   *
+   * @param {String} id Component instance id.
+   */
+
+  function updateEntity (entityId) {
+    var entity = entities[entityId]
+    setSources(entity)
+
+    if (!shouldUpdate(entity)) return updateChildren(entityId)
+
+    var currentTree = entity.virtualElement
+    var nextProps = entity.pendingProps
+    var nextState = entity.pendingState
+    var previousState = entity.context.state
+    var previousProps = entity.context.props
+
+    // hook before rendering. could modify state just before the render occurs.
+    trigger('beforeUpdate', entity, [entity.context, nextProps, nextState])
+    trigger('beforeRender', entity, [entity.context])
+
+    // commit state and props.
+    commit(entity)
+
+    // re-render.
+    var nextTree = renderEntity(entity)
+
+    // if the tree is the same we can just skip this component
+    // but we should still check the children to see if they're dirty.
+    // This allows us to memoize the render function of components.
+    if (nextTree === currentTree) return updateChildren(entityId)
+
+    // apply new virtual tree to native dom.
+    entity.nativeElement = patch(entityId, currentTree, nextTree, entity.nativeElement)
+    entity.virtualElement = nextTree
+    updateChildren(entityId)
+
+    // trigger render hook
+    trigger('afterRender', entity, [entity.context, entity.nativeElement])
+
+    // trigger afterUpdate after all children have updated.
+    trigger('afterUpdate', entity, [entity.context, previousProps, previousState, setState(entity)])
+  }
+
+  /**
+   * Update all the children of an entity.
+   *
+   * @param {String} id Component instance id.
+   */
+
+  function updateChildren (entityId) {
+    forEach(children[entityId], function (childId) {
+      updateEntity(childId)
+    })
+  }
+
+  /**
+   * Remove all of the child entities of an entity
+   *
+   * @param {Entity} entity
+   */
+
+  function unmountChildren (entityId) {
+    forEach(children[entityId], function (childId) {
+      unmountEntity(childId)
+    })
+  }
+
+  /**
+   * Remove the root element. If this is called synchronously we need to
+   * cancel any pending future updates.
+   */
+
+  function removeNativeElement () {
+    clearFrame()
+    removeElement(rootId, '0', currentNativeElement)
+    currentNativeElement = null
+  }
+
+  /**
+   * Create a native element from a virtual element.
+   *
+   * @param {String} entityId
+   * @param {String} path
+   * @param {Object} vnode
+   *
+   * @return {HTMLDocumentFragment}
+   */
+
+  function toNative (entityId, path, vnode) {
+    switch (vnode.type) {
+      case 'text': return toNativeText(vnode)
+      case 'element': return toNativeElement(entityId, path, vnode)
+      case 'component': return toNativeComponent(entityId, path, vnode)
+    }
+  }
+
+  /**
+   * Create a native text element from a virtual element.
+   *
+   * @param {Object} vnode
+   */
+
+  function toNativeText (vnode) {
+    return document.createTextNode(vnode.data)
+  }
+
+  /**
+   * Create a native element from a virtual element.
+   */
+
+  function toNativeElement (entityId, path, vnode) {
+    var attributes = vnode.attributes
+    var children = vnode.children
+    var tagName = vnode.tagName
+    var el
+
+    // create element either from pool or fresh.
+    if (!options.pooling || !canPool(tagName)) {
+      if (svg.isElement(tagName)) {
+        el = document.createElementNS(svg.namespace, tagName)
+      } else {
+        el = document.createElement(tagName)
+      }
+    } else {
+      var pool = getPool(tagName)
+      el = cleanup(pool.pop())
+      if (el.parentNode) el.parentNode.removeChild(el)
+    }
+
+    // set attributes.
+    forEach(attributes, function (value, name) {
+      setAttribute(entityId, path, el, name, value)
+    })
+
+    // store keys on the native element for fast event handling.
+    el.__entity__ = entityId
+    el.__path__ = path
+
+    // add children.
+    forEach(children, function (child, i) {
+      var childEl = toNative(entityId, path + '.' + i, child)
+      if (!childEl.parentNode) el.appendChild(childEl)
+    })
+
+    return el
+  }
+
+  /**
+   * Create a native element from a component.
+   */
+
+  function toNativeComponent (entityId, path, vnode) {
+    var child = new Entity(vnode.component, vnode.props)
+    children[entityId][path] = child.id
+    return mountEntity(child)
+  }
+
+  /**
+   * Patch an element with the diff from two trees.
+   */
+
+  function patch (entityId, prev, next, el) {
+    return diffNode('0', entityId, prev, next, el)
+  }
+
+  /**
+   * Create a diff between two tress of nodes.
+   */
+
+  function diffNode (path, entityId, prev, next, el) {
+    // Type changed. This could be from element->text, text->ComponentA,
+    // ComponentA->ComponentB etc. But NOT div->span. These are the same type
+    // (ElementNode) but different tag name.
+    if (prev.type !== next.type) return replaceElement(entityId, path, el, next)
+
+    switch (next.type) {
+      case 'text': return diffText(prev, next, el)
+      case 'element': return diffElement(path, entityId, prev, next, el)
+      case 'component': return diffComponent(path, entityId, prev, next, el)
+    }
+  }
+
+  /**
+   * Diff two text nodes and update the element.
+   */
+
+  function diffText (previous, current, el) {
+    if (current.data !== previous.data) el.data = current.data
+    return el
+  }
+
+  /**
+   * Diff the children of an ElementNode.
+   */
+
+  function diffChildren (path, entityId, prev, next, el) {
+    var positions = []
+    var hasKeys = false
+    var childNodes = Array.prototype.slice.apply(el.childNodes)
+    var leftKeys = reduce(prev.children, keyMapReducer, {})
+    var rightKeys = reduce(next.children, keyMapReducer, {})
+    var currentChildren = assign({}, children[entityId])
+
+    function keyMapReducer (acc, child) {
+      if (child.key != null) {
+        acc[child.key] = child
+        hasKeys = true
+      }
+      return acc
+    }
+
+    // Diff all of the nodes that have keys. This lets us re-used elements
+    // instead of overriding them and lets us move them around.
+    if (hasKeys) {
+
+      // Removals
+      forEach(leftKeys, function (leftNode, key) {
+        if (rightKeys[key] == null) {
+          var leftPath = path + '.' + leftNode.index
+          removeElement(
+            entityId,
+            leftPath,
+            childNodes[leftNode.index]
+          )
+        }
+      })
+
+      // Update nodes
+      forEach(rightKeys, function (rightNode, key) {
+        var leftNode = leftKeys[key]
+
+        // We only want updates for now
+        if (leftNode == null) return
+
+        var leftPath = path + '.' + leftNode.index
+
+        // Updated
+        positions[rightNode.index] = diffNode(
+          leftPath,
+          entityId,
+          leftNode,
+          rightNode,
+          childNodes[leftNode.index]
+        )
+      })
+
+      // Update the positions of all child components and event handlers
+      forEach(rightKeys, function (rightNode, key) {
+        var leftNode = leftKeys[key]
+
+        // We just want elements that have moved around
+        if (leftNode == null || leftNode.index === rightNode.index) return
+
+        var rightPath = path + '.' + rightNode.index
+        var leftPath = path + '.' + leftNode.index
+
+        // Update all the child component path positions to match
+        // the latest positions if they've changed. This is a bit hacky.
+        forEach(currentChildren, function (childId, childPath) {
+          if (leftPath === childPath) {
+            delete children[entityId][childPath]
+            children[entityId][rightPath] = childId
+          }
+        })
+      })
+
+      // Now add all of the new nodes last in case their path
+      // would have conflicted with one of the previous paths.
+      forEach(rightKeys, function (rightNode, key) {
+        var rightPath = path + '.' + rightNode.index
+        if (leftKeys[key] == null) {
+          positions[rightNode.index] = toNative(
+            entityId,
+            rightPath,
+            rightNode
+          )
+        }
+      })
+
+    } else {
+      var maxLength = Math.max(prev.children.length, next.children.length)
+
+      // Now diff all of the nodes that don't have keys
+      for (var i = 0; i < maxLength; i++) {
+        var leftNode = prev.children[i]
+        var rightNode = next.children[i]
+
+        // Removals
+        if (rightNode == null) {
+          removeElement(
+            entityId,
+            path + '.' + leftNode.index,
+            childNodes[leftNode.index]
+          )
+        }
+
+        // New Node
+        if (leftNode == null) {
+          positions[rightNode.index] = toNative(
+            entityId,
+            path + '.' + rightNode.index,
+            rightNode
+          )
+        }
+
+        // Updated
+        if (leftNode && rightNode) {
+          positions[leftNode.index] = diffNode(
+            path + '.' + leftNode.index,
+            entityId,
+            leftNode,
+            rightNode,
+            childNodes[leftNode.index]
+          )
+        }
+      }
+    }
+
+    // Reposition all the elements
+    forEach(positions, function (childEl, newPosition) {
+      var target = el.childNodes[newPosition]
+      if (childEl !== target) {
+        if (target) {
+          el.insertBefore(childEl, target)
+        } else {
+          el.appendChild(childEl)
+        }
+      }
+    })
+  }
+
+  /**
+   * Diff the attributes and add/remove them.
+   */
+
+  function diffAttributes (prev, next, el, entityId, path) {
+    var nextAttrs = next.attributes
+    var prevAttrs = prev.attributes
+
+    // add new attrs
+    forEach(nextAttrs, function (value, name) {
+      if (events[name] || !(name in prevAttrs) || prevAttrs[name] !== value) {
+        setAttribute(entityId, path, el, name, value)
+      }
+    })
+
+    // remove old attrs
+    forEach(prevAttrs, function (value, name) {
+      if (!(name in nextAttrs)) {
+        removeAttribute(entityId, path, el, name)
+      }
+    })
+  }
+
+  /**
+   * Update a component with the props from the next node. If
+   * the component type has changed, we'll just remove the old one
+   * and replace it with the new component.
+   */
+
+  function diffComponent (path, entityId, prev, next, el) {
+    if (next.component !== prev.component) {
+      return replaceElement(entityId, path, el, next)
+    } else {
+      var targetId = children[entityId][path]
+
+      // This is a hack for now
+      if (targetId) {
+        updateEntityProps(targetId, next.props)
+      }
+
+      return el
+    }
+  }
+
+  /**
+   * Diff two element nodes.
+   */
+
+  function diffElement (path, entityId, prev, next, el) {
+    if (next.tagName !== prev.tagName) return replaceElement(entityId, path, el, next)
+    diffAttributes(prev, next, el, entityId, path)
+    diffChildren(path, entityId, prev, next, el)
+    return el
+  }
+
+  /**
+   * Removes an element from the DOM and unmounts and components
+   * that are within that branch
+   *
+   * side effects:
+   *   - removes element from the DOM
+   *   - removes internal references
+   *
+   * @param {String} entityId
+   * @param {String} path
+   * @param {HTMLElement} el
+   */
+
+  function removeElement (entityId, path, el) {
+    var childrenByPath = children[entityId]
+    var childId = childrenByPath[path]
+    var entityHandlers = handlers[entityId] || {}
+    var removals = []
+
+    // If the path points to a component we should use that
+    // components element instead, because it might have moved it.
+    if (childId) {
+      var child = entities[childId]
+      el = child.nativeElement
+      unmountEntity(childId)
+      removals.push(path)
+    } else {
+
+      // Just remove the text node
+      if (!isElement(el)) return el.parentNode.removeChild(el)
+
+      // Then we need to find any components within this
+      // branch and unmount them.
+      forEach(childrenByPath, function (childId, childPath) {
+        if (childPath === path || isWithinPath(path, childPath)) {
+          unmountEntity(childId)
+          removals.push(childPath)
+        }
+      })
+
+      // Remove all events at this path or below it
+      forEach(entityHandlers, function (fn, handlerPath) {
+        if (handlerPath === path || isWithinPath(path, handlerPath)) {
+          removeEvent(entityId, handlerPath)
+        }
+      })
+    }
+
+    // Remove the paths from the object without touching the
+    // old object. This keeps the object using fast properties.
+    forEach(removals, function (path) {
+      delete children[entityId][path]
+    })
+
+    // Remove it from the DOM
+    el.parentNode.removeChild(el)
+
+    // Return all of the elements in this node tree to the pool
+    // so that the elements can be re-used.
+    if (options.pooling) {
+      walk(el, function (node) {
+        if (!isElement(node) || !canPool(node.tagName)) return
+        getPool(node.tagName.toLowerCase()).push(node)
+      })
+    }
+  }
+
+  /**
+   * Replace an element in the DOM. Removing all components
+   * within that element and re-rendering the new virtual node.
+   *
+   * @param {Entity} entity
+   * @param {String} path
+   * @param {HTMLElement} el
+   * @param {Object} vnode
+   *
+   * @return {void}
+   */
+
+  function replaceElement (entityId, path, el, vnode) {
+    var parent = el.parentNode
+    var index = Array.prototype.indexOf.call(parent.childNodes, el)
+
+    // remove the previous element and all nested components. This
+    // needs to happen before we create the new element so we don't
+    // get clashes on the component paths.
+    removeElement(entityId, path, el)
+
+    // then add the new element in there
+    var newEl = toNative(entityId, path, vnode)
+    var target = parent.childNodes[index]
+
+    if (target) {
+      parent.insertBefore(newEl, target)
+    } else {
+      parent.appendChild(newEl)
+    }
+
+    // update all `entity.nativeElement` references.
+    forEach(entities, function (entity) {
+      if (entity.nativeElement === el) {
+        entity.nativeElement = newEl
+      }
+    })
+
+    return newEl
+  }
+
+  /**
+   * Set the attribute of an element, performing additional transformations
+   * dependning on the attribute name
+   *
+   * @param {HTMLElement} el
+   * @param {String} name
+   * @param {String} value
+   */
+
+  function setAttribute (entityId, path, el, name, value) {
+    if (events[name]) {
+      addEvent(entityId, path, events[name], value)
+      return
+    }
+    switch (name) {
+      case 'value':
+        el.value = value
+        break
+      case 'innerHTML':
+        el.innerHTML = value
+        break
+      case svg.isAttribute(name):
+        el.setAttributeNS(svg.namespace, name, value)
+        break
+      default:
+        el.setAttribute(name, value)
+        break
+    }
+  }
+
+  /**
+   * Remove an attribute, performing additional transformations
+   * dependning on the attribute name
+   *
+   * @param {HTMLElement} el
+   * @param {String} name
+   */
+
+  function removeAttribute (entityId, path, el, name) {
+    if (events[name]) {
+      removeEvent(entityId, path, events[name])
+      return
+    }
+    el.removeAttribute(name)
+  }
+
+  /**
+   * Checks to see if one tree path is within
+   * another tree path. Example:
+   *
+   * 0.1 vs 0.1.1 = true
+   * 0.2 vs 0.3.5 = false
+   *
+   * @param {String} target
+   * @param {String} path
+   *
+   * @return {Boolean}
+   */
+
+  function isWithinPath (target, path) {
+    return path.indexOf(target + '.') === 0
+  }
+
+  /**
+   * Is the DOM node an element node
+   *
+   * @param {HTMLElement} el
+   *
+   * @return {Boolean}
+   */
+
+  function isElement (el) {
+    return !!el.tagName
+  }
+
+  /**
+   * Get the pool for a tagName, creating it if it
+   * doesn't exist.
+   *
+   * @param {String} tagName
+   *
+   * @return {Pool}
+   */
+
+  function getPool (tagName) {
+    var pool = pools[tagName]
+    if (!pool) {
+      var poolOpts = svg.isElement(tagName) ?
+        { namespace: svg.namespace, tagName: tagName } :
+        { tagName: tagName }
+      pool = pools[tagName] = new Pool(poolOpts)
+    }
+    return pool
+  }
+
+  /**
+   * Clean up previously used native element for reuse.
+   *
+   * @param {HTMLElement} el
+   */
+
+  function cleanup (el) {
+    removeAllChildren(el)
+    removeAllAttributes(el)
+    return el
+  }
+
+  /**
+   * Remove all the attributes from a node
+   *
+   * @param {HTMLElement} el
+   */
+
+  function removeAllAttributes (el) {
+    for (var i = el.attributes.length - 1; i >= 0; i--) {
+      var name = el.attributes[i].name
+      el.removeAttribute(name)
+    }
+  }
+
+  /**
+   * Remove all the child nodes from an element
+   *
+   * @param {HTMLElement} el
+   */
+
+  function removeAllChildren (el) {
+    while (el.firstChild) el.removeChild(el.firstChild)
+  }
+
+  /**
+   * Trigger a hook on a component.
+   *
+   * @param {String} name Name of hook.
+   * @param {Entity} entity The component instance.
+   * @param {Array} args To pass along to hook.
+   */
+
+  function trigger (name, entity, args) {
+    if (typeof entity.component[name] !== 'function') return
+    entity.component[name].apply(null, args)
+  }
+
+  /**
+   * Update an entity to match the latest rendered vode. We always
+   * replace the props on the component when composing them. This
+   * will trigger a re-render on all children below this point.
+   *
+   * @param {Entity} entity
+   * @param {String} path
+   * @param {Object} vnode
+   *
+   * @return {void}
+   */
+
+  function updateEntityProps (entityId, nextProps) {
+    var entity = entities[entityId]
+    entity.pendingProps = nextProps
+    entity.dirty = true
+    invalidate()
+  }
+
+  /**
+   * Update component instance state.
+   */
+
+  function updateEntityState (entity, nextState) {
+    entity.pendingState = assign(entity.pendingState, nextState)
+    entity.dirty = true
+    invalidate()
+  }
+
+  /**
+   * Commit props and state changes to an entity.
+   */
+
+  function commit (entity) {
+    entity.context = {
+      state: entity.pendingState,
+      props: entity.pendingProps,
+      id: entity.id
+    }
+    entity.pendingState = assign({}, entity.context.state)
+    entity.pendingProps = assign({}, entity.context.props)
+    validateProps(entity.context.props, entity.propTypes)
+    entity.dirty = false
+  }
+
+  /**
+   * Try to avoid creating new virtual dom if possible.
+   *
+   * Later we may expose this so you can override, but not there yet.
+   */
+
+  function shouldUpdate (entity) {
+    if (!entity.dirty) return false
+    if (!entity.component.shouldUpdate) return true
+    var nextProps = entity.pendingProps
+    var nextState = entity.pendingState
+    var bool = entity.component.shouldUpdate(entity.context, nextProps, nextState)
+    return bool
+  }
+
+  /**
+   * Register an entity.
+   *
+   * This is mostly to pre-preprocess component properties and values chains.
+   *
+   * The end result is for every component that gets mounted,
+   * you create a set of IO nodes in the network from the `value` definitions.
+   *
+   * @param {Component} component
+   */
+
+  function register (entity) {
+    var component = entity.component
+    // all entities for this component type.
+    var entities = component.entities = component.entities || {}
+    // add entity to component list
+    entities[entity.id] = entity
+
+    // get 'class-level' sources.
+    var sources = component.sources
+    if (sources) return
+
+    var map = component.sourceToPropertyName = {}
+    component.sources = sources = []
+    var propTypes = component.propTypes
+    for (var name in propTypes) {
+      var data = propTypes[name]
+      if (!data) continue
+      if (!data.source) continue
+      sources.push(data.source)
+      map[data.source] = name
+    }
+
+    // send value updates to all component instances.
+    sources.forEach(function (source) {
+      connections[source] = update
+
+      function update (data) {
+        var prop = map[source]
+        for (var entityId in entities) {
+          var entity = entities[entityId]
+          var changes = {}
+          changes[prop] = data
+          updateEntityProps(entityId, assign(entity.pendingProps, changes))
+        }
+      }
+    })
+  }
+
+  /**
+   * Set the initial source value on the entity
+   *
+   * @param {Entity} entity
+   */
+
+  function setSources (entity) {
+    var component = entity.component
+    var map = component.sourceToPropertyName
+    var sources = component.sources
+    sources.forEach(function (source) {
+      var name = map[source]
+      if (entity.pendingProps[name] != null) return
+      entity.pendingProps[name] = app.sources[source] // get latest value plugged into global store
+    })
+  }
+
+  /**
+   * Add all of the DOM event listeners
+   */
+
+  function addNativeEventListeners () {
+    forEach(events, function (eventType) {
+      document.body.addEventListener(eventType, handleEvent, true)
+    })
+  }
+
+  /**
+   * Add all of the DOM event listeners
+   */
+
+  function removeNativeEventListeners () {
+    forEach(events, function (eventType) {
+      document.body.removeEventListener(eventType, handleEvent, true)
+    })
+  }
+
+  /**
+   * Handle an event that has occured within the container
+   *
+   * @param {Event} event
+   */
+
+  function handleEvent (event) {
+    var target = event.target
+    var entityId = target.__entity__
+    var eventType = event.type
+
+    // Walk up the DOM tree and see if there is a handler
+    // for this event type higher up.
+    while (target && target.__entity__ === entityId) {
+      var fn = keypath.get(handlers, [entityId, target.__path__, eventType])
+      if (fn) {
+        event.delegateTarget = target
+        fn(event)
+        break
+      }
+      target = target.parentNode
+    }
+  }
+
+  /**
+   * Bind events for an element, and all it's rendered child elements.
+   *
+   * @param {String} path
+   * @param {String} event
+   * @param {Function} fn
+   */
+
+  function addEvent (entityId, path, eventType, fn) {
+    keypath.set(handlers, [entityId, path, eventType], throttle(function (e) {
+      var entity = entities[entityId]
+      if (entity) {
+        fn.call(null, e, entity.context, setState(entity))
+      } else {
+        fn.call(null, e)
+      }
+    }))
+  }
+
+  /**
+   * Unbind events for a entityId
+   *
+   * @param {String} entityId
+   */
+
+  function removeEvent (entityId, path, eventType) {
+    var args = [entityId]
+    if (path) args.push(path)
+    if (eventType) args.push(eventType)
+    keypath.del(handlers, args)
+  }
+
+  /**
+   * Unbind all events from an entity
+   *
+   * @param {Entity} entity
+   */
+
+  function removeAllEvents (entityId) {
+    keypath.del(handlers, [entityId])
+  }
+
+  /**
+   * Validate the current properties. These simple validations
+   * make it easier to ensure the correct props are passed in.
+   *
+   * Available rules include:
+   *
+   * type: string | array | object | boolean | number | date | function
+   * expects: [] An array of values this prop could equal
+   * optional: Boolean
+   */
+
+  function validateProps (props, rules) {
+    if (!options.validateProps) return
+
+    // TODO: Only validate in dev mode
+    forEach(rules, function (options, name) {
+      if (name === 'children') return
+      var value = props[name]
+      var optional = (options.optional === true)
+      if (optional && value == null) {
+        return
+      }
+      if (!optional && value == null) {
+        throw new Error('Missing prop named: ' + name)
+      }
+      if (options.type && type(value) !== options.type) {
+        throw new Error('Invalid type for prop named: ' + name)
+      }
+      if (options.expects && options.expects.indexOf(value) < 0) {
+        throw new Error('Invalid value for prop named: ' + name + '. Must be one of ' + options.expects.toString())
+      }
+    })
+
+    // Now check for props that haven't been defined
+    forEach(props, function (value, key) {
+      if (key === 'children') return
+      if (!rules[key]) throw new Error('Unexpected prop named: ' + key)
+    })
+  }
+
+  /**
+   * Used for debugging to inspect the current state without
+   * us needing to explicitly manage storing/updating references.
+   *
+   * @return {Object}
+   */
+
+  function inspect () {
+    return {
+      entities: entities,
+      pools: pools,
+      handlers: handlers,
+      connections: connections,
+      currentElement: currentElement,
+      options: options,
+      app: app,
+      container: container,
+      children: children
+    }
+  }
+
+  /**
+   * Return an object that lets us completely remove the automatic
+   * DOM rendering and export debugging tools.
+   */
+
+  return {
+    remove: teardown,
+    inspect: inspect
+  }
+}
+
+/**
+ * A rendered component instance.
+ *
+ * This manages the lifecycle, props and state of the component.
+ * It's basically just a data object for more straightfoward lookup.
+ *
+ * @param {Component} component
+ * @param {Object} props
+ */
+
+function Entity (component, props) {
+  this.id = uid()
+  this.component = component
+  this.propTypes = component.propTypes || {}
+  this.context = {}
+  this.context.id = this.id;
+  this.context.props = defaults(props || {}, component.defaultProps || {})
+  this.context.state = this.component.initialState ? this.component.initialState() : {}
+  this.pendingProps = assign({}, this.context.props)
+  this.pendingState = assign({}, this.context.state)
+  this.dirty = false
+  this.virtualElement = null
+  this.nativeElement = null
+  this.displayName = component.name || 'Component'
+}
+
+/**
+ * Should we pool an element?
+ */
+
+function canPool(tagName) {
+  return avoidPooling.indexOf(tagName) < 0
+}
+
+/**
+ * Get a nested node using a path
+ *
+ * @param {HTMLElement} el   The root node '0'
+ * @param {String} path The path string eg. '0.2.43'
+ */
+
+function getNodeAtPath(el, path) {
+  var parts = path.split('.')
+  parts.shift()
+  while (parts.length) {
+    el = el.childNodes[parts.pop()]
+  }
+  return el
+}
+
+},{"./svg":5,"./utils":6,"component-raf":10,"component-type":11,"dom-pool":12,"dom-walk":13,"fast.js":41,"get-uid":57,"is-dom":58,"object-path":59,"per-frame":60}],4:[function(_require,module,exports){
+var utils = _require('./utils')
+var defaults = utils.defaults
+
+/**
+ * Expose `stringify`.
+ */
+
+module.exports = function (app) {
+  if (!app.element) {
+    throw new Error('No element mounted')
+  }
+
+  /**
+   * Render to string.
+   *
+   * @param {Component} component
+   * @param {Object} [props]
+   * @return {String}
+   */
+
+  function stringify (component, optProps) {
+    var propTypes = component.propTypes || {}
+    var state = component.initialState ? component.initialState() : {}
+    var props = defaults(optProps, component.defaultProps || {})
+
+    for (var name in propTypes) {
+      var options = propTypes[name]
+      if (options.source) {
+        props[name] = app.sources[options.source]
+      }
+    }
+
+    if (component.beforeMount) component.beforeMount({ props: props, state: state })
+    if (component.beforeRender) component.beforeRender({ props: props, state: state })
+    var node = component.render({ props: props, state: state })
+    return stringifyNode(node, '0')
+  }
+
+  /**
+   * Render a node to a string
+   *
+   * @param {Node} node
+   * @param {Tree} tree
+   *
+   * @return {String}
+   */
+
+  function stringifyNode (node, path) {
+    switch (node.type) {
+      case 'text': return node.data
+      case 'element':
+        var children = node.children
+        var attributes = node.attributes
+        var tagName = node.tagName
+        var innerHTML = attributes.innerHTML
+        var str = '<' + tagName + attrs(attributes) + '>'
+
+        if (innerHTML) {
+          str += innerHTML
+        } else {
+          for (var i = 0, n = children.length; i < n; i++) {
+            str += stringifyNode(children[i], path + '.' + i)
+          }
+        }
+
+        str += '</' + tagName + '>'
+        return str
+      case 'component': return stringify(node.component, node.props)
+    }
+
+    throw new Error('Invalid type')
+  }
+
+  return stringifyNode(app.element, '0')
+}
+
+/**
+ * HTML attributes to string.
+ *
+ * @param {Object} attributes
+ * @return {String}
+ * @api private
+ */
+
+function attrs (attributes) {
+  var str = ''
+  for (var key in attributes) {
+    if (key === 'innerHTML') continue
+    str += attr(key, attributes[key])
+  }
+  return str
+}
+
+/**
+ * HTML attribute to string.
+ *
+ * @param {String} key
+ * @param {String} val
+ * @return {String}
+ * @api private
+ */
+
+function attr (key, val) {
+  return ' ' + key + '="' + val + '"'
+}
+
+},{"./utils":6}],5:[function(_require,module,exports){
+var fast = _require('fast.js')
+var indexOf = fast.indexOf
+
+/**
+ * This file lists the supported SVG elements used by the
+ * renderer. We may add better SVG support in the future
+ * that doesn't require whitelisting elements.
+ */
+
+exports.namespace  = 'http://www.w3.org/2000/svg'
+
+/**
+ * Supported SVG elements
+ *
+ * @type {Array}
+ */
+
+exports.elements = [
+  'circle',
+  'defs',
+  'ellipse',
+  'g',
+  'line',
+  'linearGradient',
+  'mask',
+  'path',
+  'pattern',
+  'polygon',
+  'polyline',
+  'radialGradient',
+  'rect',
+  'stop',
+  'svg',
+  'text',
+  'tspan'
+]
+
+/**
+ * Supported SVG attributes
+ */
+
+exports.attributes = [
+  'cx',
+  'cy',
+  'd',
+  'dx',
+  'dy',
+  'fill',
+  'fillOpacity',
+  'fontFamily',
+  'fontSize',
+  'fx',
+  'fy',
+  'gradientTransform',
+  'gradientUnits',
+  'markerEnd',
+  'markerMid',
+  'markerStart',
+  'offset',
+  'opacity',
+  'patternContentUnits',
+  'patternUnits',
+  'points',
+  'preserveAspectRatio',
+  'r',
+  'rx',
+  'ry',
+  'spreadMethod',
+  'stopColor',
+  'stopOpacity',
+  'stroke',
+  'strokeDasharray',
+  'strokeLinecap',
+  'strokeOpacity',
+  'strokeWidth',
+  'textAnchor',
+  'transform',
+  'version',
+  'viewBox',
+  'x1',
+  'x2',
+  'x',
+  'y1',
+  'y2',
+  'y'
+]
+
+/**
+ * Is element's namespace SVG?
+ *
+ * @param {String} name
+ */
+
+exports.isElement = function (name) {
+  return indexOf(exports.elements, name) !== -1
+}
+
+/**
+ * Are element's attributes SVG?
+ *
+ * @param {String} attr
+ */
+
+exports.isAttribute = function (attr) {
+  return indexOf(exports.attributes, attr) !== -1
+}
+
+
+},{"fast.js":41}],6:[function(_require,module,exports){
+/**
+ * The npm 'defaults' module but without clone because
+ * it was requiring the 'Buffer' module which is huge.
+ *
+ * @param {Object} options
+ * @param {Object} defaults
+ *
+ * @return {Object}
+ */
+
+exports.defaults = function(options, defaults) {
+  Object.keys(defaults).forEach(function(key) {
+    if (typeof options[key] === 'undefined') {
+      options[key] = defaults[key]
+    }
+  })
+  return options
+}
+
+},{}],7:[function(_require,module,exports){
+/**
+ * Module dependencies.
+ */
+
+var type = _require('component-type')
+var slice = _require('sliced')
+var flatten = _require('array-flatten')
+
+/**
+ * This function lets us create virtual nodes using a simple
+ * syntax. It is compatible with JSX transforms so you can use
+ * JSX to write nodes that will compile to this function.
+ *
+ * let node = virtual('div', { id: 'foo' }, [
+ *   virtual('a', { href: 'http://google.com' }, 'Google')
+ * ])
+ *
+ * You can leave out the attributes or the children if either
+ * of them aren't needed and it will figure out what you're
+ * trying to do.
+ */
+
+module.exports = virtual
+
+/**
+ * Create virtual DOM trees.
+ *
+ * This creates the nicer API for the user.
+ * It translates that friendly API into an actual tree of nodes.
+ *
+ * @param {String|Function} type
+ * @param {Object} props
+ * @param {Array} children
+ * @return {Node}
+ * @api public
+ */
+
+function virtual (type, props, children) {
+  // Default to div with no args
+  if (!type) {
+    throw new Error('Element needs a type. https://gist.github.com/anthonyshort/77ced43b5defe39908af')
+  }
+
+  // Skipped adding attributes and we're passing
+  // in children instead.
+  if (arguments.length === 2 && (typeof props === 'string' || Array.isArray(props))) {
+    children = props
+    props = {}
+  }
+
+  // Account for JSX putting the children as multiple arguments.
+  // This is essentially just the ES6 rest param
+  if (arguments.length > 2 && Array.isArray(arguments[2]) === false) {
+    children = slice(arguments, 2)
+  }
+
+  children = children || []
+  props = props || {}
+
+  // passing in a single child, you can skip
+  // using the array
+  if (!Array.isArray(children)) {
+    children = [ children ]
+  }
+
+  children = flatten(children, 1).reduce(normalize, [])
+
+  // pull the key out from the data.
+  var key = 'key' in props ? String(props.key) : null
+  delete props['key']
+
+  // if you pass in a function, it's a `Component` constructor.
+  // otherwise it's an element.
+  var node
+  if (typeof type === 'string') {
+    node = new ElementNode(type, props, key, children)
+  } else {
+    node = new ComponentNode(type, props, key, children)
+  }
+
+  // set the unique ID
+  node.index = 0
+
+  return node
+}
+
+/**
+ * Parse nodes into real `Node` objects.
+ *
+ * @param {Mixed} node
+ * @param {Integer} index
+ * @return {Node}
+ * @api private
+ */
+
+function normalize (acc, node) {
+  if (node == null) {
+    return acc
+  }
+  if (typeof node === 'string' || typeof node === 'number') {
+    var newNode = new TextNode(String(node))
+    newNode.index = acc.length
+    acc.push(newNode)
+  } else {
+    node.index = acc.length
+    acc.push(node)
+  }
+  return acc
+}
+
+/**
+ * Initialize a new `ComponentNode`.
+ *
+ * @param {Component} component
+ * @param {Object} props
+ * @param {String} key Used for sorting/replacing during diffing.
+ * @param {Array} children Child virtual nodes
+ * @api public
+ */
+
+function ComponentNode (component, props, key, children) {
+  this.key = key
+  this.props = props
+  this.type = 'component'
+  this.component = component
+  this.props.children = children || []
+}
+
+/**
+ * Initialize a new `ElementNode`.
+ *
+ * @param {String} tagName
+ * @param {Object} attributes
+ * @param {String} key Used for sorting/replacing during diffing.
+ * @param {Array} children Child virtual dom nodes.
+ * @api public
+ */
+
+function ElementNode (tagName, attributes, key, children) {
+  this.type = 'element'
+  this.attributes = parseAttributes(attributes)
+  this.tagName = tagName
+  this.children = children || []
+  this.key = key
+}
+
+/**
+ * Initialize a new `TextNode`.
+ *
+ * This is just a virtual HTML text object.
+ *
+ * @param {String} text
+ * @api public
+ */
+
+function TextNode (text) {
+  this.type = 'text'
+  this.data = String(text)
+}
+
+/**
+ * Parse attributes for some special cases.
+ *
+ * TODO: This could be more functional and allow hooks
+ * into the processing of the attributes at a component-level
+ *
+ * @param {Object} attributes
+ *
+ * @return {Object}
+ */
+
+function parseAttributes (attributes) {
+  // style: { 'text-align': 'left' }
+  if (attributes.style) {
+    attributes.style = parseStyle(attributes.style)
+  }
+
+  // class: { foo: true, bar: false, baz: true }
+  // class: ['foo', 'bar', 'baz']
+  if (attributes.class) {
+    attributes.class = parseClass(attributes.class)
+  }
+
+  // Remove attributes with false values
+  var filteredAttributes = {}
+  for (var key in attributes) {
+    var value = attributes[key]
+    if (value == null || value === false) continue
+    filteredAttributes[key] = value
+  }
+
+  return filteredAttributes
+}
+
+/**
+ * Parse a block of styles into a string.
+ *
+ * TODO: this could do a lot more with vendor prefixing,
+ * number values etc. Maybe there's a way to allow users
+ * to hook into this?
+ *
+ * @param {Object} styles
+ *
+ * @return {String}
+ */
+
+function parseStyle (styles) {
+  if (type(styles) === 'string') {
+    return styles
+  }
+  var str = ''
+  for (var name in styles) {
+    var value = styles[name]
+    str = str + name + ':' + value + ';'
+  }
+  return str;
+}
+
+/**
+ * Parse the class attribute so it's able to be
+ * set in a more user-friendly way
+ *
+ * @param {String|Object|Array} value
+ *
+ * @return {String}
+ */
+
+function parseClass (value) {
+  // { foo: true, bar: false, baz: true }
+  if (type(value) === 'object') {
+    var matched = []
+    for (var key in value) {
+      if (value[key]) matched.push(key)
+    }
+    value = matched
+  }
+
+  // ['foo', 'bar', 'baz']
+  if (type(value) === 'array') {
+    if (value.length === 0) {
+      return
+    }
+    value = value.join(' ')
+  }
+
+  return value
+}
+
+},{"array-flatten":8,"component-type":11,"sliced":61}],8:[function(_require,module,exports){
+/**
+ * Recursive flatten function. Fastest implementation for array flattening.
+ *
+ * @param  {Array}  array
+ * @param  {Array}  result
+ * @param  {Number} depth
+ * @return {Array}
+ */
+function flatten (array, result, depth) {
+  for (var i = 0; i < array.length; i++) {
+    if (depth > 0 && Array.isArray(array[i])) {
+      flatten(array[i], result, depth - 1);
+    } else {
+      result.push(array[i]);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Flatten an array, with the ability to define a depth.
+ *
+ * @param  {Array}  array
+ * @param  {Number} depth
+ * @return {Array}
+ */
+module.exports = function (array, depth) {
+  return flatten(array, [], depth || Infinity);
+};
+
+},{}],9:[function(_require,module,exports){
+
+/**
+ * Expose `Emitter`.
+ */
+
+module.exports = Emitter;
+
+/**
+ * Initialize a new `Emitter`.
+ *
+ * @api public
+ */
+
+function Emitter(obj) {
+  if (obj) return mixin(obj);
+};
+
+/**
+ * Mixin the emitter properties.
+ *
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
+ */
+
+function mixin(obj) {
+  for (var key in Emitter.prototype) {
+    obj[key] = Emitter.prototype[key];
+  }
+  return obj;
+}
+
+/**
+ * Listen on the given `event` with `fn`.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.on =
+Emitter.prototype.addEventListener = function(event, fn){
+  this._callbacks = this._callbacks || {};
+  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])
+    .push(fn);
+  return this;
+};
+
+/**
+ * Adds an `event` listener that will be invoked a single
+ * time then automatically removed.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.once = function(event, fn){
+  function on() {
+    this.off(event, on);
+    fn.apply(this, arguments);
+  }
+
+  on.fn = fn;
+  this.on(event, on);
+  return this;
+};
+
+/**
+ * Remove the given callback for `event` or all
+ * registered callbacks.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.off =
+Emitter.prototype.removeListener =
+Emitter.prototype.removeAllListeners =
+Emitter.prototype.removeEventListener = function(event, fn){
+  this._callbacks = this._callbacks || {};
+
+  // all
+  if (0 == arguments.length) {
+    this._callbacks = {};
+    return this;
+  }
+
+  // specific event
+  var callbacks = this._callbacks['$' + event];
+  if (!callbacks) return this;
+
+  // remove all handlers
+  if (1 == arguments.length) {
+    delete this._callbacks['$' + event];
+    return this;
+  }
+
+  // remove specific handler
+  var cb;
+  for (var i = 0; i < callbacks.length; i++) {
+    cb = callbacks[i];
+    if (cb === fn || cb.fn === fn) {
+      callbacks.splice(i, 1);
+      break;
+    }
+  }
+  return this;
+};
+
+/**
+ * Emit `event` with the given args.
+ *
+ * @param {String} event
+ * @param {Mixed} ...
+ * @return {Emitter}
+ */
+
+Emitter.prototype.emit = function(event){
+  this._callbacks = this._callbacks || {};
+  var args = [].slice.call(arguments, 1)
+    , callbacks = this._callbacks['$' + event];
+
+  if (callbacks) {
+    callbacks = callbacks.slice(0);
+    for (var i = 0, len = callbacks.length; i < len; ++i) {
+      callbacks[i].apply(this, args);
+    }
+  }
+
+  return this;
+};
+
+/**
+ * Return array of callbacks for `event`.
+ *
+ * @param {String} event
+ * @return {Array}
+ * @api public
+ */
+
+Emitter.prototype.listeners = function(event){
+  this._callbacks = this._callbacks || {};
+  return this._callbacks['$' + event] || [];
+};
+
+/**
+ * Check if this emitter has `event` handlers.
+ *
+ * @param {String} event
+ * @return {Boolean}
+ * @api public
+ */
+
+Emitter.prototype.hasListeners = function(event){
+  return !! this.listeners(event).length;
+};
+
+},{}],10:[function(_require,module,exports){
+/**
+ * Expose `requestAnimationFrame()`.
+ */
+
+exports = module.exports = window.requestAnimationFrame
+  || window.webkitRequestAnimationFrame
+  || window.mozRequestAnimationFrame
+  || fallback;
+
+/**
+ * Fallback implementation.
+ */
+
+var prev = new Date().getTime();
+function fallback(fn) {
+  var curr = new Date().getTime();
+  var ms = Math.max(0, 16 - (curr - prev));
+  var req = setTimeout(fn, ms);
+  prev = curr;
+  return req;
+}
+
+/**
+ * Cancel.
+ */
+
+var cancel = window.cancelAnimationFrame
+  || window.webkitCancelAnimationFrame
+  || window.mozCancelAnimationFrame
+  || window.clearTimeout;
+
+exports.cancel = function(id){
+  cancel.call(window, id);
+};
+
+},{}],11:[function(_require,module,exports){
+/**
+ * toString ref.
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Return the type of `val`.
+ *
+ * @param {Mixed} val
+ * @return {String}
+ * @api public
+ */
+
+module.exports = function(val){
+  switch (toString.call(val)) {
+    case '[object Date]': return 'date';
+    case '[object RegExp]': return 'regexp';
+    case '[object Arguments]': return 'arguments';
+    case '[object Array]': return 'array';
+    case '[object Error]': return 'error';
+  }
+
+  if (val === null) return 'null';
+  if (val === undefined) return 'undefined';
+  if (val !== val) return 'nan';
+  if (val && val.nodeType === 1) return 'element';
+
+  val = val.valueOf
+    ? val.valueOf()
+    : Object.prototype.valueOf.apply(val)
+
+  return typeof val;
+};
+
+},{}],12:[function(_require,module,exports){
+function Pool(params) {
+    if (typeof params !== 'object') {
+        throw new Error("Please pass parameters. Example -> new Pool({ tagName: \"div\" })");
+    }
+
+    if (typeof params.tagName !== 'string') {
+        throw new Error("Please specify a tagName. Example -> new Pool({ tagName: \"div\" })");
+    }
+
+    this.storage = [];
+    this.tagName = params.tagName.toLowerCase();
+    this.namespace = params.namespace;
+}
+
+Pool.prototype.push = function(el) {
+    if (el.tagName.toLowerCase() !== this.tagName) {
+        return;
+    }
+    
+    this.storage.push(el);
+};
+
+Pool.prototype.pop = function(argument) {
+    if (this.storage.length === 0) {
+        return this.create();
+    } else {
+        return this.storage.pop();
+    }
+};
+
+Pool.prototype.create = function() {
+    if (this.namespace) {
+        return document.createElementNS(this.namespace, this.tagName);
+    } else {
+        return document.createElement(this.tagName);
+    }
+};
+
+Pool.prototype.allocate = function(size) {
+    if (this.storage.length >= size) {
+        return;
+    }
+
+    var difference = size - this.storage.length;
+    for (var poolAllocIter = 0; poolAllocIter < difference; poolAllocIter++) {
+        this.storage.push(this.create());
+    }
+};
+
+if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+    module.exports = Pool;
+}
+
+},{}],13:[function(_require,module,exports){
+var slice = Array.prototype.slice
+
+module.exports = iterativelyWalk
+
+function iterativelyWalk(nodes, cb) {
+    if (!('length' in nodes)) {
+        nodes = [nodes]
+    }
+    
+    nodes = slice.call(nodes)
+
+    while(nodes.length) {
+        var node = nodes.shift(),
+            ret = cb(node)
+
+        if (ret) {
+            return ret
+        }
+
+        if (node.childNodes && node.childNodes.length) {
+            nodes = slice.call(node.childNodes).concat(nodes)
+        }
+    }
+}
+
+},{}],14:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Clone Array
+ *
+ * Clone an array or array like object (e.g. `arguments`).
+ * This is the equivalent of calling `Array.prototype.slice.call(arguments)`, but
+ * significantly faster.
+ *
+ * @param  {Array} input The array or array-like object to clone.
+ * @return {Array}       The cloned array.
+ */
+module.exports = function fastCloneArray (input) {
+  var length = input.length,
+      sliced = new Array(length),
+      i;
+  for (i = 0; i < length; i++) {
+    sliced[i] = input[i];
+  }
+  return sliced;
+};
+
+},{}],15:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Concat
+ *
+ * Concatenate multiple arrays.
+ *
+ * > Note: This function is effectively identical to `Array.prototype.concat()`.
+ *
+ *
+ * @param  {Array|mixed} item, ... The item(s) to concatenate.
+ * @return {Array}                 The array containing the concatenated items.
+ */
+module.exports = function fastConcat () {
+  var length = arguments.length,
+      arr = [],
+      i, item, childLength, j;
+
+  for (i = 0; i < length; i++) {
+    item = arguments[i];
+    if (Array.isArray(item)) {
+      childLength = item.length;
+      for (j = 0; j < childLength; j++) {
+        arr.push(item[j]);
+      }
+    }
+    else {
+      arr.push(item);
+    }
+  }
+  return arr;
+};
+
+},{}],16:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Every
+ *
+ * A fast `.every()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ * @return {Boolean}              true if all items in the array passes the truth test.
+ */
+module.exports = function fastEvery (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (!iterator(subject[i], i, subject)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+},{"../function/bindInternal3":35}],17:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Fill
+ * Fill an array with values, optionally starting and stopping at a given index.
+ *
+ * > Note: unlike the specced Array.prototype.fill(), this version does not support
+ * > negative start / end arguments.
+ *
+ * @param  {Array}   subject The array to fill.
+ * @param  {mixed}   value   The value to insert.
+ * @param  {Integer} start   The start position, defaults to 0.
+ * @param  {Integer} end     The end position, defaults to subject.length
+ * @return {Array}           The now filled subject.
+ */
+module.exports = function fastFill (subject, value, start, end) {
+  var length = subject.length,
+      i;
+  if (start === undefined) {
+    start = 0;
+  }
+  if (end === undefined) {
+    end = length;
+  }
+  for (i = start; i < end; i++) {
+    subject[i] = value;
+  }
+  return subject;
+};
+},{}],18:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Filter
+ *
+ * A fast `.filter()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to filter.
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter.
+ * @return {Array}                The array containing the results.
+ */
+module.exports = function fastFilter (subject, fn, thisContext) {
+  var length = subject.length,
+      result = [],
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (iterator(subject[i], i, subject)) {
+      result.push(subject[i]);
+    }
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":35}],19:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # For Each
+ *
+ * A fast `.forEach()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ */
+module.exports = function fastForEach (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    iterator(subject[i], i, subject);
+  }
+};
+
+},{"../function/bindInternal3":35}],20:[function(_require,module,exports){
+'use strict';
+
+exports.clone = _require('./clone');
+exports.concat = _require('./concat');
+exports.every = _require('./every');
+exports.filter = _require('./filter');
+exports.forEach = _require('./forEach');
+exports.indexOf = _require('./indexOf');
+exports.lastIndexOf = _require('./lastIndexOf');
+exports.map = _require('./map');
+exports.pluck = _require('./pluck');
+exports.reduce = _require('./reduce');
+exports.reduceRight = _require('./reduceRight');
+exports.some = _require('./some');
+exports.fill = _require('./fill');
+},{"./clone":14,"./concat":15,"./every":16,"./fill":17,"./filter":18,"./forEach":19,"./indexOf":21,"./lastIndexOf":22,"./map":23,"./pluck":24,"./reduce":25,"./reduceRight":26,"./some":27}],21:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Index Of
+ *
+ * A faster `Array.prototype.indexOf()` implementation.
+ *
+ * @param  {Array}  subject   The array (or array-like) to search within.
+ * @param  {mixed}  target    The target item to search for.
+ * @param  {Number} fromIndex The position to start searching from, if known.
+ * @return {Number}           The position of the target in the subject, or -1 if it does not exist.
+ */
+module.exports = function fastIndexOf (subject, target, fromIndex) {
+  var length = subject.length,
+      i = 0;
+
+  if (typeof fromIndex === 'number') {
+    i = fromIndex;
+    if (i < 0) {
+      i += length;
+      if (i < 0) {
+        i = 0;
+      }
+    }
+  }
+
+  for (; i < length; i++) {
+    if (subject[i] === target) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+},{}],22:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Last Index Of
+ *
+ * A faster `Array.prototype.lastIndexOf()` implementation.
+ *
+ * @param  {Array}  subject The array (or array-like) to search within.
+ * @param  {mixed}  target  The target item to search for.
+ * @param  {Number} fromIndex The position to start searching backwards from, if known.
+ * @return {Number}         The last position of the target in the subject, or -1 if it does not exist.
+ */
+module.exports = function fastLastIndexOf (subject, target, fromIndex) {
+  var length = subject.length,
+      i = length - 1;
+
+  if (typeof fromIndex === 'number') {
+    i = fromIndex;
+    if (i < 0) {
+      i += length;
+    }
+  }
+  for (; i >= 0; i--) {
+    if (subject[i] === target) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+},{}],23:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Map
+ *
+ * A fast `.map()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to map over.
+ * @param  {Function} fn          The mapper function.
+ * @param  {Object}   thisContext The context for the mapper.
+ * @return {Array}                The array containing the results.
+ */
+module.exports = function fastMap (subject, fn, thisContext) {
+  var length = subject.length,
+      result = new Array(length),
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    result[i] = iterator(subject[i], i, subject);
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":35}],24:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Pluck
+ * Pluck the property with the given name from an array of objects.
+ *
+ * @param  {Array}  input The values to pluck from.
+ * @param  {String} field The name of the field to pluck.
+ * @return {Array}        The plucked array of values.
+ */
+module.exports = function fastPluck (input, field) {
+  var length = input.length,
+      plucked = [],
+      count = 0,
+      value, i;
+
+  for (i = 0; i < length; i++) {
+    value = input[i];
+    if (value != null && value[field] !== undefined) {
+      plucked[count++] = value[field];
+    }
+  }
+  return plucked;
+};
+},{}],25:[function(_require,module,exports){
+'use strict';
+
+var bindInternal4 = _require('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast `.reduce()` implementation.
+ *
+ * @param  {Array}    subject      The array (or array-like) to reduce.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, result;
+
+  if (initialValue === undefined) {
+    i = 1;
+    result = subject[0];
+  }
+  else {
+    i = 0;
+    result = initialValue;
+  }
+
+  for (; i < length; i++) {
+    result = iterator(result, subject[i], i, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":36}],26:[function(_require,module,exports){
+'use strict';
+
+var bindInternal4 = _require('../function/bindInternal4');
+
+/**
+ * # Reduce Right
+ *
+ * A fast `.reduceRight()` implementation.
+ *
+ * @param  {Array}    subject      The array (or array-like) to reduce.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, result;
+
+  if (initialValue === undefined) {
+    i = length - 2;
+    result = subject[length - 1];
+  }
+  else {
+    i = length - 1;
+    result = initialValue;
+  }
+
+  for (; i >= 0; i--) {
+    result = iterator(result, subject[i], i, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":36}],27:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Some
+ *
+ * A fast `.some()` implementation.
+ *
+ * @param  {Array}    subject     The array (or array-like) to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ * @return {Boolean}              true if at least one item in the array passes the truth test.
+ */
+module.exports = function fastSome (subject, fn, thisContext) {
+  var length = subject.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i;
+  for (i = 0; i < length; i++) {
+    if (iterator(subject[i], i, subject)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+},{"../function/bindInternal3":35}],28:[function(_require,module,exports){
+'use strict';
+
+var cloneArray = _require('./array/clone');
+var cloneObject = _require('./object/clone');
+
+/**
+ * # Clone
+ *
+ * Clone an item. Primitive values will be returned directly,
+ * arrays and objects will be shallow cloned. If you know the
+ * type of input you're dealing with, call `.cloneArray()` or `.cloneObject()`
+ * instead.
+ *
+ * @param  {mixed} input The input to clone.
+ * @return {mixed}       The cloned input.
+ */
+module.exports = function clone (input) {
+  if (!input || typeof input !== 'object') {
+    return input;
+  }
+  else if (Array.isArray(input)) {
+    return cloneArray(input);
+  }
+  else {
+    return cloneObject(input);
+  }
+};
+
+},{"./array/clone":14,"./object/clone":44}],29:[function(_require,module,exports){
+'use strict';
+
+var filterArray = _require('./array/filter'),
+    filterObject = _require('./object/filter');
+
+/**
+ * # Filter
+ *
+ * A fast `.filter()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to filter.
+ * @param  {Function}     fn          The filter function.
+ * @param  {Object}       thisContext The context for the filter.
+ * @return {Array|Object}             The array or object containing the filtered results.
+ */
+module.exports = function fastFilter (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return filterArray(subject, fn, thisContext);
+  }
+  else {
+    return filterObject(subject, fn, thisContext);
+  }
+};
+},{"./array/filter":18,"./object/filter":45}],30:[function(_require,module,exports){
+'use strict';
+
+var forEachArray = _require('./array/forEach'),
+    forEachObject = _require('./object/forEach');
+
+/**
+ * # ForEach
+ *
+ * A fast `.forEach()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to iterate over.
+ * @param  {Function}     fn          The visitor function.
+ * @param  {Object}       thisContext The context for the visitor.
+ */
+module.exports = function fastForEach (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return forEachArray(subject, fn, thisContext);
+  }
+  else {
+    return forEachObject(subject, fn, thisContext);
+  }
+};
+},{"./array/forEach":19,"./object/forEach":46}],31:[function(_require,module,exports){
+'use strict';
+
+var applyWithContext = _require('./applyWithContext');
+var applyNoContext = _require('./applyNoContext');
+
+/**
+ * # Apply
+ *
+ * Faster version of `Function::apply()`, optimised for 8 arguments or fewer.
+ *
+ *
+ * @param  {Function} subject   The function to apply.
+ * @param  {Object} thisContext The context for the function, set to undefined or null if no context is required.
+ * @param  {Array} args         The arguments for the function.
+ * @return {mixed}              The result of the function invocation.
+ */
+module.exports = function fastApply (subject, thisContext, args) {
+  return thisContext !== undefined ? applyWithContext(subject, thisContext, args) : applyNoContext(subject, args);
+};
+
+},{"./applyNoContext":32,"./applyWithContext":33}],32:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Internal helper for applying a function without a context.
+ */
+module.exports = function applyNoContext (subject, args) {
+  switch (args.length) {
+    case 0:
+      return subject();
+    case 1:
+      return subject(args[0]);
+    case 2:
+      return subject(args[0], args[1]);
+    case 3:
+      return subject(args[0], args[1], args[2]);
+    case 4:
+      return subject(args[0], args[1], args[2], args[3]);
+    case 5:
+      return subject(args[0], args[1], args[2], args[3], args[4]);
+    case 6:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5]);
+    case 7:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    case 8:
+      return subject(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
+    default:
+      return subject.apply(undefined, args);
+  }
+};
+
+},{}],33:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Internal helper for applying a function with a context.
+ */
+module.exports = function applyWithContext (subject, thisContext, args) {
+  switch (args.length) {
+    case 0:
+      return subject.call(thisContext);
+    case 1:
+      return subject.call(thisContext, args[0]);
+    case 2:
+      return subject.call(thisContext, args[0], args[1]);
+    case 3:
+      return subject.call(thisContext, args[0], args[1], args[2]);
+    case 4:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3]);
+    case 5:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4]);
+    case 6:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5]);
+    case 7:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    case 8:
+      return subject.call(thisContext, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
+    default:
+      return subject.apply(thisContext, args);
+  }
+};
+
+},{}],34:[function(_require,module,exports){
+'use strict';
+
+var applyWithContext = _require('./applyWithContext');
+var applyNoContext = _require('./applyNoContext');
+
+/**
+ * # Bind
+ * Analogue of `Function::bind()`.
+ *
+ * ```js
+ * var bind = require('fast.js').bind;
+ * var bound = bind(myfunc, this, 1, 2, 3);
+ *
+ * bound(4);
+ * ```
+ *
+ *
+ * @param  {Function} fn          The function which should be bound.
+ * @param  {Object}   thisContext The context to bind the function to.
+ * @param  {mixed}    args, ...   Additional arguments to pre-bind.
+ * @return {Function}             The bound function.
+ */
+module.exports = function fastBind (fn, thisContext) {
+  var boundLength = arguments.length - 2,
+      boundArgs;
+
+  if (boundLength > 0) {
+    boundArgs = new Array(boundLength);
+    for (var i = 0; i < boundLength; i++) {
+      boundArgs[i] = arguments[i + 2];
+    }
+    if (thisContext !== undefined) {
+      return function () {
+        var length = arguments.length,
+            args = new Array(boundLength + length),
+            i;
+        for (i = 0; i < boundLength; i++) {
+          args[i] = boundArgs[i];
+        }
+        for (i = 0; i < length; i++) {
+          args[boundLength + i] = arguments[i];
+        }
+        return applyWithContext(fn, thisContext, args);
+      };
+    }
+    else {
+      return function () {
+        var length = arguments.length,
+            args = new Array(boundLength + length),
+            i;
+        for (i = 0; i < boundLength; i++) {
+          args[i] = boundArgs[i];
+        }
+        for (i = 0; i < length; i++) {
+          args[boundLength + i] = arguments[i];
+        }
+        return applyNoContext(fn, args);
+      };
+    }
+  }
+  if (thisContext !== undefined) {
+    return function () {
+      return applyWithContext(fn, thisContext, arguments);
+    };
+  }
+  else {
+    return function () {
+      return applyNoContext(fn, arguments);
+    };
+  }
+};
+
+},{"./applyNoContext":32,"./applyWithContext":33}],35:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Internal helper to bind a function known to have 3 arguments
+ * to a given context.
+ */
+module.exports = function bindInternal3 (func, thisContext) {
+  return function (a, b, c) {
+    return func.call(thisContext, a, b, c);
+  };
+};
+
+},{}],36:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Internal helper to bind a function known to have 4 arguments
+ * to a given context.
+ */
+module.exports = function bindInternal4 (func, thisContext) {
+  return function (a, b, c, d) {
+    return func.call(thisContext, a, b, c, d);
+  };
+};
+
+},{}],37:[function(_require,module,exports){
+'use strict';
+
+exports.apply = _require('./apply');
+exports.bind = _require('./bind');
+exports.partial = _require('./partial');
+exports.partialConstructor = _require('./partialConstructor');
+exports.try = _require('./try');
+
+},{"./apply":31,"./bind":34,"./partial":38,"./partialConstructor":39,"./try":40}],38:[function(_require,module,exports){
+'use strict';
+
+var applyWithContext = _require('./applyWithContext');
+
+/**
+ * # Partial Application
+ *
+ * Partially apply a function. This is similar to `.bind()`,
+ * but with one important difference - the returned function is not bound
+ * to a particular context. This makes it easy to add partially
+ * applied methods to objects. If you need to bind to a context,
+ * use `.bind()` instead.
+ *
+ * > Note: This function does not support partial application for
+ * constructors, for that see `partialConstructor()`
+ *
+ *
+ * @param  {Function} fn          The function to partially apply.
+ * @param  {mixed}    args, ...   Arguments to pre-bind.
+ * @return {Function}             The partially applied function.
+ */
+module.exports = function fastPartial (fn) {
+  var boundLength = arguments.length - 1,
+      boundArgs;
+
+  boundArgs = new Array(boundLength);
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = arguments[i + 1];
+  }
+  return function () {
+    var length = arguments.length,
+        args = new Array(boundLength + length),
+        i;
+    for (i = 0; i < boundLength; i++) {
+      args[i] = boundArgs[i];
+    }
+    for (i = 0; i < length; i++) {
+      args[boundLength + i] = arguments[i];
+    }
+    return applyWithContext(fn, this, args);
+  };
+};
+
+},{"./applyWithContext":33}],39:[function(_require,module,exports){
+'use strict';
+
+var applyWithContext = _require('./applyWithContext');
+
+/**
+ * # Partial Constructor
+ *
+ * Partially apply a constructor function. The returned function
+ * will work with or without the `new` keyword.
+ *
+ *
+ * @param  {Function} fn          The constructor function to partially apply.
+ * @param  {mixed}    args, ...   Arguments to pre-bind.
+ * @return {Function}             The partially applied constructor.
+ */
+module.exports = function fastPartialConstructor (fn) {
+  var boundLength = arguments.length - 1,
+      boundArgs;
+
+  boundArgs = new Array(boundLength);
+  for (var i = 0; i < boundLength; i++) {
+    boundArgs[i] = arguments[i + 1];
+  }
+  return function partialed () {
+    var length = arguments.length,
+        args = new Array(boundLength + length),
+        i;
+    for (i = 0; i < boundLength; i++) {
+      args[i] = boundArgs[i];
+    }
+    for (i = 0; i < length; i++) {
+      args[boundLength + i] = arguments[i];
+    }
+
+    var thisContext = Object.create(fn.prototype),
+        result = applyWithContext(fn, thisContext, args);
+
+    if (result != null && (typeof result === 'object' || typeof result === 'function')) {
+      return result;
+    }
+    else {
+      return thisContext;
+    }
+  };
+};
+
+},{"./applyWithContext":33}],40:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Try
+ *
+ * Allows functions to be optimised by isolating `try {} catch (e) {}` blocks
+ * outside the function declaration. Returns either the result of the function or an Error
+ * object if one was thrown. The caller should then check for `result instanceof Error`.
+ *
+ * ```js
+ * var result = fast.try(myFunction);
+ * if (result instanceof Error) {
+ *    console.log('something went wrong');
+ * }
+ * else {
+ *   console.log('result:', result);
+ * }
+ * ```
+ *
+ * @param  {Function} fn The function to invoke.
+ * @return {mixed}       The result of the function, or an `Error` object.
+ */
+module.exports = function fastTry (fn) {
+  try {
+    return fn();
+  }
+  catch (e) {
+    if (!(e instanceof Error)) {
+      return new Error(e);
+    }
+    else {
+      return e;
+    }
+  }
+};
+
+},{}],41:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Constructor
+ *
+ * Provided as a convenient wrapper around Fast functions.
+ *
+ * ```js
+ * var arr = fast([1,2,3,4,5,6]);
+ *
+ * var result = arr.filter(function (item) {
+ *   return item % 2 === 0;
+ * });
+ *
+ * result instanceof Fast; // true
+ * result.length; // 3
+ * ```
+ *
+ *
+ * @param {Array} value The value to wrap.
+ */
+function Fast (value) {
+  if (!(this instanceof Fast)) {
+    return new Fast(value);
+  }
+  this.value = value || [];
+}
+
+module.exports = exports = Fast;
+
+Fast.array = _require('./array');
+Fast['function'] = Fast.fn = _require('./function');
+Fast.object = _require('./object');
+Fast.string = _require('./string');
+
+
+Fast.apply = Fast['function'].apply;
+Fast.bind = Fast['function'].bind;
+Fast.partial = Fast['function'].partial;
+Fast.partialConstructor = Fast['function'].partialConstructor;
+Fast['try'] = Fast.attempt = Fast['function']['try'];
+
+Fast.assign = Fast.object.assign;
+Fast.cloneObject = Fast.object.clone; // @deprecated use fast.object.clone()
+Fast.keys = Fast.object.keys;
+Fast.values = Fast.object.values;
+
+
+Fast.clone = _require('./clone');
+Fast.map = _require('./map');
+Fast.filter = _require('./filter');
+Fast.forEach = _require('./forEach');
+Fast.reduce = _require('./reduce');
+Fast.reduceRight = _require('./reduceRight');
+
+
+Fast.cloneArray = Fast.array.clone; // @deprecated use fast.array.clone()
+
+Fast.concat = Fast.array.concat;
+Fast.some = Fast.array.some;
+Fast.every = Fast.array.every;
+Fast.indexOf = Fast.array.indexOf;
+Fast.lastIndexOf = Fast.array.lastIndexOf;
+Fast.pluck = Fast.array.pluck;
+Fast.fill = Fast.array.fill;
+
+Fast.intern = Fast.string.intern;
+
+
+/**
+ * # Concat
+ *
+ * Concatenate multiple arrays.
+ *
+ * @param  {Array|mixed} item, ... The item(s) to concatenate.
+ * @return {Fast}                  A new Fast object, containing the results.
+ */
+Fast.prototype.concat = function Fast$concat () {
+  var length = this.value.length,
+      arr = new Array(length),
+      i, item, childLength, j;
+
+  for (i = 0; i < length; i++) {
+    arr[i] = this.value[i];
+  }
+
+  length = arguments.length;
+  for (i = 0; i < length; i++) {
+    item = arguments[i];
+    if (Array.isArray(item)) {
+      childLength = item.length;
+      for (j = 0; j < childLength; j++) {
+        arr.push(item[j]);
+      }
+    }
+    else {
+      arr.push(item);
+    }
+  }
+  return new Fast(arr);
+};
+
+/**
+ * Fast Map
+ *
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor, if any.
+ * @return {Fast}                 A new Fast object, containing the results.
+ */
+Fast.prototype.map = function Fast$map (fn, thisContext) {
+  return new Fast(Fast.map(this.value, fn, thisContext));
+};
+
+/**
+ * Fast Filter
+ *
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter function, if any.
+ * @return {Fast}                 A new Fast object, containing the results.
+ */
+Fast.prototype.filter = function Fast$filter (fn, thisContext) {
+  return new Fast(Fast.filter(this.value, fn, thisContext));
+};
+
+/**
+ * Fast Reduce
+ *
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value, if any.
+ * @param  {Object}   thisContext  The context for the reducer, if any.
+ * @return {mixed}                 The final result.
+ */
+Fast.prototype.reduce = function Fast$reduce (fn, initialValue, thisContext) {
+  return Fast.reduce(this.value, fn, initialValue, thisContext);
+};
+
+
+/**
+ * Fast Reduce Right
+ *
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value, if any.
+ * @param  {Object}   thisContext  The context for the reducer, if any.
+ * @return {mixed}                 The final result.
+ */
+Fast.prototype.reduceRight = function Fast$reduceRight (fn, initialValue, thisContext) {
+  return Fast.reduceRight(this.value, fn, initialValue, thisContext);
+};
+
+/**
+ * Fast For Each
+ *
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor, if any.
+ * @return {Fast}                 The Fast instance.
+ */
+Fast.prototype.forEach = function Fast$forEach (fn, thisContext) {
+  Fast.forEach(this.value, fn, thisContext);
+  return this;
+};
+
+/**
+ * Fast Some
+ *
+ * @param  {Function} fn          The matcher predicate.
+ * @param  {Object}   thisContext The context for the matcher, if any.
+ * @return {Boolean}              True if at least one element matches.
+ */
+Fast.prototype.some = function Fast$some (fn, thisContext) {
+  return Fast.some(this.value, fn, thisContext);
+};
+
+/**
+ * Fast Every
+ *
+ * @param  {Function} fn          The matcher predicate.
+ * @param  {Object}   thisContext The context for the matcher, if any.
+ * @return {Boolean}              True if at all elements match.
+ */
+Fast.prototype.every = function Fast$every (fn, thisContext) {
+  return Fast.some(this.value, fn, thisContext);
+};
+
+/**
+ * Fast Index Of
+ *
+ * @param  {mixed}  target    The target to lookup.
+ * @param  {Number} fromIndex The index to start searching from, if known.
+ * @return {Number}           The index of the item, or -1 if no match found.
+ */
+Fast.prototype.indexOf = function Fast$indexOf (target, fromIndex) {
+  return Fast.indexOf(this.value, target, fromIndex);
+};
+
+
+/**
+ * Fast Last Index Of
+ *
+ * @param  {mixed}  target    The target to lookup.
+ * @param  {Number} fromIndex The index to start searching from, if known.
+ * @return {Number}           The last index of the item, or -1 if no match found.
+ */
+Fast.prototype.lastIndexOf = function Fast$lastIndexOf (target, fromIndex) {
+  return Fast.lastIndexOf(this.value, target, fromIndex);
+};
+
+/**
+ * Reverse
+ *
+ * @return {Fast} A new Fast instance, with the contents reversed.
+ */
+Fast.prototype.reverse = function Fast$reverse () {
+  return new Fast(this.value.reverse());
+};
+
+/**
+ * Value Of
+ *
+ * @return {Array} The wrapped value.
+ */
+Fast.prototype.valueOf = function Fast$valueOf () {
+  return this.value;
+};
+
+/**
+ * To JSON
+ *
+ * @return {Array} The wrapped value.
+ */
+Fast.prototype.toJSON = function Fast$toJSON () {
+  return this.value;
+};
+
+/**
+ * Item Length
+ */
+Object.defineProperty(Fast.prototype, 'length', {
+  get: function () {
+    return this.value.length;
+  }
+});
+
+},{"./array":20,"./clone":28,"./filter":29,"./forEach":30,"./function":37,"./map":42,"./object":47,"./reduce":53,"./reduceRight":54,"./string":55}],42:[function(_require,module,exports){
+'use strict';
+
+var mapArray = _require('./array/map'),
+    mapObject = _require('./object/map');
+
+/**
+ * # Map
+ *
+ * A fast `.map()` implementation.
+ *
+ * @param  {Array|Object} subject     The array or object to map over.
+ * @param  {Function}     fn          The mapper function.
+ * @param  {Object}       thisContext The context for the mapper.
+ * @return {Array|Object}             The array or object containing the results.
+ */
+module.exports = function fastMap (subject, fn, thisContext) {
+  if (subject instanceof Array) {
+    return mapArray(subject, fn, thisContext);
+  }
+  else {
+    return mapObject(subject, fn, thisContext);
+  }
+};
+},{"./array/map":23,"./object/map":49}],43:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Analogue of Object.assign().
+ * Copies properties from one or more source objects to
+ * a target object. Existing keys on the target object will be overwritten.
+ *
+ * > Note: This differs from spec in some important ways:
+ * > 1. Will throw if passed non-objects, including `undefined` or `null` values.
+ * > 2. Does not support the curious Exception handling behavior, exceptions are thrown immediately.
+ * > For more details, see:
+ * > https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+ *
+ *
+ *
+ * @param  {Object} target      The target object to copy properties to.
+ * @param  {Object} source, ... The source(s) to copy properties from.
+ * @return {Object}             The updated target object.
+ */
+module.exports = function fastAssign (target) {
+  var totalArgs = arguments.length,
+      source, i, totalKeys, keys, key, j;
+
+  for (i = 1; i < totalArgs; i++) {
+    source = arguments[i];
+    keys = Object.keys(source);
+    totalKeys = keys.length;
+    for (j = 0; j < totalKeys; j++) {
+      key = keys[j];
+      target[key] = source[key];
+    }
+  }
+  return target;
+};
+
+},{}],44:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Clone Object
+ *
+ * Shallow clone a simple object.
+ *
+ * > Note: Prototypes and non-enumerable properties will not be copied!
+ *
+ * @param  {Object} input The object to clone.
+ * @return {Object}       The cloned object.
+ */
+module.exports = function fastCloneObject (input) {
+  var keys = Object.keys(input),
+      total = keys.length,
+      cloned = {},
+      i, key;
+
+  for (i = 0; i < total; i++) {
+    key = keys[i];
+    cloned[key] = input[key];
+  }
+
+  return cloned;
+};
+
+},{}],45:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Filter
+ *
+ * A fast object `.filter()` implementation.
+ *
+ * @param  {Object}   subject     The object to filter.
+ * @param  {Function} fn          The filter function.
+ * @param  {Object}   thisContext The context for the filter.
+ * @return {Object}               The new object containing the filtered results.
+ */
+module.exports = function fastFilterObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    if (iterator(subject[key], key, subject)) {
+      result[key] = subject[key];
+    }
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":35}],46:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # For Each
+ *
+ * A fast object `.forEach()` implementation.
+ *
+ * @param  {Object}   subject     The object to iterate over.
+ * @param  {Function} fn          The visitor function.
+ * @param  {Object}   thisContext The context for the visitor.
+ */
+module.exports = function fastForEachObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      key, i;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    iterator(subject[key], key, subject);
+  }
+};
+
+},{"../function/bindInternal3":35}],47:[function(_require,module,exports){
+'use strict';
+
+exports.assign = _require('./assign');
+exports.clone = _require('./clone');
+exports.filter = _require('./filter');
+exports.forEach = _require('./forEach');
+exports.map = _require('./map');
+exports.reduce = _require('./reduce');
+exports.reduceRight = _require('./reduceRight');
+exports.keys = _require('./keys');
+exports.values = _require('./values');
+},{"./assign":43,"./clone":44,"./filter":45,"./forEach":46,"./keys":48,"./map":49,"./reduce":50,"./reduceRight":51,"./values":52}],48:[function(_require,module,exports){
+'use strict';
+
+/**
+ * Object.keys() shim for ES3 environments.
+ *
+ * @param  {Object} obj The object to get keys for.
+ * @return {Array}      The array of keys.
+ */
+module.exports = typeof Object.keys === "function" ? Object.keys : /* istanbul ignore next */ function fastKeys (obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+};
+},{}],49:[function(_require,module,exports){
+'use strict';
+
+var bindInternal3 = _require('../function/bindInternal3');
+
+/**
+ * # Map
+ *
+ * A fast object `.map()` implementation.
+ *
+ * @param  {Object}   subject     The object to map over.
+ * @param  {Function} fn          The mapper function.
+ * @param  {Object}   thisContext The context for the mapper.
+ * @return {Object}               The new object containing the results.
+ */
+module.exports = function fastMapObject (subject, fn, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      result = {},
+      iterator = thisContext !== undefined ? bindInternal3(fn, thisContext) : fn,
+      i, key;
+  for (i = 0; i < length; i++) {
+    key = keys[i];
+    result[key] = iterator(subject[key], key, subject);
+  }
+  return result;
+};
+
+},{"../function/bindInternal3":35}],50:[function(_require,module,exports){
+'use strict';
+
+var bindInternal4 = _require('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = 1;
+    result = subject[keys[0]];
+  }
+  else {
+    i = 0;
+    result = initialValue;
+  }
+
+  for (; i < length; i++) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":36}],51:[function(_require,module,exports){
+'use strict';
+
+var bindInternal4 = _require('../function/bindInternal4');
+
+/**
+ * # Reduce
+ *
+ * A fast object `.reduce()` implementation.
+ *
+ * @param  {Object}   subject      The object to reduce over.
+ * @param  {Function} fn           The reducer function.
+ * @param  {mixed}    initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}   thisContext  The context for the reducer.
+ * @return {mixed}                 The final result.
+ */
+module.exports = function fastReduceRightObject (subject, fn, initialValue, thisContext) {
+  var keys = Object.keys(subject),
+      length = keys.length,
+      iterator = thisContext !== undefined ? bindInternal4(fn, thisContext) : fn,
+      i, key, result;
+
+  if (initialValue === undefined) {
+    i = length - 2;
+    result = subject[keys[length - 1]];
+  }
+  else {
+    i = length - 1;
+    result = initialValue;
+  }
+
+  for (; i >= 0; i--) {
+    key = keys[i];
+    result = iterator(result, subject[key], key, subject);
+  }
+
+  return result;
+};
+
+},{"../function/bindInternal4":36}],52:[function(_require,module,exports){
+'use strict';
+
+/**
+ * # Values
+ * Return all the (enumerable) property values for an object.
+ * Like Object.keys() but for values.
+ *
+ * @param  {Object} obj The object to retrieve values from.
+ * @return {Array}      An array containing property values.
+ */
+module.exports = function fastValues (obj) {
+  var keys = Object.keys(obj),
+      length = keys.length,
+      values = new Array(length);
+
+  for (var i = 0; i < length; i++) {
+    values[i] = obj[keys[i]];
+  }
+  return values;
+};
+},{}],53:[function(_require,module,exports){
+'use strict';
+
+var reduceArray = _require('./array/reduce'),
+    reduceObject = _require('./object/reduce');
+
+/**
+ * # Reduce
+ *
+ * A fast `.reduce()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduce (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceObject(subject, fn, initialValue, thisContext);
+  }
+};
+},{"./array/reduce":25,"./object/reduce":50}],54:[function(_require,module,exports){
+'use strict';
+
+var reduceRightArray = _require('./array/reduceRight'),
+    reduceRightObject = _require('./object/reduceRight');
+
+/**
+ * # Reduce Right
+ *
+ * A fast `.reduceRight()` implementation.
+ *
+ * @param  {Array|Object} subject      The array or object to reduce over.
+ * @param  {Function}     fn           The reducer function.
+ * @param  {mixed}        initialValue The initial value for the reducer, defaults to subject[0].
+ * @param  {Object}       thisContext  The context for the reducer.
+ * @return {Array|Object}              The array or object containing the results.
+ */
+module.exports = function fastReduceRight (subject, fn, initialValue, thisContext) {
+  if (subject instanceof Array) {
+    return reduceRightArray(subject, fn, initialValue, thisContext);
+  }
+  else {
+    return reduceRightObject(subject, fn, initialValue, thisContext);
+  }
+};
+},{"./array/reduceRight":26,"./object/reduceRight":51}],55:[function(_require,module,exports){
+'use strict';
+
+exports.intern = _require('./intern');
+},{"./intern":56}],56:[function(_require,module,exports){
+'use strict';
+
+// Compilers such as V8 use string interning to make string comparison very fast and efficient,
+// as efficient as comparing two references to the same object.
+//
+//
+// V8 does its best to intern strings automatically where it can, for instance:
+// ```js
+//   var greeting = "hello world";
+// ```
+// With this, comparison will be very fast:
+// ```js
+//   if (greeting === "hello world") {}
+// ```
+// However, there are several cases where V8 cannot intern the string, and instead
+// must resort to byte-wise comparison. This can be signficantly slower for long strings.
+// The most common example is string concatenation:
+// ```js
+//   function subject () { return "world"; };
+//   var greeting = "hello " + subject();
+// ```
+// In this case, V8 cannot intern the string. So this comparison is *much* slower:
+// ```js
+//  if (greeting === "hello world") {}
+// ```
+
+
+
+// At the moment, the fastest, safe way of interning a string is to
+// use it as a key in an object, and then use that key.
+//
+// Note: This technique comes courtesy of Petka Antonov - http://jsperf.com/istrn/11
+//
+// We create a container object in hash mode.
+// Most strings being interned will not be valid fast property names,
+// so we ensure hash mode now to avoid transitioning the object mode at runtime.
+var container = {'- ': true};
+delete container['- '];
+
+
+/**
+ * Intern a string to make comparisons faster.
+ *
+ * > Note: This is a relatively expensive operation, you
+ * shouldn't usually do the actual interning at runtime, instead
+ * use this at compile time to make future work faster.
+ *
+ * @param  {String} string The string to intern.
+ * @return {String}        The interned string.
+ */
+module.exports = function fastIntern (string) {
+  container[string] = true;
+  var interned = Object.keys(container)[0];
+  delete container[interned];
+  return interned;
+};
+},{}],57:[function(_require,module,exports){
+/** generate unique id for selector */
+var counter = Date.now() % 1e9;
+
+module.exports = function getUid(){
+	return (Math.random() * 1e9 >>> 0) + (counter++);
+};
+},{}],58:[function(_require,module,exports){
+/*global window*/
+
+/**
+ * Check if object is dom node.
+ *
+ * @param {Object} val
+ * @return {Boolean}
+ * @api public
+ */
+
+module.exports = function isNode(val){
+  if (!val || typeof val !== 'object') return false;
+  if (window && 'object' == typeof window.Node) return val instanceof window.Node;
+  return 'number' == typeof val.nodeType && 'string' == typeof val.nodeName;
+}
+
+},{}],59:[function(_require,module,exports){
+(function (root, factory){
+  'use strict';
+
+  /*istanbul ignore next:cant test*/
+  if (typeof module === 'object' && typeof module.exports === 'object') {
+    module.exports = factory();
+  } else if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define([], factory);
+  } else {
+    // Browser globals
+    root.objectPath = factory();
+  }
+})(this, function(){
+  'use strict';
+
+  var
+    toStr = Object.prototype.toString,
+    _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+  function isEmpty(value){
+    if (!value) {
+      return true;
+    }
+    if (isArray(value) && value.length === 0) {
+      return true;
+    } else {
+      for (var i in value) {
+        if (_hasOwnProperty.call(value, i)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+  function toString(type){
+    return toStr.call(type);
+  }
+
+  function isNumber(value){
+    return typeof value === 'number' || toString(value) === "[object Number]";
+  }
+
+  function isString(obj){
+    return typeof obj === 'string' || toString(obj) === "[object String]";
+  }
+
+  function isObject(obj){
+    return typeof obj === 'object' && toString(obj) === "[object Object]";
+  }
+
+  function isArray(obj){
+    return typeof obj === 'object' && typeof obj.length === 'number' && toString(obj) === '[object Array]';
+  }
+
+  function isBoolean(obj){
+    return typeof obj === 'boolean' || toString(obj) === '[object Boolean]';
+  }
+
+  function getKey(key){
+    var intKey = parseInt(key);
+    if (intKey.toString() === key) {
+      return intKey;
+    }
+    return key;
+  }
+
+  function set(obj, path, value, doNotReplace){
+    if (isNumber(path)) {
+      path = [path];
+    }
+    if (isEmpty(path)) {
+      return obj;
+    }
+    if (isString(path)) {
+      return set(obj, path.split('.').map(getKey), value, doNotReplace);
+    }
+    var currentPath = path[0];
+
+    if (path.length === 1) {
+      var oldVal = obj[currentPath];
+      if (oldVal === void 0 || !doNotReplace) {
+        obj[currentPath] = value;
+      }
+      return oldVal;
+    }
+
+    if (obj[currentPath] === void 0) {
+      //check if we assume an array
+      if(isNumber(path[1])) {
+        obj[currentPath] = [];
+      } else {
+        obj[currentPath] = {};
+      }
+    }
+
+    return set(obj[currentPath], path.slice(1), value, doNotReplace);
+  }
+
+  function del(obj, path) {
+    if (isNumber(path)) {
+      path = [path];
+    }
+
+    if (isEmpty(obj)) {
+      return void 0;
+    }
+
+    if (isEmpty(path)) {
+      return obj;
+    }
+    if(isString(path)) {
+      return del(obj, path.split('.'));
+    }
+
+    var currentPath = getKey(path[0]);
+    var oldVal = obj[currentPath];
+
+    if(path.length === 1) {
+      if (oldVal !== void 0) {
+        if (isArray(obj)) {
+          obj.splice(currentPath, 1);
+        } else {
+          delete obj[currentPath];
+        }
+      }
+    } else {
+      if (obj[currentPath] !== void 0) {
+        return del(obj[currentPath], path.slice(1));
+      }
+    }
+
+    return obj;
+  }
+
+  var objectPath = {};
+
+  objectPath.has = function (obj, path) {
+    if (isEmpty(obj)) {
+      return false;
+    }
+
+    if (isNumber(path)) {
+      path = [path];
+    } else if (isString(path)) {
+      path = path.split('.');
+    }
+
+    if (isEmpty(path) || path.length === 0) {
+      return false;
+    }
+
+    for (var i = 0; i < path.length; i++) {
+      var j = path[i];
+      if ((isObject(obj) || isArray(obj)) && _hasOwnProperty.call(obj, j)) {
+        obj = obj[j];
+      } else {
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  objectPath.ensureExists = function (obj, path, value){
+    return set(obj, path, value, true);
+  };
+
+  objectPath.set = function (obj, path, value, doNotReplace){
+    return set(obj, path, value, doNotReplace);
+  };
+
+  objectPath.insert = function (obj, path, value, at){
+    var arr = objectPath.get(obj, path);
+    at = ~~at;
+    if (!isArray(arr)) {
+      arr = [];
+      objectPath.set(obj, path, arr);
+    }
+    arr.splice(at, 0, value);
+  };
+
+  objectPath.empty = function(obj, path) {
+    if (isEmpty(path)) {
+      return obj;
+    }
+    if (isEmpty(obj)) {
+      return void 0;
+    }
+
+    var value, i;
+    if (!(value = objectPath.get(obj, path))) {
+      return obj;
+    }
+
+    if (isString(value)) {
+      return objectPath.set(obj, path, '');
+    } else if (isBoolean(value)) {
+      return objectPath.set(obj, path, false);
+    } else if (isNumber(value)) {
+      return objectPath.set(obj, path, 0);
+    } else if (isArray(value)) {
+      value.length = 0;
+    } else if (isObject(value)) {
+      for (i in value) {
+        if (_hasOwnProperty.call(value, i)) {
+          delete value[i];
+        }
+      }
+    } else {
+      return objectPath.set(obj, path, null);
+    }
+  };
+
+  objectPath.push = function (obj, path /*, values */){
+    var arr = objectPath.get(obj, path);
+    if (!isArray(arr)) {
+      arr = [];
+      objectPath.set(obj, path, arr);
+    }
+
+    arr.push.apply(arr, Array.prototype.slice.call(arguments, 2));
+  };
+
+  objectPath.coalesce = function (obj, paths, defaultValue) {
+    var value;
+
+    for (var i = 0, len = paths.length; i < len; i++) {
+      if ((value = objectPath.get(obj, paths[i])) !== void 0) {
+        return value;
+      }
+    }
+
+    return defaultValue;
+  };
+
+  objectPath.get = function (obj, path, defaultValue){
+    if (isNumber(path)) {
+      path = [path];
+    }
+    if (isEmpty(path)) {
+      return obj;
+    }
+    if (isEmpty(obj)) {
+      return defaultValue;
+    }
+    if (isString(path)) {
+      return objectPath.get(obj, path.split('.'), defaultValue);
+    }
+
+    var currentPath = getKey(path[0]);
+
+    if (path.length === 1) {
+      if (obj[currentPath] === void 0) {
+        return defaultValue;
+      }
+      return obj[currentPath];
+    }
+
+    return objectPath.get(obj[currentPath], path.slice(1), defaultValue);
+  };
+
+  objectPath.del = function(obj, path) {
+    return del(obj, path);
+  };
+
+  return objectPath;
+});
+
+},{}],60:[function(_require,module,exports){
+/**
+ * Module Dependencies.
+ */
+
+var raf = _require('raf');
+
+/**
+ * Export `throttle`.
+ */
+
+module.exports = throttle;
+
+/**
+ * Executes a function at most once per animation frame. Kind of like
+ * throttle, but it throttles at ~60Hz.
+ *
+ * @param {Function} fn - the Function to throttle once per animation frame
+ * @return {Function}
+ * @public
+ */
+
+function throttle(fn) {
+  var rtn;
+  var ignoring = false;
+
+  return function queue() {
+    if (ignoring) return rtn;
+    ignoring = true;
+
+    raf(function() {
+      ignoring = false;
+    });
+
+    rtn = fn.apply(this, arguments);
+    return rtn;
+  };
+}
+
+},{"raf":10}],61:[function(_require,module,exports){
+module.exports = exports = _require('./lib/sliced');
+
+},{"./lib/sliced":62}],62:[function(_require,module,exports){
+
+/**
+ * An Array.prototype.slice.call(arguments) alternative
+ *
+ * @param {Object} args something with a length
+ * @param {Number} slice
+ * @param {Number} sliceEnd
+ * @api public
+ */
+
+module.exports = function (args, slice, sliceEnd) {
+  var ret = [];
+  var len = args.length;
+
+  if (0 === len) return ret;
+
+  var start = slice < 0
+    ? Math.max(0, slice + len)
+    : slice || 0;
+
+  if (sliceEnd !== undefined) {
+    len = sliceEnd < 0
+      ? sliceEnd + len
+      : sliceEnd
+  }
+
+  while (len-- > start) {
+    ret[len - start] = args[len];
+  }
+
+  return ret;
+}
+
+
+},{}]},{},[2])(2)
+});