correction && add form && add slide && add masonry && css

node_modules/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.

node_modules/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"
+  ]
+}

node_modules/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;
+
+}));

node_modules/ev-emitter/package.json

@@ -0,0 +1,55 @@
+{
+  "_from": "ev-emitter@^1.1.1",
+  "_id": "ev-emitter@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-ipiDYhdQSCZ4hSbX4rMW+XzNKMD1prg/sTvoVmSLkuQ1MVlwjJQQA+sW8tMYR3BLUr9KjodFV4pvzunvRhd33Q==",
+  "_location": "/ev-emitter",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "ev-emitter@^1.1.1",
+    "name": "ev-emitter",
+    "escapedName": "ev-emitter",
+    "rawSpec": "^1.1.1",
+    "saveSpec": null,
+    "fetchSpec": "^1.1.1"
+  },
+  "_requiredBy": [
+    "/flickity",
+    "/unipointer"
+  ],
+  "_resolved": "https://registry.npmjs.org/ev-emitter/-/ev-emitter-1.1.1.tgz",
+  "_shasum": "8f18b0ce5c76a5d18017f71c0a795c65b9138f2a",
+  "_spec": "ev-emitter@^1.1.1",
+  "_where": "/var/www/html/node_modules/flickity",
+  "author": {
+    "name": "David DeSandro"
+  },
+  "bugs": {
+    "url": "https://github.com/metafizzy/ev-emitter/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "lil' event emitter",
+  "directories": {
+    "test": "test"
+  },
+  "homepage": "https://github.com/metafizzy/ev-emitter#readme",
+  "keywords": [
+    "event",
+    "emitter",
+    "pubsub"
+  ],
+  "license": "MIT",
+  "main": "ev-emitter.js",
+  "name": "ev-emitter",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metafizzy/ev-emitter.git"
+  },
+  "scripts": {
+    "test": "mocha test/test"
+  },
+  "version": "1.1.1"
+}

node_modules/ev-emitter/sandbox/1.html

@@ -0,0 +1,37 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width" />
+
+  <title>1</title>
+
+</head>
+<body>
+
+  <h1>1</h1>
+
+<script src="../ev-emitter.js"></script>
+
+<script>
+var ee = new EvEmitter;
+
+var hey = function( a, b, c ) { console.log('hey', a, b, c ) };
+var ho = function( a, b, c ) { console.log('ho', a, b, c ) };
+var letsGo = function( a, b, c ) { console.log('lets go', a, b, c ) };
+
+ee.on( 'foo', hey );
+ee.once( 'foo', ho );
+ee.on( 'foo', letsGo );
+
+ee.emitEvent( 'foo', [ 1, 2, 3 ] );
+
+ee.off('foo', hey );
+
+ee.emitEvent( 'foo', [ 4, 5, 6 ] );
+
+</script>
+
+</body>
+</html>
+

node_modules/ev-emitter/test/test.js

@@ -0,0 +1,175 @@
+/* jshint node: true, unused: true, undef: true */
+/* globals it */
+
+var assert = require('assert');
+var EvEmitter = require('../ev-emitter');
+
+it( 'should emitEvent', function() {
+  var emitter = new EvEmitter();
+  var didPop;
+  emitter.on( 'pop', function() {
+    didPop = true;
+  });
+  emitter.emitEvent( 'pop' );
+  assert.ok( didPop, 'event emitted' );
+});
+
+it( 'emitEvent should pass argument to listener', function() {
+  var emitter = new EvEmitter();
+  var result;
+  function onPop( arg ) {
+    result = arg;
+  }
+  emitter.on( 'pop', onPop );
+  emitter.emitEvent( 'pop', [ 1 ] );
+  assert.equal( result, 1, 'event emitted, arg passed' );
+});
+
+it( 'does not allow same listener to be added', function() {
+  var emitter = new EvEmitter();
+  var ticks = 0;
+  function onPop() {
+    ticks++;
+  }
+  emitter.on( 'pop', onPop );
+  emitter.on( 'pop', onPop );
+  var _onPop = onPop;
+  emitter.on( 'pop', _onPop );
+
+  emitter.emitEvent('pop');
+  assert.equal( ticks, 1, '1 tick for same listener' );
+});
+
+it( 'should remove listener with .off()', function() {
+  var emitter = new EvEmitter();
+  var ticks = 0;
+  function onPop() {
+    ticks++;
+  }
+  emitter.on( 'pop', onPop );
+  emitter.emitEvent('pop');
+  emitter.off( 'pop', onPop );
+  emitter.emitEvent('pop');
+  assert.equal( ticks, 1, '.off() removed listener' );
+
+  // reset
+  var ary = [];
+  ticks = 0;
+  emitter.allOff();
+
+  function onPopA() {
+    ticks++;
+    ary.push('a');
+    if ( ticks == 2 ) {
+      emitter.off( 'pop', onPopA );
+    }
+  }
+  function onPopB() {
+    ary.push('b');
+  }
+
+  emitter.on( 'pop', onPopA );
+  emitter.on( 'pop', onPopB );
+  emitter.emitEvent('pop'); // a,b
+  emitter.emitEvent('pop'); // a,b - remove onPopA
+  emitter.emitEvent('pop'); // b
+
+  assert.equal( ary.join(','), 'a,b,a,b,b', '.off in listener does not interfer' );
+
+});
+
+it( 'should handle once()', function() {
+  var emitter = new EvEmitter();
+  var ary = [];
+
+  emitter.on( 'pop', function() {
+    ary.push('a');
+  });
+  emitter.once( 'pop', function() {
+    ary.push('b');
+  });
+  emitter.on( 'pop', function() {
+    ary.push('c');
+  });
+  emitter.emitEvent('pop');
+  emitter.emitEvent('pop');
+
+  assert.equal( ary.join(','), 'a,b,c,a,c', 'once listener triggered once' );
+
+  // reset
+  emitter.allOff();
+  ary = [];
+
+  // add two identical but not === listeners, only do one once
+  emitter.on( 'pop', function() {
+    ary.push('a');
+  });
+  emitter.once( 'pop', function() {
+    ary.push('a');
+  });
+  emitter.emitEvent('pop');
+  emitter.emitEvent('pop');
+
+  assert.equal( ary.join(','), 'a,a,a', 'identical listeners do not interfere with once' );
+
+});
+
+it( 'does not infinite loop in once()', function() {
+  var emitter = new EvEmitter();
+  var ticks = 0;
+  function onPop() {
+    ticks++;
+    if ( ticks < 4 ) {
+      emitter.emitEvent('pop');
+    }
+  }
+
+  emitter.once( 'pop', onPop );
+  emitter.emitEvent('pop');
+  assert.equal( ticks, 1, '1 tick with emitEvent in once' );
+});
+
+it( 'handles emitEvent with no listeners', function() {
+  var emitter = new EvEmitter();
+  assert.doesNotThrow( function() {
+    emitter.emitEvent( 'pop', [ 1, 2, 3 ] );
+  });
+
+  function onPop() {}
+
+  emitter.on( 'pop', onPop );
+  emitter.off( 'pop', onPop );
+
+  assert.doesNotThrow( function() {
+    emitter.emitEvent( 'pop', [ 1, 2, 3 ] );
+  });
+
+  emitter.on( 'pop', onPop );
+  emitter.emitEvent( 'pop', [ 1, 2, 3 ] );
+  emitter.off( 'pop', onPop );
+
+  assert.doesNotThrow( function() {
+    emitter.emitEvent( 'pop', [ 1, 2, 3 ] );
+  });
+});
+
+
+it( 'removes all listeners after allOff', function() {
+  var emitter = new EvEmitter();
+  var ary = [];
+  emitter.on( 'pop', function() {
+    ary.push('a');
+  });
+  emitter.on( 'pop', function() {
+    ary.push('b');
+  });
+  emitter.once( 'pop', function() {
+    ary.push('c');
+  });
+
+  emitter.emitEvent('pop');
+  emitter.allOff();
+  emitter.emitEvent('pop');
+
+  assert.equal( ary.join(','), 'a,b,c', 'allOff removed listeners' );
+});