update plugins

9 files changed, 1796 insertions, 0 deletions

diff --git a/plugins/jetpack/modules/infinite-scroll/infinity.css b/plugins/jetpack/modules/infinite-scroll/infinity.css
new file mode 100644
index 00000000..dd39179e
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/infinity.css
@@ -0,0 +1,137 @@
+/* =Infinity Styles
+-------------------------------------------------------------- */
+
+.infinite-wrap {
+/*	border-top: 2px solid #444;
+	border-top: 2px solid rgba(68,68,68,0.8);
+	padding: 20px 0 0; */
+}
+.infinite-loader {
+	color: #000;
+	display: block;
+	height: 28px;
+	margin: 10px;
+	text-indent: -9999px;
+}
+#infinite-handle span {
+	background: #333;
+	border-radius: 1px;
+	color: #eee;
+	cursor: pointer;
+	font-size: 13px;
+	padding: 6px 16px;
+}
+
+/**
+ * For smaller viewports, remove the down-arrow icon and turn
+ * the button into a block element, spanning the content's full width.
+ */
+@media (max-width: 800px) {
+	#infinite-handle span:before {
+		display: none;
+	}
+	#infinite-handle span {
+		display: block;
+	}
+}
+
+/**
+ * Footer
+ */
+#infinite-footer {
+	position: fixed;
+		bottom: -50px;
+		left: 0;
+	width: 100%;
+}
+#infinite-footer a {
+	text-decoration: none;
+}
+#infinite-footer .blog-info a:hover,
+#infinite-footer .blog-credits a:hover {
+	color: #444;
+	text-decoration: underline;
+}
+#infinite-footer .container {
+	background: rgba( 255, 255, 255, 0.8 );
+	border-color: #ccc;
+	border-color: rgba( 0, 0, 0, 0.1 );
+	border-style: solid;
+	border-width: 1px 0 0;
+	box-sizing: border-box;
+	margin: 0 auto;
+	overflow: hidden;
+	padding: 1px 20px;
+	width: 640px;
+}
+#infinite-footer .blog-info,
+#infinite-footer .blog-credits {
+	-moz-box-sizing: border-box;
+	-webkit-box-sizing: border-box;
+	box-sizing: border-box;
+	line-height: 25px;
+}
+#infinite-footer .blog-info {
+	float: left;
+	overflow: hidden;
+	text-align: left;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	width: 40%;
+}
+#infinite-footer .blog-credits {
+	font-weight: normal;
+	float: right;
+	width: 60%;
+}
+#infinite-footer .blog-info a {
+	color: #111;
+	font-size: 14px;
+	font-weight: bold;
+}
+#infinite-footer .blog-credits {
+	color: #888;
+	font-size: 12px;
+	text-align: right;
+}
+#infinite-footer .blog-credits a {
+	color: #666;
+}
+
+/**
+ * Hooks to infinity-end body class to restore footer
+ */
+.infinity-end.neverending #infinite-footer {
+	display: none;
+}
+
+/**
+ * Responsive structure for the footer
+ */
+@media (max-width: 640px) {
+	#infinite-footer .container {
+		-moz-box-sizing: border-box;
+		-webkit-box-sizing: border-box;
+		box-sizing: border-box;
+		width: 100%;
+	}
+	#infinite-footer .blog-info {
+		width: 30%;
+	}
+	#infinite-footer .blog-credits {
+		width: 70%;
+	}
+	#infinite-footer .blog-info a,
+	#infinite-footer .blog-credits {
+		font-size: 10px;
+	}
+}
+
+/**
+ * No fixed footer on small viewports
+ */
+@media ( max-width: 640px ) {
+	#infinite-footer {
+		position: static;
+	}
+}
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/infinity.js b/plugins/jetpack/modules/infinite-scroll/infinity.js
new file mode 100644
index 00000000..7a76d8f2
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/infinity.js
@@ -0,0 +1,490 @@
+(function($){ // Open closure
+
+// Local vars
+var Scroller, ajaxurl, stats, type, text, totop, timer;
+
+// IE requires special handling
+var isIE = ( -1 != navigator.userAgent.search( 'MSIE' ) );
+if ( isIE ) {
+	var IEVersion = navigator.userAgent.match(/MSIE\s?(\d+)\.?\d*;/);
+	var IEVersion = parseInt( IEVersion[1] );
+}
+
+/**
+ * Loads new posts when users scroll near the bottom of the page.
+ */
+Scroller = function( settings ) {
+	var self = this;
+
+	// Initialize our variables
+	this.id               = settings.id;
+	this.body             = $( document.body );
+	this.window           = $( window );
+	this.element          = $( '#' + settings.id );
+	this.wrapperClass     = settings.wrapper_class;
+	this.ready            = true;
+	this.disabled         = false;
+	this.page             = 1;
+	this.offset           = settings.offset;
+	this.order            = settings.order;
+	this.throttle         = false;
+	this.handle           = '<div id="infinite-handle"><span>' + text.replace( '\\', '' ) + '</span></div>';
+	this.google_analytics = settings.google_analytics;
+	this.history          = settings.history;
+	this.origURL          = window.location.href;
+
+	// Footer settings
+	this.footer           = $( '#infinite-footer' );
+	this.footer.wrap      = settings.footer;
+
+	// We have two type of infinite scroll
+	// cases 'scroll' and 'click'
+
+	if ( type == 'scroll' ) {
+		// Bind refresh to the scroll event
+		// Throttle to check for such case every 300ms
+
+		// On event the case becomes a fact
+		this.window.bind( 'scroll.infinity', function() {
+			this.throttle = true;
+		});
+
+		// Go back top method
+		self.gotop();
+
+		setInterval( function() {
+			if ( this.throttle ) {
+				// Once the case is the case, the action occurs and the fact is no more
+				this.throttle = false;
+				// Reveal or hide footer
+				self.thefooter();
+				// Fire the refresh
+				self.refresh();
+			}
+		}, 300 );
+
+		// Ensure that enough posts are loaded to fill the initial viewport, to compensate for short posts and large displays.
+		self.ensureFilledViewport();
+		this.body.bind( 'post-load', { self: self }, self.checkViewportOnLoad );
+	} else if ( type == 'click' ) {
+		this.element.append( self.handle );
+		this.element.delegate( '#infinite-handle', 'click.infinity', function() {
+			// Handle the handle
+			$( '#infinite-handle' ).remove();
+			// Fire the refresh
+			self.refresh();
+		});
+	}
+};
+
+/**
+ * Check whether we should fetch any additional posts.
+ *
+ * By default, checks whether the bottom of the viewport is within one
+ * viewport-height of the bottom of the content.
+ */
+Scroller.prototype.check = function() {
+	var bottom = this.window.scrollTop() + this.window.height(),
+		threshold = this.element.offset().top + this.element.outerHeight(false) - this.window.height();
+
+	return bottom > threshold;
+};
+
+/**
+ * Renders the results from a successful response.
+ */
+Scroller.prototype.render = function( response ) {
+	this.body.addClass( 'infinity-success' );
+
+	// Check if we can wrap the html
+	this.element.append( response.html );
+
+	this.body.trigger( 'post-load' );
+	this.ready = true;
+};
+
+/**
+ * Returns the object used to query for new posts.
+ */
+Scroller.prototype.query = function() {
+	return {
+		page:  this.page,
+		order: this.order,
+		scripts: window.infiniteScroll.settings.scripts,
+		styles: window.infiniteScroll.settings.styles
+	};
+};
+
+/**
+ * Scroll back to top.
+ */
+Scroller.prototype.gotop = function() {
+	var blog = $( '#infinity-blog-title' );
+
+	blog.attr( 'title', totop );
+
+	// Scroll to top on blog title
+	blog.bind( 'click', function( e ) {
+		$( 'html, body' ).animate( { scrollTop: 0 }, 'fast' );
+		e.preventDefault();
+	});
+};
+
+
+/**
+ * The infinite footer.
+ */
+Scroller.prototype.thefooter = function() {
+	var self  = this,
+		width;
+
+	// Check if we have an id for the page wrapper
+	if ( $.type( this.footer.wrap ) === "string" ) {
+		width = $( 'body #' + this.footer.wrap ).outerWidth( false );
+
+		// Make the footer match the width of the page
+		if ( width > 479 )
+			this.footer.find( '.container' ).css( 'width', width );
+	}
+
+	// Reveal footer
+	if ( this.window.scrollTop() >= 350 )
+		self.footer.animate( { 'bottom': 0 }, 'fast' );
+	else if ( this.window.scrollTop() < 350 )
+		self.footer.animate( { 'bottom': '-50px' }, 'fast' );
+};
+
+
+/**
+ * Controls the flow of the refresh. Don't mess.
+ */
+Scroller.prototype.refresh = function() {
+	var	self   = this,
+		query, jqxhr, load, loader, color;
+
+	// If we're disabled, ready, or don't pass the check, bail.
+	if ( this.disabled || ! this.ready || ! this.check() )
+		return;
+
+	// Let's get going -- set ready to false to prevent
+	// multiple refreshes from occurring at once.
+	this.ready = false;
+
+	// Create a loader element to show it's working.
+	loader = '<span class="infinite-loader"></span>';
+	this.element.append( loader );
+
+	loader = this.element.find( '.infinite-loader' );
+	color = loader.css( 'color' );
+
+	try {
+		loader.spin( 'medium-left', color );
+	} catch ( error ) { }
+
+	// Generate our query vars.
+	query = $.extend({
+		action: 'infinite_scroll'
+	}, this.query() );
+
+	// Fire the ajax request.
+	jqxhr = $.get( infiniteScroll.settings.ajaxurl, query );
+
+	// Allow refreshes to occur again if an error is triggered.
+	jqxhr.fail( function() {
+		loader.hide();
+		self.ready = true;
+	});
+
+	// Success handler
+	jqxhr.done( function( response ) {
+
+			// On success, let's hide the loader circle.
+			loader.hide();
+
+			// Check for and parse our response.
+			if ( ! response )
+				return;
+
+			response = $.parseJSON( response );
+
+			if ( ! response || ! response.type )
+				return;
+
+			// If there are no remaining posts...
+			if ( response.type == 'empty' ) {
+				// Disable the scroller.
+				self.disabled = true;
+				// Update body classes, allowing the footer to return to static positioning
+				self.body.addClass( 'infinity-end' ).removeClass( 'infinity-success' );
+
+			// If we've succeeded...
+			} else if ( response.type == 'success' ) {
+				// If additional scripts are required by the incoming set of posts, parse them
+				if ( response.scripts ) {
+					$( response.scripts ).each( function() {
+						// Add script handle to list of those already parsed
+						window.infiniteScroll.settings.scripts.push( this.handle );
+
+						// Output extra data, if present
+						if ( this.extra_data ) {
+							var data = document.createElement('script'),
+								dataContent = document.createTextNode( "//<![CDATA[ \n" + this.extra_data + "\n//]]>" );
+
+							data.type = 'text/javascript';
+							data.appendChild( dataContent );
+
+							document.getElementsByTagName( this.footer ? 'body' : 'head' )[0].appendChild(data);
+						}
+
+						// Build script tag and append to DOM in requested location
+						var script = document.createElement('script');
+						script.type = 'text/javascript';
+						script.src = this.src;
+						script.id = this.handle;
+						document.getElementsByTagName( this.footer ? 'body' : 'head' )[0].appendChild(script);
+					} );
+				}
+
+				// If additional stylesheets are required by the incoming set of posts, parse them
+				if ( response.styles ) {
+					$( response.styles ).each( function() {
+						// Add stylesheet handle to list of those already parsed
+						window.infiniteScroll.settings.styles.push( this.handle );
+
+						// Build link tag
+						var style = document.createElement('link');
+						style.rel = 'stylesheet';
+						style.href = this.src;
+						style.id = this.handle + '-css';
+
+						// Destroy link tag if a conditional statement is present and either the browser isn't IE, or the conditional doesn't evaluate true
+						if ( this.conditional && ( ! isIE || ! eval( this.conditional.replace( /%ver/g, IEVersion ) ) ) )
+							var style = false;
+
+						// Append link tag if necessary
+						if ( style )
+							document.getElementsByTagName('head')[0].appendChild(style);
+					} );
+				}
+
+				// Increment the page number
+				self.page++;
+
+				// Record pageview in WP Stats, if available.
+				if ( stats )
+					new Image().src = document.location.protocol + '//stats.wordpress.com/g.gif?' + stats + '&post=0&baba=' + Math.random();
+
+				// Add new posts to the postflair object
+				if ( 'object' == typeof response.postflair && 'object' == typeof WPCOM_sharing_counts )
+					WPCOM_sharing_counts = $.extend( WPCOM_sharing_counts, response.postflair );
+
+				// Render the results
+				self.render.apply( self, arguments );
+
+				// If 'click' type, add back the handle
+				if ( type == 'click' )
+					self.element.append( self.handle );
+
+				// Fire Google Analytics pageview
+				if ( self.google_analytics && 'object' == typeof _gaq )
+					_gaq.push(['_trackPageview', self.history.path.replace( /%d/, self.page ) ]);
+			}
+		});
+
+	return jqxhr;
+};
+
+/**
+ * Trigger IS to load additional posts if the initial posts don't fill the window.
+ * On large displays, or when posts are very short, the viewport may not be filled with posts, so we overcome this by loading additional posts when IS initializes.
+ */
+Scroller.prototype.ensureFilledViewport = function() {
+	var	self = this,
+	   	windowHeight = self.window.height(),
+	   	postsHeight = self.element.height()
+	   	aveSetHeight = 0,
+	   	wrapperQty = 0;
+
+	// Account for situations where postsHeight is 0 because child list elements are floated
+	if ( postsHeight === 0 ) {
+		$( self.element.selector + ' > li' ).each( function() {
+			postsHeight += $( this ).height();
+		} );
+
+		if ( postsHeight === 0 ) {
+			self.body.unbind( 'post-load', self.checkViewportOnLoad );
+			return;
+		}
+	}
+
+	// Calculate average height of a set of posts to prevent more posts than needed from being loaded.
+	$( '.' + self.wrapperClass ).each( function() {
+		aveSetHeight += $( this ).height();
+		wrapperQty++;
+	} );
+
+	if ( wrapperQty > 0 )
+		aveSetHeight = aveSetHeight / wrapperQty;
+	else
+		aveSetHeight = 0;
+
+	// Load more posts if space permits, otherwise stop checking for a full viewport
+	if ( postsHeight < windowHeight && ( postsHeight + aveSetHeight < windowHeight ) ) {
+		self.ready = true;
+		self.refresh();
+	}
+	else {
+		self.body.unbind( 'post-load', self.checkViewportOnLoad );
+	}
+}
+
+/**
+ * Event handler for ensureFilledViewport(), tied to the post-load trigger.
+ * Necessary to ensure that the variable `this` contains the scroller when used in ensureFilledViewport(). Since this function is tied to an event, `this` becomes the DOM element the event is tied to.
+ */
+Scroller.prototype.checkViewportOnLoad = function( ev ) {
+	ev.data.self.ensureFilledViewport();
+}
+
+/**
+ * Identify archive page that corresponds to majority of posts shown in the current browser window.
+ */
+Scroller.prototype.determineURL = function () {
+	var self         = window.infiniteScroll.scroller,
+		windowTop    = $( window ).scrollTop(),
+		windowBottom = windowTop + $( window ).height(),
+		windowSize   = windowBottom - windowTop,
+		setsInView   = [],
+		pageNum      = false;
+
+	// Find out which sets are in view
+	$( '.' + self.wrapperClass ).each( function() {
+		var id         = $( this ).attr( 'id' ),
+			setTop     = $( this ).offset().top,
+			setHeight  = $( this ).outerHeight( false ),
+			setBottom  = 0,
+			setPageNum = $( this ).data( 'page-num' );
+
+		// Account for containers that have no height because their children are floated elements.
+		if ( 0 == setHeight ) {
+			$( '> *', this ).each( function() {
+				setHeight += $( this ).outerHeight( false );
+			} );
+		}
+
+		// Determine position of bottom of set by adding its height to the scroll position of its top.
+		setBottom = setTop + setHeight;
+
+		// Populate setsInView object. While this logic could all be combined into a single conditional statement, this is easier to understand.
+		if ( setTop < windowTop && setBottom > windowBottom ) { // top of set is above window, bottom is below
+			setsInView.push({'id': id, 'top': setTop, 'bottom': setBottom, 'pageNum': setPageNum });
+		}
+		else if( setTop > windowTop && setTop < windowBottom ) { // top of set is between top (gt) and bottom (lt)
+			setsInView.push({'id': id, 'top': setTop, 'bottom': setBottom, 'pageNum': setPageNum });
+		}
+		else if( setBottom > windowTop && setBottom < windowBottom ) { // bottom of set is between top (gt) and bottom (lt)
+			setsInView.push({'id': id, 'top': setTop, 'bottom': setBottom, 'pageNum': setPageNum });
+		}
+	} );
+
+	// Parse number of sets found in view in an attempt to update the URL to match the set that comprises the majority of the window.
+	if ( 0 == setsInView.length ) {
+		pageNum = -1;
+	}
+	else if ( 1 == setsInView.length ) {
+		var setData = setsInView.pop();
+
+		// If the first set of IS posts is in the same view as the posts loaded in the template by WordPress, determine how much of the view is comprised of IS-loaded posts
+		if ( ( ( windowBottom - setData.top ) / windowSize ) < 0.5 )
+			pageNum = -1;
+		else
+			pageNum = setData.pageNum;
+	}
+	else {
+		var majorityPercentageInView = 0;
+
+		// Identify the IS set that comprises the majority of the current window and set the URL to it.
+		$.each( setsInView, function( i, setData ) {
+			var topInView     = 0,
+				bottomInView  = 0,
+				percentOfView = 0;
+
+			// Figure percentage of view the current set represents
+			if ( setData.top > windowTop && setData.top < windowBottom )
+				topInView = ( windowBottom - setData.top ) / windowSize;
+
+			if ( setData.bottom > windowTop && setData.bottom < windowBottom )
+				bottomInView = ( setData.bottom - windowTop ) / windowSize;
+
+			// Figure out largest percentage of view for current set
+			if ( topInView >= bottomInView )
+				percentOfView = topInView;
+			else if ( bottomInView >= topInView )
+				percentOfView = bottomInView;
+
+			// Does current set's percentage of view supplant the largest previously-found set?
+			if ( percentOfView > majorityPercentageInView ) {
+				pageNum = setData.pageNum;
+				majorityPercentageInView = percentOfView;
+			}
+		} );
+	}
+
+	// If a page number could be determined, update the URL
+	// -1 indicates that the original requested URL should be used.
+	if ( 'number' == typeof pageNum ) {
+		if ( pageNum != -1 )
+			pageNum += ( 0 == self.offset ) ? 1 : self.offset;
+
+		self.updateURL( pageNum );
+	}
+}
+
+/**
+ * Update address bar to reflect archive page URL for a given page number.
+ * Checks if URL is different to prevent polution of browser history.
+ */
+Scroller.prototype.updateURL = function( page ) {
+	var self = this,
+		pageSlug = -1 == page ? self.origURL : window.location.protocol + '//' + self.history.host + self.history.path.replace( /%d/, page );
+
+	if ( window.location.href != pageSlug )
+		history.pushState( null, null, pageSlug );
+}
+
+/**
+ * Ready, set, go!
+ */
+$( document ).ready( function() {
+	// Check for our variables
+	if ( ! infiniteScroll )
+		return;
+
+	// Set ajaxurl (for brevity)
+	ajaxurl = infiniteScroll.settings.ajaxurl;
+
+	// Set stats, used for tracking stats
+	stats = infiniteScroll.settings.stats;
+
+	// Define what type of infinity we have, grab text for click-handle
+	type  = infiniteScroll.settings.type;
+	text  = infiniteScroll.settings.text;
+	totop = infiniteScroll.settings.totop;
+
+	// Initialize the scroller (with the ID of the element from the theme)
+	infiniteScroll.scroller = new Scroller( infiniteScroll.settings );
+
+	/**
+	 * Monitor user scroll activity to update URL to correspond to archive page for current set of IS posts
+	 * IE only supports pushState() in v10 and above, so don't bother if those conditions aren't met.
+	 */
+	if ( ! isIE || ( isIE && IEVersion >= 10 ) ) {
+		$( window ).bind( 'scroll', function() {
+			clearTimeout( timer );
+			timer = setTimeout( infiniteScroll.scroller.determineURL , 100 );
+		});
+	}
+});
+
+
+})(jQuery); // Close closure
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/infinity.php b/plugins/jetpack/modules/infinite-scroll/infinity.php
new file mode 100644
index 00000000..ad57f1b6
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/infinity.php
@@ -0,0 +1,945 @@
+<?php
+
+/*
+Plugin Name: The Neverending Home Page.
+Plugin URI: http://automattic.com/
+Description: Adds infinite scrolling support to the front-end blog post view for themes, pulling the next set of posts automatically into view when the reader approaches the bottom of the page.
+Version: 1.1
+Author: Automattic
+Author URI: http://automattic.com/
+License: GNU General Public License v2 or later
+License URI: http://www.gnu.org/licenses/gpl-2.0.html
+*/
+
+/**
+ * Class: The_Neverending_Home_Page relies on add_theme_support, expects specific
+ * styling from each theme; including fixed footer.
+ */
+class The_Neverending_Home_Page {
+	/**
+	 *
+	 */
+	function __construct() {
+		add_filter( 'pre_get_posts',                  array( $this, 'posts_per_page_query' ) );
+
+		add_action( 'admin_init',                     array( $this, 'settings_api_init' ) );
+		add_action( 'template_redirect',              array( $this, 'action_template_redirect' ) );
+		add_action( 'template_redirect',              array( $this, 'ajax_response' ) );
+		add_action( 'custom_ajax_infinite_scroll',    array( $this, 'query' ) );
+		add_action( 'the_post',                       array( $this, 'preserve_more_tag' ) );
+		add_action( 'get_footer',                     array( $this, 'footer' ) );
+
+		// Plugin compatibility
+		add_filter( 'grunion_contact_form_redirect_url', array( $this, 'filter_grunion_redirect_url' ) );
+
+		// Parse IS settings from theme
+		self::get_settings();
+	}
+
+	/**
+	 * Initialize our static variables
+	 */
+	static $the_time = null;
+	static $settings = null; // Don't access directly, instead use self::get_settings().
+
+	static $option_name_enabled = 'infinite_scroll';
+
+	/**
+	 * Parse IS settings provided by theme
+	 *
+	 * @uses get_theme_support, infinite_scroll_has_footer_widgets, sanitize_title, add_action, get_option, wp_parse_args, is_active_sidebar
+	 * @return object
+	 */
+	static function get_settings() {
+		if ( is_null( self::$settings ) ) {
+			$css_pattern = '#[^A-Z\d\-_]#i';
+
+			$settings = $defaults = array(
+				'type'           => 'scroll', // scroll | click
+				'requested_type' => 'scroll', // store the original type for use when logic overrides it
+				'footer_widgets' => false, // true | false | sidebar_id | array of sidebar_ids -- last two are checked with is_active_sidebar
+				'container'      => 'content', // container html id
+				'wrapper'        => true, // true | false | html class
+				'render'         => false, // optional function, otherwise the `content` template part will be used
+				'footer'         => true, // boolean to enable or disable the infinite footer | string to provide an html id to derive footer width from
+				'posts_per_page' => false // int | false to set based on IS type
+			);
+
+			// Validate settings passed through add_theme_support()
+			$_settings = get_theme_support( 'infinite-scroll' );
+
+			if ( is_array( $_settings ) ) {
+				// Preferred implementation, where theme provides an array of options
+				if ( isset( $_settings[0] ) && is_array( $_settings[0] ) ) {
+					foreach ( $_settings[0] as $key => $value ) {
+						switch ( $key ) {
+							case 'type' :
+								if ( in_array( $value, array( 'scroll', 'click' ) ) )
+									$settings[ $key ] = $settings['requested_type'] = $value;
+
+								break;
+
+							case 'footer_widgets' :
+								if ( is_string( $value ) )
+									$settings[ $key ] = sanitize_title( $value );
+								elseif ( is_array( $value ) )
+									$settings[ $key ] = array_map( 'sanitize_title', $value );
+								elseif ( is_bool( $value ) )
+									$settings[ $key ] = $value;
+
+								break;
+
+							case 'container' :
+							case 'wrapper' :
+								if ( 'wrapper' == $key && is_bool( $value ) ) {
+									$settings[ $key ] = $value;
+								}
+								else {
+									$value = preg_replace( $css_pattern, '', $value );
+
+									if ( ! empty( $value ) )
+										$settings[ $key ] = $value;
+								}
+
+								break;
+
+							case 'render' :
+								if ( false !== $value && is_callable( $value ) ) {
+									$settings[ $key ] = $value;
+
+									add_action( 'infinite_scroll_render', $value );
+								}
+
+								break;
+
+							case 'footer' :
+								if ( is_bool( $value ) ) {
+									$settings[ $key ] = $value;
+								}
+								elseif ( is_string( $value ) ) {
+									$value = preg_replace( $css_pattern, '', $value );
+
+									if ( ! empty( $value ) )
+										$settings[ $key ] = $value;
+								}
+
+								break;
+
+							case 'posts_per_page' :
+								if ( is_numeric( $value ) )
+									$settings[ $key ] = (int) $value;
+
+								break;
+
+							default:
+								continue;
+
+								break;
+						}
+					}
+				}
+				// Checks below are for backwards compatibility
+				elseif ( is_string( $_settings[0] ) ) {
+					// Container to append new posts to
+					$settings['container'] = preg_replace( $css_pattern, '', $_settings[0] );
+
+					// Wrap IS elements?
+					if ( isset( $_settings[1] ) )
+						$settings['wrapper'] = (bool) $_settings[1];
+				}
+			}
+
+			// Always ensure all values are present in the final array
+			$settings = wp_parse_args( $settings, $defaults );
+
+			// Check if a legacy `infinite_scroll_has_footer_widgets()` function is defined and override the footer_widgets parameter's value.
+			// Otherwise, if a widget area ID or array of IDs was provided in the footer_widgets parameter, check if any contains any widgets.
+			// It is safe to use `is_active_sidebar()` before the sidebar is registered as this function doesn't check for a sidebar's existence when determining if it contains any widgets.
+			if ( function_exists( 'infinite_scroll_has_footer_widgets' ) ) {
+				$settings['footer_widgets'] = (bool) infinite_scroll_has_footer_widgets();
+			}
+			elseif ( is_array( $settings['footer_widgets'] ) ) {
+				$sidebar_ids = $settings['footer_widgets'];
+				$settings['footer_widgets'] = false;
+
+				foreach ( $sidebar_ids as $sidebar_id ) {
+					if ( is_active_sidebar( $sidebar_id ) ) {
+						$settings['footer_widgets'] = true;
+						break;
+					}
+				}
+
+				unset( $sidebar_ids );
+				unset( $sidebar_id );
+			}
+			elseif ( is_string( $settings['footer_widgets'] ) ) {
+				$settings['footer_widgets'] = (bool) is_active_sidebar( $settings['footer_widgets'] );
+			}
+
+			// For complex logic, let themes filter the `footer_widgets` parameter.
+			$settings['footer_widgets'] = apply_filters( 'infinite_scroll_has_footer_widgets', $settings['footer_widgets'] );
+
+			// Finally, after all of the sidebar checks and filtering, ensure that a boolean value is present, otherwise set to default of `false`.
+			if ( ! is_bool( $settings['footer_widgets'] ) )
+				$settings['footer_widgets'] = false;
+
+			// Ensure that IS is enabled and no footer widgets exist if the IS type isn't already "click".
+			if ( 'click' != $settings['type'] ) {
+				// Check the setting status
+				$disabled = '' === get_option( self::$option_name_enabled ) ? true : false;
+
+				// Footer content or Reading option check
+				if ( $settings['footer_widgets'] || $disabled )
+					$settings['type'] = 'click';
+			}
+
+			// Backwards compatibility for posts_per_page setting
+			if ( false === $settings['posts_per_page'] )
+				$settings['posts_per_page'] = 'click' == $settings['type'] ? (int) get_option( 'posts_per_page' ) : 7;
+
+			// Store final settings in a class static to avoid reparsing
+			self::$settings = apply_filters( 'infinite_scroll_settings', $settings );
+		}
+
+		return (object) self::$settings;
+	}
+
+	/**
+	 * Has infinite scroll been triggered?
+	 */
+	static function got_infinity() {
+		return isset( $_GET[ 'infinity' ] );
+	}
+
+	/**
+	 * The more tag will be ignored by default if the blog page isn't our homepage.
+	 * Let's force the $more global to false.
+	 */
+	function preserve_more_tag( $array ) {
+		global $more;
+
+		if ( self::got_infinity() )
+			$more = 0; //0 = show content up to the more tag. Add more link.
+
+		return $array;
+	}
+
+	/**
+	 * Add a checkbox field to Settings > Reading
+	 * for enabling infinite scroll.
+	 *
+	 * Only show if the current theme supports infinity.
+	 *
+	 * @uses current_theme_supports, add_settings_field, __, register_setting
+	 * @action admin_init
+	 * @return null
+	 */
+	function settings_api_init() {
+		if ( ! current_theme_supports( 'infinite-scroll' ) )
+			return;
+
+		// Add the setting field [infinite_scroll] and place it in Settings > Reading
+		add_settings_field( self::$option_name_enabled, '<span id="infinite-scroll-options">' . __( 'To infinity and beyond', 'jetpack' ) . '</span>', array( $this, 'infinite_setting_html' ), 'reading' );
+		register_setting( 'reading', self::$option_name_enabled, 'esc_attr' );
+	}
+
+	/**
+	 * HTML code to display a checkbox true/false option
+	 * for the infinite_scroll setting.
+	 */
+	function infinite_setting_html() {
+		$notice = '<em>' . __( "We've disabled this option for you since you have footer widgets in Appearance &rarr; Widgets, or because your theme does not support infinite scroll.", 'jetpack' ) . '</em>';
+
+		// If the blog has footer widgets, show a notice instead of the checkbox
+		if ( self::get_settings()->footer_widgets || 'click' == self::get_settings()->requested_type ) {
+			echo '<label>' . $notice . '</label>';
+		} else {
+			echo '<label><input name="infinite_scroll" type="checkbox" value="1" ' . checked( 1, '' !== get_option( self::$option_name_enabled ), false ) . ' /> ' . __( 'Scroll Infinitely', 'jetpack' ) . '</br><small>' . sprintf( __( '(Shows %s posts on each load)', 'jetpack' ), number_format_i18n( self::get_settings()->posts_per_page ) ) . '</small>' . '</label>';
+		}
+	}
+
+	/**
+	 * Does the legwork to determine whether the feature is enabled.
+	 *
+	 * @uses current_theme_supports, self::archive_supports_infinity, self::get_settings, self::set_last_post_time, add_filter, wp_enqueue_script, plugins_url, wp_enqueue_style, add_action
+	 * @action template_redirect
+	 * @return null
+	 */
+	function action_template_redirect() {
+		// Check that we support infinite scroll, and are on the home page.
+		if ( ! current_theme_supports( 'infinite-scroll' ) || ! self::archive_supports_infinity() )
+			return;
+
+		$id = self::get_settings()->container;
+
+		// Check that we have an id.
+		if ( empty( $id ) )
+			return;
+
+		// Bail if there are not enough posts for infinity.
+		if ( ! self::set_last_post_time() )
+			return;
+
+		// Add a class to the body.
+		add_filter( 'body_class', array( $this, 'body_class' ) );
+
+		// Add our scripts.
+		wp_enqueue_script( 'the-neverending-homepage', plugins_url( 'infinity.js', __FILE__ ), array( 'jquery' ), '20130101' );
+
+		// Add our default styles.
+		wp_enqueue_style( 'the-neverending-homepage', plugins_url( 'infinity.css', __FILE__ ), array(), '20120612' );
+
+		add_action( 'wp_enqueue_scripts', array( $this, 'enqueue_spinner_scripts' ) );
+
+		add_action( 'wp_head', array( $this, 'action_wp_head' ), 2 );
+
+		add_action( 'wp_footer', array( $this, 'action_wp_footer' ), 99999999 );
+
+		add_filter( 'infinite_scroll_results', array( $this, 'filter_infinite_scroll_results' ), 10, 3 );
+	}
+
+	/**
+	 * Enqueue spinner scripts.
+	 */
+	function enqueue_spinner_scripts() {
+		wp_enqueue_script( 'jquery.spin' );
+	}
+
+	/**
+	 * Adds an 'infinite-scroll' class to the body.
+	 */
+	function body_class( $classes ) {
+		$classes[] = 'infinite-scroll';
+
+		if ( 'scroll' == self::get_settings()->type )
+			$classes[] = 'neverending';
+
+		return $classes;
+	}
+
+	/**
+	 * Grab the timestamp for the last post.
+	 * @return string 'Y-m-d H:i:s' or null
+	 */
+	function set_last_post_time( $date = false ) {
+		global $posts;
+		$count = count( $posts );
+
+		if ( ! empty( $date ) && preg_match( '|\d{4}\-\d{2}\-\d{2}|', $_GET['date'] ) ) {
+			self::$the_time = "$date 00:00:00";
+			return self::$the_time;
+		}
+
+		// If we don't have enough posts for infinity, return early
+		if ( ! $count || $count < self::get_settings()->posts_per_page )
+			return self::$the_time;
+
+		$last_post = end( $posts );
+
+		// If the function is called again but we already have a value, return it
+		if ( null != self::$the_time ) {
+			return self::$the_time;
+		}
+		else if ( isset( $last_post->post_date_gmt ) ) {
+			// Grab the latest post time in Y-m-d H:i:s gmt format
+			self::$the_time = $last_post->post_date_gmt;
+		}
+
+		return self::$the_time;
+	}
+
+	/**
+	 * Create a where clause that will make sure post queries
+	 * will always return results prior to (descending sort)
+	 * or before (ascending sort) the last post date.
+	 *
+	 * @param string $where
+	 * @param object $query
+	 * @filter posts_where
+	 * @return string
+	 */
+	function query_time_filter( $where, $query ) {
+		global $wpdb;
+
+		$operator = 'ASC' == $query->get( 'order' ) ? '>' : '<';
+
+		// Construct the date query using our timestamp
+		$where .= $wpdb->prepare( " AND post_date_gmt {$operator} %s", self::set_last_post_time() );
+
+		return $where;
+	}
+
+	/**
+	 * Let's overwrite the default post_per_page setting to always display a fixed amount.
+	 *
+	 * @global $wp_the_query Used to provide compatibility back to WP 3.2
+	 * @param object $query
+	 * @uses self::archive_supports_infinity, self::get_settings
+	 * @return null
+	 */
+	function posts_per_page_query( $query ) {
+		global $wp_the_query;
+
+		if ( self::archive_supports_infinity() && $query === $wp_the_query ) // After 3.3, this line would be: if ( self::archive_supports_infinity() && $query->is_main_query() )
+			$query->set( 'posts_per_page', self::get_settings()->posts_per_page );
+	}
+
+	/**
+	 * Check if the IS output should be wrapped in a div.
+	 * Setting value can be a boolean or a string specifying the class applied to the div.
+	 *
+	 * @uses self::get_settings
+	 * @return bool
+	 */
+	function has_wrapper() {
+		return (bool) self::get_settings()->wrapper;
+	}
+
+	/**
+	 * Returns the Ajax url
+	 *
+	 * @global $wp
+	 * @uses home_url, is_ssl, add_query_arg, trailingslashit, apply_filters
+	 * @return string
+	 */
+	function ajax_url() {
+		global $wp;
+
+		// When using default permalinks, $wp->request will be null, so we reconstruct the request from the query arguments WP parsed.
+		if ( is_null( $wp->request ) ) {
+			$base_url = home_url( '/', is_ssl() ? 'https' : 'http' );
+			$base_url = add_query_arg( $wp->query_vars, $base_url );
+		} else {
+			$base_url = home_url( trailingslashit( $wp->request ), is_ssl() ? 'https' : 'http' );
+		}
+
+		$ajaxurl = add_query_arg( array( 'infinity' => 'scrolling' ), $base_url );
+
+		return apply_filters( 'infinite_scroll_ajax_url', $ajaxurl );
+	}
+
+	/**
+	 * Our own Ajax response, avoiding calling admin-ajax
+	 */
+	function ajax_response() {
+		// Only proceed if the url query has a key of "Infinity"
+		if ( ! self::got_infinity() )
+			return false;
+
+		define( 'DOING_AJAX', true );
+
+		@header( 'Content-Type: text/html; charset=' . get_option( 'blog_charset' ) );
+		send_nosniff_header();
+
+		do_action( 'custom_ajax_infinite_scroll' );
+		die( '0' );
+	}
+
+	/**
+	 * Prints the relevant infinite scroll settings in JS.
+	 *
+	 * @uses self::get_settings, esc_js, esc_url_raw, self::has_wrapper, __, apply_filters, do_action
+	 * @action wp_head
+	 * @return string
+	 */
+	function action_wp_head() {
+		global $wp_query, $wp_the_query, $wp_rewrite;
+
+		// Base JS settings
+		$js_settings = array(
+			'id'               => self::get_settings()->container,
+			'ajaxurl'          => esc_url_raw( self::ajax_url() ),
+			'type'             => esc_js( self::get_settings()->type ),
+			'wrapper'          => self::has_wrapper(),
+			'wrapper_class'    => is_string( self::get_settings()->wrapper ) ? esc_js( self::get_settings()->wrapper ) : 'infinite-wrap',
+			'footer'           => is_string( self::get_settings()->footer ) ? esc_js( self::get_settings()->footer ) : self::get_settings()->footer,
+			'text'             => esc_js( __( 'Older posts', 'jetpack' ) ),
+			'totop'            => esc_js( __( 'Scroll back to top', 'jetpack' ) ),
+			'order'            => 'DESC',
+			'scripts'          => array(),
+			'styles'           => array(),
+			'google_analytics' => false,
+			'offset'           => $wp_query->get( 'paged' ),
+			'history'          => array(
+				'host'                 => preg_replace( '#^http(s)?://#i', '', untrailingslashit( get_option( 'home' ) ) ),
+				'path'                 => self::get_request_path(),
+				'use_trailing_slashes' => $wp_rewrite->use_trailing_slashes
+			)
+		);
+
+		// Optional order param
+		if ( isset( $_GET['order'] ) ) {
+			$order = strtoupper( $_GET['order'] );
+
+			if ( in_array( $order, array( 'ASC', 'DESC' ) ) )
+				$js_settings['order'] = $order;
+		}
+
+		$js_settings = apply_filters( 'infinite_scroll_js_settings', $js_settings );
+
+		do_action( 'infinite_scroll_wp_head' );
+
+		?>
+		<script type="text/javascript">
+		//<![CDATA[
+		var infiniteScroll = <?php echo json_encode( array( 'settings' => $js_settings ) ); ?>;
+		//]]>
+		</script>
+		<?php
+	}
+
+	/**
+	 * Build path data for current request.
+	 * Used for Google Analytics and pushState history tracking.
+	 *
+	 * @global $wp_rewrite
+	 * @global $wp
+	 * @uses user_trailingslashit, sanitize_text_field, add_query_arg
+	 * @return string|bool
+	 */
+	private function get_request_path() {
+		global $wp_rewrite;
+
+		if ( $wp_rewrite->using_permalinks() ) {
+			global $wp;
+
+			// If called too early, bail
+			if ( ! isset( $wp->request ) )
+				return false;
+
+			// Determine path for paginated version of current request
+			if ( false != preg_match( '#' . $wp_rewrite->pagination_base . '/\d+/?$#i', $wp->request ) )
+				$path = preg_replace( '#' . $wp_rewrite->pagination_base . '/\d+$#i', $wp_rewrite->pagination_base . '/%d', $wp->request );
+			else
+				$path = $wp->request . '/' . $wp_rewrite->pagination_base . '/%d';
+
+			// Slashes everywhere we need them
+			if ( 0 !== strpos( $path, '/' ) )
+				$path = '/' . $path;
+
+			$path = user_trailingslashit( $path );
+		}
+		else {
+			// Clean up raw $_GET input
+			$path = array_map( 'sanitize_text_field', $_GET );
+			$path = array_filter( $path );
+
+			$path['paged'] = '%d';
+
+			$path = add_query_arg( $path, '/' );
+		}
+
+		return empty( $path ) ? false : $path;
+	}
+
+	/**
+	 * Provide IS with a list of the scripts and stylesheets already present on the page.
+	 * Since posts may contain require additional assets that haven't been loaded, this data will be used to track the additional assets.
+	 *
+	 * @global $wp_scripts, $wp_styles
+	 * @action wp_footer
+	 * @return string
+	 */
+	function action_wp_footer() {
+		global $wp_scripts, $wp_styles;
+
+		$scripts = is_a( $wp_scripts, 'WP_Scripts' ) ? $wp_scripts->done : array();
+		$scripts = apply_filters( 'infinite_scroll_existing_scripts', $scripts );
+
+		$styles = is_a( $wp_styles, 'WP_Styles' ) ? $wp_styles->done : array();
+		$styles = apply_filters( 'infinite_scroll_existing_stylesheets', $styles );
+
+		?><script type="text/javascript">
+			jQuery.extend( infiniteScroll.settings.scripts, <?php echo json_encode( $scripts ); ?> );
+			jQuery.extend( infiniteScroll.settings.styles, <?php echo json_encode( $styles ); ?> );
+		</script><?php
+	}
+
+	/**
+	 * Identify additional scripts required by the latest set of IS posts and provide the necessary data to the IS response handler.
+	 *
+	 * @global $wp_scripts
+	 * @uses sanitize_text_field, add_query_arg
+	 * @filter infinite_scroll_results
+	 * @return array
+	 */
+	function filter_infinite_scroll_results( $results, $query_args, $wp_query ) {
+		// Don't bother unless there are posts to display
+		if ( 'success' != $results['type'] )
+			return $results;
+
+		// Parse and sanitize the script handles already output
+		$initial_scripts = isset( $_GET['scripts'] ) && is_array( $_GET['scripts'] ) ? array_map( 'sanitize_text_field', $_GET['scripts'] ) : false;
+
+		if ( is_array( $initial_scripts ) ) {
+			global $wp_scripts;
+
+			// Identify new scripts needed by the latest set of IS posts
+			$new_scripts = array_diff( $wp_scripts->done, $initial_scripts );
+
+			// If new scripts are needed, extract relevant data from $wp_scripts
+			if ( ! empty( $new_scripts ) ) {
+				$results['scripts'] = array();
+
+				foreach ( $new_scripts as $handle ) {
+					// Abort if somehow the handle doesn't correspond to a registered script
+					if ( ! isset( $wp_scripts->registered[ $handle ] ) )
+						continue;
+
+					// Provide basic script data
+					$script_data = array(
+						'handle'     => $handle,
+						'footer'     => ( is_array( $wp_scripts->in_footer ) && in_array( $handle, $wp_scripts->in_footer ) ),
+						'extra_data' => $wp_scripts->print_extra_script( $handle, false )
+					);
+
+					// Base source
+					$src = $wp_scripts->registered[ $handle ]->src;
+
+					// Take base_url into account
+					if ( strpos( $src, 'http' ) !== 0 )
+						$src = $wp_scripts->base_url . $src;
+
+					// Version and additional arguments
+					if ( null === $wp_scripts->registered[ $handle ]->ver )
+						$ver = '';
+					else
+						$ver = $wp_scripts->registered[ $handle ]->ver ? $wp_scripts->registered[ $handle ]->ver : $wp_scripts->default_version;
+
+					if ( isset($wp_scripts->args[ $handle ] ) )
+						$ver = $ver ? $ver . '&amp;' . $wp_scripts->args[$handle] : $wp_scripts->args[$handle];
+
+					// Full script source with version info
+					$script_data['src'] = add_query_arg( 'ver', $ver, $src );
+
+					// Add script to data that will be returned to IS JS
+					array_push( $results['scripts'], $script_data );
+				}
+			}
+		}
+
+		// Expose additional script data to filters, but only include in final `$results` array if needed.
+		if ( ! isset( $results['scripts'] ) )
+			$results['scripts'] = array();
+
+		$results['scripts'] = apply_filters( 'infinite_scroll_additional_scripts', $results['scripts'], $initial_scripts, $results, $query_args, $wp_query );
+
+		if ( empty( $results['scripts'] ) )
+			unset( $results['scripts' ] );
+
+		// Parse and sanitize the style handles already output
+		$initial_styles = isset( $_GET['styles'] ) && is_array( $_GET['styles'] ) ? array_map( 'sanitize_text_field', $_GET['styles'] ) : false;
+
+		if ( is_array( $initial_styles ) ) {
+			global $wp_styles;
+
+			// Identify new styles needed by the latest set of IS posts
+			$new_styles = array_diff( $wp_styles->done, $initial_styles );
+
+			// If new styles are needed, extract relevant data from $wp_styles
+			if ( ! empty( $new_styles ) ) {
+				$results['styles'] = array();
+
+				foreach ( $new_styles as $handle ) {
+					// Abort if somehow the handle doesn't correspond to a registered stylesheet
+					if ( ! isset( $wp_styles->registered[ $handle ] ) )
+						continue;
+
+					// Provide basic style data
+					$style_data = array(
+						'handle' => $handle,
+						'media'  => 'all'
+					);
+
+					// Base source
+					$src = $wp_styles->registered[ $handle ]->src;
+
+					// Take base_url into account
+					if ( strpos( $src, 'http' ) !== 0 )
+						$src = $wp_styles->base_url . $src;
+
+					// Version and additional arguments
+					if ( null === $wp_styles->registered[ $handle ]->ver )
+						$ver = '';
+					else
+						$ver = $wp_styles->registered[ $handle ]->ver ? $wp_styles->registered[ $handle ]->ver : $wp_styles->default_version;
+
+					if ( isset($wp_styles->args[ $handle ] ) )
+						$ver = $ver ? $ver . '&amp;' . $wp_styles->args[$handle] : $wp_styles->args[$handle];
+
+					// Full stylesheet source with version info
+					$style_data['src'] = add_query_arg( 'ver', $ver, $src );
+
+					// Parse stylesheet's conditional comments if present, converting to logic executable in JS
+					if ( isset( $wp_styles->registered[ $handle ]->extra['conditional'] ) && $wp_styles->registered[ $handle ]->extra['conditional'] ) {
+						// First, convert conditional comment operators to standard logical operators. %ver is replaced in JS with the IE version
+						$style_data['conditional'] = str_replace( array(
+							'lte',
+							'lt',
+							'gte',
+							'gt'
+						), array(
+							'%ver <=',
+							'%ver <',
+							'%ver >=',
+							'%ver >',
+						), $wp_styles->registered[ $handle ]->extra['conditional'] );
+
+						// Next, replace any !IE checks. These shouldn't be present since WP's conditional stylesheet implementation doesn't support them, but someone could be _doing_it_wrong().
+						$style_data['conditional'] = preg_replace( '#!\s*IE(\s*\d+){0}#i', '1==2', $style_data['conditional'] );
+
+						// Lastly, remove the IE strings
+						$style_data['conditional'] = str_replace( 'IE', '', $style_data['conditional'] );
+					}
+
+					// Parse requested media context for stylesheet
+					if ( isset( $wp_styles->registered[ $handle ]->args ) )
+						$style_data['media'] = esc_attr( $wp_styles->registered[ $handle ]->args );
+
+					// Add stylesheet to data that will be returned to IS JS
+					array_push( $results['styles'], $style_data );
+				}
+			}
+		}
+
+		// Expose additional stylesheet data to filters, but only include in final `$results` array if needed.
+		if ( ! isset( $results['styles'] ) )
+			$results['styles'] = array();
+
+		$results['styles'] = apply_filters( 'infinite_scroll_additional_stylesheets', $results['styles'], $initial_styles, $results, $query_args, $wp_query );
+
+		if ( empty( $results['styles'] ) )
+			unset( $results['styles' ] );
+
+		// Lastly, return the IS results array
+		return $results;
+	}
+
+	/**
+	 * Runs the query and returns the results via JSON.
+	 * Triggered by an AJAX request.
+	 *
+	 * @global $wp_query
+	 * @global $wp_the_query
+	 * @uses current_user_can, get_option, self::set_last_post_time, current_user_can, apply_filters, self::get_settings, add_filter, WP_Query, remove_filter, have_posts, wp_head, do_action, add_action, this::render, this::has_wrapper, esc_attr, wp_footer, sharing_register_post_for_share_counts, get_the_id
+	 * @return string or null
+	 */
+	function query() {
+		global $wp_query, $wp_the_query;
+
+		if ( ! isset( $_GET['page'] ) || ! current_theme_supports( 'infinite-scroll' ) )
+			die;
+
+		$page = (int) $_GET['page'];
+		$sticky = get_option( 'sticky_posts' );
+
+		if ( ! empty( $_GET['date'] ) )
+			self::set_last_post_time( $_GET['date'] );
+
+		$post_status = array( 'publish' );
+		if ( current_user_can( 'read_private_posts' ) )
+			array_push( $post_status, 'private' );
+
+		$order = in_array( $_GET['order'], array( 'ASC', 'DESC' ) ) ? $_GET['order'] : 'DESC';
+
+		$query_args = array_merge( $wp_the_query->query_vars, array(
+			'paged'          => $page,
+			'post_status'    => $post_status,
+			'posts_per_page' => self::get_settings()->posts_per_page,
+			'post__not_in'   => ( array ) $sticky,
+			'order'          => $order
+		) );
+
+		// By default, don't query for a specific page of a paged post object.
+		// This argument comes from merging $wp_the_query.
+		// Since IS is only used on archives, we should always display the first page of any paged content.
+		unset( $query_args['page'] );
+
+		$query_args = apply_filters( 'infinite_scroll_query_args', $query_args );
+
+		// Add query filter that checks for posts below the date
+		add_filter( 'posts_where', array( $this, 'query_time_filter' ), 10, 2 );
+
+		$wp_the_query = $wp_query = new WP_Query( $query_args );
+
+		remove_filter( 'posts_where', array( $this, 'query_time_filter' ), 10, 2 );
+
+		$results = array();
+
+		if ( have_posts() ) {
+			// Fire wp_head to ensure that all necessary scripts are enqueued. Output isn't used, but scripts are extracted in self::action_wp_footer.
+			ob_start();
+			wp_head();
+			ob_end_clean();
+
+			$results['type'] = 'success';
+
+			// First, try theme's specified rendering handler, either specified via `add_theme_support` or by hooking to this action directly.
+			ob_start();
+			do_action( 'infinite_scroll_render' );
+			$results['html'] = ob_get_clean();
+
+			// Fall back if a theme doesn't specify a rendering function. Because themes may hook additional functions to the `infinite_scroll_render` action, `has_action()` is ineffective here.
+			if ( empty( $results['html'] ) ) {
+				add_action( 'infinite_scroll_render', array( $this, 'render' ) );
+				rewind_posts();
+
+				ob_start();
+				do_action( 'infinite_scroll_render' );
+				$results['html'] = ob_get_clean();
+			}
+
+			// If primary and fallback rendering methods fail, prevent further IS rendering attempts. Otherwise, wrap the output if requested.
+			if ( empty( $results['html'] ) ) {
+				unset( $results['html'] );
+				do_action( 'infinite_scroll_empty' );
+				$results['type'] = 'empty';
+			}
+			elseif ( $this->has_wrapper() ) {
+				$wrapper_classes = is_string( self::get_settings()->wrapper ) ? self::get_settings()->wrapper : 'infinite-wrap';
+				$wrapper_classes .= ' infinite-view-' . $page;
+				$wrapper_classes = trim( $wrapper_classes );
+
+				$results['html'] = '<div class="' . esc_attr( $wrapper_classes ) . '" id="infinite-view-' . $page . '" data-page-num="' . $page . '">' . $results['html'] . '</div>';
+			}
+
+			// Fire wp_footer to ensure that all necessary scripts are enqueued. Output isn't used, but scripts are extracted in self::action_wp_footer.
+			ob_start();
+			wp_footer();
+			ob_end_clean();
+
+			// Loop through posts to capture sharing data for new posts loaded via Infinite Scroll
+			if ( 'success' == $results['type'] && function_exists( 'sharing_register_post_for_share_counts' ) ) {
+				global $jetpack_sharing_counts;
+
+				while( have_posts() ) {
+					the_post();
+
+					sharing_register_post_for_share_counts( get_the_ID() );
+				}
+
+				$results['postflair'] = array_flip( $jetpack_sharing_counts );
+			}
+		} else {
+			do_action( 'infinite_scroll_empty' );
+			$results['type'] = 'empty';
+		}
+
+		echo json_encode( apply_filters( 'infinite_scroll_results', $results, $query_args, $wp_query ) );
+		die;
+	}
+
+	/**
+	 * Rendering fallback used when themes don't specify their own handler.
+	 *
+	 * @uses have_posts, the_post, get_template_part, get_post_format
+	 * @action infinite_scroll_render
+	 * @return string
+	 */
+	function render() {
+		while ( have_posts() ) {
+			the_post();
+
+			get_template_part( 'content', get_post_format() );
+		}
+	}
+
+	/**
+	 * Allow plugins to filter what archives Infinite Scroll supports
+	 *
+	 * @uses apply_filters, current_theme_supports, is_home, is_archive, self::get_settings
+	 * @return bool
+	 */
+	public static function archive_supports_infinity() {
+		return (bool) apply_filters( 'infinite_scroll_archive_supported', current_theme_supports( 'infinite-scroll' ) && ( is_home() || is_archive() ), self::get_settings() );
+	}
+
+	/**
+	 * The Infinite Blog Footer
+	 *
+	 * @uses self::get_settings, self::set_last_post_time, self::archive_supports_infinity, __, wp_get_theme, get_current_theme, apply_filters, home_url, esc_attr, get_bloginfo, bloginfo
+	 * @return string or null
+	 */
+	function footer() {
+		// Bail if theme requested footer not show
+		if ( false == self::get_settings()->footer )
+			return;
+
+		// Bail if there are not enough posts for infinity.
+		if ( ! self::set_last_post_time() )
+			return;
+
+		// We only need the new footer for the 'scroll' type
+		if ( 'scroll' != self::get_settings()->type || ! self::archive_supports_infinity() )
+			return;
+
+		$credits = '<a href="http://wordpress.org/" rel="generator">Proudly powered by WordPress</a> ';
+		$credits .= sprintf( __( 'Theme: %1$s.', 'jetpack' ), function_exists( 'wp_get_theme' ) ? wp_get_theme()->Name : get_current_theme() );
+		$credits = apply_filters( 'infinite_scroll_credit', $credits );
+
+		?>
+		<div id="infinite-footer">
+			<div class="container">
+				<div class="blog-info">
+					<a id="infinity-blog-title" href="<?php echo home_url( '/' ); ?>" title="<?php echo esc_attr( get_bloginfo( 'name', 'display' ) ); ?>" rel="home">
+						<?php bloginfo( 'name' ); ?>
+					</a>
+				</div>
+				<div class="blog-credits">
+					<?php echo $credits; ?>
+				</div>
+			</div>
+		</div><!-- #infinite-footer -->
+		<?php
+	}
+
+	/**
+	 * Ensure that IS doesn't interfere with Grunion by stripping IS query arguments from the Grunion redirect URL.
+	 * When arguments are present, Grunion redirects to the IS AJAX endpoint.
+	 *
+	 * @param string $url
+	 * @uses remove_query_arg
+	 * @filter grunion_contact_form_redirect_url
+	 * @return string
+	 */
+	public function filter_grunion_redirect_url( $url ) {
+		// Remove IS query args, if present
+		if ( false !== strpos( $url, 'infinity=scrolling' ) ) {
+			$url = remove_query_arg( array(
+				'infinity',
+				'action',
+				'page',
+				'order',
+				'scripts',
+				'styles'
+			), $url );
+		}
+
+		return $url;
+	}
+};
+
+/**
+ * Initialize The_Neverending_Home_Page
+ */
+function the_neverending_home_page_init() {
+	if ( ! current_theme_supports( 'infinite-scroll' ) )
+		return;
+
+	new The_Neverending_Home_Page;
+}
+add_action( 'init', 'the_neverending_home_page_init', 20 );
+
+/**
+ * Check whether the current theme is infinite-scroll aware.
+ * If so, include the files which add theme support.
+ */
+function the_neverending_home_page_theme_support() {
+	$theme_name = get_stylesheet();
+
+	$customization_file = apply_filters( 'infinite_scroll_customization_file', dirname( __FILE__ ) . "/themes/{$theme_name}.php", $theme_name );
+
+	if ( is_readable( $customization_file ) )
+		require_once( $customization_file );
+}
+add_action( 'after_setup_theme', 'the_neverending_home_page_theme_support', 5 );
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.css b/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.css
new file mode 100644
index 00000000..cc232785
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.css
@@ -0,0 +1,45 @@
+/* =Infinity Styles
+-------------------------------------------------------------- */
+.infinite-scroll #main:after {
+	clear: both;
+	content: '';
+	display: block;
+}
+.infinite-scroll #content {
+	margin-bottom: 40px;
+}
+.infinite-scroll.neverending #content {
+	margin-bottom: 70px;
+}
+.infinite-scroll .infinite-wrap {
+	border-top: none;
+	padding-top: 0;
+}
+.infinite-scroll .infinite-wrap .hentry:last-child {
+	border-bottom: 1px solid #ddd;
+}
+.infinite-scroll .infinite-wrap:last-of-type .hentry:last-child {
+	border-bottom: none;
+}
+
+/**
+ * Elements to hide:
+ * (footer widgets, post navigation, regular footer)
+ */
+.infinite-scroll.neverending #colophon #supplementary,
+.infinite-scroll #nav-below,
+.infinite-scroll.neverending #colophon {
+	display: none;
+}
+
+/* Hooks to infinity-end body class to restore footer */
+.infinity-end.neverending #colophon {
+	display: block;
+}
+
+/* For responsive CSS */
+@media (max-width: 800px) {
+	.infinite-scroll #infinite-handle {
+		padding-bottom: 40px;
+	}
+}
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.php b/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.php
new file mode 100644
index 00000000..a80ee810
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentyeleven.php
@@ -0,0 +1,27 @@
+<?php
+/**
+ * Infinite Scroll Theme Assets
+ *
+ * Register support for @Twenty Eleven and enqueue relevant styles.
+ */
+
+/**
+ * Add theme support for infinity scroll
+ */
+function twenty_eleven_infinite_scroll_init() {
+	add_theme_support( 'infinite-scroll', array(
+		'container'      => 'content',
+		'footer_widgets' => array( 'sidebar-3', 'sidebar-4', 'sidebar-5' ),
+		'footer'         => 'page',
+	) );
+}
+add_action( 'init', 'twenty_eleven_infinite_scroll_init' );
+
+/**
+ * Enqueue CSS stylesheet with theme styles for infinity.
+ */
+function twenty_eleven_infinite_scroll_enqueue_styles() {
+	// Add theme specific styles.
+	wp_enqueue_style( 'infinity-twentyeleven', plugins_url( 'twentyeleven.css', __FILE__ ), array( 'the-neverending-homepage' ), '20121002' );
+}
+add_action( 'wp_enqueue_scripts', 'twenty_eleven_infinite_scroll_enqueue_styles', 25 );
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentyten.css b/plugins/jetpack/modules/infinite-scroll/themes/twentyten.css
new file mode 100644
index 00000000..889abb3f
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentyten.css
@@ -0,0 +1,25 @@
+/* =Infinity Styles
+-------------------------------------------------------------- */
+.infinite-scroll #wrapper {
+	margin-bottom: 40px;
+}
+.infinite-scroll #content {
+	margin-bottom: 50px;
+}
+.infinite-scroll #content .infinite-wrap {
+	padding-top: 0;
+	border-top: 0;
+}
+/* Elements to hide */
+.infinite-scroll #nav-above,
+.infinite-scroll #nav-below,
+.infinite-scroll.neverending #footer {
+	display: none;
+}
+/* Restore the footer when IS is finished */
+.infinity-end.neverending #footer {
+	display: block;
+}
+#infinite-footer .blog-info a {
+	font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+}
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentyten.php b/plugins/jetpack/modules/infinite-scroll/themes/twentyten.php
new file mode 100644
index 00000000..094cef9c
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentyten.php
@@ -0,0 +1,48 @@
+<?php
+/**
+ * Infinite Scroll Theme Assets
+ *
+ * Register support for @Twenty Ten and enqueue relevant styles.
+ */
+
+/**
+ * Add theme support for infinity scroll
+ */
+function twenty_ten_infinite_scroll_init() {
+	add_theme_support( 'infinite-scroll', array(
+		'container' => 'content',
+		'render'    => 'twenty_ten_infinite_scroll_render',
+		'footer'    => 'wrapper',
+	) );
+}
+add_action( 'init', 'twenty_ten_infinite_scroll_init' );
+
+/**
+ * Set the code to be rendered on for calling posts,
+ * hooked to template parts when possible.
+ *
+ * Note: must define a loop.
+ */
+function twenty_ten_infinite_scroll_render() {
+	get_template_part( 'loop' );
+}
+
+/**
+ * Enqueue CSS stylesheet with theme styles for infinity.
+ */
+function twenty_ten_infinite_scroll_enqueue_styles() {
+	// Add theme specific styles.
+	wp_enqueue_style( 'infinity-twentyten', plugins_url( 'twentyten.css', __FILE__ ), array( 'the-neverending-homepage' ), '20121002' );
+}
+add_action( 'wp_enqueue_scripts', 'twenty_ten_infinite_scroll_enqueue_styles', 25 );
+
+/**
+ * Do we have footer widgets?
+ */
+function twenty_ten_has_footer_widgets( $has_widgets ) {
+	if ( is_active_sidebar( 'first-footer-widget-area' ) || is_active_sidebar( 'second-footer-widget-area' ) || is_active_sidebar( 'third-footer-widget-area'  ) || is_active_sidebar( 'fourth-footer-widget-area' ) )
+		$has_widgets = true;
+
+	return $has_widgets;
+}
+add_filter( 'infinite_scroll_has_footer_widgets', 'twenty_ten_has_footer_widgets' );
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.css b/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.css
new file mode 100644
index 00000000..032c2c9a
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.css
@@ -0,0 +1,33 @@
+/* =Infinity Styles
+-------------------------------------------------------------- */
+.infinite-scroll .site-content:after {
+	clear: both;
+	content: '';
+	display: block;
+}
+.infinite-wrap {
+	border-top: 0;
+}
+.infinite-scroll.neverending .site-content {
+	margin-bottom: 48px;
+	margin-bottom: 3.428571429rem;
+}
+
+/* Elements to hide: post navigation, regular footer */
+.infinite-scroll #nav-below,
+.infinite-scroll.neverending #colophon {
+	display: none;
+}
+
+/* Hooks to infinity-end body class to restore footer */
+.infinity-end.neverending #colophon {
+	display: block;
+}
+
+/* For responsive CSS */
+@media (max-width: 599px) {
+	.infinite-scroll #infinite-handle {
+		padding-bottom: 48px;
+		padding-bottom: 3.428571429rem;
+	}
+}
\ No newline at end of file
diff --git a/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.php b/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.php
new file mode 100644
index 00000000..f8b77011
--- /dev/null
+++ b/plugins/jetpack/modules/infinite-scroll/themes/twentytwelve.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Infinite Scroll Theme Assets
+ *
+ * Register support for Twenty Twelve and enqueue relevant styles.
+ */
+
+/**
+ * Add theme support for infinite scroll
+ */
+function twenty_twelve_infinite_scroll_init() {
+	add_theme_support( 'infinite-scroll', array(
+		'container'      => 'content',
+		'footer'         => 'page'
+	) );
+}
+add_action( 'after_setup_theme', 'twenty_twelve_infinite_scroll_init' );
+
+/**
+ * Enqueue CSS stylesheet with theme styles for infinity.
+ */
+function twenty_twelve_infinite_scroll_enqueue_styles() {
+    // Add theme specific styles.
+    wp_enqueue_style( 'infinity-twentytwelve', plugins_url( 'twentytwelve.css', __FILE__ ), array( 'the-neverending-homepage' ), '20120817' );
+}
+add_action( 'wp_enqueue_scripts', 'twenty_twelve_infinite_scroll_enqueue_styles', 25 );
+
+/**
+ * Handle `footer_widgets` argument for mobile devices
+ *
+ * @param bool $has_widgets
+ * @uses jetpack_is_mobile, is_front_page, is_active_sidebar
+ * @filter infinite_scroll_has_footer_widgets
+ * @return bool
+ */
+function twenty_twelve_has_footer_widgets( $has_widgets ) {
+	if ( function_exists( 'jetpack_is_mobile' ) && jetpack_is_mobile() ) {
+		if ( is_front_page() && ( is_active_sidebar( 'sidebar-2' ) || is_active_sidebar( 'sidebar-3' ) ) )
+			$has_widgets = true;
+		elseif ( is_active_sidebar( 'sidebar-1' ) )
+			$has_widgets = true;
+	}
+
+	return $has_widgets;
+}
+add_filter( 'infinite_scroll_has_footer_widgets', 'twenty_twelve_has_footer_widgets' );
\ No newline at end of file