initial commit

hamrokhaanpaan/wp-includes/js/plupload/handlers.js

@@ -0,0 +1,657 @@
+/* global plupload, pluploadL10n, ajaxurl, post_id, wpUploaderInit, deleteUserSetting, setUserSetting, getUserSetting, shortform */
+var topWin = window.dialogArguments || opener || parent || top, uploader, uploader_init;
+
+// Progress and success handlers for media multi uploads.
+function fileQueued( fileObj ) {
+	// Get rid of unused form.
+	jQuery( '.media-blank' ).remove();
+
+	var items = jQuery( '#media-items' ).children(), postid = post_id || 0;
+
+	// Collapse a single item.
+	if ( items.length == 1 ) {
+		items.removeClass( 'open' ).find( '.slidetoggle' ).slideUp( 200 );
+	}
+	// Create a progress bar containing the filename.
+	jQuery( '<div class="media-item">' )
+		.attr( 'id', 'media-item-' + fileObj.id )
+		.addClass( 'child-of-' + postid )
+		.append( '<div class="progress"><div class="percent">0%</div><div class="bar"></div></div>',
+			jQuery( '<div class="filename original">' ).text( ' ' + fileObj.name ) )
+		.appendTo( jQuery( '#media-items' ) );
+
+	// Disable submit.
+	jQuery( '#insert-gallery' ).prop( 'disabled', true );
+}
+
+function uploadStart() {
+	try {
+		if ( typeof topWin.tb_remove != 'undefined' )
+			topWin.jQuery( '#TB_overlay' ).unbind( 'click', topWin.tb_remove );
+	} catch( e ){}
+
+	return true;
+}
+
+function uploadProgress( up, file ) {
+	var item = jQuery( '#media-item-' + file.id );
+
+	jQuery( '.bar', item ).width( ( 200 * file.loaded ) / file.size );
+	jQuery( '.percent', item ).html( file.percent + '%' );
+}
+
+// Check to see if a large file failed to upload.
+function fileUploading( up, file ) {
+	var hundredmb = 100 * 1024 * 1024,
+		max = parseInt( up.settings.max_file_size, 10 );
+
+	if ( max > hundredmb && file.size > hundredmb ) {
+		setTimeout( function() {
+			if ( file.status < 3 && file.loaded === 0 ) { // Not uploading.
+				wpFileError( file, pluploadL10n.big_upload_failed.replace( '%1$s', '<a class="uploader-html" href="#">' ).replace( '%2$s', '</a>' ) );
+				up.stop();  // Stop the whole queue.
+				up.removeFile( file );
+				up.start(); // Restart the queue.
+			}
+		}, 10000 ); // Wait for 10 seconds for the file to start uploading.
+	}
+}
+
+function updateMediaForm() {
+	var items = jQuery( '#media-items' ).children();
+
+	// Just one file, no need for collapsible part.
+	if ( items.length == 1 ) {
+		items.addClass( 'open' ).find( '.slidetoggle' ).show();
+		jQuery( '.insert-gallery' ).hide();
+	} else if ( items.length > 1 ) {
+		items.removeClass( 'open' );
+		// Only show Gallery/Playlist buttons when there are at least two files.
+		jQuery( '.insert-gallery' ).show();
+	}
+
+	// Only show Save buttons when there is at least one file.
+	if ( items.not( '.media-blank' ).length > 0 )
+		jQuery( '.savebutton' ).show();
+	else
+		jQuery( '.savebutton' ).hide();
+}
+
+function uploadSuccess( fileObj, serverData ) {
+	var item = jQuery( '#media-item-' + fileObj.id );
+
+	// On success serverData should be numeric,
+	// fix bug in html4 runtime returning the serverData wrapped in a <pre> tag.
+	if ( typeof serverData === 'string' ) {
+		serverData = serverData.replace( /^<pre>(\d+)<\/pre>$/, '$1' );
+
+		// If async-upload returned an error message, place it in the media item div and return.
+		if ( /media-upload-error|error-div/.test( serverData ) ) {
+			item.html( serverData );
+			return;
+		}
+	}
+
+	item.find( '.percent' ).html( pluploadL10n.crunching );
+
+	prepareMediaItem( fileObj, serverData );
+	updateMediaForm();
+
+	// Increment the counter.
+	if ( post_id && item.hasClass( 'child-of-' + post_id ) ) {
+		jQuery( '#attachments-count' ).text( 1 * jQuery( '#attachments-count' ).text() + 1 );
+	}
+}
+
+function setResize( arg ) {
+	if ( arg ) {
+		if ( window.resize_width && window.resize_height ) {
+			uploader.settings.resize = {
+				enabled: true,
+				width: window.resize_width,
+				height: window.resize_height,
+				quality: 100
+			};
+		} else {
+			uploader.settings.multipart_params.image_resize = true;
+		}
+	} else {
+		delete( uploader.settings.multipart_params.image_resize );
+	}
+}
+
+function prepareMediaItem( fileObj, serverData ) {
+	var f = ( typeof shortform == 'undefined' ) ? 1 : 2, item = jQuery( '#media-item-' + fileObj.id );
+	if ( f == 2 && shortform > 2 )
+		f = shortform;
+
+	try {
+		if ( typeof topWin.tb_remove != 'undefined' )
+			topWin.jQuery( '#TB_overlay' ).click( topWin.tb_remove );
+	} catch( e ){}
+
+	if ( isNaN( serverData ) || !serverData ) {
+		// Old style: Append the HTML returned by the server -- thumbnail and form inputs.
+		item.append( serverData );
+		prepareMediaItemInit( fileObj );
+	} else {
+		// New style: server data is just the attachment ID, fetch the thumbnail and form html from the server.
+		item.load( 'async-upload.php', {attachment_id:serverData, fetch:f}, function(){prepareMediaItemInit( fileObj );updateMediaForm();});
+	}
+}
+
+function prepareMediaItemInit( fileObj ) {
+	var item = jQuery( '#media-item-' + fileObj.id );
+	// Clone the thumbnail as a "pinkynail" -- a tiny image to the left of the filename.
+	jQuery( '.thumbnail', item ).clone().attr( 'class', 'pinkynail toggle' ).prependTo( item );
+
+	// Replace the original filename with the new (unique) one assigned during upload.
+	jQuery( '.filename.original', item ).replaceWith( jQuery( '.filename.new', item ) );
+
+	// Bind Ajax to the new Delete button.
+	jQuery( 'a.delete', item ).click( function(){
+		// Tell the server to delete it. TODO: Handle exceptions.
+		jQuery.ajax({
+			url: ajaxurl,
+			type: 'post',
+			success: deleteSuccess,
+			error: deleteError,
+			id: fileObj.id,
+			data: {
+				id : this.id.replace(/[^0-9]/g, '' ),
+				action : 'trash-post',
+				_ajax_nonce : this.href.replace(/^.*wpnonce=/,'' )
+			}
+		});
+		return false;
+	});
+
+	// Bind Ajax to the new Undo button.
+	jQuery( 'a.undo', item ).click( function(){
+		// Tell the server to untrash it. TODO: Handle exceptions.
+		jQuery.ajax({
+			url: ajaxurl,
+			type: 'post',
+			id: fileObj.id,
+			data: {
+				id : this.id.replace(/[^0-9]/g,'' ),
+				action: 'untrash-post',
+				_ajax_nonce: this.href.replace(/^.*wpnonce=/,'' )
+			},
+			success: function( ){
+				var type,
+					item = jQuery( '#media-item-' + fileObj.id );
+
+				if ( type = jQuery( '#type-of-' + fileObj.id ).val() )
+					jQuery( '#' + type + '-counter' ).text( jQuery( '#' + type + '-counter' ).text()-0+1 );
+
+				if ( post_id && item.hasClass( 'child-of-'+post_id ) )
+					jQuery( '#attachments-count' ).text( jQuery( '#attachments-count' ).text()-0+1 );
+
+				jQuery( '.filename .trashnotice', item ).remove();
+				jQuery( '.filename .title', item ).css( 'font-weight','normal' );
+				jQuery( 'a.undo', item ).addClass( 'hidden' );
+				jQuery( '.menu_order_input', item ).show();
+				item.css( {backgroundColor:'#ceb'} ).animate( {backgroundColor: '#fff'}, { queue: false, duration: 500, complete: function(){ jQuery( this ).css({backgroundColor:''}); } }).removeClass( 'undo' );
+			}
+		});
+		return false;
+	});
+
+	// Open this item if it says to start open (e.g. to display an error).
+	jQuery( '#media-item-' + fileObj.id + '.startopen' ).removeClass( 'startopen' ).addClass( 'open' ).find( 'slidetoggle' ).fadeIn();
+}
+
+// Generic error message.
+function wpQueueError( message ) {
+	jQuery( '#media-upload-error' ).show().html( '<div class="error"><p>' + message + '</p></div>' );
+}
+
+// File-specific error messages.
+function wpFileError( fileObj, message ) {
+	itemAjaxError( fileObj.id, message );
+}
+
+function itemAjaxError( id, message ) {
+	var item = jQuery( '#media-item-' + id ), filename = item.find( '.filename' ).text(), last_err = item.data( 'last-err' );
+
+	if ( last_err == id ) // Prevent firing an error for the same file twice.
+		return;
+
+	item.html( '<div class="error-div">' +
+				'<a class="dismiss" href="#">' + pluploadL10n.dismiss + '</a>' +
+				'<strong>' + pluploadL10n.error_uploading.replace( '%s', jQuery.trim( filename )) + '</strong> ' +
+				message +
+				'</div>' ).data( 'last-err', id );
+}
+
+function deleteSuccess( data ) {
+	var type, id, item;
+	if ( data == '-1' )
+		return itemAjaxError( this.id, 'You do not have permission. Has your session expired?' );
+
+	if ( data == '0' )
+		return itemAjaxError( this.id, 'Could not be deleted. Has it been deleted already?' );
+
+	id = this.id;
+	item = jQuery( '#media-item-' + id );
+
+	// Decrement the counters.
+	if ( type = jQuery( '#type-of-' + id ).val() )
+		jQuery( '#' + type + '-counter' ).text( jQuery( '#' + type + '-counter' ).text() - 1 );
+
+	if ( post_id && item.hasClass( 'child-of-'+post_id ) )
+		jQuery( '#attachments-count' ).text( jQuery( '#attachments-count' ).text() - 1 );
+
+	if ( jQuery( 'form.type-form #media-items' ).children().length == 1 && jQuery( '.hidden', '#media-items' ).length > 0 ) {
+		jQuery( '.toggle' ).toggle();
+		jQuery( '.slidetoggle' ).slideUp( 200 ).siblings().removeClass( 'hidden' );
+	}
+
+	// Vanish it.
+	jQuery( '.toggle', item ).toggle();
+	jQuery( '.slidetoggle', item ).slideUp( 200 ).siblings().removeClass( 'hidden' );
+	item.css( {backgroundColor:'#faa'} ).animate( {backgroundColor:'#f4f4f4'}, {queue:false, duration:500} ).addClass( 'undo' );
+
+	jQuery( '.filename:empty', item ).remove();
+	jQuery( '.filename .title', item ).css( 'font-weight','bold' );
+	jQuery( '.filename', item ).append( '<span class="trashnotice"> ' + pluploadL10n.deleted + ' </span>' ).siblings( 'a.toggle' ).hide();
+	jQuery( '.filename', item ).append( jQuery( 'a.undo', item ).removeClass( 'hidden' ) );
+	jQuery( '.menu_order_input', item ).hide();
+
+	return;
+}
+
+function deleteError() {
+}
+
+function uploadComplete() {
+	jQuery( '#insert-gallery' ).prop( 'disabled', false );
+}
+
+function switchUploader( s ) {
+	if ( s ) {
+		deleteUserSetting( 'uploader' );
+		jQuery( '.media-upload-form' ).removeClass( 'html-uploader' );
+
+		if ( typeof( uploader ) == 'object' )
+			uploader.refresh();
+	} else {
+		setUserSetting( 'uploader', '1' ); // 1 == html uploader.
+		jQuery( '.media-upload-form' ).addClass( 'html-uploader' );
+	}
+}
+
+function uploadError( fileObj, errorCode, message, up ) {
+	var hundredmb = 100 * 1024 * 1024, max;
+
+	switch ( errorCode ) {
+		case plupload.FAILED:
+			wpFileError( fileObj, pluploadL10n.upload_failed );
+			break;
+		case plupload.FILE_EXTENSION_ERROR:
+			wpFileExtensionError( up, fileObj, pluploadL10n.invalid_filetype );
+			break;
+		case plupload.FILE_SIZE_ERROR:
+			uploadSizeError( up, fileObj );
+			break;
+		case plupload.IMAGE_FORMAT_ERROR:
+			wpFileError( fileObj, pluploadL10n.not_an_image );
+			break;
+		case plupload.IMAGE_MEMORY_ERROR:
+			wpFileError( fileObj, pluploadL10n.image_memory_exceeded );
+			break;
+		case plupload.IMAGE_DIMENSIONS_ERROR:
+			wpFileError( fileObj, pluploadL10n.image_dimensions_exceeded );
+			break;
+		case plupload.GENERIC_ERROR:
+			wpQueueError( pluploadL10n.upload_failed );
+			break;
+		case plupload.IO_ERROR:
+			max = parseInt( up.settings.filters.max_file_size, 10 );
+
+			if ( max > hundredmb && fileObj.size > hundredmb ) {
+				wpFileError( fileObj, pluploadL10n.big_upload_failed.replace( '%1$s', '<a class="uploader-html" href="#">' ).replace( '%2$s', '</a>' ) );
+			} else {
+				wpQueueError( pluploadL10n.io_error );
+			}
+
+			break;
+		case plupload.HTTP_ERROR:
+			wpQueueError( pluploadL10n.http_error );
+			break;
+		case plupload.INIT_ERROR:
+			jQuery( '.media-upload-form' ).addClass( 'html-uploader' );
+			break;
+		case plupload.SECURITY_ERROR:
+			wpQueueError( pluploadL10n.security_error );
+			break;
+/*		case plupload.UPLOAD_ERROR.UPLOAD_STOPPED:
+		case plupload.UPLOAD_ERROR.FILE_CANCELLED:
+			jQuery( '#media-item-' + fileObj.id ).remove();
+			break;*/
+		default:
+			wpFileError( fileObj, pluploadL10n.default_error );
+	}
+}
+
+function uploadSizeError( up, file ) {
+	var message, errorDiv;
+
+	message = pluploadL10n.file_exceeds_size_limit.replace( '%s', file.name );
+
+	// Construct the error div.
+	errorDiv = jQuery( '<div />' )
+		.attr( {
+			'id':    'media-item-' + file.id,
+			'class': 'media-item error'
+		} )
+		.append(
+			jQuery( '<p />' )
+				.text( message )
+		);
+
+	// Append the error.
+	jQuery( '#media-items' ).append( errorDiv );
+	up.removeFile( file );
+}
+
+function wpFileExtensionError( up, file, message ) {
+	jQuery( '#media-items' ).append( '<div id="media-item-' + file.id + '" class="media-item error"><p>' + message + '</p></div>' );
+	up.removeFile( file );
+}
+
+/**
+ * Copies the attachment URL to the clipboard.
+ *
+ * @since 5.8.0
+ *
+ * @param {MouseEvent} event A click event.
+ *
+ * @return {void}
+ */
+function copyAttachmentUploadURLClipboard() {
+	var clipboard = new ClipboardJS( '.copy-attachment-url' ),
+		successTimeout;
+
+	clipboard.on( 'success', function( event ) {
+		var triggerElement = jQuery( event.trigger ),
+			successElement = jQuery( '.success', triggerElement.closest( '.copy-to-clipboard-container' ) );
+
+		// Clear the selection and move focus back to the trigger.
+		event.clearSelection();
+		// Handle ClipboardJS focus bug, see https://github.com/zenorocha/clipboard.js/issues/680
+		triggerElement.trigger( 'focus' );
+		// Show success visual feedback.
+		clearTimeout( successTimeout );
+		successElement.removeClass( 'hidden' );
+		// Hide success visual feedback after 3 seconds since last success.
+		successTimeout = setTimeout( function() {
+			successElement.addClass( 'hidden' );
+		}, 3000 );
+		// Handle success audible feedback.
+		wp.a11y.speak( pluploadL10n.file_url_copied );
+	} );
+}
+
+jQuery( document ).ready( function( $ ) {
+	copyAttachmentUploadURLClipboard();
+	var tryAgainCount = {};
+	var tryAgain;
+
+	$( '.media-upload-form' ).bind( 'click.uploader', function( e ) {
+		var target = $( e.target ), tr, c;
+
+		if ( target.is( 'input[type="radio"]' ) ) { // Remember the last used image size and alignment.
+			tr = target.closest( 'tr' );
+
+			if ( tr.hasClass( 'align' ) )
+				setUserSetting( 'align', target.val() );
+			else if ( tr.hasClass( 'image-size' ) )
+				setUserSetting( 'imgsize', target.val() );
+
+		} else if ( target.is( 'button.button' ) ) { // Remember the last used image link url.
+			c = e.target.className || '';
+			c = c.match( /url([^ '"]+)/ );
+
+			if ( c && c[1] ) {
+				setUserSetting( 'urlbutton', c[1] );
+				target.siblings( '.urlfield' ).val( target.data( 'link-url' ) );
+			}
+		} else if ( target.is( 'a.dismiss' ) ) {
+			target.parents( '.media-item' ).fadeOut( 200, function() {
+				$( this ).remove();
+			} );
+		} else if ( target.is( '.upload-flash-bypass a' ) || target.is( 'a.uploader-html' ) ) { // Switch uploader to html4.
+			$( '#media-items, p.submit, span.big-file-warning' ).css( 'display', 'none' );
+			switchUploader( 0 );
+			e.preventDefault();
+		} else if ( target.is( '.upload-html-bypass a' ) ) { // Switch uploader to multi-file.
+			$( '#media-items, p.submit, span.big-file-warning' ).css( 'display', '' );
+			switchUploader( 1 );
+			e.preventDefault();
+		} else if ( target.is( 'a.describe-toggle-on' ) ) { // Show.
+			target.parent().addClass( 'open' );
+			target.siblings( '.slidetoggle' ).fadeIn( 250, function() {
+				var S = $( window ).scrollTop(),
+					H = $( window ).height(),
+					top = $( this ).offset().top,
+					h = $( this ).height(),
+					b,
+					B;
+
+				if ( H && top && h ) {
+					b = top + h;
+					B = S + H;
+
+					if ( b > B ) {
+						if ( b - B < top - S )
+							window.scrollBy( 0, ( b - B ) + 10 );
+						else
+							window.scrollBy( 0, top - S - 40 );
+					}
+				}
+			} );
+
+			e.preventDefault();
+		} else if ( target.is( 'a.describe-toggle-off' ) ) { // Hide.
+			target.siblings( '.slidetoggle' ).fadeOut( 250, function() {
+				target.parent().removeClass( 'open' );
+			} );
+
+			e.preventDefault();
+		}
+	});
+
+	// Attempt to create image sub-sizes when an image was uploaded successfully
+	// but the server responded with an HTTP 5xx error.
+	tryAgain = function( up, error ) {
+		var file = error.file;
+		var times;
+		var id;
+
+		if ( ! error || ! error.responseHeaders ) {
+			wpQueueError( pluploadL10n.http_error_image );
+			return;
+		}
+
+		id = error.responseHeaders.match( /x-wp-upload-attachment-id:\s*(\d+)/i );
+
+		if ( id && id[1] ) {
+			id = id[1];
+		} else {
+			wpQueueError( pluploadL10n.http_error_image );
+			return;
+		}
+
+		times = tryAgainCount[ file.id ];
+
+		if ( times && times > 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: 'post',
+				url: ajaxurl,
+				dataType: 'json',
+				data: {
+					action: 'media-create-image-subsizes',
+					_wpnonce: wpUploaderInit.multipart_params._wpnonce,
+					attachment_id: id,
+					_wp_upload_failed_cleanup: true,
+				}
+			});
+
+			if ( error.message && ( error.status < 500 || error.status >= 600 ) ) {
+				wpQueueError( error.message );
+			} else {
+				wpQueueError( pluploadL10n.http_error_image );
+			}
+
+			return;
+		}
+
+		if ( ! times ) {
+			tryAgainCount[ file.id ] = 1;
+		} else {
+			tryAgainCount[ file.id ] = ++times;
+		}
+
+		// Try to create the missing image sizes.
+		$.ajax({
+			type: 'post',
+			url: ajaxurl,
+			dataType: 'json',
+			data: {
+				action: 'media-create-image-subsizes',
+				_wpnonce: wpUploaderInit.multipart_params._wpnonce,
+				attachment_id: id,
+				_legacy_support: 'true',
+			}
+		}).done( function( response ) {
+			var message;
+
+			if ( response.success ) {
+				uploadSuccess( file, response.data.id );
+			} else {
+				if ( response.data && response.data.message ) {
+					message = response.data.message;
+				}
+
+				wpQueueError( message || pluploadL10n.http_error_image );
+			}
+		}).fail( function( jqXHR ) {
+			// If another HTTP 5xx error, try try again...
+			if ( jqXHR.status >= 500 && jqXHR.status < 600 ) {
+				tryAgain( up, error );
+				return;
+			}
+
+			wpQueueError( pluploadL10n.http_error_image );
+		});
+	}
+
+	// Init and set the uploader.
+	uploader_init = function() {
+		uploader = new plupload.Uploader( wpUploaderInit );
+
+		$( '#image_resize' ).bind( 'change', function() {
+			var arg = $( this ).prop( 'checked' );
+
+			setResize( arg );
+
+			if ( arg )
+				setUserSetting( 'upload_resize', '1' );
+			else
+				deleteUserSetting( 'upload_resize' );
+		});
+
+		uploader.bind( 'Init', function( up ) {
+			var uploaddiv = $( '#plupload-upload-ui' );
+
+			setResize( getUserSetting( 'upload_resize', false ) );
+
+			if ( up.features.dragdrop && ! $( document.body ).hasClass( 'mobile' ) ) {
+				uploaddiv.addClass( 'drag-drop' );
+
+				$( '#drag-drop-area' ).on( 'dragover.wp-uploader', function() { // dragenter doesn't fire right :(
+					uploaddiv.addClass( 'drag-over' );
+				}).on( 'dragleave.wp-uploader, drop.wp-uploader', function() {
+					uploaddiv.removeClass( 'drag-over' );
+				});
+			} else {
+				uploaddiv.removeClass( 'drag-drop' );
+				$( '#drag-drop-area' ).off( '.wp-uploader' );
+			}
+
+			if ( up.runtime === 'html4' ) {
+				$( '.upload-flash-bypass' ).hide();
+			}
+		});
+
+		uploader.bind( 'postinit', function( up ) {
+			up.refresh();
+		});
+
+		uploader.init();
+
+		uploader.bind( 'FilesAdded', function( up, files ) {
+			$( '#media-upload-error' ).empty();
+			uploadStart();
+
+			plupload.each( files, function( file ) {
+				if ( file.type === 'image/heic' && up.settings.heic_upload_error ) {
+					// Show error but do not block uploading.
+					wpQueueError( pluploadL10n.unsupported_image );
+				} else if ( file.type === 'image/webp' && up.settings.webp_upload_error ) {
+					// Disallow uploading of WebP images if the server cannot edit them.
+					wpQueueError( pluploadL10n.noneditable_image );
+					up.removeFile( file );
+					return;
+				}
+
+				fileQueued( file );
+			});
+
+			up.refresh();
+			up.start();
+		});
+
+		uploader.bind( 'UploadFile', function( up, file ) {
+			fileUploading( up, file );
+		});
+
+		uploader.bind( 'UploadProgress', function( up, file ) {
+			uploadProgress( up, file );
+		});
+
+		uploader.bind( 'Error', function( up, error ) {
+			var isImage = error.file && error.file.type && error.file.type.indexOf( 'image/' ) === 0;
+			var status  = error && error.status;
+
+			// If the file is an image and the error is HTTP 5xx try to create sub-sizes again.
+			if ( isImage && status >= 500 && status < 600 ) {
+				tryAgain( up, error );
+				return;
+			}
+
+			uploadError( error.file, error.code, error.message, up );
+			up.refresh();
+		});
+
+		uploader.bind( 'FileUploaded', function( up, file, response ) {
+			uploadSuccess( file, response.response );
+		});
+
+		uploader.bind( 'UploadComplete', function() {
+			uploadComplete();
+		});
+	};
+
+	if ( typeof( wpUploaderInit ) == 'object' ) {
+		uploader_init();
+	}
+
+});

hamrokhaanpaan/wp-includes/js/plupload/license.txt

@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

hamrokhaanpaan/wp-includes/js/plupload/wp-plupload.js

@@ -0,0 +1,576 @@
+/* global pluploadL10n, plupload, _wpPluploadSettings */
+
+/**
+ * @namespace wp
+ */
+window.wp = window.wp || {};
+
+( function( exports, $ ) {
+	var Uploader;
+
+	if ( typeof _wpPluploadSettings === 'undefined' ) {
+		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: 'container',
+				browser:   'browse_button',
+				dropzone:  'drop_element'
+			},
+			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 ] === 'function' ) {
+				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('id') ) {
+				this[ key ].prop( 'id', '__wp-uploader-id-' + Uploader.uuid++ );
+			}
+
+			this.plupload[ elements[ key ] ] = this[ key ].prop('id');
+		}
+
+		// If the uploader has neither a browse button nor a dropzone, bail.
+		if ( ! ( this.browser && this.browser.length ) && ! ( this.dropzone && 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, 'no-retry' );
+				return;
+			}
+
+			id = data.responseHeaders.match( /x-wp-upload-attachment-id:\s*(\d+)/i );
+
+			if ( id && id[1] ) {
+				id = id[1];
+			} else {
+				error( pluploadL10n.http_error_image, data, file, 'no-retry' );
+				return;
+			}
+
+			times = tryAgainCount[ file.id ];
+
+			if ( times && times > 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: 'post',
+					url: ajaxurl,
+					dataType: 'json',
+					data: {
+						action: 'media-create-image-subsizes',
+						_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
+						attachment_id: id,
+						_wp_upload_failed_cleanup: true,
+					}
+				});
+
+				error( message, data, file, 'no-retry' );
+				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: 'post',
+				url: ajaxurl,
+				dataType: 'json',
+				data: {
+					action: 'media-create-image-subsizes',
+					_wpnonce: _wpPluploadSettings.defaults.multipart_params._wpnonce,
+					attachment_id: id,
+				}
+			}).done( function( response ) {
+				if ( response.success ) {
+					fileUploaded( self.uploader, file, response );
+				} else {
+					if ( response.data && response.data.message ) {
+						message = response.data.message;
+					}
+
+					error( message, data, file, 'no-retry' );
+				}
+			}).fail( function( jqXHR ) {
+				// If another HTTP 5xx error, try try again...
+				if ( jqXHR.status >= 500 && jqXHR.status < 600 ) {
+					tryAgain( message, data, file );
+					return;
+				}
+
+				error( message, data, file, 'no-retry' );
+			});
+		}
+
+		/**
+		 * 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 'no-retry' will prevent it.
+		 */
+		error = function( message, data, file, retry ) {
+			var isImage = file.type && file.type.indexOf( 'image/' ) === 0,
+				status = data && data.status;
+
+			// If the file is an image and the error is HTTP 5xx try to create sub-sizes again.
+			if ( retry !== 'no-retry' && isImage && status >= 500 && status < 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 "uploading" UI elements.
+			_.each( ['file','loaded','size','percent'], 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( 'uploading' );
+			});
+
+			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( 'init', function( uploader ) {
+			var timer, active, dragdrop,
+				dropzone = self.dropzone;
+
+			dragdrop = self.supports.dragdrop = uploader.features.dragdrop && ! Uploader.browser.mobile;
+
+			// Generate drag/drop helper classes.
+			if ( ! dropzone ) {
+				return;
+			}
+
+			dropzone.toggleClass( 'supports-drag-drop', !! dragdrop );
+
+			if ( ! dragdrop ) {
+				return dropzone.unbind('.wp-uploader');
+			}
+
+			// 'dragenter' doesn't fire correctly, simulate it with a limited 'dragover'.
+			dropzone.on( 'dragover.wp-uploader', function() {
+				if ( timer ) {
+					clearTimeout( timer );
+				}
+
+				if ( active ) {
+					return;
+				}
+
+				dropzone.trigger('dropzone:enter').addClass('drag-over');
+				active = true;
+			});
+
+			dropzone.on('dragleave.wp-uploader, drop.wp-uploader', 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('dropzone:leave').removeClass('drag-over');
+				}, 0 );
+			});
+
+			self.ready = true;
+			$(self).trigger( 'uploader:ready' );
+		});
+
+		this.uploader.bind( 'postinit', function( up ) {
+			up.refresh();
+			self.init();
+		});
+
+		this.uploader.init();
+
+		if ( this.browser ) {
+			this.browser.on( 'mouseenter', this.refresh );
+		} else {
+			this.uploader.disableBrowse( true );
+		}
+
+		$( self ).on( 'uploader:ready', function() {
+			$( '.moxie-shim-html5 input[type="file"]' )
+				.attr( {
+					tabIndex:      '-1',
+					'aria-hidden': 'true'
+				} );
+		} );
+
+		/**
+		 * 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( 'FilesAdded', function( up, files ) {
+			_.each( files, function( file ) {
+				var attributes, image;
+
+				// Ignore failed uploads.
+				if ( plupload.FAILED === file.status ) {
+					return;
+				}
+
+				if ( file.type === 'image/heic' && 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 === 'image/webp' && up.settings.webp_upload_error ) {
+					// Disallow uploading of WebP images if the server cannot edit them.
+					error( pluploadL10n.noneditable_image, {}, file, 'no-retry' );
+					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, 'loaded', 'size', 'percent' ) );
+
+				// Handle early mime type scanning for images.
+				image = /(?:jpe?g|png|gif)$/i.exec( file.name );
+
+				// For images set the model's type and subtype attributes.
+				if ( image ) {
+					attributes.type = 'image';
+
+					// `jpeg`, `png` and `gif` are valid subtypes.
+					// `jpg` is not, so map it to `jpeg`.
+					attributes.subtype = ( 'jpg' === image[0] ) ? 'jpeg' : 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( 'UploadProgress', function( up, file ) {
+			file.attachment.set( _.pick( file, 'loaded', 'percent' ) );
+			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( 'FileUploaded', 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 && 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( 'Error', 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 === 'function' ) {
+						message = message( pluploadError.file, pluploadError );
+					}
+
+					break;
+				}
+			}
+
+			error( message, pluploadError, pluploadError.file );
+			up.refresh();
+		});
+
+	};
+
+	// Adds the 'defaults' and 'browser' properties.
+	$.extend( Uploader, _wpPluploadSettings );
+
+	Uploader.uuid = 0;
+
+	// Map Plupload error codes to user friendly error messages.
+	Uploader.errorMap = {
+		'FAILED':                 pluploadL10n.upload_failed,
+		'FILE_EXTENSION_ERROR':   pluploadL10n.invalid_filetype,
+		'IMAGE_FORMAT_ERROR':     pluploadL10n.not_an_image,
+		'IMAGE_MEMORY_ERROR':     pluploadL10n.image_memory_exceeded,
+		'IMAGE_DIMENSIONS_ERROR': pluploadL10n.image_dimensions_exceeded,
+		'GENERIC_ERROR':          pluploadL10n.upload_failed,
+		'IO_ERROR':               pluploadL10n.io_error,
+		'SECURITY_ERROR':         pluploadL10n.security_error,
+
+		'FILE_SIZE_ERROR': function( file ) {
+			return pluploadL10n.file_exceeds_size_limit.replace( '%s', file.name );
+		},
+
+		'HTTP_ERROR': function( file ) {
+			if ( file.type && file.type.indexOf( 'image/' ) === 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'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 && typeof key === 'string' ) {
+				return this.uploader.settings.multipart_params[ key ];
+			}
+
+			if ( arguments.length > 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 = 'wp-uploader-browser-' + this.uploader.id;
+
+					container = $( '#' + id );
+					if ( ! container.length ) {
+						container = $('<div class="wp-uploader-browser" />').css({
+							position: 'fixed',
+							top: '-1000px',
+							left: '-1000px',
+							height: 0,
+							width: 0
+						}).attr( 'id', 'wp-uploader-browser-' + this.uploader.id ).appendTo('body');
+					}
+
+					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 );