enmi-conf.org: comparison wp/wp-includes/functions.php

equal deleted inserted replaced

-:be944660c56a
+:3d72ae0968f4
 require ABSPATH . WPINC . '/option.php';
 /**
 * Convert given MySQL date string into a different format.
 *
-* `$format` should be a PHP date format string.
+*  - `$format` should be a PHP date format string.
-* 'U' and 'G' formats will return a sum of timestamp with timezone offset.
+*  - 'U' and 'G' formats will return an integer sum of timestamp with timezone offset.
-* `$date` is expected to be local time in MySQL format (`Y-m-d H:i:s`).
+*  - `$date` is expected to be local time in MySQL format (`Y-m-d H:i:s`).
 *
 * Historically UTC time could be passed to the function to produce Unix timestamp.
 *
 * If `$translate` is true then the given date and format string will
 * be passed to `wp_date()` for translation.
 * @since 0.71
 *
 * @param string $format    Format of the date to return.
 * @param string $date      Date string to convert.
 * @param bool   $translate Whether the return date should be translated. Default true.
-* @return string|int|false Formatted date string or sum of Unix timestamp and timezone offset.
+* @return string|int|false Integer if `$format` is 'U' or 'G', string otherwise.
 *                          False on failure.
 */
 function mysql2date( $format, $date, $translate = true ) {
 	if ( empty( $date ) ) {
 		return false;
 }
 /**
 * Retrieves the current time based on specified type.
 *
-* The 'mysql' type will return the time in the format for MySQL DATETIME field.
+*  - The 'mysql' type will return the time in the format for MySQL DATETIME field.
-* The 'timestamp' type will return the current timestamp or a sum of timestamp
+*  - The 'timestamp' or 'U' types will return the current timestamp or a sum of timestamp
-* and timezone offset, depending on `$gmt`.
+*    and timezone offset, depending on `$gmt`.
-* Other strings will be interpreted as PHP date formats (e.g. 'Y-m-d').
+*  - Other strings will be interpreted as PHP date formats (e.g. 'Y-m-d').
 *
-* If $gmt is set to either '1' or 'true', then both types will use GMT time.
+* If `$gmt` is a truthy value then both types will use GMT time, otherwise the
-* if $gmt is false, the output is adjusted with the GMT offset in the WordPress option.
+* output is adjusted with the GMT offset for the site.
 *
 * @since 1.0.0
-*
+* @since 5.3.0 Now returns an integer if `$type` is 'U'. Previously a string was returned.
-* @param string   $type Type of time to retrieve. Accepts 'mysql', 'timestamp',
+*
+* @param string   $type Type of time to retrieve. Accepts 'mysql', 'timestamp', 'U',
 *                       or PHP date format string (e.g. 'Y-m-d').
 * @param int|bool $gmt  Optional. Whether to use GMT timezone. Default false.
-* @return int|string Integer if $type is 'timestamp', string otherwise.
+* @return int|string Integer if `$type` is 'timestamp' or 'U', string otherwise.
 */
 function current_time( $type, $gmt = 0 ) {
 	// Don't use non-GMT timestamp, unless you know the difference and really need to.
 	if ( 'timestamp' === $type || 'U' === $type ) {
 		return $gmt ? time() : time() + (int) ( get_option( 'gmt_offset' ) * HOUR_IN_SECONDS );
 	return $datetime->format( $type );
 }
 /**
-* Retrieves the current time as an object with the timezone from settings.
+* Retrieves the current time as an object using the site's timezone.
 *
 * @since 5.3.0
 *
 * @return DateTimeImmutable Date and time object.
 */
 function current_datetime() {
 	return new DateTimeImmutable( 'now', wp_timezone() );
 }
 /**
-* Retrieves the timezone from site settings as a string.
+* Retrieves the timezone of the site as a string.
 *
-* Uses the `timezone_string` option to get a proper timezone if available,
+* Uses the `timezone_string` option to get a proper timezone name if available,
-* otherwise falls back to an offset.
+* otherwise falls back to a manual UTC ± offset.
+*
+* Example return values:
+*
+*  - 'Europe/Rome'
+*  - 'America/North_Dakota/New_Salem'
+*  - 'UTC'
+*  - '-06:30'
+*  - '+00:00'
+*  - '+08:45'
 *
 * @since 5.3.0
 *
-* @return string PHP timezone string or a ±HH:MM offset.
+* @return string PHP timezone name or a ±HH:MM offset.
 */
 function wp_timezone_string() {
 	$timezone_string = get_option( 'timezone_string' );
 	if ( $timezone_string ) {
 	return $tz_offset;
 }
 /**
-* Retrieves the timezone from site settings as a `DateTimeZone` object.
+* Retrieves the timezone of the site as a `DateTimeZone` object.
 *
 * Timezone can be based on a PHP timezone string or a ±HH:MM offset.
 *
 * @since 5.3.0
 *
 function date_i18n( $format, $timestamp_with_offset = false, $gmt = false ) {
 	$timestamp = $timestamp_with_offset;
 	// If timestamp is omitted it should be current time (summed with offset, unless `$gmt` is true).
 	if ( ! is_numeric( $timestamp ) ) {
+		// phpcs:ignore WordPress.DateTime.CurrentTimeTimestamp.Requested
 		$timestamp = current_time( 'timestamp', $gmt );
 	}
 	/*
 	 * This is a legacy implementation quirk that the returned timestamp is also with offset.
 *
 * Note that, unlike `date_i18n()`, this function accepts a true Unix timestamp, not summed
 * with timezone offset.
 *
 * @since 5.3.0
+*
+* @global WP_Locale $wp_locale WordPress date and time locale object.
 *
 * @param string       $format    PHP date format.
 * @param int          $timestamp Optional. Unix timestamp. Defaults to current time.
 * @param DateTimeZone $timezone  Optional. Timezone to output result in. Defaults to timezone
 *                                from site settings.
 	 */
 	return apply_filters( 'number_format_i18n', $formatted, $number, $decimals );
 }
 /**
-* Convert number of bytes largest unit bytes will fit into.
+* Converts a number of bytes to the largest unit the bytes will fit into.
 *
 * It is easier to read 1 KB than 1024 bytes and 1 MB than 1048576 bytes. Converts
 * number of bytes to human readable number by taking the number of that unit
-* that the bytes will go into it. Supports TB value.
+* that the bytes will go into it. Supports YB value.
 *
 * Please note that integers in PHP are limited to 32 bits, unless they are on
 * 64 bit architecture, then they have 64 bit size. If you need to place the
 * larger size then what PHP integer type will hold, then use a string. It will
 * be converted to a double, which should always have 64 bit length.
 *
 * Technically the correct unit names for powers of 1024 are KiB, MiB etc.
 *
 * @since 2.3.0
+* @since 6.0.0 Support for PB, EB, ZB, and YB was added.
 *
 * @param int|string $bytes    Number of bytes. Note max integer size for integers.
 * @param int        $decimals Optional. Precision of number of decimal places. Default 0.
 * @return string|false Number string on success, false on failure.
 */
 function size_format( $bytes, $decimals = 0 ) {
 	$quant = array(
+		/* translators: Unit symbol for yottabyte. */
+		_x( 'YB', 'unit symbol' ) => YB_IN_BYTES,
+		/* translators: Unit symbol for zettabyte. */
+		_x( 'ZB', 'unit symbol' ) => ZB_IN_BYTES,
+		/* translators: Unit symbol for exabyte. */
+		_x( 'EB', 'unit symbol' ) => EB_IN_BYTES,
+		/* translators: Unit symbol for petabyte. */
+		_x( 'PB', 'unit symbol' ) => PB_IN_BYTES,
 		/* translators: Unit symbol for terabyte. */
 		_x( 'TB', 'unit symbol' ) => TB_IN_BYTES,
 		/* translators: Unit symbol for gigabyte. */
 		_x( 'GB', 'unit symbol' ) => GB_IN_BYTES,
 		/* translators: Unit symbol for megabyte. */
 *
 * @since 0.71
 *
 * @param string     $mysqlstring   Date or datetime field type from MySQL.
 * @param int|string $start_of_week Optional. Start of the week as an integer. Default empty string.
-* @return array Keys are 'start' and 'end'.
+* @return int[] {
+*     Week start and end dates as Unix timestamps.
+*
+*     @type int $start The week start date as a Unix timestamp.
+*     @type int $end   The week end date as a Unix timestamp.
+* }
 */
 function get_weekstartend( $mysqlstring, $start_of_week = '' ) {
 	// MySQL string year.
 	$my = substr( $mysqlstring, 0, 4 );
 /**
 * Use RegEx to extract URLs from arbitrary content.
 *
 * @since 3.7.0
+* @since 6.0.0 Fixes support for HTML entities (Trac 30580).
 *
 * @param string $content Content to extract URLs from.
 * @return string[] Array of URLs found in passed string.
 */
 function wp_extract_urls( $content ) {
 			. '[^\s()<>]+'
 			. '[.]'
 			. '(?:'
 				. '\([\w\d]+\)|'
 				. '(?:'
-					. "[^`!()\[\]{};:'\".,<>«»“”‘’\s]|"
+					. "[^`!()\[\]{}:'\".,<>«»“”‘’\s]|"
 					. '(?:[:]\d+)?/?'
 				. ')+'
 			. ')'
 		. ")\\1#",
 		$content,
 		$post_links
 	);
-	$post_links = array_unique( array_map( 'html_entity_decode', $post_links[2] ) );
+	$post_links = array_unique(
+		array_map(
+			static function( $link ) {
+				// Decode to replace valid entities, like &amp;.
+				$link = html_entity_decode( $link );
+				// Maintain backward compatibility by removing extraneous semi-colons (`;`).
+				return str_replace( ';', '', $link );
+			},
+			$post_links[2]
+		)
+	);
 	return array_values( $post_links );
 }
 /**
 	$ret = build_query( $qs );
 	$ret = trim( $ret, '?' );
 	$ret = preg_replace( '#=(&|$)#', '$1', $ret );
 	$ret = $protocol . $base . $ret . $frag;
 	$ret = rtrim( $ret, '?' );
+	$ret = str_replace( '?#', '#', $ret );
 	return $ret;
 }
 /**
 * Removes an item or items from a query string.
 * Must be 'y' to be true.
 *
 * @since 1.0.0
 *
 * @param string $yn Character string containing either 'y' (yes) or 'n' (no).
-* @return bool True if yes, false on anything else.
+* @return bool True if 'y', false on anything else.
 */
 function bool_from_yn( $yn ) {
 	return ( 'y' === strtolower( $yn ) );
 }
 	if ( '' === $feed || 'feed' === $feed ) {
 		$feed = get_default_feed();
 	}
 	if ( ! has_action( "do_feed_{$feed}" ) ) {
-		wp_die( __( 'Error: This is not a valid feed template.' ), '', array( 'response' => 404 ) );
+		wp_die( __( '<strong>Error</strong>: This is not a valid feed template.' ), '', array( 'response' => 404 ) );
 	}
 	/**
 	 * Fires once the given feed is loaded.
 	 *
 		list( $wrapper, $path ) = explode( '://', $path, 2 );
 		$wrapper .= '://';
 	}
-	// Standardise all paths to use '/'.
+	// Standardize all paths to use '/'.
 	$path = str_replace( '\\', '/', $path );
 	// Replace multiple slashes down to a singular, allowing for network shares having two slashes.
 	$path = preg_replace( '|(?<=.)/+|', '/', $path );
 			// At this point the file name may not be unique. This is tested below and the $number is incremented.
 			$filename = str_replace( "{$fname}{$ext}", "{$fname}-{$number}{$ext}", $filename );
 		}
-		// Get the mime type. Uploaded files were already checked with wp_check_filetype_and_ext()
+		/*
-		// in _wp_handle_upload(). Using wp_check_filetype() would be sufficient here.
+		 * Get the mime type. Uploaded files were already checked with wp_check_filetype_and_ext()
+		 * in _wp_handle_upload(). Using wp_check_filetype() would be sufficient here.
+		 */
 		$file_type = wp_check_filetype( $filename );
 		$mime_type = $file_type['type'];
 		$is_image    = ( ! empty( $mime_type ) && 0 === strpos( $mime_type, 'image/' ) );
 		$upload_dir  = wp_get_upload_dir();
 		$lc_filename = null;
 		$lc_ext = strtolower( $ext );
 		$_dir   = trailingslashit( $dir );
-		// If the extension is uppercase add an alternate file name with lowercase extension. Both need to be tested
+		/*
-		// for uniqueness as the extension will be changed to lowercase for better compatibility with different filesystems.
+		 * If the extension is uppercase add an alternate file name with lowercase extension.
-		// Fixes an inconsistency in WP < 2.9 where uppercase extensions were allowed but image sub-sizes were created with
+		 * Both need to be tested for uniqueness as the extension will be changed to lowercase
-		// lowercase extensions.
+		 * for better compatibility with different filesystems. Fixes an inconsistency in WP < 2.9
+		 * where uppercase extensions were allowed but image sub-sizes were created with
+		 * lowercase extensions.
+		 */
 		if ( $ext && $lc_ext !== $ext ) {
 			$lc_filename = preg_replace( '|' . preg_quote( $ext ) . '$|', $lc_ext, $filename );
 		}
-		// Increment the number added to the file name if there are any files in $dir whose names match one of the
+		/*
-		// possible name variations.
+		 * Increment the number added to the file name if there are any files in $dir
+		 * whose names match one of the possible name variations.
+		 */
 		while ( file_exists( $_dir . $filename ) || ( $lc_filename && file_exists( $_dir . $lc_filename ) ) ) {
 			$new_number = (int) $number + 1;
 			if ( $lc_filename ) {
-				$lc_filename = str_replace( array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ), "-{$new_number}{$lc_ext}", $lc_filename );
+				$lc_filename = str_replace(
+					array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ),
+					"-{$new_number}{$lc_ext}",
+					$lc_filename
+				);
 			}
 			if ( '' === "{$number}{$ext}" ) {
 				$filename = "{$filename}-{$new_number}";
 			} else {
-				$filename = str_replace( array( "-{$number}{$ext}", "{$number}{$ext}" ), "-{$new_number}{$ext}", $filename );
+				$filename = str_replace(
+					array( "-{$number}{$ext}", "{$number}{$ext}" ),
+					"-{$new_number}{$ext}",
+					$filename
+				);
 			}
 			$number = $new_number;
 		}
 		// Change the extension to lowercase if needed.
 		if ( $lc_filename ) {
 			$filename = $lc_filename;
 		}
-		// Prevent collisions with existing file names that contain dimension-like strings
+		/*
-		// (whether they are subsizes or originals uploaded prior to #42437).
+		 * Prevent collisions with existing file names that contain dimension-like strings
+		 * (whether they are subsizes or originals uploaded prior to #42437).
+		 */
 		$files = array();
 		$count = 10000;
 		// The (resized) image files would have name and extension, and will be in the uploads dir.
 			}
 			if ( ! empty( $files ) ) {
 				$count = count( $files );
-				// Ensure this never goes into infinite loop
+				/*
-				// as it uses pathinfo() and regex in the check, but string replacement for the changes.
+				 * Ensure this never goes into infinite loop as it uses pathinfo() and regex in the check,
+				 * but string replacement for the changes.
+				 */
 				$i = 0;
 				while ( $i <= $count && _wp_check_existing_file_names( $filename, $files ) ) {
 					$new_number = (int) $number + 1;
 					// If $ext is uppercase it was replaced with the lowercase version after the previous loop.
-					$filename = str_replace( array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ), "-{$new_number}{$lc_ext}", $filename );
+					$filename = str_replace(
+						array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ),
+						"-{$new_number}{$lc_ext}",
+						$filename
+					);
 					$number = $new_number;
 					$i++;
 				}
 			}
 		}
-		// Check if an image will be converted after uploading or some existing images sub-sizes file names may conflict
+		/*
-		// when regenerated. If yes, ensure the new file name will be unique and will produce unique sub-sizes.
+		 * Check if an image will be converted after uploading or some existing image sub-size file names may conflict
+		 * when regenerated. If yes, ensure the new file name will be unique and will produce unique sub-sizes.
+		 */
 		if ( $is_image ) {
+			/** This filter is documented in wp-includes/class-wp-image-editor.php */
 			$output_formats = apply_filters( 'image_editor_output_format', array(), $_dir . $filename, $mime_type );
 			$alt_types      = array();
 			if ( ! empty( $output_formats[ $mime_type ] ) ) {
 				// The image will be converted to this format/mime type.
 				$alt_filenames[ $alt_ext ] = $alt_filename;
 			}
 			if ( ! empty( $alt_filenames ) ) {
-				// Add the original filename. It needs to be checked again together with the alternate filenames
+				/*
-				// when $number is incremented.
+				 * Add the original filename. It needs to be checked again
+				 * together with the alternate filenames when $number is incremented.
+				 */
 				$alt_filenames[ $lc_ext ] = $filename;
 				// Ensure no infinite loop.
 				$i = 0;
 				while ( $i <= $count && _wp_check_alternate_file_names( $alt_filenames, $_dir, $files ) ) {
 					$new_number = (int) $number + 1;
 					foreach ( $alt_filenames as $alt_ext => $alt_filename ) {
-						$alt_filenames[ $alt_ext ] = str_replace( array( "-{$number}{$alt_ext}", "{$number}{$alt_ext}" ), "-{$new_number}{$alt_ext}", $alt_filename );
+						$alt_filenames[ $alt_ext ] = str_replace(
+							array( "-{$number}{$alt_ext}", "{$number}{$alt_ext}" ),
+							"-{$new_number}{$alt_ext}",
+							$alt_filename
+						);
 					}
-					// Also update the $number in (the output) $filename.
+					/*
-					// If the extension was uppercase it was already replaced with the lowercase version.
+					 * Also update the $number in (the output) $filename.
-					$filename = str_replace( array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ), "-{$new_number}{$lc_ext}", $filename );
+					 * If the extension was uppercase it was already replaced with the lowercase version.
+					 */
+					$filename = str_replace(
+						array( "-{$number}{$lc_ext}", "{$number}{$lc_ext}" ),
+						"-{$new_number}{$lc_ext}",
+						$filename
+					);
 					$number = $new_number;
 					$i++;
 				}
 			}
 	 *
 	 * @since 4.5.0
 	 * @since 5.8.1 The `$alt_filenames` and `$number` parameters were added.
 	 *
 	 * @param string        $filename                 Unique file name.
-	 * @param string        $ext                      File extension, eg. ".png".
+	 * @param string        $ext                      File extension. Example: ".png".
 	 * @param string        $dir                      Directory path.
 	 * @param callable|null $unique_filename_callback Callback function that generates the unique file name.
 	 * @param string[]      $alt_filenames            Array of alternate file names that were checked for collisions.
 	 * @param int|string    $number                   The highest number that was used to make the file name unique
 	 *                                                or an empty string if unused.
 		return array( 'error' => __( 'Empty filename' ) );
 	}
 	$wp_filetype = wp_check_filetype( $name );
 	if ( ! $wp_filetype['ext'] && ! current_user_can( 'unfiltered_upload' ) ) {
-		return array( 'error' => __( 'Sorry, this file type is not permitted for security reasons.' ) );
+		return array( 'error' => __( 'Sorry, you are not allowed to upload this file type.' ) );
 	}
 	$upload = wp_upload_dir( $time );
 	if ( false !== $upload['error'] ) {
 * @return string|false The actual mime type or false if the type cannot be determined.
 */
 function wp_get_image_mime( $file ) {
 	/*
 	 * Use exif_imagetype() to check the mimetype if available or fall back to
-	 * getimagesize() if exif isn't avaialbe. If either function throws an Exception
+	 * getimagesize() if exif isn't available. If either function throws an Exception
 	 * we assume the file could not be validated.
 	 */
 	try {
 		if ( is_callable( 'exif_imagetype' ) ) {
 			$imagetype = exif_imagetype( $file );
 		if ( false !== $mime ) {
 			return $mime;
 		}
-		$handle = fopen( $file, 'rb' );
+		$magic = file_get_contents( $file, false, null, 0, 12 );
-		if ( false === $handle ) {
-			return false;
-		}
-		$magic = fread( $handle, 12 );
 		if ( false === $magic ) {
 			return false;
 		}
 		/*
 			// WEBP.
 			( 16 === strpos( $magic, '57454250' ) )
 		) {
 			$mime = 'image/webp';
 		}
-		fclose( $handle );
 	} catch ( Exception $e ) {
 		$mime = false;
 	}
 	return $mime;
 		)
 	);
 }
 /**
+* Wrapper for PHP filesize with filters and casting the result as an integer.
+*
+* @since 6.0.0
+*
+* @link https://www.php.net/manual/en/function.filesize.php
+*
+* @param string $path Path to the file.
+* @return int The size of the file in bytes, or 0 in the event of an error.
+*/
+function wp_filesize( $path ) {
+	/**
+	 * Filters the result of wp_filesize before the PHP function is run.
+	 *
+	 * @since 6.0.0
+	 *
+	 * @param null|int $size The unfiltered value. Returning an int from the callback bypasses the filesize call.
+	 * @param string   $path Path to the file.
+	 */
+	$size = apply_filters( 'pre_wp_filesize', null, $path );
+	if ( is_int( $size ) ) {
+		return $size;
+	}
+	$size = file_exists( $path ) ? (int) filesize( $path ) : 0;
+	/**
+	 * Filters the size of the file.
+	 *
+	 * @since 6.0.0
+	 *
+	 * @param int    $size The result of PHP filesize on the file.
+	 * @param string $path Path to the file.
+	 */
+	return (int) apply_filters( 'wp_filesize', $size, $path );
+}
+/**
 * Retrieve list of allowed mime types and file extensions.
 *
 * @since 2.8.6
 *
 * @param int|WP_User $user Optional. User to check. Defaults to current user.
 * @since 2.0.4
 *
 * @param string $action The nonce action.
 */
 function wp_nonce_ays( $action ) {
+	// Default title and response code.
+	$title         = __( 'Something went wrong.' );
+	$response_code = 403;
 	if ( 'log-out' === $action ) {
-		$html = sprintf(
+		$title = sprintf(
 			/* translators: %s: Site title. */
 			__( 'You are attempting to log out of %s' ),
 			get_bloginfo( 'name' )
 		);
+		$html        = $title;
 		$html       .= '</p><p>';
 		$redirect_to = isset( $_REQUEST['redirect_to'] ) ? $_REQUEST['redirect_to'] : '';
 		$html       .= sprintf(
 			/* translators: %s: Logout URL. */
 			__( 'Do you really want to <a href="%s">log out</a>?' ),
 				__( 'Please try again.' )
 			);
 		}
 	}
-	wp_die( $html, __( 'Something went wrong.' ), 403 );
+	wp_die( $html, $title, $response_code );
 }
 /**
 * Kills WordPress execution and displays HTML page with an error message.
 *
 		/**
 		 * Filters the callback for killing WordPress execution for Ajax requests.
 		 *
 		 * @since 3.4.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_ajax_handler', '_ajax_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_ajax_handler', '_ajax_wp_die_handler' );
 	} elseif ( wp_is_json_request() ) {
 		/**
 		 * Filters the callback for killing WordPress execution for JSON requests.
 		 *
 		 * @since 5.1.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_json_handler', '_json_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_json_handler', '_json_wp_die_handler' );
 	} elseif ( defined( 'REST_REQUEST' ) && REST_REQUEST && wp_is_jsonp_request() ) {
 		/**
 		 * Filters the callback for killing WordPress execution for JSONP REST requests.
 		 *
 		 * @since 5.2.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_jsonp_handler', '_jsonp_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_jsonp_handler', '_jsonp_wp_die_handler' );
 	} elseif ( defined( 'XMLRPC_REQUEST' ) && XMLRPC_REQUEST ) {
 		/**
 		 * Filters the callback for killing WordPress execution for XML-RPC requests.
 		 *
 		 * @since 3.4.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_xmlrpc_handler', '_xmlrpc_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_xmlrpc_handler', '_xmlrpc_wp_die_handler' );
 	} elseif ( wp_is_xml_request()
 		|| isset( $wp_query ) &&
 			( function_exists( 'is_feed' ) && is_feed()
 			|| function_exists( 'is_comment_feed' ) && is_comment_feed()
 			|| function_exists( 'is_trackback' ) && is_trackback() ) ) {
 		/**
 		 * Filters the callback for killing WordPress execution for XML requests.
 		 *
 		 * @since 5.2.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_xml_handler', '_xml_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_xml_handler', '_xml_wp_die_handler' );
 	} else {
 		/**
 		 * Filters the callback for killing WordPress execution for all non-Ajax, non-JSON, non-XML requests.
 		 *
 		 * @since 3.0.0
 		 *
-		 * @param callable $function Callback function name.
+		 * @param callable $callback Callback function name.
 		 */
-		$function = apply_filters( 'wp_die_handler', '_default_wp_die_handler' );
+		$callback = apply_filters( 'wp_die_handler', '_default_wp_die_handler' );
 	}
-	call_user_func( $function, $message, $title, $args );
+	call_user_func( $callback, $message, $title, $args );
 }
 /**
 * Kills WordPress execution and displays HTML page with an error message.
 *
 	return 0 === $illegal_char_count;
 }
 /**
+* Reads and decodes a JSON file.
+*
+* @since 5.9.0
+*
+* @param string $filename Path to the JSON file.
+* @param array  $options  {
+*     Optional. Options to be used with `json_decode()`.
+*
+*     @type bool $associative Optional. When `true`, JSON objects will be returned as associative arrays.
+*                             When `false`, JSON objects will be returned as objects.
+* }
+*
+* @return mixed Returns the value encoded in JSON in appropriate PHP type.
+*               `null` is returned if the file is not found, or its content can't be decoded.
+*/
+function wp_json_file_decode( $filename, $options = array() ) {
+	$result   = null;
+	$filename = wp_normalize_path( realpath( $filename ) );
+	if ( ! file_exists( $filename ) ) {
+		trigger_error(
+			sprintf(
+				/* translators: %s: Path to the JSON file. */
+				__( "File %s doesn't exist!" ),
+				$filename
+			)
+		);
+		return $result;
+	}
+	$options      = wp_parse_args( $options, array( 'associative' => false ) );
+	$decoded_file = json_decode( file_get_contents( $filename ), $options['associative'] );
+	if ( JSON_ERROR_NONE !== json_last_error() ) {
+		trigger_error(
+			sprintf(
+				/* translators: 1: Path to the JSON file, 2: Error message. */
+				__( 'Error when decoding a JSON file at path %1$s: %2$s' ),
+				$filename,
+				json_last_error_msg()
+			)
+		);
+		return $result;
+	}
+	return $decoded_file;
+}
+/**
 * Retrieve the WordPress home page URL.
 *
 * If the constant named 'WP_HOME' exists, then it will be used and returned
 * by the function. This can be used to counter the redirection on your local
 * development environment.
 * @access private
 *
 * @see WP_SITEURL
 *
 * @param string $url URL to set the WordPress site location.
-* @return string The WordPress Site URL.
+* @return string The WordPress site URL.
 */
 function _config_wp_siteurl( $url = '' ) {
 	if ( defined( 'WP_SITEURL' ) ) {
 		return untrailingslashit( WP_SITEURL );
 	}
 * If you want to retrieve a particular field from all matching objects,
 * use wp_filter_object_list() instead.
 *
 * @since 3.1.0
 * @since 4.7.0 Uses `WP_List_Util` class.
+* @since 5.9.0 Converted into a wrapper for `wp_filter_object_list()`.
 *
 * @param array  $list     An array of objects to filter.
 * @param array  $args     Optional. An array of key => value arguments to match
 *                         against each object. Default empty array.
 * @param string $operator Optional. The logical operation to perform. 'AND' means
 *                         one element needs to match. 'NOT' means no elements may
 *                         match. Default 'AND'.
 * @return array Array of found values.
 */
 function wp_list_filter( $list, $args = array(), $operator = 'AND' ) {
-	if ( ! is_array( $list ) ) {
+	return wp_filter_object_list( $list, $args, $operator );
-		return array();
+}
-	}
+/**
-	$util = new WP_List_Util( $list );
+* Plucks a certain field out of each object or array in an array.
-	return $util->filter( $args, $operator );
-}
-/**
-* Pluck a certain field out of each object in a list.
 *
 * This has the same functionality and prototype of
 * array_column() (PHP 5.5) but also supports objects.
 *
 * @since 3.1.0
 * @return array Array of found values. If `$index_key` is set, an array of found values with keys
 *               corresponding to `$index_key`. If `$index_key` is null, array keys from the original
 *               `$list` will be preserved in the results.
 */
 function wp_list_pluck( $list, $field, $index_key = null ) {
+	if ( ! is_array( $list ) ) {
+		return array();
+	}
 	$util = new WP_List_Util( $list );
 	return $util->pluck( $field, $index_key );
 }
 /**
-* Sorts a list of objects, based on one or more orderby arguments.
+* Sorts an array of objects or arrays based on one or more orderby arguments.
 *
 * @since 4.7.0
 *
 * @param array        $list          An array of objects to sort.
 * @param string|array $orderby       Optional. Either the field name to order by or an array
 /**
 * Append the Widgets menu to the themes main menu.
 *
 * @since 2.2.0
+* @since 5.9.3 Don't specify menu order when the active theme is a block theme.
 *
 * @global array $submenu
 */
 function wp_widgets_add_menu() {
 	global $submenu;
 	if ( ! current_theme_supports( 'widgets' ) ) {
 		return;
 	}
-	$submenu['themes.php'][7] = array( __( 'Widgets' ), 'edit_theme_options', 'widgets.php' );
+	$menu_name = __( 'Widgets' );
+	if ( wp_is_block_theme() ) {
+		$submenu['themes.php'][] = array( $menu_name, 'edit_theme_options', 'widgets.php' );
+	} else {
+		$submenu['themes.php'][7] = array( $menu_name, 'edit_theme_options', 'widgets.php' );
+	}
 	ksort( $submenu['themes.php'], SORT_NUMERIC );
 }
 /**
 * Flush all output buffers for PHP 5.2.
 		if ( function_exists( '__' ) ) {
 			if ( $replacement ) {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP function name, 2: Version number, 3: Alternative function name. */
-						__( '%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
+						__( 'Function %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
 						$function,
 						$version,
 						$replacement
 					),
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP function name, 2: Version number. */
-						__( '%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
+						__( 'Function %1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
 						$function,
 						$version
 					),
 					E_USER_DEPRECATED
 				);
 			}
 		} else {
 			if ( $replacement ) {
 				trigger_error(
 					sprintf(
-						'%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
+						'Function %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
 						$function,
 						$version,
 						$replacement
 					),
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
-						'%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.',
+						'Function %1$s is <strong>deprecated</strong> since version %2$s with no alternative available.',
 						$function,
 						$version
 					),
 					E_USER_DEPRECATED
 				);
 		if ( function_exists( '__' ) ) {
 			if ( $parent_class ) {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP class name, 2: PHP parent class name, 3: Version number, 4: __construct() method. */
-						__( 'The called constructor method for %1$s in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.' ),
+						__( 'The called constructor method for %1$s class in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.' ),
 						$class,
 						$parent_class,
 						$version,
 						'<code>__construct()</code>'
 					),
 				);
 			} else {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP class name, 2: Version number, 3: __construct() method. */
-						__( 'The called constructor method for %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
+						__( 'The called constructor method for %1$s class is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
 						$class,
 						$version,
 						'<code>__construct()</code>'
 					),
 					E_USER_DEPRECATED
 			}
 		} else {
 			if ( $parent_class ) {
 				trigger_error(
 					sprintf(
-						'The called constructor method for %1$s in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.',
+						'The called constructor method for %1$s class in %2$s is <strong>deprecated</strong> since version %3$s! Use %4$s instead.',
 						$class,
 						$parent_class,
 						$version,
 						'<code>__construct()</code>'
 					),
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
-						'The called constructor method for %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
+						'The called constructor method for %1$s class is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
 						$class,
 						$version,
 						'<code>__construct()</code>'
 					),
 					E_USER_DEPRECATED
 		if ( function_exists( '__' ) ) {
 			if ( $replacement ) {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP file name, 2: Version number, 3: Alternative file name. */
-						__( '%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
+						__( 'File %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
 						$file,
 						$version,
 						$replacement
 					) . $message,
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP file name, 2: Version number. */
-						__( '%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
+						__( 'File %1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
 						$file,
 						$version
 					) . $message,
 					E_USER_DEPRECATED
 				);
 			}
 		} else {
 			if ( $replacement ) {
 				trigger_error(
 					sprintf(
-						'%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
+						'File %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.',
 						$file,
 						$version,
 						$replacement
 					) . $message,
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
-						'%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.',
+						'File %1$s is <strong>deprecated</strong> since version %2$s with no alternative available.',
 						$file,
 						$version
 					) . $message,
 					E_USER_DEPRECATED
 				);
 		if ( function_exists( '__' ) ) {
 			if ( $message ) {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP function name, 2: Version number, 3: Optional message regarding the change. */
-						__( '%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s' ),
+						__( 'Function %1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s' ),
 						$function,
 						$version,
 						$message
 					),
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
 						/* translators: 1: PHP function name, 2: Version number. */
-						__( '%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
+						__( 'Function %1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
 						$function,
 						$version
 					),
 					E_USER_DEPRECATED
 				);
 			}
 		} else {
 			if ( $message ) {
 				trigger_error(
 					sprintf(
-						'%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s',
+						'Function %1$s was called with an argument that is <strong>deprecated</strong> since version %2$s! %3$s',
 						$function,
 						$version,
 						$message
 					),
 					E_USER_DEPRECATED
 				);
 			} else {
 				trigger_error(
 					sprintf(
-						'%1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.',
+						'Function %1$s was called with an argument that is <strong>deprecated</strong> since version %2$s with no alternative available.',
 						$function,
 						$version
 					),
 					E_USER_DEPRECATED
 				);
 		if ( $replacement ) {
 			trigger_error(
 				sprintf(
 					/* translators: 1: WordPress hook name, 2: Version number, 3: Alternative hook name. */
-					__( '%1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
+					__( 'Hook %1$s is <strong>deprecated</strong> since version %2$s! Use %3$s instead.' ),
 					$hook,
 					$version,
 					$replacement
 				) . $message,
 				E_USER_DEPRECATED
 			);
 		} else {
 			trigger_error(
 				sprintf(
 					/* translators: 1: WordPress hook name, 2: Version number. */
-					__( '%1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
+					__( 'Hook %1$s is <strong>deprecated</strong> since version %2$s with no alternative available.' ),
 					$hook,
 					$version
 				) . $message,
 				E_USER_DEPRECATED
 			);
 			);
 			trigger_error(
 				sprintf(
 					/* translators: Developer debugging message. 1: PHP function name, 2: Explanatory message, 3: WordPress version number. */
-					__( '%1$s was called <strong>incorrectly</strong>. %2$s %3$s' ),
+					__( 'Function %1$s was called <strong>incorrectly</strong>. %2$s %3$s' ),
 					$function,
 					$message,
 					$version
 				),
 				E_USER_NOTICE
 				'https://wordpress.org/support/article/debugging-in-wordpress/'
 			);
 			trigger_error(
 				sprintf(
-					'%1$s was called <strong>incorrectly</strong>. %2$s %3$s',
+					'Function %1$s was called <strong>incorrectly</strong>. %2$s %3$s',
 					$function,
 					$message,
 					$version
 				),
 				E_USER_NOTICE
 * @param string   $file          File path.
 * @param string[] $allowed_files Optional. Array of allowed files.
 * @return int 0 means nothing is wrong, greater than 0 means something was wrong.
 */
 function validate_file( $file, $allowed_files = array() ) {
+	if ( ! is_scalar( $file ) || '' === $file ) {
+		return 0;
+	}
 	// `../` on its own is not allowed:
 	if ( '../' === $file ) {
 		return 1;
 	}
-	// More than one occurence of `../` is not allowed:
+	// More than one occurrence of `../` is not allowed:
 	if ( preg_match_all( '#\.\./#', $file, $matches, PREG_SET_ORDER ) && ( count( $matches ) > 1 ) ) {
 		return 1;
 	}
 	// `../` which does not occur at the end of the path is not allowed:
 * @param string $context         Optional. If specified adds filter hook {@see 'extra_$context_headers'}.
 *                                Default empty.
 * @return string[] Array of file header values keyed by header name.
 */
 function get_file_data( $file, $default_headers, $context = '' ) {
-	// We don't need to write to the file, so just open for reading.
+	// Pull only the first 8 KB of the file in.
-	$fp = fopen( $file, 'r' );
+	$file_data = file_get_contents( $file, false, null, 0, 8 * KB_IN_BYTES );
-	if ( $fp ) {
+	if ( false === $file_data ) {
-		// Pull only the first 8 KB of the file in.
-		$file_data = fread( $fp, 8 * KB_IN_BYTES );
-		// PHP will close file handle, but we are good citizens.
-		fclose( $fp );
-	} else {
 		$file_data = '';
 	}
 	// Make sure we catch CR-only line endings.
 	$file_data = str_replace( "\r", "\n", $file_data );
 /**
 * Send a HTTP header to limit rendering of pages to same origin iframes.
 *
 * @since 3.1.3
 *
-* @see https://developer.mozilla.org/en/the_x-frame-options_response_header
+* @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
 */
 function send_frame_options_header() {
 	header( 'X-Frame-Options: SAMEORIGIN' );
 }
 	return $protocols;
 }
 /**
-* Return a comma-separated string of functions that have been called to get
+* Returns a comma-separated string or array of functions that have been called to get
 * to the current point in code.
 *
 * @since 3.4.0
 *
 * @see https://core.trac.wordpress.org/ticket/19589
 *
 * @param string $ignore_class Optional. A class to ignore all function calls within - useful
 *                             when you want to just give info about the callee. Default null.
 * @param int    $skip_frames  Optional. A number of stack frames to skip - useful for unwinding
 *                             back to the source of the issue. Default 0.
-* @param bool   $pretty       Optional. Whether or not you want a comma separated string or raw
+* @param bool   $pretty       Optional. Whether you want a comma separated string instead of
-*                             array returned. Default true.
+*                             the raw array returned. Default true.
 * @return string|array Either a string containing a reversed comma separated trace or an array
 *                      of individual calls.
 */
 function wp_debug_backtrace_summary( $ignore_class = null, $skip_frames = 0, $pretty = true ) {
 	static $truncate_paths;
 * @param bool   $ipv6_fallback Optional. Whether to return the original IPv6 address if the needed functions
 *                              to anonymize it are not present. Default false, return `::` (unspecified address).
 * @return string  The anonymized IP address.
 */
 function wp_privacy_anonymize_ip( $ip_addr, $ipv6_fallback = false ) {
+	if ( empty( $ip_addr ) ) {
+		return '0.0.0.0';
+	}
 	// Detect what kind of IP address this is.
 	$ip_prefix = '';
 	$is_ipv6   = substr_count( $ip_addr, ':' ) > 1;
 	$is_ipv4   = ( 3 === substr_count( $ip_addr, '.' ) );
 * @since MU (3.0.0)
 * @since 4.3.0 The `$exclude` parameter was added.
 * @since 5.2.0 The `$max_execution_time` parameter was added.
 * @since 5.6.0 The `$directory_cache` parameter was added.
 *
-* @param string       $directory          Full path of a directory.
+* @param string          $directory          Full path of a directory.
-* @param string|array $exclude            Optional. Full path of a subdirectory to exclude from the total,
+* @param string|string[] $exclude            Optional. Full path of a subdirectory to exclude from the total,
-*                                         or array of paths. Expected without trailing slash(es).
+*                                            or array of paths. Expected without trailing slash(es).
-* @param int          $max_execution_time Maximum time to run before giving up. In seconds. The timeout is global
+* @param int             $max_execution_time Optional. Maximum time to run before giving up. In seconds.
-*                                         and is measured from the moment WordPress started to load.
+*                                            The timeout is global and is measured from the moment
-* @param array        $directory_cache    Optional. Array of cached directory paths.
+*                                            WordPress started to load.
+* @param array           $directory_cache    Optional. Array of cached directory paths.
 *
 * @return int|false|null Size in bytes if a valid directory. False if not. Null if timeout.
 */
 function recurse_dirsize( $directory, $exclude = null, $max_execution_time = null, &$directory_cache = null ) {
 	$directory  = untrailingslashit( $directory );
 	 * Return the actual used space to short-circuit the recursive PHP file size calculation
 	 * and use something else, like a CDN API or native operating system tools for better performance.
 	 *
 	 * @since 5.6.0
 	 *
-	 * @param int|false $space_used The amount of used space, in bytes. Default false.
+	 * @param int|false            $space_used         The amount of used space, in bytes. Default false.
+	 * @param string               $directory          Full path of a directory.
+	 * @param string|string[]|null $exclude            Full path of a subdirectory to exclude from the total,
+	 *                                                 or array of paths.
+	 * @param int                  $max_execution_time Maximum time to run before giving up. In seconds.
+	 * @param array                $directory_cache    Array of cached directory paths.
 	 */
 	$size = apply_filters( 'pre_recurse_dirsize', false, $directory, $exclude, $max_execution_time, $directory_cache );
 	if ( false === $size ) {
 		$size = 0;
 						if ( $handlesize > 0 ) {
 							$size += $handlesize;
 						}
 					}
-					if ( $max_execution_time > 0 && microtime( true ) - WP_START_TIMESTAMP > $max_execution_time ) {
+					if ( $max_execution_time > 0 &&
+						( microtime( true ) - WP_START_TIMESTAMP ) > $max_execution_time
+					) {
 						// Time exceeded. Give up instead of risking a fatal timeout.
 						$size = null;
 						break;
 					}
 				}
 			}
 			closedir( $handle );
 		}
 	}
+	if ( ! is_array( $directory_cache ) ) {
+		$directory_cache = array();
+	}
 	$directory_cache[ $directory ] = $size;
 	// Only write the transient on the top level call and not on recursive calls.
 	if ( $save_cache ) {
 		set_transient( 'dirsize_cache', $directory_cache );
 * Cleans directory size cache used by recurse_dirsize().
 *
 * Removes the current directory and all parent directories from the `dirsize_cache` transient.
 *
 * @since 5.6.0
+* @since 5.9.0 Added input validation with a notice for invalid input.
 *
 * @param string $path Full path of a directory or file.
 */
 function clean_dirsize_cache( $path ) {
+	if ( ! is_string( $path ) || empty( $path ) ) {
+		trigger_error(
+			sprintf(
+				/* translators: 1: Function name, 2: A variable type, like "boolean" or "integer". */
+				__( '%1$s only accepts a non-empty path string, received %2$s.' ),
+				'<code>clean_dirsize_cache()</code>',
+				'<code>' . gettype( $path ) . '</code>'
+			)
+		);
+		return;
+	}
 	$directory_cache = get_transient( 'dirsize_cache' );
 	if ( empty( $directory_cache ) ) {
 		return;
 	}
-	$path = untrailingslashit( $path );
+	if (
+		strpos( $path, '/' ) === false &&
+		strpos( $path, '\\' ) === false
+	) {
+		unset( $directory_cache[ $path ] );
+		set_transient( 'dirsize_cache', $directory_cache );
+		return;
+	}
+	$last_path = null;
+	$path      = untrailingslashit( $path );
 	unset( $directory_cache[ $path ] );
-	while ( DIRECTORY_SEPARATOR !== $path && '.' !== $path && '..' !== $path ) {
+	while (
-		$path = dirname( $path );
+		$last_path !== $path &&
+		DIRECTORY_SEPARATOR !== $path &&
+		'.' !== $path &&
+		'..' !== $path
+	) {
+		$last_path = $path;
+		$path      = dirname( $path );
 		unset( $directory_cache[ $path ] );
 	}
 	set_transient( 'dirsize_cache', $directory_cache );
 }
 /**
 * Checks compatibility with the current WordPress version.
 *
 * @since 5.2.0
+*
+* @global string $wp_version The WordPress version string.
 *
 * @param string $required Minimum required WordPress version.
 * @return bool True if required version is compatible or empty, false if not.
 */
 function is_wp_version_compatible( $required ) {
-	return empty( $required ) || version_compare( get_bloginfo( 'version' ), $required, '>=' );
+	global $wp_version;
+	// Strip off any -alpha, -RC, -beta, -src suffixes.
+	list( $version ) = explode( '-', $wp_version );
+	return empty( $required ) || version_compare( $version, $required, '>=' );
 }
 /**
 * Checks compatibility with the current PHP version.
 *
 function is_php_version_compatible( $required ) {
 	return empty( $required ) || version_compare( phpversion(), $required, '>=' );
 }
 /**
-* Check if two numbers are nearly the same.
+* Checks if two numbers are nearly the same.
 *
 * This is similar to using `round()` but the precision is more fine-grained.
 *
 * @since 5.3.0
 *
 * @param int|float $expected  The expected value.
 * @param int|float $actual    The actual number.
 * @param int|float $precision The allowed variation.
-* @return bool Whether the numbers match whithin the specified precision.
+* @return bool Whether the numbers match within the specified precision.
 */
 function wp_fuzzy_number_match( $expected, $actual, $precision = 1 ) {
 	return abs( (float) $expected - (float) $actual ) <= $precision;
 }
+/**
+* Sorts the keys of an array alphabetically.
+* The array is passed by reference so it doesn't get returned
+* which mimics the behaviour of ksort.
+*
+* @since 6.0.0
+*
+* @param array $array The array to sort, passed by reference.
+*/
+function wp_recursive_ksort( &$array ) {
+	foreach ( $array as &$value ) {
+		if ( is_array( $value ) ) {
+			wp_recursive_ksort( $value );
+		}
+	}
+	ksort( $array );
+}

changeset 19	3d72ae0968f4
parent 18	be944660c56a
child 21	48c4eec2b7e6