/*!
 * infinite scroll packaged v3.0.2
 * automatically add next page
 *
 * licensed gplv3 for open source use
 * or infinite scroll commercial license for commercial use
 *
 * https://infinite-scroll.com
 * copyright 2017 metafizzy
 */

/**
 * bridget makes jquery widgets
 * v2.0.1
 * mit license
 */

/* jshint browser: true, strict: true, undef: true, unused: true */

( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'jquery-bridget/jquery-bridget',[ 'jquery' ], function( jquery ) {
        return factory( window, jquery );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('jquery')
      );
    } else {
      // browser global
      window.jquerybridget = factory(
        window,
        window.jquery
      );
    }
  
  }( window, function factory( window, jquery ) {
  'use strict';
  
  // ----- utils ----- //
  
  var arrayslice = array.prototype.slice;
  
  // helper function for logging errors
  // $.error breaks jquery chaining
  var console = window.console;
  var logerror = typeof console == 'undefined' ? function() {} :
    function( message ) {
      console.error( message );
    };
  
  // ----- jquerybridget ----- //
  
  function jquerybridget( namespace, pluginclass, $ ) {
    $ = $ || jquery || window.jquery;
    if ( !$ ) {
      return;
    }
  
    // add option method -> $().plugin('option', {...})
    if ( !pluginclass.prototype.option ) {
      // option setter
      pluginclass.prototype.option = function( opts ) {
        // bail out if not an object
        if ( !$.isplainobject( opts ) ){
          return;
        }
        this.options = $.extend( true, this.options, opts );
      };
    }
  
    // make jquery plugin
    $.fn[ namespace ] = function( arg0 /*, arg1 */ ) {
      if ( typeof arg0 == 'string' ) {
        // method call $().plugin( 'methodname', { options } )
        // shift arguments by 1
        var args = arrayslice.call( arguments, 1 );
        return methodcall( this, arg0, args );
      }
      // just $().plugin({ options })
      plaincall( this, arg0 );
      return this;
    };
  
    // $().plugin('methodname')
    function methodcall( $elems, methodname, args ) {
      var returnvalue;
      var pluginmethodstr = '$().' + namespace + '("' + methodname + '")';
  
      $elems.each( function( i, elem ) {
        // get instance
        var instance = $.data( elem, namespace );
        if ( !instance ) {
          logerror( namespace + ' not initialized. cannot call methods, i.e. ' +
            pluginmethodstr );
          return;
        }
  
        var method = instance[ methodname ];
        if ( !method || methodname.charat(0) == '_' ) {
          logerror( pluginmethodstr + ' is not a valid method' );
          return;
        }
  
        // apply method, get return value
        var value = method.apply( instance, args );
        // set return value if value is returned, use only first value
        returnvalue = returnvalue === undefined ? value : returnvalue;
      });
  
      return returnvalue !== undefined ? returnvalue : $elems;
    }
  
    function plaincall( $elems, options ) {
      $elems.each( function( i, elem ) {
        var instance = $.data( elem, namespace );
        if ( instance ) {
          // set options & init
          instance.option( options );
          instance._init();
        } else {
          // initialize new instance
          instance = new pluginclass( elem, options );
          $.data( elem, namespace, instance );
        }
      });
    }
  
    updatejquery( $ );
  
  }
  
  // ----- updatejquery ----- //
  
  // set $.bridget for v1 backwards compatibility
  function updatejquery( $ ) {
    if ( !$ || ( $ && $.bridget ) ) {
      return;
    }
    $.bridget = jquerybridget;
  }
  
  updatejquery( jquery || window.jquery );
  
  // -----  ----- //
  
  return jquerybridget;
  
  }));
  
  /**
   * 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( 'ev-emitter/ev-emitter',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() {
  
  
  
  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;
    }
    var i = 0;
    var listener = listeners[i];
    args = args || [];
    // once stuff
    var oncelisteners = this._onceevents && this._onceevents[ eventname ];
  
    while ( listener ) {
      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 );
      // get next listener
      i += isonce ? 0 : 1;
      listener = listeners[i];
    }
  
    return this;
  };
  
  proto.alloff =
  proto.removealllisteners = function() {
    delete this._events;
    delete this._onceevents;
  };
  
  return evemitter;
  
  }));
  
  /**
   * matchesselector v2.0.2
   * matchesselector( element, '.selector' )
   * mit license
   */
  
  /*jshint browser: true, strict: true, undef: true, unused: true */
  
  ( function( window, factory ) {
    /*global define: false, module: false */
    'use strict';
    // universal module definition
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'desandro-matches-selector/matches-selector',factory );
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory();
    } else {
      // browser global
      window.matchesselector = factory();
    }
  
  }( window, function factory() {
    'use strict';
  
    var matchesmethod = ( function() {
      var elemproto = window.element.prototype;
      // check for the standard method name first
      if ( elemproto.matches ) {
        return 'matches';
      }
      // check un-prefixed
      if ( elemproto.matchesselector ) {
        return 'matchesselector';
      }
      // check vendor prefixes
      var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
  
      for ( var i=0; i < prefixes.length; i++ ) {
        var prefix = prefixes[i];
        var method = prefix + 'matchesselector';
        if ( elemproto[ method ] ) {
          return method;
        }
      }
    })();
  
    return function matchesselector( elem, selector ) {
      return elem[ matchesmethod ]( selector );
    };
  
  }));
  
  /**
   * fizzy ui utils v2.0.5
   * mit license
   */
  
  /*jshint browser: true, undef: true, unused: true, strict: true */
  
  ( function( window, factory ) {
    // universal module definition
    /*jshint strict: false */ /*globals define, module, require */
  
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'fizzy-ui-utils/utils',[
        'desandro-matches-selector/matches-selector'
      ], function( matchesselector ) {
        return factory( window, matchesselector );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('desandro-matches-selector')
      );
    } else {
      // browser global
      window.fizzyuiutils = factory(
        window,
        window.matchesselector
      );
    }
  
  }( window, function factory( window, matchesselector ) {
  
  
  
  var utils = {};
  
  // ----- extend ----- //
  
  // extends objects
  utils.extend = function( a, b ) {
    for ( var prop in b ) {
      a[ prop ] = b[ prop ];
    }
    return a;
  };
  
  // ----- modulo ----- //
  
  utils.modulo = function( num, div ) {
    return ( ( num % div ) + div ) % div;
  };
  
  // ----- makearray ----- //
  
  // turn element or nodelist into an array
  utils.makearray = function( obj ) {
    var ary = [];
    if ( array.isarray( obj ) ) {
      // use object if already an array
      ary = obj;
    } else if ( obj && typeof obj == 'object' &&
      typeof obj.length == 'number' ) {
      // convert nodelist to array
      for ( var i=0; i < obj.length; i++ ) {
        ary.push( obj[i] );
      }
    } else {
      // array of single index
      ary.push( obj );
    }
    return ary;
  };
  
  // ----- removefrom ----- //
  
  utils.removefrom = function( ary, obj ) {
    var index = ary.indexof( obj );
    if ( index != -1 ) {
      ary.splice( index, 1 );
    }
  };
  
  // ----- getparent ----- //
  
  utils.getparent = function( elem, selector ) {
    while ( elem.parentnode && elem != document.body ) {
      elem = elem.parentnode;
      if ( matchesselector( elem, selector ) ) {
        return elem;
      }
    }
  };
  
  // ----- getqueryelement ----- //
  
  // use element as selector string
  utils.getqueryelement = function( elem ) {
    if ( typeof elem == 'string' ) {
      return document.queryselector( elem );
    }
    return elem;
  };
  
  // ----- handleevent ----- //
  
  // enable .ontype to trigger from .addeventlistener( elem, 'type' )
  utils.handleevent = function( event ) {
    var method = 'on' + event.type;
    if ( this[ method ] ) {
      this[ method ]( event );
    }
  };
  
  // ----- filterfindelements ----- //
  
  utils.filterfindelements = function( elems, selector ) {
    // make array of elems
    elems = utils.makearray( elems );
    var ffelems = [];
  
    elems.foreach( function( elem ) {
      // check that elem is an actual element
      if ( !( elem instanceof htmlelement ) ) {
        return;
      }
      // add elem if no selector
      if ( !selector ) {
        ffelems.push( elem );
        return;
      }
      // filter & find items if we have a selector
      // filter
      if ( matchesselector( elem, selector ) ) {
        ffelems.push( elem );
      }
      // find children
      var childelems = elem.queryselectorall( selector );
      // concat childelems to filterfound array
      for ( var i=0; i < childelems.length; i++ ) {
        ffelems.push( childelems[i] );
      }
    });
  
    return ffelems;
  };
  
  // ----- debouncemethod ----- //
  
  utils.debouncemethod = function( _class, methodname, threshold ) {
    // original method
    var method = _class.prototype[ methodname ];
    var timeoutname = methodname + 'timeout';
  
    _class.prototype[ methodname ] = function() {
      var timeout = this[ timeoutname ];
      if ( timeout ) {
        cleartimeout( timeout );
      }
      var args = arguments;
  
      var _this = this;
      this[ timeoutname ] = settimeout( function() {
        method.apply( _this, args );
        delete _this[ timeoutname ];
      }, threshold || 100 );
    };
  };
  
  // ----- docready ----- //
  
  utils.docready = function( callback ) {
    var readystate = document.readystate;
    if ( readystate == 'complete' || readystate == 'interactive' ) {
      // do async to allow for other scripts to run. metafizzy/flickity#441
      settimeout( callback );
    } else {
      document.addeventlistener( 'domcontentloaded', callback );
    }
  };
  
  // ----- htmlinit ----- //
  
  // http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
  utils.todashed = function( str ) {
    return str.replace( /(.)([a-z])/g, function( match, $1, $2 ) {
      return $1 + '-' + $2;
    }).tolowercase();
  };
  
  var console = window.console;
  /**
   * allow user to initialize classes via [data-namespace] or .js-namespace class
   * htmlinit( widget, 'widgetname' )
   * options are parsed from data-namespace-options
   */
  utils.htmlinit = function( widgetclass, namespace ) {
    utils.docready( function() {
      var dashednamespace = utils.todashed( namespace );
      var dataattr = 'data-' + dashednamespace;
      var dataattrelems = document.queryselectorall( '[' + dataattr + ']' );
      var jsdashelems = document.queryselectorall( '.js-' + dashednamespace );
      var elems = utils.makearray( dataattrelems )
        .concat( utils.makearray( jsdashelems ) );
      var dataoptionsattr = dataattr + '-options';
      var jquery = window.jquery;
  
      elems.foreach( function( elem ) {
        var attr = elem.getattribute( dataattr ) ||
          elem.getattribute( dataoptionsattr );
        var options;
        try {
          options = attr && json.parse( attr );
        } catch ( error ) {
          // log error, do not initialize
          if ( console ) {
            console.error( 'error parsing ' + dataattr + ' on ' + elem.classname +
            ': ' + error );
          }
          return;
        }
        // initialize
        var instance = new widgetclass( elem, options );
        // make available via $().data('namespace')
        if ( jquery ) {
          jquery.data( elem, namespace, instance );
        }
      });
  
    });
  };
  
  // -----  ----- //
  
  return utils;
  
  }));
  
  // core
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/core',[
        'ev-emitter/ev-emitter',
        'fizzy-ui-utils/utils',
      ], function( evemitter, utils) {
        return factory( window, evemitter, utils );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('ev-emitter'),
        require('fizzy-ui-utils')
      );
    } else {
      // browser global
      window.infinitescroll = factory(
        window,
        window.evemitter,
        window.fizzyuiutils
      );
    }
  
  }( window, function factory( window, evemitter, utils ) {
  
  var jquery = window.jquery;
  // internal store of all infinitescroll intances
  var instances = {};
  
  function infinitescroll( element, options ) {
    var queryelem = utils.getqueryelement( element );
  
    if ( !queryelem ) {
      console.error( 'bad element for infinitescroll: ' + ( queryelem || element ) );
      return;
    }
    element = queryelem;
    // do not initialize twice on same element
    if ( element.infinitescrollguid ) {
      var instance = instances[ element.infinitescrollguid ];
      instance.option( options );
      return instance;
    }
  
    this.element = element;
    // options
    this.options = utils.extend( {}, infinitescroll.defaults );
    this.option( options );
    // add jquery
    if ( jquery ) {
      this.$element = jquery( this.element );
    }
  
    this.create();
  }
  
  // defaults
  infinitescroll.defaults = {
    // path: null,
    // hidenav: null,
    // debug: false,
  };
  
  // create & destroy methods
  infinitescroll.create = {};
  infinitescroll.destroy = {};
  
  var proto = infinitescroll.prototype;
  // inherit evemitter
  utils.extend( proto, evemitter.prototype );
  
  // --------------------------  -------------------------- //
  
  // globally unique identifiers
  var guid = 0;
  
  proto.create = function() {
    // create core
    // add id for infinitescroll.data
    var id = this.guid = ++guid;
    this.element.infinitescrollguid = id; // expando
    instances[ id ] = this; // associate via id
    // properties
    this.pageindex = 1; // default to first page
    this.loadcount = 0;
    this.updategetpath();
    // bail if getpath not set
    if ( !this.getpath ) {
      console.error('disabling infinitescroll');
      return;
    }
    this.updategetabsolutepath();
    this.log( 'initialized', [ this.element.classname ] );
    this.calloninit();
    // create features
    for ( var method in infinitescroll.create ) {
      infinitescroll.create[ method ].call( this );
    }
  };
  
  proto.option = function( opts ) {
    utils.extend( this.options, opts );
  };
  
  // call oninit option, used for binding events on init
  proto.calloninit = function() {
    var oninit = this.options.oninit;
    if ( oninit ) {
      oninit.call( this, this );
    }
  };
  
  // ----- events ----- //
  
  proto.dispatchevent = function( type, event, args ) {
    this.log( type, args );
    var emitargs = event ? [ event ].concat( args ) : args;
    this.emitevent( type, emitargs );
    // trigger jquery event
    if ( !jquery || !this.$element ) {
      return;
    }
    // namespace jquery event
    type += '.infinitescroll';
    var $event = type;
    if ( event ) {
      // create jquery event
      var jqevent = jquery.event( event );
      jqevent.type = type;
      $event = jqevent;
    }
    this.$element.trigger( $event, args );
  };
  
  var loggers = {
    initialized: function( classname ) {
      return 'on ' + classname;
    },
    request: function( path ) {
      return 'url: ' + path;
    },
    load: function( response, path ) {
      return ( response.title || '' ) + '. url: ' + path;
    },
    error: function( error, path ) {
      return error + '. url: ' + path;
    },
    append: function( response, path, items ) {
      return items.length + ' items. url: ' + path;
    },
    last: function( response, path ) {
      return 'url: ' + path;
    },
    history: function( title, path ) {
      return 'url: ' + path;
    },
    pageindex: function( index, origin ) {
      return 'current page determined to be: ' + index + ' from ' + origin;
    },
  };
  
  // log events
  proto.log = function( type, args ) {
    if ( !this.options.debug ) {
      return;
    }
    var message = '[infinitescroll] ' + type;
    var logger = loggers[ type ];
    if ( logger ) {
      message += '. ' + logger.apply( this, args );
    }
    console.log( message );
  };
  
  // -------------------------- methods used amoung features -------------------------- //
  
  proto.updatemeasurements = function() {
    this.windowheight = window.innerheight;
    var rect = this.element.getboundingclientrect();
    this.top = rect.top + window.pageyoffset;
  };
  
  proto.updatescroller = function() {
    var elementscroll = this.options.elementscroll;
    if ( !elementscroll ) {
      // default, use window
      this.scroller = window;
      return;
    }
    // if true, set to element, otherwise use option
    this.scroller = elementscroll === true ? this.element :
      utils.getqueryelement( elementscroll );
    if ( !this.scroller ) {
      throw 'unable to find elementscroll: ' + elementscroll;
    }
  };
  
  // -------------------------- page path -------------------------- //
  
  proto.updategetpath = function() {
    var optpath = this.options.path;
    if ( !optpath ) {
      console.error( 'infinitescroll path option required. set as: ' + optpath );
      return;
    }
    // function
    var type = typeof optpath;
    if ( type == 'function' ) {
      this.getpath = optpath;
      return;
    }
    // template string: '/pages/{{#}}.html'
    var templatematch = type == 'string' && optpath.match('{{#}}');
    if ( templatematch ) {
      this.updategetpathtemplate( optpath );
      return;
    }
    // selector: '.next-page-selector'
    this.updategetpathselector( optpath );
  };
  
  proto.updategetpathtemplate = function( optpath ) {
    // set getpath with template string
    this.getpath = function() {
      var nextindex = this.pageindex + 1;
      return optpath.replace( '{{#}}', nextindex );
    }.bind( this );
    // get pageindex from location
    // convert path option into regex to look for pattern in location
    var regexstring = optpath.replace( '{{#}}', '(\\d\\d?\\d?)' );
    var templatere = new regexp( regexstring );
    var match = location.href.match( templatere );
    if ( match ) {
      this.pageindex = parseint( match[1], 10 );
      this.log( 'pageindex', this.pageindex, 'template string' );
    }
  };
  
  var pathregexes = [
    // wordpress & tumblr - example.com/page/2
    // jekyll - example.com/page2
    /^(.*?\/?page\/?)(\d\d?\d?)(.*?$)/,
    // drupal - example.com/?page=1
    /^(.*?\/?\?page=)(\d\d?\d?)(.*?$)/,
    // catch all, last occurence of a number
    /(.*?)(\d\d?\d?)(?!.*\d)(.*?$)/,
  ];
  
  proto.updategetpathselector = function( optpath ) {
    // parse href of link: '.next-page-link'
    var hrefelem = document.queryselector( optpath );
    if ( !hrefelem ) {
      console.error( 'bad infinitescroll path option. next link not found: ' +
        optpath );
      return;
    }
    var href = hrefelem.getattribute('href');
    // try matching href to pathregexes patterns
    var pathparts, regex;
    for ( var i=0; href && i < pathregexes.length; i++ ) {
      regex = pathregexes[i];
      var match = href.match( regex );
      if ( match ) {
        pathparts = match.slice(1); // remove first part
        break;
      }
    }
    if ( !pathparts ) {
      console.error( 'infinitescroll unable to parse next link href: ' + href );
      return;
    }
    this.ispathselector = true; // flag for checklastpage()
    this.getpath = function() {
      var nextindex = this.pageindex + 1;
      return pathparts[0] + nextindex + pathparts[2];
    }.bind( this );
    // get pageindex from href
    this.pageindex = parseint( pathparts[1], 10 ) - 1;
    this.log( 'pageindex', [ this.pageindex, 'next link' ] );
  };
  
  proto.updategetabsolutepath = function() {
    var path = this.getpath();
    // path doesn't start with http or /
    var isabsolute = path.match( /^http/ ) || path.match( /^\// );
    if ( isabsolute ) {
      this.getabsolutepath = this.getpath;
      return;
    }
  
    var pathname = location.pathname;
    // /foo/bar/index.html => /foo/bar
    var directory = pathname.substring( 0, pathname.lastindexof('/') );
  
    this.getabsolutepath = function() {
      return directory + '/' + this.getpath();
    };
  };
  
  // -------------------------- nav -------------------------- //
  
  // hide navigation
  infinitescroll.create.hidenav = function() {
    var nav = utils.getqueryelement( this.options.hidenav );
    if ( !nav ) {
      return;
    }
    nav.style.display = 'none';
    this.nav = nav;
  };
  
  infinitescroll.destroy.hidenav = function() {
    if ( this.nav ) {
      this.nav.style.display = '';
    }
  };
  
  // -------------------------- destroy -------------------------- //
  
  proto.destroy = function() {
    this.alloff(); // remove all event listeners
    // call destroy methods
    for ( var method in infinitescroll.destroy ) {
      infinitescroll.destroy[ method ].call( this );
    }
  
    delete this.element.infinitescrollguid;
    delete instances[ this.guid ];
  };
  
  // -------------------------- utilities -------------------------- //
  
  // https://remysharp.com/2010/07/21/throttling-function-calls
  infinitescroll.throttle = function( fn, threshold ) {
    threshold = threshold || 200;
    var last, timeout;
  
    return function() {
      var now = +new date();
      var args = arguments;
      var trigger = function() {
        last = now;
        fn.apply( this, args );
      }.bind( this );
      if ( last && now < last + threshold ) {
        // hold on to it
        cleartimeout( timeout );
        timeout = settimeout( trigger, threshold );
      } else {
        trigger();
      }
    };
  };
  
  infinitescroll.data = function( elem ) {
    elem = utils.getqueryelement( elem );
    var id = elem && elem.infinitescrollguid;
    return id && instances[ id ];
  };
  
  // set internal jquery, for webpack + jquery v3
  infinitescroll.setjquery = function( $ ) {
    jquery = $;
  };
  
  // -------------------------- setup -------------------------- //
  
  utils.htmlinit( infinitescroll, 'infinite-scroll' );
  
  if ( jquery && jquery.bridget ) {
    jquery.bridget( 'infinitescroll', infinitescroll );
  }
  
  // --------------------------  -------------------------- //
  
  return infinitescroll;
  
  }));
  
  // page-load
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/page-load',[
        './core',
      ], function( infinitescroll ) {
        return factory( window, infinitescroll );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('./core')
      );
    } else {
      // browser global
      factory(
        window,
        window.infinitescroll
      );
    }
  
  }( window, function factory( window, infinitescroll ) {
  
  var proto = infinitescroll.prototype;
  
  // infinitescroll.defaults.append = false;
  infinitescroll.defaults.loadonscroll = true;
  infinitescroll.defaults.checklastpage = true;
  infinitescroll.defaults.responsetype = 'document';
  // infinitescroll.defaults.prefill = false;
  // infinitescroll.defaults.outlayer = null;
  
  infinitescroll.create.pageload = function() {
    this.canload = true;
    this.on( 'scrollthreshold', this.onscrollthresholdload );
    this.on( 'append', this.checklastpage );
    if ( this.options.outlayer ) {
      this.on( 'append', this.onappendoutlayer );
    }
  };
  
  proto.onscrollthresholdload = function() {
    if ( this.options.loadonscroll ) {
      this.loadnextpage();
    }
  };
  
  proto.loadnextpage = function() {
    if ( this.isloading || !this.canload ) {
      return;
    }
  
    var path = this.getabsolutepath();
    this.isloading = true;
  
    var onload = function( response ) {
      this.onpageload( response, path );
    }.bind( this );
  
    var onerror = function( error ) {
      this.onpageerror( error, path );
    }.bind( this );
  
    request( path, this.options.responsetype, onload, onerror );
    this.dispatchevent( 'request', null, [ path ] );
  };
  
  proto.onpageload = function( response, path ) {
    // done loading if not appending
    if ( !this.options.append ) {
      this.isloading = false;
    }
    this.pageindex++;
    this.loadcount++;
    this.dispatchevent( 'load', null, [ response, path ] );
    this.appendnextpage( response, path );
    return response;
  };
  
  proto.appendnextpage = function( response, path ) {
    var optappend = this.options.append;
    // do not append json
    var isdocument = this.options.responsetype == 'document';
    if ( !isdocument || !optappend ) {
      return;
    }
  
    var items = response.queryselectorall( optappend );
    var fragment = getitemsfragment( items );
    var appendready = function () {
      this.appenditems( items, fragment );
      this.isloading = false;
      this.dispatchevent( 'append', null, [ response, path, items ] );
    }.bind( this );
  
    // todo add hook for option to trigger appendready
    if ( this.options.outlayer ) {
      this.appendoutlayeritems( fragment, appendready );
    } else {
      appendready();
    }
  };
  
  proto.appenditems = function( items, fragment ) {
    if ( !items || !items.length ) {
      return;
    }
    // get fragment if not provided
    fragment = fragment || getitemsfragment( items );
    refreshscripts( fragment );
    this.element.appendchild( fragment );
  };
  
  function getitemsfragment( items ) {
    // add items to fragment
    var fragment = document.createdocumentfragment();
    for ( var i=0; items && i < items.length; i++ ) {
      fragment.appendchild( items[i] );
    }
    return fragment;
  }
  
  // replace <script>s with copies so they load
  // <script>s added by infinitescroll will not load
  // similar to https://stackoverflow.com/questions/610995
  function refreshscripts( fragment ) {
    var scripts = fragment.queryselectorall('script');
    for ( var i=0; i < scripts.length; i++ ) {
      var script = scripts[i];
      var freshscript = document.createelement('script');
      copyattributes( script, freshscript );
      script.parentnode.replacechild( freshscript, script );
    }
  }
  
  function copyattributes( fromnode, tonode ) {
    var attrs = fromnode.attributes;
    for ( var i=0; i < attrs.length; i++ ) {
      var attr = attrs[i];
      tonode.setattribute( attr.name, attr.value );
    }
  }
  
  // ----- outlayer ----- //
  
  proto.appendoutlayeritems = function( fragment, appendready ) {
    var imagesloaded = infinitescroll.imagesloaded || window.imagesloaded;
    if ( !imagesloaded ) {
      console.error('[infinitescroll] imagesloaded required for outlayer option');
      this.isloading = false;
      return;
    }
    // append once images loaded
    imagesloaded( fragment, appendready );
  };
  
  proto.onappendoutlayer = function( response, path, items ) {
    this.options.outlayer.appended( items );
  };
  
  // ----- checklastpage ----- //
  
  // check response for next element
  proto.checklastpage = function( response, path ) {
    var checklastpage = this.options.checklastpage;
    if ( !checklastpage ) {
      return;
    }
  
    var pathopt = this.options.path;
    // if path is function, check if next path is truthy
    if ( typeof pathopt == 'function' ) {
      var nextpath = this.getpath();
      if ( !nextpath ) {
        this.lastpagereached( response, path );
        return;
      }
    }
    // get selector from checklastpage or path option
    var selector;
    if ( typeof checklastpage == 'string' ) {
      selector = checklastpage;
    } else if ( this.ispathselector ) {
      // path option is selector string
      selector = pathopt;
    }
    // check last page for selector
    // bail if no selector or not document response
    if ( !selector || !response.queryselector ) {
      return;
    }
    // check if response has selector
    var nextelem = response.queryselector( selector );
    if ( !nextelem ) {
      this.lastpagereached( response, path );
    }
  };
  
  proto.lastpagereached = function( response, path ) {
    this.canload = false;
    this.dispatchevent( 'last', null, [ response, path ] );
  };
  
  // ----- error ----- //
  
  proto.onpageerror = function( error, path ) {
    this.isloading = false;
    this.canload = false;
    this.dispatchevent( 'error', null, [ error, path ] );
    return error;
  };
  
  // -------------------------- prefill -------------------------- //
  
  infinitescroll.create.prefill = function() {
    if ( !this.options.prefill ) {
      return;
    }
    var append = this.options.append;
    if ( !append ) {
      console.error( 'append option required for prefill. set as :' + append );
      return;
    }
    this.updatemeasurements();
    this.updatescroller();
    this.isprefilling = true;
    this.on( 'append', this.prefill );
    this.once( 'error', this.stopprefill );
    this.once( 'last', this.stopprefill );
    this.prefill();
  };
  
  proto.prefill = function() {
    var distance = this.getprefilldistance();
    this.isprefilling = distance >= 0;
    if ( this.isprefilling ) {
      this.log('prefill');
      this.loadnextpage();
    } else {
      this.stopprefill();
    }
  };
  
  proto.getprefilldistance = function() {
    // element scroll
    if ( this.options.elementscroll ) {
      return this.scroller.clientheight - this.scroller.scrollheight;
    }
    // window
    return this.windowheight - this.element.clientheight;
  };
  
  proto.stopprefill = function() {
    console.log('stopping prefill');
    this.off( 'append', this.prefill );
  };
  
  // -------------------------- request -------------------------- //
  
  function request( url, responsetype, onload, onerror ) {
    var req = new xmlhttprequest();
    req.open( 'get', url, true );
    // set responsetype document to return dom
    req.responsetype = responsetype || '';
  
    // set x-requested-with header to check that is ajax request
    req.setrequestheader('x-requested-with', 'xmlhttprequest');
  
    req.onload = function() {
      if ( req.status == 200 ) {
        onload( req.response );
      } else {
        // not 200 ok, error
        var error = new error( req.statustext );
        onerror( error );
      }
    };
  
    // handle network errors
    req.onerror = function() {
      var error = new error( 'network error requesting ' + url );
      onerror( error );
    };
  
    req.send();
  }
  
  // --------------------------  -------------------------- //
  
  return infinitescroll;
  
  }));
  
  // scroll-watch
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/scroll-watch',[
        './core',
        'fizzy-ui-utils/utils',
      ], function( infinitescroll, utils ) {
        return factory( window, infinitescroll, utils );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('./core'),
        require('fizzy-ui-utils')
      );
    } else {
      // browser global
      factory(
        window,
        window.infinitescroll,
        window.fizzyuiutils
      );
    }
  
  }( window, function factory( window, infinitescroll, utils ) {
  
  var proto = infinitescroll.prototype;
  
  // default options
  infinitescroll.defaults.scrollthreshold = 400;
  // infinitescroll.defaults.elementscroll = null;
  
  infinitescroll.create.scrollwatch = function() {
    // events
    this.pagescrollhandler = this.onpagescroll.bind( this );
    this.resizehandler = this.onresize.bind( this );
  
    var scrollthreshold = this.options.scrollthreshold;
    var isenable = scrollthreshold || scrollthreshold === 0;
    if ( isenable ) {
      this.enablescrollwatch();
    }
  };
  
  infinitescroll.destroy.scrollwatch = function() {
    this.disablescrollwatch();
  };
  
  proto.enablescrollwatch = function() {
    if ( this.isscrollwatching ) {
      return;
    }
    this.isscrollwatching = true;
    this.updatemeasurements();
    this.updatescroller();
    // todo disable after error?
    this.on( 'last', this.disablescrollwatch );
    this.bindscrollwatchevents( true );
  };
  
  proto.disablescrollwatch = function() {
    if ( !this.isscrollwatching ) {
      return;
    }
    this.bindscrollwatchevents( false );
    delete this.isscrollwatching;
  };
  
  proto.bindscrollwatchevents = function( isbind ) {
    var addremove = isbind ? 'addeventlistener' : 'removeeventlistener';
    this.scroller[ addremove ]( 'scroll', this.pagescrollhandler );
    window[ addremove ]( 'resize', this.resizehandler );
  };
  
  proto.onpagescroll = infinitescroll.throttle( function() {
    var distance = this.getbottomdistance();
    if ( distance <= this.options.scrollthreshold ) {
      this.dispatchevent('scrollthreshold');
    }
  });
  
  proto.getbottomdistance = function() {
    if ( this.options.elementscroll ) {
      return this.getelementbottomdistance();
    } else {
      return this.getwindowbottomdistance();
    }
  };
  
  proto.getwindowbottomdistance = function() {
    var bottom = this.top + this.element.clientheight;
    var scrolly = window.pageyoffset + this.windowheight;
    return bottom - scrolly;
  };
  
  proto.getelementbottomdistance = function() {
    var bottom = this.scroller.scrollheight;
    var scrolly = this.scroller.scrolltop + this.scroller.clientheight;
    return bottom - scrolly;
  };
  
  proto.onresize = function() {
    this.updatemeasurements();
  };
  
  utils.debouncemethod( infinitescroll, 'onresize', 150 );
  
  // --------------------------  -------------------------- //
  
  return infinitescroll;
  
  }));
  
  // history
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/history',[
        './core',
        'fizzy-ui-utils/utils',
      ], function( infinitescroll, utils ) {
        return factory( window, infinitescroll, utils );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('./core'),
        require('fizzy-ui-utils')
      );
    } else {
      // browser global
      factory(
        window,
        window.infinitescroll,
        window.fizzyuiutils
      );
    }
  
  }( window, function factory( window, infinitescroll, utils ) {
  
  var proto = infinitescroll.prototype;
  
  infinitescroll.defaults.history = 'replace';
  // infinitescroll.defaults.historytitle = false;
  
  var link = document.createelement('a');
  
  // ----- create/destroy ----- //
  
  infinitescroll.create.history = function() {
    if ( !this.options.history ) {
      return;
    }
    // check for same origin
    link.href = this.getabsolutepath();
    // ms edge does not have origin on link https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12236493/
    var linkorigin = link.origin || link.protocol + '//' + link.host;
    var issameorigin = linkorigin == location.origin;
    if ( !issameorigin ) {
      console.error( '[infinitescroll] cannot set history with different origin: ' +
        link.origin + ' on ' + location.origin +
        ' . history behavior disabled.' );
      return;
    }
  
    // two ways to handle changing history
    if ( this.options.append ) {
      this.createhistoryappend();
    } else {
      this.createhistorypageload();
    }
  };
  
  proto.createhistoryappend = function() {
    this.updatemeasurements();
    this.updatescroller();
    // array of scroll positions of appended pages
    this.scrollpages = [
      {
        // first page
        top: 0,
        path: location.href,
        title: document.title,
      }
    ];
    this.scrollpageindex = 0;
    // events
    this.scrollhistoryhandler = this.onscrollhistory.bind( this );
    this.unloadhandler = this.onunload.bind( this );
    this.scroller.addeventlistener( 'scroll', this.scrollhistoryhandler );
    this.on( 'append', this.onappendhistory );
    this.bindhistoryappendevents( true );
  };
  
  proto.bindhistoryappendevents = function( isbind ) {
    var addremove = isbind ? 'addeventlistener' : 'removeeventlistener';
    this.scroller[ addremove ]( 'scroll', this.scrollhistoryhandler );
    window[ addremove ]( 'unload', this.unloadhandler );
  };
  
  proto.createhistorypageload = function() {
    this.on( 'load', this.onpageloadhistory );
  };
  
  infinitescroll.destroy.history =
  proto.destroyhistory = function() {
    var ishistoryappend = this.options.history && this.options.append;
    if ( ishistoryappend ) {
      this.bindhistoryappendevents( false );
    }
  };
  
  // ----- append history ----- //
  
  proto.onappendhistory = function( response, path, items ) {
    var firstitem = items[0];
    var elemscrolly = this.getelementscrolly( firstitem );
    // resolve path
    link.href = path;
    // add page data to hash
    this.scrollpages.push({
      top: elemscrolly,
      path: link.href,
      title: response.title,
    });
  };
  
  proto.getelementscrolly = function( elem ) {
    if ( this.options.elementscroll ) {
      return this.getelementelementscrolly( elem );
    } else {
      return this.getelementwindowscrolly( elem );
    }
  };
  
  proto.getelementwindowscrolly = function( elem ) {
    var rect = elem.getboundingclientrect();
    return rect.top + window.pageyoffset;
  };
  
  // wow, stupid name
  proto.getelementelementscrolly = function( elem ) {
    return elem.offsettop - this.top;
  };
  
  proto.onscrollhistory = function() {
    // cycle through positions, find biggest without going over
    var scrollviewy = this.getscrollviewy();
    var pageindex, page;
    for ( var i=0; i < this.scrollpages.length; i++ ) {
      var scrollpage = this.scrollpages[i];
      if ( scrollpage.top >= scrollviewy ) {
        break;
      }
      pageindex = i;
      page = scrollpage;
    }
    // set history if changed
    if ( pageindex != this.scrollpageindex ) {
      this.scrollpageindex = pageindex;
      this.sethistory( page.title, page.path );
    }
  };
  
  utils.debouncemethod( infinitescroll, 'onscrollhistory', 150 );
  
  proto.getscrollviewy = function() {
    if ( this.options.elementscroll ) {
      return this.scroller.scrolltop + this.scroller.clientheight/2;
    } else {
      return window.pageyoffset + this.windowheight/2;
    }
  };
  
  proto.sethistory = function( title, path ) {
    var opthistory = this.options.history;
    var historymethod = opthistory && history[ opthistory + 'state' ];
    if ( !historymethod ) {
      return;
    }
  
    history[ opthistory + 'state' ]( null, title, path );
  
    if ( this.options.historytitle ) {
      document.title = title;
    }
  
    this.dispatchevent( 'history', null, [ title, path ] );
  };
  
  // scroll to top to prevent initial scroll-reset after page refresh
  // http://stackoverflow.com/a/18633915/182183
  proto.onunload = function() {
    var pageindex = this.scrollpageindex;
    if ( pageindex === 0 ) {
      return;
    }
    // calculate where scroll position would be on refresh
    var scrollpage = this.scrollpages[ pageindex ];
    var scrolly = window.pageyoffset - scrollpage.top + this.top;
    // disable scroll event before setting scroll #679
    this.destroyhistory();
    scrollto( 0, scrolly );
  };
  
  // ----- load history ----- //
  
  // update url
  proto.onpageloadhistory = function( response, path ) {
    this.sethistory( response.title, path );
  };
  
  // --------------------------  -------------------------- //
  
  return infinitescroll;
  
  }));
  
  // button
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/button',[
        './core',
        'fizzy-ui-utils/utils',
      ], function( infinitescroll, utils ) {
        return factory( window, infinitescroll, utils );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('./core'),
        require('fizzy-ui-utils')
      );
    } else {
      // browser global
      factory(
        window,
        window.infinitescroll,
        window.fizzyuiutils
      );
    }
  
  }( window, function factory( window, infinitescroll, utils ) {
  
  // infinitescroll.defaults.button = null;
  
  infinitescroll.create.button = function() {
    var buttonelem = utils.getqueryelement( this.options.button );
    if ( buttonelem ) {
      this.button = new infinitescrollbutton( buttonelem, this );
      return;
    }
  };
  
  infinitescroll.destroy.button = function() {
    if ( this.button ) {
      this.button.destroy();
    }
  };
  
  // -------------------------- infinitescrollbutton -------------------------- //
  
  function infinitescrollbutton( element, infscroll ) {
    this.element = element;
    this.infscroll = infscroll;
    // events
    this.clickhandler = this.onclick.bind( this );
    this.element.addeventlistener( 'click', this.clickhandler );
    infscroll.on( 'request', this.disable.bind( this ) );
    infscroll.on( 'load', this.enable.bind( this ) );
    infscroll.on( 'error', this.hide.bind( this ) );
    infscroll.on( 'last', this.hide.bind( this ) );
  }
  
  infinitescrollbutton.prototype.onclick = function( event ) {
    event.preventdefault();
    this.infscroll.loadnextpage();
  };
  
  infinitescrollbutton.prototype.enable = function() {
    this.element.removeattribute('disabled');
  };
  
  infinitescrollbutton.prototype.disable = function() {
    this.element.disabled = 'disabled';
  };
  
  infinitescrollbutton.prototype.hide = function() {
    this.element.style.display = 'none';
  };
  
  infinitescrollbutton.prototype.destroy = function() {
    this.element.removeeventlistener( 'click', this.clickhandler );
  };
  
  // --------------------------  -------------------------- //
  
  infinitescroll.button = infinitescrollbutton;
  
  return infinitescroll;
  
  }));
  
  // status
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'infinite-scroll/js/status',[
        './core',
        'fizzy-ui-utils/utils',
      ], function( infinitescroll, utils ) {
        return factory( window, infinitescroll, utils );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('./core'),
        require('fizzy-ui-utils')
      );
    } else {
      // browser global
      factory(
        window,
        window.infinitescroll,
        window.fizzyuiutils
      );
    }
  
  }( window, function factory( window, infinitescroll, utils ) { 
  
  var proto = infinitescroll.prototype;
  
  // infinitescroll.defaults.status = null;
  
  infinitescroll.create.status = function() {
    var statuselem = utils.getqueryelement( this.options.status );
    if ( !statuselem ) {
      return;
    }
    // elements
    this.statuselement = statuselem;
    this.statuseventelements = {
      request: statuselem.queryselector('.infinite-scroll-request'),
      error: statuselem.queryselector('.infinite-scroll-error'),
      last: statuselem.queryselector('.infinite-scroll-last'),
    };
    // events
    this.on( 'request', this.showrequeststatus );
    this.on( 'error', this.showerrorstatus );
    this.on( 'last', this.showlaststatus );
    this.bindhidestatus('on');
  };
  
  proto.bindhidestatus = function( bindmethod ) {
    var hideevent = this.options.append ? 'append' : 'load';
    this[ bindmethod ]( hideevent, this.hideallstatus );
  };
  
  proto.showrequeststatus = function() {
    this.showstatus('request');
  };
  
  proto.showerrorstatus = function() {
    this.showstatus('error');
  };
  
  proto.showlaststatus = function() {
    this.showstatus('last');
    // prevent last then append event race condition from showing last status #706
    this.bindhidestatus('off');
  };
  
  proto.showstatus = function( eventname ) {
    show( this.statuselement );
    this.hidestatuseventelements();
    var eventelem = this.statuseventelements[ eventname ];
    show( eventelem );
  };
  
  proto.hideallstatus = function() {
    hide( this.statuselement );
    this.hidestatuseventelements();
  };
  
  proto.hidestatuseventelements = function() {
    for ( var type in this.statuseventelements ) {
      var eventelem = this.statuseventelements[ type ];
      hide( eventelem );
    }
  };
  
  // --------------------------  -------------------------- //
  
  function hide( elem ) {
    setdisplay( elem, 'none' );
  }
  
  function show( elem ) {
    setdisplay( elem, 'block' );
  }
  
  function setdisplay( elem, value ) {
    if ( elem ) {
      elem.style.display = value;
    }
  }
  
  // --------------------------  -------------------------- //
  
  return infinitescroll;
  
  }));
  
  /*!
   * infinite scroll v3.0.2
   * automatically add next page
   *
   * licensed gplv3 for open source use
   * or infinite scroll commercial license for commercial use
   *
   * https://infinite-scroll.com
   * copyright 2017 metafizzy
   */
  
  ( function( window, factory ) {
    // universal module definition
    /* globals define, module, require */
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( [
        'infinite-scroll/js/core',
        'infinite-scroll/js/page-load',
        'infinite-scroll/js/scroll-watch',
        'infinite-scroll/js/history',
        'infinite-scroll/js/button',
        'infinite-scroll/js/status',
      ], factory );
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        require('./core'),
        require('./page-load'),
        require('./scroll-watch'),
        require('./history'),
        require('./button'),
        require('./status')
      );
    }
  
  })( window, function factory( infinitescroll ) {
    return infinitescroll;
  });
  
  /*!
   * imagesloaded v4.1.3
   * javascript is all like "you images are done yet or what?"
   * mit license
   */
  
  ( function( window, factory ) { 'use strict';
    // universal module definition
  
    /*global define: false, module: false, require: false */
  
    if ( typeof define == 'function' && define.amd ) {
      // amd
      define( 'imagesloaded/imagesloaded',[
        'ev-emitter/ev-emitter'
      ], function( evemitter ) {
        return factory( window, evemitter );
      });
    } else if ( typeof module == 'object' && module.exports ) {
      // commonjs
      module.exports = factory(
        window,
        require('ev-emitter')
      );
    } else {
      // browser global
      window.imagesloaded = factory(
        window,
        window.evemitter
      );
    }
  
  })( typeof window !== 'undefined' ? window : this,
  
  // --------------------------  factory -------------------------- //
  
  function factory( window, evemitter ) {
  
  
  
  var $ = window.jquery;
  var console = window.console;
  
  // -------------------------- helpers -------------------------- //
  
  // extend objects
  function extend( a, b ) {
    for ( var prop in b ) {
      a[ prop ] = b[ prop ];
    }
    return a;
  }
  
  // turn element or nodelist into an array
  function makearray( obj ) {
    var ary = [];
    if ( array.isarray( obj ) ) {
      // use object if already an array
      ary = obj;
    } else if ( typeof obj.length == 'number' ) {
      // convert nodelist to array
      for ( var i=0; i < obj.length; i++ ) {
        ary.push( obj[i] );
      }
    } else {
      // array of single index
      ary.push( obj );
    }
    return ary;
  }
  
  // -------------------------- imagesloaded -------------------------- //
  
  /**
   * @param {array, element, nodelist, string} elem
   * @param {object or function} options - if function, use as callback
   * @param {function} onalways - callback function
   */
  function imagesloaded( elem, options, onalways ) {
    // coerce imagesloaded() without new, to be new imagesloaded()
    if ( !( this instanceof imagesloaded ) ) {
      return new imagesloaded( elem, options, onalways );
    }
    // use elem as selector string
    if ( typeof elem == 'string' ) {
      elem = document.queryselectorall( elem );
    }
  
    this.elements = makearray( elem );
    this.options = extend( {}, this.options );
  
    if ( typeof options == 'function' ) {
      onalways = options;
    } else {
      extend( this.options, options );
    }
  
    if ( onalways ) {
      this.on( 'always', onalways );
    }
  
    this.getimages();
  
    if ( $ ) {
      // add jquery deferred object
      this.jqdeferred = new $.deferred();
    }
  
    // hack check async to allow time to bind listeners
    settimeout( function() {
      this.check();
    }.bind( this ));
  }
  
  imagesloaded.prototype = object.create( evemitter.prototype );
  
  imagesloaded.prototype.options = {};
  
  imagesloaded.prototype.getimages = function() {
    this.images = [];
  
    // filter & find items if we have an item selector
    this.elements.foreach( this.addelementimages, this );
  };
  
  /**
   * @param {node} element
   */
  imagesloaded.prototype.addelementimages = function( elem ) {
    // filter siblings
    if ( elem.nodename == 'img' ) {
      this.addimage( elem );
    }
    // get background image on element
    if ( this.options.background === true ) {
      this.addelementbackgroundimages( elem );
    }
  
    // find children
    // no non-element nodes, #143
    var nodetype = elem.nodetype;
    if ( !nodetype || !elementnodetypes[ nodetype ] ) {
      return;
    }
    var childimgs = elem.queryselectorall('img');
    // concat childelems to filterfound array
    for ( var i=0; i < childimgs.length; i++ ) {
      var img = childimgs[i];
      this.addimage( img );
    }
  
    // get child background images
    if ( typeof this.options.background == 'string' ) {
      var children = elem.queryselectorall( this.options.background );
      for ( i=0; i < children.length; i++ ) {
        var child = children[i];
        this.addelementbackgroundimages( child );
      }
    }
  };
  
  var elementnodetypes = {
    1: true,
    9: true,
    11: true
  };
  
  imagesloaded.prototype.addelementbackgroundimages = function( elem ) {
    var style = getcomputedstyle( elem );
    if ( !style ) {
      // firefox returns null if in a hidden iframe https://bugzil.la/548397
      return;
    }
    // get url inside url("...")
    var reurl = /url\((['"])?(.*?)\1\)/gi;
    var matches = reurl.exec( style.backgroundimage );
    while ( matches !== null ) {
      var url = matches && matches[2];
      if ( url ) {
        this.addbackground( url, elem );
      }
      matches = reurl.exec( style.backgroundimage );
    }
  };
  
  /**
   * @param {image} img
   */
  imagesloaded.prototype.addimage = function( img ) {
    var loadingimage = new loadingimage( img );
    this.images.push( loadingimage );
  };
  
  imagesloaded.prototype.addbackground = function( url, elem ) {
    var background = new background( url, elem );
    this.images.push( background );
  };
  
  imagesloaded.prototype.check = function() {
    var _this = this;
    this.progressedcount = 0;
    this.hasanybroken = false;
    // complete if no images
    if ( !this.images.length ) {
      this.complete();
      return;
    }
  
    function onprogress( image, elem, message ) {
      // hack - chrome triggers event before object properties have changed. #83
      settimeout( function() {
        _this.progress( image, elem, message );
      });
    }
  
    this.images.foreach( function( loadingimage ) {
      loadingimage.once( 'progress', onprogress );
      loadingimage.check();
    });
  };
  
  imagesloaded.prototype.progress = function( image, elem, message ) {
    this.progressedcount++;
    this.hasanybroken = this.hasanybroken || !image.isloaded;
    // progress event
    this.emitevent( 'progress', [ this, image, elem ] );
    if ( this.jqdeferred && this.jqdeferred.notify ) {
      this.jqdeferred.notify( this, image );
    }
    // check if completed
    if ( this.progressedcount == this.images.length ) {
      this.complete();
    }
  
    if ( this.options.debug && console ) {
      console.log( 'progress: ' + message, image, elem );
    }
  };
  
  imagesloaded.prototype.complete = function() {
    var eventname = this.hasanybroken ? 'fail' : 'done';
    this.iscomplete = true;
    this.emitevent( eventname, [ this ] );
    this.emitevent( 'always', [ this ] );
    if ( this.jqdeferred ) {
      var jqmethod = this.hasanybroken ? 'reject' : 'resolve';
      this.jqdeferred[ jqmethod ]( this );
    }
  };
  
  // --------------------------  -------------------------- //
  
  function loadingimage( img ) {
    this.img = img;
  }
  
  loadingimage.prototype = object.create( evemitter.prototype );
  
  loadingimage.prototype.check = function() {
    // if complete is true and browser supports natural sizes,
    // try to check for image status manually.
    var iscomplete = this.getisimagecomplete();
    if ( iscomplete ) {
      // report based on naturalwidth
      this.confirm( this.img.naturalwidth !== 0, 'naturalwidth' );
      return;
    }
  
    // if none of the checks above matched, simulate loading on detached element.
    this.proxyimage = new image();
    this.proxyimage.addeventlistener( 'load', this );
    this.proxyimage.addeventlistener( 'error', this );
    // bind to image as well for firefox. #191
    this.img.addeventlistener( 'load', this );
    this.img.addeventlistener( 'error', this );
    this.proxyimage.src = this.img.src;
  };
  
  loadingimage.prototype.getisimagecomplete = function() {
    return this.img.complete && this.img.naturalwidth !== undefined;
  };
  
  loadingimage.prototype.confirm = function( isloaded, message ) {
    this.isloaded = isloaded;
    this.emitevent( 'progress', [ this, this.img, message ] );
  };
  
  // ----- events ----- //
  
  // trigger specified handler for event type
  loadingimage.prototype.handleevent = function( event ) {
    var method = 'on' + event.type;
    if ( this[ method ] ) {
      this[ method ]( event );
    }
  };
  
  loadingimage.prototype.onload = function() {
    this.confirm( true, 'onload' );
    this.unbindevents();
  };
  
  loadingimage.prototype.onerror = function() {
    this.confirm( false, 'onerror' );
    this.unbindevents();
  };
  
  loadingimage.prototype.unbindevents = function() {
    this.proxyimage.removeeventlistener( 'load', this );
    this.proxyimage.removeeventlistener( 'error', this );
    this.img.removeeventlistener( 'load', this );
    this.img.removeeventlistener( 'error', this );
  };
  
  // -------------------------- background -------------------------- //
  
  function background( url, element ) {
    this.url = url;
    this.element = element;
    this.img = new image();
  }
  
  // inherit loadingimage prototype
  background.prototype = object.create( loadingimage.prototype );
  
  background.prototype.check = function() {
    this.img.addeventlistener( 'load', this );
    this.img.addeventlistener( 'error', this );
    this.img.src = this.url;
    // check if image is already complete
    var iscomplete = this.getisimagecomplete();
    if ( iscomplete ) {
      this.confirm( this.img.naturalwidth !== 0, 'naturalwidth' );
      this.unbindevents();
    }
  };
  
  background.prototype.unbindevents = function() {
    this.img.removeeventlistener( 'load', this );
    this.img.removeeventlistener( 'error', this );
  };
  
  background.prototype.confirm = function( isloaded, message ) {
    this.isloaded = isloaded;
    this.emitevent( 'progress', [ this, this.element, message ] );
  };
  
  // -------------------------- jquery -------------------------- //
  
  imagesloaded.makejqueryplugin = function( jquery ) {
    jquery = jquery || window.jquery;
    if ( !jquery ) {
      return;
    }
    // set local variable
    $ = jquery;
    // $().imagesloaded()
    $.fn.imagesloaded = function( options, callback ) {
      var instance = new imagesloaded( this, options, callback );
      return instance.jqdeferred.promise( $(this) );
    };
  };
  // try making plugin
  imagesloaded.makejqueryplugin();
  
  // --------------------------  -------------------------- //
  
  return imagesloaded;
  
  });