← All changes | modules/infinite-scroll/infinity.php +2205 -0 16.2-beta → 16.3 View file →

		@@ -1,0 +1,2205 @@
	1	+<?php // phpcs:ignore WordPress.Files.FileName.InvalidClassFileName
	2	+
	3	+// phpcs:disable Universal.Files.SeparateFunctionsFromOO.Mixed -- TODO: Move classes to appropriately-named class files.
	4	+
	5	+use Automattic\Jetpack\Assets;
	6	+
	7	+if ( ! defined( 'ABSPATH' ) ) {
	8	+ exit( 0 );
	9	+}
	10	+
	11	+/*
	12	+Plugin Name: The Neverending Home Page.
	13	+Plugin URI: https://automattic.com/
	14	+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.
	15	+Version: 1.1
	16	+Author: Automattic
	17	+Author URI: https://automattic.com/
	18	+License: GNU General Public License v2 or later
	19	+License URI: https://www.gnu.org/licenses/gpl-2.0.html
	20	+Text Domain: jetpack
	21	+*/
	22	+
	23	+/**
	24	+ * Class: The_Neverending_Home_Page relies on add_theme_support, expects specific
	25	+ * styling from each theme; including fixed footer.
	26	+ *
	27	+ * @phan-constructor-used-for-side-effects
	28	+ */
	29	+class The_Neverending_Home_Page {
	30	+ /**
	31	+ * Maximum allowed number of posts per page in $_REQUEST.
	32	+ */
	33	+ const MAX_ALLOWED_POSTS_PER_PAGE_ΙΝ_REQUEST = 5000;
	34	+
	35	+ /**
	36	+ * Register actions and filters, plus parse IS settings
	37	+ *
	38	+ * @uses add_action, add_filter, self::get_settings
	39	+ */
	40	+ public function __construct() {
	41	+ add_action( 'pre_get_posts', array( $this, 'posts_per_page_query' ) );
	42	+ add_action( 'admin_init', array( $this, 'settings_api_init' ) );
	43	+ add_action( 'template_redirect', array( $this, 'action_template_redirect' ) );
	44	+ add_action( 'customize_preview_init', array( $this, 'init_customizer_assets' ) );
	45	+ add_action( 'template_redirect', array( $this, 'ajax_response' ) );
	46	+ add_action( 'custom_ajax_infinite_scroll', array( $this, 'query' ) );
	47	+ add_filter( 'infinite_scroll_query_args', array( $this, 'inject_query_args' ) );
	48	+ add_filter( 'infinite_scroll_allowed_vars', array( $this, 'allowed_query_vars' ) );
	49	+ add_action( 'the_post', array( $this, 'preserve_more_tag' ) );
	50	+ add_action( 'wp_footer', array( $this, 'footer' ) );
	51	+ add_filter( 'infinite_scroll_additional_scripts', array( $this, 'add_mejs_config' ) );
	52	+
	53	+ // Plugin compatibility
	54	+ add_filter( 'grunion_contact_form_redirect_url', array( $this, 'filter_grunion_redirect_url' ) );
	55	+
	56	+ // AMP compatibility
	57	+ // needs to happen after parse_query so that Jetpack_AMP_Support::is_amp_request() is ready.
	58	+ add_action( 'wp', array( $this, 'amp_load_hooks' ) );
	59	+
	60	+ // Parse IS settings from theme
	61	+ self::get_settings();
	62	+ }
	63	+
	64	+ /**
	65	+ * Initialize our static variables
	66	+ */
	67	+
	68	+ /**
	69	+ * The time.
	70	+ *
	71	+ * @var null - I don't think this is used?
	72	+ */
	73	+ public static $the_time = null;
	74	+
	75	+ /**
	76	+ * Settings.
	77	+ *
	78	+ * Don't access directly, instead use self::get_settings().
	79	+ *
	80	+ * @var array
	81	+ */
	82	+ public static $settings = null;
	83	+
	84	+ /**
	85	+ * The enabled option name.
	86	+ *
	87	+ * @var string
	88	+ */
	89	+ public static $option_name_enabled = 'infinite_scroll';
	90	+
	91	+ /**
	92	+ * Parse IS settings provided by theme
	93	+ *
	94	+ * @uses get_theme_support, infinite_scroll_has_footer_widgets, sanitize_title, add_action, get_option, wp_parse_args, is_active_sidebar
	95	+ * @return object
	96	+ */
	97	+ public static function get_settings() {
	98	+ $defaults = array(
	99	+ 'type' => 'scroll', // scroll | click
	100	+ 'requested_type' => 'scroll', // store the original type for use when logic overrides it
	101	+ 'footer_widgets' => false, // true | false | sidebar_id | array of sidebar_ids -- last two are checked with is_active_sidebar
	102	+ 'container' => 'content', // container html id
	103	+ 'wrapper' => true, // true | false | html class -- the html class.
	104	+ 'render' => false, // optional function, otherwise the `content` template part will be used
	105	+ 'footer' => true, // boolean to enable or disable the infinite footer | string to provide an html id to derive footer width from
	106	+ 'footer_callback' => false, // function to be called to render the IS footer, in place of the default
	107	+ 'posts_per_page' => false,
	108	+ 'click_handle' => true, // boolean to enable or disable rendering the click handler div. If type is click and this is false, page must include its own trigger with the HTML ID `infinite-handle`.
	109	+ );
	110	+
	111	+ if ( self::$settings === null ) {
	112	+ $css_pattern = '#[^A-Z\d\-_]#i';
	113	+
	114	+ $settings = $defaults;
	115	+ // Validate settings passed through add_theme_support()
	116	+ $_settings = get_theme_support( 'infinite-scroll' );
	117	+
	118	+ if ( is_array( $_settings ) ) {
	119	+ // Preferred implementation, where theme provides an array of options
	120	+ if ( isset( $_settings[0] ) && is_array( $_settings[0] ) ) {
	121	+ foreach ( $_settings[0] as $key => $value ) {
	122	+ switch ( $key ) {
	123	+ case 'type':
	124	+ if ( in_array( $value, array( 'scroll', 'click' ), true ) ) {
	125	+ $settings['requested_type'] = $value;
	126	+ $settings[ $key ] = $settings['requested_type'];
	127	+ }
	128	+
	129	+ break;
	130	+
	131	+ case 'footer_widgets':
	132	+ if ( is_string( $value ) ) {
	133	+ $settings[ $key ] = sanitize_title( $value );
	134	+ } elseif ( is_array( $value ) ) {
	135	+ $settings[ $key ] = array_map( 'sanitize_title', $value );
	136	+ } elseif ( is_bool( $value ) ) {
	137	+ $settings[ $key ] = $value;
	138	+ }
	139	+
	140	+ break;
	141	+
	142	+ case 'container':
	143	+ case 'wrapper':
	144	+ if ( 'wrapper' === $key && is_bool( $value ) ) {
	145	+ $settings[ $key ] = $value;
	146	+ } else {
	147	+ $value = preg_replace( $css_pattern, '', $value );
	148	+
	149	+ if ( ! empty( $value ) ) {
	150	+ $settings[ $key ] = $value;
	151	+ }
	152	+ }
	153	+
	154	+ break;
	155	+
	156	+ case 'render':
	157	+ if ( false !== $value && is_callable( $value ) ) {
	158	+ $settings[ $key ] = $value;
	159	+ }
	160	+
	161	+ break;
	162	+
	163	+ case 'footer':
	164	+ if ( is_bool( $value ) ) {
	165	+ $settings[ $key ] = $value;
	166	+ } elseif ( is_string( $value ) ) {
	167	+ $value = preg_replace( $css_pattern, '', $value );
	168	+
	169	+ if ( ! empty( $value ) ) {
	170	+ $settings[ $key ] = $value;
	171	+ }
	172	+ }
	173	+
	174	+ break;
	175	+
	176	+ case 'footer_callback':
	177	+ if ( is_callable( $value ) ) {
	178	+ $settings[ $key ] = $value;
	179	+ } else {
	180	+ $settings[ $key ] = false;
	181	+ }
	182	+
	183	+ break;
	184	+
	185	+ case 'posts_per_page':
	186	+ if ( is_numeric( $value ) ) {
	187	+ $settings[ $key ] = (int) $value;
	188	+ }
	189	+
	190	+ break;
	191	+
	192	+ case 'click_handle':
	193	+ if ( is_bool( $value ) ) {
	194	+ $settings[ $key ] = $value;
	195	+ }
	196	+
	197	+ break;
	198	+
	199	+ default:
	200	+ break;
	201	+ }
	202	+ }
	203	+ } elseif ( is_string( $_settings[0] ) ) {
	204	+ // Checks below are for backwards compatibility
	205	+
	206	+ // Container to append new posts to
	207	+ $settings['container'] = preg_replace( $css_pattern, '', $_settings[0] );
	208	+
	209	+ // Wrap IS elements?
	210	+ if ( isset( $_settings[1] ) ) {
	211	+ $settings['wrapper'] = (bool) $_settings[1];
	212	+ }
	213	+ }
	214	+ }
	215	+
	216	+ // Always ensure all values are present in the final array
	217	+ $settings = wp_parse_args( $settings, $defaults );
	218	+
	219	+ // Check if a legacy `infinite_scroll_has_footer_widgets()` function is defined and override the footer_widgets parameter's value.
	220	+ // Otherwise, if a widget area ID or array of IDs was provided in the footer_widgets parameter, check if any contains any widgets.
	221	+ // 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.
	222	+ if ( function_exists( 'infinite_scroll_has_footer_widgets' ) ) {
	223	+ // @phan-suppress-next-line PhanUndeclaredFunction -- Checked above. See also https://github.com/phan/phan/issues/1204.
	224	+ $settings['footer_widgets'] = (bool) infinite_scroll_has_footer_widgets();
	225	+ } elseif ( is_array( $settings['footer_widgets'] ) ) {
	226	+ $sidebar_ids = $settings['footer_widgets'];
	227	+ $settings['footer_widgets'] = false;
	228	+
	229	+ foreach ( $sidebar_ids as $sidebar_id ) {
	230	+ if ( is_active_sidebar( $sidebar_id ) ) {
	231	+ $settings['footer_widgets'] = true;
	232	+ break;
	233	+ }
	234	+ }
	235	+
	236	+ unset( $sidebar_ids );
	237	+ unset( $sidebar_id );
	238	+ } elseif ( is_string( $settings['footer_widgets'] ) ) {
	239	+ $settings['footer_widgets'] = (bool) is_active_sidebar( $settings['footer_widgets'] );
	240	+ }
	241	+
	242	+ /**
	243	+ * Filter Infinite Scroll's `footer_widgets` parameter.
	244	+ *
	245	+ * @module infinite-scroll
	246	+ *
	247	+ * @since 2.0.0
	248	+ *
	249	+ * @param bool $settings['footer_widgets'] Does the current theme have Footer Widgets.
	250	+ */
	251	+ $settings['footer_widgets'] = apply_filters( 'infinite_scroll_has_footer_widgets', $settings['footer_widgets'] );
	252	+
	253	+ // Finally, after all of the sidebar checks and filtering, ensure that a boolean value is present, otherwise set to default of `false`.
	254	+ if ( ! is_bool( $settings['footer_widgets'] ) ) {
	255	+ $settings['footer_widgets'] = false;
	256	+ }
	257	+
	258	+ // Ensure that IS is enabled and no footer widgets exist if the IS type isn't already "click".
	259	+ if ( 'click' !== $settings['type'] ) {
	260	+ // Check the setting status
	261	+ $disabled = '' === get_option( self::$option_name_enabled );
	262	+
	263	+ // Footer content or Reading option check
	264	+ if ( $settings['footer_widgets'] || $disabled ) {
	265	+ $settings['type'] = 'click';
	266	+ }
	267	+ }
	268	+
	269	+ // Force display of the click handler and attendant bits when the type isn't `click`
	270	+ if ( 'click' !== $settings['type'] ) {
	271	+ $settings['click_handle'] = true;
	272	+ }
	273	+
	274	+ // Store final settings in a class static to avoid reparsing
	275	+ self::$settings = $settings;
	276	+ }
	277	+
	278	+ /**
	279	+ * Filter the array of Infinite Scroll settings.
	280	+ *
	281	+ * @module infinite-scroll
	282	+ *
	283	+ * @since 2.0.0
	284	+ *
	285	+ * @param array $settings Array of Infinite Scroll settings.
	286	+ */
	287	+ $filtered_settings = apply_filters( 'infinite_scroll_settings', self::$settings );
	288	+
	289	+ // Ensure all properties are still set.
	290	+ return (object) wp_parse_args( $filtered_settings, $defaults );
	291	+ }
	292	+
	293	+ /**
	294	+ * Number of posts per page.
	295	+ *
	296	+ * @uses self::wp_query, self::get_settings, apply_filters
	297	+ * @return int
	298	+ */
	299	+ public static function posts_per_page() {
	300	+ $settings = self::get_settings();
	301	+ $posts_per_page = $settings->posts_per_page ? $settings->posts_per_page : self::wp_query()->get( 'posts_per_page' );
	302	+ $posts_per_page_core_option = get_option( 'posts_per_page' );
	303	+
	304	+ // If Infinite Scroll is set to click, and if the site owner changed posts_per_page, let's use that.
	305	+ if (
	306	+ 'click' === $settings->type
	307	+ && ( '10' !== $posts_per_page_core_option )
	308	+ ) {
	309	+ $posts_per_page = $posts_per_page_core_option;
	310	+ }
	311	+
	312	+ // Take JS query into consideration here.
	313	+ $posts_per_page_in_request = isset( $_REQUEST['query_args']['posts_per_page'] ) ? (int) $_REQUEST['query_args']['posts_per_page'] : 0; // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	314	+ if ( $posts_per_page_in_request > 0 &&
	315	+ self::MAX_ALLOWED_POSTS_PER_PAGE_ΙΝ_REQUEST >= $posts_per_page_in_request
	316	+ ) {
	317	+ $posts_per_page = $posts_per_page_in_request;
	318	+ }
	319	+
	320	+ /**
	321	+ * Filter the number of posts per page.
	322	+ *
	323	+ * @module infinite-scroll
	324	+ *
	325	+ * @since 6.0.0
	326	+ *
	327	+ * @param int $posts_per_page The number of posts to display per page.
	328	+ */
	329	+ return (int) apply_filters( 'infinite_scroll_posts_per_page', $posts_per_page );
	330	+ }
	331	+
	332	+ /**
	333	+ * Retrieve the query used with Infinite Scroll
	334	+ *
	335	+ * @global $wp_the_query
	336	+ * @uses apply_filters
	337	+ * @return object
	338	+ */
	339	+ public static function wp_query() {
	340	+ global $wp_the_query;
	341	+ /**
	342	+ * Filter the Infinite Scroll query object.
	343	+ *
	344	+ * @module infinite-scroll
	345	+ *
	346	+ * @since 2.2.1
	347	+ *
	348	+ * @param WP_Query $wp_the_query WP Query.
	349	+ */
	350	+ return apply_filters( 'infinite_scroll_query_object', $wp_the_query );
	351	+ }
	352	+
	353	+ /**
	354	+ * Has infinite scroll been triggered?
	355	+ */
	356	+ public static function got_infinity() {
	357	+ /**
	358	+ * Filter the parameter used to check if Infinite Scroll has been triggered.
	359	+ *
	360	+ * @module infinite-scroll
	361	+ *
	362	+ * @since 3.9.0
	363	+ *
	364	+ * @param bool isset( $_GET[ 'infinity' ] ) Return true if the "infinity" parameter is set.
	365	+ */
	366	+ return apply_filters( 'infinite_scroll_got_infinity', isset( $_GET['infinity'] ) ); // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	367	+ }
	368	+
	369	+ /**
	370	+ * Is this guaranteed to be the last batch of posts?
	371	+ */
	372	+ public static function is_last_batch() {
	373	+ /**
	374	+ * Override whether or not this is the last batch for a request
	375	+ *
	376	+ * @module infinite-scroll
	377	+ *
	378	+ * @since 4.8.0
	379	+ *
	380	+ * @param bool|null null Bool if value should be overridden, null to determine from query
	381	+ * @param object self::wp_query() WP_Query object for current request
	382	+ * @param object self::get_settings() Infinite Scroll settings
	383	+ */
	384	+ $override = apply_filters( 'infinite_scroll_is_last_batch', null, self::wp_query(), self::get_settings() );
	385	+ if ( is_bool( $override ) ) {
	386	+ return $override;
	387	+ }
	388	+
	389	+ $entries = (int) self::wp_query()->found_posts;
	390	+ $posts_per_page = self::posts_per_page();
	391	+
	392	+ // This is to cope with an issue in certain themes or setups where posts are returned but found_posts is 0.
	393	+ if ( 0 === $entries ) {
	394	+ return ( ! is_countable( self::wp_query()->posts ) || ( count( self::wp_query()->posts ) < $posts_per_page ) );
	395	+ }
	396	+ $paged = max( 1, (int) self::wp_query()->get( 'paged' ) );
	397	+
	398	+ // Are there enough posts for more than the first page?
	399	+ if ( $entries <= $posts_per_page ) {
	400	+ return true;
	401	+ }
	402	+
	403	+ // Calculate entries left after a certain number of pages
	404	+ if ( $paged && $paged > 1 ) {
	405	+ $entries -= $posts_per_page * $paged;
	406	+ }
	407	+
	408	+ // Are there some entries left to display?
	409	+ return $entries <= 0;
	410	+ }
	411	+
	412	+ /**
	413	+ * The more tag will be ignored by default if the blog page isn't our homepage.
	414	+ * Let's force the $more global to false.
	415	+ *
	416	+ * @param array $array - the_post array.
	417	+ * @return array
	418	+ */
	419	+ public function preserve_more_tag( $array ) {
	420	+ global $more;
	421	+
	422	+ if ( self::got_infinity() ) {
	423	+ $more = 0; // phpcs:ignore WordPress.WP.GlobalVariablesOverride.Prohibited -- 0 = show content up to the more tag. Add more link.
	424	+ }
	425	+
	426	+ return $array;
	427	+ }
	428	+
	429	+ /**
	430	+ * Add a checkbox field to Settings > Reading
	431	+ * for enabling infinite scroll.
	432	+ *
	433	+ * Only show if the current theme supports infinity.
	434	+ *
	435	+ * @uses current_theme_supports, add_settings_field, __, register_setting
	436	+ * @action admin_init
	437	+ * @return null
	438	+ */
	439	+ public function settings_api_init() {
	440	+ if ( ! current_theme_supports( 'infinite-scroll' ) ) {
	441	+ return;
	442	+ }
	443	+
	444	+ // Add the setting field [infinite_scroll] and place it in Settings > Reading
	445	+ add_settings_field( self::$option_name_enabled, '<span id="infinite-scroll-options">' . esc_html__( 'Infinite Scroll Behavior', 'jetpack' ) . '</span>', array( $this, 'infinite_setting_html' ), 'reading' );
	446	+ register_setting( 'reading', self::$option_name_enabled, 'esc_attr' );
	447	+ }
	448	+
	449	+ /**
	450	+ * HTML code to display a checkbox true/false option
	451	+ * for the infinite_scroll setting.
	452	+ */
	453	+ public function infinite_setting_html() {
	454	+ $settings = self::get_settings();
	455	+
	456	+ // If the blog has footer widgets, show a notice instead of the checkbox
	457	+ if ( $settings->footer_widgets || 'click' === $settings->requested_type ) {
	458	+ echo '<label><em>' . esc_html__( 'We&rsquo;ve changed this option to a click-to-scroll version for you since you have footer widgets in Appearance &rarr; Widgets, or your theme uses click-to-scroll as the default behavior.', 'jetpack' ) . '</em></label>';
	459	+ } else {
	460	+ echo '<label><input name="infinite_scroll" type="checkbox" value="1" ' . checked( 1, '' !== get_option( self::$option_name_enabled ), false ) . ' /> ' . esc_html__( 'Check to load posts as you scroll. Uncheck to show clickable button to load posts', 'jetpack' ) . '</label>';
	461	+ // translators: the number of posts to show on each page load.
	462	+ echo '<p class="description">' . esc_html( sprintf( _n( 'Shows %s post on each load.', 'Shows %s posts on each load.', self::posts_per_page(), 'jetpack' ), number_format_i18n( self::posts_per_page() ) ) ) . '</p>';
	463	+ }
	464	+ }
	465	+
	466	+ /**
	467	+ * Does the legwork to determine whether the feature is enabled.
	468	+ *
	469	+ * @uses current_theme_supports, self::archive_supports_infinity, self::get_settings, add_filter, wp_enqueue_script, plugins_url, wp_enqueue_style, add_action
	470	+ * @action template_redirect
	471	+ * @return null
	472	+ */
	473	+ public function action_template_redirect() {
	474	+ // Check that we support infinite scroll, and are on the home page.
	475	+ if ( ! current_theme_supports( 'infinite-scroll' ) || ! self::archive_supports_infinity() ) {
	476	+ return;
	477	+ }
	478	+
	479	+ $id = self::get_settings()->container;
	480	+
	481	+ // Check that we have an id.
	482	+ if ( empty( $id ) ) {
	483	+ return;
	484	+ }
	485	+
	486	+ // AMP infinite scroll functionality will start on amp_load_hooks().
	487	+ if ( class_exists( 'Jetpack_AMP_Support' ) && Jetpack_AMP_Support::is_amp_request() ) {
	488	+ return;
	489	+ }
	490	+
	491	+ // Add our scripts.
	492	+ wp_register_script(
	493	+ 'the-neverending-homepage',
	494	+ Assets::get_file_url_for_environment(
	495	+ '_inc/build/infinite-scroll/infinity.min.js',
	496	+ 'modules/infinite-scroll/infinity.js'
	497	+ ),
	498	+ array(),
	499	+ JETPACK__VERSION . '-is5.0.1', // Added for ability to cachebust on WP.com.
	500	+ true
	501	+ );
	502	+
	503	+ // Add our default styles.
	504	+ wp_register_style( 'the-neverending-homepage', plugins_url( 'infinity.css', __FILE__ ), array(), '20140422' );
	505	+
	506	+ // Make sure there are enough posts for IS
	507	+ if ( self::is_last_batch() ) {
	508	+ return;
	509	+ }
	510	+
	511	+ // Add our scripts.
	512	+ wp_enqueue_script( 'the-neverending-homepage' );
	513	+
	514	+ // Add our default styles.
	515	+ wp_enqueue_style( 'the-neverending-homepage' );
	516	+
	517	+ add_action( 'wp_footer', array( $this, 'action_wp_footer_settings' ), 2 );
	518	+
	519	+ add_action( 'wp_footer', array( $this, 'action_wp_footer' ), 21 ); // Core prints footer scripts at priority 20, so we just need to be one later than that
	520	+
	521	+ add_filter( 'infinite_scroll_results', array( $this, 'filter_infinite_scroll_results' ), 10, 3 );
	522	+ }
	523	+
	524	+ /**
	525	+ * Initialize the Customizer logic separately from the main JS.
	526	+ *
	527	+ * @since 8.4.0
	528	+ */
	529	+ public function init_customizer_assets() {
	530	+ // Add our scripts.
	531	+ wp_register_script(
	532	+ 'the-neverending-homepage-customizer',
	533	+ Assets::get_file_url_for_environment(
	534	+ '_inc/build/infinite-scroll/infinity-customizer.min.js',
	535	+ 'modules/infinite-scroll/infinity-customizer.js'
	536	+ ),
	537	+ array( 'jquery', 'customize-base' ),
	538	+ JETPACK__VERSION . '-is5.0.0', // Added for ability to cachebust on WP.com.
	539	+ true
	540	+ );
	541	+
	542	+ wp_enqueue_script( 'the-neverending-homepage-customizer' );
	543	+ }
	544	+
	545	+ /**
	546	+ * Returns classes to be added to <body>. If it's enabled, 'infinite-scroll'. If set to continuous scroll, adds 'neverending' too.
	547	+ *
	548	+ * @since 4.7.0 No longer added as a 'body_class' filter but passed to JS environment and added using JS.
	549	+ *
	550	+ * @return string
	551	+ */
	552	+ public function body_class() {
	553	+ $settings = self::get_settings();
	554	+ $classes = '';
	555	+ // Do not add infinity-scroll class if disabled through the Reading page
	556	+ $disabled = '' === get_option( self::$option_name_enabled );
	557	+ if ( ! $disabled || 'click' === $settings->type ) {
	558	+ $classes = 'infinite-scroll';
	559	+
	560	+ if ( 'scroll' === $settings->type ) {
	561	+ $classes .= ' neverending';
	562	+ }
	563	+ }
	564	+
	565	+ return $classes;
	566	+ }
	567	+
	568	+ /**
	569	+ * In case IS is activated on search page, we have to exclude initially loaded posts which match the keyword by title, not the content as they are displayed before content-matching ones
	570	+ *
	571	+ * @uses self::wp_query
	572	+ * @uses self::get_last_post_date
	573	+ * @uses self::has_only_title_matching_posts
	574	+ * @return array
	575	+ */
	576	+ public function get_excluded_posts() {
	577	+
	578	+ $excluded_posts = array();
	579	+ // loop through posts returned by wp_query call
	580	+ foreach ( self::wp_query()->get_posts() as $post ) {
	581	+ if ( ! $post instanceof \WP_Post ) {
	582	+ continue;
	583	+ }
	584	+
	585	+ // @phan-suppress-next-line PhanPluginDuplicateConditionalNullCoalescing -- probably would be safe to collapse, but not changing just in case.
	586	+ $orderby = isset( self::wp_query()->query_vars['orderby'] ) ? self::wp_query()->query_vars['orderby'] : '';
	587	+ $post_date = ( ! empty( $post->post_date ) ? $post->post_date : false );
	588	+ if ( 'modified' === $orderby || false === $post_date ) {
	589	+ $post_date = $post->post_modified;
	590	+ }
	591	+
	592	+ // in case all posts initially displayed match the keyword by title we add em all to excluded posts array
	593	+ // else, we add only posts which are older than last_post_date param as newer are natually excluded by last_post_date condition in the SQL query
	594	+ if ( self::has_only_title_matching_posts() || $post_date <= self::get_last_post_date() ) {
	595	+ array_push( $excluded_posts, $post->ID );
	596	+ }
	597	+ }
	598	+ return $excluded_posts;
	599	+ }
	600	+
	601	+ /**
	602	+ * In case IS is active on search, we have to exclude posts matched by title rather than by post_content in order to prevent dupes on next pages
	603	+ *
	604	+ * @uses self::wp_query
	605	+ * @uses self::get_excluded_posts
	606	+ * @return array
	607	+ */
	608	+ public function get_query_vars() {
	609	+
	610	+ $query_vars = self::wp_query()->query_vars;
	611	+ // applies to search page only
	612	+ if ( true === self::wp_query()->is_search() ) {
	613	+ // set post__not_in array in query_vars in case it does not exists
	614	+ if ( ! isset( $query_vars['post__not_in'] ) ) {
	615	+ $query_vars['post__not_in'] = array();
	616	+ }
	617	+ // get excluded posts
	618	+ $excluded = self::get_excluded_posts();
	619	+ // merge them with other post__not_in posts (eg.: sticky posts)
	620	+ $query_vars['post__not_in'] = array_merge( $query_vars['post__not_in'], $excluded );
	621	+ }
	622	+ return $query_vars;
	623	+ }
	624	+
	625	+ /**
	626	+ * This function checks whether all posts returned by initial wp_query match the keyword by title
	627	+ * The code used in this function is borrowed from WP_Query class where it is used to construct like conditions for keywords
	628	+ *
	629	+ * @uses self::wp_query
	630	+ * @return bool
	631	+ */
	632	+ public function has_only_title_matching_posts() {
	633	+
	634	+ // apply following logic for search page results only
	635	+ if ( false === self::wp_query()->is_search() ) {
	636	+ return false;
	637	+ }
	638	+
	639	+ // grab the last posts in the stack as if the last one is title-matching the rest is title-matching as well
	640	+ $post = end( self::wp_query()->posts );
	641	+ if ( ! $post instanceof WP_Post ) {
	642	+ return false;
	643	+ }
	644	+
	645	+ // code inspired by WP_Query class
	646	+ if ( preg_match_all( '/".*?("|$)|((?<=[\t ",+])|^)[^\t ",+]+/', self::wp_query()->get( 's' ), $matches ) ) {
	647	+ $search_terms = self::wp_query()->query_vars['search_terms'] ?? null;
	648	+ // if the search string has only short terms or stopwords, or is 10+ terms long, match it as sentence
	649	+ if ( empty( $search_terms ) || ! is_countable( $search_terms ) || count( $search_terms ) > 9 ) {
	650	+ $search_terms = array( self::wp_query()->get( 's' ) );
	651	+ }
	652	+ } else {
	653	+ $search_terms = array( self::wp_query()->get( 's' ) );
	654	+ }
	655	+
	656	+ // actual testing. As search query combines multiple keywords with AND, it's enough to check if any of the keywords is present in the title
	657	+ $term = current( $search_terms );
	658	+ if ( ! empty( $term ) && str_contains( $post->post_title, $term ) ) {
	659	+ return true;
	660	+ }
	661	+
	662	+ return false;
	663	+ }
	664	+
	665	+ /**
	666	+ * Grab the timestamp for the initial query's last post.
	667	+ *
	668	+ * This takes into account the query's 'orderby' parameter and returns
	669	+ * false if the posts are not ordered by date.
	670	+ *
	671	+ * @uses self::got_infinity
	672	+ * @uses self::has_only_title_matching_posts
	673	+ * @uses self::wp_query
	674	+ * @return string 'Y-m-d H:i:s' or false
	675	+ */
	676	+ public function get_last_post_date() {
	677	+ if ( self::got_infinity() ) {
	678	+ return;
	679	+ }
	680	+
	681	+ if ( ! self::wp_query()->have_posts() ) {
	682	+ return null;
	683	+ }
	684	+
	685	+ // In case there are only title-matching posts in the initial WP_Query result, we don't want to use the last_post_date param yet
	686	+ if ( true === self::has_only_title_matching_posts() ) {
	687	+ return false;
	688	+ }
	689	+
	690	+ $post = end( self::wp_query()->posts );
	691	+ // @phan-suppress-next-line PhanPluginDuplicateConditionalNullCoalescing -- probably would be safe to collapse, but not changing just in case.
	692	+ $orderby = isset( self::wp_query()->query_vars['orderby'] ) ? self::wp_query()->query_vars['orderby'] : '';
	693	+ $post_date = ( ! empty( $post->post_date ) ? $post->post_date : false );
	694	+ switch ( $orderby ) {
	695	+ case 'modified':
	696	+ return $post->post_modified;
	697	+ case 'date':
	698	+ case '':
	699	+ return $post_date;
	700	+ default:
	701	+ return false;
	702	+ }
	703	+ }
	704	+
	705	+ /**
	706	+ * Returns the appropriate `wp_posts` table field for a given query's
	707	+ * 'orderby' parameter, if applicable.
	708	+ *
	709	+ * @param object $query - an optional query object.
	710	+ * @uses self::wp_query
	711	+ * @return string or false
	712	+ */
	713	+ public function get_query_sort_field( $query = null ) {
	714	+ if ( empty( $query ) ) {
	715	+ $query = self::wp_query();
	716	+ }
	717	+
	718	+ $orderby = $query->query_vars['orderby'] ?? '';
	719	+
	720	+ switch ( $orderby ) {
	721	+ case 'modified':
	722	+ return 'post_modified';
	723	+ case 'date':
	724	+ case '':
	725	+ return 'post_date';
	726	+ default:
	727	+ return false;
	728	+ }
	729	+ }
	730	+
	731	+ /**
	732	+ * Create a where clause that will make sure post queries return posts
	733	+ * in the correct order, without duplicates, if a new post is added
	734	+ * and we're sorting by post date.
	735	+ *
	736	+ * @global $wpdb
	737	+ * @param string $where - the where clause.
	738	+ * @param object $query - the query.
	739	+ * @uses apply_filters
	740	+ * @filter posts_where
	741	+ * @return string
	742	+ */
	743	+ public function query_time_filter( $where, $query ) {
	744	+ if ( self::got_infinity() ) {
	745	+ global $wpdb;
	746	+
	747	+ $sort_field = self::get_query_sort_field( $query );
	748	+
	749	+ if ( 'post_date' !== $sort_field ||
	750	+ ! isset( $_REQUEST['query_args']['order'] ) || 'DESC' !== $_REQUEST['query_args']['order'] ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	751	+ return $where;
	752	+ }
	753	+
	754	+ $query_before = isset( $_REQUEST['query_before'] ) ? sanitize_text_field( wp_unslash( $_REQUEST['query_before'] ) ) : ''; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	755	+
	756	+ if ( empty( $query_before ) ) {
	757	+ return $where;
	758	+ }
	759	+
	760	+ // Construct the date query using our timestamp
	761	+ $clause = $wpdb->prepare( " AND {$wpdb->posts}.post_date <= %s", $query_before );
	762	+
	763	+ /**
	764	+ * Filter Infinite Scroll's SQL date query making sure post queries
	765	+ * will always return results prior to (descending sort)
	766	+ * or before (ascending sort) the last post date.
	767	+ *
	768	+ * @deprecated 14.0
	769	+ *
	770	+ * @module infinite-scroll
	771	+ *
	772	+ * @param string $clause SQL Date query.
	773	+ * @param object $query Query.
	774	+ * @param string $operator @deprecated Query operator.
	775	+ * @param string $last_post_date @deprecated Last Post Date timestamp.
	776	+ */
	777	+ $operator = '<';
	778	+ $last_post_date = isset( $_REQUEST['last_post_date'] ) ? sanitize_text_field( wp_unslash( $_REQUEST['last_post_date'] ) ) : ''; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes to the site
	779	+ $where .= apply_filters_deprecated( 'infinite_scroll_posts_where', array( $clause, $query, $operator, $last_post_date ), '14.0', '' );
	780	+ }
	781	+
	782	+ return $where;
	783	+ }
	784	+
	785	+ /**
	786	+ * Let's overwrite the default post_per_page setting to always display a fixed amount.
	787	+ *
	788	+ * @param object $query - the query.
	789	+ * @uses is_admin, self::archive_supports_infinity, self::get_settings
	790	+ */
	791	+ public function posts_per_page_query( $query ) {
	792	+ if ( ! is_admin() && self::archive_supports_infinity() && $query->is_main_query() ) {
	793	+ $query->set( 'posts_per_page', self::posts_per_page() );
	794	+ }
	795	+ }
	796	+
	797	+ /**
	798	+ * Check if the IS output should be wrapped in a div.
	799	+ * Setting value can be a boolean or a string specifying the class applied to the div.
	800	+ *
	801	+ * @uses self::get_settings
	802	+ * @return bool
	803	+ */
	804	+ public function has_wrapper() {
	805	+ return (bool) self::get_settings()->wrapper;
	806	+ }
	807	+
	808	+ /**
	809	+ * Returns the Ajax url
	810	+ *
	811	+ * @global $wp
	812	+ * @uses home_url, add_query_arg, apply_filters
	813	+ * @return string
	814	+ */
	815	+ public function ajax_url() {
	816	+ $base_url = set_url_scheme( home_url( '/' ) );
	817	+
	818	+ $ajaxurl = add_query_arg( array( 'infinity' => 'scrolling' ), $base_url );
	819	+
	820	+ /**
	821	+ * Filter the Infinite Scroll Ajax URL.
	822	+ *
	823	+ * @module infinite-scroll
	824	+ *
	825	+ * @since 2.0.0
	826	+ *
	827	+ * @param string $ajaxurl Infinite Scroll Ajax URL.
	828	+ */
	829	+ return apply_filters( 'infinite_scroll_ajax_url', $ajaxurl );
	830	+ }
	831	+
	832	+ /**
	833	+ * Our own Ajax response, avoiding calling admin-ajax
	834	+ */
	835	+ public function ajax_response() {
	836	+ // Only proceed if the url query has a key of "Infinity"
	837	+ if ( ! self::got_infinity() ) {
	838	+ return false;
	839	+ }
	840	+
	841	+ // This should already be defined below, but make sure.
	842	+ if ( ! defined( 'DOING_AJAX' ) ) {
	843	+ define( 'DOING_AJAX', true );
	844	+ }
	845	+
	846	+ @header( 'Content-Type: text/html; charset=' . get_option( 'blog_charset' ) ); // phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
	847	+ send_nosniff_header();
	848	+
	849	+ /**
	850	+ * Fires at the end of the Infinite Scroll Ajax response.
	851	+ *
	852	+ * @module infinite-scroll
	853	+ *
	854	+ * @since 2.0.0
	855	+ */
	856	+ do_action( 'custom_ajax_infinite_scroll' );
	857	+ die( '0' );
	858	+ }
	859	+
	860	+ /**
	861	+ * Alias for renamed class method.
	862	+ *
	863	+ * Previously, JS settings object was unnecessarily output in the document head.
	864	+ * When the hook was changed, the method name no longer made sense.
	865	+ */
	866	+ public function action_wp_head() {
	867	+ $this->action_wp_footer_settings();
	868	+ }
	869	+
	870	+ /**
	871	+ * Prints the relevant infinite scroll settings in JS.
	872	+ *
	873	+ * @global $wp_rewrite
	874	+ * @uses self::get_settings, esc_js, esc_url_raw, self::has_wrapper, __, apply_filters, do_action, self::get_query_vars
	875	+ * @action wp_footer
	876	+ */
	877	+ public function action_wp_footer_settings() {
	878	+ global $wp_rewrite;
	879	+ global $currentday;
	880	+
	881	+ $settings = self::get_settings();
	882	+
	883	+ // Default click handle text
	884	+ $click_handle_text = __( 'Older posts', 'jetpack' );
	885	+
	886	+ // If a single CPT is displayed, use its plural name instead of "posts"
	887	+ // Could be empty (posts) or an array of multiple post types.
	888	+ // In the latter two cases cases, the default text is used, leaving the `infinite_scroll_js_settings` filter for further customization.
	889	+ $post_type = self::wp_query()->get( 'post_type' );
	890	+
	891	+ // If it's a taxonomy, try to change the button text.
	892	+ if ( is_tax() ) {
	893	+ // Get current taxonomy slug.
	894	+ $taxonomy_slug = self::wp_query()->get( 'taxonomy' );
	895	+
	896	+ // Get taxonomy settings.
	897	+ $taxonomy = get_taxonomy( $taxonomy_slug );
	898	+
	899	+ // Check if the taxonomy is attached to one post type only and use its plural name.
	900	+ // If not, use "Posts" without confusing the users.
	901	+ if (
	902	+ is_a( $taxonomy, 'WP_Taxonomy' )
	903	+ && is_countable( $taxonomy->object_type )
	904	+ && ! empty( $taxonomy->object_type )
	905	+ && count( $taxonomy->object_type ) < 2
	906	+ ) {
	907	+ // It seems [0] doesn't work, as sometimes plugins can deregister a taxonomy but not reindex.
	908	+ $post_type = reset( $taxonomy->object_type );
	909	+ }
	910	+ }
	911	+
	912	+ if ( is_string( $post_type ) && ! empty( $post_type ) ) {
	913	+ $post_type = get_post_type_object( $post_type );
	914	+
	915	+ if ( is_object( $post_type ) && ! is_wp_error( $post_type ) ) {
	916	+ if ( isset( $post_type->labels->name ) ) {
	917	+ $cpt_text = $post_type->labels->name;
	918	+ } elseif ( isset( $post_type->label ) ) {
	919	+ $cpt_text = $post_type->label;
	920	+ }
	921	+
	922	+ if ( isset( $cpt_text ) ) {
	923	+ /* translators: %s is the name of a custom post type */
	924	+ $click_handle_text = sprintf( __( 'More %s', 'jetpack' ), $cpt_text );
	925	+ unset( $cpt_text );
	926	+ }
	927	+ }
	928	+ }
	929	+
	930	+ unset( $post_type );
	931	+
	932	+ // Base JS settings
	933	+ $js_settings = array(
	934	+ 'id' => $settings->container,
	935	+ 'ajaxurl' => esc_url_raw( self::ajax_url() ),
	936	+ 'type' => esc_js( $settings->type ),
	937	+ 'wrapper' => self::has_wrapper(),
	938	+ 'wrapper_class' => is_string( $settings->wrapper ) ? esc_js( $settings->wrapper ) : 'infinite-wrap',
	939	+ 'footer' => is_string( $settings->footer ) ? esc_js( $settings->footer ) : $settings->footer,
	940	+ 'click_handle' => esc_js( $settings->click_handle ),
	941	+ 'text' => $click_handle_text,
	942	+ 'totop' => __( 'Scroll back to top', 'jetpack' ),
	943	+ 'currentday' => $currentday,
	944	+ 'order' => 'DESC',
	945	+ 'scripts' => array(),
	946	+ 'styles' => array(),
	947	+ 'google_analytics' => false,
	948	+ 'offset' => max( 1, self::wp_query()->get( 'paged' ) ), // Pass through the current page so we can use that to offset the first load.
	949	+ 'history' => array(
	950	+ 'host' => preg_replace( '#^http(s)?://#i', '', untrailingslashit( esc_url( get_home_url() ) ) ),
	951	+ 'path' => self::get_request_path(),
	952	+ 'use_trailing_slashes' => $wp_rewrite->use_trailing_slashes,
	953	+ 'parameters' => self::get_request_parameters(),
	954	+ ),
	955	+ 'query_args' => self::get_query_vars(),
	956	+ 'query_before' => current_time( 'mysql' ),
	957	+ 'last_post_date' => self::get_last_post_date(),
	958	+ 'body_class' => self::body_class(),
	959	+ 'loading_text' => __( 'Loading new page', 'jetpack' ),
	960	+ );
	961	+
	962	+ // Optional order param
	963	+ if ( isset( $_REQUEST['order'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	964	+ $order = strtoupper( sanitize_text_field( wp_unslash( $_REQUEST['order'] ) ) ); // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	965	+
	966	+ if ( in_array( $order, array( 'ASC', 'DESC' ), true ) ) {
	967	+ $js_settings['order'] = $order;
	968	+ }
	969	+ }
	970	+
	971	+ /**
	972	+ * Filter the Infinite Scroll JS settings outputted in the head.
	973	+ *
	974	+ * @module infinite-scroll
	975	+ *
	976	+ * @since 2.0.0
	977	+ *
	978	+ * @param array $js_settings Infinite Scroll JS settings.
	979	+ */
	980	+ $js_settings = apply_filters( 'infinite_scroll_js_settings', $js_settings );
	981	+
	982	+ /**
	983	+ * Fires before Infinite Scroll outputs inline JavaScript in the head.
	984	+ *
	985	+ * @module infinite-scroll
	986	+ *
	987	+ * @since 2.0.0
	988	+ */
	989	+ do_action( 'infinite_scroll_wp_head' );
	990	+
	991	+ ?>
	992	+ <script type="text/javascript">
	993	+ var infiniteScroll = <?php echo wp_json_encode( array( 'settings' => $js_settings ), JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ); ?>;
	994	+ </script>
	995	+ <?php
	996	+ }
	997	+
	998	+ // phpcs:disable WordPress.WP.GlobalVariablesOverride.Prohibited
	999	+
	1000	+ /**
	1001	+ * Build path data for current request.
	1002	+ * Used for Google Analytics and pushState history tracking.
	1003	+ *
	1004	+ * @global $wp_rewrite
	1005	+ * @global $wp
	1006	+ * @uses user_trailingslashit, sanitize_text_field, add_query_arg
	1007	+ * @return string|bool
	1008	+ */
	1009	+ private function get_request_path() {
	1010	+ global $wp_rewrite;
	1011	+
	1012	+ if ( $wp_rewrite->using_permalinks() ) {
	1013	+ global $wp;
	1014	+
	1015	+ // If called too early, bail
	1016	+ if ( ! isset( $wp->request ) ) {
	1017	+ return false;
	1018	+ }
	1019	+
	1020	+ // Determine path for paginated version of current request
	1021	+ if ( preg_match( '#' . preg_quote( $wp_rewrite->pagination_base, '#' ) . '/\d+/?$#i', $wp->request ) ) {
	1022	+ $path = preg_replace( '#' . preg_quote( $wp_rewrite->pagination_base, '#' ) . '/\d+$#i', $wp_rewrite->pagination_base . '/%d', $wp->request );
	1023	+ } else {
	1024	+ $path = $wp->request . '/' . $wp_rewrite->pagination_base . '/%d';
	1025	+ }
	1026	+
	1027	+ // Slashes everywhere we need them
	1028	+ if ( ! str_starts_with( $path, '/' ) ) {
	1029	+ $path = '/' . $path;
	1030	+ }
	1031	+
	1032	+ $path = user_trailingslashit( $path );
	1033	+ } else {
	1034	+ // Clean up raw $_REQUEST input
	1035	+ $path = array_map( 'sanitize_text_field', wp_unslash( $_REQUEST ) ); // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- seems this is used for Google Analytics and browser history tracking.
	1036	+ $path = array_filter( $path );
	1037	+
	1038	+ $path['paged'] = '%d';
	1039	+
	1040	+ $path = add_query_arg( $path, '/' );
	1041	+ }
	1042	+
	1043	+ return empty( $path ) ? false : $path;
	1044	+ }
	1045	+
	1046	+ /**
	1047	+ * Return query string for current request, prefixed with '?'.
	1048	+ *
	1049	+ * @return string
	1050	+ */
	1051	+ private function get_request_parameters() {
	1052	+ $uri = isset( $_SERVER['REQUEST_URI'] ) ? sanitize_text_field( wp_unslash( $_SERVER['REQUEST_URI'] ) ) : '';
	1053	+ $uri = preg_replace( '/^[^?]*(\?.*$)/', '$1', $uri, 1, $count );
	1054	+ if ( $count !== 1 ) {
	1055	+ return '';
	1056	+ }
	1057	+ return $uri;
	1058	+ }
	1059	+
	1060	+ /**
	1061	+ * Provide IS with a list of the scripts and stylesheets already present on the page.
	1062	+ * Since posts may contain require additional assets that haven't been loaded, this data will be used to track the additional assets.
	1063	+ *
	1064	+ * @global $wp_scripts, $wp_styles
	1065	+ * @action wp_footer
	1066	+ */
	1067	+ public function action_wp_footer() {
	1068	+ global $wp_scripts, $wp_styles;
	1069	+
	1070	+ $scripts = is_a( $wp_scripts, 'WP_Scripts' ) ? $wp_scripts->done : array();
	1071	+ /**
	1072	+ * Filter the list of scripts already present on the page.
	1073	+ *
	1074	+ * @module infinite-scroll
	1075	+ *
	1076	+ * @since 2.1.2
	1077	+ *
	1078	+ * @param array $scripts Array of scripts present on the page.
	1079	+ */
	1080	+ $scripts = apply_filters( 'infinite_scroll_existing_scripts', $scripts );
	1081	+
	1082	+ $styles = is_a( $wp_styles, 'WP_Styles' ) ? $wp_styles->done : array();
	1083	+ /**
	1084	+ * Filter the list of styles already present on the page.
	1085	+ *
	1086	+ * @module infinite-scroll
	1087	+ *
	1088	+ * @since 2.1.2
	1089	+ *
	1090	+ * @param array $styles Array of styles present on the page.
	1091	+ */
	1092	+ $styles = apply_filters( 'infinite_scroll_existing_stylesheets', $styles );
	1093	+
	1094	+ ?>
	1095	+ <script type="text/javascript">
	1096	+ (function() {
	1097	+ var extend = function(out) {
	1098	+ out = out || {};
	1099	+
	1100	+ for (var i = 1; i < arguments.length; i++) {
	1101	+ if (!arguments[i])
	1102	+ continue;
	1103	+
	1104	+ for (var key in arguments[i]) {
	1105	+ if (arguments[i].hasOwnProperty(key))
	1106	+ out[key] = arguments[i][key];
	1107	+ }
	1108	+ }
	1109	+
	1110	+ return out;
	1111	+ };
	1112	+ extend( window.infiniteScroll.settings.scripts, <?php echo wp_json_encode( $scripts, JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ); ?> );
	1113	+ extend( window.infiniteScroll.settings.styles, <?php echo wp_json_encode( $styles, JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ); ?> );
	1114	+ })();
	1115	+ </script>
	1116	+ <?php
	1117	+ $aria_live = 'assertive';
	1118	+ if ( 'scroll' === self::get_settings()->type ) {
	1119	+ $aria_live = 'polite';
	1120	+ }
	1121	+ ?>
	1122	+ <span id="infinite-aria" aria-live="<?php echo esc_attr( $aria_live ); ?>"></span>
	1123	+ <?php
	1124	+ }
	1125	+
	1126	+ /**
	1127	+ * Identify additional scripts required by the latest set of IS posts and provide the necessary data to the IS response handler.
	1128	+ *
	1129	+ * @param array $results - the results.
	1130	+ * @param array $query_args - Array of Query arguments.
	1131	+ * @param array $wp_query - the WP query.
	1132	+ * @global $wp_scripts
	1133	+ * @uses sanitize_text_field, add_query_arg
	1134	+ * @filter infinite_scroll_results
	1135	+ * @return array
	1136	+ */
	1137	+ public function filter_infinite_scroll_results( $results, $query_args, $wp_query ) {
	1138	+ // Don't bother unless there are posts to display
	1139	+ if ( 'success' !== $results['type'] ) {
	1140	+ return $results;
	1141	+ }
	1142	+
	1143	+ // Parse and sanitize the script handles already output
	1144	+ $initial_scripts = isset( $_REQUEST['scripts'] ) && is_array( $_REQUEST['scripts'] ) ? array_map( 'sanitize_text_field', wp_unslash( $_REQUEST['scripts'] ) ) : false; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no site changes made.
	1145	+
	1146	+ if ( is_array( $initial_scripts ) ) {
	1147	+ global $wp_scripts;
	1148	+
	1149	+ // Identify new scripts needed by the latest set of IS posts
	1150	+ $new_scripts = array_filter(
	1151	+ $wp_scripts->done,
	1152	+ function ( $script_name ) use ( $initial_scripts ) {
	1153	+ // Jetpack block scripts should always be sent, even if they've been
	1154	+ // sent before. These scripts only run once on when loaded, they don't
	1155	+ // watch for new blocks being added.
	1156	+ if ( str_starts_with( $script_name, 'jetpack-block-' ) ) {
	1157	+ return true;
	1158	+ }
	1159	+
	1160	+ return ! in_array( $script_name, $initial_scripts, true );
	1161	+ }
	1162	+ );
	1163	+
	1164	+ // If new scripts are needed, extract relevant data from $wp_scripts
	1165	+ if ( ! empty( $new_scripts ) ) {
	1166	+ $results['scripts'] = array();
	1167	+
	1168	+ foreach ( $new_scripts as $handle ) {
	1169	+ // Abort if somehow the handle doesn't correspond to a registered script
	1170	+ // or if the script doesn't have `src` set.
	1171	+ $script_not_registered = ! isset( $wp_scripts->registered[ $handle ] );
	1172	+ $empty_src = empty( $wp_scripts->registered[ $handle ]->src );
	1173	+ if ( $script_not_registered || $empty_src ) {
	1174	+ continue;
	1175	+ }
	1176	+
	1177	+ $before_handle = $wp_scripts->get_inline_script_data( $handle, 'before' );
	1178	+ $after_handle = $wp_scripts->get_inline_script_data( $handle, 'after' );
	1179	+
	1180	+ // Provide basic script data
	1181	+ $script_data = array(
	1182	+ 'handle' => $handle,
	1183	+ 'footer' => ( is_array( $wp_scripts->in_footer ) && in_array( $handle, $wp_scripts->in_footer, true ) ),
	1184	+ 'extra_data' => $wp_scripts->print_extra_script( $handle, false ),
	1185	+ 'before_handle' => $before_handle,
	1186	+ 'after_handle' => $after_handle,
	1187	+ );
	1188	+
	1189	+ // Base source
	1190	+ $src = $wp_scripts->registered[ $handle ]->src;
	1191	+
	1192	+ // Take base_url into account
	1193	+ if ( strpos( $src, 'http' ) !== 0 ) {
	1194	+ $src = $wp_scripts->base_url . $src;
	1195	+ }
	1196	+
	1197	+ // Version and additional arguments
	1198	+ if ( null === $wp_scripts->registered[ $handle ]->ver ) {
	1199	+ $ver = '';
	1200	+ } else {
	1201	+ $ver = $wp_scripts->registered[ $handle ]->ver ? $wp_scripts->registered[ $handle ]->ver : $wp_scripts->default_version;
	1202	+ }
	1203	+
	1204	+ if ( isset( $wp_scripts->args[ $handle ] ) ) {
	1205	+ $ver = $ver ? $ver . '&amp;' . $wp_scripts->args[ $handle ] : $wp_scripts->args[ $handle ];
	1206	+ }
	1207	+
	1208	+ // Full script source with version info
	1209	+ $script_data['src'] = add_query_arg( 'ver', $ver, $src );
	1210	+
	1211	+ // Add script to data that will be returned to IS JS
	1212	+ array_push( $results['scripts'], $script_data );
	1213	+ }
	1214	+ }
	1215	+ }
	1216	+
	1217	+ // Expose additional script data to filters, but only include in final `$results` array if needed.
	1218	+ if ( ! isset( $results['scripts'] ) ) {
	1219	+ $results['scripts'] = array();
	1220	+ }
	1221	+
	1222	+ /**
	1223	+ * Filter the additional scripts required by the latest set of IS posts.
	1224	+ *
	1225	+ * @module infinite-scroll
	1226	+ *
	1227	+ * @since 2.1.2
	1228	+ *
	1229	+ * @param array $results['scripts'] Additional scripts required by the latest set of IS posts.
	1230	+ * @param array|bool $initial_scripts Set of scripts loaded on each page.
	1231	+ * @param array $results Array of Infinite Scroll results.
	1232	+ * @param array $query_args Array of Query arguments.
	1233	+ * @param WP_Query $wp_query WP Query.
	1234	+ */
	1235	+ $results['scripts'] = apply_filters(
	1236	+ 'infinite_scroll_additional_scripts',
	1237	+ $results['scripts'],
	1238	+ $initial_scripts,
	1239	+ $results,
	1240	+ $query_args,
	1241	+ $wp_query
	1242	+ );
	1243	+
	1244	+ if ( empty( $results['scripts'] ) ) {
	1245	+ unset( $results['scripts'] );
	1246	+ }
	1247	+
	1248	+ // Parse and sanitize the style handles already output
	1249	+ $initial_styles = isset( $_REQUEST['styles'] ) && is_array( $_REQUEST['styles'] ) ? array_map( 'sanitize_text_field', wp_unslash( $_REQUEST['styles'] ) ) : false; // phpcs:ignore WordPress.Security.NonceVerification.Recommended
	1250	+
	1251	+ if ( is_array( $initial_styles ) ) {
	1252	+ global $wp_styles;
	1253	+
	1254	+ // Identify new styles needed by the latest set of IS posts
	1255	+ $new_styles = array_diff( $wp_styles->done, $initial_styles );
	1256	+
	1257	+ // If new styles are needed, extract relevant data from $wp_styles
	1258	+ if ( ! empty( $new_styles ) ) {
	1259	+ $results['styles'] = array();
	1260	+
	1261	+ foreach ( $new_styles as $handle ) {
	1262	+ // Abort if somehow the handle doesn't correspond to a registered stylesheet
	1263	+ if ( ! isset( $wp_styles->registered[ $handle ] ) ) {
	1264	+ continue;
	1265	+ }
	1266	+
	1267	+ // Provide basic style data
	1268	+ $style_data = array(
	1269	+ 'handle' => $handle,
	1270	+ 'media' => 'all',
	1271	+ );
	1272	+
	1273	+ // Base source
	1274	+ $src = $wp_styles->registered[ $handle ]->src;
	1275	+
	1276	+ // Take base_url into account
	1277	+ if ( strpos( $src, 'http' ) !== 0 ) {
	1278	+ $src = $wp_styles->base_url . $src;
	1279	+ }
	1280	+
	1281	+ // Version and additional arguments
	1282	+ if ( null === $wp_styles->registered[ $handle ]->ver ) {
	1283	+ $ver = '';
	1284	+ } else {
	1285	+ $ver = $wp_styles->registered[ $handle ]->ver ? $wp_styles->registered[ $handle ]->ver : $wp_styles->default_version;
	1286	+ }
	1287	+
	1288	+ if ( isset( $wp_styles->args[ $handle ] ) ) {
	1289	+ $ver = $ver ? $ver . '&amp;' . $wp_styles->args[ $handle ] : $wp_styles->args[ $handle ];
	1290	+ }
	1291	+
	1292	+ // Full stylesheet source with version info
	1293	+ $style_data['src'] = add_query_arg( 'ver', $ver, $src );
	1294	+
	1295	+ // Parse stylesheet's conditional comments if present, converting to logic executable in JS
	1296	+ if ( isset( $wp_styles->registered[ $handle ]->extra['conditional'] ) && $wp_styles->registered[ $handle ]->extra['conditional'] ) {
	1297	+ // First, convert conditional comment operators to standard logical operators. %ver is replaced in JS with the IE version
	1298	+ $style_data['conditional'] = str_replace(
	1299	+ array(
	1300	+ 'lte',
	1301	+ 'lt',
	1302	+ 'gte',
	1303	+ 'gt',
	1304	+ ),
	1305	+ array(
	1306	+ '%ver <=',
	1307	+ '%ver <',
	1308	+ '%ver >=',
	1309	+ '%ver >',
	1310	+ ),
	1311	+ $wp_styles->registered[ $handle ]->extra['conditional']
	1312	+ );
	1313	+
	1314	+ // 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().
	1315	+ $style_data['conditional'] = preg_replace( '#!\s*IE(\s*\d+){0}#i', '1==2', $style_data['conditional'] );
	1316	+
	1317	+ // Lastly, remove the IE strings
	1318	+ $style_data['conditional'] = str_replace( 'IE', '', $style_data['conditional'] );
	1319	+ }
	1320	+
	1321	+ // Parse requested media context for stylesheet
	1322	+ if ( isset( $wp_styles->registered[ $handle ]->args ) ) {
	1323	+ $style_data['media'] = esc_attr( $wp_styles->registered[ $handle ]->args );
	1324	+ }
	1325	+
	1326	+ // Add stylesheet to data that will be returned to IS JS
	1327	+ array_push( $results['styles'], $style_data );
	1328	+ }
	1329	+ }
	1330	+ }
	1331	+
	1332	+ // Expose additional stylesheet data to filters, but only include in final `$results` array if needed.
	1333	+ if ( ! isset( $results['styles'] ) ) {
	1334	+ $results['styles'] = array();
	1335	+ }
	1336	+
	1337	+ /**
	1338	+ * Filter the additional styles required by the latest set of IS posts.
	1339	+ *
	1340	+ * @module infinite-scroll
	1341	+ *
	1342	+ * @since 2.1.2
	1343	+ *
	1344	+ * @param array $results['styles'] Additional styles required by the latest set of IS posts.
	1345	+ * @param array|bool $initial_styles Set of styles loaded on each page.
	1346	+ * @param array $results Array of Infinite Scroll results.
	1347	+ * @param array $query_args Array of Query arguments.
	1348	+ * @param WP_Query $wp_query WP Query.
	1349	+ */
	1350	+ $results['styles'] = apply_filters(
	1351	+ 'infinite_scroll_additional_stylesheets',
	1352	+ $results['styles'],
	1353	+ $initial_styles,
	1354	+ $results,
	1355	+ $query_args,
	1356	+ $wp_query
	1357	+ );
	1358	+
	1359	+ if ( empty( $results['styles'] ) ) {
	1360	+ unset( $results['styles'] );
	1361	+ }
	1362	+
	1363	+ // Lastly, return the IS results array
	1364	+ return $results;
	1365	+ }
	1366	+
	1367	+ /**
	1368	+ * Runs the query and returns the results via JSON.
	1369	+ * Triggered by an AJAX request.
	1370	+ *
	1371	+ * @global $wp_query
	1372	+ * @global $wp_the_query
	1373	+ * @uses current_theme_supports, get_option, self::wp_query, 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
	1374	+ */
	1375	+ public function query() {
	1376	+ if ( ! isset( $_REQUEST['page'] ) || ! current_theme_supports( 'infinite-scroll' ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes to the site.
	1377	+ die( 0 );
	1378	+ }
	1379	+
	1380	+ // @todo see if we should validate this nonce since we use it to form a query.
	1381	+ $page = (int) $_REQUEST['page']; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- we're casting this to an int and not making changes to the site.
	1382	+
	1383	+ // Sanitize and set $previousday. Expected format: dd.mm.yy
	1384	+ if ( isset( $_REQUEST['currentday'] ) && is_string( $_REQUEST['currentday'] ) && preg_match( '/^\d{2}\.\d{2}\.\d{2}$/', $_REQUEST['currentday'] ) ) { // phpcs:ignore WordPress.Security.ValidatedSanitizedInput, WordPress.Security.NonceVerification.Recommended -- manually validating, no changes to site
	1385	+ global $previousday;
	1386	+ $previousday = $_REQUEST['currentday']; // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput
	1387	+ }
	1388	+
	1389	+ $post_status = array( 'publish' );
	1390	+ if ( current_user_can( 'read_private_posts' ) ) {
	1391	+ array_push( $post_status, 'private' );
	1392	+ }
	1393	+
	1394	+ $order = isset( $_REQUEST['order'] ) && in_array( $_REQUEST['order'], array( 'ASC', 'DESC' ), true ) ? sanitize_text_field( wp_unslash( $_REQUEST['order'] ) ) : 'DESC'; // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no changes made to the site.
	1395	+
	1396	+ $query_args = array_merge(
	1397	+ self::wp_query()->query_vars,
	1398	+ array(
	1399	+ 'paged' => $page,
	1400	+ 'post_status' => $post_status,
	1401	+ 'posts_per_page' => self::posts_per_page(),
	1402	+ 'order' => $order,
	1403	+ )
	1404	+ );
	1405	+
	1406	+ // 4.0 ?s= compatibility, see https://core.trac.wordpress.org/ticket/11330#comment:50
	1407	+ if ( empty( $query_args['s'] ) && ! isset( self::wp_query()->query['s'] ) ) {
	1408	+ unset( $query_args['s'] );
	1409	+ }
	1410	+
	1411	+ // By default, don't query for a specific page of a paged post object.
	1412	+ // This argument can come from merging self::wp_query() into $query_args above.
	1413	+ // Since IS is only used on archives, we should always display the first page of any paged content.
	1414	+ unset( $query_args['page'] );
	1415	+
	1416	+ /**
	1417	+ * Filter the array of main query arguments.
	1418	+ *
	1419	+ * @module infinite-scroll
	1420	+ *
	1421	+ * @since 2.0.1
	1422	+ *
	1423	+ * @param array $query_args Array of Query arguments.
	1424	+ */
	1425	+ $query_args = apply_filters( 'infinite_scroll_query_args', $query_args );
	1426	+
	1427	+ add_filter( 'posts_where', array( $this, 'query_time_filter' ), 10, 2 );
	1428	+
	1429	+ $infinite_scroll_query = new WP_Query();
	1430	+ $GLOBALS['wp_the_query'] = $infinite_scroll_query;
	1431	+ $GLOBALS['wp_query'] = $infinite_scroll_query;
	1432	+
	1433	+ $infinite_scroll_query->query( $query_args );
	1434	+
	1435	+ remove_filter( 'posts_where', array( $this, 'query_time_filter' ), 10 );
	1436	+
	1437	+ $results = array();
	1438	+
	1439	+ if ( have_posts() ) {
	1440	+ // Fire wp_head to ensure that all necessary scripts are enqueued. Output isn't used, but scripts are extracted in self::action_wp_footer.
	1441	+ ob_start();
	1442	+ wp_head();
	1443	+ while ( ob_get_length() ) {
	1444	+ ob_end_clean();
	1445	+ }
	1446	+
	1447	+ $results['type'] = 'success';
	1448	+
	1449	+ /**
	1450	+ * Fires when rendering Infinite Scroll posts.
	1451	+ *
	1452	+ * @module infinite-scroll
	1453	+ *
	1454	+ * @since 2.0.0
	1455	+ */
	1456	+ do_action( 'infinite_scroll_render' );
	1457	+ $results['html'] = ob_get_clean();
	1458	+ if ( empty( $results['html'] ) ) {
	1459	+ /**
	1460	+ * Gather renderer callbacks. These will be called in order and allow multiple callbacks to be queued. Once content is found, no futher callbacks will run.
	1461	+ *
	1462	+ * @module infinite-scroll
	1463	+ *
	1464	+ * @since 6.0.0
	1465	+ */
	1466	+ $callbacks = apply_filters(
	1467	+ 'infinite_scroll_render_callbacks',
	1468	+ array( self::get_settings()->render ) // This is the setting callback e.g. from add theme support.
	1469	+ );
	1470	+
	1471	+ // Append fallback callback. That rhymes.
	1472	+ $callbacks[] = array( $this, 'render' );
	1473	+
	1474	+ foreach ( $callbacks as $callback ) {
	1475	+ if ( false !== $callback && is_callable( $callback ) ) {
	1476	+ rewind_posts();
	1477	+ ob_start();
	1478	+
	1479	+ add_action( 'infinite_scroll_render', $callback );
	1480	+
	1481	+ /**
	1482	+ * This action is already documented above.
	1483	+ * See https://github.com/Automattic/jetpack/pull/16317/
	1484	+ * for more details as to why it was introduced.
	1485	+ */
	1486	+ do_action( 'infinite_scroll_render' );
	1487	+
	1488	+ // Fire wp_head to ensure that all necessary scripts are enqueued. Output isn't used, but scripts are extracted in self::action_wp_footer.
	1489	+ wp_head();
	1490	+
	1491	+ $results['html'] = ob_get_clean();
	1492	+ remove_action( 'infinite_scroll_render', $callback );
	1493	+ }
	1494	+ if ( ! empty( $results['html'] ) ) {
	1495	+ break;
	1496	+ }
	1497	+ }
	1498	+ }
	1499	+
	1500	+ // If primary and fallback rendering methods fail, prevent further IS rendering attempts. Otherwise, wrap the output if requested.
	1501	+ if ( empty( $results['html'] ) ) {
	1502	+ unset( $results['html'] );
	1503	+ /**
	1504	+ * Fires when Infinite Scoll doesn't render any posts.
	1505	+ *
	1506	+ * @module infinite-scroll
	1507	+ *
	1508	+ * @since 2.0.0
	1509	+ */
	1510	+ do_action( 'infinite_scroll_empty' );
	1511	+ $results['type'] = 'empty';
	1512	+ } elseif ( $this->has_wrapper() ) {
	1513	+ $wrapper_classes = is_string( self::get_settings()->wrapper ) ? self::get_settings()->wrapper : 'infinite-wrap';
	1514	+ $wrapper_classes .= ' infinite-view-' . $page;
	1515	+ $wrapper_classes = trim( $wrapper_classes );
	1516	+ $aria_label = sprintf(
	1517	+ /* translators: %1$s is the page count */
	1518	+ __( 'Page: %1$d.', 'jetpack' ),
	1519	+ $page
	1520	+ );
	1521	+
	1522	+ $results['html'] = '<div class="' . esc_attr( $wrapper_classes ) . '" id="infinite-view-' . $page . '" data-page-num="' . $page . '" role="region" aria-label="' . esc_attr( $aria_label ) . '">' . $results['html'] . '</div>';
	1523	+ }
	1524	+
	1525	+ // Fire wp_footer to ensure that all necessary scripts are enqueued. Output isn't used, but scripts are extracted in self::action_wp_footer.
	1526	+ ob_start();
	1527	+ wp_footer();
	1528	+ while ( ob_get_length() ) {
	1529	+ ob_end_clean();
	1530	+ }
	1531	+
	1532	+ if ( 'success' === $results['type'] ) {
	1533	+ global $currentday;
	1534	+ $results['lastbatch'] = self::is_last_batch();
	1535	+ $results['currentday'] = $currentday;
	1536	+ }
	1537	+
	1538	+ // Loop through posts to capture sharing data for new posts loaded via Infinite Scroll
	1539	+ if ( 'success' === $results['type'] && function_exists( 'sharing_register_post_for_share_counts' ) ) {
	1540	+ global $jetpack_sharing_counts;
	1541	+
	1542	+ while ( have_posts() ) {
	1543	+ the_post();
	1544	+
	1545	+ sharing_register_post_for_share_counts( get_the_ID() );
	1546	+ }
	1547	+
	1548	+ // If sharing counts are not initialized for any reason, we initialize them here.
	1549	+ if ( ! is_array( $jetpack_sharing_counts ) ) {
	1550	+ $jetpack_sharing_counts = array();
	1551	+ } else {
	1552	+ // Filter out non-string and non-integer values to avoid warnings with array_flip.
	1553	+ $flippable_jetpack_sharing_counts = array_filter(
	1554	+ $jetpack_sharing_counts,
	1555	+ function ( $value ) {
	1556	+ return is_string( $value ) || is_int( $value );
	1557	+ }
	1558	+ );
	1559	+ }
	1560	+
	1561	+ $results['postflair'] = array_flip( $flippable_jetpack_sharing_counts ?? array() );
	1562	+ }
	1563	+ } else {
	1564	+ /** This action is already documented in modules/infinite-scroll/infinity.php */
	1565	+ do_action( 'infinite_scroll_empty' );
	1566	+ $results['type'] = 'empty';
	1567	+ }
	1568	+
	1569	+ wp_send_json(
	1570	+ /**
	1571	+ * Filter the Infinite Scroll results.
	1572	+ *
	1573	+ * @module infinite-scroll
	1574	+ *
	1575	+ * @since 2.0.0
	1576	+ *
	1577	+ * @param array $results Array of Infinite Scroll results.
	1578	+ * @param array $query_args Array of main query arguments.
	1579	+ * @param WP_Query $wp_query WP Query.
	1580	+ */
	1581	+ apply_filters( 'infinite_scroll_results', $results, $query_args, self::wp_query() ),
	1582	+ null, // @phan-suppress-current-line PhanTypeMismatchArgumentProbablyReal -- It takes null, but its phpdoc only says int.
	1583	+ JSON_UNESCAPED_SLASHES
	1584	+ );
	1585	+ }
	1586	+
	1587	+ /**
	1588	+ * Update the $allowed_vars array with the standard WP public and private
	1589	+ * query vars, as well as taxonomy vars
	1590	+ *
	1591	+ * @global $wp
	1592	+ * @param array $allowed_vars - the allowed variables array.
	1593	+ * @filter infinite_scroll_allowed_vars
	1594	+ * @return array
	1595	+ */
	1596	+ public function allowed_query_vars( $allowed_vars ) {
	1597	+ global $wp;
	1598	+
	1599	+ $allowed_vars += $wp->public_query_vars;
	1600	+ $allowed_vars += $wp->private_query_vars;
	1601	+ $allowed_vars += $this->get_taxonomy_vars();
	1602	+
	1603	+ foreach ( array_keys( $allowed_vars, 'paged', true ) as $key ) {
	1604	+ unset( $allowed_vars[ $key ] );
	1605	+ }
	1606	+
	1607	+ return array_unique( $allowed_vars );
	1608	+ }
	1609	+
	1610	+ /**
	1611	+ * Returns an array of stock and custom taxonomy query vars
	1612	+ *
	1613	+ * @global $wp_taxonomies
	1614	+ * @return array
	1615	+ */
	1616	+ public function get_taxonomy_vars() {
	1617	+ global $wp_taxonomies;
	1618	+
	1619	+ $taxonomy_vars = array();
	1620	+ foreach ( $wp_taxonomies as $t ) {
	1621	+ if ( $t->query_var ) {
	1622	+ $taxonomy_vars[] = $t->query_var;
	1623	+ }
	1624	+ }
	1625	+
	1626	+ // still needed?
	1627	+ $taxonomy_vars[] = 'tag_id';
	1628	+
	1629	+ return $taxonomy_vars;
	1630	+ }
	1631	+
	1632	+ /**
	1633	+ * Update the $query_args array with the parameters provided via AJAX/GET.
	1634	+ *
	1635	+ * @param array $query_args - the query args.
	1636	+ * @filter infinite_scroll_query_args
	1637	+ * @return array
	1638	+ */
	1639	+ public function inject_query_args( $query_args ) {
	1640	+ /**
	1641	+ * Filter the array of allowed Infinite Scroll query arguments.
	1642	+ *
	1643	+ * @module infinite-scroll
	1644	+ *
	1645	+ * @since 2.6.0
	1646	+ *
	1647	+ * @param array $args Array of allowed Infinite Scroll query arguments.
	1648	+ * @param array $query_args Array of query arguments.
	1649	+ */
	1650	+ $allowed_vars = apply_filters( 'infinite_scroll_allowed_vars', array(), $query_args );
	1651	+
	1652	+ $query_args = array_merge(
	1653	+ $query_args,
	1654	+ array(
	1655	+ 'suppress_filters' => false,
	1656	+ )
	1657	+ );
	1658	+
	1659	+ if ( isset( $_REQUEST['query_args'] ) && is_array( $_REQUEST['query_args'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended -- no site changes.
	1660	+ foreach ( wp_unslash( $_REQUEST['query_args'] ) as $var => $value ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- no site changes, sanitized below.
	1661	+ if ( ! in_array( $var, $allowed_vars, true ) || empty( $value ) ) {
	1662	+ continue;
	1663	+ }
	1664	+
	1665	+ if ( 'post_type' === $var && ! self::is_queryable_post_type( $value ) ) {
	1666	+ continue;
	1667	+ }
	1668	+
	1669	+ $query_args[ $var ] = filter_var( $value );
	1670	+ }
	1671	+ }
	1672	+
	1673	+ return $query_args;
	1674	+ }
	1675	+
	1676	+ /**
	1677	+ * Whether a post type supplied with the request may be queried on the front end.
	1678	+ *
	1679	+ * Core applies this test to the main query in WP::parse_request(), but the
	1680	+ * Infinite Scroll query is a secondary one and never passes through it.
	1681	+ *
	1682	+ * @param mixed $post_type Post type name, or array of names, from the request.
	1683	+ * @return bool
	1684	+ */
	1685	+ private static function is_queryable_post_type( $post_type ) {
	1686	+ // WP_Query expands 'any' to the types that opted into search results.
	1687	+ if ( 'any' === $post_type ) {
	1688	+ return true;
	1689	+ }
	1690	+
	1691	+ foreach ( (array) $post_type as $type ) {
	1692	+ if ( ! is_string( $type ) || ! is_post_type_viewable( $type ) ) {
	1693	+ return false;
	1694	+ }
	1695	+ }
	1696	+
	1697	+ return true;
	1698	+ }
	1699	+
	1700	+ /**
	1701	+ * Rendering fallback used when themes don't specify their own handler.
	1702	+ *
	1703	+ * @uses have_posts, the_post, get_template_part, get_post_format
	1704	+ * @action infinite_scroll_render
	1705	+ */
	1706	+ public function render() {
	1707	+ while ( have_posts() ) {
	1708	+ the_post();
	1709	+
	1710	+ get_template_part( 'content', get_post_format() );
	1711	+ }
	1712	+ }
	1713	+
	1714	+ /**
	1715	+ * Allow plugins to filter what archives Infinite Scroll supports
	1716	+ *
	1717	+ * @uses current_theme_supports, is_home, is_archive, apply_filters, self::get_settings
	1718	+ * @return bool
	1719	+ */
	1720	+ public static function archive_supports_infinity() {
	1721	+ $supported = current_theme_supports( 'infinite-scroll' ) && ( is_home() || is_archive() || is_search() );
	1722	+
	1723	+ // Disable when previewing a non-active theme in the customizer
	1724	+ if ( is_customize_preview() && ! $GLOBALS['wp_customize']->is_theme_active() ) {
	1725	+ return false;
	1726	+ }
	1727	+
	1728	+ /**
	1729	+ * Allow plugins to filter what archives Infinite Scroll supports.
	1730	+ *
	1731	+ * @module infinite-scroll
	1732	+ *
	1733	+ * @since 2.0.0
	1734	+ *
	1735	+ * @param bool $supported Does the Archive page support Infinite Scroll.
	1736	+ * @param object self::get_settings() IS settings provided by theme.
	1737	+ */
	1738	+ return (bool) apply_filters( 'infinite_scroll_archive_supported', $supported, self::get_settings() );
	1739	+ }
	1740	+
	1741	+ /**
	1742	+ * The Infinite Blog Footer
	1743	+ *
	1744	+ * @uses self::get_settings, self::archive_supports_infinity, self::default_footer
	1745	+ * @return string or null
	1746	+ */
	1747	+ public function footer() {
	1748	+ if ( class_exists( 'Jetpack_AMP_Support' ) && Jetpack_AMP_Support::is_amp_request() ) {
	1749	+ return;
	1750	+ }
	1751	+
	1752	+ $settings = self::get_settings();
	1753	+
	1754	+ // Bail if theme requested footer not show
	1755	+ if ( false === $settings->footer ) {
	1756	+ return;
	1757	+ }
	1758	+
	1759	+ // We only need the new footer for the 'scroll' type
	1760	+ if ( 'scroll' !== $settings->type || ! self::archive_supports_infinity() ) {
	1761	+ return;
	1762	+ }
	1763	+
	1764	+ if ( self::is_last_batch() ) {
	1765	+ return;
	1766	+ }
	1767	+
	1768	+ // Display a footer, either user-specified or a default
	1769	+ if ( false !== $settings->footer_callback && is_callable( $settings->footer_callback ) ) {
	1770	+ call_user_func( $settings->footer_callback, $settings );
	1771	+ } else {
	1772	+ self::default_footer();
	1773	+ }
	1774	+ }
	1775	+
	1776	+ /**
	1777	+ * Render default IS footer
	1778	+ *
	1779	+ * @uses __, wp_get_theme, apply_filters, home_url, esc_attr, get_bloginfo, bloginfo
	1780	+ */
	1781	+ private function default_footer() {
	1782	+ if ( '' !== get_privacy_policy_url() ) {
	1783	+ $credits = get_the_privacy_policy_link() . '<span role="separator" aria-hidden="true"> / </span>';
	1784	+ } else {
	1785	+ $credits = '';
	1786	+ }
	1787	+ $credits .= sprintf(
	1788	+ '<a href="https://wordpress.org/" rel="noopener noreferrer" target="_blank" rel="generator">%1$s</a> ',
	1789	+ __( 'Proudly powered by WordPress', 'jetpack' )
	1790	+ );
	1791	+ $credits .= sprintf(
	1792	+ /* translators: %1$s is the name of a theme */
	1793	+ __( 'Theme: %1$s.', 'jetpack' ),
	1794	+ wp_get_theme()->Name
	1795	+ );
	1796	+ /**
	1797	+ * Filter Infinite Scroll's credit text.
	1798	+ *
	1799	+ * @module infinite-scroll
	1800	+ *
	1801	+ * @since 2.0.0
	1802	+ *
	1803	+ * @param string $credits Infinite Scroll credits.
	1804	+ */
	1805	+ $credits = apply_filters( 'infinite_scroll_credit', $credits );
	1806	+
	1807	+ ?>
	1808	+ <div id="infinite-footer">
	1809	+ <div class="container">
	1810	+ <div class="blog-info">
	1811	+ <a id="infinity-blog-title" href="<?php echo esc_url( home_url( '/' ) ); ?>" rel="home">
	1812	+ <?php bloginfo( 'name' ); ?>
	1813	+ </a>
	1814	+ </div>
	1815	+ <div class="blog-credits">
	1816	+ <?php echo $credits; //phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped ?>
	1817	+ </div>
	1818	+ </div>
	1819	+ </div><!-- #infinite-footer -->
	1820	+ <?php
	1821	+ }
	1822	+
	1823	+ /**
	1824	+ * Ensure that IS doesn't interfere with Grunion by stripping IS query arguments from the Grunion redirect URL.
	1825	+ * When arguments are present, Grunion redirects to the IS AJAX endpoint.
	1826	+ *
	1827	+ * @param string $url - the Grunion redirect URL.
	1828	+ * @uses remove_query_arg
	1829	+ * @filter grunion_contact_form_redirect_url
	1830	+ * @return string
	1831	+ */
	1832	+ public function filter_grunion_redirect_url( $url ) {
	1833	+ // Remove IS query args, if present
	1834	+ if ( str_contains( $url, 'infinity=scrolling' ) ) {
	1835	+ $url = remove_query_arg(
	1836	+ array(
	1837	+ 'infinity',
	1838	+ 'action',
	1839	+ 'page',
	1840	+ 'order',
	1841	+ 'scripts',
	1842	+ 'styles',
	1843	+ ),
	1844	+ $url
	1845	+ );
	1846	+ }
	1847	+
	1848	+ return $url;
	1849	+ }
	1850	+
	1851	+ /**
	1852	+ * When the MediaElement is loaded in dynamically, we need to enforce that
	1853	+ * its settings are added to the page as well.
	1854	+ *
	1855	+ * @param array $scripts_data New scripts exposed to the infinite scroll.
	1856	+ *
	1857	+ * @since 8.4.0
	1858	+ */
	1859	+ public function add_mejs_config( $scripts_data ) {
	1860	+ foreach ( $scripts_data as $key => $data ) {
	1861	+ if ( 'mediaelement-core' === $data['handle'] ) {
	1862	+ $mejs_settings = array(
	1863	+ 'pluginPath' => includes_url( 'js/mediaelement/', 'relative' ),
	1864	+ 'classPrefix' => 'mejs-',
	1865	+ 'stretching' => 'responsive',
	1866	+ );
	1867	+
	1868	+ $scripts_data[ $key ]['extra_data'] = sprintf(
	1869	+ 'window.%s = %s',
	1870	+ '_wpmejsSettings',
	1871	+ wp_json_encode( apply_filters( 'mejs_settings', $mejs_settings ), JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP )
	1872	+ );
	1873	+ }
	1874	+ }
	1875	+ return $scripts_data;
	1876	+ }
	1877	+
	1878	+ /**
	1879	+ * Determines whether the legacy AMP Reader post templates are being used.
	1880	+ *
	1881	+ * @return bool
	1882	+ */
	1883	+ private function is_exempted_amp_page() {
	1884	+ if ( is_singular( 'web-story' ) ) {
	1885	+ // Ensure that <amp-next-page> is not injected after <amp-story> as generated by the Web Stories plugin.
	1886	+ return true;
	1887	+ }
	1888	+ if ( function_exists( 'amp_is_legacy' ) ) {
	1889	+ // Available since AMP v2.0, this will return false if a theme like Twenty Twenty is selected as the Reader theme.
	1890	+ return amp_is_legacy();
	1891	+ }
	1892	+ if ( method_exists( 'AMP_Options_Manager', 'get_option' ) ) {
	1893	+ // In versions prior to v2.0, checking the template mode as being 'reader' is sufficient.
	1894	+ return 'reader' === AMP_Options_Manager::get_option( 'theme_support' );
	1895	+ }
	1896	+ return false;
	1897	+ }
	1898	+
	1899	+ /**
	1900	+ * Load AMP specific hooks.
	1901	+ *
	1902	+ * @return void
	1903	+ */
	1904	+ public function amp_load_hooks() {
	1905	+ if ( $this->is_exempted_amp_page() ) {
	1906	+ return;
	1907	+ }
	1908	+
	1909	+ if ( class_exists( 'Jetpack_AMP_Support' ) && Jetpack_AMP_Support::is_amp_request() ) {
	1910	+ $template = self::get_settings()->render;
	1911	+
	1912	+ add_filter( 'jetpack_infinite_scroll_load_scripts_and_styles', '__return_false' );
	1913	+
	1914	+ add_action( 'template_redirect', array( $this, 'amp_start_output_buffering' ), 0 );
	1915	+ add_action( 'shutdown', array( $this, 'amp_output_buffer' ), 1 );
	1916	+
	1917	+ if ( is_string( $template ) && strpos( $template, '::' ) === false && is_callable( "amp_{$template}_hooks" ) ) {
	1918	+ call_user_func( "amp_{$template}_hooks" );
	1919	+ }
	1920	+
	1921	+ // Warms up the amp next page markup.
	1922	+ // This should be done outside the output buffering callback started in the template_redirect.
	1923	+ $this->amp_get_footer_template();
	1924	+ }
	1925	+ }
	1926	+
	1927	+ /**
	1928	+ * Start the AMP output buffering.
	1929	+ *
	1930	+ * @return void
	1931	+ */
	1932	+ public function amp_start_output_buffering() {
	1933	+ ob_start( array( $this, 'amp_finish_output_buffering' ) );
	1934	+ }
	1935	+
	1936	+ /**
	1937	+ * Flush the AMP output buffer.
	1938	+ *
	1939	+ * @return void
	1940	+ */
	1941	+ public function amp_output_buffer() {
	1942	+ if ( ob_get_contents() ) {
	1943	+ ob_end_flush();
	1944	+ }
	1945	+ }
	1946	+
	1947	+ /**
	1948	+ * Filter the AMP output buffer contents.
	1949	+ *
	1950	+ * @param string $buffer Contents of the output buffer.
	1951	+ *
	1952	+ * @return string|false
	1953	+ */
	1954	+ public function amp_finish_output_buffering( $buffer ) {
	1955	+ // Hide WordPress admin bar on next page load.
	1956	+ $buffer = preg_replace(
	1957	+ '/id="wpadminbar"/',
	1958	+ '$0 next-page-hide',
	1959	+ $buffer
	1960	+ );
	1961	+
	1962	+ /**
	1963	+ * Get the theme footers.
	1964	+ *
	1965	+ * @module infinite-scroll
	1966	+ *
	1967	+ * @since 9.0.0
	1968	+ *
	1969	+ * @param array array() An array to store multiple markup entries to be added to the footer.
	1970	+ * @param string $buffer The contents of the output buffer.
	1971	+ */
	1972	+ $footers = apply_filters( 'jetpack_amp_infinite_footers', array(), $buffer );
	1973	+
	1974	+ /**
	1975	+ * Filter the output buffer.
	1976	+ * Themes can leverage this hook to add custom markup on next page load.
	1977	+ *
	1978	+ * @module infinite-scroll
	1979	+ *
	1980	+ * @since 9.0.0
	1981	+ *
	1982	+ * @param string $buffer The contents of the output buffer.
	1983	+ */
	1984	+ $buffer = apply_filters( 'jetpack_amp_infinite_output', $buffer );
	1985	+
	1986	+ // Add the amp next page markup.
	1987	+ $buffer = preg_replace(
	1988	+ '~</body>~',
	1989	+ $this->amp_get_footer_template( $footers ) . '$0',
	1990	+ $buffer
	1991	+ );
	1992	+
	1993	+ return $buffer;
	1994	+ }
	1995	+
	1996	+ /**
	1997	+ * Get AMP next page markup with the custom footers.
	1998	+ *
	1999	+ * @param string[] $footers The theme footers.
	2000	+ *
	2001	+ * @return string
	2002	+ */
	2003	+ protected function amp_get_footer_template( $footers = array() ) {
	2004	+ static $template = null;
	2005	+
	2006	+ if ( null === $template ) {
	2007	+ $template = $this->amp_footer_template();
	2008	+ }
	2009	+
	2010	+ if ( empty( $footers ) ) {
	2011	+ return $template;
	2012	+ }
	2013	+
	2014	+ return preg_replace(
	2015	+ '/%%footer%%/',
	2016	+ implode( '', $footers ),
	2017	+ $template
	2018	+ );
	2019	+ }
	2020	+
	2021	+ /**
	2022	+ * AMP Next Page markup.
	2023	+ *
	2024	+ * @return string
	2025	+ */
	2026	+ protected function amp_footer_template() {
	2027	+ ob_start();
	2028	+ ?>
	2029	+<amp-next-page max-pages="<?php echo esc_attr( static::amp_get_max_pages() ); ?>">
	2030	+ <script type="application/json">
	2031	+ [
	2032	+ <?php echo wp_json_encode( $this->amp_next_page(), JSON_UNESCAPED_SLASHES | JSON_HEX_TAG | JSON_HEX_AMP ); ?>
	2033	+ ]
	2034	+ </script>
	2035	+ <div separator>
	2036	+ <?php
	2037	+ echo wp_kses_post(
	2038	+ /**
	2039	+ * AMP infinite scroll separator.
	2040	+ *
	2041	+ * @module infinite-scroll
	2042	+ *
	2043	+ * @since 9.0.0
	2044	+ *
	2045	+ * @param string '' The markup for the next page separator.
	2046	+ */
	2047	+ apply_filters( 'jetpack_amp_infinite_separator', '' )
	2048	+ );
	2049	+ ?>
	2050	+ </div>
	2051	+ <div recommendation-box class="recommendation-box">
	2052	+ <template type="amp-mustache">
	2053	+ {{#pages}}
	2054	+ <?php
	2055	+ echo wp_kses_post(
	2056	+ /**
	2057	+ * AMP infinite scroll older posts markup.
	2058	+ *
	2059	+ * @module infinite-scroll
	2060	+ *
	2061	+ * @since 9.0.0
	2062	+ *
	2063	+ * @param string '' The markup for the older posts/next page.
	2064	+ */
	2065	+ apply_filters( 'jetpack_amp_infinite_older_posts', '' )
	2066	+ );
	2067	+ ?>
	2068	+ {{/pages}}
	2069	+ </template>
	2070	+ </div>
	2071	+ <div footer>
	2072	+ %%footer%%
	2073	+ </div>
	2074	+</amp-next-page>
	2075	+ <?php
	2076	+ return ob_get_clean();
	2077	+ }
	2078	+
	2079	+ /**
	2080	+ * Get the AMP next page information.
	2081	+ *
	2082	+ * @return array
	2083	+ */
	2084	+ protected function amp_next_page() {
	2085	+ $title = '';
	2086	+ $url = '';
	2087	+ $image = '';
	2088	+
	2089	+ if ( ! static::amp_is_last_page() ) {
	2090	+ $title = sprintf(
	2091	+ '%s - %s %d - %s',
	2092	+ wp_title( '', false ),
	2093	+ __( 'Page', 'jetpack' ),
	2094	+ max( get_query_var( 'paged', 1 ), 1 ) + 1,
	2095	+ get_bloginfo( 'name' )
	2096	+ );
	2097	+ $url = get_next_posts_page_link();
	2098	+ }
	2099	+
	2100	+ $next_page = array(
	2101	+ 'title' => $title,
	2102	+ 'url' => $url,
	2103	+ 'image' => $image,
	2104	+ );
	2105	+
	2106	+ /**
	2107	+ * The next page settings.
	2108	+ * An array containing:
	2109	+ * - title => The title to be featured on the browser tab.
	2110	+ * - url => The URL of next page.
	2111	+ * - image => The image URL. A required AMP setting, not in use currently. Themes are welcome to leverage.
	2112	+ *
	2113	+ * @module infinite-scroll
	2114	+ *
	2115	+ * @since 9.0.0
	2116	+ *
	2117	+ * @param array $next_page The contents of the output buffer.
	2118	+ */
	2119	+ return apply_filters( 'jetpack_amp_infinite_next_page_data', $next_page );
	2120	+ }
	2121	+
	2122	+ /**
	2123	+ * Get the number of pages left.
	2124	+ *
	2125	+ * @return int
	2126	+ */
	2127	+ protected static function amp_get_max_pages() {
	2128	+ global $wp_query;
	2129	+
	2130	+ return (int) $wp_query->max_num_pages - (int) $wp_query->query_vars['paged'];
	2131	+ }
	2132	+
	2133	+ /**
	2134	+ * Is the last page.
	2135	+ *
	2136	+ * @return bool
	2137	+ */
	2138	+ protected static function amp_is_last_page() {
	2139	+ return 0 === static::amp_get_max_pages();
	2140	+ }
	2141	+}
	2142	+
	2143	+/**
	2144	+ * Initialize The_Neverending_Home_Page
	2145	+ */
	2146	+function the_neverending_home_page_init() {
	2147	+ if ( ! current_theme_supports( 'infinite-scroll' ) ) {
	2148	+ return;
	2149	+ }
	2150	+
	2151	+ new The_Neverending_Home_Page();
	2152	+}
	2153	+add_action( 'init', 'the_neverending_home_page_init', 20 );
	2154	+
	2155	+/**
	2156	+ * Check whether the current theme is infinite-scroll aware.
	2157	+ * If so, include the files which add theme support.
	2158	+ */
	2159	+function the_neverending_home_page_theme_support() {
	2160	+ if (
	2161	+ defined( 'IS_WPCOM' ) && IS_WPCOM &&
	2162	+ defined( 'REST_API_REQUEST' ) && REST_API_REQUEST &&
	2163	+ ! doing_action( 'restapi_theme_after_setup_theme' )
	2164	+ ) {
	2165	+ // Don't source theme compat files until we're in the site's context
	2166	+ return;
	2167	+ }
	2168	+ $theme_name = get_stylesheet();
	2169	+
	2170	+ /**
	2171	+ * Filter the path to the Infinite Scroll compatibility file.
	2172	+ *
	2173	+ * @module infinite-scroll
	2174	+ *
	2175	+ * @since 2.0.0
	2176	+ *
	2177	+ * @param string $str IS compatibility file path.
	2178	+ * @param string $theme_name Theme name.
	2179	+ */
	2180	+ $customization_file = apply_filters( 'infinite_scroll_customization_file', __DIR__ . "/themes/{$theme_name}.php", $theme_name );
	2181	+
	2182	+ if ( is_readable( $customization_file ) ) {
	2183	+ require_once $customization_file;
	2184	+ }
	2185	+}
	2186	+add_action( 'after_setup_theme', 'the_neverending_home_page_theme_support', 5 );
	2187	+
	2188	+/**
	2189	+ * Early accommodation of the Infinite Scroll AJAX request
	2190	+ */
	2191	+if ( The_Neverending_Home_Page::got_infinity() ) {
	2192	+ /**
	2193	+ * If we're sure this is an AJAX request (i.e. the HTTP_X_REQUESTED_WITH header says so),
	2194	+ * indicate it as early as possible for actions like init
	2195	+ */
	2196	+ if ( ! defined( 'DOING_AJAX' ) &&
	2197	+ isset( $_SERVER['HTTP_X_REQUESTED_WITH'] ) &&
	2198	+ strtoupper( sanitize_text_field( wp_unslash( $_SERVER['HTTP_X_REQUESTED_WITH'] ) ) ) === 'XMLHTTPREQUEST'
	2199	+ ) {
	2200	+ define( 'DOING_AJAX', true );
	2201	+ }
	2202	+
	2203	+ // Don't load the admin bar when doing the AJAX response.
	2204	+ show_admin_bar( false );
	2205	+}