Ondersteuning » Code oplossingen gezocht » Problemen met code na automatische update naar 6.1

  • Opgelost olaframak

    (@olaframak)


    Goedenavond, na een automatische update van wordpress naar 6.1 kan ik mijn site niet meer in via de normale manier. Heb al veel geprobeerd maar ik blijf deze foutcodes krijgen:
    Warning: Unterminated comment starting line 2497 in /var/www/vhosts/mondgezondheidscentrumamersfoort.nl/webspace/httpdocs/mondgezondheidscentrumamersfoort.nl/wp-includes/theme.php on line 2497 Parse error: syntax error, unexpected end of file in /var/www/vhosts/mondgezondheidscentrumamersfoort.nl/webspace/httpdocs/mondgezondheidscentrumamersfoort.nl/wp-includes/theme.php on line 2503
    Het zal vast iets simpels zijn in de code. (hopelijk)
    Alvast bedankt voor je hulp!
    Hier de complete code van de theme.php:

    <?php
    /**
     * Theme, template, and stylesheet functions.
     *
     * @package WordPress
     * @subpackage Theme
     */
    
    /**
     * Returns an array of WP_Theme objects based on the arguments.
     *
     * Despite advances over get_themes(), this function is quite expensive, and grows
     * linearly with additional themes. Stick to wp_get_theme() if possible.
     *
     * @since 3.4.0
     *
     * @global array $wp_theme_directories
     *
     * @param array $args {
     *     Optional. The search arguments.
     *
     *     @type mixed $errors  True to return themes with errors, false to return
     *                          themes without errors, null to return all themes.
     *                          Default false.
     *     @type mixed $allowed (Multisite) True to return only allowed themes for a site.
     *                          False to return only disallowed themes for a site.
     *                          'site' to return only site-allowed themes.
     *                          'network' to return only network-allowed themes.
     *                          Null to return all themes. Default null.
     *     @type int   $blog_id (Multisite) The blog ID used to calculate which themes
     *                          are allowed. Default 0, synonymous for the current blog.
     * }
     * @return WP_Theme[] Array of WP_Theme objects.
     */
    function wp_get_themes( $args = array() ) {
    	global $wp_theme_directories;
    
    	$defaults = array(
    		'errors'  => false,
    		'allowed' => null,
    		'blog_id' => 0,
    	);
    	$args     = wp_parse_args( $args, $defaults );
    
    	$theme_directories = search_theme_directories();
    
    	if ( is_array( $wp_theme_directories ) && count( $wp_theme_directories ) > 1 ) {
    		// Make sure the active theme wins out, in case search_theme_directories() picks the wrong
    		// one in the case of a conflict. (Normally, last registered theme root wins.)
    		$current_theme = get_stylesheet();
    		if ( isset( $theme_directories[ $current_theme ] ) ) {
    			$root_of_current_theme = get_raw_theme_root( $current_theme );
    			if ( ! in_array( $root_of_current_theme, $wp_theme_directories, true ) ) {
    				$root_of_current_theme = WP_CONTENT_DIR . $root_of_current_theme;
    			}
    			$theme_directories[ $current_theme ]['theme_root'] = $root_of_current_theme;
    		}
    	}
    
    	if ( empty( $theme_directories ) ) {
    		return array();
    	}
    
    	if ( is_multisite() && null !== $args['allowed'] ) {
    		$allowed = $args['allowed'];
    		if ( 'network' === $allowed ) {
    			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed_on_network() );
    		} elseif ( 'site' === $allowed ) {
    			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed_on_site( $args['blog_id'] ) );
    		} elseif ( $allowed ) {
    			$theme_directories = array_intersect_key( $theme_directories, WP_Theme::get_allowed( $args['blog_id'] ) );
    		} else {
    			$theme_directories = array_diff_key( $theme_directories, WP_Theme::get_allowed( $args['blog_id'] ) );
    		}
    	}
    
    	$themes         = array();
    	static $_themes = array();
    
    	foreach ( $theme_directories as $theme => $theme_root ) {
    		if ( isset( $_themes[ $theme_root['theme_root'] . '/' . $theme ] ) ) {
    			$themes[ $theme ] = $_themes[ $theme_root['theme_root'] . '/' . $theme ];
    		} else {
    			$themes[ $theme ] = new WP_Theme( $theme, $theme_root['theme_root'] );
    
    			$_themes[ $theme_root['theme_root'] . '/' . $theme ] = $themes[ $theme ];
    		}
    	}
    
    	if ( null !== $args['errors'] ) {
    		foreach ( $themes as $theme => $wp_theme ) {
    			if ( $wp_theme->errors() != $args['errors'] ) {
    				unset( $themes[ $theme ] );
    			}
    		}
    	}
    
    	return $themes;
    }
    
    /**
     * Gets a WP_Theme object for a theme.
     *
     * @since 3.4.0
     *
     * @global array $wp_theme_directories
     *
     * @param string $stylesheet Optional. Directory name for the theme. Defaults to active theme.
     * @param string $theme_root Optional. Absolute path of the theme root to look in.
     *                           If not specified, get_raw_theme_root() is used to calculate
     *                           the theme root for the $stylesheet provided (or active theme).
     * @return WP_Theme Theme object. Be sure to check the object's exists() method
     *                  if you need to confirm the theme's existence.
     */
    function wp_get_theme( $stylesheet = '', $theme_root = '' ) {
    	global $wp_theme_directories;
    
    	if ( empty( $stylesheet ) ) {
    		$stylesheet = get_stylesheet();
    	}
    
    	if ( empty( $theme_root ) ) {
    		$theme_root = get_raw_theme_root( $stylesheet );
    		if ( false === $theme_root ) {
    			$theme_root = WP_CONTENT_DIR . '/themes';
    		} elseif ( ! in_array( $theme_root, (array) $wp_theme_directories, true ) ) {
    			$theme_root = WP_CONTENT_DIR . $theme_root;
    		}
    	}
    
    	return new WP_Theme( $stylesheet, $theme_root );
    }
    
    /**
     * Clears the cache held by get_theme_roots() and WP_Theme.
     *
     * @since 3.5.0
     * @param bool $clear_update_cache Whether to clear the theme updates cache.
     */
    function wp_clean_themes_cache( $clear_update_cache = true ) {
    	if ( $clear_update_cache ) {
    		delete_site_transient( 'update_themes' );
    	}
    	search_theme_directories( true );
    	foreach ( wp_get_themes( array( 'errors' => null ) ) as $theme ) {
    		$theme->cache_delete();
    	}
    }
    
    /**
     * Whether a child theme is in use.
     *
     * @since 3.0.0
     *
     * @return bool True if a child theme is in use, false otherwise.
     */
    function is_child_theme() {
    	return ( TEMPLATEPATH !== STYLESHEETPATH );
    }
    
    /**
     * Retrieves name of the current stylesheet.
     *
     * The theme name that is currently set as the front end theme.
     *
     * For all intents and purposes, the template name and the stylesheet name
     * are going to be the same for most cases.
     *
     * @since 1.5.0
     *
     * @return string Stylesheet name.
     */
    function get_stylesheet() {
    	/**
    	 * Filters the name of current stylesheet.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $stylesheet Name of the current stylesheet.
    	 */
    	return apply_filters( 'stylesheet', get_option( 'stylesheet' ) );
    }
    
    /**
     * Retrieves stylesheet directory path for the active theme.
     *
     * @since 1.5.0
     *
     * @return string Path to active theme's stylesheet directory.
     */
    function get_stylesheet_directory() {
    	$stylesheet     = get_stylesheet();
    	$theme_root     = get_theme_root( $stylesheet );
    	$stylesheet_dir = "$theme_root/$stylesheet";
    
    	/**
    	 * Filters the stylesheet directory path for the active theme.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $stylesheet_dir Absolute path to the active theme.
    	 * @param string $stylesheet     Directory name of the active theme.
    	 * @param string $theme_root     Absolute path to themes directory.
    	 */
    	return apply_filters( 'stylesheet_directory', $stylesheet_dir, $stylesheet, $theme_root );
    }
    
    /**
     * Retrieves stylesheet directory URI for the active theme.
     *
     * @since 1.5.0
     *
     * @return string URI to active theme's stylesheet directory.
     */
    function get_stylesheet_directory_uri() {
    	$stylesheet         = str_replace( '%2F', '/', rawurlencode( get_stylesheet() ) );
    	$theme_root_uri     = get_theme_root_uri( $stylesheet );
    	$stylesheet_dir_uri = "$theme_root_uri/$stylesheet";
    
    	/**
    	 * Filters the stylesheet directory URI.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $stylesheet_dir_uri Stylesheet directory URI.
    	 * @param string $stylesheet         Name of the activated theme's directory.
    	 * @param string $theme_root_uri     Themes root URI.
    	 */
    	return apply_filters( 'stylesheet_directory_uri', $stylesheet_dir_uri, $stylesheet, $theme_root_uri );
    }
    
    /**
     * Retrieves stylesheet URI for the active theme.
     *
     * The stylesheet file name is 'style.css' which is appended to the stylesheet directory URI path.
     * See get_stylesheet_directory_uri().
     *
     * @since 1.5.0
     *
     * @return string URI to active theme's stylesheet.
     */
    function get_stylesheet_uri() {
    	$stylesheet_dir_uri = get_stylesheet_directory_uri();
    	$stylesheet_uri     = $stylesheet_dir_uri . '/style.css';
    	/**
    	 * Filters the URI of the active theme stylesheet.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $stylesheet_uri     Stylesheet URI for the active theme/child theme.
    	 * @param string $stylesheet_dir_uri Stylesheet directory URI for the active theme/child theme.
    	 */
    	return apply_filters( 'stylesheet_uri', $stylesheet_uri, $stylesheet_dir_uri );
    }
    
    /**
     * Retrieves the localized stylesheet URI.
     *
     * The stylesheet directory for the localized stylesheet files are located, by
     * default, in the base theme directory. The name of the locale file will be the
     * locale followed by '.css'. If that does not exist, then the text direction
     * stylesheet will be checked for existence, for example 'ltr.css'.
     *
     * The theme may change the location of the stylesheet directory by either using
     * the {@see 'stylesheet_directory_uri'} or {@see 'locale_stylesheet_uri'} filters.
     *
     * If you want to change the location of the stylesheet files for the entire
     * WordPress workflow, then change the former. If you just have the locale in a
     * separate folder, then change the latter.
     *
     * @since 2.1.0
     *
     * @global WP_Locale $wp_locale WordPress date and time locale object.
     *
     * @return string URI to active theme's localized stylesheet.
     */
    function get_locale_stylesheet_uri() {
    	global $wp_locale;
    	$stylesheet_dir_uri = get_stylesheet_directory_uri();
    	$dir                = get_stylesheet_directory();
    	$locale             = get_locale();
    	if ( file_exists( "$dir/$locale.css" ) ) {
    		$stylesheet_uri = "$stylesheet_dir_uri/$locale.css";
    	} elseif ( ! empty( $wp_locale->text_direction ) && file_exists( "$dir/{$wp_locale->text_direction}.css" ) ) {
    		$stylesheet_uri = "$stylesheet_dir_uri/{$wp_locale->text_direction}.css";
    	} else {
    		$stylesheet_uri = '';
    	}
    	/**
    	 * Filters the localized stylesheet URI.
    	 *
    	 * @since 2.1.0
    	 *
    	 * @param string $stylesheet_uri     Localized stylesheet URI.
    	 * @param string $stylesheet_dir_uri Stylesheet directory URI.
    	 */
    	return apply_filters( 'locale_stylesheet_uri', $stylesheet_uri, $stylesheet_dir_uri );
    }
    
    /**
     * Retrieves name of the active theme.
     *
     * @since 1.5.0
     *
     * @return string Template name.
     */
    function get_template() {
    	/**
    	 * Filters the name of the active theme.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $template active theme's directory name.
    	 */
    	return apply_filters( 'template', get_option( 'template' ) );
    }
    
    /**
     * Retrieves template directory path for the active theme.
     *
     * @since 1.5.0
     *
     * @return string Path to active theme's template directory.
     */
    function get_template_directory() {
    	$template     = get_template();
    	$theme_root   = get_theme_root( $template );
    	$template_dir = "$theme_root/$template";
    
    	/**
    	 * Filters the active theme directory path.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $template_dir The path of the active theme directory.
    	 * @param string $template     Directory name of the active theme.
    	 * @param string $theme_root   Absolute path to the themes directory.
    	 */
    	return apply_filters( 'template_directory', $template_dir, $template, $theme_root );
    }
    
    /**
     * Retrieves template directory URI for the active theme.
     *
     * @since 1.5.0
     *
     * @return string URI to active theme's template directory.
     */
    function get_template_directory_uri() {
    	$template         = str_replace( '%2F', '/', rawurlencode( get_template() ) );
    	$theme_root_uri   = get_theme_root_uri( $template );
    	$template_dir_uri = "$theme_root_uri/$template";
    
    	/**
    	 * Filters the active theme directory URI.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $template_dir_uri The URI of the active theme directory.
    	 * @param string $template         Directory name of the active theme.
    	 * @param string $theme_root_uri   The themes root URI.
    	 */
    	return apply_filters( 'template_directory_uri', $template_dir_uri, $template, $theme_root_uri );
    }
    
    /**
     * Retrieves theme roots.
     *
     * @since 2.9.0
     *
     * @global array $wp_theme_directories
     *
     * @return array|string An array of theme roots keyed by template/stylesheet
     *                      or a single theme root if all themes have the same root.
     */
    function get_theme_roots() {
    	global $wp_theme_directories;
    
    	if ( ! is_array( $wp_theme_directories ) || count( $wp_theme_directories ) <= 1 ) {
    		return '/themes';
    	}
    
    	$theme_roots = get_site_transient( 'theme_roots' );
    	if ( false === $theme_roots ) {
    		search_theme_directories( true ); // Regenerate the transient.
    		$theme_roots = get_site_transient( 'theme_roots' );
    	}
    	return $theme_roots;
    }
    
    /**
     * Registers a directory that contains themes.
     *
     * @since 2.9.0
     *
     * @global array $wp_theme_directories
     *
     * @param string $directory Either the full filesystem path to a theme folder
     *                          or a folder within WP_CONTENT_DIR.
     * @return bool True if successfully registered a directory that contains themes,
     *              false if the directory does not exist.
     */
    function register_theme_directory( $directory ) {
    	global $wp_theme_directories;
    
    	if ( ! file_exists( $directory ) ) {
    		// Try prepending as the theme directory could be relative to the content directory.
    		$directory = WP_CONTENT_DIR . '/' . $directory;
    		// If this directory does not exist, return and do not register.
    		if ( ! file_exists( $directory ) ) {
    			return false;
    		}
    	}
    
    	if ( ! is_array( $wp_theme_directories ) ) {
    		$wp_theme_directories = array();
    	}
    
    	$untrailed = untrailingslashit( $directory );
    	if ( ! empty( $untrailed ) && ! in_array( $untrailed, $wp_theme_directories, true ) ) {
    		$wp_theme_directories[] = $untrailed;
    	}
    
    	return true;
    }
    
    /**
     * Searches all registered theme directories for complete and valid themes.
     *
     * @since 2.9.0
     *
     * @global array $wp_theme_directories
     *
     * @param bool $force Optional. Whether to force a new directory scan. Default false.
     * @return array|false Valid themes found on success, false on failure.
     */
    function search_theme_directories( $force = false ) {
    	global $wp_theme_directories;
    	static $found_themes = null;
    
    	if ( empty( $wp_theme_directories ) ) {
    		return false;
    	}
    
    	if ( ! $force && isset( $found_themes ) ) {
    		return $found_themes;
    	}
    
    	$found_themes = array();
    
    	$wp_theme_directories = (array) $wp_theme_directories;
    	$relative_theme_roots = array();
    
    	/*
    	 * Set up maybe-relative, maybe-absolute array of theme directories.
    	 * We always want to return absolute, but we need to cache relative
    	 * to use in get_theme_root().
    	 */
    	foreach ( $wp_theme_directories as $theme_root ) {
    		if ( 0 === strpos( $theme_root, WP_CONTENT_DIR ) ) {
    			$relative_theme_roots[ str_replace( WP_CONTENT_DIR, '', $theme_root ) ] = $theme_root;
    		} else {
    			$relative_theme_roots[ $theme_root ] = $theme_root;
    		}
    	}
    
    	/**
    	 * Filters whether to get the cache of the registered theme directories.
    	 *
    	 * @since 3.4.0
    	 *
    	 * @param bool   $cache_expiration Whether to get the cache of the theme directories. Default false.
    	 * @param string $context          The class or function name calling the filter.
    	 */
    	$cache_expiration = apply_filters( 'wp_cache_themes_persistently', false, 'search_theme_directories' );
    
    	if ( $cache_expiration ) {
    		$cached_roots = get_site_transient( 'theme_roots' );
    		if ( is_array( $cached_roots ) ) {
    			foreach ( $cached_roots as $theme_dir => $theme_root ) {
    				// A cached theme root is no longer around, so skip it.
    				if ( ! isset( $relative_theme_roots[ $theme_root ] ) ) {
    					continue;
    				}
    				$found_themes[ $theme_dir ] = array(
    					'theme_file' => $theme_dir . '/style.css',
    					'theme_root' => $relative_theme_roots[ $theme_root ], // Convert relative to absolute.
    				);
    			}
    			return $found_themes;
    		}
    		if ( ! is_int( $cache_expiration ) ) {
    			$cache_expiration = 30 * MINUTE_IN_SECONDS;
    		}
    	} else {
    		$cache_expiration = 30 * MINUTE_IN_SECONDS;
    	}
    
    	/* Loop the registered theme directories and extract all themes */
    	foreach ( $wp_theme_directories as $theme_root ) {
    
    		// Start with directories in the root of the active theme directory.
    		$dirs = @ scandir( $theme_root );
    		if ( ! $dirs ) {
    			trigger_error( "$theme_root is not readable", E_USER_NOTICE );
    			continue;
    		}
    		foreach ( $dirs as $dir ) {
    			if ( ! is_dir( $theme_root . '/' . $dir ) || '.' === $dir[0] || 'CVS' === $dir ) {
    				continue;
    			}
    			if ( file_exists( $theme_root . '/' . $dir . '/style.css' ) ) {
    				// wp-content/themes/a-single-theme
    				// wp-content/themes is $theme_root, a-single-theme is $dir.
    				$found_themes[ $dir ] = array(
    					'theme_file' => $dir . '/style.css',
    					'theme_root' => $theme_root,
    				);
    			} else {
    				$found_theme = false;
    				// wp-content/themes/a-folder-of-themes/*
    				// wp-content/themes is $theme_root, a-folder-of-themes is $dir, then themes are $sub_dirs.
    				$sub_dirs = @ scandir( $theme_root . '/' . $dir );
    				if ( ! $sub_dirs ) {
    					trigger_error( "$theme_root/$dir is not readable", E_USER_NOTICE );
    					continue;
    				}
    				foreach ( $sub_dirs as $sub_dir ) {
    					if ( ! is_dir( $theme_root . '/' . $dir . '/' . $sub_dir ) || '.' === $dir[0] || 'CVS' === $dir ) {
    						continue;
    					}
    					if ( ! file_exists( $theme_root . '/' . $dir . '/' . $sub_dir . '/style.css' ) ) {
    						continue;
    					}
    					$found_themes[ $dir . '/' . $sub_dir ] = array(
    						'theme_file' => $dir . '/' . $sub_dir . '/style.css',
    						'theme_root' => $theme_root,
    					);
    					$found_theme                           = true;
    				}
    				// Never mind the above, it's just a theme missing a style.css.
    				// Return it; WP_Theme will catch the error.
    				if ( ! $found_theme ) {
    					$found_themes[ $dir ] = array(
    						'theme_file' => $dir . '/style.css',
    						'theme_root' => $theme_root,
    					);
    				}
    			}
    		}
    	}
    
    	asort( $found_themes );
    
    	$theme_roots          = array();
    	$relative_theme_roots = array_flip( $relative_theme_roots );
    
    	foreach ( $found_themes as $theme_dir => $theme_data ) {
    		$theme_roots[ $theme_dir ] = $relative_theme_roots[ $theme_data['theme_root'] ]; // Convert absolute to relative.
    	}
    
    	if ( get_site_transient( 'theme_roots' ) != $theme_roots ) {
    		set_site_transient( 'theme_roots', $theme_roots, $cache_expiration );
    	}
    
    	return $found_themes;
    }
    
    /**
     * Retrieves path to themes directory.
     *
     * Does not have trailing slash.
     *
     * @since 1.5.0
     *
     * @global array $wp_theme_directories
     *
     * @param string $stylesheet_or_template Optional. The stylesheet or template name of the theme.
     *                                       Default is to leverage the main theme root.
     * @return string Themes directory path.
     */
    function get_theme_root( $stylesheet_or_template = '' ) {
    	global $wp_theme_directories;
    
    	$theme_root = '';
    
    	if ( $stylesheet_or_template ) {
    		$theme_root = get_raw_theme_root( $stylesheet_or_template );
    		if ( $theme_root ) {
    			// Always prepend WP_CONTENT_DIR unless the root currently registered as a theme directory.
    			// This gives relative theme roots the benefit of the doubt when things go haywire.
    			if ( ! in_array( $theme_root, (array) $wp_theme_directories, true ) ) {
    				$theme_root = WP_CONTENT_DIR . $theme_root;
    			}
    		}
    	}
    
    	if ( ! $theme_root ) {
    		$theme_root = WP_CONTENT_DIR . '/themes';
    	}
    
    	/**
    	 * Filters the absolute path to the themes directory.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $theme_root Absolute path to themes directory.
    	 */
    	return apply_filters( 'theme_root', $theme_root );
    }
    
    /**
     * Retrieves URI for themes directory.
     *
     * Does not have trailing slash.
     *
     * @since 1.5.0
     *
     * @global array $wp_theme_directories
     *
     * @param string $stylesheet_or_template Optional. The stylesheet or template name of the theme.
     *                                       Default is to leverage the main theme root.
     * @param string $theme_root             Optional. The theme root for which calculations will be based,
     *                                       preventing the need for a get_raw_theme_root() call. Default empty.
     * @return string Themes directory URI.
     */
    function get_theme_root_uri( $stylesheet_or_template = '', $theme_root = '' ) {
    	global $wp_theme_directories;
    
    	if ( $stylesheet_or_template && ! $theme_root ) {
    		$theme_root = get_raw_theme_root( $stylesheet_or_template );
    	}
    
    	if ( $stylesheet_or_template && $theme_root ) {
    		if ( in_array( $theme_root, (array) $wp_theme_directories, true ) ) {
    			// Absolute path. Make an educated guess. YMMV -- but note the filter below.
    			if ( 0 === strpos( $theme_root, WP_CONTENT_DIR ) ) {
    				$theme_root_uri = content_url( str_replace( WP_CONTENT_DIR, '', $theme_root ) );
    			} elseif ( 0 === strpos( $theme_root, ABSPATH ) ) {
    				$theme_root_uri = site_url( str_replace( ABSPATH, '', $theme_root ) );
    			} elseif ( 0 === strpos( $theme_root, WP_PLUGIN_DIR ) || 0 === strpos( $theme_root, WPMU_PLUGIN_DIR ) ) {
    				$theme_root_uri = plugins_url( basename( $theme_root ), $theme_root );
    			} else {
    				$theme_root_uri = $theme_root;
    			}
    		} else {
    			$theme_root_uri = content_url( $theme_root );
    		}
    	} else {
    		$theme_root_uri = content_url( 'themes' );
    	}
    
    	/**
    	 * Filters the URI for themes directory.
    	 *
    	 * @since 1.5.0
    	 *
    	 * @param string $theme_root_uri         The URI for themes directory.
    	 * @param string $siteurl                WordPress web address which is set in General Options.
    	 * @param string $stylesheet_or_template The stylesheet or template name of the theme.
    	 */
    	return apply_filters( 'theme_root_uri', $theme_root_uri, get_option( 'siteurl' ), $stylesheet_or_template );
    }
    
    /**
     * Gets the raw theme root relative to the content directory with no filters applied.
     *
     * @since 3.1.0
     *
     * @global array $wp_theme_directories
     *
     * @param string $stylesheet_or_template The stylesheet or template name of the theme.
     * @param bool   $skip_cache             Optional. Whether to skip the cache.
     *                                       Defaults to false, meaning the cache is used.
     * @return string Theme root.
     */
    function get_raw_theme_root( $stylesheet_or_template, $skip_cache = false ) {
    	global $wp_theme_directories;
    
    	if ( ! is_array( $wp_theme_directories ) || count( $wp_theme_directories ) <= 1 ) {
    		return '/themes';
    	}
    
    	$theme_root = false;
    
    	// If requesting the root for the active theme, consult options to avoid calling get_theme_roots().
    	if ( ! $skip_cache ) {
    		if ( get_option( 'stylesheet' ) == $stylesheet_or_template ) {
    			$theme_root = get_option( 'stylesheet_root' );
    		} elseif ( get_option( 'template' ) == $stylesheet_or_template ) {
    			$theme_root = get_option( 'template_root' );
    		}
    	}
    
    	if ( empty( $theme_root ) ) {
    		$theme_roots = get_theme_roots();
    		if ( ! empty( $theme_roots[ $stylesheet_or_template ] ) ) {
    			$theme_root = $theme_roots[ $stylesheet_or_template ];
    		}
    	}
    
    	return $theme_root;
    }
    
    /**
     * Displays localized stylesheet link element.
     *
     * @since 2.1.0
     */
    function locale_stylesheet() {
    	$stylesheet = get_locale_stylesheet_uri();
    	if ( empty( $stylesheet ) ) {
    		return;
    	}
    
    	$type_attr = current_theme_supports( 'html5', 'style' ) ? '' : ' type="text/css"';
    
    	printf(
    		'<link rel="stylesheet" href="%s"%s media="screen" />',
    		$stylesheet,
    		$type_attr
    	);
    }
    
    /**
     * Switches the theme.
     *
     * Accepts one argument: $stylesheet of the theme. It also accepts an additional function signature
     * of two arguments: $template then $stylesheet. This is for backward compatibility.
     *
     * @since 2.5.0
     *
     * @global array                $wp_theme_directories
     * @global WP_Customize_Manager $wp_customize
     * @global array                $sidebars_widgets
     *
     * @param string $stylesheet Stylesheet name.
     */
    function switch_theme( $stylesheet ) {
    	global $wp_theme_directories, $wp_customize, $sidebars_widgets;
    
    	$requirements = validate_theme_requirements( $stylesheet );
    	if ( is_wp_error( $requirements ) ) {
    		wp_die( $requirements );
    	}
    
    	$_sidebars_widgets = null;
    	if ( 'wp_ajax_customize_save' === current_action() ) {
    		$old_sidebars_widgets_data_setting = $wp_customize->get_setting( 'old_sidebars_widgets_data' );
    		if ( $old_sidebars_widgets_data_setting ) {
    			$_sidebars_widgets = $wp_customize->post_value( $old_sidebars_widgets_data_setting );
    		}
    	} elseif ( is_array( $sidebars_widgets ) ) {
    		$_sidebars_widgets = $sidebars_widgets;
    	}
    
    	if ( is_array( $_sidebars_widgets ) ) {
    		set_theme_mod(
    			'sidebars_widgets',
    			array(
    				'time' => time(),
    				'data' => $_sidebars_widgets,
    			)
    		);
    	}
    
    	$nav_menu_locations = get_theme_mod( 'nav_menu_locations' );
    	update_option( 'theme_switch_menu_locations', $nav_menu_locations );
    
    	if ( func_num_args() > 1 ) {
    		$stylesheet = func_get_arg( 1 );
    	}
    
    	$old_theme = wp_get_theme();
    	$new_theme = wp_get_theme( $stylesheet );
    	$template  = $new_theme->get_template();
    
    	if ( wp_is_recovery_mode() ) {
    		$paused_themes = wp_paused_themes();
    		$paused_themes->delete( $old_theme->get_stylesheet() );
    		$paused_themes->delete( $old_theme->get_template() );
    	}
    
    	update_option( 'template', $template );
    	update_option( 'stylesheet', $stylesheet );
    
    	if ( count( $wp_theme_directories ) > 1 ) {
    		update_option( 'template_root', get_raw_theme_root( $template, true ) );
    		update_option( 'stylesheet_root', get_raw_theme_root( $stylesheet, true ) );
    	} else {
    		delete_option( 'template_root' );
    		delete_option( 'stylesheet_root' );
    	}
    
    	$new_name = $new_theme->get( 'Name' );
    
    	update_option( 'current_theme', $new_name );
    
    	// Migrate from the old mods_{name} option to theme_mods_{slug}.
    	if ( is_admin() && false === get_option( 'theme_mods_' . $stylesheet ) ) {
    		$default_theme_mods = (array) get_option( 'mods_' . $new_name );
    		if ( ! empty( $nav_menu_locations ) && empty( $default_theme_mods['nav_menu_locations'] ) ) {
    			$default_theme_mods['nav_menu_locations'] = $nav_menu_locations;
    		}
    		add_option( "theme_mods_$stylesheet", $default_theme_mods );
    	} else {
    		/*
    		 * Since retrieve_widgets() is called when initializing a theme in the Customizer,
    		 * we need to remove the theme mods to avoid overwriting changes made via
    		 * the Customizer when accessing wp-admin/widgets.php.
    		 */
    		if ( 'wp_ajax_customize_save' === current_action() ) {
    			remove_theme_mod( 'sidebars_widgets' );
    		}
    	}
    
    	update_option( 'theme_switched', $old_theme->get_stylesheet() );
    
    	/**
    	 * Fires after the theme is switched.
    	 *
    	 * @since 1.5.0
    	 * @since 4.5.0 Introduced the <code>$old_theme</code> parameter.
    	 *
    	 * @param string   $new_name  Name of the new theme.
    	 * @param WP_Theme $new_theme WP_Theme instance of the new theme.
    	 * @param WP_Theme $old_theme WP_Theme instance of the old theme.
    	 */
    	do_action( 'switch_theme', $new_name, $new_theme, $old_theme );
    }
    
    /**
     * Checks that the active theme has the required files.
     *
     * Standalone themes need to have a <code>templates/index.html</code> or <code>index.php</code> template file.
     * Child themes need to have a <code>Template</code> header in the <code>style.css</code> stylesheet.
     *
     * Does not initially check the default theme, which is the fallback and should always exist.
     * But if it doesn't exist, it'll fall back to the latest core default theme that does exist.
     * Will switch theme to the fallback theme if active theme does not validate.
     *
     * You can use the {@see 'validate_current_theme'} filter to return false to disable
     * this functionality.
     *
     * @since 1.5.0
     * @since 6.0.0 Removed the requirement for block themes to have an <code>index.php</code> template.
     *
     * @see WP_DEFAULT_THEME
     *
     * @return bool
     */
    function validate_current_theme() {
    	/**
    	 * Filters whether to validate the active theme.
    	 *
    	 * @since 2.7.0
    	 *
    	 * @param bool $validate Whether to validate the active theme. Default true.
    	 */
    	if ( wp_installing() || ! apply_filters( 'validate_current_theme', true ) ) {
    		return true;
    	}
    
    	if (
    		! file_exists( get_template_directory() . '/templates/index.html' )
    		&& ! file_exists( get_template_directory() . '/block-templates/index.html' ) // Deprecated path support since 5.9.0.
    		&& ! file_exists( get_template_directory() . '/index.php' )
    	) {
    		// Invalid.
    	} elseif ( ! file_exists( get_template_directory() . '/style.css' ) ) {
    		// Invalid.
    	} elseif ( is_child_theme() && ! file_exists( get_stylesheet_directory() . '/style.css' ) ) {
    		// Invalid.
    	} else {
    		// Valid.
    		return true;
    	}
    
    	$default = wp_get_theme( WP_DEFAULT_THEME );
    	if ( $default->exists() ) {
    		switch_theme( WP_DEFAULT_THEME );
    		return false;
    	}
    
    	/**
    	 * If we're in an invalid state but WP_DEFAULT_THEME doesn't exist,
    	 * switch to the latest core default theme that's installed.
    	 *
    	 * If it turns out that this latest core default theme is our current
    	 * theme, then there's nothing we can do about that, so we have to bail,
    	 * rather than going into an infinite loop. (This is why there are
    	 * checks against WP_DEFAULT_THEME above, also.) We also can't do anything
    	 * if it turns out there is no default theme installed. (That's <code>false</code>.)
    	 */
    	$default = WP_Theme::get_core_default_theme();
    	if ( false === $default || get_stylesheet() == $default->get_stylesheet() ) {
    		return true;
    	}
    
    	switch_theme( $default->get_stylesheet() );
    	return false;
    }
    
    /**
     * Validates the theme requirements for WordPress version and PHP version.
     *
     * Uses the information from <code>Requires at least</code> and <code>Requires PHP</code> headers
     * defined in the theme's <code>style.css</code> file.
     *
     * @since 5.5.0
     * @since 5.8.0 Removed support for using <code>readme.txt</code> as a fallback.
     *
     * @param string $stylesheet Directory name for the theme.
     * @return true|WP_Error True if requirements are met, WP_Error on failure.
     */
    function validate_theme_requirements( $stylesheet ) {
    	$theme = wp_get_theme( $stylesheet );
    
    	$requirements = array(
    		'requires'     => ! empty( $theme->get( 'RequiresWP' ) ) ? $theme->get( 'RequiresWP' ) : '',
    		'requires_php' => ! empty( $theme->get( 'RequiresPHP' ) ) ? $theme->get( 'RequiresPHP' ) : '',
    	);
    
    	$compatible_wp  = is_wp_version_compatible( $requirements['requires'] );
    	$compatible_php = is_php_version_compatible( $requirements['requires_php'] );
    
    	if ( ! $compatible_wp && ! $compatible_php ) {
    		return new WP_Error(
    			'theme_wp_php_incompatible',
    			sprintf(
    				/* translators: %s: Theme name. */
    				_x( '<strong>Error:</strong> Current WordPress and PHP versions do not meet minimum requirements for %s.', 'theme' ),
    				$theme->display( 'Name' )
    			)
    		);
    	} elseif ( ! $compatible_php ) {
    		return new WP_Error(
    			'theme_php_incompatible',
    			sprintf(
    				/* translators: %s: Theme name. */
    				_x( '<strong>Error:</strong> Current PHP version does not meet minimum requirements for %s.', 'theme' ),
    				$theme->display( 'Name' )
    			)
    		);
    	} elseif ( ! $compatible_wp ) {
    		return new WP_Error(
    			'theme_wp_incompatible',
    			sprintf(
    				/* translators: %s: Theme name. */
    				_x( '<strong>Error:</strong> Current WordPress version does not meet minimum requirements for %s.', 'theme' ),
    				$theme->display( 'Name' )
    			)
    		);
    	}
    
    	return true;
    }
    
    /**
     * Retrieves all theme modifications.
     *
     * @since 3.1.0
     * @since 5.9.0 The return value is always an array.
     *
     * @return array Theme modifications.
     */
    function get_theme_mods() {
    	$theme_slug = get_option( 'stylesheet' );
    	$mods       = get_option( "theme_mods_$theme_slug" );
    
    	if ( false === $mods ) {
    		$theme_name = get_option( 'current_theme' );
    		if ( false === $theme_name ) {
    			$theme_name = wp_get_theme()->get( 'Name' );
    		}
    
    		$mods = get_option( "mods_$theme_name" ); // Deprecated location.
    		if ( is_admin() && false !== $mods ) {
    			update_option( "theme_mods_$theme_slug", $mods );
    			delete_option( "mods_$theme_name" );
    		}
    	}
    
    	if ( ! is_array( $mods ) ) {
    		$mods = array();
    	}
    
    	return $mods;
    }
    
    /**
     * Retrieves theme modification value for the active theme.
     *
     * If the modification name does not exist and <code>$default</code> is a string, then the
     * default will be passed through the {@link https://www.php.net/sprintf sprintf()}
     * PHP function with the template directory URI as the first value and the
     * stylesheet directory URI as the second value.
     *
     * @since 2.1.0
     *
     * @param string $name    Theme modification name.
     * @param mixed  $default Optional. Theme modification default value. Default false.
     * @return mixed Theme modification value.
     */
    function get_theme_mod( $name, $default = false ) {
    	$mods = get_theme_mods();
    
    	if ( isset( $mods[ $name ] ) ) {
    		/**
    		 * Filters the theme modification, or 'theme_mod', value.
    		 *
    		 * The dynamic portion of the hook name, <code>$name</code>, refers to the key name
    		 * of the modification array. For example, 'header_textcolor', 'header_image',
    		 * and so on depending on the theme options.
    		 *
    		 * @since 2.2.0
    		 *
    		 * @param mixed $current_mod The value of the active theme modification.
    		 */
    		return apply_filters( "theme_mod_{$name}", $mods[ $name ] );
    	}
    
    	if ( is_string( $default ) ) {
    		// Only run the replacement if an sprintf() string format pattern was found.
    		if ( preg_match( '#(?<!%)%(?:\d+\$?)?s#', $default ) ) {
    			// Remove a single trailing percent sign.
    			$default = preg_replace( '#(?<!%)%$#', '', $default );
    			$default = sprintf( $default, get_template_directory_uri(), get_stylesheet_directory_uri() );
    		}
    	}
    
    	/** This filter is documented in wp-includes/theme.php */
    	return apply_filters( "theme_mod_{$name}", $default );
    }
    
    /**
     * Updates theme modification value for the active theme.
     *
     * @since 2.1.0
     * @since 5.6.0 A return value was added.
     *
     * @param string $name  Theme modification name.
     * @param mixed  $value Theme modification value.
     * @return bool True if the value was updated, false otherwise.
     */
    function set_theme_mod( $name, $value ) {
    	$mods      = get_theme_mods();
    	$old_value = isset( $mods[ $name ] ) ? $mods[ $name ] : false;
    
    	/**
    	 * Filters the theme modification, or 'theme_mod', value on save.
    	 *
    	 * The dynamic portion of the hook name, <code>$name</code>, refers to the key name
    	 * of the modification array. For example, 'header_textcolor', 'header_image',
    	 * and so on depending on the theme options.
    	 *
    	 * @since 3.9.0
    	 *
    	 * @param mixed $value     The new value of the theme modification.
    	 * @param mixed $old_value The current value of the theme modification.
    	 */
    	$mods[ $name ] = apply_filters( "pre_set_theme_mod_{$name}", $value, $old_value );
    
    	$theme = get_option( 'stylesheet' );
    
    	return update_option( "theme_mods_$theme", $mods );
    }
    
    /**
     * Removes theme modification name from active theme list.
     *
     * If removing the name also removes all elements, then the entire option
     * will be removed.
     *
     * @since 2.1.0
     *
     * @param string $name Theme modification name.
     */
    function remove_theme_mod( $name ) {
    	$mods = get_theme_mods();
    
    	if ( ! isset( $mods[ $name ] ) ) {
    		return;
    	}
    
    	unset( $mods[ $name ] );
    
    	if ( empty( $mods ) ) {
    		remove_theme_mods();
    		return;
    	}
    
    	$theme = get_option( 'stylesheet' );
    
    	update_option( "theme_mods_$theme", $mods );
    }
    
    /**
     * Removes theme modifications option for the active theme.
     *
     * @since 2.1.0
     */
    function remove_theme_mods() {
    	delete_option( 'theme_mods_' . get_option( 'stylesheet' ) );
    
    	// Old style.
    	$theme_name = get_option( 'current_theme' );
    	if ( false === $theme_name ) {
    		$theme_name = wp_get_theme()->get( 'Name' );
    	}
    
    	delete_option( 'mods_' . $theme_name );
    }
    
    /**
     * Retrieves the custom header text color in 3- or 6-digit hexadecimal form.
     *
     * @since 2.1.0
     *
     * @return string Header text color in 3- or 6-digit hexadecimal form (minus the hash symbol).
     */
    function get_header_textcolor() {
    	return get_theme_mod( 'header_textcolor', get_theme_support( 'custom-header', 'default-text-color' ) );
    }
    
    /**
     * Displays the custom header text color in 3- or 6-digit hexadecimal form (minus the hash symbol).
     *
     * @since 2.1.0
     */
    function header_textcolor() {
    	echo get_header_textcolor();
    }
    
    /**
     * Whether to display the header text.
     *
     * @since 3.4.0
     *
     * @return bool
     */
    function display_header_text() {
    	if ( ! current_theme_supports( 'custom-header', 'header-text' ) ) {
    		return false;
    	}
    
    	$text_color = get_theme_mod( 'header_textcolor', get_theme_support( 'custom-header', 'default-text-color' ) );
    	return 'blank' !== $text_color;
    }
    
    /**
     * Checks whether a header image is set or not.
     *
     * @since 4.2.0
     *
     * @see get_header_image()
     *
     * @return bool Whether a header image is set or not.
     */
    function has_header_image() {
    	return (bool) get_header_image();
    }
    
    /**
     * Retrieves header image for custom header.
     *
     * @since 2.1.0
     *
     * @return string|false
     */
    function get_header_image() {
    	$url = get_theme_mod( 'header_image', get_theme_support( 'custom-header', 'default-image' ) );
    
    	if ( 'remove-header' === $url ) {
    		return false;
    	}
    
    	if ( is_random_header_image() ) {
    		$url = get_random_header_image();
    	}
    
    	return esc_url_raw( set_url_scheme( $url ) );
    }
    
    /**
     * Creates image tag markup for a custom header image.
     *
     * @since 4.4.0
     *
     * @param array $attr Optional. Additional attributes for the image tag. Can be used
     *                              to override the default attributes. Default empty.
     * @return string HTML image element markup or empty string on failure.
     */
    function get_header_image_tag( $attr = array() ) {
    	$header      = get_custom_header();
    	$header->url = get_header_image();
    
    	if ( ! $header->url ) {
    		return '';
    	}
    
    	$width  = absint( $header->width );
    	$height = absint( $header->height );
    	$alt    = '';
    
    	// Use alternative text assigned to the image, if available. Otherwise, leave it empty.
    	if ( ! empty( $header->attachment_id ) ) {
    		$image_alt = get_post_meta( $header->attachment_id, '_wp_attachment_image_alt', true );
    
    		if ( is_string( $image_alt ) ) {
    			$alt = $image_alt;
    		}
    	}
    
    	$attr = wp_parse_args(
    		$attr,
    		array(
    			'src'    => $header->url,
    			'width'  => $width,
    			'height' => $height,
    			'alt'    => $alt,
    		)
    	);
    
    	// Generate 'srcset' and 'sizes' if not already present.
    	if ( empty( $attr['srcset'] ) && ! empty( $header->attachment_id ) ) {
    		$image_meta = get_post_meta( $header->attachment_id, '_wp_attachment_metadata', true );
    		$size_array = array( $width, $height );
    
    		if ( is_array( $image_meta ) ) {
    			$srcset = wp_calculate_image_srcset( $size_array, $header->url, $image_meta, $header->attachment_id );
    
    			if ( ! empty( $attr['sizes'] ) ) {
    				$sizes = $attr['sizes'];
    			} else {
    				$sizes = wp_calculate_image_sizes( $size_array, $header->url, $image_meta, $header->attachment_id );
    			}
    
    			if ( $srcset && $sizes ) {
    				$attr['srcset'] = $srcset;
    				$attr['sizes']  = $sizes;
    			}
    		}
    	}
    
    	/**
    	 * Filters the list of header image attributes.
    	 *
    	 * @since 5.9.0
    	 *
    	 * @param array  $attr   Array of the attributes for the image tag.
    	 * @param object $header The custom header object returned by 'get_custom_header()'.
    	 */
    	$attr = apply_filters( 'get_header_image_tag_attributes', $attr, $header );
    
    	$attr = array_map( 'esc_attr', $attr );
    	$html = '<img';
    
    	foreach ( $attr as $name => $value ) {
    		$html .= ' ' . $name . '="' . $value . '"';
    	}
    
    	$html .= ' />';
    
    	/**
    	 * Filters the markup of header images.
    	 *
    	 * @since 4.4.0
    	 *
    	 * @param string $html   The HTML image tag markup being filtered.
    	 * @param object $header The custom header object returned by 'get_custom_header()'.
    	 * @param array  $attr   Array of the attributes for the image tag.
    	 */
    	return apply_filters( 'get_header_image_tag', $html, $header, $attr );
    }
    
    /**
     * Displays the image markup for a custom header image.
     *
     * @since 4.4.0
     *
     * @param array $attr Optional. Attributes for the image markup. Default empty.
     */
    function the_header_image_tag( $attr = array() ) {
    	echo get_header_image_tag( $attr );
    }
    
    /**
     * Gets random header image data from registered images in theme.
     *
     * @since 3.4.0
     *
     * @access private
     *
     * @global array $_wp_default_headers
     *
     * @return object
     */
    function _get_random_header_data() {
    	global $_wp_default_headers;
    	static $_wp_random_header = null;
    
    	if ( empty( $_wp_random_header ) ) {
    		$header_image_mod = get_theme_mod( 'header_image', '' );
    		$headers          = array();
    
    		if ( 'random-uploaded-image' === $header_image_mod ) {
    			$headers = get_uploaded_header_images();
    		} elseif ( ! empty( $_wp_default_headers ) ) {
    			if ( 'random-default-image' === $header_image_mod ) {
    				$headers = $_wp_default_headers;
    			} else {
    				if ( current_theme_supports( 'custom-header', 'random-default' ) ) {
    					$headers = $_wp_default_headers;
    				}
    			}
    		}
    
    		if ( empty( $headers ) ) {
    			return new stdClass;
    		}
    
    		$_wp_random_header = (object) $headers[ array_rand( $headers ) ];
    
    		$_wp_random_header->url = sprintf(
    			$_wp_random_header->url,
    			get_template_directory_uri(),
    			get_stylesheet_directory_uri()
    		);
    
    		$_wp_random_header->thumbnail_url = sprintf(
    			$_wp_random_header->thumbnail_url,
    			get_template_directory_uri(),
    			get_stylesheet_directory_uri()
    		);
    	}
    
    	return $_wp_random_header;
    }
    
    /**
     * Gets random header image URL from registered images in theme.
     *
     * @since 3.2.0
     *
     * @return string Path to header image.
     */
    function get_random_header_image() {
    	$random_image = _get_random_header_data();
    
    	if ( empty( $random_image->url ) ) {
    		return '';
    	}
    
    	return $random_image->url;
    }
    
    /**
     * Checks if random header image is in use.
     *
     * Always true if user expressly chooses the option in Appearance > Header.
     * Also true if theme has multiple header images registered, no specific header image
     * is chosen, and theme turns on random headers with add_theme_support().
     *
     * @since 3.2.0
     *
     * @param string $type The random pool to use. Possible values include 'any',
     *                     'default', 'uploaded'. Default 'any'.
     * @return bool
     */
    function is_random_header_image( $type = 'any' ) {
    	$header_image_mod = get_theme_mod( 'header_image', get_theme_support( 'custom-header', 'default-image' ) );
    
    	if ( 'any' === $type ) {
    		if ( 'random-default-image' === $header_image_mod
    			|| 'random-uploaded-image' === $header_image_mod
    			|| ( '' !== get_random_header_image() && empty( $header_image_mod ) )
    		) {
    			return true;
    		}
    	} else {
    		if ( "random-$type-image" === $header_image_mod ) {
    			return true;
    		} elseif ( 'default' === $type && empty( $header_image_mod ) && '' !== get_random_header_image() ) {
    			return true;
    		}
    	}
    
    	return false;
    }
    
    /**
     * Displays header image URL.
     *
     * @since 2.1.0
     */
    function header_image() {
    	$image = get_header_image();
    
    	if ( $image ) {
    		echo esc_url( $image );
    	}
    }
    
    /**
     * Gets the header images uploaded for the active theme.
     *
     * @since 3.2.0
     *
     * @return array
     */
    function get_uploaded_header_images() {
    	$header_images = array();
    
    	// @todo Caching.
    	$headers = get_posts(
    		array(
    			'post_type'  => 'attachment',
    			'meta_key'   => '_wp_attachment_is_custom_header',
    			'meta_value' => get_option( 'stylesheet' ),
    			'orderby'    => 'none',
    			'nopaging'   => true,
    		)
    	);
    
    	if ( empty( $headers ) ) {
    		return array();
    	}
    
    	foreach ( (array) $headers as $header ) {
    		$url          = esc_url_raw( wp_get_attachment_url( $header->ID ) );
    		$header_data  = wp_get_attachment_metadata( $header->ID );
    		$header_index = $header->ID;
    
    		$header_images[ $header_index ]                  = array();
    		$header_images[ $header_index ]['attachment_id'] = $header->ID;
    		$header_images[ $header_index ]['url']           = $url;
    		$header_images[ $header_index ]['thumbnail_url'] = $url;
    		$header_images[ $header_index ]['alt_text']      = get_post_meta( $header->ID, '_wp_attachment_image_alt', true );
    
    		if ( isset( $header_data['attachment_parent'] ) ) {
    			$header_images[ $header_index ]['attachment_parent'] = $header_data['attachment_parent'];
    		} else {
    			$header_images[ $header_index ]['attachment_parent'] = '';
    		}
    
    		if ( isset( $header_data['width'] ) ) {
    			$header_images[ $header_index ]['width'] = $header_data['width'];
    		}
    		if ( isset( $header_data['height'] ) ) {
    			$header_images[ $header_index ]['height'] = $header_data['height'];
    		}
    	}
    
    	return $header_images;
    }
    
    /**
     * Gets the header image data.
     *
     * @since 3.4.0
     *
     * @global array $_wp_default_headers
     *
     * @return object
     */
    function get_custom_header() {
    	global $_wp_default_headers;
    
    	if ( is_random_header_image() ) {
    		$data = _get_random_header_data();
    	} else {
    		$data = get_theme_mod( 'header_image_data' );
    		if ( ! $data && current_theme_supports( 'custom-header', 'default-image' ) ) {
    			$directory_args        = array( get_template_directory_uri(), get_stylesheet_directory_uri() );
    			$data                  = array();
    			$data['url']           = vsprintf( get_theme_support( 'custom-header', 'default-image' ), $directory_args );
    			$data['thumbnail_url'] = $data['url'];
    			if ( ! empty( $_wp_default_headers ) ) {
    				foreach ( (array) $_wp_default_headers as $default_header ) {
    					$url = vsprintf( $default_header['url'], $directory_args );
    					if ( $data['url'] == $url ) {
    						$data                  = $default_header;
    						$data['url']           = $url;
    						$data['thumbnail_url'] = vsprintf( $data['thumbnail_url'], $directory_args );
    						break;
    					}
    				}
    			}
    		}
    	}
    
    	$default = array(
    		'url'           => '',
    		'thumbnail_url' => '',
    		'width'         => get_theme_support( 'custom-header', 'width' ),
    		'height'        => get_theme_support( 'custom-header', 'height' ),
    		'video'         => get_theme_support( 'custom-header', 'video' ),
    	);
    	return (object) wp_parse_args( $data, $default );
    }
    
    /**
     * Registers a selection of default headers to be displayed by the custom header admin UI.
     *
     * @since 3.0.0
     *
     * @global array $_wp_default_headers
     *
     * @param array $headers Array of headers keyed by a string ID. The IDs point to arrays
     *                       containing 'url', 'thumbnail_url', and 'description' keys.
     */
    function register_default_headers( $headers ) {
    	global $_wp_default_headers;
    
    	$_wp_default_headers = array_merge( (array) $_wp_default_headers, (array) $headers );
    }
    
    /**
     * Unregisters default headers.
     *
     * This function must be called after register_default_headers() has already added the
     * header you want to remove.
     *
     * @see register_default_headers()
     * @since 3.0.0
     *
     * @global array $_wp_default_headers
     *
     * @param string|array $header The header string id (key of array) to remove, or an array thereof.
     * @return bool|void A single header returns true on success, false on failure.
     *                   There is currently no return value for multiple headers.
     */
    function unregister_default_headers( $header ) {
    	global $_wp_default_headers;
    
    	if ( is_array( $header ) ) {
    		array_map( 'unregister_default_headers', $header );
    	} elseif ( isset( $_wp_default_headers[ $header ] ) ) {
    		unset( $_wp_default_headers[ $header ] );
    		return true;
    	} else {
    		return false;
    	}
    }
    
    /**
     * Checks whether a header video is set or not.
     *
     * @since 4.7.0
     *
     * @see get_header_video_url()
     *
     * @return bool Whether a header video is set or not.
     */
    function has_header_video() {
    	return (bool) get_header_video_url();
    }
    
    /**
     * Retrieves header video URL for custom header.
     *
     * Uses a local video if present, or falls back to an external video.
     *
     * @since 4.7.0
     *
     * @return string|false Header video URL or false if there is no video.
     */
    function get_header_video_url() {
    	$id = absint( get_theme_mod( 'header_video' ) );
    
    	if ( $id ) {
    		// Get the file URL from the attachment ID.
    		$url = wp_get_attachment_url( $id );
    	} else {
    		$url = get_theme_mod( 'external_header_video' );
    	}
    
    	/**
    	 * Filters the header video URL.
    	 *
    	 * @since 4.7.3
    	 *
    	 * @param string $url Header video URL, if available.
    	 */
    	$url = apply_filters( 'get_header_video_url', $url );
    
    	if ( ! $id && ! $url ) {
    		return false;
    	}
    
    	return esc_url_raw( set_url_scheme( $url ) );
    }
    
    /**
     * Displays header video URL.
     *
     * @since 4.7.0
     */
    function the_header_video_url() {
    	$video = get_header_video_url();
    
    	if ( $video ) {
    		echo esc_url( $video );
    	}
    }
    
    /**
     * Retrieves header video settings.
     *
     * @since 4.7.0
     *
     * @return array
     */
    function get_header_video_settings() {
    	$header     = get_custom_header();
    	$video_url  = get_header_video_url();
    	$video_type = wp_check_filetype( $video_url, wp_get_mime_types() );
    
    	$settings = array(
    		'mimeType'  => '',
    		'posterUrl' => get_header_image(),
    		'videoUrl'  => $video_url,
    		'width'     => absint( $header->width ),
    		'height'    => absint( $header->height ),
    		'minWidth'  => 900,
    		'minHeight' => 500,
    		'l10n'      => array(
    			'pause'      => __( 'Pause' ),
    			'play'       => __( 'Play' ),
    			'pauseSpeak' => __( 'Video is paused.' ),
    			'playSpeak'  => __( 'Video is playing.' ),
    		),
    	);
    
    	if ( preg_match( '#^https?://(?:www\.)?(?:youtube\.com/watch|youtu\.be/)#', $video_url ) ) {
    		$settings['mimeType'] = 'video/x-youtube';
    	} elseif ( ! empty( $video_type['type'] ) ) {
    		$settings['mimeType'] = $video_type['type'];
    	}
    
    	/**
    	 * Filters header video settings.
    	 *
    	 * @since 4.7.0
    	 *
    	 * @param array $settings An array of header video settings.
    	 */
    	return apply_filters( 'header_video_settings', $settings );
    }
    
    /**
     * Checks whether a custom header is set or not.
     *
     * @since 4.7.0
     *
     * @return bool True if a custom header is set. False if not.
     */
    function has_custom_header() {
    	if ( has_header_image() || ( has_header_video() && is_header_video_active() ) ) {
    		return true;
    	}
    
    	return false;
    }
    
    /**
     * Checks whether the custom header video is eligible to show on the current page.
     *
     * @since 4.7.0
     *
     * @return bool True if the custom header video should be shown. False if not.
     */
    function is_header_video_active() {
    	if ( ! get_theme_support( 'custom-header', 'video' ) ) {
    		return false;
    	}
    
    	$video_active_cb = get_theme_support( 'custom-header', 'video-active-callback' );
    
    	if ( empty( $video_active_cb ) || ! is_callable( $video_active_cb ) ) {
    		$show_video = true;
    	} else {
    		$show_video = call_user_func( $video_active_cb );
    	}
    
    	/**
    	 * Filters whether the custom header video is eligible to show on the current page.
    	 *
    	 * @since 4.7.0
    	 *
    	 * @param bool $show_video Whether the custom header video should be shown. Returns the value
    	 *                         of the theme setting for the <code>custom-header</code>'s <code>video-active-callback</code>.
    	 *                         If no callback is set, the default value is that of <code>is_front_page()</code>.
    	 */
    	return apply_filters( 'is_header_video_active', $show_video );
    }
    
    /**
     * Retrieves the markup for a custom header.
     *
     * The container div will always be returned in the Customizer preview.
     *
     * @since 4.7.0
     *
     * @return string The markup for a custom header on success.
     */
    function get_custom_header_markup() {
    	if ( ! has_custom_header() && ! is_customize_preview() ) {
    		return '';
    	}
    
    	return sprintf(
    		'<div id="wp-custom-header" class="wp-custom-header">%s</div>',
    		get_header_image_tag()
    	);
    }
    
    /**
     * Prints the markup for a custom header.
     *
     * A container div will always be printed in the Customizer preview.
     *
     * @since 4.7.0
     */
    function the_custom_header_markup() {
    	$custom_header = get_custom_header_markup();
    	if ( empty( $custom_header ) ) {
    		return;
    	}
    
    	echo $custom_header;
    
    	if ( is_header_video_active() && ( has_header_video() || is_customize_preview() ) ) {
    		wp_enqueue_script( 'wp-custom-header' );
    		wp_localize_script( 'wp-custom-header', '_wpCustomHeaderSettings', get_header_video_settings() );
    	}
    }
    
    /**
     * Retrieves background image for custom background.
     *
     * @since 3.0.0
     *
     * @return string
     */
    function get_background_image() {
    	return get_theme_mod( 'background_image', get_theme_support( 'custom-background', 'default-image' ) );
    }
    
    /**
     * Displays background image path.
     *
     * @since 3.0.0
     */
    function background_image() {
    	echo get_background_image();
    }
    
    /**
     * Retrieves value for custom background color.
     *
     * @since 3.0.0
     *
     * @return string
     */
    function get_background_color() {
    	return get_theme_mod( 'background_color', get_theme_support( 'custom-background', 'default-color' ) );
    }
    
    /**
     * Displays background color value.
     *
     * @since 3.0.0
     */
    function background_color() {
    	echo get_background_color();
    }
    
    /**
     * Default custom background callback.
     *
     * @since 3.0.0
     */
    function _custom_background_cb() {
    	// $background is the saved custom image, or the default image.
    	$background = set_url_scheme( get_background_image() );
    
    	// $color is the saved custom color.
    	// A default has to be specified in style.css. It will not be printed here.
    	$color = get_background_color();
    
    	if ( get_theme_support( 'custom-background', 'default-color' ) === $color ) {
    		$color = false;
    	}
    
    	$type_attr = current_theme_supports( 'html5', 'style' ) ? '' : ' type="text/css"';
    
    	if ( ! $background && ! $color ) {
    		if ( is_customize_preview() ) {
    			printf( '<style%s id="custom-background-css"></style>', $type_attr );
    		}
    		return;
    	}
    
    	$style = $color ? "background-color: #$color;" : '';
    
    	if ( $background ) {
    		$image = ' background-image: url("' . esc_url_raw( $background ) . '");';
    
    		// Background Position.
    		$position_x = get_theme_mod( 'background_position_x', get_theme_support( 'custom-background', 'default-position-x' ) );
    		$position_y = get_theme_mod( 'background_position_y', get_theme_support( 'custom-background', 'default-position-y' ) );
    
    		if ( ! in_array( $position_x, array( 'left', 'center', 'right' ), true ) ) {
    			$position_x = 'left';
    		}
    
    		if ( ! in_array( $position_y, array( 'top', 'center', 'bottom' ), true ) ) {
    			$position_y = 'top';
    		}
    
    		$position = " background-position: $position_x $position_y;";
    
    		// Background Size.
    		$size = get_theme_mod( 'background_size', get_theme_support( 'custom-background', 'default-size' ) );
    
    		if ( ! in_array( $size, array( 'auto', 'contain', 'cover' ), true ) ) {
    			$size = 'auto';
    		}
    
    		$size = " background-size: $size;";
    
    		// Background Repeat.
    		$repeat = get_theme_mod( 'background_repeat', get_theme_support( 'custom-background', 'default-repeat' ) );
    
    		if ( ! in_array( $repeat, array( 'repeat-x', 'repeat-y', 'repeat', 'no-repeat' ), true ) ) {
    			$repeat = 'repeat';
    		}
    
    		$repeat = " background-repeat: $repeat;";
    
    		// Background Scroll.
    		$attachment = get_theme_mod( 'background_attachment', get_theme_support( 'custom-background', 'default-attachment' ) );
    
    		if ( 'fixed' !== $attachment ) {
    			$attachment = 'scroll';
    		}
    
    		$attachment = " background-attachment: $attachment;";
    
    		$style .= $image . $position . $size . $repeat . $attachment;
    	}
    	?>
    <style<?php echo $type_attr; ?> id="custom-background-css">
    body.custom-background { <?php echo trim( $style ); ?> }
    </style>
    	<?php
    }
    
    /**
     * Renders the Custom CSS style element.
     *
     * @since 4.7.0
     */
    function wp_custom_css_cb() {
    	$styles = wp_get_custom_css();
    	if ( $styles || is_customize_preview() ) :
    		$type_attr = current_theme_supports( 'html5', 'style' ) ? '' : ' type="text/css"';
    		?>
    		<style<?php echo $type_attr; ?> id="wp-custom-css">
    			<?php
    			// Note that esc_html() cannot be used because <code>div > span</code> is not interpreted properly.
    			echo strip_tags( $styles );
    			?>
    		</style>
    		<?php
    	endif;
    }
    
    /**
     * Fetches the <code>custom_css</code> post for a given theme.
     *
     * @since 4.7.0
     *
     * @param string $stylesheet Optional. A theme object stylesheet name. Defaults to the active theme.
     * @return WP_Post|null The custom_css post or null if none exists.
     */
    function wp_get_custom_css_post( $stylesheet = '' ) {
    	if ( empty( $stylesheet ) ) {
    		$stylesheet = get_stylesheet();
    	}
    
    	$custom_css_query_vars = array(
    		'post_type'              => 'custom_css',
    		'post_status'            => get_post_stati(),
    		'name'                   => sanitize_title( $stylesheet ),
    		'posts_per_page'         => 1,
    		'no_found_rows'          => true,
    		'cache_results'          => true,
    		'update_post_meta_cache' => false,
    		'update_post_term_cache' => false,
    		'lazy_load_term_meta'    => false,
    	);
    
    	$post = null;
    	if ( get_stylesheet() === $stylesheet ) {
    		$post_id = get_theme_mod( 'custom_css_post_id' );
    
    		if ( $post_id > 0 && get_post( $post_id ) ) {
    			$post = get_post( $post_id );
    		}
    
    		// <code>-1</code> indicates no post exists; no query necessary.
    		if ( ! $post && -1 !== $post_id ) {
    			$query = new WP_Query( $custom_css_query_vars );
    			$post  = $query->post;
    			/*
    			 * Cache the lookup. See wp_update_custom_css_post().
    			 * @todo This should get cleared if a custom_css post is added/removed.
    			 */
    			set_theme_mod( 'custom_css_post_id', $post ? $post->ID : -1 );
    		}
    	} else {
    		$query = new WP_Query( $custom_css_query_vars );
    		$post  = $query->post;
    	}
    
    	return $post;
    }
    
    /**
     * Fetches the saved Custom CSS content for rendering.
     *
     * @since 4.7.0
     *
     * @param string $stylesheet Optional. A theme object stylesheet name. Defaults to the active theme.
     * @return string The Custom CSS Post content.
     */
    function wp_get_custom_css( $stylesheet = '' ) {
    	$css = '';
    
    	if ( empty( $stylesheet ) ) {
    		$stylesheet = get_stylesheet();
    	}
    
    	$post = wp_get_custom_css_post( $stylesheet );
    	if ( $post ) {
    		$css = $post->post_content;
    	}
    
    	/**
    	 * Filters the custom CSS output into the head element.
    	 *
    	 * @since 4.7.0
    	 *
    	 * @param string $css        CSS pulled in from the Custom CSS post type.
    	 * @param string $stylesheet The theme stylesheet name.
    	 */
    	$css = apply_filters( 'wp_get_custom_css', $css, $stylesheet );
    
    	return $css;
    }
    
    /**
     * Updates the <code>custom_css</code> post for a given theme.
     *
     * Inserts a <code>custom_css</code> post when one doesn't yet exist.
     *
     * @since 4.7.0
     *
     * @param string $css CSS, stored in <code>post_content</code>.
     * @param array  $args {
     *     Args.
     *
     *     @type string $preprocessed Optional. Pre-processed CSS, stored in <code>post_content_filtered</code>.
     *                                Normally empty string.
     *     @type string $stylesheet   Optional. Stylesheet (child theme) to update.
     *                                Defaults to active theme/stylesheet.
     * }
     * @return WP_Post|WP_Error Post on success, error on failure.
     */
    function wp_update_custom_css_post( $css, $args = array() ) {
    	$args = wp_parse_args(
    		$args,
    		array(
    			'preprocessed' => '',
    			'stylesheet'   => get_stylesheet(),
    		)
    	);
    
    	$data = array(
    		'css'          => $css,
    		'preprocessed' => $args['preprocessed'],
    	);
    
    	/**
    	 * Filters the <code>css</code> (<code>post_content</code>) and <code>preprocessed</code> (<code>post_content_filtered</code>) args
    	 * for a <code>custom_css</code> post being updated.
    	 *
    	 * This filter can be used by plugin that offer CSS pre-processors, to store the original
    	 * pre-processed CSS in <code>post_content_filtered</code> and then store processed CSS in <code>post_content</code>.
    	 * When used in this way, the <code>post_content_filtered</code> should be supplied as the setting value
    	 * instead of <code>post_content</code> via a the <code>customize_value_custom_css</code> filter, for example:
    	 *
    	 * <code>
    	 * add_filter( 'customize_value_custom_css', function( $value, $setting ) {
    	 *     $post = wp_get_custom_css_post( $setting->stylesheet );
    	 *     if ( $post && ! empty( $post->post_content_filtered ) ) {
    	 *         $css = $post->post_content_filtered;
    	 *     }
    	 *     return $css;
    	 * }, 10, 2 );
    	 * </code>
    	 *
    	 * @since 4.7.0
    	 * @param array $data {
    	 *     Custom CSS data.
    	 *
    	 *     @type string $css          CSS stored in <code>post_content</code>.
    	 *     @type string $preprocessed Pre-processed CSS stored in <code>post_content_filtered</code>.
    	 *                                Normally empty string.
    	 * }
    	 * @param array $args {
    	 *     The args passed into <code>wp_update_custom_css_post()</code> merged with defaults.
    	 *
    	 *     @type string $css          The original CSS passed in to be updated.
    	 *     @type string $preprocessed The original preprocessed CSS passed in to be updated.
    	 *     @type string $stylesheet   The stylesheet (theme) being updated.
    	 * }
    	 */
    	$data = apply_filters( 'update_custom_css_data', $data, array_merge( $args, compact( 'css' ) ) );
    
    	$post_data = array(
    		'post_title'            => $args['stylesheet'],
    		'post_name'             => sanitize_title( $args['stylesheet'] ),
    		'post_type'             => 'custom_css',
    		'post_status'           => 'publish',
    		'post_content'          => $data['css'],
    		'post_content_filtered' => $data['preprocessed'],
    	);
    
    	// Update post if it already exists, otherwise create a new one.
    	$post = wp_get_custom_css_post( $args['stylesheet'] );
    	if ( $post ) {
    		$post_data['ID'] = $post->ID;
    		$r               = wp_update_post( wp_slash( $post_data ), true );
    	} else {
    		$r = wp_insert_post( wp_slash( $post_data ), true );
    
    		if ( ! is_wp_error( $r ) ) {
    			if ( get_stylesheet() === $args['stylesheet'] ) {
    				set_theme_mod( 'custom_css_post_id', $r );
    			}
    
    			// Trigger creation of a revision. This should be removed once #30854 is resolved.
    			if ( 0 === count( wp_get_post_revisions( $r ) ) ) {
    				wp_save_post_revision( $r );
    			}
    		}
    	}
    
    	if ( is_wp_error( $r ) ) {
    		return $r;
    	}
    	return get_post( $r );
    }
    
    /**
     * Adds callback for custom TinyMCE editor stylesheets.
     *
     * The parameter $stylesheet is the name of the stylesheet, relative to
     * the theme root. It also accepts an array of stylesheets.
     * It is optional and defaults to 'editor-style.css'.
     *
     * This function automatically adds another stylesheet with -rtl prefix, e.g. editor-style-rtl.css.
     * If that file doesn't exist, it is removed before adding the stylesheet(s) to TinyMCE.
     * If an array of stylesheets is passed to add_editor_style(),
     * RTL is only added for the first stylesheet.
     *
     * Since version 3.4 the TinyMCE body has .rtl CSS class.
     * It is a better option to use that class and add any RTL styles to the main stylesheet.
     *
     * @since 3.0.0
     *
     * @global array $editor_styles
     *
     * @param array|string $stylesheet Optional. Stylesheet name or array thereof, relative to theme root.
     *                                 Defaults to 'editor-style.css'
     */
    function add_editor_style( $stylesheet = 'editor-style.css' ) {
    	global $editor_styles;
    
    	add_theme_support( 'editor-style' );
    
    	$editor_styles = (array) $editor_styles;
    	$stylesheet    = (array) $stylesheet;
    
    	if ( is_rtl() ) {
    		$rtl_stylesheet = str_replace( '.css', '-rtl.css', $stylesheet[0] );
    		$stylesheet[]   = $rtl_stylesheet;
    	}
    
    	$editor_styles = array_merge( $editor_styles, $stylesheet );
    }
    
    /**
     * Removes all visual editor stylesheets.
     *
     * @since 3.1.0
     *
     * @global array $editor_styles
     *
     * @return bool True on success, false if there were no stylesheets to remove.
     */
    function remove_editor_styles() {
    	if ( ! current_theme_supports( 'editor-style' ) ) {
    		return false;
    	}
    	_remove_theme_support( 'editor-style' );
    	if ( is_admin() ) {
    		$GLOBALS['editor_styles'] = array();
    	}
    	return true;
    }
    
    /**
     * Retrieves any registered editor stylesheet URLs.
     *
     * @since 4.0.0
     *
     * @global array $editor_styles Registered editor stylesheets
     *
     * @return string[] If registered, a list of editor stylesheet URLs.
     */
    function get_editor_stylesheets() {
    	$stylesheets = array();
    	// Load editor_style.css if the active theme supports it.
    	if ( ! empty( $GLOBALS['editor_styles'] ) && is_array( $GLOBALS['editor_styles'] ) ) {
    		$editor_styles = $GLOBALS['editor_styles'];
    
    		$editor_styles = array_unique( array_filter( $editor_styles ) );
    		$style_uri     = get_stylesheet_directory_uri();
    		$style_dir     = get_stylesheet_directory();
    
    		// Support externally referenced styles (like, say, fonts).
    		foreach ( $editor_styles as $key => $file ) {
    			if ( preg_match( '~^(https?:)?//~', $file ) ) {
    				$stylesheets[] = esc_url_raw( $file );
    				unset( $editor_styles[ $key ] );
    			}
    		}
    
    		// Look in a parent theme first, that way child theme CSS overrides.
    		if ( is_child_theme() ) {
    			$template_uri = get_template_directory_uri();
    			$template_dir = get_template_directory();
    
    			foreach ( $editor_styles as $key => $file ) {
    				if ( $file && file_exists( "$template_dir/$file" ) ) {
    					$stylesheets[] = "$template_uri/$file";
    				}
    			}
    		}
    
    		foreach ( $editor_styles as $file ) {
    			if ( $file && file_exists( "$style_dir/$file" ) ) {
    				$stylesheets[] = "$style_uri/$file";
    			}
    		}
    	}
    
    	/**
    	 * Filters the array of URLs of stylesheets applied to the editor.
    	 *
    	 * @since 4.3.0
    	 *
    	 * @param string[] $stylesheets Array of URLs of stylesheets to be applied to the editor.
    	 */
    	return apply_filters( 'editor_stylesheets', $stylesheets );
    }
    
    /**
     * Expands a theme's starter content configuration using core-provided data.
     *
     * @since 4.7.0
     *
     * @return array Array of starter content.
     */
    function get_theme_starter_content() {
    	$theme_support = get_theme_support( 'starter-content' );
    	if ( is_array( $theme_support ) && ! empty( $theme_support[0] ) && is_array( $theme_support[0] ) ) {
    		$config = $theme_support[0];
    	} else {
    		$config = array();
    	}
    
    	$core_content = array(
    		'widgets'   => array(
    			'text_business_info' => array(
    				'text',
    				array(
    					'title'  => _x( 'Find Us', 'Theme starter content' ),
    					'text'   => implode(
    						'',
    						array(
    							'<strong>' . _x( 'Address', 'Theme starter content' ) . "</strong>\n",
    							_x( '123 Main Street', 'Theme starter content' ) . "\n",
    							_x( 'New York, NY 10001', 'Theme starter content' ) . "\n\n",
    							'<strong>' . _x( 'Hours', 'Theme starter content' ) . "</strong>\n",
    							_x( 'Monday&ndash;Friday: 9:00AM&ndash;5:00PM', 'Theme starter content' ) . "\n",
    							_x( 'Saturday & Sunday: 11:00AM&ndash;3:00PM', 'Theme starter content' ),
    						)
    					),
    					'filter' => true,
    					'visual' => true,
    				),
    			),
    			'text_about'         => array(
    				'text',
    				array(
    					'title'  => _x( 'About This Site', 'Theme starter content' ),
    					'text'   => _x( 'This may be a good place to introduce yourself and your site or include some credits.', 'Theme starter content' ),
    					'filter' => true,
    					'visual' => true,
    				),
    			),
    			'archives'           => array(
    				'archives',
    				array(
    					'title' => _x( 'Archives', 'Theme starter content' ),
    				),
    			),
    			'calendar'           => array(
    				'calendar',
    				array(
    					'title' => _x( 'Calendar', 'Theme starter content' ),
    				),
    			),
    			'categories'         => array(
    				'categories',
    				array(
    					'title' => _x( 'Categories', 'Theme starter content' ),
    				),
    			),
    			'meta'               => array(
    				'meta',
    				array(
    					'title' => _x( 'Meta', 'Theme starter content' ),
    				),
    			),
    			'recent-comments'    => array(
    				'recent-comments',
    				array(
    					'title' => _x( 'Recent Comments', 'Theme starter content' ),
    				),
    			),
    			'recent-posts'       => array(
    				'recent-posts',
    				array(
    					'title' => _x( 'Recent Posts', 'Theme starter content' ),
    				),
    			),
    			'search'             => array(
    				'search',
    				array(
    					'title' => _x( 'Search', 'Theme starter content' ),
    				),
    			),
    		),
    		'nav_menus' => array(
    			'link_home'       => array(
    				'type'  => 'custom',
    				'title' => _x( 'Home', 'Theme starter content' ),
    				'url'   => home_url( '/' ),
    			),
    			'page_home'       => array( // Deprecated in favor of 'link_home'.
    				'type'      => 'post_type',
    				'object'    => 'page',
    				'object_id' => '{{home}}',
    			),
    			'page_about'      => array(
    				'type'      => 'post_type',
    				'object'    => 'page',
    				'object_id' => '{{about}}',
    			),
    			'page_blog'       => array(
    				'type'      => 'post_type',
    				'object'    => 'page',
    				'object_id' => '{{blog}}',
    			),
    			'page_news'       => array(
    				'type'      => 'post_type',
    				'object'    => 'page',
    				'object_id' => '{{news}}',
    			),
    			'page_contact'    => array(
    				'type'      => 'post_type',
    				'object'    => 'page',
    				'object_id' => '{{contact}}',
    			),
    
    			'link_email'      => array(
    				'title' => _x( 'Email', 'Theme starter content' ),
    				'url'   => 'mailto:wordpress@example.com',
    			),
    			'link_facebook'   => array(
    				'title' => _x( 'Facebook', 'Theme starter content' ),
    				'url'   => 'https://www.facebook.com/wordpress',
    			),
    			'link_foursquare' => array(
    				'title' => _x( 'Foursquare', 'Theme starter content' ),
    				'url'   => 'https://foursquare.com/',
    			),
    			'link_github'     => array(
    				'title' => _x( 'GitHub', 'Theme starter content' ),
    				'url'   => 'https://github.com/wordpress/',
    			),
    			'link_instagram'  => array(
    				'title' => _x( 'Instagram', 'Theme starter content' ),
    				'url'   => 'https://www.instagram.com/explore/tags/wordcamp/',
    			),
    			'link_linkedin'   => array(
    				'title' => _x( 'LinkedIn', 'Theme starter content' ),
    				'url'   => 'https://www.linkedin.com/company/1089783',
    			),
    			'link_pinterest'  => array(
    				'title' => _x( 'Pinterest', 'Theme starter content' ),
    				'url'   => 'https://www.pinterest.com/',
    			),
    			'link_twitter'    => array(
    				'title' => _x( 'Twitter', 'Theme starter content' ),
    				'url'   => 'https://twitter.com/wordpress',
    			),
    			'link_yelp'       => array(
    				'title' => _x( 'Yelp', 'Theme starter content' ),
    				'url'   => 'https://www.yelp.com',
    			),
    			'link_youtube'    => array(
    				'title' => _x( 'YouTube', 'Theme starter content' ),
    				'url'   => 'https://www.youtube.com/channel/UCdof4Ju7amm1chz1gi1T2ZA',
    			),
    		),
    		'posts'     => array(
    			'home'             => array(
    				'post_type'    => 'page',
    				'post_title'   => _x( 'Home', 'Theme starter content' ),
    				'post_content' => sprintf(
    					"<!-- wp:paragraph -->\n<p>%s</p>\n<!-- /wp:paragraph -->",
    					_x( 'Welcome to your site! This is your homepage, which is what most visitors will see when they come to your site for the first time.', 'Theme starter content' )
    				),
    			),
    			'about'            => array(
    				'post_type'    => 'page',
    				'post_title'   => _x( 'About', 'Theme starter content' ),
    				'post_content' => sprintf(
    					"<!-- wp:paragraph -->\n<p>%s</p>\n<!-- /wp:paragraph -->",
    					_x( 'You might be an artist who would like to introduce yourself and your work here or maybe you&rsquo;re a business with a mission to describe.', 'Theme starter content' )
    				),
    			),
    			'contact'          => array(
    				'post_type'    => 'page',
    				'post_title'   => _x( 'Contact', 'Theme starter content' ),
    				'post_content' => sprintf(
    					"<!-- wp:paragraph -->\n<p>%s</p>\n<!-- /wp:paragraph -->",
    					_x( 'This is a page with some basic contact information, such as an address and phone number. You might also try a plugin to add a contact form.', 'Theme starter content' )
    				),
    			),
    			'blog'             => array(
    				'post_type'  => 'page',
    				'post_title' => _x( 'Blog', 'Theme starter content' ),
    			),
    			'news'             => array(
    				'post_type'  => 'page',
    				'post_title' => _x( 'News', 'Theme starter content' ),
    			),
    
    			'homepage-section' => array(
    				'post_type'    => 'page',
    				'post_title'   => _x( 'A homepage section', 'Theme starter content' ),
    				'post_content' => sprintf(
    					"<!-- wp:paragraph -->\n<p>%s</p>\n<!-- /wp:paragraph -->",
    					_x( 'This is an example of a homepage section. Homepage sections can be any page other than the homepage itself, including the page that shows your latest blog posts.', 'Theme starter content' )
    				),
    			),
    		),
    	);
    
    	$content = array();
    
    	foreach ( $config as $type => $args ) {
    		switch ( $type ) {
    			// Use options and theme_mods as-is.
    			case 'options':
    			case 'theme_mods':
    				$content[ $type ] = $config[ $type ];
    				break;
    
    			// Widgets are grouped into sidebars.
    			case 'widgets':
    				foreach ( $config[ $type ] as $sidebar_id => $widgets ) {
    					foreach ( $widgets as $id => $widget ) {
    						if ( is_array( $widget ) ) {
    
    							// Item extends core content.
    							if ( ! empty( $core_content[ $type ][ $id ] ) ) {
    								$widget = array(
    									$core_content[ $type ][ $id ][0],
    									array_merge( $core_content[ $type ][ $id ][1], $widget ),
    								);
    							}
    
    							$content[ $type ][ $sidebar_id ][] = $widget;
    						} elseif ( is_string( $widget )
    							&& ! empty( $core_content[ $type ] )
    							&& ! empty( $core_content[ $type ][ $widget ] )
    						) {
    							$content[ $type ][ $sidebar_id ][] = $core_content[ $type ][ $widget ];
    						}
    					}
    				}
    				break;
    
    			// And nav menu items are grouped into nav menus.
    			case 'nav_menus':
    				foreach ( $config[ $type ] as $nav_menu_location => $nav_menu ) {
    
    					// Ensure nav menus get a name.
    					if ( empty( $nav_menu['name'] ) ) {
    						$nav_menu['name'] = $nav_menu_location;
    					}
    
    					$content[ $type ][ $nav_menu_location ]['name'] = $nav_menu['name'];
    
    					foreach ( $nav_menu['items'] as $id => $nav_menu_item ) {
    						if ( is_array( $nav_menu_item ) ) {
    
    							// Item extends core content.
    							if ( ! empty( $core_content[ $type ][ $id ] ) ) {
    								$nav_menu_item = array_merge( $core_content[ $type ][ $id ], $nav_menu_item );
    							}
    
    							$content[ $type ][ $nav_menu_location ]['items'][] = $nav_menu_item;
    						} elseif ( is_string( $nav_menu_item )
    							&& ! empty( $core_content[ $type ] )
    							&& ! empty( $core_content[ $type ][ $nav_menu_item ] )
    						) {
    							$content[ $type ][ $nav_menu_location ]['items'][] = $core_content[ $type ][ $nav_menu_item ];
    						}
    					}
    				}
    				break;
    
    			// Attachments are posts but have special treatment.
    			case 'attachments':
    				foreach ( $config[ $type ] as $id => $item ) {
    					if ( ! empty( $item['file'] ) ) {
    						$content[ $type ][ $id ] = $item;
    					}
    				}
    				break;
    
    			// All that's left now are posts (besides attachments).
    			// Not a default case for the sake of clarity and future work.
    			case 'posts':
    				foreach ( $config[ $type ] as $id => $item ) {
    					if ( is_array( $item ) ) {
    
    						// Item extends core content.
    						if ( ! empty( $core_content[ $type ][ $id ] ) ) {
    							$item = array_merge( $core_content[ $type ][ $id ], $item );
    						}
    
    						// Enforce a subset of fields.
    						$content[ $type ][ $id ] = wp_array_slice_assoc(
    							$item,
    							array(
    								'post_type',
    								'post_title',
    								'post_excerpt',
    								'post_name',
    								'post_content',
    								'menu_order',
    								'comment_status',
    								'thumbnail',
    								'template',
    							)
    						);
    					} elseif ( is_string( $item ) && ! empty( $core_content[ $type ][ $item ] ) ) {
    						$content[ $type ][ $item ] = $core_content[ $type ][ $item ];
    					}
    				}
    				break;
    		}
    	}
    
    	/**
    	 * Filters the expanded array of starter content.
    	 *
    	 * @since 4.7.0
    	 *
    	 * @param array $content Array of starter content.
    	 * @p

    De pagina waar ik hulp bij nodig heb: [log in om de link te zien]

4 reacties aan het bekijken - 1 tot 4 (van in totaal 4)
  • Moderator Jeroen Rotty

    (@jeroenrotty)

    Support Moderator

    Bizar, klinkt alsof de update de file mogelijks niet goed heeft weggeschreven en er een stuk zou ontbreken. Wat ik zou proberen is /wp-includes/theme.php uit het WordPress installatiebestand te kopieren naar je site. Dat kan via (s)FTP of als je host een controlepaneel heeft met bestandsbeheer mogelijkheden.

    Dat is alvast een eerste stap om te checken of het helpt. Was verder je thema’s en plugins up to date?

    Wat Jeroen zegt klopt helemaal. Ik heb mijn theme.php bestand er even naast gezet en jouwe komt uit op 2503 lijnen terwijl die van mij, nog nooit aangepast komt op: 4214 lijnen.

    Dus ik zou ofwel je theme.php vanuit een back-up terugzetten en 6.0.1 opnieuw laten installeren vanuit het admin panel of gewoon een cleane versie erop zetten.

    Zoals Jeroen ook zegt, via (S)FTP via je host controlepaneel of met de FTP gegevens en Filezilla is dit een eenvoudige klus om te klaren.

    Ik zou zobiezo na het verplaatsen van het theme.php bestand de update via je WordPress dashboard opnieuw laten installeren. Je weet maar nooit.

    PS: check ook eens of de schijfruimte niet vol is. Misschien had je te weinig schijfruimte waardoor de update niet goed kon uitpakken en zo je theme.php bestand corrupt geraakt is.

    Thread starter olaframak

    (@olaframak)

    Goedemorgen Jeroen en Pieterjan,

    Ten eerste wil ik jullie hartelijk bedanken voor jullie hulp.
    Ik heb gedaan wat Jeroen heeft aangeraden en toen kon ik weer inloggen en langzaam aan alle plugins weer aanzetten. Eerste maar eens een backup gemaakt van de werkende site, dat leek me wel handig.
    Inmiddels is alles weer helemaal oke!
    Nogmaals heel erge bedankt voor jullie hulp! Heel blij mee!

    Mvg,
    Olaf

    Moderator Jeroen Rotty

    (@jeroenrotty)

    Support Moderator

    Hey Olaf,

    Super! Klinkt goed, leuk dat ik kon helpen.

4 reacties aan het bekijken - 1 tot 4 (van in totaal 4)