jquery-waypoints-rails 0.0.2.alpha → 2.0.5

data/app/assets/javascripts/jquery.waypoints.sticky.js

@@ -0,0 +1,65 @@
+// Generated by CoffeeScript 1.6.2
+/*
+Sticky Elements Shortcut for jQuery Waypoints - v2.0.5
+Copyright (c) 2011-2014 Caleb Troughton
+Licensed under the MIT license.
+https://github.com/imakewebthings/jquery-waypoints/blob/master/licenses.txt
+*/
+
+
+(function() {
+  (function(root, factory) {
+    if (typeof define === 'function' && define.amd) {
+      return define(['jquery', 'waypoints'], factory);
+    } else {
+      return factory(root.jQuery);
+    }
+  })(window, function($) {
+    var defaults, wrap;
+
+    defaults = {
+      wrapper: '<div class="sticky-wrapper" />',
+      stuckClass: 'stuck',
+      direction: 'down right'
+    };
+    wrap = function($elements, options) {
+      var $parent;
+
+      $elements.wrap(options.wrapper);
+      $parent = $elements.parent();
+      return $parent.data('isWaypointStickyWrapper', true);
+    };
+    $.waypoints('extendFn', 'sticky', function(opt) {
+      var $wrap, options, originalHandler;
+
+      options = $.extend({}, $.fn.waypoint.defaults, defaults, opt);
+      $wrap = wrap(this, options);
+      originalHandler = options.handler;
+      options.handler = function(direction) {
+        var $sticky, shouldBeStuck;
+
+        $sticky = $(this).children(':first');
+        shouldBeStuck = options.direction.indexOf(direction) !== -1;
+        $sticky.toggleClass(options.stuckClass, shouldBeStuck);
+        $wrap.height(shouldBeStuck ? $sticky.outerHeight() : '');
+        if (originalHandler != null) {
+          return originalHandler.call(this, direction);
+        }
+      };
+      $wrap.waypoint(options);
+      return this.data('stuckClass', options.stuckClass);
+    });
+    return $.waypoints('extendFn', 'unsticky', function() {
+      var $parent;
+
+      $parent = this.parent();
+      if (!$parent.data('isWaypointStickyWrapper')) {
+        return this;
+      }
+      $parent.waypoint('destroy');
+      this.unwrap();
+      return this.removeClass(this.data('stuckClass'));
+    });
+  });
+
+}).call(this);

data/jquery-waypoints-rails.gemspec

@@ -5,8 +5,8 @@ require "jquery-waypoints-rails/version"
 Gem::Specification.new do |s|
   s.name        = "jquery-waypoints-rails"
   s.version     = JqueryWaypoints::Rails::VERSION
-  s.authors     = ["Wagner Amaral", "Daniel Libanori"]
-  s.email       = ["wamaral@wamaral.org", "daniellibanori@gmail.com"]
+  s.authors     = ["Wagner Amaral", "Daniel Libanori", "Albert Bellonch Llargués"]
+  s.email       = ["wamaral@wamaral.org", "daniellibanori@gmail.com", "albert@itnig.net"]
   s.homepage    = "http://github.com/wamaral/jquery-waypoints-rails"
   s.summary     = "This gem just adds jquery-waypoints to your ASSets"
 

data/lib/jquery-waypoints-rails/version.rb

@@ -1,5 +1,5 @@
 module JqueryWaypoints
   module Rails
-    VERSION = "0.0.2.alpha"
+    VERSION = "2.0.5"
   end
 end

metadata

@@ -1,87 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: jquery-waypoints-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.2.alpha
-  prerelease: 6
+  version: 2.0.5
 platform: ruby
 authors:
 - Wagner Amaral
 - Daniel Libanori
+- Albert Bellonch Llargués
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-30 00:00:00.000000000 Z
+date: 2014-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
 email:
 - wamaral@wamaral.org
 - daniellibanori@gmail.com
+- albert@itnig.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - README.md
 - Rakefile
-- app/assets/javascripts/waypoints.js
+- app/assets/javascripts/jquery.waypoints.infinite.js
+- app/assets/javascripts/jquery.waypoints.js
+- app/assets/javascripts/jquery.waypoints.sticky.js
 - jquery-waypoints-rails.gemspec
 - lib/jquery-waypoints-rails.rb
 - lib/jquery-waypoints-rails/version.rb
 homepage: http://github.com/wamaral/jquery-waypoints-rails
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: jquery-waypoints-rails
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: This gem just adds jquery-waypoints to your ASSets
 test_files: []

data/app/assets/javascripts/waypoints.js

@@ -1,676 +0,0 @@
-/*!
-jQuery Waypoints - v1.1.7
-Copyright (c) 2011-2012 Caleb Troughton
-Dual licensed under the MIT license and GPL license.
-https://github.com/imakewebthings/jquery-waypoints/blob/master/MIT-license.txt
-https://github.com/imakewebthings/jquery-waypoints/blob/master/GPL-license.txt
-*/
-
-/*
-Waypoints is a small jQuery plugin that makes it easy to execute a function
-whenever you scroll to an element.
-
-GitHub Repository: https://github.com/imakewebthings/jquery-waypoints
-Documentation and Examples: http://imakewebthings.github.com/jquery-waypoints
-
-Changelog:
-	v1.1.7
-		- Actually fix the post-load bug in Issue #28 from v1.1.3.
-	v1.1.6
-		- Fix potential memory leak by unbinding events on empty context elements.
-	v1.1.5
-		- Make plugin compatible with Browserify/RequireJS. (Thanks @cjroebuck)
-	v1.1.4
-		- Add handler option to give alternate binding method. (Issue #34)
-	v1.1.3
-		- Fix cases where waypoints are added post-load and should be triggered
-		  immediately. (Issue #28)
-	v1.1.2
-		- Fixed error thrown by waypoints with triggerOnce option that were
-		  triggered via resize refresh.
-	v1.1.1
-		- Fixed bug in initialization where all offsets were being calculated
-		  as if set to 0 initially, causing unwarranted triggers during the
-		  subsequent refresh.
-		- Added onlyOnScroll, an option for individual waypoints that disables
-		  triggers due to an offset refresh that crosses the current scroll
-		  point. (All credit to @knuton on this one.)
-	v1.1
-		- Moved the continuous option out of global settings and into the options
-		  object for individual waypoints.
-		- Added the context option, which allows for using waypoints within any
-		  scrollable element, not just the window.
-	v1.0.2
-		- Moved scroll and resize handler bindings out of load.  Should play nicer
-		  with async loaders like Head JS and LABjs.
-		- Fixed a 1px off error when using certain % offsets.
-		- Added unit tests.
-	v1.0.1
-		- Added $.waypoints('viewportHeight').
-		- Fixed iOS bug (using the new viewportHeight method).
-		- Added offset function alias: 'bottom-in-view'.
-	v1.0
-		- Initial release.
-	
-Support:
-	- jQuery versions 1.4.3+
-	- IE6+, FF3+, Chrome 6+, Safari 4+, Opera 11
-	- Other versions and browsers may work, these are just the ones I've looked at.
-*/
-
-(function($, wp, wps, window, undefined){
-	'$:nomunge';
-	
-	var $w = $(window),
-	
-	// Keeping common strings as variables = better minification
-	eventName = 'waypoint.reached',
-	
-	/*
-	For the waypoint and direction passed in, trigger the waypoint.reached
-	event and deal with the triggerOnce option.
-	*/
-	triggerWaypoint = function(way, dir) {
-		way.element.trigger(eventName, dir);
-		if (way.options.triggerOnce) {
-			way.element[wp]('destroy');
-		}
-	},
-	
-	/*
-	Given a jQuery element and Context, returns the index of that element in the waypoints
-	array.  Returns the index, or -1 if the element is not a waypoint.
-	*/
-	waypointIndex = function(el, context) {
-		if (!context) return -1;
-		var i = context.waypoints.length - 1;
-		while (i >= 0 && context.waypoints[i].element[0] !== el[0]) {
-			i -= 1;
-		}
-		return i;
-	},
-	
-	// Private list of all elements used as scrolling contexts for waypoints.
-	contexts = [],
-	
-	/*
-	Context Class - represents a scrolling context.  Properties include:
-		element: jQuery object containing a single HTML element.
-		waypoints: Array of waypoints operating under this scroll context.
-		oldScroll: Keeps the previous scroll position to determine scroll direction.
-		didScroll: Flag used in scrolling the context's scroll event.
-		didResize: Flag used in scrolling the context's resize event.
-		doScroll: Function that checks for crossed waypoints. Called from throttler.
-	*/
-	Context = function(context) {
-		$.extend(this, {
-			element: $(context),
-			oldScroll: 0,
-			
-			/*
-			List of all elements that have been registered as waypoints.
-			Each object in the array contains:
-				element: jQuery object containing a single HTML element.
-				offset: The window scroll offset, in px, that triggers the waypoint event.
-				options: Options object that was passed to the waypoint fn function.
-			*/
-			'waypoints': [],
-			
-			didScroll: false,
-			didResize: false,
-	
-			doScroll: $.proxy(function() {
-				var newScroll = this.element.scrollTop(),
-				
-				// Are we scrolling up or down? Used for direction argument in callback.
-				isDown = newScroll > this.oldScroll,
-				that = this,
-
-				// Get a list of all waypoints that were crossed since last scroll move.
-				pointsHit = $.grep(this.waypoints, function(el, i) {
-					return isDown ?
-						(el.offset > that.oldScroll && el.offset <= newScroll) :
-						(el.offset <= that.oldScroll && el.offset > newScroll);
-				}),
-				len = pointsHit.length;
-				
-				// iOS adjustment
-				if (!this.oldScroll || !newScroll) {
-					$[wps]('refresh');
-				}
-
-				// Done with scroll comparisons, store new scroll before ejection
-				this.oldScroll = newScroll;
-
-				// No waypoints crossed? Eject.
-				if (!len) return;
-
-				// If several waypoints triggered, need to do so in reverse order going up
-				if (!isDown) pointsHit.reverse();
-
-				/*
-				One scroll move may cross several waypoints.  If the waypoint's continuous
-				option is true it should fire even if it isn't the last waypoint.  If false,
-				it will only fire if it's the last one.
-				*/
-				$.each(pointsHit, function(i, point) {
-					if (point.options.continuous || i === len - 1) {
-						triggerWaypoint(point, [isDown ? 'down' : 'up']);
-					}
-				});
-			}, this)
-		});
-		
-		// Setup scroll and resize handlers.  Throttled at the settings-defined rate limits.
-		$(context).bind('scroll.waypoints', $.proxy(function() {
-			if (!this.didScroll) {
-				this.didScroll = true;
-				window.setTimeout($.proxy(function() {
-					this.doScroll();
-					this.didScroll = false;
-				}, this), $[wps].settings.scrollThrottle);
-			}
-		}, this)).bind('resize.waypoints', $.proxy(function() {
-			if (!this.didResize) {
-				this.didResize = true;
-				window.setTimeout($.proxy(function() {
-					$[wps]('refresh');
-					this.didResize = false;
-				}, this), $[wps].settings.resizeThrottle);
-			}
-		}, this));
-		
-		$w.load($.proxy(function() {
-			/*
-			Fire a scroll check, should the page be loaded at a non-zero scroll value,
-			as with a fragment id link or a page refresh.
-			*/
-			this.doScroll();
-		}, this));
-	},
-	
-	/* Returns a Context object from the contexts array, given the raw HTML element
-	for that context. */
-	getContextByElement = function(element) {
-		var found = null;
-		
-		$.each(contexts, function(i, c) {
-			if (c.element[0] === element) {
-				found = c;
-				return false;
-			}
-		});
-		
-		return found;
-	},
-	
-	// Methods exposed to the effin' object 
-	methods = {
-		/*
-		jQuery.fn.waypoint([handler], [options])
-		
-		handler
-			function, optional
-			A callback function called when the user scrolls past the element.
-			The function signature is function(event, direction) where event is
-			a standard jQuery Event Object and direction is a string, either 'down'
-			or 'up' indicating which direction the user is scrolling.
-			
-		options
-			object, optional
-			A map of options to apply to this set of waypoints, including where on
-			the browser window the waypoint is triggered. For a full list of
-			options and their defaults, see $.fn.waypoint.defaults.
-			
-		This is how you register an element as a waypoint. When the user scrolls past
-		that element it triggers waypoint.reached, a custom event. Since the
-		parameters for creating a waypoint are optional, we have a few different
-		possible signatures. Let’s look at each of them.
-
-		someElements.waypoint();
-			
-		Calling .waypoint with no parameters will register the elements as waypoints
-		using the default options. The elements will fire the waypoint.reached event,
-		but calling it in this way does not bind any handler to the event. You can
-		bind to the event yourself, as with any other event, like so:
-
-		someElements.bind('waypoint.reached', function(event, direction) {
-		   // make it rain
-		});
-			
-		You will usually want to create a waypoint and immediately bind a function to
-		waypoint.reached, and can do so by passing a handler as the first argument to
-		.waypoint:
-
-		someElements.waypoint(function(event, direction) {
-		   if (direction === 'down') {
-		      // do this on the way down
-		   }
-		   else {
-		      // do this on the way back up through the waypoint
-		   }
-		});
-			
-		This will still use the default options, which will trigger the waypoint when
-		the top of the element hits the top of the window. We can pass .waypoint an
-		options object to customize things:
-
-		someElements.waypoint(function(event, direction) {
-		   // do something amazing
-		}, {
-		   offset: '50%'  // middle of the page
-		});
-			
-		You can also pass just an options object.
-
-		someElements.waypoint({
-		   offset: 100  // 100px from the top
-		});
-			
-		This behaves like .waypoint(), in that it registers the elements as waypoints
-		but binds no event handlers.
-
-		Calling .waypoint on an existing waypoint will extend the previous options.
-		If the call includes a handler, it will be bound to waypoint.reached without
-		unbinding any other handlers.
-		*/
-		init: function(f, options) {
-			// Register each element as a waypoint, add to array.
-			this.each(function() {
-				var cElement = $.fn[wp].defaults.context,
-				context,
-				$this = $(this);
-
-				// Default window context or a specific element?
-				if (options && options.context) {
-					cElement = options.context;
-				}
-
-				// Find the closest element that matches the context
-				if (!$.isWindow(cElement)) {
-					cElement = $this.closest(cElement)[0];
-				}
-				context = getContextByElement(cElement);
-
-				// Not a context yet? Create and push.
-				if (!context) {
-					context = new Context(cElement);
-					contexts.push(context);
-				}
-				
-				// Extend default and preexisting options
-				var ndx = waypointIndex($this, context),
-				base = ndx < 0 ? $.fn[wp].defaults : context.waypoints[ndx].options,
-				opts = $.extend({}, base, options);
-				
-				// Offset aliases
-				opts.offset = opts.offset === "bottom-in-view" ?
-					function() {
-						var cHeight = $.isWindow(cElement) ? $[wps]('viewportHeight')
-							: $(cElement).height();
-						return cHeight - $(this).outerHeight();
-					} : opts.offset;
-
-				// Update, or create new waypoint
-				if (ndx < 0) {
-					context.waypoints.push({
-						'element': $this,
-						'offset': null,
-						'options': opts
-					});
-				}
-				else {
-					context.waypoints[ndx].options = opts;
-				}
-				
-				// Bind the function if it was passed in.
-				if (f) {
-					$this.bind(eventName, f);
-				}
-				// Bind the function in the handler option if it exists.
-				if (options && options.handler) {
-					$this.bind(eventName, options.handler);
-				}
-			});
-			
-			// Need to re-sort+refresh the waypoints array after new elements are added.
-			$[wps]('refresh');
-			
-			return this;
-		},
-		
-		
-		/*
-		jQuery.fn.waypoint('remove')
-		
-		Passing the string 'remove' to .waypoint unregisters the elements as waypoints
-		and wipes any custom options, but leaves the waypoint.reached events bound.
-		Calling .waypoint again in the future would reregister the waypoint and the old
-		handlers would continue to work.
-		*/
-		remove: function() {
-			return this.each(function(i, el) {
-				var $el = $(el);
-				
-				$.each(contexts, function(i, c) {
-					var ndx = waypointIndex($el, c);
-
-					if (ndx >= 0) {
-						c.waypoints.splice(ndx, 1);
-
-						if (!c.waypoints.length) {
-							c.element.unbind('scroll.waypoints resize.waypoints');
-							contexts.splice(i, 1);
-						}
-					}
-				});
-			});
-		},
-		
-		/*
-		jQuery.fn.waypoint('destroy')
-		
-		Passing the string 'destroy' to .waypoint will unbind all waypoint.reached
-		event handlers on those elements and unregisters them as waypoints.
-		*/
-		destroy: function() {
-			return this.unbind(eventName)[wp]('remove');
-		}
-	},
-	
-	/*
-	Methods used by the jQuery object extension.
-	*/
-	jQMethods = {
-		
-		/*
-		jQuery.waypoints('refresh')
-		
-		This will force a recalculation of each waypoint’s trigger point based on
-		its offset option and context. This is called automatically whenever the window
-		(or other defined context) is resized, new waypoints are added, or a waypoint’s
-		options are modified. If your project is changing the DOM or page layout without
-		doing one of these things, you may want to manually call this refresh.
-		*/
-		refresh: function() {
-			$.each(contexts, function(i, c) {
-				var isWin = $.isWindow(c.element[0]),
-				contextOffset = isWin ? 0 : c.element.offset().top,
-				contextHeight = isWin ? $[wps]('viewportHeight') : c.element.height(),
-				contextScroll = isWin ? 0 : c.element.scrollTop();
-				
-				$.each(c.waypoints, function(j, o) {
-					/* $.each isn't safe from element removal due to triggerOnce.
-					Should rewrite the loop but this is way easier. */
-					if (!o) return;
-
-					// Adjustment is just the offset if it's a px value
-					var adjustment = o.options.offset,
-					oldOffset = o.offset;
-					
-					// Set adjustment to the return value if offset is a function.
-					if (typeof o.options.offset === "function") {
-						adjustment = o.options.offset.apply(o.element);
-					}
-					// Calculate the adjustment if offset is a percentage.
-					else if (typeof o.options.offset === "string") {
-						var amount = parseFloat(o.options.offset);
-						adjustment = o.options.offset.indexOf("%") ?
-							Math.ceil(contextHeight * (amount / 100)) : amount;
-					}
-
-					/* 
-					Set the element offset to the window scroll offset, less
-					all our adjustments.
-					*/
-					o.offset = o.element.offset().top - contextOffset
-						+ contextScroll - adjustment;
-
-					/*
-					An element offset change across the current scroll point triggers
-					the event, just as if we scrolled past it unless prevented by an
-					optional flag.
-					*/
-					if (o.options.onlyOnScroll) return;
-
-					if (oldOffset !== null && c.oldScroll > oldOffset && c.oldScroll <= o.offset) {
-						triggerWaypoint(o, ['up']);
-					}
-					else if (oldOffset !== null && c.oldScroll < oldOffset && c.oldScroll >= o.offset) {
-						triggerWaypoint(o, ['down']);
-					}
-					/* For new waypoints added after load, check that down should have
-					already been triggered */
-					else if (!oldOffset && c.element.scrollTop() > o.offset) {
-						triggerWaypoint(o, ['down']);
-					}
-				});
-				
-				// Keep waypoints sorted by offset value.
-				c.waypoints.sort(function(a, b) {
-					return a.offset - b.offset;
-				});
-			});
-		},
-		
-		
-		/*
-		jQuery.waypoints('viewportHeight')
-		
-		This will return the height of the viewport, adjusting for inconsistencies
-		that come with calling $(window).height() in iOS. Recommended for use
-		within any offset functions.
-		*/
-		viewportHeight: function() {
-			return (window.innerHeight ? window.innerHeight : $w.height());
-		},
-		
-		
-		/*
-		jQuery.waypoints()
-		
-		This will return a jQuery object with a collection of all registered waypoint
-		elements.
-
-		$('.post').waypoint();
-		$('.ad-unit').waypoint(function(event, direction) {
-		   // Passed an ad unit
-		});
-		console.log($.waypoints());
-		
-		The example above would log a jQuery object containing all .post and .ad-unit
-		elements.
-		*/
-		aggregate: function() {
-			var points = $();
-			$.each(contexts, function(i, c) {
-				$.each(c.waypoints, function(i, e) {
-					points = points.add(e.element);
-				});
-			});
-			return points;
-		}
-	};
-
-	
-	/*
-	fn extension.  Delegates to appropriate method.
-	*/
-	$.fn[wp] = function(method) {
-		
-		if (methods[method]) {
-			return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
-		}
-		else if (typeof method === "function" || !method) {
-			return methods.init.apply(this, arguments);
-		}
-		else if (typeof method === "object") {
-			return methods.init.apply(this, [null, method]);
-		}
-		else {
-			$.error( 'Method ' + method + ' does not exist on jQuery ' + wp );
-		}
-	};
-	
-	
-	/*
-	The default options object that is extended when calling .waypoint. It has the
-	following properties:
-	
-	context
-		string | element | jQuery*
-		default: window
-		The context defines which scrollable element the waypoint belongs to and acts
-		within. The default, window, means the waypoint offset is calculated with relation
-		to the whole viewport.  You can set this to another element to use the waypoints
-		within that element.  Accepts a selector string, *but if you use jQuery 1.6+ it
-		also accepts a raw HTML element or jQuery object.
-	
-	continuous
-		boolean
-		default: true
-		If true, and multiple waypoints are triggered in one scroll, this waypoint will
-		trigger even if it is not the last waypoint reached.  If false, it will only
-		trigger if it is the last waypoint.
-		
-	handler
-		function
-		default: undefined
-		An alternative way to bind functions to the waypoint, without using the function
-		as the first argument to the waypoint function.
-
-	offset
-		number | string | function
-		default: 0
-		Determines how far the top of the element must be from the top of the browser
-		window to trigger a waypoint. It can be a number, which is taken as a number
-		of pixels, a string representing a percentage of the viewport height, or a
-		function that will return a number of pixels.
-		
-	onlyOnScroll
-		boolean
-		default: false
-		If true, this waypoint will not trigger if an offset change during a refresh
-		causes it to pass the current scroll point.
-		
-	triggerOnce
-		boolean
-		default: false
-		If true, the waypoint will be destroyed when triggered.
-	
-	An offset of 250 would trigger the waypoint when the top of the element is 250px
-	from the top of the viewport. Negative values for any offset work as you might
-	expect. A value of -100 would trigger the waypoint when the element is 100px above
-	the top of the window.
-
-	offset: '100%'
-	
-	A string percentage will determine the pixel offset based on the height of the
-	window. When resizing the window, this offset will automatically be recalculated
-	without needing to call $.waypoints('refresh').
-
-	// The bottom of the element is in view
-	offset: function() {
-	   return $.waypoints('viewportHeight') - $(this).outerHeight();
-	}
-	
-	Offset can take a function, which must return a number of pixels from the top of
-	the window. The this value will always refer to the raw HTML element of the
-	waypoint. As with % values, functions are recalculated automatically when the
-	window resizes. For more on recalculating offsets, see $.waypoints('refresh').
-	
-	An offset value of 'bottom-in-view' will act as an alias for the function in the
-	example above, as this is a common usage.
-	
-	offset: 'bottom-in-view'
-	
-	You can see this alias in use on the Scroll Analytics example page.
-
-	The triggerOnce flag, if true, will destroy the waypoint after the first trigger.
-	This is just a shortcut for calling .waypoint('destroy') within the waypoint
-	handler. This is useful in situations such as scroll analytics, where you only
-	want to record an event once for each page visit.
-	
-	The context option lets you use Waypoints within an element other than the window.
-	You can define the context with a selector string and the waypoint will act within
-	the nearest ancestor that matches this selector.
-	
-	$('.something-scrollable .waypoint').waypoint({
-	   context: '.something-scrollable'
-	});
-	
-	You can see this in action on the Dial Controls example.
-	
-	The handler option gives authors an alternative way to bind functions when
-	creating a waypoint.  In place of:
-	
-	$('.item').waypoint(function(event, direction) {
-	   // make things happen
-	});
-	
-	You may instead write:
-	
-	$('.item').waypoint({
-	   handler: function(event, direction) {
-	      // make things happen
-	   }
-	});
-	
-	*/
-	$.fn[wp].defaults = {
-		continuous: true,
-		offset: 0,
-		triggerOnce: false,
-		context: window
-	};
-	
-	
-	
-	
-	
-	/*
-	jQuery object extension. Delegates to appropriate methods above.
-	*/
-	$[wps] = function(method) {
-		if (jQMethods[method]) {
-			return jQMethods[method].apply(this);
-		}
-		else {
-			return jQMethods['aggregate']();
-		}
-	};
-	
-	
-	/*
-	$.waypoints.settings
-	
-	Settings object that determines some of the plugin’s behavior.
-		
-	resizeThrottle
-		number
-		default: 200
-		For performance reasons, the refresh performed during resizes is
-		throttled. This value is the rate-limit in milliseconds between resize
-		refreshes. For more information on throttling, check out Ben Alman’s
-		throttle / debounce plugin.
-		http://benalman.com/projects/jquery-throttle-debounce-plugin/
-		
-	scrollThrottle
-		number
-		default: 100
-		For performance reasons, checking for any crossed waypoints during a
-		scroll event is throttled. This value is the rate-limit in milliseconds
-		between scroll checks. For more information on throttling, check out Ben
-		Alman’s throttle / debounce plugin.
-		http://benalman.com/projects/jquery-throttle-debounce-plugin/
-	*/
-	$[wps].settings = {
-		resizeThrottle: 200,
-		scrollThrottle: 100
-	};
-	
-	$w.load(function() {
-		// Calculate everything once on load.
-		$[wps]('refresh');
-	});
-})(jQuery, 'waypoint', 'waypoints', window);