upgrade

web/assets/ev-emitter/.bower.json

@@ -0,0 +1,39 @@
+{
+  "name": "ev-emitter",
+  "main": "ev-emitter.js",
+  "homepage": "https://github.com/metafizzy/ev-emitter",
+  "authors": [
+    "David DeSandro <desandrocodes@gmail.com>"
+  ],
+  "description": "lil' event emitter",
+  "moduleType": [
+    "amd",
+    "globals",
+    "node"
+  ],
+  "keywords": [
+    "event",
+    "emitter",
+    "pubsub"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests",
+    "sandbox",
+    "package.json"
+  ],
+  "version": "1.1.1",
+  "_release": "1.1.1",
+  "_resolution": {
+    "type": "version",
+    "tag": "v1.1.1",
+    "commit": "911c394516b3aec85b0e63df121de88f8c773fc6"
+  },
+  "_source": "https://github.com/metafizzy/ev-emitter.git",
+  "_target": "^1.0.0",
+  "_originalSource": "ev-emitter"
+}

web/assets/ev-emitter/README.md

@@ -0,0 +1,109 @@
+# EvEmitter
+
+_Lil' event emitter_ — add a little pub/sub
+
+EvEmitter adds publish/subscribe pattern to a browser class. It's a smaller version of [Olical/EventEmitter](https://github.com/Olical/EventEmitter). That EventEmitter is full featured, widely used, and great. This EvEmitter has just the base event functionality to power the event API in libraries like [Isotope](http://isotope.metafizzy.co), [Flickity](http://flickity.metafizzy.co), [Masonry](http://masonry.desandro.com), and [imagesLoaded](http://imagesloaded.desandro.com).
+
+## API
+
+``` js
+// Inherit prototype, IE8+
+MyClass.prototype = new EvEmitter();
+
+// Inherit prototype, IE9+
+MyClass.prototype = Object.create( EvEmitter.prototype );
+
+// Mixin prototype
+_.extend( MyClass.prototype, EvEmitter.prototype );
+
+// single instance
+var emitter = new EvEmitter();
+```
+
+### on
+
+Add an event listener.
+
+``` js
+emitter.on( eventName, listener )
+```
+
++ `eventName` - _String_ - name of the event
++ `listener` - _Function_
+
+### off
+
+Remove an event listener.
+
+``` js
+emitter.off( eventName, listener )
+```
+
+### once
+
+Add an event listener to be triggered only once.
+
+``` js
+emitter.once( eventName, listener )
+```
+
+### emitEvent
+
+Trigger an event.
+
+``` js
+emitter.emitEvent( eventName, args )
+```
+
++ `eventName` - _String_ - name of the event
++ `args` - _Array_ - arguments passed to listeners
+
+### allOff
+
+Removes all event listeners.
+
+``` js
+emitter.allOff()
+```
+
+## Code example
+
+``` js
+// create event emitter
+var emitter = new EventEmitter();
+
+// listeners
+function hey( a, b, c ) {
+  console.log( 'Hey', a, b, c )
+}
+
+function ho( a, b, c ) {
+  console.log( 'Ho', a, b, c )
+}
+
+function letsGo( a, b, c ) {
+  console.log( 'Lets go', a, b, c )
+}
+
+// bind listeners
+emitter.on( 'rock', hey )
+emitter.once( 'rock', ho )
+// trigger letsGo once
+emitter.on( 'rock', letsGo )
+
+// emit event
+emitter.emitEvent( 'rock', [ 1, 2, 3 ] )
+// => 'Hey', 1, 2, 3
+// => 'Ho', 1, 2, 3
+// => 'Lets go', 1, 2, 3
+
+// unbind
+emitter.off( 'rock', ho )
+
+emitter.emitEvent( 'rock', [ 4, 5, 6 ] )
+// => 'Hey' 4, 5, 6
+```
+
+## License
+
+EvEmitter is released under the [MIT License](http://desandro.mit-license.org/). Have at it.

web/assets/ev-emitter/bower.json

@@ -0,0 +1,29 @@
+{
+  "name": "ev-emitter",
+  "main": "ev-emitter.js",
+  "homepage": "https://github.com/metafizzy/ev-emitter",
+  "authors": [
+    "David DeSandro <desandrocodes@gmail.com>"
+  ],
+  "description": "lil' event emitter",
+  "moduleType": [
+    "amd",
+    "globals",
+    "node"
+  ],
+  "keywords": [
+    "event",
+    "emitter",
+    "pubsub"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests",
+    "sandbox",
+    "package.json"
+  ]
+}

web/assets/ev-emitter/ev-emitter.js

@@ -0,0 +1,112 @@
+/**
+ * EvEmitter v1.1.0
+ * Lil' event emitter
+ * MIT License
+ */
+
+/* jshint unused: true, undef: true, strict: true */
+
+( function( global, factory ) {
+  // universal module definition
+  /* jshint strict: false */ /* globals define, module, window */
+  if ( typeof define == 'function' && define.amd ) {
+    // AMD - RequireJS
+    define( factory );
+  } else if ( typeof module == 'object' && module.exports ) {
+    // CommonJS - Browserify, Webpack
+    module.exports = factory();
+  } else {
+    // Browser globals
+    global.EvEmitter = factory();
+  }
+
+}( typeof window != 'undefined' ? window : this, function() {
+
+"use strict";
+
+function EvEmitter() {}
+
+var proto = EvEmitter.prototype;
+
+proto.on = function( eventName, listener ) {
+  if ( !eventName || !listener ) {
+    return;
+  }
+  // set events hash
+  var events = this._events = this._events || {};
+  // set listeners array
+  var listeners = events[ eventName ] = events[ eventName ] || [];
+  // only add once
+  if ( listeners.indexOf( listener ) == -1 ) {
+    listeners.push( listener );
+  }
+
+  return this;
+};
+
+proto.once = function( eventName, listener ) {
+  if ( !eventName || !listener ) {
+    return;
+  }
+  // add event
+  this.on( eventName, listener );
+  // set once flag
+  // set onceEvents hash
+  var onceEvents = this._onceEvents = this._onceEvents || {};
+  // set onceListeners object
+  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};
+  // set flag
+  onceListeners[ listener ] = true;
+
+  return this;
+};
+
+proto.off = function( eventName, listener ) {
+  var listeners = this._events && this._events[ eventName ];
+  if ( !listeners || !listeners.length ) {
+    return;
+  }
+  var index = listeners.indexOf( listener );
+  if ( index != -1 ) {
+    listeners.splice( index, 1 );
+  }
+
+  return this;
+};
+
+proto.emitEvent = function( eventName, args ) {
+  var listeners = this._events && this._events[ eventName ];
+  if ( !listeners || !listeners.length ) {
+    return;
+  }
+  // copy over to avoid interference if .off() in listener
+  listeners = listeners.slice(0);
+  args = args || [];
+  // once stuff
+  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];
+
+  for ( var i=0; i < listeners.length; i++ ) {
+    var listener = listeners[i]
+    var isOnce = onceListeners && onceListeners[ listener ];
+    if ( isOnce ) {
+      // remove listener
+      // remove before trigger to prevent recursion
+      this.off( eventName, listener );
+      // unset once flag
+      delete onceListeners[ listener ];
+    }
+    // trigger listener
+    listener.apply( this, args );
+  }
+
+  return this;
+};
+
+proto.allOff = function() {
+  delete this._events;
+  delete this._onceEvents;
+};
+
+return EvEmitter;
+
+}));