<h2>File Contents: /home/planet5/public_html/wp-content/plugins/jetpack/modules/infinite-scroll/infinity.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/jetpack/modules/infinite-scroll/infinity.js'><textarea name='file_content' rows='10' cols='50'>(function($){ // Open closure
// Local vars
var Scroller, ajaxurl, stats, type, text, totop;

// IE requires special handling
var isIE = ( -1 != navigator.userAgent.search( &#039;MSIE&#039; ) );
if ( isIE ) {
	var IEVersion = navigator.userAgent.match(/MSIE\s?(\d+)\.?\d*;/);
	var IEVersion = parseInt( IEVersion[1] );
}

// HTTP ajaxurl when site is HTTPS causes Access-Control-Allow-Origin failure in Desktop and iOS Safari
if ( &quot;https:&quot; == document.location.protocol ) {
	infiniteScroll.settings.ajaxurl = infiniteScroll.settings.ajaxurl.replace( &quot;http://&quot;, &quot;https://&quot; );
}

/**
 * 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          = $( &#039;#&#039; + settings.id );
	this.wrapperClass     = settings.wrapper_class;
	this.ready            = true;
	this.disabled         = false;
	this.page             = 1;
	this.offset           = settings.offset;
	this.currentday       = settings.currentday;
	this.order            = settings.order;
	this.throttle         = false;
	this.handle           = &#039;&lt;div id=&quot;infinite-handle&quot;&gt;&lt;span&gt;&lt;button&gt;&#039; + text.replace( &#039;\\&#039;, &#039;&#039; ) + &#039;&lt;/button&gt;&lt;/span&gt;&lt;/div&gt;&#039;;
	this.click_handle     = settings.click_handle;
	this.google_analytics = settings.google_analytics;
	this.history          = settings.history;
	this.origURL          = window.location.href;
	this.pageCache        = {};

	// Footer settings
	this.footer           = $( &#039;#infinite-footer&#039; );
	this.footer.wrap      = settings.footer;

	// Core&#039;s native MediaElement.js implementation needs special handling
	this.wpMediaelement   = null;

	// We have two type of infinite scroll
	// cases &#039;scroll&#039; and &#039;click&#039;

	if ( type == &#039;scroll&#039; ) {
		// Bind refresh to the scroll event
		// Throttle to check for such case every 300ms

		// On event the case becomes a fact
		this.window.bind( &#039;scroll.infinity&#039;, 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();
                self.determineURL(); // determine the url 
			}
		}, 250 );

		// Ensure that enough posts are loaded to fill the initial viewport, to compensate for short posts and large displays.
		self.ensureFilledViewport();
		this.body.bind( &#039;post-load&#039;, { self: self }, self.checkViewportOnLoad );
	} else if ( type == &#039;click&#039; ) {
		if ( this.click_handle ) {
			this.element.append( this.handle );
		}

		this.body.delegate( &#039;#infinite-handle&#039;, &#039;click.infinity&#039;, function() {
			// Handle the handle
			if ( self.click_handle ) {
				$( &#039;#infinite-handle&#039; ).remove();
			}

			// Fire the refresh
			self.refresh();
		});
	}

	// Initialize any Core audio or video players loaded via IS
	this.body.bind( &#039;post-load&#039;, { self: self }, self.initializeMejs );
};

/**
 * Check whether we should fetch any additional posts.
 */
Scroller.prototype.check = function() {
	var container = this.element.offset();

	// If the container can&#039;t be found, stop otherwise errors result
	if ( &#039;object&#039; !== typeof container ) {
		return false;
	}

	var bottom = this.window.scrollTop() + this.window.height(),
		threshold = container.top + this.element.outerHeight(false) - (this.window.height() * 2);

	return bottom &gt; threshold;
};

/**
 * Renders the results from a successful response.
 */
Scroller.prototype.render = function( response ) {
	this.body.addClass( &#039;infinity-success&#039; );

	// Check if we can wrap the html
	this.element.append( response.html );
	this.body.trigger( &#039;post-load&#039;, response );
	this.ready = true;
};

/**
 * Returns the object used to query for new posts.
 */
Scroller.prototype.query = function() {
	return {
		page           : this.page,
		currentday     : this.currentday,
		order          : this.order,
		scripts        : window.infiniteScroll.settings.scripts,
		styles         : window.infiniteScroll.settings.styles,
		query_args     : window.infiniteScroll.settings.query_args,
		last_post_date : window.infiniteScroll.settings.last_post_date
	};
};

/**
 * Scroll back to top.
 */
Scroller.prototype.gotop = function() {
	var blog = $( &#039;#infinity-blog-title&#039; );

	blog.attr( &#039;title&#039;, totop );

	// Scroll to top on blog title
	blog.bind( &#039;click&#039;, function( e ) {
		$( &#039;html, body&#039; ).animate( { scrollTop: 0 }, &#039;fast&#039; );
		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 ) === &quot;string&quot; ) {
		width = $( &#039;body #&#039; + this.footer.wrap ).outerWidth( false );

		// Make the footer match the width of the page
		if ( width &gt; 479 )
			this.footer.find( &#039;.container&#039; ).css( &#039;width&#039;, width );
	}

	// Reveal footer
	if ( this.window.scrollTop() &gt;= 350 )
		self.footer.animate( { &#039;bottom&#039;: 0 }, &#039;fast&#039; );
	else if ( this.window.scrollTop() &lt; 350 )
		self.footer.animate( { &#039;bottom&#039;: &#039;-50px&#039; }, &#039;fast&#039; );
};


/**
 * Controls the flow of the refresh. Don&#039;t mess.
 */
Scroller.prototype.refresh = function() {
	var	self   = this,
		query, jqxhr, load, loader, color, customized;

	// If we&#039;re disabled, ready, or don&#039;t pass the check, bail.
	if ( this.disabled || ! this.ready || ! this.check() )
		return;

	// Let&#039;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&#039;s working.
	if ( this.click_handle ) {
		loader = &#039;&lt;span class=&quot;infinite-loader&quot;&gt;&lt;/span&gt;&#039;;
		this.element.append( loader );

		loader = this.element.find( &#039;.infinite-loader&#039; );
		color = loader.css( &#039;color&#039; );

		try {
			loader.spin( &#039;medium-left&#039;, color );
		} catch ( error ) { }
	}

	// Generate our query vars.
	query = $.extend({
		action: &#039;infinite_scroll&#039;
	}, this.query() );

	// Inject Customizer state.
	if ( &#039;undefined&#039; !== typeof wp &amp;&amp; wp.customize &amp;&amp; wp.customize.settings.theme ) {
		customized = {};
		query.wp_customize = &#039;on&#039;;
		query.theme = wp.customize.settings.theme.stylesheet;
		wp.customize.each( function( setting ) {
			if ( setting._dirty ) {
				customized[ setting.id ] = setting();
			}
		} );
		query.customized = JSON.stringify( customized );
		query.nonce = wp.customize.settings.nonce.preview;
	}

	// Fire the ajax request.
	jqxhr = $.post( infiniteScroll.settings.ajaxurl, query );

	// Allow refreshes to occur again if an error is triggered.
	jqxhr.fail( function() {
		if ( self.click_handle ) {
			loader.hide();
		}

		self.ready = true;
	});

	// Success handler
	jqxhr.done( function( response ) {
			// On success, let&#039;s hide the loader circle.
			if ( self.click_handle ) {
				loader.hide();
			}

			// Check for and parse our response.
			if ( ! response || ! response.type ) {
				return;
			}

			// If we&#039;ve succeeded...
			if ( response.type == &#039;success&#039; ) {
				// If additional scripts are required by the incoming set of posts, parse them
				if ( response.scripts ) {
					$( response.scripts ).each( function() {
						var elementToAppendTo = this.footer ? &#039;body&#039; : &#039;head&#039;;

						// 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(&#039;script&#039;),
								dataContent = document.createTextNode( &quot;//&lt;![CDATA[ \n&quot; + this.extra_data + &quot;\n//]]&gt;&quot; );

							data.type = &#039;text/javascript&#039;;
							data.appendChild( dataContent );

							document.getElementsByTagName( elementToAppendTo )[0].appendChild(data);
						}

						// Build script tag and append to DOM in requested location
						var script = document.createElement(&#039;script&#039;);
						script.type = &#039;text/javascript&#039;;
						script.src = this.src;
						script.id = this.handle;

						// If MediaElement.js is loaded in by this set of posts, don&#039;t initialize the players a second time as it breaks them all
						if ( &#039;wp-mediaelement&#039; === this.handle ) {
							self.body.unbind( &#039;post-load&#039;, self.initializeMejs );
						}

						if ( &#039;wp-mediaelement&#039; === this.handle &amp;&amp; &#039;undefined&#039; === typeof mejs ) {
							self.wpMediaelement = {};
							self.wpMediaelement.tag = script;
							self.wpMediaelement.element = elementToAppendTo;
							setTimeout( self.maybeLoadMejs.bind( self ), 250 );
						} else {
							document.getElementsByTagName( elementToAppendTo )[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(&#039;link&#039;);
						style.rel = &#039;stylesheet&#039;;
						style.href = this.src;
						style.id = this.handle + &#039;-css&#039;;

						// Destroy link tag if a conditional statement is present and either the browser isn&#039;t IE, or the conditional doesn&#039;t evaluate true
						if ( this.conditional &amp;&amp; ( ! isIE || ! eval( this.conditional.replace( /%ver/g, IEVersion ) ) ) )
							var style = false;

						// Append link tag if necessary
						if ( style )
							document.getElementsByTagName(&#039;head&#039;)[0].appendChild(style);
					} );
				}

				// stash the response in the page cache
				self.pageCache[self.page] = response;

				// Increment the page number
				self.page++;

				// Record pageview in WP Stats, if available.
				if ( stats )
					new Image().src = document.location.protocol + &#039;//pixel.wp.com/g.gif?&#039; + stats + &#039;&amp;post=0&amp;baba=&#039; + Math.random();

				// Add new posts to the postflair object
				if ( &#039;object&#039; == typeof response.postflair &amp;&amp; &#039;object&#039; == typeof WPCOM_sharing_counts )
					WPCOM_sharing_counts = $.extend( WPCOM_sharing_counts, response.postflair );

				// Render the results
				self.render.apply( self, arguments );

				// If &#039;click&#039; type and there are still posts to fetch, add back the handle
				if ( type == &#039;click&#039; ) {
					if ( response.lastbatch ) {
						if ( self.click_handle ) {
							$( &#039;#infinite-handle&#039; ).remove();
							// Update body classes
							self.body.addClass( &#039;infinity-end&#039; ).removeClass( &#039;infinity-success&#039; );
						} else {
							self.body.trigger( &#039;infinite-scroll-posts-end&#039; );
						}
					} else {
						if ( self.click_handle ) {
							self.element.append( self.handle );
						} else {
							self.body.trigger( &#039;infinite-scroll-posts-more&#039; );
						}
					}
				} else if ( response.lastbatch ) {
					self.disabled = true;
					self.body.addClass( &#039;infinity-end&#039; ).removeClass( &#039;infinity-success&#039; );
				}

				// Update currentday to the latest value returned from the server
				if ( response.currentday ) {
					self.currentday = response.currentday;
				}

				// Fire Google Analytics pageview
				if ( self.google_analytics ) {
					var ga_url = self.history.path.replace( /%d/, self.page );
					if ( &#039;object&#039; === typeof _gaq ) {
						_gaq.push( [ &#039;_trackPageview&#039;, ga_url ] );
					}
					if ( &#039;function&#039; === typeof ga ) {
						ga( &#039;send&#039;, &#039;pageview&#039;, ga_url );
					}
				}
			}
		});

	return jqxhr;
};

/**
 * Core&#039;s native media player uses MediaElement.js
 * The library&#039;s size is sufficient that it may not be loaded in time for Core&#039;s helper to invoke it, so we need to delay until `mejs` exists.
 */
Scroller.prototype.maybeLoadMejs = function() {
	if ( null === this.wpMediaelement ) {
		return;
	}

	if ( &#039;undefined&#039; === typeof mejs ) {
		setTimeout( this.maybeLoadMejs, 250 );
	} else {
		document.getElementsByTagName( this.wpMediaelement.element )[0].appendChild( this.wpMediaelement.tag );
		this.wpMediaelement = null;

		// Ensure any subsequent IS loads initialize the players
		this.body.bind( &#039;post-load&#039;, { self: this }, this.initializeMejs );
	}
}

/**
 * Initialize the MediaElement.js player for any posts not previously initialized
 */
Scroller.prototype.initializeMejs = function( ev, response ) {
	// Are there media players in the incoming set of posts?
	if ( ! response.html || -1 === response.html.indexOf( &#039;wp-audio-shortcode&#039; ) &amp;&amp; -1 === response.html.indexOf( &#039;wp-video-shortcode&#039; ) ) {
		return;
	}

	// Don&#039;t bother if mejs isn&#039;t loaded for some reason
	if ( &#039;undefined&#039; === typeof mejs ) {
		return;
	}

	// Adapted from wp-includes/js/mediaelement/wp-mediaelement.js
	// Modified to not initialize already-initialized players, as Mejs doesn&#039;t handle that well
	$(function () {
		var settings = {};

		if ( typeof _wpmejsSettings !== &#039;undefined&#039; ) {
			settings.pluginPath = _wpmejsSettings.pluginPath;
		}

		settings.success = function (mejs) {
			var autoplay = mejs.attributes.autoplay &amp;&amp; &#039;false&#039; !== mejs.attributes.autoplay;
			if ( &#039;flash&#039; === mejs.pluginType &amp;&amp; autoplay ) {
				mejs.addEventListener( &#039;canplay&#039;, function () {
					mejs.play();
				}, false );
			}
		};

		$(&#039;.wp-audio-shortcode, .wp-video-shortcode&#039;).not( &#039;.mejs-container&#039; ).mediaelementplayer( settings );
	});
}

/**
 * Trigger IS to load additional posts if the initial posts don&#039;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 + &#039; &gt; li&#039; ).each( function() {
			postsHeight += $( this ).height();
		} );

		if ( postsHeight === 0 ) {
			self.body.unbind( &#039;post-load&#039;, self.checkViewportOnLoad );
			return;
		}
	}

	// Calculate average height of a set of posts to prevent more posts than needed from being loaded.
	$( &#039;.&#039; + self.wrapperClass ).each( function() {
		aveSetHeight += $( this ).height();
		wrapperQty++;
	} );

	if ( wrapperQty &gt; 0 )
		aveSetHeight = aveSetHeight / wrapperQty;
	else
		aveSetHeight = 0;

	// Load more posts if space permits, otherwise stop checking for a full viewport
	if ( postsHeight &lt; windowHeight &amp;&amp; ( postsHeight + aveSetHeight &lt; windowHeight ) ) {
		self.ready = true;
		self.refresh();
	}
	else {
		self.body.unbind( &#039;post-load&#039;, 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         = this,
		windowTop    = $( window ).scrollTop(),
		windowBottom = windowTop + $( window ).height(),
		windowSize   = windowBottom - windowTop,
		setsInView   = [],
		setsHidden   = [],
		pageNum      = false;

	// Find out which sets are in view
	$( &#039;.&#039; + self.wrapperClass ).each( function() {
		var id         = $( this ).attr( &#039;id&#039; ),
			setTop     = $( this ).offset().top,
			setHeight  = $( this ).outerHeight( false ),
			setBottom  = 0,
			setPageNum = $( this ).data( &#039;page-num&#039; );

		// Account for containers that have no height because their children are floated elements.
		if ( 0 === setHeight ) {
			$( &#039;&gt; *&#039;, 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 &lt; windowTop &amp;&amp; setBottom &gt; windowBottom ) { // top of set is above window, bottom is below
			setsInView.push({&#039;id&#039;: id, &#039;top&#039;: setTop, &#039;bottom&#039;: setBottom, &#039;pageNum&#039;: setPageNum });
		}
		else if( setTop &gt; windowTop &amp;&amp; setTop &lt; windowBottom ) { // top of set is between top (gt) and bottom (lt)
			setsInView.push({&#039;id&#039;: id, &#039;top&#039;: setTop, &#039;bottom&#039;: setBottom, &#039;pageNum&#039;: setPageNum });
		}
		else if( setBottom &gt; windowTop &amp;&amp; setBottom &lt; windowBottom ) { // bottom of set is between top (gt) and bottom (lt)
			setsInView.push({&#039;id&#039;: id, &#039;top&#039;: setTop, &#039;bottom&#039;: setBottom, &#039;pageNum&#039;: setPageNum });
		} else {
			setsHidden.push({&#039;id&#039;: id, &#039;top&#039;: setTop, &#039;bottom&#039;: setBottom, &#039;pageNum&#039;: setPageNum });
		}
	} );

	$.each(setsHidden, function() {
		var $set = $(&#039;#&#039; + this.id);
		if( $set.hasClass( &#039;is--replaced&#039; ) ) {
			return;
		}

	        self.pageCache[ this.pageNum].html = $set.html();

		$set.css(&#039;min-height&#039;, ( this.bottom - this.top ) + &#039;px&#039; )
		    .addClass(&#039;is--replaced&#039;)
		    .empty();
	});

	$.each(setsInView, function() {
		var $set = $(&#039;#&#039; + this.id);

		if( $set.hasClass(&#039;is--replaced&#039;) ) {
			$set.css(&#039;min-height&#039;, &#039;&#039;).removeClass(&#039;is--replaced&#039;);
			if( this.pageNum in self.pageCache ) {
				$set.html( self.pageCache[this.pageNum].html );
		        	self.body.trigger( &#039;post-load&#039;, self.pageCache[this.pageNum] );
			}
		}

	});

	// 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 ) &lt; 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 &gt; windowTop &amp;&amp; setData.top &lt; windowBottom )
				topInView = ( windowBottom - setData.top ) / windowSize;

			if ( setData.bottom &gt; windowTop &amp;&amp; setData.bottom &lt; windowBottom )
				bottomInView = ( setData.bottom - windowTop ) / windowSize;

			// Figure out largest percentage of view for current set
			if ( topInView &gt;= bottomInView )
				percentOfView = topInView;
			else if ( bottomInView &gt;= topInView )
				percentOfView = bottomInView;

			// Does current set&#039;s percentage of view supplant the largest previously-found set?
			if ( percentOfView &gt; 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 ( &#039;number&#039; == typeof pageNum ) {
		if ( pageNum != -1 )
			pageNum++;

		self.updateURL( pageNum );
	}
}

/**
 * Update address bar to reflect archive page URL for a given page number.
 * Checks if URL is different to prevent pollution of browser history.
 */
Scroller.prototype.updateURL = function( page ) {
	// IE only supports pushState() in v10 and above, so don&#039;t bother if those conditions aren&#039;t met.
	if ( ! window.history.pushState ) {
		return;
	}
	var self = this,
		offset = self.offset &gt; 0 ? self.offset - 1 : 0,
		pageSlug = -1 == page ? self.origURL : window.location.protocol + &#039;//&#039; + self.history.host + self.history.path.replace( /%d/, page + offset ) + self.history.parameters;

	if ( window.location.href != pageSlug ) {
		history.pushState( null, null, pageSlug );
	}
}

/**
 * Pause scrolling.
 */
Scroller.prototype.pause = function() {
	this.disabled = true;
};

/**
 * Resume scrolling.
 */
Scroller.prototype.resume = function() {
	this.disabled = false;
};

/**
 * Ready, set, go!
 */
$( document ).ready( function() {
	// Check for our variables
	if ( &#039;object&#039; != typeof infiniteScroll )
		return;

	$( document.body ).addClass( infiniteScroll.settings.body_class );

	// 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
	 */
    if( type == &#039;click&#039; ) {
        var timer = null;
        $( window ).bind( &#039;scroll&#039;, function() {
            // run the real scroll handler once every 250 ms.
            if ( timer ) { return; }
            timer = setTimeout( function() {
                infiniteScroll.scroller.determineURL();
                timer = null;
            } , 250 );
        });
    }

	// Integrate with Selective Refresh in the Customizer.
	if ( &#039;undefined&#039; !== typeof wp &amp;&amp; wp.customize &amp;&amp; wp.customize.selectiveRefresh ) {

		/**
		 * Handle rendering of selective refresh partials.
		 *
		 * Make sure that when a partial is rendered, the Jetpack post-load event
		 * will be triggered so that any dynamic elements will be re-constructed,
		 * such as ME.js elements, Photon replacements, social sharing, and more.
		 * Note that this is applying here not strictly to posts being loaded.
		 * If a widget contains a ME.js element and it is previewed via selective
		 * refresh, the post-load would get triggered allowing any dynamic elements
		 * therein to also be re-constructed.
		 *
		 * @param {wp.customize.selectiveRefresh.Placement} placement
		 */
		wp.customize.selectiveRefresh.bind( &#039;partial-content-rendered&#039;, function( placement ) {
			var content;
			if ( &#039;string&#039; === typeof placement.addedContent ) {
				content = placement.addedContent;
			} else if ( placement.container ) {
				content = $( placement.container ).html();
			}

			if ( content ) {
				$( document.body ).trigger( &#039;post-load&#039;, { html: content } );
			}
		} );

		/*
		 * Add partials for posts added via infinite scroll.
		 *
		 * This is unnecessary when MutationObserver is supported by the browser
		 * since then this will be handled by Selective Refresh in core.
		 */
		if ( &#039;undefined&#039; === typeof MutationObserver ) {
			$( document.body ).on( &#039;post-load&#039;, function( e, response ) {
				var rootElement = null;
				if ( response.html &amp;&amp; -1 !== response.html.indexOf( &#039;data-customize-partial&#039; ) ) {
					if ( infiniteScroll.settings.id ) {
						rootElement = $( &#039;#&#039; + infiniteScroll.settings.id );
					}
					wp.customize.selectiveRefresh.addPartials( rootElement );
				}
			} );
		}
	}
});


})(jQuery); // Close closure
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Fjetpack%2Fmodules%2Finfinite-scroll'>⬅ Back to Directory</a>