?<h3>D¨ızenle: wp-plupload.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/* global pluploadL10n, plupload, _wpPluploadSettings */

/**
 * @namespace wp
 */
window.wp = window.wp || {};

( function( exports, $ ) {
	var Uploader;

	if ( typeof _wpPluploadSettings === &#039;undefined&#039; ) {
		return;
	}

	/**
	 * A WordPress uploader.
	 *
	 * The Plupload library provides cross-browser uploader UI integration.
	 * This object bridges the Plupload API to integrate uploads into the
	 * WordPress back end and the WordPress media experience.
	 *
	 * @class
	 * @memberOf wp
	 * @alias wp.Uploader
	 *
	 * @param {object} options           The options passed to the new plupload instance.
	 * @param {object} options.container The id of uploader container.
	 * @param {object} options.browser   The id of button to trigger the file select.
	 * @param {object} options.dropzone  The id of file drop target.
	 * @param {object} options.plupload  An object of parameters to pass to the plupload instance.
	 * @param {object} options.params    An object of parameters to pass to $_POST when uploading the file.
	 *                                   Extends this.plupload.multipart_params under the hood.
	 */
	Uploader = function( options ) {
		var self = this,
			isIE, // Not used, back-compat.
			elements = {
				container: &#039;container&#039;,
				browser:   &#039;browse_button&#039;,
				dropzone:  &#039;drop_element&#039;
			},
			tryAgainCount = {},
			tryAgain,
			key,
			error,
			fileUploaded;

		this.supports = {
			upload: Uploader.browser.supported
		};

		this.supported = this.supports.upload;

		if ( ! this.supported ) {
			return;
		}

		// Arguments to send to pluplad.Uploader().
		// Use deep extend to ensure that multipart_params and other objects are cloned.
		this.plupload = $.extend( true, { multipart_params: {} }, Uploader.defaults );
		this.container = document.body; // Set default container.

		/*
		 * Extend the instance with options.
		 *
		 * Use deep extend to allow options.plupload to override individual
		 * default plupload keys.
		 */
		$.extend( true, this, options );

		// Proxy all methods so this always refers to the current instance.
		for ( key in this ) {
			if ( typeof this[ key ] === &#039;function&#039; ) {
				this[ key ] = $.proxy( this[ key ], this );
			}
		}

		// Ensure all elements are jQuery elements and have id attributes,
		// then set the proper plupload arguments to the ids.
		for ( key in elements ) {
			if ( ! this[ key ] ) {
				continue;
			}

			this[ key ] = $( this[ key ] ).first();

			if ( ! this[ key ].length ) {
				delete this[ key ];
				continue;
			}

			if ( ! this[ key ].prop(&#039;id&#039;) ) {
				this[ key ].prop( &#039;id&#039;, &#039;__wp-uploader-id-&#039; + Uploader.uuid++ );
			}

			this.plupload[ elements[ key ] ] = this[ key ].prop(&#039;id&#039;);
		}

		// If the uploader has neither a browse button nor a dropzone, bail.
		if ( ! ( this.browser &amp;&amp; this.browser.length ) &amp;&amp; ! ( this.dropzone &amp;&amp; this.dropzone.length ) ) {
			return;
		}

		// Initialize the plupload instance.
		this.uploader = new plupload.Uploader( this.plupload );
		delete this.plupload;

		// Set default params and remove this.params alias.
		this.param( this.params || {} );
		delete this.params;

		/**
		 * Attempt to create image sub-sizes when an image was uploaded successfully
		 * but the server responded with HTTP 5xx error.
		 *
		 * @since 5.3.0
		 *
		 * @param {string}        message Error message.
		 * @param {object}        data    Error data from Plupload.
		 * @param {plupload.File} file    File that was uploaded.
		 */
		tryAgain = function( message, data, file ) {
			var times, id;

			if ( ! data || ! data.responseHeaders ) {
				error( pluploadL10n.http_error_image, data, file, &#039;no-retry&#039; );
				return;
			}

			id = data.responseHeaders.match( /x-wp-upload-attachment-id:\s*(\d+)/i );

			if ( id &amp;&amp; id[1] ) {
				id = id[1];
			} else {
				error( pluploadL10n.http_error_image, data, file, &#039;no-retry&#039; );
				return;
			}

			times = tryAgainCount[ file.id ];

			if ( times &amp;&amp; times &gt; 4 ) {
				/*
				 * The file may have been uploaded and attachment post created,
				 * but post-processing and resizing failed...
				 * Do a cleanup then tell the user to scale down the image and upload it again.
				 */
				$.ajax({
					type: &#039;post&#039;,
					url: ajaxurl,
					dataType: &#039;json&#039;,
					data: {
						action: &#039;media-create-image-subsizes&#039;,
						_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
						attachment_id: id,
						_wp_upload_failed_cleanup: true,
					}
				});

				error( message, data, file, &#039;no-retry&#039; );
				return;
			}

			if ( ! times ) {
				tryAgainCount[ file.id ] = 1;
			} else {
				tryAgainCount[ file.id ] = ++times;
			}

			// Another request to try to create the missing image sub-sizes.
			$.ajax({
				type: &#039;post&#039;,
				url: ajaxurl,
				dataType: &#039;json&#039;,
				data: {
					action: &#039;media-create-image-subsizes&#039;,
					_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
					attachment_id: id,
				}
			}).done( function( response ) {
				if ( response.success ) {
					fileUploaded( self.uploader, file, response );
				} else {
					if ( response.data &amp;&amp; response.data.message ) {
						message = response.data.message;
					}

					error( message, data, file, &#039;no-retry&#039; );
				}
			}).fail( function( jqXHR ) {
				// If another HTTP 5xx error, try try again...
				if ( jqXHR.status &gt;= 500 &amp;&amp; jqXHR.status &lt; 600 ) {
					tryAgain( message, data, file );
					return;
				}

				error( message, data, file, &#039;no-retry&#039; );
			});
		}

		/**
		 * Custom error callback.
		 *
		 * Add a new error to the errors collection, so other modules can track
		 * and display errors. @see wp.Uploader.errors.
		 *
		 * @param {string}        message Error message.
		 * @param {object}        data    Error data from Plupload.
		 * @param {plupload.File} file    File that was uploaded.
		 * @param {string}        retry   Whether to try again to create image sub-sizes. Passing &#039;no-retry&#039; will prevent it.
		 */
		error = function( message, data, file, retry ) {
			var isImage = file.type &amp;&amp; file.type.indexOf( &#039;image/&#039; ) === 0,
				status = data &amp;&amp; data.status;

			// If the file is an image and the error is HTTP 5xx try to create sub-sizes again.
			if ( retry !== &#039;no-retry&#039; &amp;&amp; isImage &amp;&amp; status &gt;= 500 &amp;&amp; status &lt; 600 ) {
				tryAgain( message, data, file );
				return;
			}

			if ( file.attachment ) {
				file.attachment.destroy();
			}

			Uploader.errors.unshift({
				message: message || pluploadL10n.default_error,
				data:    data,
				file:    file
			});

			self.error( message, data, file );
		};

		/**
		 * After a file is successfully uploaded, update its model.
		 *
		 * @param {plupload.Uploader} up       Uploader instance.
		 * @param {plupload.File}     file     File that was uploaded.
		 * @param {Object}            response Object with response properties.
		 */
		fileUploaded = function( up, file, response ) {
			var complete;

			// Remove the &quot;uploading&quot; UI elements.
			_.each( [&#039;file&#039;,&#039;loaded&#039;,&#039;size&#039;,&#039;percent&#039;], function( key ) {
				file.attachment.unset( key );
			} );

			file.attachment.set( _.extend( response.data, { uploading: false } ) );

			wp.media.model.Attachment.get( response.data.id, file.attachment );

			complete = Uploader.queue.all( function( attachment ) {
				return ! attachment.get( &#039;uploading&#039; );
			});

			if ( complete ) {
				Uploader.queue.reset();
			}

			self.success( file.attachment );
		}

		/**
		 * After the Uploader has been initialized, initialize some behaviors for the dropzone.
		 *
		 * @param {plupload.Uploader} uploader Uploader instance.
		 */
		this.uploader.bind( &#039;init&#039;, function( uploader ) {
			var timer, active, dragdrop,
				dropzone = self.dropzone;

			dragdrop = self.supports.dragdrop = uploader.features.dragdrop &amp;&amp; ! Uploader.browser.mobile;

			// Generate drag/drop helper classes.
			if ( ! dropzone ) {
				return;
			}

			dropzone.toggleClass( &#039;supports-drag-drop&#039;, !! dragdrop );

			if ( ! dragdrop ) {
				return dropzone.unbind(&#039;.wp-uploader&#039;);
			}

			// &#039;dragenter&#039; doesn&#039;t fire correctly, simulate it with a limited &#039;dragover&#039;.
			dropzone.on( &#039;dragover.wp-uploader&#039;, function() {
				if ( timer ) {
					clearTimeout( timer );
				}

				if ( active ) {
					return;
				}

				dropzone.trigger(&#039;dropzone:enter&#039;).addClass(&#039;drag-over&#039;);
				active = true;
			});

			dropzone.on(&#039;dragleave.wp-uploader, drop.wp-uploader&#039;, function() {
				/*
				 * Using an instant timer prevents the drag-over class
				 * from being quickly removed and re-added when elements
				 * inside the dropzone are repositioned.
				 *
				 * @see https://core.trac.wordpress.org/ticket/21705
				 */
				timer = setTimeout( function() {
					active = false;
					dropzone.trigger(&#039;dropzone:leave&#039;).removeClass(&#039;drag-over&#039;);
				}, 0 );
			});

			self.ready = true;
			$(self).trigger( &#039;uploader:ready&#039; );
		});

		this.uploader.bind( &#039;postinit&#039;, function( up ) {
			up.refresh();
			self.init();
		});

		this.uploader.init();

		if ( this.browser ) {
			this.browser.on( &#039;mouseenter&#039;, this.refresh );
		} else {
			this.uploader.disableBrowse( true );
		}

		$( self ).on( &#039;uploader:ready&#039;, function() {
			$( &#039;.moxie-shim-html5 input[type=&quot;file&quot;]&#039; )
				.attr( {
					tabIndex:      &#039;-1&#039;,
					&#039;aria-hidden&#039;: &#039;true&#039;
				} );
		} );

		/**
		 * After files were filtered and added to the queue, create a model for each.
		 *
		 * @param {plupload.Uploader} up    Uploader instance.
		 * @param {Array}             files Array of file objects that were added to queue by the user.
		 */
		this.uploader.bind( &#039;FilesAdded&#039;, function( up, files ) {
			_.each( files, function( file ) {
				var attributes, image;

				// Ignore failed uploads.
				if ( plupload.FAILED === file.status ) {
					return;
				}

				if ( file.type === &#039;image/heic&#039; &amp;&amp; up.settings.heic_upload_error ) {
					// Show error but do not block uploading.
					Uploader.errors.unshift({
						message: pluploadL10n.unsupported_image,
						data:    {},
						file:    file
					});
				} else if ( file.type === &#039;image/webp&#039; &amp;&amp; up.settings.webp_upload_error ) {
					// Disallow uploading of WebP images if the server cannot edit them.
					error( pluploadL10n.noneditable_image, {}, file, &#039;no-retry&#039; );
					up.removeFile( file );
					return;
				} else if ( file.type === &#039;image/avif&#039; &amp;&amp; up.settings.avif_upload_error ) {
					// Disallow uploading of AVIF images if the server cannot edit them.
					error( pluploadL10n.noneditable_image, {}, file, &#039;no-retry&#039; );
					up.removeFile( file );
					return;
				}

				// Generate attributes for a new `Attachment` model.
				attributes = _.extend({
					file:      file,
					uploading: true,
					date:      new Date(),
					filename:  file.name,
					menuOrder: 0,
					uploadedTo: wp.media.model.settings.post.id
				}, _.pick( file, &#039;loaded&#039;, &#039;size&#039;, &#039;percent&#039; ) );

				// Handle early mime type scanning for images.
				image = /(?:jpe?g|png|gif)$/i.exec( file.name );

				// For images set the model&#039;s type and subtype attributes.
				if ( image ) {
					attributes.type = &#039;image&#039;;

					// `jpeg`, `png` and `gif` are valid subtypes.
					// `jpg` is not, so map it to `jpeg`.
					attributes.subtype = ( &#039;jpg&#039; === image[0] ) ? &#039;jpeg&#039; : image[0];
				}

				// Create a model for the attachment, and add it to the Upload queue collection
				// so listeners to the upload queue can track and display upload progress.
				file.attachment = wp.media.model.Attachment.create( attributes );
				Uploader.queue.add( file.attachment );

				self.added( file.attachment );
			});

			up.refresh();
			up.start();
		});

		this.uploader.bind( &#039;UploadProgress&#039;, function( up, file ) {
			file.attachment.set( _.pick( file, &#039;loaded&#039;, &#039;percent&#039; ) );
			self.progress( file.attachment );
		});

		/**
		 * After a file is successfully uploaded, update its model.
		 *
		 * @param {plupload.Uploader} up       Uploader instance.
		 * @param {plupload.File}     file     File that was uploaded.
		 * @param {Object}            response Object with response properties.
		 * @return {mixed}
		 */
		this.uploader.bind( &#039;FileUploaded&#039;, function( up, file, response ) {

			try {
				response = JSON.parse( response.response );
			} catch ( e ) {
				return error( pluploadL10n.default_error, e, file );
			}

			if ( ! _.isObject( response ) || _.isUndefined( response.success ) ) {
				return error( pluploadL10n.default_error, null, file );
			} else if ( ! response.success ) {
				return error( response.data &amp;&amp; response.data.message, response.data, file );
			}

			// Success. Update the UI with the new attachment.
			fileUploaded( up, file, response );
		});

		/**
		 * When plupload surfaces an error, send it to the error handler.
		 *
		 * @param {plupload.Uploader} up            Uploader instance.
		 * @param {Object}            pluploadError Contains code, message and sometimes file and other details.
		 */
		this.uploader.bind( &#039;Error&#039;, function( up, pluploadError ) {
			var message = pluploadL10n.default_error,
				key;

			// Check for plupload errors.
			for ( key in Uploader.errorMap ) {
				if ( pluploadError.code === plupload[ key ] ) {
					message = Uploader.errorMap[ key ];

					if ( typeof message === &#039;function&#039; ) {
						message = message( pluploadError.file, pluploadError );
					}

					break;
				}
			}

			error( message, pluploadError, pluploadError.file );
			up.refresh();
		});

	};

	// Adds the &#039;defaults&#039; and &#039;browser&#039; properties.
	$.extend( Uploader, _wpPluploadSettings );

	Uploader.uuid = 0;

	// Map Plupload error codes to user friendly error messages.
	Uploader.errorMap = {
		&#039;FAILED&#039;:                 pluploadL10n.upload_failed,
		&#039;FILE_EXTENSION_ERROR&#039;:   pluploadL10n.invalid_filetype,
		&#039;IMAGE_FORMAT_ERROR&#039;:     pluploadL10n.not_an_image,
		&#039;IMAGE_MEMORY_ERROR&#039;:     pluploadL10n.image_memory_exceeded,
		&#039;IMAGE_DIMENSIONS_ERROR&#039;: pluploadL10n.image_dimensions_exceeded,
		&#039;GENERIC_ERROR&#039;:          pluploadL10n.upload_failed,
		&#039;IO_ERROR&#039;:               pluploadL10n.io_error,
		&#039;SECURITY_ERROR&#039;:         pluploadL10n.security_error,

		&#039;FILE_SIZE_ERROR&#039;: function( file ) {
			return pluploadL10n.file_exceeds_size_limit.replace( &#039;%s&#039;, file.name );
		},

		&#039;HTTP_ERROR&#039;: function( file ) {
			if ( file.type &amp;&amp; file.type.indexOf( &#039;image/&#039; ) === 0 ) {
				return pluploadL10n.http_error_image;
			}

			return pluploadL10n.http_error;
		},
	};

	$.extend( Uploader.prototype, /** @lends wp.Uploader.prototype */{
		/**
		 * Acts as a shortcut to extending the uploader&#039;s multipart_params object.
		 *
		 * param( key )
		 *    Returns the value of the key.
		 *
		 * param( key, value )
		 *    Sets the value of a key.
		 *
		 * param( map )
		 *    Sets values for a map of data.
		 */
		param: function( key, value ) {
			if ( arguments.length === 1 &amp;&amp; typeof key === &#039;string&#039; ) {
				return this.uploader.settings.multipart_params[ key ];
			}

			if ( arguments.length &gt; 1 ) {
				this.uploader.settings.multipart_params[ key ] = value;
			} else {
				$.extend( this.uploader.settings.multipart_params, key );
			}
		},

		/**
		 * Make a few internal event callbacks available on the wp.Uploader object
		 * to change the Uploader internals if absolutely necessary.
		 */
		init:     function() {},
		error:    function() {},
		success:  function() {},
		added:    function() {},
		progress: function() {},
		complete: function() {},
		refresh:  function() {
			var node, attached, container, id;

			if ( this.browser ) {
				node = this.browser[0];

				// Check if the browser node is in the DOM.
				while ( node ) {
					if ( node === document.body ) {
						attached = true;
						break;
					}
					node = node.parentNode;
				}

				/*
				 * If the browser node is not attached to the DOM,
				 * use a temporary container to house it, as the browser button shims
				 * require the button to exist in the DOM at all times.
				 */
				if ( ! attached ) {
					id = &#039;wp-uploader-browser-&#039; + this.uploader.id;

					container = $( &#039;#&#039; + id );
					if ( ! container.length ) {
						container = $(&#039;&lt;div class=&quot;wp-uploader-browser&quot; /&gt;&#039;).css({
							position: &#039;fixed&#039;,
							top: &#039;-1000px&#039;,
							left: &#039;-1000px&#039;,
							height: 0,
							width: 0
						}).attr( &#039;id&#039;, &#039;wp-uploader-browser-&#039; + this.uploader.id ).appendTo(&#039;body&#039;);
					}

					container.append( this.browser );
				}
			}

			this.uploader.refresh();
		}
	});

	// Create a collection of attachments in the upload queue,
	// so that other modules can track and display upload progress.
	Uploader.queue = new wp.media.model.Attachments( [], { query: false });

	// Create a collection to collect errors incurred while attempting upload.
	Uploader.errors = new Backbone.Collection();

	exports.Uploader = Uploader;
})( wp, jQuery );
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Fjs'>?? Yukar?</a>