/*!
Waypoints - 4.0.1
Copyright © 2011-2016 Caleb Troughton
Licensed under the MIT license.
https://github.com/imakewebthings/waypoints/blob/master/licenses.txt
*/
(function() {
  'use strict'

  var keyCounter = 0
  var allWaypoints = {}

  /* http://imakewebthings.com/waypoints/api/waypoint */
  function Waypoint(options) {
	if (!options) {
	  throw new Error('No options passed to Waypoint constructor')
	}
	if (!options.element) {
	  throw new Error('No element option passed to Waypoint constructor')
	}
	if (!options.handler) {
	  throw new Error('No handler option passed to Waypoint constructor')
	}

	this.key = 'waypoint-' + keyCounter
	this.options = Waypoint.Adapter.extend({}, Waypoint.defaults, options)
	this.element = this.options.element
	this.adapter = new Waypoint.Adapter(this.element)
	this.callback = options.handler
	this.axis = this.options.horizontal ? 'horizontal' : 'vertical'
	this.enabled = this.options.enabled
	this.triggerPoint = null
	this.group = Waypoint.Group.findOrCreate({
	  name: this.options.group,
	  axis: this.axis
	})
	this.context = Waypoint.Context.findOrCreateByElement(this.options.context)

	if (Waypoint.offsetAliases[this.options.offset]) {
	  this.options.offset = Waypoint.offsetAliases[this.options.offset]
	}
	this.group.add(this)
	this.context.add(this)
	allWaypoints[this.key] = this
	keyCounter += 1
  }

  /* Private */
  Waypoint.prototype.queueTrigger = function(direction) {
	this.group.queueTrigger(this, direction)
  }

  /* Private */
  Waypoint.prototype.trigger = function(args) {
	if (!this.enabled) {
	  return
	}
	if (this.callback) {
	  this.callback.apply(this, args)
	}
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/destroy */
  Waypoint.prototype.destroy = function() {
	this.context.remove(this)
	this.group.remove(this)
	delete allWaypoints[this.key]
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/disable */
  Waypoint.prototype.disable = function() {
	this.enabled = false
	return this
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/enable */
  Waypoint.prototype.enable = function() {
	this.context.refresh()
	this.enabled = true
	return this
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/next */
  Waypoint.prototype.next = function() {
	return this.group.next(this)
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/previous */
  Waypoint.prototype.previous = function() {
	return this.group.previous(this)
  }

  /* Private */
  Waypoint.invokeAll = function(method) {
	var allWaypointsArray = []
	for (var waypointKey in allWaypoints) {
	  allWaypointsArray.push(allWaypoints[waypointKey])
	}
	for (var i = 0, end = allWaypointsArray.length; i < end; i++) {
	  allWaypointsArray[i][method]()
	}
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/destroy-all */
  Waypoint.destroyAll = function() {
	Waypoint.invokeAll('destroy')
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/disable-all */
  Waypoint.disableAll = function() {
	Waypoint.invokeAll('disable')
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/enable-all */
  Waypoint.enableAll = function() {
	Waypoint.Context.refreshAll()
	for (var waypointKey in allWaypoints) {
	  allWaypoints[waypointKey].enabled = true
	}
	return this
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/refresh-all */
  Waypoint.refreshAll = function() {
	Waypoint.Context.refreshAll()
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/viewport-height */
  Waypoint.viewportHeight = function() {
	return window.innerHeight || document.documentElement.clientHeight
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/viewport-width */
  Waypoint.viewportWidth = function() {
	return document.documentElement.clientWidth
  }

  Waypoint.adapters = []

  Waypoint.defaults = {
	context: window,
	continuous: true,
	enabled: true,
	group: 'default',
	horizontal: false,
	offset: 0
  }

  Waypoint.offsetAliases = {
	'bottom-in-view': function() {
	  return this.context.innerHeight() - this.adapter.outerHeight()
	},
	'right-in-view': function() {
	  return this.context.innerWidth() - this.adapter.outerWidth()
	}
  }

  window.Waypoint = Waypoint
}())
;(function() {
  'use strict'

  function requestAnimationFrameShim(callback) {
	window.setTimeout(callback, 1000 / 60)
  }

  var keyCounter = 0
  var contexts = {}
  var Waypoint = window.Waypoint
  var oldWindowLoad = window.onload

  /* http://imakewebthings.com/waypoints/api/context */
  function Context(element) {
	this.element = element
	this.Adapter = Waypoint.Adapter
	this.adapter = new this.Adapter(element)
	this.key = 'waypoint-context-' + keyCounter
	this.didScroll = false
	this.didResize = false
	this.oldScroll = {
	  x: this.adapter.scrollLeft(),
	  y: this.adapter.scrollTop()
	}
	this.waypoints = {
	  vertical: {},
	  horizontal: {}
	}

	element.waypointContextKey = this.key
	contexts[element.waypointContextKey] = this
	keyCounter += 1
	if (!Waypoint.windowContext) {
	  Waypoint.windowContext = true
	  Waypoint.windowContext = new Context(window)
	}

	this.createThrottledScrollHandler()
	this.createThrottledResizeHandler()
  }

  /* Private */
  Context.prototype.add = function(waypoint) {
	var axis = waypoint.options.horizontal ? 'horizontal' : 'vertical'
	this.waypoints[axis][waypoint.key] = waypoint
	this.refresh()
  }

  /* Private */
  Context.prototype.checkEmpty = function() {
	var horizontalEmpty = this.Adapter.isEmptyObject(this.waypoints.horizontal)
	var verticalEmpty = this.Adapter.isEmptyObject(this.waypoints.vertical)
	var isWindow = this.element == this.element.window
	if (horizontalEmpty && verticalEmpty && !isWindow) {
	  this.adapter.off('.waypoints')
	  delete contexts[this.key]
	}
  }

  /* Private */
  Context.prototype.createThrottledResizeHandler = function() {
	var self = this

	function resizeHandler() {
	  self.handleResize()
	  self.didResize = false
	}

	this.adapter.on('resize.waypoints', function() {
	  if (!self.didResize) {
		self.didResize = true
		Waypoint.requestAnimationFrame(resizeHandler)
	  }
	})
  }

  /* Private */
  Context.prototype.createThrottledScrollHandler = function() {
	var self = this
	function scrollHandler() {
	  self.handleScroll()
	  self.didScroll = false
	}

	this.adapter.on('scroll.waypoints', function() {
	  if (!self.didScroll || Waypoint.isTouch) {
		self.didScroll = true
		Waypoint.requestAnimationFrame(scrollHandler)
	  }
	})
  }

  /* Private */
  Context.prototype.handleResize = function() {
	Waypoint.Context.refreshAll()
  }

  /* Private */
  Context.prototype.handleScroll = function() {
	var triggeredGroups = {}
	var axes = {
	  horizontal: {
		newScroll: this.adapter.scrollLeft(),
		oldScroll: this.oldScroll.x,
		forward: 'right',
		backward: 'left'
	  },
	  vertical: {
		newScroll: this.adapter.scrollTop(),
		oldScroll: this.oldScroll.y,
		forward: 'down',
		backward: 'up'
	  }
	}

	for (var axisKey in axes) {
	  var axis = axes[axisKey]
	  var isForward = axis.newScroll > axis.oldScroll
	  var direction = isForward ? axis.forward : axis.backward

	  for (var waypointKey in this.waypoints[axisKey]) {
		var waypoint = this.waypoints[axisKey][waypointKey]
		if (waypoint.triggerPoint === null) {
		  continue
		}
		var wasBeforeTriggerPoint = axis.oldScroll < waypoint.triggerPoint
		var nowAfterTriggerPoint = axis.newScroll >= waypoint.triggerPoint
		var crossedForward = wasBeforeTriggerPoint && nowAfterTriggerPoint
		var crossedBackward = !wasBeforeTriggerPoint && !nowAfterTriggerPoint
		if (crossedForward || crossedBackward) {
		  waypoint.queueTrigger(direction)
		  triggeredGroups[waypoint.group.id] = waypoint.group
		}
	  }
	}

	for (var groupKey in triggeredGroups) {
	  triggeredGroups[groupKey].flushTriggers()
	}

	this.oldScroll = {
	  x: axes.horizontal.newScroll,
	  y: axes.vertical.newScroll
	}
  }

  /* Private */
  Context.prototype.innerHeight = function() {
	/*eslint-disable eqeqeq */
	if (this.element == this.element.window) {
	  return Waypoint.viewportHeight()
	}
	/*eslint-enable eqeqeq */
	return this.adapter.innerHeight()
  }

  /* Private */
  Context.prototype.remove = function(waypoint) {
	delete this.waypoints[waypoint.axis][waypoint.key]
	this.checkEmpty()
  }

  /* Private */
  Context.prototype.innerWidth = function() {
	/*eslint-disable eqeqeq */
	if (this.element == this.element.window) {
	  return Waypoint.viewportWidth()
	}
	/*eslint-enable eqeqeq */
	return this.adapter.innerWidth()
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-destroy */
  Context.prototype.destroy = function() {
	var allWaypoints = []
	for (var axis in this.waypoints) {
	  for (var waypointKey in this.waypoints[axis]) {
		allWaypoints.push(this.waypoints[axis][waypointKey])
	  }
	}
	for (var i = 0, end = allWaypoints.length; i < end; i++) {
	  allWaypoints[i].destroy()
	}
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-refresh */
  Context.prototype.refresh = function() {
	/*eslint-disable eqeqeq */
	var isWindow = this.element == this.element.window
	/*eslint-enable eqeqeq */
	var contextOffset = isWindow ? undefined : this.adapter.offset()
	var triggeredGroups = {}
	var axes

	this.handleScroll()
	axes = {
	  horizontal: {
		contextOffset: isWindow ? 0 : contextOffset.left,
		contextScroll: isWindow ? 0 : this.oldScroll.x,
		contextDimension: this.innerWidth(),
		oldScroll: this.oldScroll.x,
		forward: 'right',
		backward: 'left',
		offsetProp: 'left'
	  },
	  vertical: {
		contextOffset: isWindow ? 0 : contextOffset.top,
		contextScroll: isWindow ? 0 : this.oldScroll.y,
		contextDimension: this.innerHeight(),
		oldScroll: this.oldScroll.y,
		forward: 'down',
		backward: 'up',
		offsetProp: 'top'
	  }
	}

	for (var axisKey in axes) {
	  var axis = axes[axisKey]
	  for (var waypointKey in this.waypoints[axisKey]) {
		var waypoint = this.waypoints[axisKey][waypointKey]
		var adjustment = waypoint.options.offset
		var oldTriggerPoint = waypoint.triggerPoint
		var elementOffset = 0
		var freshWaypoint = oldTriggerPoint == null
		var contextModifier, wasBeforeScroll, nowAfterScroll
		var triggeredBackward, triggeredForward

		if (waypoint.element !== waypoint.element.window) {
		  elementOffset = waypoint.adapter.offset()[axis.offsetProp]
		}

		if (typeof adjustment === 'function') {
		  adjustment = adjustment.apply(waypoint)
		}
		else if (typeof adjustment === 'string') {
		  adjustment = parseFloat(adjustment)
		  if (waypoint.options.offset.indexOf('%') > - 1) {
			adjustment = Math.ceil(axis.contextDimension * adjustment / 100)
		  }
		}

		contextModifier = axis.contextScroll - axis.contextOffset
		waypoint.triggerPoint = Math.floor(elementOffset + contextModifier - adjustment)
		wasBeforeScroll = oldTriggerPoint < axis.oldScroll
		nowAfterScroll = waypoint.triggerPoint >= axis.oldScroll
		triggeredBackward = wasBeforeScroll && nowAfterScroll
		triggeredForward = !wasBeforeScroll && !nowAfterScroll

		if (!freshWaypoint && triggeredBackward) {
		  waypoint.queueTrigger(axis.backward)
		  triggeredGroups[waypoint.group.id] = waypoint.group
		}
		else if (!freshWaypoint && triggeredForward) {
		  waypoint.queueTrigger(axis.forward)
		  triggeredGroups[waypoint.group.id] = waypoint.group
		}
		else if (freshWaypoint && axis.oldScroll >= waypoint.triggerPoint) {
		  waypoint.queueTrigger(axis.forward)
		  triggeredGroups[waypoint.group.id] = waypoint.group
		}
	  }
	}

	Waypoint.requestAnimationFrame(function() {
	  for (var groupKey in triggeredGroups) {
		triggeredGroups[groupKey].flushTriggers()
	  }
	})

	return this
  }

  /* Private */
  Context.findOrCreateByElement = function(element) {
	return Context.findByElement(element) || new Context(element)
  }

  /* Private */
  Context.refreshAll = function() {
	for (var contextId in contexts) {
	  contexts[contextId].refresh()
	}
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-find-by-element */
  Context.findByElement = function(element) {
	return contexts[element.waypointContextKey]
  }

  window.onload = function() {
	if (oldWindowLoad) {
	  oldWindowLoad()
	}
	Context.refreshAll()
  }

  Waypoint.requestAnimationFrame = function(callback) {
	var requestFn = window.requestAnimationFrame ||
	  window.mozRequestAnimationFrame ||
	  window.webkitRequestAnimationFrame ||
	  requestAnimationFrameShim
	requestFn.call(window, callback)
  }
  Waypoint.Context = Context
}())
;(function() {
  'use strict'

  function byTriggerPoint(a, b) {
	return a.triggerPoint - b.triggerPoint
  }

  function byReverseTriggerPoint(a, b) {
	return b.triggerPoint - a.triggerPoint
  }

  var groups = {
	vertical: {},
	horizontal: {}
  }
  var Waypoint = window.Waypoint

  /* http://imakewebthings.com/waypoints/api/group */
  function Group(options) {
	this.name = options.name
	this.axis = options.axis
	this.id = this.name + '-' + this.axis
	this.waypoints = []
	this.clearTriggerQueues()
	groups[this.axis][this.name] = this
  }

  /* Private */
  Group.prototype.add = function(waypoint) {
	this.waypoints.push(waypoint)
  }

  /* Private */
  Group.prototype.clearTriggerQueues = function() {
	this.triggerQueues = {
	  up: [],
	  down: [],
	  left: [],
	  right: []
	}
  }

  /* Private */
  Group.prototype.flushTriggers = function() {
	for (var direction in this.triggerQueues) {
	  var waypoints = this.triggerQueues[direction]
	  var reverse = direction === 'up' || direction === 'left'
	  waypoints.sort(reverse ? byReverseTriggerPoint : byTriggerPoint)
	  for (var i = 0, end = waypoints.length; i < end; i += 1) {
		var waypoint = waypoints[i]
		if (waypoint.options.continuous || i === waypoints.length - 1) {
		  waypoint.trigger([direction])
		}
	  }
	}
	this.clearTriggerQueues()
  }

  /* Private */
  Group.prototype.next = function(waypoint) {
	this.waypoints.sort(byTriggerPoint)
	var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
	var isLast = index === this.waypoints.length - 1
	return isLast ? null : this.waypoints[index + 1]
  }

  /* Private */
  Group.prototype.previous = function(waypoint) {
	this.waypoints.sort(byTriggerPoint)
	var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
	return index ? this.waypoints[index - 1] : null
  }

  /* Private */
  Group.prototype.queueTrigger = function(waypoint, direction) {
	this.triggerQueues[direction].push(waypoint)
  }

  /* Private */
  Group.prototype.remove = function(waypoint) {
	var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
	if (index > -1) {
	  this.waypoints.splice(index, 1)
	}
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/first */
  Group.prototype.first = function() {
	return this.waypoints[0]
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/last */
  Group.prototype.last = function() {
	return this.waypoints[this.waypoints.length - 1]
  }

  /* Private */
  Group.findOrCreate = function(options) {
	return groups[options.axis][options.name] || new Group(options)
  }

  Waypoint.Group = Group
}())
;(function() {
  'use strict'

  var $ = window.jQuery
  var Waypoint = window.Waypoint

  function JQueryAdapter(element) {
	this.$element = $(element)
  }

  $.each([
	'innerHeight',
	'innerWidth',
	'off',
	'offset',
	'on',
	'outerHeight',
	'outerWidth',
	'scrollLeft',
	'scrollTop'
  ], function(i, method) {
	JQueryAdapter.prototype[method] = function() {
	  var args = Array.prototype.slice.call(arguments)
	  return this.$element[method].apply(this.$element, args)
	}
  })

  $.each([
	'extend',
	'inArray',
	'isEmptyObject'
  ], function(i, method) {
	JQueryAdapter[method] = $[method]
  })

  Waypoint.adapters.push({
	name: 'jquery',
	Adapter: JQueryAdapter
  })
  Waypoint.Adapter = JQueryAdapter
}())
;(function() {
  'use strict'

  var Waypoint = window.Waypoint

  function createExtension(framework) {
	return function() {
	  var waypoints = []
	  var overrides = arguments[0]

	  if (framework.isFunction(arguments[0])) {
		overrides = framework.extend({}, arguments[1])
		overrides.handler = arguments[0]
	  }

	  this.each(function() {
		var options = framework.extend({}, overrides, {
		  element: this
		})
		if (typeof options.context === 'string') {
		  options.context = framework(this).closest(options.context)[0]
		}
		waypoints.push(new Waypoint(options))
	  })

	  return waypoints
	}
  }

  if (window.jQuery) {
	window.jQuery.fn.waypoint = createExtension(window.jQuery)
  }
  if (window.Zepto) {
	window.Zepto.fn.waypoint = createExtension(window.Zepto)
  }
}())
;