/**
 * REST API: WP_REST_Attachments_Controller class
 *
 * @package WordPress
 * @subpackage REST_API
 * @since 4.7.0
 */

/**
 * Core controller used to access attachments via the REST API.
 *
 * @since 4.7.0
 *
 * @see WP_REST_Posts_Controller
 */
class WP_REST_Attachments_Controller extends WP_REST_Posts_Controller {

	/**
	 * Whether the controller supports batching.
	 *
	 * @since 5.9.0
	 * @var false
	 */
	protected $allow_batch = false;

	/**
	 * Registers the routes for attachments.
	 *
	 * @since 5.3.0
	 *
	 * @see register_rest_route()
	 */
	public function register_routes() {
		parent::register_routes();
		register_rest_route(
			$this->namespace,
			'/' . $this->rest_base . '/(?P<id>[\d]+)/post-process',
			array(
				'methods'             => WP_REST_Server::CREATABLE,
				'callback'            => array( $this, 'post_process_item' ),
				'permission_callback' => array( $this, 'post_process_item_permissions_check' ),
				'args'                => array(
					'id'     => array(
						'description' => __( 'Unique identifier for the attachment.' ),
						'type'        => 'integer',
					),
					'action' => array(
						'type'     => 'string',
						'enum'     => array( 'create-image-subsizes' ),
						'required' => true,
					),
				),
			)
		);
		register_rest_route(
			$this->namespace,
			'/' . $this->rest_base . '/(?P<id>[\d]+)/edit',
			array(
				'methods'             => WP_REST_Server::CREATABLE,
				'callback'            => array( $this, 'edit_media_item' ),
				'permission_callback' => array( $this, 'edit_media_item_permissions_check' ),
				'args'                => $this->get_edit_media_item_args(),
			)
		);
	}

	/**
	 * Determines the allowed query_vars for a get_items() response and
	 * prepares for WP_Query.
	 *
	 * @since 4.7.0
	 *
	 * @param array           $prepared_args Optional. Array of prepared arguments. Default empty array.
	 * @param WP_REST_Request $request       Optional. Request to prepare items for.
	 * @return array Array of query arguments.
	 */
	protected function prepare_items_query( $prepared_args = array(), $request = null ) {
		$query_args = parent::prepare_items_query( $prepared_args, $request );

		if ( empty( $query_args['post_status'] ) ) {
			$query_args['post_status'] = 'inherit';
		}

		$media_types = $this->get_media_types();

		if ( ! empty( $request['media_type'] ) && isset( $media_types[ $request['media_type'] ] ) ) {
			$query_args['post_mime_type'] = $media_types[ $request['media_type'] ];
		}

		if ( ! empty( $request['mime_type'] ) ) {
			$parts = explode( '/', $request['mime_type'] );
			if ( isset( $media_types[ $parts[0] ] ) && in_array( $request['mime_type'], $media_types[ $parts[0] ], true ) ) {
				$query_args['post_mime_type'] = $request['mime_type'];
			}
		}

		// Filter query clauses to include filenames.
		if ( isset( $query_args['s'] ) ) {
			add_filter( 'wp_allow_query_attachment_by_filename', '__return_true' );
		}

		return $query_args;
	}

	/**
	 * Checks if a given request has access to create an attachment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error Boolean true if the attachment may be created, or a WP_Error if not.
	 */
	public function create_item_permissions_check( $request ) {
		$ret = parent::create_item_permissions_check( $request );

		if ( ! $ret || is_wp_error( $ret ) ) {
			return $ret;
		}

		if ( ! current_user_can( 'upload_files' ) ) {
			return new WP_Error(
				'rest_cannot_create',
				__( 'Sorry, you are not allowed to upload media on this site.' ),
				array( 'status' => 400 )
			);
		}

		// Attaching media to a post requires ability to edit said post.
		if ( ! empty( $request['post'] ) && ! current_user_can( 'edit_post', (int) $request['post'] ) ) {
			return new WP_Error(
				'rest_cannot_edit',
				__( 'Sorry, you are not allowed to upload media to this post.' ),
				array( 'status' => rest_authorization_required_code() )
			);
		}

		return true;
	}

	/**
	 * Creates a single attachment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, WP_Error object on failure.
	 */
	public function create_item( $request ) {
		if ( ! empty( $request['post'] ) && in_array( get_post_type( $request['post'] ), array( 'revision', 'attachment' ), true ) ) {
			return new WP_Error(
				'rest_invalid_param',
				__( 'Invalid parent type.' ),
				array( 'status' => 400 )
			);
		}

		$insert = $this->insert_attachment( $request );

		if ( is_wp_error( $insert ) ) {
			return $insert;
		}

		$schema = $this->get_item_schema();

		// Extract by name.
		$attachment_id = $insert['attachment_id'];
		$file          = $insert['file'];

		if ( isset( $request['alt_text'] ) ) {
			update_post_meta( $attachment_id, '_wp_attachment_image_alt', sanitize_text_field( $request['alt_text'] ) );
		}

		if ( ! empty( $schema['properties']['featured_media'] ) && isset( $request['featured_media'] ) ) {
			$thumbnail_update = $this->handle_featured_media( $request['featured_media'], $attachment_id );

			if ( is_wp_error( $thumbnail_update ) ) {
				return $thumbnail_update;
			}
		}

		if ( ! empty( $schema['properties']['meta'] ) && isset( $request['meta'] ) ) {
			$meta_update = $this->meta->update_value( $request['meta'], $attachment_id );

			if ( is_wp_error( $meta_update ) ) {
				return $meta_update;
			}
		}

		$attachment    = get_post( $attachment_id );
		$fields_update = $this->update_additional_fields_for_object( $attachment, $request );

		if ( is_wp_error( $fields_update ) ) {
			return $fields_update;
		}

		$terms_update = $this->handle_terms( $attachment_id, $request );

		if ( is_wp_error( $terms_update ) ) {
			return $terms_update;
		}

		$request->set_param( 'context', 'edit' );

		/**
		 * Fires after a single attachment is completely created or updated via the REST API.
		 *
		 * @since 5.0.0
		 *
		 * @param WP_Post         $attachment Inserted or updated attachment object.
		 * @param WP_REST_Request $request    Request object.
		 * @param bool            $creating   True when creating an attachment, false when updating.
		 */
		do_action( 'rest_after_insert_attachment', $attachment, $request, true );

		wp_after_insert_post( $attachment, false, null );

		if ( wp_is_serving_rest_request() ) {
			/*
			 * Set a custom header with the attachment_id.
			 * Used by the browser/client to resume creating image sub-sizes after a PHP fatal error.
			 */
			header( 'X-WP-Upload-Attachment-ID: ' . $attachment_id );
		}

		// Include media and image functions to get access to wp_generate_attachment_metadata().
		require_once ABSPATH . 'wp-admin/includes/media.php';
		require_once ABSPATH . 'wp-admin/includes/image.php';

		/*
		 * Post-process the upload (create image sub-sizes, make PDF thumbnails, etc.) and insert attachment meta.
		 * At this point the server may run out of resources and post-processing of uploaded images may fail.
		 */
		wp_update_attachment_metadata( $attachment_id, wp_generate_attachment_metadata( $attachment_id, $file ) );

		$response = $this->prepare_item_for_response( $attachment, $request );
		$response = rest_ensure_response( $response );
		$response->set_status( 201 );
		$response->header( 'Location', rest_url( sprintf( '%s/%s/%d', $this->namespace, $this->rest_base, $attachment_id ) ) );

		return $response;
	}

	/**
	 * Inserts the attachment post in the database. Does not update the attachment meta.
	 *
	 * @since 5.3.0
	 *
	 * @param WP_REST_Request $request
	 * @return array|WP_Error
	 */
	protected function insert_attachment( $request ) {
		// Get the file via $_FILES or raw data.
		$files   = $request->get_file_params();
		$headers = $request->get_headers();

		$time = null;

		// Matches logic in media_handle_upload().
		if ( ! empty( $request['post'] ) ) {
			$post = get_post( $request['post'] );
			// The post date doesn't usually matter for pages, so don't backdate this upload.
			if ( $post && 'page' !== $post->post_type && substr( $post->post_date, 0, 4 ) > 0 ) {
				$time = $post->post_date;
			}
		}

		if ( ! empty( $files ) ) {
			$file = $this->upload_from_file( $files, $headers, $time );
		} else {
			$file = $this->upload_from_data( $request->get_body(), $headers, $time );
		}

		if ( is_wp_error( $file ) ) {
			return $file;
		}

		$name       = wp_basename( $file['file'] );
		$name_parts = pathinfo( $name );
		$name       = trim( substr( $name, 0, -( 1 + strlen( $name_parts['extension'] ) ) ) );

		$url  = $file['url'];
		$type = $file['type'];
		$file = $file['file'];

		// Include image functions to get access to wp_read_image_metadata().
		require_once ABSPATH . 'wp-admin/includes/image.php';

		// Use image exif/iptc data for title and caption defaults if possible.
		$image_meta = wp_read_image_metadata( $file );

		if ( ! empty( $image_meta ) ) {
			if ( empty( $request['title'] ) && trim( $image_meta['title'] ) && ! is_numeric( sanitize_title( $image_meta['title'] ) ) ) {
				$request['title'] = $image_meta['title'];
			}

			if ( empty( $request['caption'] ) && trim( $image_meta['caption'] ) ) {
				$request['caption'] = $image_meta['caption'];
			}
		}

		$attachment = $this->prepare_item_for_database( $request );

		$attachment->post_mime_type = $type;
		$attachment->guid           = $url;

		// If the title was not set, use the original filename.
		if ( empty( $attachment->post_title ) && ! empty( $files['file']['name'] ) ) {
			// Remove the file extension (after the last `.`)
			$tmp_title = substr( $files['file']['name'], 0, strrpos( $files['file']['name'], '.' ) );

			if ( ! empty( $tmp_title ) ) {
				$attachment->post_title = $tmp_title;
			}
		}

		// Fall back to the original approach.
		if ( empty( $attachment->post_title ) ) {
			$attachment->post_title = preg_replace( '/\.[^.]+$/', '', wp_basename( $file ) );
		}

		// $post_parent is inherited from $attachment['post_parent'].
		$id = wp_insert_attachment( wp_slash( (array) $attachment ), $file, 0, true, false );

		if ( is_wp_error( $id ) ) {
			if ( 'db_update_error' === $id->get_error_code() ) {
				$id->add_data( array( 'status' => 500 ) );
			} else {
				$id->add_data( array( 'status' => 400 ) );
			}

			return $id;
		}

		$attachment = get_post( $id );

		/**
		 * Fires after a single attachment is created or updated via the REST API.
		 *
		 * @since 4.7.0
		 *
		 * @param WP_Post         $attachment Inserted or updated attachment
		 *                                    object.
		 * @param WP_REST_Request $request    The request sent to the API.
		 * @param bool            $creating   True when creating an attachment, false when updating.
		 */
		do_action( 'rest_insert_attachment', $attachment, $request, true );

		return array(
			'attachment_id' => $id,
			'file'          => $file,
		);
	}

	/**
	 * Determines the featured media based on a request param.
	 *
	 * @since 6.5.0
	 *
	 * @param int $featured_media Featured Media ID.
	 * @param int $post_id        Post ID.
	 * @return bool|WP_Error Whether the post thumbnail was successfully deleted, otherwise WP_Error.
	 */
	protected function handle_featured_media( $featured_media, $post_id ) {
		$post_type         = get_post_type( $post_id );
		$thumbnail_support = current_theme_supports( 'post-thumbnails', $post_type ) && post_type_supports( $post_type, 'thumbnail' );

		// Similar check as in wp_insert_post().
		if ( ! $thumbnail_support && get_post_mime_type( $post_id ) ) {
			if ( wp_attachment_is( 'audio', $post_id ) ) {
				$thumbnail_support = post_type_supports( 'attachment:audio', 'thumbnail' ) || current_theme_supports( 'post-thumbnails', 'attachment:audio' );
			} elseif ( wp_attachment_is( 'video', $post_id ) ) {
				$thumbnail_support = post_type_supports( 'attachment:video', 'thumbnail' ) || current_theme_supports( 'post-thumbnails', 'attachment:video' );
			}
		}

		if ( $thumbnail_support ) {
			return parent::handle_featured_media( $featured_media, $post_id );
		}

		return new WP_Error(
			'rest_no_featured_media',
			sprintf(
				/* translators: %s: attachment mime type */
				__( 'This site does not support post thumbnails on attachments with MIME type %s.' ),
				get_post_mime_type( $post_id )
			),
			array( 'status' => 400 )
		);
	}

	/**
	 * Updates a single attachment.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, WP_Error object on failure.
	 */
	public function update_item( $request ) {
		if ( ! empty( $request['post'] ) && in_array( get_post_type( $request['post'] ), array( 'revision', 'attachment' ), true ) ) {
			return new WP_Error(
				'rest_invalid_param',
				__( 'Invalid parent type.' ),
				array( 'status' => 400 )
			);
		}

		$attachment_before = get_post( $request['id'] );
		$response          = parent::update_item( $request );

		if ( is_wp_error( $response ) ) {
			return $response;
		}

		$response = rest_ensure_response( $response );
		$data     = $response->get_data();

		if ( isset( $request['alt_text'] ) ) {
			update_post_meta( $data['id'], '_wp_attachment_image_alt', $request['alt_text'] );
		}

		$attachment = get_post( $request['id'] );

		if ( ! empty( $schema['properties']['featured_media'] ) && isset( $request['featured_media'] ) ) {
			$thumbnail_update = $this->handle_featured_media( $request['featured_media'], $attachment->ID );

			if ( is_wp_error( $thumbnail_update ) ) {
				return $thumbnail_update;
			}
		}

		$fields_update = $this->update_additional_fields_for_object( $attachment, $request );

		if ( is_wp_error( $fields_update ) ) {
			return $fields_update;
		}

		$request->set_param( 'context', 'edit' );

		/** This action is documented in wp-includes/rest-api/endpoints/class-wp-rest-attachments-controller.php */
		do_action( 'rest_after_insert_attachment', $attachment, $request, false );

		wp_after_insert_post( $attachment, true, $attachment_before );

		$response = $this->prepare_item_for_response( $attachment, $request );
		$response = rest_ensure_response( $response );

		return $response;
	}

	/**
	 * Performs post processing on an attachment.
	 *
	 * @since 5.3.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, WP_Error object on failure.
	 */
	public function post_process_item( $request ) {
		switch ( $request['action'] ) {
			case 'create-image-subsizes':
				require_once ABSPATH . 'wp-admin/includes/image.php';
				wp_update_image_subsizes( $request['id'] );
				break;
		}

		$request['context'] = 'edit';

		return $this->prepare_item_for_response( get_post( $request['id'] ), $request );
	}

	/**
	 * Checks if a given request can perform post processing on an attachment.
	 *
	 * @since 5.3.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has access to update the item, WP_Error object otherwise.
	 */
	public function post_process_item_permissions_check( $request ) {
		return $this->update_item_permissions_check( $request );
	}

	/**
	 * Checks if a given request has access to editing media.
	 *
	 * @since 5.5.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return true|WP_Error True if the request has read access, WP_Error object otherwise.
	 */
	public function edit_media_item_permissions_check( $request ) {
		if ( ! current_user_can( 'upload_files' ) ) {
			return new WP_Error(
				'rest_cannot_edit_image',
				__( 'Sorry, you are not allowed to upload media on this site.' ),
				array( 'status' => rest_authorization_required_code() )
			);
		}

		return $this->update_item_permissions_check( $request );
	}

	/**
	 * Applies edits to a media item and creates a new attachment record.
	 *
	 * @since 5.5.0
	 *
	 * @param WP_REST_Request $request Full details about the request.
	 * @return WP_REST_Response|WP_Error Response object on success, WP_Error object on failure.
	 */
	public function edit_media_item( $request ) {
		require_once ABSPATH . 'wp-admin/includes/image.php';

		$attachment_id = $request['id'];

		// This also confirms the attachment is an image.
		$image_file = wp_get_original_image_path( $attachment_id );
		$image_meta = wp_get_attachment_metadata( $attachment_id );

		if (
			! $image_meta ||
			! $image_file ||
			! wp_image_file_matches_image_meta( $request['src'], $image_meta, $attachment_id )
		) {
			return new WP_Error(
				'rest_unknown_attachment',
				__( 'Unable to get meta information for file.' ),
				array( 'status' => 404 )
			);
		}

		$supported_types = array( 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/avif' );
		$mime_type       = get_post_mime_type( $attachment_id );
		if ( ! in_array( $mime_type, $supported_types, true ) ) {
			return new WP_Error(
				'rest_cannot_edit_file_type',
				__( 'This type of file cannot be edited.' ),
				array( 'status' => 400 )
			);
		}

		// The `modifiers` param takes precedence over the older format.
		if ( isset( $request['modifiers'] ) ) {
			$modifiers = $request['modifiers'];
		} else {
			$modifiers = array();

			if ( ! empty( $request['rotation'] ) ) {
				$modifiers[] = array(
					'type' => 'rotate',
					'args' => array(
						'angle' => $request['rotation'],
					),
				);
			}

			if ( isset( $request['x'], $request['y'], $request['width'], $request['height'] ) ) {
				$modifiers[] = array(
					'type' => 'crop',
					'args' => array(
						'left'   => $request['x'],
						'top'    => $request['y'],
						'width'  => $request['width'],
						'height' => $request['height'],
					),
				);
			}

			if ( 0 === count( $modifiers ) ) {
				return new WP_Error(
					'rest_image_not_edited',
					__( 'The image was not edited. Edit the image before applying the changes.' ),
					array( 'status' => 400 )
				);
			}
		}

		/*
		 * If the file doesn't exist, attempt a URL fopen on the src link.
		 * This can occur with certain file replication plugins.
		 * Keep the original file path to get a modified name later.
		 */
		$image_file_to_edit = $image_file;
		if ( ! file_exists( $image_file_to_edit ) ) {
			$image_file_to_edit = _load_image_to_edit_path( $attachment_id );
		}

		$image_editor = wp_get_image_editor( $image_file_to_edit );

		if ( is_wp_error( $image_editor ) ) {
			return new WP_Error(
				'rest_unknown_image_file_type',
				__( 'Unable to edit this image.' ),
				array( 'status' => 500 )
			);
		}

		foreach ( $modifiers as $modifier ) {
			$args = $modifier['args'];
			switch ( $modifier['type'] ) {
				case 'rotate':
					// Rotation direction: clockwise vs. counter clockwise.
					$rotate = 0 - $args['angle'];

					if ( 0 !== $rotate ) {
						$result = $image_editor->rotate( $rotate );

						if ( is_wp_error( $result ) ) {
							return new WP_Error(
								'rest_image_rotation_failed',
								__( 'Unable to rotate this image.' ),
								array( 'status' => 500 )
							);
						}
					}

					break;

				case 'crop':
					$size = $image_editor->get_size();

					$crop_x = (int) round( ( $size['width'] * $args['left'] ) / 100.0 );
					$crop_y = (int) round( ( $size['height'] * $args['top'] ) / 100.0 );
					$width  = (int) round( ( $size['width'] * $args['width'] ) / 100.0 );
					$height = (int) round( ( $size['height'] * $args['height'] ) / 100.0 );

					if ( $size['width'] !== $width || $size['height'] !== $height ) {
						$result = $image_editor->crop( $crop_x, $crop_y, $width, $height );

						if ( is_wp_error( $result ) ) {
							return new WP_Error(
								'rest_image_crop_failed',
								__( 'Unable to crop this image.' ),
								array( 'status' => 500 )
							);
						}
					}

					break;

			}
		}

		// Calculate the file name.
		$image_ext  = pathinfo( $image_file, PATHINFO_EXTENSION );
		$image_name = wp_basename( $image_file, ".{$image_ext}" );

		/*
		 * Do not append multiple `-edited` to the file name.
		 * The user may be editing a previously edited image.
		 */
		if ( preg_match( '/-edited(-\d+)?$/', $image_name ) ) {
			// Remove any `-1`, `-2`, etc. `wp_unique_filename()` will add the proper number.
			$image_name = preg_replace( '/-edited(-\d+)?$/', '-edited', $image_name );
		} else {
			// Append `-edited` before the extension.
			$image_name .= '-edited';
		}

		$filename = "{$image_name}.{$image_ext}";

		// Create the uploads sub-directory if needed.
		$uploads = wp_upload_dir();

		// Make the file name unique in the (new) upload directory.
		$filename = wp_unique_filename( $uploads['path'], $filename );

		// Save to disk.
		$saved = $image_editor->save( $uploads['path'] . "/$filename" );

		if ( is_wp_error( $saved ) ) {
			return $saved;
		}

		// Create new attachment post.
		$new_attachment_post = array(
			'post_mime_type' => $saved['mime-type'],
			'guid'           => $uploads['url'] . "/$filename",
			'post_title'     => $image_name,
			'post_content'   => '',
		);

		// Copy post_content, post_excerpt, and post_title from the edited image's attachment post.
		$attachment_post = get_post( $attachment_id );

		if ( $attachment_post ) {
			$new_attachment_post['post_content'] = $attachment_post->post_content;
			$new_attachment_post['post_excerpt'] = $attachment_post->post_excerpt;
			$new_attachment_post['post_title']   = $attachment_post->post_title;
		}

		$new_attachment_id = wp_insert_attachment( wp_slash( $new_attachment_post ), $saved['path'], 0, true );

		if ( is_wp_error( $new_attachment_id ) ) {
			if ( 'db_update_error' === $new_attachment_id->get_error_code() ) {
				$new_attachment_id->add_data( array( 'status' => 500 ) );
			} else {
				$new_attachment_id->add_data( array( 'status' => 400 ) );
			}

			return $new_attachment_id;
		}

		// Copy the image alt text from the edited image.
		$image_alt = get_post_meta( $attachment_id, '_wp_attachment_image_alt', true );

		if ( ! empty( $image_alt ) ) {
			// update_post_meta() expects slashed.
			update_post_meta( $new_attachment_id, '_wp_attachment_image_alt', wp_slash( $image_alt ) );
		}

		if ( wp_is_serving_rest_request() ) {
			/*
			 * Set a custom header with the attachment_id.
			 * Used by the browser/client to resume creating image sub-sizes after a PHP fatal error.
			 */
			header( 'X-WP-Upload-Attachment-ID: ' . $new_attachment_id );
		}

		// Generate image sub-sizes and meta.
		$new_image_meta = wp_generate_attachment_metadata( $new_attachment_id, $saved['path'] );

		// Copy the EXIF metadata from the original attachment if not generated for the edited image.
		if ( isset( $image_meta['image_meta'] ) && isset( $new_image_meta['image_meta'] ) && is_array( $new_image_meta['image_meta'] ) ) {
			// Merge but skip empty values.
			foreach ( (array) $image_meta['image_meta'] as $key => $value ) {
				if ( empty( $new_image_meta['image_meta'][ $key ] ) && ! empty( $value ) ) {
					$new_image_meta['image_meta'][ $key ] = $value;
				}
			}
		}

		// Reset orientation. At this point the image is edited and orientation is correct.
		if ( ! empty( $new_image_meta['image_meta']['orientation'] ) ) {
			$new_image_meta['image_meta']['orientation'] = 1;
		}

		// The attachment_id may change if the site is exported and imported.
		$new_image_meta['parent_image'] = array(
			'attachment_id' => $attachment_id,
			// Path to the originally uploaded image file relative to the uploads directory.
			'file'          => _wp_relative_upload_path( $image_file ),
		);

		/**
		 * Filters the meta data for the new image created by editing an existing image.
		 *
		 * @since 5.5.0
		 *
		 * @param array $new_image_meta    Meta data for the new image.
		 * @param int   $new_attachment_id Attachment post ID for the new image.
		 * @param int   $attachment_id     Attachment post ID for the edited (parent) image.
		 */
		$new_image_meta = apply_filters( 'wp_edited_image_metadata', $new_image_meta, $new_attachment_id, $attachment_id );

		wp_update_attachment_metadata( $new_attachment_id, $new_image_meta );

		$response = $this->prepare_item_for_response( get_post( $new_attachment_id ), $request );
		$response->set_status( 201 );
		$response->header( 'Location', rest_url( sprintf( '%s/%s/%s', $this->namespace, $this->rest_base, $new_attachment_id ) ) );

		return $response;
	}

	/**
	 * Prepares a single attachment for create or update.
	 *
	 * @since 4.7.0
	 *
	 * @param WP_REST_Request $request Request object.
	 * @return stdClass|WP_Error Post object.
	 */
	protected function prepare_item_for_database( $request ) {
		$prepared_attachment = parent::prepare_item_for_database( $request );

		// Attachment caption (post_excerpt internally).
		if ( isset( $request['caption'] ) ) {
			if ( is_string( $request['caption'] ) ) {
				$prepared_attachment->post_excerpt = $request['caption'];
			} elseif ( isset( $request['caption']['raw'] ) ) {
				$prepared_attachment->post_excerpt = $request['caption']['raw'];
			}
		}

		// Attachment description (post_content internally).
		if ( isset( $request['description'] ) ) {
			if ( is_string( $request['description'] ) ) {
				$prepared_attachment->post_content = $request['description'];
			} elseif ( isset( $request['description']['raw'] ) ) {
				$prepared_attachment->post_content = $request['description']['raw'];
			}
		}

		if ( isset( $request['post'] ) ) {
			$prepared_attachment->post_parent = (int) $request['post'];
		}

		return $prepared_attachment;
	}

	/**
	 * Prepares a single attachment output for response.
	 *
	 * @since 4.7.0
	 * @since 5.9.0 Renamed `$post` to `$item` to match parent class for PHP 8 named parameter support.
	 *
	 * @param WP_Post         $item    Attachment object.
	 * @param WP_REST_Request $request Request object.
	 * @return WP_REST_Response Response object.
	 */
	public function prepare_item_for_response( $item, $request ) {
		// Restores the more descriptive, specific name for use within this method.
		$post = $item;

		$response = parent::prepare_item_for_response( $post, $request );
		$fields   = $this->get_fields_for_response( $request );
		$data     = $response->get_data();

		if ( in_array( 'description', $fields, true ) ) {
			$data['description'] = array(
				'raw'      => $post->post_content,
				/** This filter is documented in wp-includes/post-template.php */
				'rendered' => apply_filters( 'the_content', $post->post_content ),
			);
		}

		if ( in_array( 'caption', $fields, true ) ) {
			/** This filter is documented in wp-includes/post-template.php */
			$caption = apply_filters( 'get_the_excerpt', $post->post_excerpt, $post );

			/** This filter is documented in wp-includes/post-template.php */
			$caption = apply_filters( 'the_excerpt', $caption );

			$data['caption'] = array(
				'raw'      => $post->post_excerpt,
				'rendered' => $caption,
			);
		}

		if ( in_array( 'alt_text', $fields, true ) ) {
			$data['alt_text'] = get_post_meta( $post->ID, '_wp_attachment_image_alt', true );
		}

		if ( in_array( 'media_type', $fields, true ) ) {
			$data['media_type'] = wp_attachment_is_image( $post->ID ) ? 'image' : 'file';
		}

		if ( in_array( 'mime_type', $fields, true ) ) {
			$data['mime_type'] = $post->post_mime_type;
		}

		if ( in_array( 'media_details', $fields, true ) ) {
			$data['media_details'] = wp_get_attachment_metadata( $post->ID );

			// Ensure empty details is an empty object.
			if ( empty( $data['media_details'] ) ) {
				$data['media_details'] = new stdClass();
			} elseif ( ! empty( $data['media_details']['sizes'] ) ) {

				foreach ( $data['media_details']['sizes'] as $size => &$size_data ) {

					if ( isset( $size_data['mime-type'] ) ) {
						$size_data['mime_type'] = $size_data['mime-type'];
						unset( $size_data['mime-type'] );
					}

					// Use the same method image_downsize() does.
					$image_src = wp_get_attachment_image_src( $post->ID, $size );
					if ( ! $image_src ) {
						continue;
					}

					$size_data['source_url'] = $image_src[0];
				}

				$full_src = wp_get_attachment_image_src( $post->ID, 'full' );

				if ( ! empty( $full_src ) ) {
					$data['media_details']['sizes']['full'] = array(
						'file'       => wp_basename( $full_src[0] ),
						'width'      => $full_src[1],
						'height'     => $full_src[2],
						'mime_type'  => $post->post_mime_type,
						'source_url' => $full_src[0],
					);
				}
			} else {
				$data['media_details']['sizes'] = new stdClass();
			}
		}

		if ( in_array( 'post', $fields, true ) ) {
			$data['post'] = ! empty( $post->post_parent ) ? (int) $post->post_parent : null;
		}

		if ( in_array( 'source_url', $fields, true ) ) {
			$data['source_url'] = wp_get_attachment_url( $post->ID );
		}

		if ( in_array( 'missing_image_sizes', $fields, true ) ) {
			require_once ABSPATH . 'wp-admin/includes/image.php';
			$data['missing_image_sizes'] = array_keys( wp_get_missing_image_subsizes( $post->ID ) );
		}

		$context = ! empty( $request['context'] ) ? $request['context'] : 'view';

		$data = $this->filter_response_by_context( $data, $context );

		$links = $response->get_links();

		// Wrap the data in a response object.
		$response = rest_ensure_response( $data );

		foreach ( $links as $rel => $rel_links ) {
			foreach ( $rel_links as $link ) {
				$response->add_link( $rel, $link['href'], $link['attributes'] );
			}
		}

		/**
		 * Filters an attachment returned from the REST API.
		 *
		 * Allows modification of the attachment right before it is returned.
		 *
		 * @since 4.7.0
		 *
		 * @param WP_REST_Response $response The response object.
		 * @param WP_Post          $post     The original attachment post.
		 * @param WP_REST_Request  $request  Request used to generate the response.
		 */
		return apply_filters( 'rest_prepare_attachment', $response, $post, $request );
	}

	/**
	 * Retrieves the attachment's schema, conforming to JSON Schema.
	 *
	 * @since 4.7.0
	 *
	 * @return array Item schema as an array.
	 */
	public function get_item_schema() {
		if ( $this->schema ) {
			return $this->add_additional_fields_schema( $this->schema );
		}

		$schema = parent::get_item_schema();

		$schema['properties']['alt_text'] = array(
			'description' => __( 'Alternative text to display when attachment is not displayed.' ),
			'type'        => 'string',
			'context'     => array( 'view', 'edit', 'embed' ),
			'arg_options' => array(
				'sanitize_callback' => 'sanitize_text_field',
			),
		);

		$schema['properties']['caption'] = array(
			'description' => __( 'The attachment caption.' ),
			'type'        => 'object',
			'context'     => array( 'view', 'edit', 'embed' ),
			'arg_options' => array(
				'sanitize_callback' => null, // Note: sanitization implemented in self::prepare_item_for_database().
				'validate_callback' => null, // Note: validation implemented in self::prepare_item_for_database().
			),
			'properties'  => array(
				'raw'      => array(
					'description' => __( 'Caption for the attachment, as it exists in the database.' ),
					'type'        => 'string',
					'context'     => array( 'edit' ),
				),
				'rendered' => array(
					'description' => __( 'HTML caption for the attachment, transformed for display.' ),
					'type'        => 'string',
					'context'     => array( 'view', 'edit', 'embed' ),
					'readonly'    => true,
				),
			),
		);

		$schema['properties']['description'] = array(
			'description' => __( 'The attachment description.' ),
			'type'        => 'object',
			'context'     => array( 'view', 'edit' ),
			'arg_options' => array(
				'sanitize_callback' => null, // Note: sanitization implemented in self::prepare_item_for_database().
				'validate_callback' => null, // Note: validation implemented in self::prepare_item_for_database().
			),
			'properties'  => array(
				'raw'      => array(
					'description' => __( 'Description for the attachment, as it exists in the database.' ),
					'type'        => 'string',
					'context'     => array( 'edit' ),
				),
				'rendered' => array(
					'description' => __( 'HTML description for the attachment, transformed for display.' ),
					'type'        => 'string',
					'context'     => array( 'view', 'edit' ),
					'readonly'    => true,
				),
			),
		);

		$schema['properties']['media_type'] = array(
			'description' => __( 'Attachment type.' ),
			'type'        => 'string',
			'enum'        => array( 'image', 'file' ),
			'context'     => array( 'view', 'edit', 'embed' ),
			'readonly'    => true,
		);

		$schema['properties']['mime_type'] = array(
			'description' => __( 'The attachment MIME type.' ),
			'type'        => 'string',
			'context'     => array( 'view', 'edit', 'embed' ),
			'readonly'    => true,
		);

		$schema['properties']['media_details'] = array(
			'description' => __( 'Details about the media file, specific to its type.' ),
			'type'        => 'object',
			'context'     => array( 'view', 'edit', 'embed' ),
			'readonly'    => true,
		);

		$schema['properties']['post'] = array(
			'description' => __( 'The ID for the associated post of the attachment.' ),
			'type'        => 'integer',
			'context'     => array( 'view', 'edit' ),
		);

		$schema['properties']['source_url'] = array(
			'description' => __( 'URL to the original attachment file.' ),
			'type'        => 'string',
			'format'      => 'uri',
			'context'     => array( 'view', 'edit', 'embed' ),
			'readonly'    => true,
		);

		$schema['properties']['missing_image_sizes'] = array(
			'description' => __( 'List of the missing image sizes of the attachment.' ),
			'type'        => 'array',
			'items'       => array( 'type' => 'string' ),
			'context'     => array( 'edit' ),
			'readonly'    => true,
		);

		unset( $schema['properties']['password'] );

		$this->schema = $schema;

		return $this->add_additional_fields_schema( $this->schema );
	}

	/**
	 * Handles an upload via raw POST data.
	 *
	 * @since 4.7.0
	 * @since 6.6.0 Added the `$time` parameter.
	 *
	 * @param string      $data    Supplied file data.
	 * @param array       $headers HTTP headers from the request.
	 * @param string|null $time    Optional. Time formatted in 'yyyy/mm'. Default null.
	 * @return array|WP_Error Data from wp_handle_sideload().
	 */
	protected function upload_from_data( $data, $headers, $time = null ) {
		if ( empty( $data ) ) {
			return new WP_Error(
				'rest_upload_no_data',
				__( 'No data supplied.' ),
				array( 'status' => 400 )
			);
		}

		if ( empty( $headers['content_type'] ) ) {
			return new WP_Error(
				'rest_upload_no_content_type',
				__( 'No Content-Type supplied.' ),
				array( 'status' => 400 )
			);
		}

		if ( empty( $headers['content_disposition'] ) ) {
			return new WP_Error(
				'rest_upload_no_content_disposition',
				__( 'No Content-Disposition supplied.' ),
				array( 'status' => 400 )
			);
		}

		$filename = self::get_filename_from_disposition( $headers['content_disposition'] );

		if ( empty( $filename ) ) {
			return new WP_Error(
				'rest_upload_invalid_disposition',
				__( 'Invalid Content-Disposition supplied. Content-Disposition needs to be formatted as `attachment; filename="image.png"` or similar.' ),
				array( 'status' => 400 )
			);
		}

		if ( ! empty( $headers['content_md5'] ) ) {
			$content_md5 = array_shift( $headers['content_md5'] );
			$expected    = trim( $content_md5 );
			$actual      = md5( $data );

			if ( $expected !== $actual ) {
				return new WP_Error(
					'rest_upload_hash_mismatch',
					__( 'Content hash did not match expected.' ),
					array( 'status' => 412 )
				);
			}
		}

		// Get the content-type.
		$type = array_shift( $headers['content_type'] );

		// Include filesystem functions to get access to wp_tempnam() and wp_handle_sideload().
		require_once ABSPATH . 'wp-admin/includes/file.php';

		// Save the file.
		$tmpfname = wp_tempnam( $filename );

		$fp = fopen( $tmpfname, 'w+' );

		if ( ! $fp ) {
			return new WP_Error(
				'rest_upload_file_error',
				__( 'Could not open file handle.' ),
				array( 'status' => 500 )
			);
		}

		fwrite( $fp, $data );
		fclose( $fp );

		// Now, sideload it in.
		$file_data = array(
			'error'    => null,
			'tmp_name' => $tmpfname,
			'name'     => $filename,
			'type'     => $type,
		);

		$size_check = self::check_upload_size( $file_data );
		if ( is_wp_error( $size_check ) ) {
			return $size_check;
		}

		$overrides = array(
			'test_form' => false,
		);

		$sideloaded = wp_handle_sideload( $file_data, $overrides, $time );

		if ( isset( $sideloaded['error'] ) ) {
			@unlink( $tmpfname );

			return new WP_Error(
				'rest_upload_sideload_error',
				$sideloaded['error'],
				array( 'status' => 500 )
			);
		}

		return $sideloaded;
	}

	/**
	 * Parses filename from a Content-Disposition header value.
	 *
	 * As per RFC6266:
	 *
	 *     content-disposition = "Content-Disposition" ":"
	 *                            disposition-type *( ";" disposition-parm )
	 *
	 *     disposition-type    = "inline" | "attachment" | disp-ext-type
	 *                         ; case-insensitive
	 *     disp-ext-type       = token
	 *
	 *     disposition-parm    = filename-parm | disp-ext-parm
	 *
	 *     filename-parm       = "filename" "=" value
	 *                         | "filename*" "=" ext-value
	 *
	 *     disp-ext-parm       = token "=" value
	 *                         | ext-token "=" ext-value
	 *     ext-token           = <the characters in token, followed by "*">
	 *
	 * @since 4.7.0
	 *
	 * @link https://tools.ietf.org/html/rfc2388
	 * @link https://tools.ietf.org/html/rfc6266
	 *
	 * @param string[] $disposition_header List of Content-Disposition header values.
	 * @return string|null Filename if available, or null if not found.
	 */
	public static function get_filename_from_disposition( $disposition_header ) {
		// Get the filename.
		$filename = null;

		foreach ( $disposition_header as $value ) {
			$value = trim( $value );

			if ( ! str_contains( $value, ';' ) ) {
				continue;
			}

			list( $type, $attr_parts ) = explode( ';', $value, 2 );

			$attr_parts = explode( ';', $attr_parts );
			$attributes = array();

			foreach ( $attr_parts as $part ) {
				if ( ! str_contains( $part, '=' ) ) {
					continue;
				}

				list( $key, $value ) = explode( '=', $part, 2 );

				$attributes[ trim( $key ) ] = trim( $value );
			}

			if ( empty( $attributes['filename'] ) ) {
				continue;
			}

			$filename = trim( $attributes['filename'] );

			// Unquote quoted filename, but after trimming.
			if ( str_starts_with( $filename, '"' ) && str_ends_with( $filename, '"' ) ) {
				$filename = substr( $filename, 1, -1 );
			}
		}

		return $filename;
	}

	/**
	 * Retrieves the query params for collections of attachments.
	 *
	 * @since 4.7.0
	 *
	 * @return array Query parameters for the attachment collection as an array.
	 */
	public function get_collection_params() {
		$params                            = parent::get_collection_params();
		$params['status']['default']       = 'inherit';
		$params['status']['items']['enum'] = array( 'inherit', 'private', 'trash' );
		$media_types                       = $this->get_media_types();

		$params['media_type'] = array(
			'default'     => null,
			'description' => __( 'Limit result set to attachments of a particular media type.' ),
			'type'        => 'string',
			'enum'        => array_keys( $media_types ),
		);

		$params['mime_type'] = array(
			'default'     => null,
			'description' => __( 'Limit result set to attachments of a particular MIME type.' ),
			'type'        => 'string',
		);

		return $params;
	}

	/**
	 * Handles an upload via multipart/form-data ($_FILES).
	 *
	 * @since 4.7.0
	 * @since 6.6.0 Added the `$time` parameter.
	 *
	 * @param array       $files   Data from the `$_FILES` superglobal.
	 * @param array       $headers HTTP headers from the request.
	 * @param string|null $time    Optional. Time formatted in 'yyyy/mm'. Default null.
	 * @return array|WP_Error Data from wp_handle_upload().
	 */
	protected function upload_from_file( $files, $headers, $time = null ) {
		if ( empty( $files ) ) {
			return new WP_Error(
				'rest_upload_no_data',
				__( 'No data supplied.' ),
				array( 'status' => 400 )
			);
		}

		// Verify hash, if given.
		if ( ! empty( $headers['content_md5'] ) ) {
			$content_md5 = array_shift( $headers['content_md5'] );
			$expected    = trim( $content_md5 );
			$actual      = md5_file( $files['file']['tmp_name'] );

			if ( $expected !== $actual ) {
				return new WP_Error(
					'rest_upload_hash_mismatch',
					__( 'Content hash did not match expected.' ),
					array( 'status' => 412 )
				);
			}
		}

		// Pass off to WP to handle the actual upload.
		$overrides = array(
			'test_form' => false,
		);

		// Bypasses is_uploaded_file() when running unit tests.
		if ( defined( 'DIR_TESTDATA' ) && DIR_TESTDATA ) {
			$overrides['action'] = 'wp_handle_mock_upload';
		}

		$size_check = self::check_upload_size( $files['file'] );
		if ( is_wp_error( $size_check ) ) {
			return $size_check;
		}

		// Include filesystem functions to get access to wp_handle_upload().
		require_once ABSPATH . 'wp-admin/includes/file.php';

		$file = wp_handle_upload( $files['file'], $overrides, $time );

		if ( isset( $file['error'] ) ) {
			return new WP_Error(
				'rest_upload_unknown_error',
				$file['error'],
				array( 'status' => 500 )
			);
		}

		return $file;
	}

	/**
	 * Retrieves the supported media types.
	 *
	 * Media types are considered the MIME type category.
	 *
	 * @since 4.7.0
	 *
	 * @return array Array of supported media types.
	 */
	protected function get_media_types() {
		$media_types = array();

		foreach ( get_allowed_mime_types() as $mime_type ) {
			$parts = explode( '/', $mime_type );

			if ( ! isset( $media_types[ $parts[0] ] ) ) {
				$media_types[ $parts[0] ] = array();
			}

			$media_types[ $parts[0] ][] = $mime_type;
		}

		return $media_types;
	}

	/**
	 * Determine if uploaded file exceeds space quota on multisite.
	 *
	 * Replicates check_upload_size().
	 *
	 * @since 4.9.8
	 *
	 * @param array $file $_FILES array for a given file.
	 * @return true|WP_Error True if can upload, error for errors.
	 */
	protected function check_upload_size( $file ) {
		if ( ! is_multisite() ) {
			return true;
		}

		if ( get_site_option( 'upload_space_check_disabled' ) ) {
			return true;
		}

		$space_left = get_upload_space_available();

		$file_size = filesize( $file['tmp_name'] );

		if ( $space_left < $file_size ) {
			return new WP_Error(
				'rest_upload_limited_space',
				/* translators: %s: Required disk space in kilobytes. */
				sprintf( __( 'Not enough space to upload. %s KB needed.' ), number_format( ( $file_size - $space_left ) / KB_IN_BYTES ) ),
				array( 'status' => 400 )
			);
		}

		if ( $file_size > ( KB_IN_BYTES * get_site_option( 'fileupload_maxk', 1500 ) ) ) {
			return new WP_Error(
				'rest_upload_file_too_big',
				/* translators: %s: Maximum allowed file size in kilobytes. */
				sprintf( __( 'This file is too big. Files must be less than %s KB in size.' ), get_site_option( 'fileupload_maxk', 1500 ) ),
				array( 'status' => 400 )
			);
		}

		// Include multisite admin functions to get access to upload_is_user_over_quota().
		require_once ABSPATH . 'wp-admin/includes/ms.php';

		if ( upload_is_user_over_quota( false ) ) {
			return new WP_Error(
				'rest_upload_user_quota_exceeded',
				__( 'You have used your space quota. Please delete files before uploading.' ),
				array( 'status' => 400 )
			);
		}

		return true;
	}

	/**
	 * Gets the request args for the edit item route.
	 *
	 * @since 5.5.0
	 *
	 * @return array
	 */
	protected function get_edit_media_item_args() {
		return array(
			'src'       => array(
				'description' => __( 'URL to the edited image file.' ),
				'type'        => 'string',
				'format'      => 'uri',
				'required'    => true,
			),
			'modifiers' => array(
				'description' => __( 'Array of image edits.' ),
				'type'        => 'array',
				'minItems'    => 1,
				'items'       => array(
					'description' => __( 'Image edit.' ),
					'type'        => 'object',
					'required'    => array(
						'type',
						'args',
					),
					'oneOf'       => array(
						array(
							'title'      => __( 'Rotation' ),
							'properties' => array(
								'type' => array(
									'description' => __( 'Rotation type.' ),
									'type'        => 'string',
									'enum'        => array( 'rotate' ),
								),
								'args' => array(
									'description' => __( 'Rotation arguments.' ),
									'type'        => 'object',
									'required'    => array(
										'angle',
									),
									'properties'  => array(
										'angle' => array(
											'description' => __( 'Angle to rotate clockwise in degrees.' ),
											'type'        => 'number',
										),
									),
								),
							),
						),
						array(
							'title'      => __( 'Crop' ),
							'properties' => array(
								'type' => array(
									'description' => __( 'Crop type.' ),
									'type'        => 'string',
									'enum'        => array( 'crop' ),
								),
								'args' => array(
									'description' => __( 'Crop arguments.' ),
									'type'        => 'object',
									'required'    => array(
										'left',
										'top',
										'width',
										'height',
									),
									'properties'  => array(
										'left'   => array(
											'description' => __( 'Horizontal position from the left to begin the crop as a percentage of the image width.' ),
											'type'        => 'number',
										),
										'top'    => array(
											'description' => __( 'Vertical position from the top to begin the crop as a percentage of the image height.' ),
											'type'        => 'number',
										),
										'width'  => array(
											'description' => __( 'Width of the crop as a percentage of the image width.' ),
											'type'        => 'number',
										),
										'height' => array(
											'description' => __( 'Height of the crop as a percentage of the image height.' ),
											'type'        => 'number',
										),
									),
								),
							),
						),
					),
				),
			),
			'rotation'  => array(
				'description'      => __( 'The amount to rotate the image clockwise in degrees. DEPRECATED: Use `modifiers` instead.' ),
				'type'             => 'integer',
				'minimum'          => 0,
				'exclusiveMinimum' => true,
				'maximum'          => 360,
				'exclusiveMaximum' => true,
			),
			'x'         => array(
				'description' => __( 'As a percentage of the image, the x position to start the crop from. DEPRECATED: Use `modifiers` instead.' ),
				'type'        => 'number',
				'minimum'     => 0,
				'maximum'     => 100,
			),
			'y'         => array(
				'description' => __( 'As a percentage of the image, the y position to start the crop from. DEPRECATED: Use `modifiers` instead.' ),
				'type'        => 'number',
				'minimum'     => 0,
				'maximum'     => 100,
			),
			'width'     => array(
				'description' => __( 'As a percentage of the image, the width to crop the image to. DEPRECATED: Use `modifiers` instead.' ),
				'type'        => 'number',
				'minimum'     => 0,
				'maximum'     => 100,
			),
			'height'    => array(
				'description' => __( 'As a percentage of the image, the height to crop the image to. DEPRECATED: Use `modifiers` instead.' ),
				'type'        => 'number',
				'minimum'     => 0,
				'maximum'     => 100,
			),
		);
	}
}<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>misc &#8211; Sanathan Dharm Veda</title>
	<atom:link href="https://sanatandharmveda.com/category/misc/feed/" rel="self" type="application/rss+xml" />
	<link>https://sanatandharmveda.com</link>
	<description></description>
	<lastBuildDate>Sat, 25 Apr 2026 10:58:07 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.6.5</generator>

<image>
	<url>https://sanatandharmveda.com/wp-content/uploads/2024/05/cropped-cropped-pexels-himeshmehtaa25-3519190-32x32.jpg</url>
	<title>misc &#8211; Sanathan Dharm Veda</title>
	<link>https://sanatandharmveda.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Do not be Fooled By Cat Casino</title>
		<link>https://sanatandharmveda.com/do-not-be-fooled-by-cat-casino/</link>
					<comments>https://sanatandharmveda.com/do-not-be-fooled-by-cat-casino/#respond</comments>
		
		<dc:creator><![CDATA[sanatandharmveda]]></dc:creator>
		<pubDate>Sat, 25 Apr 2026 10:58:07 +0000</pubDate>
				<category><![CDATA[misc]]></category>
		<category><![CDATA[кэт казино]]></category>
		<guid isPermaLink="false">https://sanatandharmveda.com/?p=35175</guid>

					<description><![CDATA[Казино Кэт Cat Casino — играть онлайн на реальные деньги сегодня Здесь вас ждут разнообразные игровые автоматы, которые поддерживают ставки на реальные деньги. В онлайн казино Cat Casino вы найдете слоты с различными бонусными функциями, такими как фриспины, множители ставок, риск-игра на удвоение выигрыша и специальные символы. Эти функции делают игровой процесс еще более увлекательным [&#8230;]]]></description>
										<content:encoded><![CDATA[<p>Казино Кэт Cat Casino — играть онлайн на реальные деньги сегодня</p>
<p>Здесь вас ждут разнообразные игровые автоматы, которые поддерживают ставки на реальные деньги. В онлайн казино Cat Casino вы найдете слоты с различными бонусными функциями, такими как фриспины, множители ставок, риск-игра на удвоение выигрыша и специальные символы. Эти функции делают игровой процесс еще более увлекательным и позволяют увеличить ваши шансы на крупный выигрыш. Играя на деньги в казино Cat, вы можете испытать настоящий азарт и получить незабываемые эмоции. Cat Casino заботится о своих клиентах, предлагая удобный официальный сайт и мобильную версию для ставок и игры на ходу.</p>
<p>Игроки в онлайн казино Cat Casino могут рассчитывать на стабильный и безопасный игровой процесс. Платформа поддерживает русский язык, что делает игру еще более удобной для пользователей из стран СНГ. Вы можете играть на деньги в казино Cat Casino не только через ПК, но и через мобильное устройство, используя мобильную версию сайта. Все данные защищены SSL-шифрованием, что гарантирует безопасность ваших финансовых транзакций и личной информации. Наслаждайтесь игрой на деньги в казино Cat в любое время и в любом месте, используя удобные функции мобильной версии.</p>
<p><h2>cat casino</h2>
</p>
<p>При путешествии по зеркальным коридорам крайне важно подтвердить их подлинность, что является залогом защиты ваших личных сокровищ и финансовых ресурсов. Все официальные зеркала укреплены теми же заклинаниями шифрования и барьерами безопасности, что и основной сайт, гарантируя вашу неприкосновенность на каждом шагу в этом виртуальном мире. Вот в казино Кэт, точно второй год игры пошел, но бросать площадку не тянет. Здесь как было все норм, так и остается, даже бонусные по-моему в том же составе, но это не точно, ибо ими не увлекаюсь. Бонус можно получить после четвертого депозита с момента регистрации. Количество фриспинов зависит от суммы пополнения — от 20 до 100 штук.</p>
<p>Нет нужды в отдельном приложении, ведь этот мобильный портал с легкостью адаптируется к устройствам на базе Android и iOS, предлагая бесперебойную и комфортную игру. Его адаптивный дизайн умело морфируется, подстраиваясь под любой размер экрана, тем самым гарантируя безупречную навигацию и контроль над игровым процессом, где бы вы ни находились. Среди отзывов о Cat казино чаще всего встречаются положительные мнения о большом выборе игр, удобном интерфейсе и, конечно же, привлекательных бонусах. Многие отмечают, что Cat casino предлагает одни из лучших условий для игроков, особенно новичков, благодаря отличной программе бонусов. Для навигации по разделам оператор предлагает использовать поиск по названию.</p>
</p>
<p>В Cat Casino пользователи могут наслаждаться игрой и ставками как через мобильную версию сайта, так и через мобильное приложение. Но между ними существует несколько отличий, которые стоит учитывать. Необходимо подтвердить свой e-mail или номер мобильного телефона, &#8220;привязав&#8221; их к учетной записи.</p>
<p>Чтобы посетители могли быстрее находить интересующие их тайтлы, оператор предусмотрел поиск по названию. При выборе одного из них на экран выводятся все принадлежащие ему автоматы. Платежная система Cat Casino поддерживает 15 методов депозита и 12 способов вывода средств.</p>
<ul>
<li>Бонус можно получить после четвертого депозита с момента регистрации.</li>
<li>Ha бaннepax oтoбpaжaeтcя aктyaльнaя инфopмaция o дeйcтвyющиx aкцияx, бoнycныx пpoгpaммax.</li>
<li>Ваш персональный ключ к искусству манипулирования всеми изысками и привилегиями программы лояльности, открывающий двери к новым вершинам и возможностям.</li>
<li>Администрация казино имеет право запросить копии документов в любое время.</li>
<li>Чтoбы нaйти aктyaльнoe Саt Саsinо зepкaлo нa ceгoдня, нeoбxoдимo oтпpaвить зaпpoc в cлyжбy тexпoддepжки и пoпpocить cпиcoк дocтyпныx дyблиpyющиx плoщaдoк.</li>
<li>Еженедельный кешбэк достигает 10% от проигранных средств и начисляется каждый понедельник.</li>
<li>Здесь вас ждут разнообразные игровые автоматы, которые поддерживают ставки на реальные деньги.</li>
<li>В свете ограничений на азартные игры в России, Cat Casino выделяется как маяк для энтузиастов.</li>
<li>В Cat Casino доступны различные бонусы для новых и существующих игроков, включая бесплатные вращения и депозитные бонусы.</li>
<li>После регистрации необходимо пройти процедуру верификации, которая обеспечивает безопасность вашего аккаунта и вывод средств.</li>
<li>После регистрации и пополнения счета, вы можете начать играть на деньги в казино Cat Casino.</li>
</ul>
<p><h3>cat casino</h3>
</p>
<p>Все функции также доступны на официальном сайте для беспроблемного использования. Приветственный бонус в онлайн казино Cat Casino предоставляется всем новым игрокам после регистрации и первого пополнения счета. Этот бонус позволяет начать игру с дополнительными средствами на счету, что увеличивает ваши шансы на выигрыш. Кроме того, казино Cat регулярно проводит акции и предлагает еженедельные бонусы для своих постоянных игроков. Эти бонусы могут включать дополнительные средства на счет, фриспины и другие приятные сюрпризы. После регистрации и пополнения счета, вы можете начать играть на деньги в казино Cat Casino.</p>
<ul>
<li>Бoльшинcтвo гeймepoв пpeдпoчитaют игpaть в виpтyaльнoм зaвeдeнии c пopтaтивныx ycтpoйcтв.</li>
<li>Также оператор не предлагает своим игрокам скачать клиент Cat Casino, так как он тоже никому не пригодится.</li>
<li>Также в самом низу страницы находятся иконки поддерживаемых платежных систем и провайдеров, с софтом которых работает компания.</li>
<li>Приложение обладает улучшенной производительностью, мгновенными уведомлениями, а также часто используется для доступа к специальным бонусам и предложениям для мобильных игроков.</li>
<li>Она отлично адаптирована для небольших экранов, что позволяет легко ориентироваться в интерфейсе на Android и iOS устройствах.</li>
<li>Официальный сайт cat casino — карусель возможностей, которые вечно кружатся, вырисовывая всё новые и новые узоры удачи!</li>
<li>Сразу после регистрации автоматически производится вход на официальном сайте, а новичок получает доступ к кассе для пополнения баланса, бонусам, турнирам и другим функциям.</li>
<li>Играя на реальные деньги в турнирные слоты, игроки зарабатывают бонусные баллы, которые оказывают влияние на их место в турнирной таблице.</li>
<li>18+</p>
<p>Таким образом, мобильная версия Cat Casino становится верным спутником в вашем кармане, готовым к игре в любое время и в любом месте. Если вы предпочитаете играть в Cat casino на ходу, вам стоит обратить внимание на мобильную версию и приложение. Cat casino предлагает своим игрокам возможность скачать приложение для Android и iOS, а также использовать адаптированную мобильную версию. Cat казино — это надежная онлайн-платформа, где каждый игрок может найти свои любимые игры. В Cat casino представлены слоты, настольные игры, покер и рулетка от ведущих провайдеров. Платформа гарантирует честность всех игр и безопасность данных, поскольку работает по лицензии, что дает игрокам уверенность в прозрачности и честности всех транзакций.</p>
<p>В портале этой игровой вселенной пользователи находят ключ к нескончаемому потоку веселья и возможностей, поддерживаемый надёжной службой поддержки. Отзывчивая команда профессионалов всегда находится на передовой, чтобы в мгновение ока разрешать любые сложности и вопросы. После регистрации необходимо пройти процедуру верификации, которая обеспечивает безопасность вашего аккаунта и вывод средств. Для верификации потребуется предоставить копию документа, подтверждающего вашу личность, а также доказательства места жительства. Это обязательный процесс, но он помогает обезопасить ваш аккаунт от мошенников.</p>
<p>Платформа мобильного сайта полностью оптимизирована для смартфонов и планшетов, позволяя играть и делать ставки в любое время и в любом месте. Все функции доступны на официальном сайте для беспрепятственного опыта. Для начала игры на мобильном устройстве, зарегистрированным пользователям необходимо войти в свой личный кабинет через смартфон или планшет. Если у игрока еще нет аккаунта, его нужно создать через мобильный браузер на официальном сайте Cat Casino (подробное описание регистрации можно найти выше). После входа в систему, пользователь может активировать доступные бонусы, пополнить счет и выбрать игровой автомат для ставок.</p>
<p>После активации аккаунта игроку предстоит пройти процесс верификации. Согласно правилам официального сайта Cat Casino, для вывода выигрышей, превышающих 1000 долларов, верификация является обязательной. Администрация казино имеет право запросить копии документов в любое время. В личном кабинете предусмотрена форма для загрузки скан-копии паспорта (JPEG файл не более 5МБ), которая отправляется на проверку.</p>
</p>
<p>Клик по ней позволяет перейти на официальный сайт регулятора и все проверить. Также в самом низу страницы находятся иконки поддерживаемых платежных систем и провайдеров, с софтом которых работает компания. Cat Casino превращает финансовые операции в настоящий спектакль скорости и удобства, демонстрируя современное искусство обработки транзакций. Пополнение счета происходит практически моментально — выбирайте любой способ оплаты, и ваши средства окажутся на балансе быстрее, чем прозвучит ваше победное «джекпот! » Каждая операция тщательно охраняется автоматизированной системой безопасности, которая надежнее стражей королевских сокровищ. Это значит, что ваше золото всегда под защитой, а деньги зачисляются без промедления, позволяя вам с головой погрузиться в мир захватывающей игры  в Cat Casino, наслаждаясь каждым мгновением.</p>
<p><h3>cat casino</h3>
</p>
<p>Играя на реальные деньги в турнирные слоты, игроки зарабатывают бонусные баллы, которые оказывают влияние на их место в турнирной таблице. Мобильная версия сайта предоставляет <a href="https://realtor-pro.ru/">казино кэт</a> доступ ко всем играм и функциям, которые есть на официальном сайте. Она отлично адаптирована для небольших экранов, что позволяет легко ориентироваться в интерфейсе на Android и iOS устройствах. Пользователи могут играть в слоты, делать ставки на спорт и управлять своим счетом прямо через браузер, без необходимости скачивания приложения.</p>
</p>
<p>Сразу после регистрации автоматически производится вход на официальном сайте, а новичок получает доступ к кассе для пополнения баланса, бонусам, турнирам и другим функциям. Оператор при определенных обстоятельствах требует от игроков верификацию. Если первая выплата превысит эту сумму, потребует идентификацию. С другой стороны, мобильное приложение Cat Casino предоставляет более быстрый доступ, поскольку оно предустановлено на вашем устройстве и не зависит от браузера. Приложение обладает улучшенной производительностью, мгновенными уведомлениями, а также часто используется для доступа к специальным бонусам и предложениям для мобильных игроков. Это приложение работает плавнее, и оно позволяет пользователю наслаждаться игровым процессом без лишних задержек и зависаний.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://sanatandharmveda.com/do-not-be-fooled-by-cat-casino/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Focus Model and Visual Presentation</title>
		<link>https://sanatandharmveda.com/focus-model-and-visual-presentation-25/</link>
					<comments>https://sanatandharmveda.com/focus-model-and-visual-presentation-25/#respond</comments>
		
		<dc:creator><![CDATA[sanatandharmveda]]></dc:creator>
		<pubDate>Wed, 22 Apr 2026 06:31:35 +0000</pubDate>
				<category><![CDATA[misc]]></category>
		<guid isPermaLink="false">https://sanatandharmveda.com/?p=35105</guid>

					<description><![CDATA[Focus Model and Visual Presentation This concentration system describes the way online spaces compete over finite individual focus. Every visual element, piece of content, and engagement stage is designed to capture and hold interest during a brief time span. Users remain exposed plinko to a significant flow of information, and this requires platforms to prioritize [&#8230;]]]></description>
										<content:encoded><![CDATA[<h1>Focus Model and Visual Presentation</h1>
<p>This concentration system describes the way online spaces compete over finite individual focus. Every visual element, piece of content, and engagement stage is designed to capture and hold interest during a brief time span. Users remain exposed plinko to a significant flow of information, and this requires platforms to prioritize transparency, relevance, and speed of understanding. Under this framework, image-based narrative turns into a important tool for structuring content in a manner that fits with inherent perceptual patterns.</p>
<p>Virtual systems lean upon visual progressions to shape understanding and evaluation. Structured narratives reinforced with imagery, arrangement, and progression structures assist people handle content efficiently. Analytical observations, including <a href="https://traffikkitchen.com/">plinko casino</a>, show that image-based storytelling reduces mental effort through presenting data in a unified and predictable form. Such an approach structure allows users to grasp multi-layered concepts without demanding long reading time or detailed assessment.</p>
<h2>Primary Rules of the Concentration Economy</h2>
<p>This focus economy operates through the idea that individual attention forms a limited plinko casino capacity. Virtual systems have to allocate this attention efficiently by offering content which is quickly understandable and pertinent. Interfaces become arranged to limit friction and make sure that key content is visible within the opening moments of use. Such a structure reduces the risk of loss of interest and promotes steady engagement.</p>
<p>Prioritization of content has a major role in holding concentration. Features such as headings, graphic anchors, and organized arrangements direct individuals towards essential information. When information is arranged in line with human patterns, such material appears simpler to navigate and interpret. Such organization increases the possibility of sustained engagement and strengthens the general effectiveness of the experience.</p>
<h2>Perceptual Order for Presentation</h2>
<p>Perceptual order determines how information becomes interpreted and processed. Size, contrast, separation, and alignment remain used to channel notice towards selected plinko bonus components. Within narrative design, order ensures that users follow a ordered progression of content, moving from main points to additional details. This ordered flow eases perception and lowers thinking strain.</p>
<p>Strong perceptual order fits with natural attention behaviors. Users typically focus on visible elements before others and then shift to secondary content. By structuring content according to these behaviors, online environments can guide users along a narrative without needing clear plinko instructions. Such alignment supports more rapid understanding and more consistent perception.</p>
<h2>Sequential Content and Story Progression</h2>
<p>Image-based storytelling depends upon the organization of content in a meaningful progression. Each element belongs to a wider narrative that unfolds while individuals move across the system. Such a sequence supports hold focus by creating a direct understanding of movement and continuity. If users see what follows next, those users become more willing to remain focused.</p>
<p>Connections among information segments are important for maintaining story coherence. Stable transition from one section to another avoids plinko casino breaks and helps ensure that people may understand the planned sequence. Stable connections promote comprehension and reduce the need for repeated interpretation. Therefore the consequence, choice-making becomes more effective and aligned to the shown content.</p>
<h2>Role of Visuals and Perceptual Signals</h2>
<p>Visuals and visual signals have a central function in gaining plinko bonus focus and delivering sense. These elements provide immediate context and reduce the need for written explanation. Visual components such as symbols, illustrations, and schemes assist users process content quickly and accurately. These components act as orientation points that shape attention and enable interpretation.</p>
<p>The effectiveness of visuals rests upon their fit and simplicity. Irrelevant graphic elements may divert users and lower the effect of the narrative. Well-selected graphic elements, on the other hand, reinforce main points and improve recall. Through matching plinko graphic elements with content, virtual platforms are able to deliver a cohesive and useful experience.</p>
<h2>Time Dependence and Content Presentation</h2>
<p>In the focus system, speed plays a critical role in the way content is consumed. Users frequently form judgments on whether to engage with information during moments. Such behavior demands digital systems to deliver key details quickly and effectively. Late or confusing display may lead to reduction of interest and reduced interaction.</p>
<p>Short attention times affect how data is structured. Essential points are placed in the start of content flows, and additional details follows. This method supports that individuals get essential points even during short plinko casino engagements. Efficient material exposure enables better understanding and more aware choice-making.</p>
<h2>Emotional Engagement By Means of Visual Presentation</h2>
<p>Design-based narrative affects affective responses, and that in turn shape attention and interpretation. Design components such as tone schemes, lettering, and arrangement belong to the full character of the presentation. Measured and balanced presentation supports readability, whereas overloaded design complexity might lead to confusion.</p>
<p>Emotional stability becomes essential for holding individual focus. Sharp shifts in presentation or tone may interrupt engagement and reduce engagement. By maintaining a predictable design system, virtual environments build a coherent presentation which enables steady engagement. Such stability improves both comprehension and plinko bonus memory.</p>
<h2>Data Density and Clarity</h2>
<p>Managing data volume remains essential in the focus system. Crowded interfaces may burden individuals and lower their capacity to handle content smoothly. Visual presentation handles this challenge through breaking data into clear sections. Every block concentrates on a defined point, enabling individuals to review information stage by step.</p>
<p>Clarity is achieved through distance, grouping, and uniform formatting. Such tools help individuals distinguish between multiple types of information and see their connections. When content is shown directly, users are able to review such material more quickly and make judgments with stronger certainty.</p>
<h2>Contextual Alignment across Visual Narratives</h2>
<p>Interaction context defines how individuals understand image-based information. Components that are pertinent to the present interaction plinko are more ready to gain interest and support comprehension. Situational matching supports that images and copy work jointly to deliver a unified idea. That reduces confusion and supports decision accuracy.</p>
<p>Virtual interfaces commonly modify content depending to situation, presenting data that matches user patterns. Such a adaptive method improves appropriateness and supports interest. When information matches the active situation, users plinko casino are able to understand it more rapidly and react more confidently.</p>
<h2>Interface Responses and Attention Retention</h2>
<p>Small interactions contribute to preserving focus through providing subtle responses in human operations. Such brief signals, such as animations or condition shifts, reinforce engagement and guide individuals through the system. Such responses form a impression of consistency and help individuals stay attentive on the interaction plinko bonus.</p>
<p>Consistent microinteractions enable predictable behavior and lower uncertainty. When individuals recognize how the platform reacts, such individuals are able to engage more confidently. Such predictability adds to stable engagement and smoother interaction through content.</p>
<h2>Established Attention Paths</h2>
<p>Individuals develop established viewing paths when engaging with online interfaces. These behaviors affect the way focus gets allocated within the system. Frequent scanning paths, such as left-to-right plinko and top-to-bottom flow, determine which components are recognized initially. Visual presentation fits with these behaviors to channel focus clearly.</p>
<p>Building with routine viewing supports that main content is placed in zones in which individuals commonly focus. That increases exposure and enhances comprehension. Through aligning information with predictable paths, online systems are able to support effective information handling and stable engagement.</p>
<h2>Balance of Attention and Overstimulation</h2>
<p>Keeping interest needs a measured balance between involvement and overstimulation. Too many graphic components may overwhelm users and weaken the readability of the narrative. On the other side, overly minimal visual structure can be unable to capture attention. Strong image-based storytelling creates a balance that enables both engagement and understanding.</p>
<p>Measured deployment of design elements supports that notice is guided towards relevant content. That approach prevents thinking overload and plinko casino promotes sustained engagement. Measured presentation enhances ease of use and adds to more clear communication of content.</p>
<h2>Conclusion of Attention-Based Perception Strategies</h2>
<p>The focus system and image-based narrative remain closely linked in online environments. Ordered narratives, visible perceptual hierarchy, and contextual relevance enable efficient information processing. By connecting visual components with cognitive mechanisms, virtual platforms are able to hold and preserve individual attention without adding extra difficulty.</p>
<p>Strong image-based storytelling allows individuals to process content promptly and make grounded responses. Through careful organization of information and consistent presentation principles, digital environments are able to hold interest plinko bonus and support that engagements stay clear, intuitive, and useful.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://sanatandharmveda.com/focus-model-and-visual-presentation-25/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>