window.wp = window.wp || {};

	var Uploader;

		return;

	 *

	 *

	 */

	Uploader = function( options ) {

		var self = this,

			elements = {

				container: 'container',

				browser:   'browse_button',

				dropzone:  'drop_element'

			},

			key, error;

		this.supports = {

			upload: Uploader.browser.supported

		};

		this.supported = this.supports.upload;

			return;

		// 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.

		//

		// 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 ) {

				this[ key ] = $.proxy( this[ key ], this );

		}

		for ( key in elements ) {

				continue;

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

			if ( ! this[ key ].length ) {

				delete this[ key ];

				continue;

			}

				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.

			return;

		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;

		error = function( message, data, file ) {

				file.attachment.destroy();

			Uploader.errors.unshift({

				message: message || pluploadL10n.default_error,

				data:    data,

				file:    file

			});

			self.error( message, data, file );

		};

				return;

				return dropzone.unbind('.wp-uploader');

					clearTimeout( timer );

					return;

				dropzone.trigger('dropzone:enter').addClass('drag-over');

				active = true;

			});

				// Using an instant timer prevents the drag-over class from

				// being quickly removed and re-added when elements inside the

				// dropzone are repositioned.

				//

				timer = setTimeout( function() {

					active = false;

					dropzone.trigger('dropzone:leave').removeClass('drag-over');

				}, 0 );

			});

		if ( this.browser ) {

			this.browser.on( 'mouseenter', this.refresh );

		} else {

			this.uploader.disableBrowse( true );

			// If HTML5 mode, hide the auto-created file container.

			$('#' + this.uploader.id + '_html5_container').hide();

		}

		this.uploader.bind( 'FilesAdded', function( up, files ) {

			_.each( files, function( file ) {

				var attributes, image;

				// Ignore failed uploads.

					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 );

				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];

				}

				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 );

		});

		this.uploader.bind( 'FileUploaded', function( up, file, response ) {

			var complete;

			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 );

			_.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 );

		});

		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 ];

						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;

	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,

		'HTTP_ERROR':             pluploadL10n.http_error,

		'SECURITY_ERROR':         pluploadL10n.security_error,

		'FILE_SIZE_ERROR': function( file ) {

			return pluploadL10n.file_exceeds_size_limit.replace('%s', file.name);

		}

	};

	$.extend( 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 ) {

				return this.uploader.settings.multipart_params[ key ];

			if ( arguments.length > 1 ) {

				this.uploader.settings.multipart_params[ key ] = value;

			} else {