Ticket #28510: browserify.diff

Gruntfile.js

@@ -114 +114 @@
                                 }
                         }
                 },
+                browserify: {
+                        media: {
+                                files: {
+                                        'src/wp-includes/js/media/models.js' : [ SOURCE_DIR + 'wp-includes/js/media/models.manifest.js' ],
+                                        'src/wp-includes/js/media/views.js' : [ SOURCE_DIR + 'wp-includes/js/media/views.manifest.js' ],
+                                        'src/wp-includes/js/media/audio-video.js' : [ SOURCE_DIR + 'wp-includes/js/media/audio-video.manifest.js' ],
+                                        'src/wp-includes/js/media/grid.js' : [ SOURCE_DIR + 'wp-includes/js/media/grid.manifest.js' ]
+                                },
+                                options: { debug: true }
+                        }
+                },
                 sass: {
                         colors: {
                                 expand: true,
@@ -358 +369 @@
                                         '!wp-includes/js/zxcvbn.min.js'
                                 ]
                         },
+                        media: {
+                                expand: true,
+                                cwd: SOURCE_DIR,
+                                dest: BUILD_DIR,
+                                ext: '.min.js',
+                                src: [
+                                        'wp-includes/js/media/audio-video.js',
+                                        'wp-includes/js/media/grid.js',
+                                        'wp-includes/js/media/models.js',
+                                        'wp-includes/js/media/views.js'
+                                ]
+                        },
                         jqueryui: {
                                 options: {
                                         preserveComments: 'some'
@@ -435 +458 @@
                                         interval: 2000
                                 }
                         },
+                        browserify: {
+                                files: [
+                                        SOURCE_DIR + 'wp-includes/js/media/**/*.js',
+                                        '!' + SOURCE_DIR + 'wp-includes/js/media/audio-video.js',
+                                        '!' + SOURCE_DIR + 'wp-includes/js/media/grid.js',
+                                        '!' + SOURCE_DIR + 'wp-includes/js/media/models.js',
+                                        '!' + SOURCE_DIR + 'wp-includes/js/media/views.js'
+                                ],
+                                tasks: ['browserify', 'uglify:media']
+                        },
                         config: {
                                 files: 'Gruntfile.js'
                         },
@@ -483 +516 @@
 
         // Build task.
         grunt.registerTask('build', ['clean:all', 'copy:all', 'cssmin:core', 'colors', 'rtl', 'cssmin:rtl', 'cssmin:colors',
-                'uglify:core', 'uglify:jqueryui', 'concat:tinymce', 'compress:tinymce', 'clean:tinymce', 'jsvalidate:build']);
+                'browserify:media', 'uglify:core', 'uglify:media', 'uglify:jqueryui', 'concat:tinymce', 'compress:tinymce',
+                'clean:tinymce', 'jsvalidate:build']);
 
         // Testing tasks.
         grunt.registerMultiTask('phpunit', 'Runs PHPUnit tests, including the ajax, external-http, and multisite tests.', function() {

package.json

@@ -11 +11 @@
   "devDependencies": {
     "grunt": "~0.4.5",
     "grunt-autoprefixer": "~1.0.1",
+        "grunt-browserify": "~3.2.1",
     "grunt-contrib-clean": "~0.6.0",
     "grunt-contrib-compress": "~0.12.0",
     "grunt-contrib-concat": "~0.5.0",

src/wp-includes/js/media/audio-video.js

@@ +1 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/* global _wpMediaViewsL10n, _wpmejsSettings, MediaElementPlayer */
+
+(function($, _, Backbone) {
+        var media = wp.media,
+                baseSettings = {},
+                l10n = typeof _wpMediaViewsL10n === 'undefined' ? {} : _wpMediaViewsL10n;
+
+        if ( ! _.isUndefined( window._wpmejsSettings ) ) {
+                baseSettings = _wpmejsSettings;
+        }
+
+        /**
+         * @mixin
+         */
+        wp.media.mixin = {
+                mejsSettings: baseSettings,
+
+                removeAllPlayers: function() {
+                        var p;
+
+                        if ( window.mejs && window.mejs.players ) {
+                                for ( p in window.mejs.players ) {
+                                        window.mejs.players[p].pause();
+                                        this.removePlayer( window.mejs.players[p] );
+                                }
+                        }
+                },
+
+                /**
+                 * Override the MediaElement method for removing a player.
+                 *      MediaElement tries to pull the audio/video tag out of
+                 *      its container and re-add it to the DOM.
+                 */
+                removePlayer: function(t) {
+                        var featureIndex, feature;
+
+                        if ( ! t.options ) {
+                                return;
+                        }
+
+                        // invoke features cleanup
+                        for ( featureIndex in t.options.features ) {
+                                feature = t.options.features[featureIndex];
+                                if ( t['clean' + feature] ) {
+                                        try {
+                                                t['clean' + feature](t);
+                                        } catch (e) {}
+                                }
+                        }
+
+                        if ( ! t.isDynamic ) {
+                                t.$node.remove();
+                        }
+
+                        if ( 'native' !== t.media.pluginType ) {
+                                t.media.remove();
+                        }
+
+                        delete window.mejs.players[t.id];
+
+                        t.container.remove();
+                        t.globalUnbind();
+                        delete t.node.player;
+                },
+
+                /**
+                 * Allows any class that has set 'player' to a MediaElementPlayer
+                 *  instance to remove the player when listening to events.
+                 *
+                 *  Examples: modal closes, shortcode properties are removed, etc.
+                 */
+                unsetPlayers : function() {
+                        if ( this.players && this.players.length ) {
+                                _.each( this.players, function (player) {
+                                        player.pause();
+                                        wp.media.mixin.removePlayer( player );
+                                } );
+                                this.players = [];
+                        }
+                }
+        };
+
+        /**
+         * Autowire "collection"-type shortcodes
+         */
+        wp.media.playlist = new wp.media.collection({
+                tag: 'playlist',
+                editTitle : l10n.editPlaylistTitle,
+                defaults : {
+                        id: wp.media.view.settings.post.id,
+                        style: 'light',
+                        tracklist: true,
+                        tracknumbers: true,
+                        images: true,
+                        artists: true,
+                        type: 'audio'
+                }
+        });
+
+        /**
+         * Shortcode modeling for audio
+         *  `edit()` prepares the shortcode for the media modal
+         *  `shortcode()` builds the new shortcode after update
+         *
+         * @namespace
+         */
+        wp.media.audio = {
+                coerce : wp.media.coerce,
+
+                defaults : {
+                        id : wp.media.view.settings.post.id,
+                        src : '',
+                        loop : false,
+                        autoplay : false,
+                        preload : 'none',
+                        width : 400
+                },
+
+                edit : function( data ) {
+                        var frame, shortcode = wp.shortcode.next( 'audio', data ).shortcode;
+                        console.log( 'woo' );
+
+                        frame = wp.media({
+                                frame: 'audio',
+                                state: 'audio-details',
+                                metadata: _.defaults( shortcode.attrs.named, this.defaults )
+                        });
+
+                        console.log( frame );
+
+                        return frame;
+                },
+
+                shortcode : function( model ) {
+                        var self = this, content;
+
+                        _.each( this.defaults, function( value, key ) {
+                                model[ key ] = self.coerce( model, key );
+
+                                if ( value === model[ key ] ) {
+                                        delete model[ key ];
+                                }
+                        });
+
+                        content = model.content;
+                        delete model.content;
+
+                        return new wp.shortcode({
+                                tag: 'audio',
+                                attrs: model,
+                                content: content
+                        });
+                }
+        };
+
+        /**
+         * Shortcode modeling for video
+         *  `edit()` prepares the shortcode for the media modal
+         *  `shortcode()` builds the new shortcode after update
+         *
+         * @namespace
+         */
+        wp.media.video = {
+                coerce : wp.media.coerce,
+
+                defaults : {
+                        id : wp.media.view.settings.post.id,
+                        src : '',
+                        poster : '',
+                        loop : false,
+                        autoplay : false,
+                        preload : 'metadata',
+                        content : '',
+                        width : 640,
+                        height : 360
+                },
+
+                edit : function( data ) {
+                        var frame,
+                                shortcode = wp.shortcode.next( 'video', data ).shortcode,
+                                attrs;
+
+                        attrs = shortcode.attrs.named;
+                        attrs.content = shortcode.content;
+
+                        frame = wp.media({
+                                frame: 'video',
+                                state: 'video-details',
+                                metadata: _.defaults( attrs, this.defaults )
+                        });
+
+                        return frame;
+                },
+
+                shortcode : function( model ) {
+                        var self = this, content;
+
+                        _.each( this.defaults, function( value, key ) {
+                                model[ key ] = self.coerce( model, key );
+
+                                if ( value === model[ key ] ) {
+                                        delete model[ key ];
+                                }
+                        });
+
+                        content = model.content;
+                        delete model.content;
+
+                        return new wp.shortcode({
+                                tag: 'video',
+                                attrs: model,
+                                content: content
+                        });
+                }
+        };
+
+        media.model.PostMedia = require( './models/post-media.js' );
+        media.controller.AudioDetails = require( './controllers/audio-details.js' );
+        media.controller.VideoDetails = require( './controllers/video-details.js' );
+        media.view.MediaFrame.MediaDetails = require( './views/frame/media-details.js' );
+        media.view.MediaFrame.AudioDetails = require( './views/frame/audio-details.js' );
+        media.view.MediaFrame.VideoDetails = require( './views/frame/video-details.js' );
+        media.view.MediaDetails = require( './views/media-details.js' );
+        media.view.AudioDetails = require( './views/audio-details.js' );
+        media.view.VideoDetails = require( './views/video-details.js' );
+
+}(jQuery, _, Backbone));
+
+},{"./controllers/audio-details.js":2,"./controllers/video-details.js":8,"./models/post-media.js":11,"./views/audio-details.js":25,"./views/frame/audio-details.js":29,"./views/frame/media-details.js":30,"./views/frame/video-details.js":32,"./views/media-details.js":35,"./views/video-details.js":54}],2:[function(require,module,exports){
+/**
+ * The controller for the Audio Details state
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        AudioDetails;
+
+AudioDetails = State.extend({
+        defaults: {
+                id: 'audio-details',
+                toolbar: 'audio-details',
+                title: l10n.audioDetailsTitle,
+                content: 'audio-details',
+                menu: 'audio-details',
+                router: false,
+                priority: 60
+        },
+
+        initialize: function( options ) {
+                this.media = options.media;
+                State.prototype.initialize.apply( this, arguments );
+        }
+});
+
+module.exports = AudioDetails;
+
+},{"./state.js":7}],3:[function(require,module,exports){
+/**
+ * wp.media.controller.Library
+ *
+ * A state for choosing an attachment or group of attachments from the media library.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ * @mixes media.selectionSync
+ *
+ * @param {object}                          [attributes]                         The attributes hash passed to the state.
+ * @param {string}                          [attributes.id=library]              Unique identifier.
+ * @param {string}                          [attributes.title=Media library]     Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments}      [attributes.library]                 The attachments collection to browse.
+ *                                                                               If one is not supplied, a collection of all attachments will be created.
+ * @param {wp.media.model.Selection|object} [attributes.selection]               A collection to contain attachment selections within the state.
+ *                                                                               If the 'selection' attribute is a plain JS object,
+ *                                                                               a Selection will be created using its values as the selection instance's `props` model.
+ *                                                                               Otherwise, it will copy the library's `props` model.
+ * @param {boolean}                         [attributes.multiple=false]          Whether multi-select is enabled.
+ * @param {string}                          [attributes.content=upload]          Initial mode for the content region.
+ *                                                                               Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                          [attributes.menu=default]            Initial mode for the menu region.
+ * @param {string}                          [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                          [attributes.toolbar=select]          Initial mode for the toolbar region.
+ * @param {boolean}                         [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean|string}                  [attributes.filterable=false]        Whether the library is filterable, and if so what filters should be shown.
+ *                                                                               Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                         [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                         [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                         [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                         [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                         [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.
+ */
+var selectionSync = require( '../utils/selection-sync.js' ),
+        SelectionModel = require( '../models/selection.js' ),
+        State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Library;
+
+Library = State.extend({
+        defaults: {
+                id:                 'library',
+                title:              l10n.mediaLibraryTitle,
+                multiple:           false,
+                content:            'upload',
+                menu:               'default',
+                router:             'browse',
+                toolbar:            'select',
+                searchable:         true,
+                filterable:         false,
+                sortable:           true,
+                autoSelect:         true,
+                describe:           false,
+                contentUserSetting: true,
+                syncSelection:      true
+        },
+
+        /**
+         * If a library isn't provided, query all media items.
+         * If a selection instance isn't provided, create one.
+         *
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var selection = this.get('selection'),
+                        props;
+
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query() );
+                }
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        props = selection;
+
+                        if ( ! props ) {
+                                props = this.get('library').props.toJSON();
+                                props = _.omit( props, 'orderby', 'query' );
+                        }
+
+                        this.set( 'selection', new SelectionModel( null, {
+                                multiple: this.get('multiple'),
+                                props: props
+                        }) );
+                }
+
+                this.resetDisplays();
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.syncSelection();
+
+                wp.Uploader.queue.on( 'add', this.uploading, this );
+
+                this.get('selection').on( 'add remove reset', this.refreshContent, this );
+
+                if ( this.get( 'router' ) && this.get('contentUserSetting') ) {
+                        this.frame.on( 'content:activate', this.saveContentMode, this );
+                        this.set( 'content', getUserSetting( 'libraryContent', this.get('content') ) );
+                }
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.recordSelection();
+
+                this.frame.off( 'content:activate', this.saveContentMode, this );
+
+                // Unbind all event handlers that use this state as the context
+                // from the selection.
+                this.get('selection').off( null, null, this );
+
+                wp.Uploader.queue.off( null, null, this );
+        },
+
+        /**
+         * Reset the library to its initial state.
+         *
+         * @since 3.5.0
+         */
+        reset: function() {
+                this.get('selection').reset();
+                this.resetDisplays();
+                this.refreshContent();
+        },
+
+        /**
+         * Reset the attachment display settings defaults to the site options.
+         *
+         * If site options don't define them, fall back to a persistent user setting.
+         *
+         * @since 3.5.0
+         */
+        resetDisplays: function() {
+                var defaultProps = wp.media.view.settings.defaultProps;
+                this._displays = [];
+                this._defaultDisplaySettings = {
+                        align: defaultProps.align || getUserSetting( 'align', 'none' ),
+                        size:  defaultProps.size  || getUserSetting( 'imgsize', 'medium' ),
+                        link:  defaultProps.link  || getUserSetting( 'urlbutton', 'file' )
+                };
+        },
+
+        /**
+         * Create a model to represent display settings (alignment, etc.) for an attachment.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Backbone.Model}
+         */
+        display: function( attachment ) {
+                var displays = this._displays;
+
+                if ( ! displays[ attachment.cid ] ) {
+                        displays[ attachment.cid ] = new Backbone.Model( this.defaultDisplaySettings( attachment ) );
+                }
+                return displays[ attachment.cid ];
+        },
+
+        /**
+         * Given an attachment, create attachment display settings properties.
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Object}
+         */
+        defaultDisplaySettings: function( attachment ) {
+                var settings = this._defaultDisplaySettings;
+                if ( settings.canEmbed = this.canEmbed( attachment ) ) {
+                        settings.link = 'embed';
+                }
+                return settings;
+        },
+
+        /**
+         * Whether an attachment can be embedded (audio or video).
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        canEmbed: function( attachment ) {
+                // If uploading, we know the filename but not the mime type.
+                if ( ! attachment.get('uploading') ) {
+                        var type = attachment.get('type');
+                        if ( type !== 'audio' && type !== 'video' ) {
+                                return false;
+                        }
+                }
+
+                return _.contains( wp.media.view.settings.embedExts, attachment.get('filename').split('.').pop() );
+        },
+
+
+        /**
+         * If the state is active, no items are selected, and the current
+         * content mode is not an option in the state's router (provided
+         * the state has a router), reset the content mode to the default.
+         *
+         * @since 3.5.0
+         */
+        refreshContent: function() {
+                var selection = this.get('selection'),
+                        frame = this.frame,
+                        router = frame.router.get(),
+                        mode = frame.content.mode();
+
+                if ( this.active && ! selection.length && router && ! router.get( mode ) ) {
+                        this.frame.content.render( this.get('content') );
+                }
+        },
+
+        /**
+         * Callback handler when an attachment is uploaded.
+         *
+         * Switch to the Media Library if uploaded from the 'Upload Files' tab.
+         *
+         * Adds any uploading attachments to the selection.
+         *
+         * If the state only supports one attachment to be selected and multiple
+         * attachments are uploaded, the last attachment in the upload queue will
+         * be selected.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         */
+        uploading: function( attachment ) {
+                var content = this.frame.content;
+
+                if ( 'upload' === content.mode() ) {
+                        this.frame.content.mode('browse');
+                }
+
+                if ( this.get( 'autoSelect' ) ) {
+                        this.get('selection').add( attachment );
+                        this.frame.trigger( 'library:selection:add' );
+                }
+        },
+
+        /**
+         * Persist the mode of the content region as a user setting.
+         *
+         * @since 3.5.0
+         */
+        saveContentMode: function() {
+                if ( 'browse' !== this.get('router') ) {
+                        return;
+                }
+
+                var mode = this.frame.content.mode(),
+                        view = this.frame.router.get();
+
+                if ( view && view.get( mode ) ) {
+                        setUserSetting( 'libraryContent', mode );
+                }
+        }
+});
+
+// Make selectionSync available on any Media Library state.
+_.extend( Library.prototype, selectionSync );
+
+module.exports = Library;
+},{"../models/selection.js":13,"../utils/selection-sync.js":14,"./state.js":7}],4:[function(require,module,exports){
+/**
+ * wp.media.controller.MediaLibrary
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var Library = require( './library.js' ),
+        MediaLibrary;
+
+MediaLibrary = Library.extend({
+        defaults: _.defaults({
+                // Attachments browser defaults. @see media.view.AttachmentsBrowser
+                filterable:      'uploaded',
+
+                displaySettings: false,
+                priority:        80,
+                syncSelection:   false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         *
+         * @param options
+         */
+        initialize: function( options ) {
+                this.media = options.media;
+                this.type = options.type;
+                this.set( 'library', wp.media.query({ type: this.type }) );
+
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                // @todo this should use this.frame.
+                if ( wp.media.frame.lastMime ) {
+                        this.set( 'library', wp.media.query({ type: wp.media.frame.lastMime }) );
+                        delete wp.media.frame.lastMime;
+                }
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = MediaLibrary;
+},{"./library.js":3}],5:[function(require,module,exports){
+/**
+ * wp.media.controller.Region
+ *
+ * A region is a persistent application layout area.
+ *
+ * A region assumes one mode at any time, and can be switched to another.
+ *
+ * When mode changes, events are triggered on the region's parent view.
+ * The parent view will listen to specific events and fill the region with an
+ * appropriate view depending on mode. For example, a frame listens for the
+ * 'browse' mode t be activated on the 'content' view and then fills the region
+ * with an AttachmentsBrowser view.
+ *
+ * @class
+ *
+ * @param {object}        options          Options hash for the region.
+ * @param {string}        options.id       Unique identifier for the region.
+ * @param {Backbone.View} options.view     A parent view the region exists within.
+ * @param {string}        options.selector jQuery selector for the region within the parent view.
+ */
+var Region = function( options ) {
+        _.extend( this, _.pick( options || {}, 'id', 'view', 'selector' ) );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+Region.extend = Backbone.Model.extend;
+
+_.extend( Region.prototype, {
+        /**
+         * Activate a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:activate:{this._mode}
+         * @fires this.view#{this.id}:activate
+         * @fires this.view#{this.id}:deactivate:{this._mode}
+         * @fires this.view#{this.id}:deactivate
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        mode: function( mode ) {
+                if ( ! mode ) {
+                        return this._mode;
+                }
+                // Bail if we're trying to change to the current mode.
+                if ( mode === this._mode ) {
+                        return this;
+                }
+
+                /**
+                 * Region mode deactivation event.
+                 *
+                 * @event this.view#{this.id}:deactivate:{this._mode}
+                 * @event this.view#{this.id}:deactivate
+                 */
+                this.trigger('deactivate');
+
+                this._mode = mode;
+                this.render( mode );
+
+                /**
+                 * Region mode activation event.
+                 *
+                 * @event this.view#{this.id}:activate:{this._mode}
+                 * @event this.view#{this.id}:activate
+                 */
+                this.trigger('activate');
+                return this;
+        },
+        /**
+         * Render a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:create:{this._mode}
+         * @fires this.view#{this.id}:create
+         * @fires this.view#{this.id}:render:{this._mode}
+         * @fires this.view#{this.id}:render
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining
+         */
+        render: function( mode ) {
+                // If the mode isn't active, activate it.
+                if ( mode && mode !== this._mode ) {
+                        return this.mode( mode );
+                }
+
+                var set = { view: null },
+                        view;
+
+                /**
+                 * Create region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'create', set );
+                view = set.view;
+
+                /**
+                 * Render region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'render', view );
+                if ( view ) {
+                        this.set( view );
+                }
+                return this;
+        },
+
+        /**
+         * Get the region's view.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.View}
+         */
+        get: function() {
+                return this.view.views.first( this.selector );
+        },
+
+        /**
+         * Set the region's view as a subview of the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {Array|Object} views
+         * @param {Object} [options={}]
+         * @returns {wp.Backbone.Subviews} Subviews is returned to allow chaining
+         */
+        set: function( views, options ) {
+                if ( options ) {
+                        options.add = false;
+                }
+                return this.view.views.set( this.selector, views, options );
+        },
+
+        /**
+         * Trigger regional view events on the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} event
+         * @returns {undefined|wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        trigger: function( event ) {
+                var base, args;
+
+                if ( ! this._mode ) {
+                        return;
+                }
+
+                args = _.toArray( arguments );
+                base = this.id + ':' + event;
+
+                // Trigger `{this.id}:{event}:{this._mode}` event on the frame.
+                args[0] = base + ':' + this._mode;
+                this.view.trigger.apply( this.view, args );
+
+                // Trigger `{this.id}:{event}` event on the frame.
+                args[0] = base;
+                this.view.trigger.apply( this.view, args );
+                return this;
+        }
+});
+
+module.exports = Region;
+},{}],6:[function(require,module,exports){
+/**
+ * wp.media.controller.StateMachine
+ *
+ * A state machine keeps track of state. It is in one state at a time,
+ * and can change from one state to another.
+ *
+ * States are stored as models in a Backbone collection.
+ *
+ * @since 3.5.0
+ *
+ * @class
+ * @augments Backbone.Model
+ * @mixin
+ * @mixes Backbone.Events
+ *
+ * @param {Array} states
+ */
+var StateMachine = function( states ) {
+        // @todo This is dead code. The states collection gets created in media.view.Frame._createStates.
+        this.states = new Backbone.Collection( states );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+StateMachine.extend = Backbone.Model.extend;
+
+_.extend( StateMachine.prototype, Backbone.Events, {
+        /**
+         * Fetch a state.
+         *
+         * If no `id` is provided, returns the active state.
+         *
+         * Implicitly creates states.
+         *
+         * Ensure that the `states` collection exists so the `StateMachine`
+         *   can be used as a mixin.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         * @returns {wp.media.controller.State} Returns a State model
+         *   from the StateMachine collection
+         */
+        state: function( id ) {
+                this.states = this.states || new Backbone.Collection();
+
+                // Default to the active state.
+                id = id || this._state;
+
+                if ( id && ! this.states.get( id ) ) {
+                        this.states.add({ id: id });
+                }
+                return this.states.get( id );
+        },
+
+        /**
+         * Sets the active state.
+         *
+         * Bail if we're trying to select the current state, if we haven't
+         * created the `states` collection, or are trying to select a state
+         * that does not exist.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         *
+         * @fires wp.media.controller.State#deactivate
+         * @fires wp.media.controller.State#activate
+         *
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining
+         */
+        setState: function( id ) {
+                var previous = this.state();
+
+                if ( ( previous && id === previous.id ) || ! this.states || ! this.states.get( id ) ) {
+                        return this;
+                }
+
+                if ( previous ) {
+                        previous.trigger('deactivate');
+                        this._lastState = previous.id;
+                }
+
+                this._state = id;
+                this.state().trigger('activate');
+
+                return this;
+        },
+
+        /**
+         * Returns the previous active state.
+         *
+         * Call the `state()` method with no parameters to retrieve the current
+         * active state.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.controller.State} Returns a State model
+         *    from the StateMachine collection
+         */
+        lastState: function() {
+                if ( this._lastState ) {
+                        return this.state( this._lastState );
+                }
+        }
+});
+
+// Map all event binding and triggering on a StateMachine to its `states` collection.
+_.each([ 'on', 'off', 'trigger' ], function( method ) {
+        /**
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.
+         */
+        StateMachine.prototype[ method ] = function() {
+                // Ensure that the `states` collection exists so the `StateMachine`
+                // can be used as a mixin.
+                this.states = this.states || new Backbone.Collection();
+                // Forward the method to the `states` collection.
+                this.states[ method ].apply( this.states, arguments );
+                return this;
+        };
+});
+
+module.exports = StateMachine;
+},{}],7:[function(require,module,exports){
+/**
+ * wp.media.controller.State
+ *
+ * A state is a step in a workflow that when set will trigger the controllers
+ * for the regions to be updated as specified in the frame.
+ *
+ * A state has an event-driven lifecycle:
+ *
+ *     'ready'      triggers when a state is added to a state machine's collection.
+ *     'activate'   triggers when a state is activated by a state machine.
+ *     'deactivate' triggers when a state is deactivated by a state machine.
+ *     'reset'      is not triggered automatically. It should be invoked by the
+ *                  proper controller to reset the state to its default.
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var State = Backbone.Model.extend({
+        /**
+         * Constructor.
+         *
+         * @since 3.5.0
+         */
+        constructor: function() {
+                this.on( 'activate', this._preActivate, this );
+                this.on( 'activate', this.activate, this );
+                this.on( 'activate', this._postActivate, this );
+                this.on( 'deactivate', this._deactivate, this );
+                this.on( 'deactivate', this.deactivate, this );
+                this.on( 'reset', this.reset, this );
+                this.on( 'ready', this._ready, this );
+                this.on( 'ready', this.ready, this );
+                /**
+                 * Call parent constructor with passed arguments
+                 */
+                Backbone.Model.apply( this, arguments );
+                this.on( 'change:menu', this._updateMenu, this );
+        },
+        /**
+         * Ready event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        ready: function() {},
+
+        /**
+         * Activate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        activate: function() {},
+
+        /**
+         * Deactivate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        deactivate: function() {},
+
+        /**
+         * Reset event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        reset: function() {},
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _ready: function() {
+                this._updateMenu();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+        */
+        _preActivate: function() {
+                this.active = true;
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _postActivate: function() {
+                this.on( 'change:menu', this._menu, this );
+                this.on( 'change:titleMode', this._title, this );
+                this.on( 'change:content', this._content, this );
+                this.on( 'change:toolbar', this._toolbar, this );
+
+                this.frame.on( 'title:render:default', this._renderTitle, this );
+
+                this._title();
+                this._menu();
+                this._toolbar();
+                this._content();
+                this._router();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _deactivate: function() {
+                this.active = false;
+
+                this.frame.off( 'title:render:default', this._renderTitle, this );
+
+                this.off( 'change:menu', this._menu, this );
+                this.off( 'change:titleMode', this._title, this );
+                this.off( 'change:content', this._content, this );
+                this.off( 'change:toolbar', this._toolbar, this );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _title: function() {
+                this.frame.title.render( this.get('titleMode') || 'default' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _renderTitle: function( view ) {
+                view.$el.text( this.get('title') || '' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _router: function() {
+                var router = this.frame.router,
+                        mode = this.get('router'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-router', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                this.frame.router.render( mode );
+
+                view = router.get();
+                if ( view && view.select ) {
+                        view.select( this.frame.content.mode() );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _menu: function() {
+                var menu = this.frame.menu,
+                        mode = this.get('menu'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-menu', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                menu.mode( mode );
+
+                view = menu.get();
+                if ( view && view.select ) {
+                        view.select( this.id );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _updateMenu: function() {
+                var previous = this.previous('menu'),
+                        menu = this.get('menu');
+
+                if ( previous ) {
+                        this.frame.off( 'menu:render:' + previous, this._renderMenu, this );
+                }
+
+                if ( menu ) {
+                        this.frame.on( 'menu:render:' + menu, this._renderMenu, this );
+                }
+        },
+
+        /**
+         * Create a view in the media menu for the state.
+         *
+         * @access private
+         * @since 3.5.0
+         *
+         * @param {media.view.Menu} view The menu view.
+         */
+        _renderMenu: function( view ) {
+                var menuItem = this.get('menuItem'),
+                        title = this.get('title'),
+                        priority = this.get('priority');
+
+                if ( ! menuItem && title ) {
+                        menuItem = { text: title };
+
+                        if ( priority ) {
+                                menuItem.priority = priority;
+                        }
+                }
+
+                if ( ! menuItem ) {
+                        return;
+                }
+
+                view.set( this.id, menuItem );
+        }
+});
+
+_.each(['toolbar','content'], function( region ) {
+        /**
+         * @access private
+         */
+        State.prototype[ '_' + region ] = function() {
+                var mode = this.get( region );
+                if ( mode ) {
+                        this.frame[ region ].render( mode );
+                }
+        };
+});
+
+module.exports = State;
+},{}],8:[function(require,module,exports){
+/**
+ * The controller for the Video Details state
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        VideoDetails;
+
+VideoDetails = State.extend({
+        defaults: {
+                id: 'video-details',
+                toolbar: 'video-details',
+                title: l10n.videoDetailsTitle,
+                content: 'video-details',
+                menu: 'video-details',
+                router: false,
+                priority: 60
+        },
+
+        initialize: function( options ) {
+                this.media = options.media;
+                State.prototype.initialize.apply( this, arguments );
+        }
+});
+
+module.exports = VideoDetails;
+},{"./state.js":7}],9:[function(require,module,exports){
+/**
+ * wp.media.model.Attachment
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var $ = jQuery,
+        Attachment;
+
+Attachment = Backbone.Model.extend({
+        /**
+         * Triggered when attachment details change
+         * Overrides Backbone.Model.sync
+         *
+         * @param {string} method
+         * @param {wp.media.model.Attachment} model
+         * @param {Object} [options={}]
+         *
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                // If the attachment does not yet have an `id`, return an instantly
+                // rejected promise. Otherwise, all of our requests will fail.
+                if ( _.isUndefined( this.id ) ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                // Overload the `read` request so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action: 'get-attachment',
+                                id: this.id
+                        });
+                        return wp.media.ajax( options );
+
+                // Overload the `update` request so properties can be saved.
+                } else if ( 'update' === method ) {
+                        // If we do not have the necessary nonce, fail immeditately.
+                        if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                                return $.Deferred().rejectWith( this ).promise();
+                        }
+
+                        options = options || {};
+                        options.context = this;
+
+                        // Set the action and ID.
+                        options.data = _.extend( options.data || {}, {
+                                action:  'save-attachment',
+                                id:      this.id,
+                                nonce:   this.get('nonces').update,
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Record the values of the changed attributes.
+                        if ( model.hasChanged() ) {
+                                options.data.changes = {};
+
+                                _.each( model.changed, function( value, key ) {
+                                        options.data.changes[ key ] = this.get( key );
+                                }, this );
+                        }
+
+                        return wp.media.ajax( options );
+
+                // Overload the `delete` request so attachments can be removed.
+                // This will permanently delete an attachment.
+                } else if ( 'delete' === method ) {
+                        options = options || {};
+
+                        if ( ! options.wait ) {
+                                this.destroyed = true;
+                        }
+
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:   'delete-post',
+                                id:       this.id,
+                                _wpnonce: this.get('nonces')['delete']
+                        });
+
+                        return wp.media.ajax( options ).done( function() {
+                                this.destroyed = true;
+                        }).fail( function() {
+                                this.destroyed = false;
+                        });
+
+                // Otherwise, fall back to `Backbone.sync()`.
+                } else {
+                        /**
+                         * Call `sync` directly on Backbone.Model
+                         */
+                        return Backbone.Model.prototype.sync.apply( this, arguments );
+                }
+        },
+        /**
+         * Convert date strings into Date objects.
+         *
+         * @param {Object} resp The raw response object, typically returned by fetch()
+         * @returns {Object} The modified response object, which is the attributes hash
+         *    to be set on the model.
+         */
+        parse: function( resp ) {
+                if ( ! resp ) {
+                        return resp;
+                }
+
+                resp.date = new Date( resp.date );
+                resp.modified = new Date( resp.modified );
+                return resp;
+        },
+        /**
+         * @param {Object} data The properties to be saved.
+         * @param {Object} options Sync options. e.g. patch, wait, success, error.
+         *
+         * @this Backbone.Model
+         *
+         * @returns {Promise}
+         */
+        saveCompat: function( data, options ) {
+                var model = this;
+
+                // If we do not have the necessary nonce, fail immeditately.
+                if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                return media.post( 'save-attachment-compat', _.defaults({
+                        id:      this.id,
+                        nonce:   this.get('nonces').update,
+                        post_id: wp.media.model.settings.post.id
+                }, data ) ).done( function( resp, status, xhr ) {
+                        model.set( model.parse( resp, xhr ), options );
+                });
+        }
+}, {
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * @static
+         * @param {Object} attrs
+         * @returns {wp.media.model.Attachment}
+         */
+        create: function( attrs ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attrs );
+        },
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * If this function has already been called for the id,
+         * it returns the specified attachment.
+         *
+         * @static
+         * @param {string} id A string used to identify a model.
+         * @param {Backbone.Model|undefined} attachment
+         * @returns {wp.media.model.Attachment}
+         */
+        get: _.memoize( function( id, attachment ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attachment || { id: id } );
+        })
+});
+
+module.exports = Attachment;
+},{"./attachments.js":10}],10:[function(require,module,exports){
+/**
+ * wp.media.model.Attachments
+ *
+ * A collection of attachments.
+ *
+ * This collection has no persistence with the server without supplying
+ * 'options.props.query = true', which will mirror the collection
+ * to an Attachments Query collection - @see wp.media.model.Attachments.mirror().
+ *
+ * @class
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                Models to initialize with the collection.
+ * @param {object} [options]               Options hash for the collection.
+ * @param {string} [options.props]         Options hash for the initial query properties.
+ * @param {string} [options.props.order]   Initial order (ASC or DESC) for the collection.
+ * @param {string} [options.props.orderby] Initial attribute key to order the collection by.
+ * @param {string} [options.props.query]   Whether the collection is linked to an attachments query.
+ * @param {string} [options.observe]
+ * @param {string} [options.filters]
+ *
+ */
+var Attachment = require( './attachment.js' ),
+        Attachments;
+
+Attachments = Backbone.Collection.extend({
+        /**
+         * @type {wp.media.model.Attachment}
+         */
+        model: Attachment,
+        /**
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                options = options || {};
+
+                this.props   = new Backbone.Model();
+                this.filters = options.filters || {};
+
+                // Bind default `change` events to the `props` model.
+                this.props.on( 'change', this._changeFilteredProps, this );
+
+                this.props.on( 'change:order',   this._changeOrder,   this );
+                this.props.on( 'change:orderby', this._changeOrderby, this );
+                this.props.on( 'change:query',   this._changeQuery,   this );
+
+                this.props.set( _.defaults( options.props || {} ) );
+
+                if ( options.observe ) {
+                        this.observe( options.observe );
+                }
+        },
+        /**
+         * Sort the collection when the order attribute changes.
+         *
+         * @access private
+         */
+        _changeOrder: function() {
+                if ( this.comparator ) {
+                        this.sort();
+                }
+        },
+        /**
+         * Set the default comparator only when the `orderby` property is set.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {string} orderby
+         */
+        _changeOrderby: function( model, orderby ) {
+                // If a different comparator is defined, bail.
+                if ( this.comparator && this.comparator !== Attachments.comparator ) {
+                        return;
+                }
+
+                if ( orderby && 'post__in' !== orderby ) {
+                        this.comparator = Attachments.comparator;
+                } else {
+                        delete this.comparator;
+                }
+        },
+        /**
+         * If the `query` property is set to true, query the server using
+         * the `props` values, and sync the results to this collection.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {Boolean} query
+         */
+        _changeQuery: function( model, query ) {
+                if ( query ) {
+                        this.props.on( 'change', this._requery, this );
+                        this._requery();
+                } else {
+                        this.props.off( 'change', this._requery, this );
+                }
+        },
+        /**
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         */
+        _changeFilteredProps: function( model ) {
+                // If this is a query, updating the collection will be handled by
+                // `this._requery()`.
+                if ( this.props.get('query') ) {
+                        return;
+                }
+
+                var changed = _.chain( model.changed ).map( function( t, prop ) {
+                        var filter = Attachments.filters[ prop ],
+                                term = model.get( prop );
+
+                        if ( ! filter ) {
+                                return;
+                        }
+
+                        if ( term && ! this.filters[ prop ] ) {
+                                this.filters[ prop ] = filter;
+                        } else if ( ! term && this.filters[ prop ] === filter ) {
+                                delete this.filters[ prop ];
+                        } else {
+                                return;
+                        }
+
+                        // Record the change.
+                        return true;
+                }, this ).any().value();
+
+                if ( ! changed ) {
+                        return;
+                }
+
+                // If no `Attachments` model is provided to source the searches
+                // from, then automatically generate a source from the existing
+                // models.
+                if ( ! this._source ) {
+                        this._source = new Attachments( this.models );
+                }
+
+                this.reset( this._source.filter( this.validator, this ) );
+        },
+
+        validateDestroyed: false,
+        /**
+         * Checks whether an attachment is valid.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        validator: function( attachment ) {
+                if ( ! this.validateDestroyed && attachment.destroyed ) {
+                        return false;
+                }
+                return _.all( this.filters, function( filter ) {
+                        return !! filter.call( this, attachment );
+                }, this );
+        },
+        /**
+         * Add or remove an attachment to the collection depending on its validity.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validate: function( attachment, options ) {
+                var valid = this.validator( attachment ),
+                        hasAttachment = !! this.get( attachment.cid );
+
+                if ( ! valid && hasAttachment ) {
+                        this.remove( attachment, options );
+                } else if ( valid && ! hasAttachment ) {
+                        this.add( attachment, options );
+                }
+
+                return this;
+        },
+
+        /**
+         * Add or remove all attachments from another collection depending on each one's validity.
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {object} [options={}]
+         *
+         * @fires wp.media.model.Attachments#reset
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validateAll: function( attachments, options ) {
+                options = options || {};
+
+                _.each( attachments.models, function( attachment ) {
+                        this.validate( attachment, { silent: true });
+                }, this );
+
+                if ( ! options.silent ) {
+                        this.trigger( 'reset', this, options );
+                }
+                return this;
+        },
+        /**
+         * Start observing another attachments collection change events
+         * and replicate them on this collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to observe.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining.
+         */
+        observe: function( attachments ) {
+                this.observers = this.observers || [];
+                this.observers.push( attachments );
+
+                attachments.on( 'add change remove', this._validateHandler, this );
+                attachments.on( 'reset', this._validateAllHandler, this );
+                this.validateAll( attachments );
+                return this;
+        },
+        /**
+         * Stop replicating collection change events from another attachments collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to stop observing.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        unobserve: function( attachments ) {
+                if ( attachments ) {
+                        attachments.off( null, null, this );
+                        this.observers = _.without( this.observers, attachments );
+
+                } else {
+                        _.each( this.observers, function( attachments ) {
+                                attachments.off( null, null, this );
+                        }, this );
+                        delete this.observers;
+                }
+
+                return this;
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachment
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateHandler: function( attachment, attachments, options ) {
+                // If we're not mirroring this `attachments` collection,
+                // only retain the `silent` option.
+                options = attachments === this.mirroring ? options : {
+                        silent: options && options.silent
+                };
+
+                return this.validate( attachment, options );
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateAllHandler: function( attachments, options ) {
+                return this.validateAll( attachments, options );
+        },
+        /**
+         * Start mirroring another attachments collection, clearing out any models already
+         * in the collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to mirror.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        mirror: function( attachments ) {
+                if ( this.mirroring && this.mirroring === attachments ) {
+                        return this;
+                }
+
+                this.unmirror();
+                this.mirroring = attachments;
+
+                // Clear the collection silently. A `reset` event will be fired
+                // when `observe()` calls `validateAll()`.
+                this.reset( [], { silent: true } );
+                this.observe( attachments );
+
+                return this;
+        },
+        /**
+         * Stop mirroring another attachments collection.
+         */
+        unmirror: function() {
+                if ( ! this.mirroring ) {
+                        return;
+                }
+
+                this.unobserve( this.mirroring );
+                delete this.mirroring;
+        },
+        /**
+         * Retrive more attachments from the server for the collection.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `more` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @param {object} options
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var deferred = jQuery.Deferred(),
+                        mirroring = this.mirroring,
+                        attachments = this;
+
+                if ( ! mirroring || ! mirroring.more ) {
+                        return deferred.resolveWith( this ).promise();
+                }
+                // If we're mirroring another collection, forward `more` to
+                // the mirrored collection. Account for a race condition by
+                // checking if we're still mirroring that collection when
+                // the request resolves.
+                mirroring.more( options ).done( function() {
+                        if ( this === attachments.mirroring )
+                                deferred.resolveWith( this );
+                });
+
+                return deferred.promise();
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `hasMore` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this.mirroring ? this.mirroring.hasMore() : false;
+        },
+        /**
+         * A custom AJAX-response parser.
+         *
+         * See trac ticket #24753
+         *
+         * @param {Object|Array} resp The raw response Object/Array.
+         * @param {Object} xhr
+         * @returns {Array} The array of model attributes to be added to the collection
+         */
+        parse: function( resp, xhr ) {
+                if ( ! _.isArray( resp ) ) {
+                        resp = [resp];
+                }
+
+                return _.map( resp, function( attrs ) {
+                        var id, attachment, newAttributes;
+
+                        if ( attrs instanceof Backbone.Model ) {
+                                id = attrs.get( 'id' );
+                                attrs = attrs.attributes;
+                        } else {
+                                id = attrs.id;
+                        }
+
+                        attachment = Attachment.get( id );
+                        newAttributes = attachment.parse( attrs, xhr );
+
+                        if ( ! _.isEqual( attachment.attributes, newAttributes ) ) {
+                                attachment.set( newAttributes );
+                        }
+
+                        return attachment;
+                });
+        },
+        /**
+         * If the collection is a query, create and mirror an Attachments Query collection.
+         *
+         * @access private
+         */
+        _requery: function( refresh ) {
+                var props, Query;
+                if ( this.props.get('query') ) {
+                        Query = require( './query.js' );
+                        props = this.props.toJSON();
+                        props.cache = ( true !== refresh );
+                        this.mirror( Query.get( props ) );
+                }
+        },
+        /**
+         * If this collection is sorted by `menuOrder`, recalculates and saves
+         * the menu order to the database.
+         *
+         * @returns {undefined|Promise}
+         */
+        saveMenuOrder: function() {
+                if ( 'menuOrder' !== this.props.get('orderby') ) {
+                        return;
+                }
+
+                // Removes any uploading attachments, updates each attachment's
+                // menu order, and returns an object with an { id: menuOrder }
+                // mapping to pass to the request.
+                var attachments = this.chain().filter( function( attachment ) {
+                        return ! _.isUndefined( attachment.id );
+                }).map( function( attachment, index ) {
+                        // Indices start at 1.
+                        index = index + 1;
+                        attachment.set( 'menuOrder', index );
+                        return [ attachment.id, index ];
+                }).object().value();
+
+                if ( _.isEmpty( attachments ) ) {
+                        return;
+                }
+
+                return wp.media.post( 'save-attachment-order', {
+                        nonce:       wp.media.model.settings.post.nonce,
+                        post_id:     wp.media.model.settings.post.id,
+                        attachments: attachments
+                });
+        }
+}, {
+        /**
+         * A function to compare two attachment models in an attachments collection.
+         *
+         * Used as the default comparator for instances of wp.media.model.Attachments
+         * and its subclasses. @see wp.media.model.Attachments._changeOrderby().
+         *
+         * @static
+         *
+         * @param {Backbone.Model} a
+         * @param {Backbone.Model} b
+         * @param {Object} options
+         * @returns {Number} -1 if the first model should come before the second,
+         *    0 if they are of the same rank and
+         *    1 if the first model should come after.
+         */
+        comparator: function( a, b, options ) {
+                var key   = this.props.get('orderby'),
+                        order = this.props.get('order') || 'DESC',
+                        ac    = a.cid,
+                        bc    = b.cid;
+
+                a = a.get( key );
+                b = b.get( key );
+
+                if ( 'date' === key || 'modified' === key ) {
+                        a = a || new Date();
+                        b = b || new Date();
+                }
+
+                // If `options.ties` is set, don't enforce the `cid` tiebreaker.
+                if ( options && options.ties ) {
+                        ac = bc = null;
+                }
+
+                return ( 'DESC' === order ) ? wp.media.compare( a, b, ac, bc ) : wp.media.compare( b, a, bc, ac );
+        },
+        /**
+         * @namespace
+         */
+        filters: {
+                /**
+                 * @static
+                 * Note that this client-side searching is *not* equivalent
+                 * to our server-side searching.
+                 *
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                search: function( attachment ) {
+                        if ( ! this.props.get('search') ) {
+                                return true;
+                        }
+
+                        return _.any(['title','filename','description','caption','name'], function( key ) {
+                                var value = attachment.get( key );
+                                return value && -1 !== value.search( this.props.get('search') );
+                        }, this );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                type: function( attachment ) {
+                        var type = this.props.get('type');
+                        return ! type || -1 !== type.indexOf( attachment.get('type') );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                uploadedTo: function( attachment ) {
+                        var uploadedTo = this.props.get('uploadedTo');
+                        if ( _.isUndefined( uploadedTo ) ) {
+                                return true;
+                        }
+
+                        return uploadedTo === attachment.get('uploadedTo');
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                status: function( attachment ) {
+                        var status = this.props.get('status');
+                        if ( _.isUndefined( status ) ) {
+                                return true;
+                        }
+
+                        return status === attachment.get('status');
+                }
+        }
+});
+
+module.exports = Attachments;
+},{"./attachment.js":9,"./query.js":12}],11:[function(require,module,exports){
+/**
+ * Shared model class for audio and video. Updates the model after
+ *   "Add Audio|Video Source" and "Replace Audio|Video" states return
+ *
+ * @constructor
+ * @augments Backbone.Model
+ */
+var PostMedia = Backbone.Model.extend({
+        initialize: function() {
+                this.attachment = false;
+        },
+
+        setSource: function( attachment ) {
+                this.attachment = attachment;
+                this.extension = attachment.get( 'filename' ).split('.').pop();
+
+                if ( this.get( 'src' ) && this.extension === this.get( 'src' ).split('.').pop() ) {
+                        this.unset( 'src' );
+                }
+
+                if ( _.contains( wp.media.view.settings.embedExts, this.extension ) ) {
+                        this.set( this.extension, this.attachment.get( 'url' ) );
+                } else {
+                        this.unset( this.extension );
+                }
+        },
+
+        changeAttachment: function( attachment ) {
+                var self = this;
+
+                this.setSource( attachment );
+
+                this.unset( 'src' );
+                _.each( _.without( wp.media.view.settings.embedExts, this.extension ), function( ext ) {
+                        self.unset( ext );
+                } );
+        }
+});
+
+module.exports = PostMedia;
+},{}],12:[function(require,module,exports){
+/**
+ * wp.media.model.Query
+ *
+ * A collection of attachments that match the supplied query arguments.
+ *
+ * Note: Do NOT change this.args after the query has been initialized.
+ *       Things will break.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                      Models to initialize with the collection.
+ * @param {object} [options]                     Options hash.
+ * @param {object} [options.args]                Attachments query arguments.
+ * @param {object} [options.args.posts_per_page]
+ */
+var Attachments = require( './attachments.js' ),
+        Query;
+
+Query = Attachments.extend({
+        /**
+         * @global wp.Uploader
+         *
+         * @param {array}  [models=[]]  Array of initial models to populate the collection.
+         * @param {object} [options={}]
+         */
+        initialize: function( models, options ) {
+                var allowed;
+
+                options = options || {};
+                Attachments.prototype.initialize.apply( this, arguments );
+
+                this.args     = options.args;
+                this._hasMore = true;
+                this.created  = new Date();
+
+                this.filters.order = function( attachment ) {
+                        var orderby = this.props.get('orderby'),
+                                order = this.props.get('order');
+
+                        if ( ! this.comparator ) {
+                                return true;
+                        }
+
+                        // We want any items that can be placed before the last
+                        // item in the set. If we add any items after the last
+                        // item, then we can't guarantee the set is complete.
+                        if ( this.length ) {
+                                return 1 !== this.comparator( attachment, this.last(), { ties: true });
+
+                        // Handle the case where there are no items yet and
+                        // we're sorting for recent items. In that case, we want
+                        // changes that occurred after we created the query.
+                        } else if ( 'DESC' === order && ( 'date' === orderby || 'modified' === orderby ) ) {
+                                return attachment.get( orderby ) >= this.created;
+
+                        // If we're sorting by menu order and we have no items,
+                        // accept any items that have the default menu order (0).
+                        } else if ( 'ASC' === order && 'menuOrder' === orderby ) {
+                                return attachment.get( orderby ) === 0;
+                        }
+
+                        // Otherwise, we don't want any items yet.
+                        return false;
+                };
+
+                // Observe the central `wp.Uploader.queue` collection to watch for
+                // new matches for the query.
+                //
+                // Only observe when a limited number of query args are set. There
+                // are no filters for other properties, so observing will result in
+                // false positives in those queries.
+                allowed = [ 's', 'order', 'orderby', 'posts_per_page', 'post_mime_type', 'post_parent' ];
+                if ( wp.Uploader && _( this.args ).chain().keys().difference( allowed ).isEmpty().value() ) {
+                        this.observe( wp.Uploader.queue );
+                }
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this._hasMore;
+        },
+        /**
+         * Fetch more attachments from the server for the collection.
+         *
+         * @param   {object}  [options={}]
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var query = this;
+
+                // If there is already a request pending, return early with the Deferred object.
+                if ( this._more && 'pending' === this._more.state() ) {
+                        return this._more;
+                }
+
+                if ( ! this.hasMore() ) {
+                        return jQuery.Deferred().resolveWith( this ).promise();
+                }
+
+                options = options || {};
+                options.remove = false;
+
+                return this._more = this.fetch( options ).done( function( resp ) {
+                        if ( _.isEmpty( resp ) || -1 === this.args.posts_per_page || resp.length < this.args.posts_per_page ) {
+                                query._hasMore = false;
+                        }
+                });
+        },
+        /**
+         * Overrides Backbone.Collection.sync
+         * Overrides wp.media.model.Attachments.sync
+         *
+         * @param {String} method
+         * @param {Backbone.Model} model
+         * @param {Object} [options={}]
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                var args, fallback;
+
+                // Overload the read method so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:  'query-attachments',
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Clone the args so manipulation is non-destructive.
+                        args = _.clone( this.args );
+
+                        // Determine which page to query.
+                        if ( -1 !== args.posts_per_page ) {
+                                args.paged = Math.floor( this.length / args.posts_per_page ) + 1;
+                        }
+
+                        options.data.query = args;
+                        return wp.media.ajax( options );
+
+                // Otherwise, fall back to Backbone.sync()
+                } else {
+                        /**
+                         * Call wp.media.model.Attachments.sync or Backbone.sync
+                         */
+                        fallback = Attachments.prototype.sync ? Attachments.prototype : Backbone;
+                        return fallback.sync.apply( this, arguments );
+                }
+        }
+}, {
+        /**
+         * @readonly
+         */
+        defaultProps: {
+                orderby: 'date',
+                order:   'DESC'
+        },
+        /**
+         * @readonly
+         */
+        defaultArgs: {
+                posts_per_page: 40
+        },
+        /**
+         * @readonly
+         */
+        orderby: {
+                allowed:  [ 'name', 'author', 'date', 'title', 'modified', 'uploadedTo', 'id', 'post__in', 'menuOrder' ],
+                /**
+                 * A map of JavaScript orderby values to their WP_Query equivalents.
+                 * @type {Object}
+                 */
+                valuemap: {
+                        'id':         'ID',
+                        'uploadedTo': 'parent',
+                        'menuOrder':  'menu_order ID'
+                }
+        },
+        /**
+         * A map of JavaScript query properties to their WP_Query equivalents.
+         *
+         * @readonly
+         */
+        propmap: {
+                'search':    's',
+                'type':      'post_mime_type',
+                'perPage':   'posts_per_page',
+                'menuOrder': 'menu_order',
+                'uploadedTo': 'post_parent',
+                'status':     'post_status',
+                'include':    'post__in',
+                'exclude':    'post__not_in'
+        },
+        /**
+         * Creates and returns an Attachments Query collection given the properties.
+         *
+         * Caches query objects and reuses where possible.
+         *
+         * @static
+         * @method
+         *
+         * @param {object} [props]
+         * @param {Object} [props.cache=true]   Whether to use the query cache or not.
+         * @param {Object} [props.order]
+         * @param {Object} [props.orderby]
+         * @param {Object} [props.include]
+         * @param {Object} [props.exclude]
+         * @param {Object} [props.s]
+         * @param {Object} [props.post_mime_type]
+         * @param {Object} [props.posts_per_page]
+         * @param {Object} [props.menu_order]
+         * @param {Object} [props.post_parent]
+         * @param {Object} [props.post_status]
+         * @param {Object} [options]
+         *
+         * @returns {wp.media.model.Query} A new Attachments Query collection.
+         */
+        get: (function(){
+                /**
+                 * @static
+                 * @type Array
+                 */
+                var queries = [];
+
+                /**
+                 * @returns {Query}
+                 */
+                return function( props, options ) {
+                        var args     = {},
+                                orderby  = Query.orderby,
+                                defaults = Query.defaultProps,
+                                query,
+                                cache    = !! props.cache || _.isUndefined( props.cache );
+
+                        // Remove the `query` property. This isn't linked to a query,
+                        // this *is* the query.
+                        delete props.query;
+                        delete props.cache;
+
+                        // Fill default args.
+                        _.defaults( props, defaults );
+
+                        // Normalize the order.
+                        props.order = props.order.toUpperCase();
+                        if ( 'DESC' !== props.order && 'ASC' !== props.order ) {
+                                props.order = defaults.order.toUpperCase();
+                        }
+
+                        // Ensure we have a valid orderby value.
+                        if ( ! _.contains( orderby.allowed, props.orderby ) ) {
+                                props.orderby = defaults.orderby;
+                        }
+
+                        _.each( [ 'include', 'exclude' ], function( prop ) {
+                                if ( props[ prop ] && ! _.isArray( props[ prop ] ) ) {
+                                        props[ prop ] = [ props[ prop ] ];
+                                }
+                        } );
+
+                        // Generate the query `args` object.
+                        // Correct any differing property names.
+                        _.each( props, function( value, prop ) {
+                                if ( _.isNull( value ) ) {
+                                        return;
+                                }
+
+                                args[ Query.propmap[ prop ] || prop ] = value;
+                        });
+
+                        // Fill any other default query args.
+                        _.defaults( args, Query.defaultArgs );
+
+                        // `props.orderby` does not always map directly to `args.orderby`.
+                        // Substitute exceptions specified in orderby.keymap.
+                        args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;
+
+                        // Search the query cache for a matching query.
+                        if ( cache ) {
+                                query = _.find( queries, function( query ) {
+                                        return _.isEqual( query.args, args );
+                                });
+                        } else {
+                                queries = [];
+                        }
+
+                        // Otherwise, create a new query and add it to the cache.
+                        if ( ! query ) {
+                                query = new Query( [], _.extend( options || {}, {
+                                        props: props,
+                                        args:  args
+                                } ) );
+                                queries.push( query );
+                        }
+
+                        return query;
+                };
+        }())
+});
+
+module.exports = Query;
+},{"./attachments.js":10}],13:[function(require,module,exports){
+/**
+ * wp.media.model.Selection
+ *
+ * A selection of attachments.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ */
+var Attachments = require( './attachments.js' ),
+        Selection;
+
+Selection = Attachments.extend({
+        /**
+         * Refresh the `single` model whenever the selection changes.
+         * Binds `single` instead of using the context argument to ensure
+         * it receives no parameters.
+         *
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                /**
+                 * call 'initialize' directly on the parent class
+                 */
+                Attachments.prototype.initialize.apply( this, arguments );
+                this.multiple = options && options.multiple;
+
+                this.on( 'add remove reset', _.bind( this.single, this, false ) );
+        },
+
+        /**
+         * If the workflow does not support multi-select, clear out the selection
+         * before adding a new attachment to it.
+         *
+         * @param {Array} models
+         * @param {Object} options
+         * @returns {wp.media.model.Attachment[]}
+         */
+        add: function( models, options ) {
+                if ( ! this.multiple ) {
+                        this.remove( this.models );
+                }
+                /**
+                 * call 'add' directly on the parent class
+                 */
+                return Attachments.prototype.add.call( this, models, options );
+        },
+
+        /**
+         * Fired when toggling (clicking on) an attachment in the modal.
+         *
+         * @param {undefined|boolean|wp.media.model.Attachment} model
+         *
+         * @fires wp.media.model.Selection#selection:single
+         * @fires wp.media.model.Selection#selection:unsingle
+         *
+         * @returns {Backbone.Model}
+         */
+        single: function( model ) {
+                var previous = this._single;
+
+                // If a `model` is provided, use it as the single model.
+                if ( model ) {
+                        this._single = model;
+                }
+                // If the single model isn't in the selection, remove it.
+                if ( this._single && ! this.get( this._single.cid ) ) {
+                        delete this._single;
+                }
+
+                this._single = this._single || this.last();
+
+                // If single has changed, fire an event.
+                if ( this._single !== previous ) {
+                        if ( previous ) {
+                                previous.trigger( 'selection:unsingle', previous, this );
+
+                                // If the model was already removed, trigger the collection
+                                // event manually.
+                                if ( ! this.get( previous.cid ) ) {
+                                        this.trigger( 'selection:unsingle', previous, this );
+                                }
+                        }
+                        if ( this._single ) {
+                                this._single.trigger( 'selection:single', this._single, this );
+                        }
+                }
+
+                // Return the single model, or the last model as a fallback.
+                return this._single;
+        }
+});
+
+module.exports = Selection;
+},{"./attachments.js":10}],14:[function(require,module,exports){
+/**
+ * wp.media.selectionSync
+ *
+ * Sync an attachments selection in a state with another state.
+ *
+ * Allows for selecting multiple images in the Insert Media workflow, and then
+ * switching to the Insert Gallery workflow while preserving the attachments selection.
+ *
+ * @mixin
+ */
+var selectionSync = {
+        /**
+         * @since 3.5.0
+         */
+        syncSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                // If the selection supports multiple items, validate the stored
+                // attachments based on the new selection's conditions. Record
+                // the attachments that are not included; we'll maintain a
+                // reference to those. Other attachments are considered in flux.
+                if ( selection.multiple ) {
+                        selection.reset( [], { silent: true });
+                        selection.validateAll( manager.attachments );
+                        manager.difference = _.difference( manager.attachments.models, selection.models );
+                }
+
+                // Sync the selection's single item with the master.
+                selection.single( manager.single );
+        },
+
+        /**
+         * Record the currently active attachments, which is a combination
+         * of the selection's attachments and the set of selected
+         * attachments that this specific selection considered invalid.
+         * Reset the difference and record the single attachment.
+         *
+         * @since 3.5.0
+         */
+        recordSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                if ( selection.multiple ) {
+                        manager.attachments.reset( selection.toArray().concat( manager.difference ) );
+                        manager.difference = [];
+                } else {
+                        manager.attachments.add( selection.toArray() );
+                }
+
+                manager.single = selection._single;
+        }
+};
+
+module.exports = selectionSync;
+},{}],15:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentCompat
+ *
+ * A view to display fields added via the `attachment_fields_to_edit` filter.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        AttachmentCompat;
+
+AttachmentCompat = View.extend({
+        tagName:   'form',
+        className: 'compat-item',
+
+        events: {
+                'submit':          'preventDefault',
+                'change input':    'save',
+                'change select':   'save',
+                'change textarea': 'save'
+        },
+
+        initialize: function() {
+                this.model.on( 'change:compat', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.$(':focus').length ) {
+                        this.save();
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        render: function() {
+                var compat = this.model.get('compat');
+                if ( ! compat || ! compat.item ) {
+                        return;
+                }
+
+                this.views.detach();
+                this.$el.html( compat.item );
+                this.views.render();
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {Object} event
+         */
+        save: function( event ) {
+                var data = {};
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                _.each( this.$el.serializeArray(), function( pair ) {
+                        data[ pair.name ] = pair.value;
+                });
+
+                this.controller.trigger( 'attachment:compat:waiting', ['waiting'] );
+                this.model.saveCompat( data ).always( _.bind( this.postSave, this ) );
+        },
+
+        postSave: function() {
+                this.controller.trigger( 'attachment:compat:ready', ['ready'] );
+        }
+});
+
+module.exports = AttachmentCompat;
+},{"./view.js":55}],16:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        AttachmentFilters;
+
+AttachmentFilters = View.extend({
+        tagName:   'select',
+        className: 'attachment-filters',
+        id:        'media-attachment-filters',
+
+        events: {
+                change: 'change'
+        },
+
+        keys: [],
+
+        initialize: function() {
+                this.createFilters();
+                _.extend( this.filters, this.options.filters );
+
+                // Build `<option>` elements.
+                this.$el.html( _.chain( this.filters ).map( function( filter, value ) {
+                        return {
+                                el: $( '<option></option>' ).val( value ).html( filter.text )[0],
+                                priority: filter.priority || 50
+                        };
+                }, this ).sortBy('priority').pluck('el').value() );
+
+                this.model.on( 'change', this.select, this );
+                this.select();
+        },
+
+        /**
+         * @abstract
+         */
+        createFilters: function() {
+                this.filters = {};
+        },
+
+        /**
+         * When the selected filter changes, update the Attachment Query properties to match.
+         */
+        change: function() {
+                var filter = this.filters[ this.el.value ];
+                if ( filter ) {
+                        this.model.set( filter.props );
+                }
+        },
+
+        select: function() {
+                var model = this.model,
+                        value = 'all',
+                        props = model.toJSON();
+
+                _.find( this.filters, function( filter, id ) {
+                        var equal = _.all( filter.props, function( prop, key ) {
+                                return prop === ( _.isUndefined( props[ key ] ) ? null : props[ key ] );
+                        });
+
+                        if ( equal ) {
+                                return value = id;
+                        }
+                });
+
+                this.$el.val( value );
+        }
+});
+
+module.exports = AttachmentFilters;
+},{"./view.js":55}],17:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters.All
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        All;
+
+All = AttachmentFilters.extend({
+        createFilters: function() {
+                var filters = {};
+
+                _.each( wp.media.view.settings.mimeTypes || {}, function( text, key ) {
+                        filters[ key ] = {
+                                text: text,
+                                props: {
+                                        status:  null,
+                                        type:    key,
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                }
+                        };
+                });
+
+                filters.all = {
+                        text:  l10n.allMediaItems,
+                        props: {
+                                status:  null,
+                                type:    null,
+                                uploadedTo: null,
+                                orderby: 'date',
+                                order:   'DESC'
+                        },
+                        priority: 10
+                };
+
+                if ( wp.media.view.settings.post.id ) {
+                        filters.uploaded = {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        status:  null,
+                                        type:    null,
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        };
+                }
+
+                filters.unattached = {
+                        text:  l10n.unattached,
+                        props: {
+                                status:     null,
+                                uploadedTo: 0,
+                                type:       null,
+                                orderby:    'menuOrder',
+                                order:      'ASC'
+                        },
+                        priority: 50
+                };
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        this.controller.isModeActive( 'grid' ) ) {
+
+                        filters.trash = {
+                                text:  l10n.trash,
+                                props: {
+                                        uploadedTo: null,
+                                        status:     'trash',
+                                        type:       null,
+                                        orderby:    'date',
+                                        order:      'DESC'
+                                },
+                                priority: 50
+                        };
+                }
+
+                this.filters = filters;
+        }
+});
+
+module.exports = All;
+},{"../attachment-filters.js":16}],18:[function(require,module,exports){
+/**
+ * A filter dropdown for month/dates.
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        DateFilter;
+
+DateFilter = AttachmentFilters.extend({
+        id: 'media-attachment-date-filters',
+
+        createFilters: function() {
+                var filters = {};
+                _.each( wp.media.view.settings.months || {}, function( value, index ) {
+                        filters[ index ] = {
+                                text: value.text,
+                                props: {
+                                        year: value.year,
+                                        monthnum: value.month
+                                }
+                        };
+                });
+                filters.all = {
+                        text:  l10n.allDates,
+                        props: {
+                                monthnum: false,
+                                year:  false
+                        },
+                        priority: 10
+                };
+                this.filters = filters;
+        }
+});
+
+module.exports = DateFilter;
+},{"../attachment-filters.js":16}],19:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters.Uploaded
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        Uploaded;
+
+Uploaded = AttachmentFilters.extend({
+        createFilters: function() {
+                var type = this.model.get('type'),
+                        types = wp.media.view.settings.mimeTypes,
+                        text;
+
+                if ( types && type ) {
+                        text = types[ type ];
+                }
+
+                this.filters = {
+                        all: {
+                                text:  text || l10n.allMediaItems,
+                                props: {
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                },
+                                priority: 10
+                        },
+
+                        uploaded: {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        },
+
+                        unattached: {
+                                text:  l10n.unattached,
+                                props: {
+                                        uploadedTo: 0,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 50
+                        }
+                };
+        }
+});
+
+module.exports = Uploaded;
+},{"../attachment-filters.js":16}],20:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Attachment;
+
+Attachment = View.extend({
+        tagName:   'li',
+        className: 'attachment',
+        template:  wp.template('attachment'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'role':         'checkbox',
+                        'aria-label':   this.model.get( 'title' ),
+                        'aria-checked': false,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'click .js--select-attachment':   'toggleSelectionHandler',
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .close':                   'removeFromLibrary',
+                'click .check':                   'checkClickHandler',
+                'click a':                        'preventDefault',
+                'keydown .close':                 'removeFromLibrary',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        buttons: {},
+
+        initialize: function() {
+                var selection = this.options.selection,
+                        options = _.defaults( this.options, {
+                                rerenderOnModelChange: true
+                        } );
+
+                if ( options.rerenderOnModelChange ) {
+                        this.model.on( 'change', this.render, this );
+                } else {
+                        this.model.on( 'change:percent', this.progress, this );
+                }
+                this.model.on( 'change:title', this._syncTitle, this );
+                this.model.on( 'change:caption', this._syncCaption, this );
+                this.model.on( 'change:artist', this._syncArtist, this );
+                this.model.on( 'change:album', this._syncAlbum, this );
+
+                // Update the selection.
+                this.model.on( 'add', this.select, this );
+                this.model.on( 'remove', this.deselect, this );
+                if ( selection ) {
+                        selection.on( 'reset', this.updateSelect, this );
+                        // Update the model's details view.
+                        this.model.on( 'selection:single selection:unsingle', this.details, this );
+                        this.details( this.model, this.controller.state().get('selection') );
+                }
+
+                this.listenTo( this.controller, 'attachment:compat:waiting attachment:compat:ready', this.updateSave );
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        dispose: function() {
+                var selection = this.options.selection;
+
+                // Make sure all settings are saved before removing the view.
+                this.updateAll();
+
+                if ( selection ) {
+                        selection.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        render: function() {
+                var options = _.defaults( this.model.toJSON(), {
+                                orientation:   'landscape',
+                                uploading:     false,
+                                type:          '',
+                                subtype:       '',
+                                icon:          '',
+                                filename:      '',
+                                caption:       '',
+                                title:         '',
+                                dateFormatted: '',
+                                width:         '',
+                                height:        '',
+                                compat:        false,
+                                alt:           '',
+                                description:   ''
+                        }, this.options );
+
+                options.buttons  = this.buttons;
+                options.describe = this.controller.state().get('describe');
+
+                if ( 'image' === options.type ) {
+                        options.size = this.imageSize();
+                }
+
+                options.can = {};
+                if ( options.nonces ) {
+                        options.can.remove = !! options.nonces['delete'];
+                        options.can.save = !! options.nonces.update;
+                }
+
+                if ( this.controller.state().get('allowLocalEdits') ) {
+                        options.allowLocalEdits = true;
+                }
+
+                if ( options.uploading && ! options.percent ) {
+                        options.percent = 0;
+                }
+
+                this.views.detach();
+                this.$el.html( this.template( options ) );
+
+                this.$el.toggleClass( 'uploading', options.uploading );
+
+                if ( options.uploading ) {
+                        this.$bar = this.$('.media-progress-bar div');
+                } else {
+                        delete this.$bar;
+                }
+
+                // Check if the model is selected.
+                this.updateSelect();
+
+                // Update the save status.
+                this.updateSave();
+
+                this.views.render();
+
+                return this;
+        },
+
+        progress: function() {
+                if ( this.$bar && this.$bar.length ) {
+                        this.$bar.width( this.model.get('percent') + '%' );
+                }
+        },
+
+        /**
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                var method;
+
+                // Don't do anything inside inputs.
+                if ( 'INPUT' === event.target.nodeName ) {
+                        return;
+                }
+
+                // Catch arrow events
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                event.preventDefault();
+
+                // In the grid view, bubble up an edit:attachment event to the controller.
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        if ( this.controller.isModeActive( 'edit' ) ) {
+                                // Pass the current target to restore focus when closing
+                                this.controller.trigger( 'edit:attachment', this.model, event.currentTarget );
+                                return;
+                        }
+
+                        if ( this.controller.isModeActive( 'select' ) ) {
+                                method = 'toggle';
+                        }
+                }
+
+                if ( event.shiftKey ) {
+                        method = 'between';
+                } else if ( event.ctrlKey || event.metaKey ) {
+                        method = 'toggle';
+                }
+
+                this.toggleSelection({
+                        method: method
+                });
+
+                this.controller.trigger( 'selection:toggle' );
+        },
+        /**
+         * @param {Object} options
+         */
+        toggleSelection: function( options ) {
+                var collection = this.collection,
+                        selection = this.options.selection,
+                        model = this.model,
+                        method = options && options.method,
+                        single, models, singleIndex, modelIndex;
+
+                if ( ! selection ) {
+                        return;
+                }
+
+                single = selection.single();
+                method = _.isUndefined( method ) ? selection.multiple : method;
+
+                // If the `method` is set to `between`, select all models that
+                // exist between the current and the selected model.
+                if ( 'between' === method && single && selection.multiple ) {
+                        // If the models are the same, short-circuit.
+                        if ( single === model ) {
+                                return;
+                        }
+
+                        singleIndex = collection.indexOf( single );
+                        modelIndex  = collection.indexOf( this.model );
+
+                        if ( singleIndex < modelIndex ) {
+                                models = collection.models.slice( singleIndex, modelIndex + 1 );
+                        } else {
+                                models = collection.models.slice( modelIndex, singleIndex + 1 );
+                        }
+
+                        selection.add( models );
+                        selection.single( model );
+                        return;
+
+                // If the `method` is set to `toggle`, just flip the selection
+                // status, regardless of whether the model is the single model.
+                } else if ( 'toggle' === method ) {
+                        selection[ this.selected() ? 'remove' : 'add' ]( model );
+                        selection.single( model );
+                        return;
+                } else if ( 'add' === method ) {
+                        selection.add( model );
+                        selection.single( model );
+                        return;
+                }
+
+                // Fixes bug that loses focus when selecting a featured image
+                if ( ! method ) {
+                        method = 'add';
+                }
+
+                if ( method !== 'add' ) {
+                        method = 'reset';
+                }
+
+                if ( this.selected() ) {
+                        // If the model is the single model, remove it.
+                        // If it is not the same as the single model,
+                        // it now becomes the single model.
+                        selection[ single === model ? 'remove' : 'single' ]( model );
+                } else {
+                        // If the model is not selected, run the `method` on the
+                        // selection. By default, we `reset` the selection, but the
+                        // `method` can be set to `add` the model to the selection.
+                        selection[ method ]( model );
+                        selection.single( model );
+                }
+        },
+
+        updateSelect: function() {
+                this[ this.selected() ? 'select' : 'deselect' ]();
+        },
+        /**
+         * @returns {unresolved|Boolean}
+         */
+        selected: function() {
+                var selection = this.options.selection;
+                if ( selection ) {
+                        return !! selection.get( this.model.cid );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        select: function( model, collection ) {
+                var selection = this.options.selection,
+                        controller = this.controller;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+
+                // Bail if the model is already selected.
+                if ( this.$el.hasClass( 'selected' ) ) {
+                        return;
+                }
+
+                // Add 'selected' class to model, set aria-checked to true.
+                this.$el.addClass( 'selected' ).attr( 'aria-checked', true );
+                //  Make the checkbox tabable, except in media grid (bulk select mode).
+                if ( ! ( controller.isModeActive( 'grid' ) && controller.isModeActive( 'select' ) ) ) {
+                        this.$( '.check' ).attr( 'tabindex', '0' );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        deselect: function( model, collection ) {
+                var selection = this.options.selection;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+                this.$el.removeClass( 'selected' ).attr( 'aria-checked', false )
+                        .find( '.check' ).attr( 'tabindex', '-1' );
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        details: function( model, collection ) {
+                var selection = this.options.selection,
+                        details;
+
+                if ( selection !== collection ) {
+                        return;
+                }
+
+                details = selection.single();
+                this.$el.toggleClass( 'details', details === this.model );
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {string} size
+         * @returns {Object}
+         */
+        imageSize: function( size ) {
+                var sizes = this.model.get('sizes');
+
+                size = size || 'medium';
+
+                // Use the provided image size if possible.
+                if ( sizes && sizes[ size ] ) {
+                        return _.clone( sizes[ size ] );
+                } else {
+                        return {
+                                url:         this.model.get('url'),
+                                width:       this.model.get('width'),
+                                height:      this.model.get('height'),
+                                orientation: this.model.get('orientation')
+                        };
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateSetting: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        setting, value;
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                setting = $setting.data('setting');
+                value   = event.target.value;
+
+                if ( this.model.get( setting ) !== value ) {
+                        this.save( setting, value );
+                }
+        },
+
+        /**
+         * Pass all the arguments to the model's save method.
+         *
+         * Records the aggregate status of all save requests and updates the
+         * view's classes accordingly.
+         */
+        save: function() {
+                var view = this,
+                        save = this._save = this._save || { status: 'ready' },
+                        request = this.model.save.apply( this.model, arguments ),
+                        requests = save.requests ? $.when( request, save.requests ) : request;
+
+                // If we're waiting to remove 'Saved.', stop.
+                if ( save.savedTimer ) {
+                        clearTimeout( save.savedTimer );
+                }
+
+                this.updateSave('waiting');
+                save.requests = requests;
+                requests.always( function() {
+                        // If we've performed another request since this one, bail.
+                        if ( save.requests !== requests ) {
+                                return;
+                        }
+
+                        view.updateSave( requests.state() === 'resolved' ? 'complete' : 'error' );
+                        save.savedTimer = setTimeout( function() {
+                                view.updateSave('ready');
+                                delete save.savedTimer;
+                        }, 2000 );
+                });
+        },
+        /**
+         * @param {string} status
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        updateSave: function( status ) {
+                var save = this._save = this._save || { status: 'ready' };
+
+                if ( status && status !== save.status ) {
+                        this.$el.removeClass( 'save-' + save.status );
+                        save.status = status;
+                }
+
+                this.$el.addClass( 'save-' + save.status );
+                return this;
+        },
+
+        updateAll: function() {
+                var $settings = this.$('[data-setting]'),
+                        model = this.model,
+                        changed;
+
+                changed = _.chain( $settings ).map( function( el ) {
+                        var $input = $('input, textarea, select, [value]', el ),
+                                setting, value;
+
+                        if ( ! $input.length ) {
+                                return;
+                        }
+
+                        setting = $(el).data('setting');
+                        value = $input.val();
+
+                        // Record the value if it changed.
+                        if ( model.get( setting ) !== value ) {
+                                return [ setting, value ];
+                        }
+                }).compact().object().value();
+
+                if ( ! _.isEmpty( changed ) ) {
+                        model.save( changed );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        removeFromLibrary: function( event ) {
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                // Stop propagation so the model isn't selected.
+                event.stopPropagation();
+
+                this.collection.remove( this.model );
+        },
+
+        /**
+         * Add the model if it isn't in the selection, if it is in the selection,
+         * remove it.
+         *
+         * @param  {[type]} event [description]
+         * @return {[type]}       [description]
+         */
+        checkClickHandler: function ( event ) {
+                var selection = this.options.selection;
+                if ( ! selection ) {
+                        return;
+                }
+                event.stopPropagation();
+                if ( selection.where( { id: this.model.get( 'id' ) } ).length ) {
+                        selection.remove( this.model );
+                        // Move focus back to the attachment tile (from the check).
+                        this.$el.focus();
+                } else {
+                        selection.add( this.model );
+                }
+        }
+});
+
+// Ensure settings remain in sync between attachment views.
+_.each({
+        caption: '_syncCaption',
+        title:   '_syncTitle',
+        artist:  '_syncArtist',
+        album:   '_syncAlbum'
+}, function( method, setting ) {
+        /**
+         * @param {Backbone.Model} model
+         * @param {string} value
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        Attachment.prototype[ method ] = function( model, value ) {
+                var $setting = this.$('[data-setting="' + setting + '"]');
+
+                if ( ! $setting.length ) {
+                        return this;
+                }
+
+                // If the updated value is in sync with the value in the DOM, there
+                // is no need to re-render. If we're currently editing the value,
+                // it will automatically be in sync, suppressing the re-render for
+                // the view we're editing, while updating any others.
+                if ( value === $setting.find('input, textarea, select, [value]').val() ) {
+                        return this;
+                }
+
+                return this.render();
+        };
+});
+
+module.exports = Attachment;
+},{"./view.js":55}],21:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment.Details
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        l10n = wp.media.view.l10n,
+        Details;
+
+Details = Attachment.extend({
+        tagName:   'div',
+        className: 'attachment-details',
+        template:  wp.template('attachment-details'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .delete-attachment':       'deleteAttachment',
+                'click .trash-attachment':        'trashAttachment',
+                'click .untrash-attachment':      'untrashAttachment',
+                'click .edit-attachment':         'editAttachment',
+                'click .refresh-attachment':      'refreshAttachment',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        initialize: function() {
+                this.options = _.defaults( this.options, {
+                        rerenderOnModelChange: false
+                });
+
+                this.on( 'ready', this.initialFocus );
+                // Call 'initialize' directly on the parent class.
+                Attachment.prototype.initialize.apply( this, arguments );
+        },
+
+        initialFocus: function() {
+                if ( ! wp.media.isTouchDevice ) {
+                        this.$( ':input' ).eq( 0 ).focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        deleteAttachment: function( event ) {
+                event.preventDefault();
+
+                if ( confirm( l10n.warnDelete ) ) {
+                        this.model.destroy();
+                        // Keep focus inside media modal
+                        // after image is deleted
+                        this.controller.modal.focusManager.focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        trashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        'edit-metadata' === this.controller.content.mode() ) {
+
+                        this.model.set( 'status', 'trash' );
+                        this.model.save().done( function() {
+                                library._requery( true );
+                        } );
+                }  else {
+                        this.model.destroy();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        untrashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                this.model.set( 'status', 'inherit' );
+                this.model.save().done( function() {
+                        library._requery( true );
+                } );
+        },
+        /**
+         * @param {Object} event
+         */
+        editAttachment: function( event ) {
+                var editState = this.controller.states.get( 'edit-image' );
+                if ( window.imageEdit && editState ) {
+                        event.preventDefault();
+
+                        editState.set( 'image', this.model );
+                        this.controller.setState( 'edit-image' );
+                } else {
+                        this.$el.addClass('needs-refresh');
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        refreshAttachment: function( event ) {
+                this.$el.removeClass('needs-refresh');
+                event.preventDefault();
+                this.model.fetch();
+        },
+        /**
+         * When reverse tabbing(shift+tab) out of the right details panel, deliver
+         * the focus to the item in the list that was being edited.
+         *
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                if ( 'keydown' === event.type && 9 === event.keyCode && event.shiftKey && event.target === this.$( ':tabbable' ).get( 0 ) ) {
+                        this.controller.trigger( 'attachment:details:shift-tab', event );
+                        return false;
+                }
+
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+        }
+});
+
+module.exports = Details;
+},{"../attachment.js":20}],22:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment.Library
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        Library;
+
+Library = Attachment.extend({
+        buttons: {
+                check: true
+        }
+});
+
+module.exports = Library;
+},{"../attachment.js":20}],23:[function(require,module,exports){
+/**
+ * wp.media.view.Attachments
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Attachment = require( './attachment.js' ),
+        $ = jQuery,
+        Attachments;
+
+Attachments = View.extend({
+        tagName:   'ul',
+        className: 'attachments',
+
+        attributes: {
+                tabIndex: -1
+        },
+
+        initialize: function() {
+                this.el.id = _.uniqueId('__attachments-view-');
+
+                _.defaults( this.options, {
+                        refreshSensitivity: wp.media.isTouchDevice ? 300 : 200,
+                        refreshThreshold:   3,
+                        AttachmentView:     Attachment,
+                        sortable:           false,
+                        resize:             true,
+                        idealColumnWidth:   $( window ).width() < 640 ? 135 : 150
+                });
+
+                this._viewsByCid = {};
+                this.$window = $( window );
+                this.resizeEvent = 'resize.media-modal-columns';
+
+                this.collection.on( 'add', function( attachment ) {
+                        this.views.add( this.createAttachmentView( attachment ), {
+                                at: this.collection.indexOf( attachment )
+                        });
+                }, this );
+
+                this.collection.on( 'remove', function( attachment ) {
+                        var view = this._viewsByCid[ attachment.cid ];
+                        delete this._viewsByCid[ attachment.cid ];
+
+                        if ( view ) {
+                                view.remove();
+                        }
+                }, this );
+
+                this.collection.on( 'reset', this.render, this );
+
+                this.listenTo( this.controller, 'library:selection:add',    this.attachmentFocus );
+
+                // Throttle the scroll handler and bind this.
+                this.scroll = _.chain( this.scroll ).bind( this ).throttle( this.options.refreshSensitivity ).value();
+
+                this.options.scrollElement = this.options.scrollElement || this.el;
+                $( this.options.scrollElement ).on( 'scroll', this.scroll );
+
+                this.initSortable();
+
+                _.bindAll( this, 'setColumns' );
+
+                if ( this.options.resize ) {
+                        this.on( 'ready', this.bindEvents );
+                        this.controller.on( 'open', this.setColumns );
+
+                        // Call this.setColumns() after this view has been rendered in the DOM so
+                        // attachments get proper width applied.
+                        _.defer( this.setColumns, this );
+                }
+        },
+
+        bindEvents: function() {
+                this.$window.off( this.resizeEvent ).on( this.resizeEvent, _.debounce( this.setColumns, 50 ) );
+        },
+
+        attachmentFocus: function() {
+                this.$( 'li:first' ).focus();
+        },
+
+        restoreFocus: function() {
+                this.$( 'li.selected:first' ).focus();
+        },
+
+        arrowEvent: function( event ) {
+                var attachments = this.$el.children( 'li' ),
+                        perRow = this.columns,
+                        index = attachments.filter( ':focus' ).index(),
+                        row = ( index + 1 ) <= perRow ? 1 : Math.ceil( ( index + 1 ) / perRow );
+
+                if ( index === -1 ) {
+                        return;
+                }
+
+                // Left arrow
+                if ( 37 === event.keyCode ) {
+                        if ( 0 === index ) {
+                                return;
+                        }
+                        attachments.eq( index - 1 ).focus();
+                }
+
+                // Up arrow
+                if ( 38 === event.keyCode ) {
+                        if ( 1 === row ) {
+                                return;
+                        }
+                        attachments.eq( index - perRow ).focus();
+                }
+
+                // Right arrow
+                if ( 39 === event.keyCode ) {
+                        if ( attachments.length === index ) {
+                                return;
+                        }
+                        attachments.eq( index + 1 ).focus();
+                }
+
+                // Down arrow
+                if ( 40 === event.keyCode ) {
+                        if ( Math.ceil( attachments.length / perRow ) === row ) {
+                                return;
+                        }
+                        attachments.eq( index + perRow ).focus();
+                }
+        },
+
+        dispose: function() {
+                this.collection.props.off( null, null, this );
+                if ( this.options.resize ) {
+                        this.$window.off( this.resizeEvent );
+                }
+
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+        },
+
+        setColumns: function() {
+                var prev = this.columns,
+                        width = this.$el.width();
+
+                if ( width ) {
+                        this.columns = Math.min( Math.round( width / this.options.idealColumnWidth ), 12 ) || 1;
+
+                        if ( ! prev || prev !== this.columns ) {
+                                this.$el.closest( '.media-frame-content' ).attr( 'data-columns', this.columns );
+                        }
+                }
+        },
+
+        initSortable: function() {
+                var collection = this.collection;
+
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                this.$el.sortable( _.extend({
+                        // If the `collection` has a `comparator`, disable sorting.
+                        disabled: !! collection.comparator,
+
+                        // Change the position of the attachment as soon as the
+                        // mouse pointer overlaps a thumbnail.
+                        tolerance: 'pointer',
+
+                        // Record the initial `index` of the dragged model.
+                        start: function( event, ui ) {
+                                ui.item.data('sortableIndexStart', ui.item.index());
+                        },
+
+                        // Update the model's index in the collection.
+                        // Do so silently, as the view is already accurate.
+                        update: function( event, ui ) {
+                                var model = collection.at( ui.item.data('sortableIndexStart') ),
+                                        comparator = collection.comparator;
+
+                                // Temporarily disable the comparator to prevent `add`
+                                // from re-sorting.
+                                delete collection.comparator;
+
+                                // Silently shift the model to its new index.
+                                collection.remove( model, {
+                                        silent: true
+                                });
+                                collection.add( model, {
+                                        silent: true,
+                                        at:     ui.item.index()
+                                });
+
+                                // Restore the comparator.
+                                collection.comparator = comparator;
+
+                                // Fire the `reset` event to ensure other collections sync.
+                                collection.trigger( 'reset', collection );
+
+                                // If the collection is sorted by menu order,
+                                // update the menu order.
+                                collection.saveMenuOrder();
+                        }
+                }, this.options.sortable ) );
+
+                // If the `orderby` property is changed on the `collection`,
+                // check to see if we have a `comparator`. If so, disable sorting.
+                collection.props.on( 'change:orderby', function() {
+                        this.$el.sortable( 'option', 'disabled', !! collection.comparator );
+                }, this );
+
+                this.collection.props.on( 'change:orderby', this.refreshSortable, this );
+                this.refreshSortable();
+        },
+
+        refreshSortable: function() {
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                // If the `collection` has a `comparator`, disable sorting.
+                var collection = this.collection,
+                        orderby = collection.props.get('orderby'),
+                        enabled = 'menuOrder' === orderby || ! collection.comparator;
+
+                this.$el.sortable( 'option', 'disabled', ! enabled );
+        },
+
+        /**
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {wp.media.View}
+         */
+        createAttachmentView: function( attachment ) {
+                var view = new this.options.AttachmentView({
+                        controller:           this.controller,
+                        model:                attachment,
+                        collection:           this.collection,
+                        selection:            this.options.selection
+                });
+
+                return this._viewsByCid[ attachment.cid ] = view;
+        },
+
+        prepare: function() {
+                // Create all of the Attachment views, and replace
+                // the list in a single DOM operation.
+                if ( this.collection.length ) {
+                        this.views.set( this.collection.map( this.createAttachmentView, this ) );
+
+                // If there are no elements, clear the views and load some.
+                } else {
+                        this.views.unset();
+                        this.collection.more().done( this.scroll );
+                }
+        },
+
+        ready: function() {
+                // Trigger the scroll event to check if we're within the
+                // threshold to query for additional attachments.
+                this.scroll();
+        },
+
+        scroll: function() {
+                var view = this,
+                        el = this.options.scrollElement,
+                        scrollTop = el.scrollTop,
+                        toolbar;
+
+                // The scroll event occurs on the document, but the element
+                // that should be checked is the document body.
+                if ( el == document ) {
+                        el = document.body;
+                        scrollTop = $(document).scrollTop();
+                }
+
+                if ( ! $(el).is(':visible') || ! this.collection.hasMore() ) {
+                        return;
+                }
+
+                toolbar = this.views.parent.toolbar;
+
+                // Show the spinner only if we are close to the bottom.
+                if ( el.scrollHeight - ( scrollTop + el.clientHeight ) < el.clientHeight / 3 ) {
+                        toolbar.get('spinner').show();
+                }
+
+                if ( el.scrollHeight < scrollTop + ( el.clientHeight * this.options.refreshThreshold ) ) {
+                        this.collection.more().done(function() {
+                                view.scroll();
+                                toolbar.get('spinner').hide();
+                        });
+                }
+        }
+});
+
+module.exports = Attachments;
+},{"./attachment.js":20,"./view.js":55}],24:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentsBrowser
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object}      options
+ * @param {object}      [options.filters=false] Which filters to show in the browser's toolbar.
+ *                                              Accepts 'uploaded' and 'all'.
+ * @param {object}      [options.search=true]   Whether to show the search interface in the
+ *                                              browser's toolbar.
+ * @param {object}      [options.display=false] Whether to show the attachments display settings
+ *                                              view in the sidebar.
+ * @param {bool|string} [options.sidebar=true]  Whether to create a sidebar for the browser.
+ *                                              Accepts true, false, and 'errors'.
+ */
+var View = require( '../view.js' ),
+        Library = require( '../attachment/library.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        Spinner = require( '../spinner.js' ),
+        Search = require( '../search.js' ),
+        Label = require( '../label.js' ),
+        Uploaded = require( '../attachment-filters/uploaded.js' ),
+        All = require( '../attachment-filters/all.js' ),
+        DateFilter = require( '../attachment-filters/date.js' ),
+        UploaderInline = require( '../uploader/inline.js' ),
+        Attachments = require( '../attachments.js' ),
+        Sidebar = require( '../sidebar.js' ),
+        UploaderStatus = require( '../uploader/status.js' ),
+        Details = require( '../attachment/details.js' ),
+        AttachmentCompat = require( '../attachment-compat.js' ),
+        AttachmentDisplay = require( '../settings/attachment-display.js' ),
+        mediaTrash = wp.media.view.settings.mediaTrash,
+        l10n = wp.media.view.l10n,
+        $ = jQuery,
+        AttachmentsBrowser;
+
+AttachmentsBrowser = View.extend({
+        tagName:   'div',
+        className: 'attachments-browser',
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        filters: false,
+                        search:  true,
+                        display: false,
+                        sidebar: true,
+                        AttachmentView: Library
+                });
+
+                this.listenTo( this.controller, 'toggle:upload:attachment', _.bind( this.toggleUploader, this ) );
+                this.controller.on( 'edit:selection', this.editSelection );
+                this.createToolbar();
+                if ( this.options.sidebar ) {
+                        this.createSidebar();
+                }
+                this.createUploader();
+                this.createAttachments();
+                this.updateContent();
+
+                if ( ! this.options.sidebar || 'errors' === this.options.sidebar ) {
+                        this.$el.addClass( 'hide-sidebar' );
+
+                        if ( 'errors' === this.options.sidebar ) {
+                                this.$el.addClass( 'sidebar-for-errors' );
+                        }
+                }
+
+                this.collection.on( 'add remove reset', this.updateContent, this );
+        },
+
+        editSelection: function( modal ) {
+                modal.$( '.media-button-backToLibrary' ).focus();
+        },
+
+        /**
+         * @returns {wp.media.view.AttachmentsBrowser} Returns itself to allow chaining
+         */
+        dispose: function() {
+                this.options.selection.off( null, null, this );
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        createToolbar: function() {
+                var LibraryViewSwitcher, Filters, toolbarOptions;
+
+                toolbarOptions = {
+                        controller: this.controller
+                };
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        toolbarOptions.className = 'media-toolbar wp-filter';
+                }
+
+                /**
+                * @member {wp.media.view.Toolbar}
+                */
+                this.toolbar = new Toolbar( toolbarOptions );
+
+                this.views.add( this.toolbar );
+
+                this.toolbar.set( 'spinner', new Spinner({
+                        priority: -60
+                }) );
+
+                if ( -1 !== $.inArray( this.options.filters, [ 'uploaded', 'all' ] ) ) {
+                        // "Filters" will return a <select>, need to render
+                        // screen reader text before
+                        this.toolbar.set( 'filtersLabel', new Label({
+                                value: l10n.filterByType,
+                                attributes: {
+                                        'for':  'media-attachment-filters'
+                                },
+                                priority:   -80
+                        }).render() );
+
+                        if ( 'uploaded' === this.options.filters ) {
+                                this.toolbar.set( 'filters', new Uploaded({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                }).render() );
+                        } else {
+                                Filters = new All({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                });
+
+                                this.toolbar.set( 'filters', Filters.render() );
+                        }
+                }
+
+                // Feels odd to bring the global media library switcher into the Attachment
+                // browser view. Is this a use case for doAction( 'add:toolbar-items:attachments-browser', this.toolbar );
+                // which the controller can tap into and add this view?
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        LibraryViewSwitcher = View.extend({
+                                className: 'view-switch media-grid-view-switch',
+                                template: wp.template( 'media-library-view-switcher')
+                        });
+
+                        this.toolbar.set( 'libraryViewSwitcher', new LibraryViewSwitcher({
+                                controller: this.controller,
+                                priority: -90
+                        }).render() );
+
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+
+                        // BulkSelection is a <div> with subviews, including screen reader text
+                        this.toolbar.set( 'selectModeToggleButton', new wp.media.view.SelectModeToggleButton({
+                                text: l10n.bulkSelect,
+                                controller: this.controller,
+                                priority: -70
+                        }).render() );
+
+                        this.toolbar.set( 'deleteSelectedButton', new wp.media.view.DeleteSelectedButton({
+                                filters: Filters,
+                                style: 'primary',
+                                disabled: true,
+                                text: mediaTrash ? l10n.trashSelected : l10n.deleteSelected,
+                                controller: this.controller,
+                                priority: -60,
+                                click: function() {
+                                        var changed = [], removed = [], self = this,
+                                                selection = this.controller.state().get( 'selection' ),
+                                                library = this.controller.state().get( 'library' );
+
+                                        if ( ! selection.length ) {
+                                                return;
+                                        }
+
+                                        if ( ! mediaTrash && ! confirm( l10n.warnBulkDelete ) ) {
+                                                return;
+                                        }
+
+                                        if ( mediaTrash &&
+                                                'trash' !== selection.at( 0 ).get( 'status' ) &&
+                                                ! confirm( l10n.warnBulkTrash ) ) {
+
+                                                return;
+                                        }
+
+                                        selection.each( function( model ) {
+                                                if ( ! model.get( 'nonces' )['delete'] ) {
+                                                        removed.push( model );
+                                                        return;
+                                                }
+
+                                                if ( mediaTrash && 'trash' === model.get( 'status' ) ) {
+                                                        model.set( 'status', 'inherit' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else if ( mediaTrash ) {
+                                                        model.set( 'status', 'trash' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else {
+                                                        model.destroy({wait: true});
+                                                }
+                                        } );
+
+                                        if ( changed.length ) {
+                                                selection.remove( removed );
+
+                                                $.when.apply( null, changed ).then( function() {
+                                                        library._requery( true );
+                                                        self.controller.trigger( 'selection:action:done' );
+                                                } );
+                                        } else {
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }
+                        }).render() );
+
+                        if ( mediaTrash ) {
+                                this.toolbar.set( 'deleteSelectedPermanentlyButton', new wp.media.view.DeleteSelectedPermanentlyButton({
+                                        filters: Filters,
+                                        style: 'primary',
+                                        disabled: true,
+                                        text: l10n.deleteSelected,
+                                        controller: this.controller,
+                                        priority: -55,
+                                        click: function() {
+                                                var removed = [], selection = this.controller.state().get( 'selection' );
+
+                                                if ( ! selection.length || ! confirm( l10n.warnBulkDelete ) ) {
+                                                        return;
+                                                }
+
+                                                selection.each( function( model ) {
+                                                        if ( ! model.get( 'nonces' )['delete'] ) {
+                                                                removed.push( model );
+                                                                return;
+                                                        }
+
+                                                        model.destroy();
+                                                } );
+
+                                                selection.remove( removed );
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }).render() );
+                        }
+
+                } else {
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+                }
+
+                if ( this.options.search ) {
+                        // Search is an input, screen reader text needs to be rendered before
+                        this.toolbar.set( 'searchLabel', new Label({
+                                value: l10n.searchMediaLabel,
+                                attributes: {
+                                        'for': 'media-search-input'
+                                },
+                                priority:   60
+                        }).render() );
+                        this.toolbar.set( 'search', new Search({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority:   60
+                        }).render() );
+                }
+
+                if ( this.options.dragInfo ) {
+                        this.toolbar.set( 'dragInfo', new View({
+                                el: $( '<div class="instructions">' + l10n.dragInfo + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+
+                if ( this.options.suggestedWidth && this.options.suggestedHeight ) {
+                        this.toolbar.set( 'suggestedDimensions', new View({
+                                el: $( '<div class="instructions">' + l10n.suggestedDimensions + ' ' + this.options.suggestedWidth + ' &times; ' + this.options.suggestedHeight + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+        },
+
+        updateContent: function() {
+                var view = this,
+                        noItemsView;
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        noItemsView = view.attachmentsNoResults;
+                } else {
+                        noItemsView = view.uploader;
+                }
+
+                if ( ! this.collection.length ) {
+                        this.toolbar.get( 'spinner' ).show();
+                        this.dfd = this.collection.more().done( function() {
+                                if ( ! view.collection.length ) {
+                                        noItemsView.$el.removeClass( 'hidden' );
+                                } else {
+                                        noItemsView.$el.addClass( 'hidden' );
+                                }
+                                view.toolbar.get( 'spinner' ).hide();
+                        } );
+                } else {
+                        noItemsView.$el.addClass( 'hidden' );
+                        view.toolbar.get( 'spinner' ).hide();
+                }
+        },
+
+        createUploader: function() {
+                this.uploader = new UploaderInline({
+                        controller: this.controller,
+                        status:     false,
+                        message:    this.controller.isModeActive( 'grid' ) ? '' : l10n.noItemsFound,
+                        canClose:   this.controller.isModeActive( 'grid' )
+                });
+
+                this.uploader.hide();
+                this.views.add( this.uploader );
+        },
+
+        toggleUploader: function() {
+                if ( this.uploader.$el.hasClass( 'hidden' ) ) {
+                        this.uploader.show();
+                } else {
+                        this.uploader.hide();
+                }
+        },
+
+        createAttachments: function() {
+                this.attachments = new Attachments({
+                        controller:           this.controller,
+                        collection:           this.collection,
+                        selection:            this.options.selection,
+                        model:                this.model,
+                        sortable:             this.options.sortable,
+                        scrollElement:        this.options.scrollElement,
+                        idealColumnWidth:     this.options.idealColumnWidth,
+
+                        // The single `Attachment` view to be used in the `Attachments` view.
+                        AttachmentView: this.options.AttachmentView
+                });
+
+                // Add keydown listener to the instance of the Attachments view
+                this.attachments.listenTo( this.controller, 'attachment:keydown:arrow',     this.attachments.arrowEvent );
+                this.attachments.listenTo( this.controller, 'attachment:details:shift-tab', this.attachments.restoreFocus );
+
+                this.views.add( this.attachments );
+
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        this.attachmentsNoResults = new View({
+                                controller: this.controller,
+                                tagName: 'p'
+                        });
+
+                        this.attachmentsNoResults.$el.addClass( 'hidden no-media' );
+                        this.attachmentsNoResults.$el.html( l10n.noMedia );
+
+                        this.views.add( this.attachmentsNoResults );
+                }
+        },
+
+        createSidebar: function() {
+                var options = this.options,
+                        selection = options.selection,
+                        sidebar = this.sidebar = new Sidebar({
+                                controller: this.controller
+                        });
+
+                this.views.add( sidebar );
+
+                if ( this.controller.uploader ) {
+                        sidebar.set( 'uploads', new UploaderStatus({
+                                controller: this.controller,
+                                priority:   40
+                        }) );
+                }
+
+                selection.on( 'selection:single', this.createSingle, this );
+                selection.on( 'selection:unsingle', this.disposeSingle, this );
+
+                if ( selection.single() ) {
+                        this.createSingle();
+                }
+        },
+
+        createSingle: function() {
+                var sidebar = this.sidebar,
+                        single = this.options.selection.single();
+
+                sidebar.set( 'details', new Details({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   80
+                }) );
+
+                sidebar.set( 'compat', new AttachmentCompat({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   120
+                }) );
+
+                if ( this.options.display ) {
+                        sidebar.set( 'display', new AttachmentDisplay({
+                                controller:   this.controller,
+                                model:        this.model.display( single ),
+                                attachment:   single,
+                                priority:     160,
+                                userSettings: this.model.get('displayUserSettings')
+                        }) );
+                }
+
+                // Show the sidebar on mobile
+                if ( this.model.id === 'insert' ) {
+                        sidebar.$el.addClass( 'visible' );
+                }
+        },
+
+        disposeSingle: function() {
+                var sidebar = this.sidebar;
+                sidebar.unset('details');
+                sidebar.unset('compat');
+                sidebar.unset('display');
+                // Hide the sidebar on mobile
+                sidebar.$el.removeClass( 'visible' );
+        }
+});
+
+module.exports = AttachmentsBrowser;
+},{"../attachment-compat.js":15,"../attachment-filters/all.js":17,"../attachment-filters/date.js":18,"../attachment-filters/uploaded.js":19,"../attachment/details.js":21,"../attachment/library.js":22,"../attachments.js":23,"../label.js":34,"../search.js":43,"../settings/attachment-display.js":45,"../sidebar.js":46,"../spinner.js":47,"../toolbar.js":48,"../uploader/inline.js":50,"../uploader/status.js":52,"../view.js":55}],25:[function(require,module,exports){
+/**
+ * wp.media.view.AudioDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaDetails
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MediaDetails = require( './media-details' ),
+        AudioDetails;
+
+AudioDetails = MediaDetails.extend({
+        className: 'audio-details',
+        template:  wp.template('audio-details'),
+
+        setMedia: function() {
+                var audio = this.$('.wp-audio-shortcode');
+
+                if ( audio.find( 'source' ).length ) {
+                        if ( audio.is(':hidden') ) {
+                                audio.show();
+                        }
+                        this.media = MediaDetails.prepareSrc( audio.get(0) );
+                } else {
+                        audio.hide();
+                        this.media = false;
+                }
+
+                return this;
+        }
+});
+
+module.exports = AudioDetails;
+},{"./media-details":35}],26:[function(require,module,exports){
+/**
+ * wp.media.view.Button
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button;
+
+Button = View.extend({
+        tagName:    'a',
+        className:  'media-button',
+        attributes: { href: '#' },
+
+        events: {
+                'click': 'click'
+        },
+
+        defaults: {
+                text:     '',
+                style:    '',
+                size:     'large',
+                disabled: false
+        },
+
+        initialize: function() {
+                /**
+                 * Create a model with the provided `defaults`.
+                 *
+                 * @member {Backbone.Model}
+                 */
+                this.model = new Backbone.Model( this.defaults );
+
+                // If any of the `options` have a key from `defaults`, apply its
+                // value to the `model` and remove it from the `options object.
+                _.each( this.defaults, function( def, key ) {
+                        var value = this.options[ key ];
+                        if ( _.isUndefined( value ) ) {
+                                return;
+                        }
+
+                        this.model.set( key, value );
+                        delete this.options[ key ];
+                }, this );
+
+                this.model.on( 'change', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.Button} Returns itself to allow chaining
+         */
+        render: function() {
+                var classes = [ 'button', this.className ],
+                        model = this.model.toJSON();
+
+                if ( model.style ) {
+                        classes.push( 'button-' + model.style );
+                }
+
+                if ( model.size ) {
+                        classes.push( 'button-' + model.size );
+                }
+
+                classes = _.uniq( classes.concat( this.options.classes ) );
+                this.el.className = classes.join(' ');
+
+                this.$el.attr( 'disabled', model.disabled );
+                this.$el.text( this.model.get('text') );
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        click: function( event ) {
+                if ( '#' === this.attributes.href ) {
+                        event.preventDefault();
+                }
+
+                if ( this.options.click && ! this.model.get('disabled') ) {
+                        this.options.click.apply( this, arguments );
+                }
+        }
+});
+
+module.exports = Button;
+},{"./view.js":55}],27:[function(require,module,exports){
+/**
+ * wp.media.view.FocusManager
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager;
+
+FocusManager = View.extend({
+
+        events: {
+                'keydown': 'constrainTabbing'
+        },
+
+        focus: function() { // Reset focus on first left menu item
+                this.$('.media-menu-item').first().focus();
+        },
+        /**
+         * @param {Object} event
+         */
+        constrainTabbing: function( event ) {
+                var tabbables;
+
+                // Look for the tab key.
+                if ( 9 !== event.keyCode ) {
+                        return;
+                }
+
+                tabbables = this.$( ':tabbable' );
+
+                // Keep tab focus within media modal while it's open
+                if ( tabbables.last()[0] === event.target && ! event.shiftKey ) {
+                        tabbables.first().focus();
+                        return false;
+                } else if ( tabbables.first()[0] === event.target && event.shiftKey ) {
+                        tabbables.last().focus();
+                        return false;
+                }
+        }
+
+});
+
+module.exports = FocusManager;
+},{"./view.js":55}],28:[function(require,module,exports){
+/**
+ * wp.media.view.Frame
+ *
+ * A frame is a composite view consisting of one or more regions and one or more
+ * states.
+ *
+ * @see wp.media.controller.State
+ * @see wp.media.controller.Region
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var StateMachine = require( '../controllers/state-machine.js' ),
+        State = require( '../controllers/state.js' ),
+        Region = require( '../controllers/region.js' ),
+        View = require( './view.js' ),
+        Frame;
+
+Frame = View.extend({
+        initialize: function() {
+                _.defaults( this.options, {
+                        mode: [ 'select' ]
+                });
+                this._createRegions();
+                this._createStates();
+                this._createModes();
+        },
+
+        _createRegions: function() {
+                // Clone the regions array.
+                this.regions = this.regions ? this.regions.slice() : [];
+
+                // Initialize regions.
+                _.each( this.regions, function( region ) {
+                        this[ region ] = new Region({
+                                view:     this,
+                                id:       region,
+                                selector: '.media-frame-' + region
+                        });
+                }, this );
+        },
+        /**
+         * Create the frame's states.
+         *
+         * @see wp.media.controller.State
+         * @see wp.media.controller.StateMachine
+         *
+         * @fires wp.media.controller.State#ready
+         */
+        _createStates: function() {
+                // Create the default `states` collection.
+                this.states = new Backbone.Collection( null, {
+                        model: State
+                });
+
+                // Ensure states have a reference to the frame.
+                this.states.on( 'add', function( model ) {
+                        model.frame = this;
+                        model.trigger('ready');
+                }, this );
+
+                if ( this.options.states ) {
+                        this.states.add( this.options.states );
+                }
+        },
+
+        /**
+         * A frame can be in a mode or multiple modes at one time.
+         *
+         * For example, the manage media frame can be in the `Bulk Select` or `Edit` mode.
+         */
+        _createModes: function() {
+                // Store active "modes" that the frame is in. Unrelated to region modes.
+                this.activeModes = new Backbone.Collection();
+                this.activeModes.on( 'add remove reset', _.bind( this.triggerModeEvents, this ) );
+
+                _.each( this.options.mode, function( mode ) {
+                        this.activateMode( mode );
+                }, this );
+        },
+        /**
+         * Reset all states on the frame to their defaults.
+         *
+         * @returns {wp.media.view.Frame} Returns itself to allow chaining
+         */
+        reset: function() {
+                this.states.invoke( 'trigger', 'reset' );
+                return this;
+        },
+        /**
+         * Map activeMode collection events to the frame.
+         */
+        triggerModeEvents: function( model, collection, options ) {
+                var collectionEvent,
+                        modeEventMap = {
+                                add: 'activate',
+                                remove: 'deactivate'
+                        },
+                        eventToTrigger;
+                // Probably a better way to do this.
+                _.each( options, function( value, key ) {
+                        if ( value ) {
+                                collectionEvent = key;
+                        }
+                } );
+
+                if ( ! _.has( modeEventMap, collectionEvent ) ) {
+                        return;
+                }
+
+                eventToTrigger = model.get('id') + ':' + modeEventMap[collectionEvent];
+                this.trigger( eventToTrigger );
+        },
+        /**
+         * Activate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        activateMode: function( mode ) {
+                // Bail if the mode is already active.
+                if ( this.isModeActive( mode ) ) {
+                        return;
+                }
+                this.activeModes.add( [ { id: mode } ] );
+                // Add a CSS class to the frame so elements can be styled for the mode.
+                this.$el.addClass( 'mode-' + mode );
+
+                return this;
+        },
+        /**
+         * Deactivate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        deactivateMode: function( mode ) {
+                // Bail if the mode isn't active.
+                if ( ! this.isModeActive( mode ) ) {
+                        return this;
+                }
+                this.activeModes.remove( this.activeModes.where( { id: mode } ) );
+                this.$el.removeClass( 'mode-' + mode );
+                /**
+                 * Frame mode deactivation event.
+                 *
+                 * @event this#{mode}:deactivate
+                 */
+                this.trigger( mode + ':deactivate' );
+
+                return this;
+        },
+        /**
+         * Check if a mode is enabled on the frame.
+         *
+         * @param  string mode Mode ID.
+         * @return bool
+         */
+        isModeActive: function( mode ) {
+                return Boolean( this.activeModes.where( { id: mode } ).length );
+        }
+});
+
+// Make the `Frame` a `StateMachine`.
+_.extend( Frame.prototype, StateMachine.prototype );
+
+module.exports = Frame;
+},{"../controllers/region.js":5,"../controllers/state-machine.js":6,"../controllers/state.js":7,"./view.js":55}],29:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame.AudioDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.MediaDetails
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaDetails = require( './media-details' ),
+        MediaLibrary = require( '../../controllers/media-library.js' ),
+        AudioDetailsView = require( '../audio-details.js' ),
+        AudioDetailsController = require( '../../controllers/audio-details.js' ),
+        l10n = wp.media.view.l10n,
+        AudioDetails;
+
+AudioDetails = MediaDetails.extend({
+        defaults: {
+                id:      'audio',
+                url:     '',
+                menu:    'audio-details',
+                content: 'audio-details',
+                toolbar: 'audio-details',
+                type:    'link',
+                title:    l10n.audioDetailsTitle,
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                options.DetailsView = AudioDetailsView;
+                options.cancelText = l10n.audioDetailsCancel;
+                options.addText = l10n.audioAddSourceTitle;
+
+                MediaDetails.prototype.initialize.call( this, options );
+        },
+
+        bindHandlers: function() {
+                MediaDetails.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'toolbar:render:replace-audio', this.renderReplaceToolbar, this );
+                this.on( 'toolbar:render:add-audio-source', this.renderAddSourceToolbar, this );
+        },
+
+        createStates: function() {
+                this.states.add([
+                        new AudioDetailsController( {
+                                media: this.media
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'audio',
+                                id: 'replace-audio',
+                                title: l10n.audioReplaceTitle,
+                                toolbar: 'replace-audio',
+                                media: this.media,
+                                menu: 'audio-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'audio',
+                                id: 'add-audio-source',
+                                title: l10n.audioAddSourceTitle,
+                                toolbar: 'add-audio-source',
+                                media: this.media,
+                                menu: false
+                        } )
+                ]);
+        }
+});
+
+module.exports = AudioDetails;
+},{"../../controllers/audio-details.js":2,"../../controllers/media-library.js":4,"../audio-details.js":25,"./media-details":30}],30:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame.MediaDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( '../view.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        Select = require( './select.js' ),
+        Selection = require( '../../models/selection.js' ),
+        PostMedia = require( '../../models/post-media.js' ),
+        l10n = wp.media.view.l10n,
+        MediaDetails;
+
+MediaDetails = Select.extend({
+        defaults: {
+                id:      'media',
+                url:     '',
+                menu:    'media-details',
+                content: 'media-details',
+                toolbar: 'media-details',
+                type:    'link',
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                this.DetailsView = options.DetailsView;
+                this.cancelText = options.cancelText;
+                this.addText = options.addText;
+
+                this.media = new PostMedia( options.metadata );
+                this.options.selection = new Selection( this.media.attachment, { multiple: false } );
+                Select.prototype.initialize.apply( this, arguments );
+        },
+
+        bindHandlers: function() {
+                var menu = this.defaults.menu;
+
+                Select.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'menu:create:' + menu, this.createMenu, this );
+                this.on( 'content:render:' + menu, this.renderDetailsContent, this );
+                this.on( 'menu:render:' + menu, this.renderMenu, this );
+                this.on( 'toolbar:render:' + menu, this.renderDetailsToolbar, this );
+        },
+
+        renderDetailsContent: function() {
+                var view = new this.DetailsView({
+                        controller: this,
+                        model: this.state().media,
+                        attachment: this.state().media.attachment
+                }).render();
+
+                this.content.set( view );
+        },
+
+        renderMenu: function( view ) {
+                var lastState = this.lastState(),
+                        previous = lastState && lastState.id,
+                        frame = this;
+
+                view.set({
+                        cancel: {
+                                text:     this.cancelText,
+                                priority: 20,
+                                click:    function() {
+                                        if ( previous ) {
+                                                frame.setState( previous );
+                                        } else {
+                                                frame.close();
+                                        }
+                                }
+                        },
+                        separateCancel: new View({
+                                className: 'separator',
+                                priority: 40
+                        })
+                });
+
+        },
+
+        setPrimaryButton: function(text, handler) {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                button: {
+                                        style:    'primary',
+                                        text:     text,
+                                        priority: 80,
+                                        click:    function() {
+                                                var controller = this.controller;
+                                                handler.call( this, controller, controller.state() );
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        renderDetailsToolbar: function() {
+                this.setPrimaryButton( l10n.update, function( controller, state ) {
+                        controller.close();
+                        state.trigger( 'update', controller.media.toJSON() );
+                } );
+        },
+
+        renderReplaceToolbar: function() {
+                this.setPrimaryButton( l10n.replace, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single();
+                        controller.media.changeAttachment( attachment );
+                        state.trigger( 'replace', controller.media.toJSON() );
+                } );
+        },
+
+        renderAddSourceToolbar: function() {
+                this.setPrimaryButton( this.addText, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single();
+                        controller.media.setSource( attachment );
+                        state.trigger( 'add-source', controller.media.toJSON() );
+                } );
+        }
+});
+
+module.exports = MediaDetails;
+},{"../../models/post-media.js":11,"../../models/selection.js":13,"../toolbar.js":48,"../view.js":55,"./select.js":31}],31:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame.Select
+ *
+ * A frame for selecting an item or items from the media library.
+ *
+ * @class
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+
+var MediaFrame = require( '../media-frame.js' ),
+        Library = require( '../../controllers/library.js' ),
+        AttachmentsModel = require( '../../models/attachments.js' ),
+        SelectionModel = require( '../../models/selection.js' ),
+        AttachmentsBrowser = require( '../attachments/browser.js' ),
+        UploaderInline = require( '../uploader/inline.js' ),
+        ToolbarSelect = require( '../toolbar/select.js' ),
+        l10n = wp.media.view.l10n,
+        Select;
+
+Select = MediaFrame.extend({
+        initialize: function() {
+                // Call 'initialize' directly on the parent class.
+                MediaFrame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        selection: [],
+                        library:   {},
+                        multiple:  false,
+                        state:    'library'
+                });
+
+                this.createSelection();
+                this.createStates();
+                this.bindHandlers();
+        },
+
+        /**
+         * Attach a selection collection to the frame.
+         *
+         * A selection is a collection of attachments used for a specific purpose
+         * by a media frame. e.g. Selecting an attachment (or many) to insert into
+         * post content.
+         *
+         * @see media.model.Selection
+         */
+        createSelection: function() {
+                var selection = this.options.selection;
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        this.options.selection = new SelectionModel( selection, {
+                                multiple: this.options.multiple
+                        });
+                }
+
+                this._selection = {
+                        attachments: new AttachmentsModel(),
+                        difference: []
+                };
+        },
+
+        /**
+         * Create the default states on the frame.
+         */
+        createStates: function() {
+                var options = this.options;
+
+                if ( this.options.states ) {
+                        return;
+                }
+
+                // Add the default states.
+                this.states.add([
+                        // Main states.
+                        new Library({
+                                library:   wp.media.query( options.library ),
+                                multiple:  options.multiple,
+                                title:     options.title,
+                                priority:  20
+                        })
+                ]);
+        },
+
+        /**
+         * Bind region mode event callbacks.
+         *
+         * @see media.controller.Region.render
+         */
+        bindHandlers: function() {
+                this.on( 'router:create:browse', this.createRouter, this );
+                this.on( 'router:render:browse', this.browseRouter, this );
+                this.on( 'content:create:browse', this.browseContent, this );
+                this.on( 'content:render:upload', this.uploadContent, this );
+                this.on( 'toolbar:create:select', this.createSelectToolbar, this );
+        },
+
+        /**
+         * Render callback for the router region in the `browse` mode.
+         *
+         * @param {wp.media.view.Router} routerView
+         */
+        browseRouter: function( routerView ) {
+                routerView.set({
+                        upload: {
+                                text:     l10n.uploadFilesTitle,
+                                priority: 20
+                        },
+                        browse: {
+                                text:     l10n.mediaLibraryTitle,
+                                priority: 40
+                        }
+                });
+        },
+
+        /**
+         * Render callback for the content region in the `browse` mode.
+         *
+         * @param {wp.media.controller.Region} contentRegion
+         */
+        browseContent: function( contentRegion ) {
+                var state = this.state();
+
+                this.$el.removeClass('hide-toolbar');
+
+                // Browse our library of attachments.
+                contentRegion.view = new AttachmentsBrowser({
+                        controller: this,
+                        collection: state.get('library'),
+                        selection:  state.get('selection'),
+                        model:      state,
+                        sortable:   state.get('sortable'),
+                        search:     state.get('searchable'),
+                        filters:    state.get('filterable'),
+                        display:    state.has('display') ? state.get('display') : state.get('displaySettings'),
+                        dragInfo:   state.get('dragInfo'),
+
+                        idealColumnWidth: state.get('idealColumnWidth'),
+                        suggestedWidth:   state.get('suggestedWidth'),
+                        suggestedHeight:  state.get('suggestedHeight'),
+
+                        AttachmentView: state.get('AttachmentView')
+                });
+        },
+
+        /**
+         * Render callback for the content region in the `upload` mode.
+         */
+        uploadContent: function() {
+                this.$el.removeClass( 'hide-toolbar' );
+                this.content.set( new UploaderInline({
+                        controller: this
+                }) );
+        },
+
+        /**
+         * Toolbars
+         *
+         * @param {Object} toolbar
+         * @param {Object} [options={}]
+         * @this wp.media.controller.Region
+         */
+        createSelectToolbar: function( toolbar, options ) {
+                options = options || this.options.button || {};
+                options.controller = this;
+
+                toolbar.view = new ToolbarSelect( options );
+        }
+});
+
+module.exports = Select;
+},{"../../controllers/library.js":3,"../../models/attachments.js":10,"../../models/selection.js":13,"../attachments/browser.js":24,"../media-frame.js":36,"../toolbar/select.js":49,"../uploader/inline.js":50}],32:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame.VideoDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.MediaDetails
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaDetails = require( './media-details' ),
+        MediaLibrary = require( '../../controllers/media-library.js' ),
+        VideoDetailsView = require( '../video-details.js' ),
+        VideoDetailsController = require( '../../controllers/video-details.js' ),
+        l10n = wp.media.view.l10n,
+        VideoDetails;
+
+VideoDetails = MediaDetails.extend({
+        defaults: {
+                id:      'video',
+                url:     '',
+                menu:    'video-details',
+                content: 'video-details',
+                toolbar: 'video-details',
+                type:    'link',
+                title:    l10n.videoDetailsTitle,
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                options.DetailsView = VideoDetailsView;
+                options.cancelText = l10n.videoDetailsCancel;
+                options.addText = l10n.videoAddSourceTitle;
+
+                MediaDetails.prototype.initialize.call( this, options );
+        },
+
+        bindHandlers: function() {
+                MediaDetails.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'toolbar:render:replace-video', this.renderReplaceToolbar, this );
+                this.on( 'toolbar:render:add-video-source', this.renderAddSourceToolbar, this );
+                this.on( 'toolbar:render:select-poster-image', this.renderSelectPosterImageToolbar, this );
+                this.on( 'toolbar:render:add-track', this.renderAddTrackToolbar, this );
+        },
+
+        createStates: function() {
+                this.states.add([
+                        new VideoDetailsController({
+                                media: this.media
+                        }),
+
+                        new MediaLibrary( {
+                                type: 'video',
+                                id: 'replace-video',
+                                title: l10n.videoReplaceTitle,
+                                toolbar: 'replace-video',
+                                media: this.media,
+                                menu: 'video-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'video',
+                                id: 'add-video-source',
+                                title: l10n.videoAddSourceTitle,
+                                toolbar: 'add-video-source',
+                                media: this.media,
+                                menu: false
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'image',
+                                id: 'select-poster-image',
+                                title: l10n.videoSelectPosterImageTitle,
+                                toolbar: 'select-poster-image',
+                                media: this.media,
+                                menu: 'video-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'text',
+                                id: 'add-track',
+                                title: l10n.videoAddTrackTitle,
+                                toolbar: 'add-track',
+                                media: this.media,
+                                menu: 'video-details'
+                        } )
+                ]);
+        },
+
+        renderSelectPosterImageToolbar: function() {
+                this.setPrimaryButton( l10n.videoSelectPosterImageTitle, function( controller, state ) {
+                        var urls = [], attachment = state.get( 'selection' ).single();
+
+                        controller.media.set( 'poster', attachment.get( 'url' ) );
+                        state.trigger( 'set-poster-image', controller.media.toJSON() );
+
+                        _.each( wp.media.view.settings.embedExts, function (ext) {
+                                if ( controller.media.get( ext ) ) {
+                                        urls.push( controller.media.get( ext ) );
+                                }
+                        } );
+
+                        wp.ajax.send( 'set-attachment-thumbnail', {
+                                data : {
+                                        urls: urls,
+                                        thumbnail_id: attachment.get( 'id' )
+                                }
+                        } );
+                } );
+        },
+
+        renderAddTrackToolbar: function() {
+                this.setPrimaryButton( l10n.videoAddTrackTitle, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single(),
+                                content = controller.media.get( 'content' );
+
+                        if ( -1 === content.indexOf( attachment.get( 'url' ) ) ) {
+                                content += [
+                                        '<track srclang="en" label="English"kind="subtitles" src="',
+                                        attachment.get( 'url' ),
+                                        '" />'
+                                ].join('');
+
+                                controller.media.set( 'content', content );
+                        }
+                        state.trigger( 'add-track', controller.media.toJSON() );
+                } );
+        }
+});
+
+module.exports = VideoDetails;
+},{"../../controllers/media-library.js":4,"../../controllers/video-details.js":8,"../video-details.js":54,"./media-details":30}],33:[function(require,module,exports){
+/**
+ * wp.media.view.Iframe
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Iframe;
+
+Iframe = View.extend({
+        className: 'media-iframe',
+        /**
+         * @returns {wp.media.view.Iframe} Returns itself to allow chaining
+         */
+        render: function() {
+                this.views.detach();
+                this.$el.html( '<iframe src="' + this.controller.state().get('src') + '" />' );
+                this.views.render();
+                return this;
+        }
+});
+
+module.exports = Iframe;
+},{"./view.js":55}],34:[function(require,module,exports){
+/**
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Label;
+
+Label = View.extend({
+        tagName: 'label',
+        className: 'screen-reader-text',
+
+        initialize: function() {
+                this.value = this.options.value;
+        },
+
+        render: function() {
+                this.$el.html( this.value );
+
+                return this;
+        }
+});
+
+module.exports = Label;
+},{"./view.js":55}],35:[function(require,module,exports){
+/**
+ * wp.media.view.MediaDetails
+ *
+ * @constructor
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentDisplay = require( './settings/attachment-display.js' ),
+        $ = jQuery,
+        MediaDetails;
+
+MediaDetails = AttachmentDisplay.extend({
+        initialize: function() {
+                _.bindAll(this, 'success');
+                this.players = [];
+                this.listenTo( this.controller, 'close', wp.media.mixin.unsetPlayers );
+                this.on( 'ready', this.setPlayer );
+                this.on( 'media:setting:remove', wp.media.mixin.unsetPlayers, this );
+                this.on( 'media:setting:remove', this.render );
+                this.on( 'media:setting:remove', this.setPlayer );
+                this.events = _.extend( this.events, {
+                        'click .remove-setting' : 'removeSetting',
+                        'change .content-track' : 'setTracks',
+                        'click .remove-track' : 'setTracks',
+                        'click .add-media-source' : 'addSource'
+                } );
+
+                AttachmentDisplay.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+
+        /**
+         * Remove a setting's UI when the model unsets it
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         *
+         * @param {Event} e
+         */
+        removeSetting : function(e) {
+                var wrap = $( e.currentTarget ).parent(), setting;
+                setting = wrap.find( 'input' ).data( 'setting' );
+
+                if ( setting ) {
+                        this.model.unset( setting );
+                        this.trigger( 'media:setting:remove', this );
+                }
+
+                wrap.remove();
+        },
+
+        /**
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         */
+        setTracks : function() {
+                var tracks = '';
+
+                _.each( this.$('.content-track'), function(track) {
+                        tracks += $( track ).val();
+                } );
+
+                this.model.set( 'content', tracks );
+                this.trigger( 'media:setting:remove', this );
+        },
+
+        addSource : function( e ) {
+                this.controller.lastMime = $( e.currentTarget ).data( 'mime' );
+                this.controller.setState( 'add-' + this.controller.defaults.id + '-source' );
+        },
+
+        /**
+         * @global MediaElementPlayer
+         */
+        setPlayer : function() {
+                if ( ! this.players.length && this.media ) {
+                        this.players.push( new MediaElementPlayer( this.media, this.settings ) );
+                }
+        },
+
+        /**
+         * @abstract
+         */
+        setMedia : function() {
+                return this;
+        },
+
+        success : function(mejs) {
+                var autoplay = mejs.attributes.autoplay && 'false' !== mejs.attributes.autoplay;
+
+                if ( 'flash' === mejs.pluginType && autoplay ) {
+                        mejs.addEventListener( 'canplay', function() {
+                                mejs.play();
+                        }, false );
+                }
+
+                this.mejs = mejs;
+        },
+
+        /**
+         * @returns {media.view.MediaDetails} Returns itself to allow chaining
+         */
+        render: function() {
+                var self = this;
+
+                AttachmentDisplay.prototype.render.apply( this, arguments );
+                setTimeout( function() { self.resetFocus(); }, 10 );
+
+                this.settings = _.defaults( {
+                        success : this.success
+                }, wp.media.mixin.mejsSettings );
+
+                return this.setMedia();
+        },
+
+        resetFocus: function() {
+                this.$( '.embed-media-settings' ).scrollTop( 0 );
+        }
+}, {
+        instances : 0,
+        /**
+         * When multiple players in the DOM contain the same src, things get weird.
+         *
+         * @param {HTMLElement} elem
+         * @returns {HTMLElement}
+         */
+        prepareSrc : function( elem ) {
+                var i = MediaDetails.instances++;
+                _.each( $( elem ).find( 'source' ), function( source ) {
+                        source.src = [
+                                source.src,
+                                source.src.indexOf('?') > -1 ? '&' : '?',
+                                '_=',
+                                i
+                        ].join('');
+                } );
+
+                return elem;
+        }
+});
+
+module.exports = MediaDetails;
+},{"./settings/attachment-display.js":45}],36:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame
+ *
+ * The frame used to create the media modal.
+ *
+ * @class
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( './view.js' ),
+        Frame = require( './frame.js' ),
+        Modal = require( './modal.js' ),
+        UploaderWindow = require( './uploader/window.js' ),
+        Menu = require( './menu.js' ),
+        Toolbar = require( './toolbar.js' ),
+        Router = require( './router.js' ),
+        Iframe = require( './iframe.js' ),
+        $ = jQuery,
+        MediaFrame;
+
+MediaFrame = Frame.extend({
+        className: 'media-frame',
+        template:  wp.template('media-frame'),
+        regions:   ['menu','title','content','toolbar','router'],
+
+        events: {
+                'click div.media-frame-title h1': 'toggleMenu'
+        },
+
+        /**
+         * @global wp.Uploader
+         */
+        initialize: function() {
+                Frame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        title:    '',
+                        modal:    true,
+                        uploader: true
+                });
+
+                // Ensure core UI is enabled.
+                this.$el.addClass('wp-core-ui');
+
+                // Initialize modal container view.
+                if ( this.options.modal ) {
+                        this.modal = new Modal({
+                                controller: this,
+                                title:      this.options.title
+                        });
+
+                        this.modal.content( this );
+                }
+
+                // Force the uploader off if the upload limit has been exceeded or
+                // if the browser isn't supported.
+                if ( wp.Uploader.limitExceeded || ! wp.Uploader.browser.supported ) {
+                        this.options.uploader = false;
+                }
+
+                // Initialize window-wide uploader.
+                if ( this.options.uploader ) {
+                        this.uploader = new UploaderWindow({
+                                controller: this,
+                                uploader: {
+                                        dropzone:  this.modal ? this.modal.$el : this.$el,
+                                        container: this.$el
+                                }
+                        });
+                        this.views.set( '.media-frame-uploader', this.uploader );
+                }
+
+                this.on( 'attach', _.bind( this.views.ready, this.views ), this );
+
+                // Bind default title creation.
+                this.on( 'title:create:default', this.createTitle, this );
+                this.title.mode('default');
+
+                this.on( 'title:render', function( view ) {
+                        view.$el.append( '<span class="dashicons dashicons-arrow-down"></span>' );
+                });
+
+                // Bind default menu.
+                this.on( 'menu:create:default', this.createMenu, this );
+        },
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        render: function() {
+                // Activate the default state if no active state exists.
+                if ( ! this.state() && this.options.state ) {
+                        this.setState( this.options.state );
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                return Frame.prototype.render.apply( this, arguments );
+        },
+        /**
+         * @param {Object} title
+         * @this wp.media.controller.Region
+         */
+        createTitle: function( title ) {
+                title.view = new View({
+                        controller: this,
+                        tagName: 'h1'
+                });
+        },
+        /**
+         * @param {Object} menu
+         * @this wp.media.controller.Region
+         */
+        createMenu: function( menu ) {
+                menu.view = new Menu({
+                        controller: this
+                });
+        },
+
+        toggleMenu: function() {
+                this.$el.find( '.media-menu' ).toggleClass( 'visible' );
+        },
+
+        /**
+         * @param {Object} toolbar
+         * @this wp.media.controller.Region
+         */
+        createToolbar: function( toolbar ) {
+                toolbar.view = new Toolbar({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} router
+         * @this wp.media.controller.Region
+         */
+        createRouter: function( router ) {
+                router.view = new Router({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} options
+         */
+        createIframeStates: function( options ) {
+                var settings = wp.media.view.settings,
+                        tabs = settings.tabs,
+                        tabUrl = settings.tabUrl,
+                        $postId;
+
+                if ( ! tabs || ! tabUrl ) {
+                        return;
+                }
+
+                // Add the post ID to the tab URL if it exists.
+                $postId = $('#post_ID');
+                if ( $postId.length ) {
+                        tabUrl += '&post_id=' + $postId.val();
+                }
+
+                // Generate the tab states.
+                _.each( tabs, function( title, id ) {
+                        this.state( 'iframe:' + id ).set( _.defaults({
+                                tab:     id,
+                                src:     tabUrl + '&tab=' + id,
+                                title:   title,
+                                content: 'iframe',
+                                menu:    'default'
+                        }, options ) );
+                }, this );
+
+                this.on( 'content:create:iframe', this.iframeContent, this );
+                this.on( 'content:deactivate:iframe', this.iframeContentCleanup, this );
+                this.on( 'menu:render:default', this.iframeMenu, this );
+                this.on( 'open', this.hijackThickbox, this );
+                this.on( 'close', this.restoreThickbox, this );
+        },
+
+        /**
+         * @param {Object} content
+         * @this wp.media.controller.Region
+         */
+        iframeContent: function( content ) {
+                this.$el.addClass('hide-toolbar');
+                content.view = new Iframe({
+                        controller: this
+                });
+        },
+
+        iframeContentCleanup: function() {
+                this.$el.removeClass('hide-toolbar');
+        },
+
+        iframeMenu: function( view ) {
+                var views = {};
+
+                if ( ! view ) {
+                        return;
+                }
+
+                _.each( wp.media.view.settings.tabs, function( title, id ) {
+                        views[ 'iframe:' + id ] = {
+                                text: this.state( 'iframe:' + id ).get('title'),
+                                priority: 200
+                        };
+                }, this );
+
+                view.set( views );
+        },
+
+        hijackThickbox: function() {
+                var frame = this;
+
+                if ( ! window.tb_remove || this._tb_remove ) {
+                        return;
+                }
+
+                this._tb_remove = window.tb_remove;
+                window.tb_remove = function() {
+                        frame.close();
+                        frame.reset();
+                        frame.setState( frame.options.state );
+                        frame._tb_remove.call( window );
+                };
+        },
+
+        restoreThickbox: function() {
+                if ( ! this._tb_remove ) {
+                        return;
+                }
+
+                window.tb_remove = this._tb_remove;
+                delete this._tb_remove;
+        }
+});
+
+// Map some of the modal's methods to the frame.
+_.each(['open','close','attach','detach','escape'], function( method ) {
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        MediaFrame.prototype[ method ] = function() {
+                if ( this.modal ) {
+                        this.modal[ method ].apply( this.modal, arguments );
+                }
+                return this;
+        };
+});
+
+module.exports = MediaFrame;
+},{"./frame.js":28,"./iframe.js":33,"./menu.js":38,"./modal.js":39,"./router.js":42,"./toolbar.js":48,"./uploader/window.js":53,"./view.js":55}],37:[function(require,module,exports){
+/**
+ * wp.media.view.MenuItem
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        MenuItem;
+
+MenuItem = View.extend({
+        tagName:   'a',
+        className: 'media-menu-item',
+
+        attributes: {
+                href: '#'
+        },
+
+        events: {
+                'click': '_click'
+        },
+        /**
+         * @param {Object} event
+         */
+        _click: function( event ) {
+                var clickOverride = this.options.click;
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                if ( clickOverride ) {
+                        clickOverride.call( this );
+                } else {
+                        this.click();
+                }
+
+                // When selecting a tab along the left side,
+                // focus should be transferred into the main panel
+                if ( ! wp.media.isTouchDevice ) {
+                        $('.media-frame-content input').first().focus();
+                }
+        },
+
+        click: function() {
+                var state = this.options.state;
+
+                if ( state ) {
+                        this.controller.setState( state );
+                        this.views.parent.$el.removeClass( 'visible' ); // TODO: or hide on any click, see below
+                }
+        },
+        /**
+         * @returns {wp.media.view.MenuItem} returns itself to allow chaining
+         */
+        render: function() {
+                var options = this.options;
+
+                if ( options.text ) {
+                        this.$el.text( options.text );
+                } else if ( options.html ) {
+                        this.$el.html( options.html );
+                }
+
+                return this;
+        }
+});
+
+module.exports = MenuItem;
+},{"./view.js":55}],38:[function(require,module,exports){
+/**
+ * wp.media.view.Menu
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Menu;
+
+Menu = PriorityList.extend({
+        tagName:   'div',
+        className: 'media-menu',
+        property:  'state',
+        ItemView:  MenuItem,
+        region:    'menu',
+
+        /* TODO: alternatively hide on any click anywhere
+        events: {
+                'click': 'click'
+        },
+
+        click: function() {
+                this.$el.removeClass( 'visible' );
+        },
+        */
+
+        /**
+         * @param {Object} options
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        toView: function( options, id ) {
+                options = options || {};
+                options[ this.property ] = options[ this.property ] || id;
+                return new this.ItemView( options ).render();
+        },
+
+        ready: function() {
+                /**
+                 * call 'ready' directly on the parent class
+                 */
+                PriorityList.prototype.ready.apply( this, arguments );
+                this.visibility();
+        },
+
+        set: function() {
+                /**
+                 * call 'set' directly on the parent class
+                 */
+                PriorityList.prototype.set.apply( this, arguments );
+                this.visibility();
+        },
+
+        unset: function() {
+                /**
+                 * call 'unset' directly on the parent class
+                 */
+                PriorityList.prototype.unset.apply( this, arguments );
+                this.visibility();
+        },
+
+        visibility: function() {
+                var region = this.region,
+                        view = this.controller[ region ].get(),
+                        views = this.views.get(),
+                        hide = ! views || views.length < 2;
+
+                if ( this === view ) {
+                        this.controller.$el.toggleClass( 'hide-' + region, hide );
+                }
+        },
+        /**
+         * @param {string} id
+         */
+        select: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                this.deselect();
+                view.$el.addClass('active');
+        },
+
+        deselect: function() {
+                this.$el.children().removeClass('active');
+        },
+
+        hide: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.addClass('hidden');
+        },
+
+        show: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.removeClass('hidden');
+        }
+});
+
+module.exports = Menu;
+},{"./menu-item.js":37,"./priority-list.js":40}],39:[function(require,module,exports){
+/**
+ * wp.media.view.Modal
+ *
+ * A modal view, which the media modal uses as its default container.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager = require( './focus-manager.js' ),
+        $ = jQuery,
+        Modal;
+
+Modal = View.extend({
+        tagName:  'div',
+        template: wp.template('media-modal'),
+
+        attributes: {
+                tabindex: 0
+        },
+
+        events: {
+                'click .media-modal-backdrop, .media-modal-close': 'escapeHandler',
+                'keydown': 'keydown'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        container: document.body,
+                        title:     '',
+                        propagate: true,
+                        freeze:    true
+                });
+
+                this.focusManager = new FocusManager({
+                        el: this.el
+                });
+        },
+        /**
+         * @returns {Object}
+         */
+        prepare: function() {
+                return {
+                        title: this.options.title
+                };
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        attach: function() {
+                if ( this.views.attached ) {
+                        return this;
+                }
+
+                if ( ! this.views.rendered ) {
+                        this.render();
+                }
+
+                this.$el.appendTo( this.options.container );
+
+                // Manually mark the view as attached and trigger ready.
+                this.views.attached = true;
+                this.views.ready();
+
+                return this.propagate('attach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        detach: function() {
+                if ( this.$el.is(':visible') ) {
+                        this.close();
+                }
+
+                this.$el.detach();
+                this.views.attached = false;
+                return this.propagate('detach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        open: function() {
+                var $el = this.$el,
+                        options = this.options,
+                        mceEditor;
+
+                if ( $el.is(':visible') ) {
+                        return this;
+                }
+
+                if ( ! this.views.attached ) {
+                        this.attach();
+                }
+
+                // If the `freeze` option is set, record the window's scroll position.
+                if ( options.freeze ) {
+                        this._freeze = {
+                                scrollTop: $( window ).scrollTop()
+                        };
+                }
+
+                // Disable page scrolling.
+                $( 'body' ).addClass( 'modal-open' );
+
+                $el.show();
+
+                // Try to close the onscreen keyboard
+                if ( 'ontouchend' in document ) {
+                        if ( ( mceEditor = window.tinymce && window.tinymce.activeEditor )  && ! mceEditor.isHidden() && mceEditor.iframeElement ) {
+                                mceEditor.iframeElement.focus();
+                                mceEditor.iframeElement.blur();
+
+                                setTimeout( function() {
+                                        mceEditor.iframeElement.blur();
+                                }, 100 );
+                        }
+                }
+
+                this.$el.focus();
+
+                return this.propagate('open');
+        },
+
+        /**
+         * @param {Object} options
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        close: function( options ) {
+                var freeze = this._freeze;
+
+                if ( ! this.views.attached || ! this.$el.is(':visible') ) {
+                        return this;
+                }
+
+                // Enable page scrolling.
+                $( 'body' ).removeClass( 'modal-open' );
+
+                // Hide modal and remove restricted media modal tab focus once it's closed
+                this.$el.hide().undelegate( 'keydown' );
+
+                // Put focus back in useful location once modal is closed
+                $('#wpbody-content').focus();
+
+                this.propagate('close');
+
+                // If the `freeze` option is set, restore the container's scroll position.
+                if ( freeze ) {
+                        $( window ).scrollTop( freeze.scrollTop );
+                }
+
+                if ( options && options.escape ) {
+                        this.propagate('escape');
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        escape: function() {
+                return this.close({ escape: true });
+        },
+        /**
+         * @param {Object} event
+         */
+        escapeHandler: function( event ) {
+                event.preventDefault();
+                this.escape();
+        },
+
+        /**
+         * @param {Array|Object} content Views to register to '.media-modal-content'
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        content: function( content ) {
+                this.views.set( '.media-modal-content', content );
+                return this;
+        },
+
+        /**
+         * Triggers a modal event and if the `propagate` option is set,
+         * forwards events to the modal's controller.
+         *
+         * @param {string} id
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        propagate: function( id ) {
+                this.trigger( id );
+
+                if ( this.options.propagate ) {
+                        this.controller.trigger( id );
+                }
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        keydown: function( event ) {
+                // Close the modal when escape is pressed.
+                if ( 27 === event.which && this.$el.is(':visible') ) {
+                        this.escape();
+                        event.stopImmediatePropagation();
+                }
+        }
+});
+
+module.exports = Modal;
+},{"./focus-manager.js":27,"./view.js":55}],40:[function(require,module,exports){
+/**
+ * wp.media.view.PriorityList
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        PriorityList;
+
+PriorityList = View.extend({
+        tagName:   'div',
+
+        initialize: function() {
+                this._views = {};
+
+                this.set( _.extend( {}, this._views, this.options.views ), { silent: true });
+                delete this.options.views;
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+        },
+        /**
+         * @param {string} id
+         * @param {wp.media.View|Object} view
+         * @param {Object} options
+         * @returns {wp.media.view.PriorityList} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var priority, views, index;
+
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view );
+                        }, this );
+                        return this;
+                }
+
+                if ( ! (view instanceof Backbone.View) ) {
+                        view = this.toView( view, id, options );
+                }
+                view.controller = view.controller || this.controller;
+
+                this.unset( id );
+
+                priority = view.options.priority || 10;
+                views = this.views.get() || [];
+
+                _.find( views, function( existing, i ) {
+                        if ( existing.options.priority > priority ) {
+                                index = i;
+                                return true;
+                        }
+                });
+
+                this._views[ id ] = view;
+                this.views.add( view, {
+                        at: _.isNumber( index ) ? index : views.length || 0
+                });
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.PriorityList}
+         */
+        unset: function( id ) {
+                var view = this.get( id );
+
+                if ( view ) {
+                        view.remove();
+                }
+
+                delete this._views[ id ];
+                return this;
+        },
+        /**
+         * @param {Object} options
+         * @returns {wp.media.View}
+         */
+        toView: function( options ) {
+                return new View( options );
+        }
+});
+
+module.exports = PriorityList;
+},{"./view.js":55}],41:[function(require,module,exports){
+/**
+ * wp.media.view.RouterItem
+ *
+ * @class
+ * @augments wp.media.view.MenuItem
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        RouterItem;
+
+RouterItem = MenuItem.extend({
+        /**
+         * On click handler to activate the content region's corresponding mode.
+         */
+        click: function() {
+                var contentMode = this.options.contentMode;
+                if ( contentMode ) {
+                        this.controller.content.mode( contentMode );
+                }
+        }
+});
+
+module.exports = RouterItem;
+},{"./menu-item.js":37}],42:[function(require,module,exports){
+/**
+ * wp.media.view.Router
+ *
+ * @class
+ * @augments wp.media.view.Menu
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Menu = require( './menu.js' ),
+        RouterItem = require( './router-item.js' ),
+        Router;
+
+Router = Menu.extend({
+        tagName:   'div',
+        className: 'media-router',
+        property:  'contentMode',
+        ItemView:  RouterItem,
+        region:    'router',
+
+        initialize: function() {
+                this.controller.on( 'content:render', this.update, this );
+                // Call 'initialize' directly on the parent class.
+                Menu.prototype.initialize.apply( this, arguments );
+        },
+
+        update: function() {
+                var mode = this.controller.content.mode();
+                if ( mode ) {
+                        this.select( mode );
+                }
+        }
+});
+
+module.exports = Router;
+},{"./menu.js":38,"./router-item.js":41}],43:[function(require,module,exports){
+/**
+ * wp.media.view.Search
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        l10n = wp.media.view.l10n,
+        Search;
+
+Search = View.extend({
+        tagName:   'input',
+        className: 'search',
+        id:        'media-search-input',
+
+        attributes: {
+                type:        'search',
+                placeholder: l10n.search
+        },
+
+        events: {
+                'input':  'search',
+                'keyup':  'search',
+                'change': 'search',
+                'search': 'search'
+        },
+
+        /**
+         * @returns {wp.media.view.Search} Returns itself to allow chaining
+         */
+        render: function() {
+                this.el.value = this.model.escape('search');
+                return this;
+        },
+
+        search: function( event ) {
+                if ( event.target.value ) {
+                        this.model.set( 'search', event.target.value );
+                } else {
+                        this.model.unset('search');
+                }
+        }
+});
+
+module.exports = Search;
+},{"./view.js":55}],44:[function(require,module,exports){
+/**
+ * wp.media.view.Settings
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Settings;
+
+Settings = View.extend({
+        events: {
+                'click button':    'updateHandler',
+                'change input':    'updateHandler',
+                'change select':   'updateHandler',
+                'change textarea': 'updateHandler'
+        },
+
+        initialize: function() {
+                this.model = this.model || new Backbone.Model();
+                this.model.on( 'change', this.updateChanges, this );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+        /**
+         * @returns {wp.media.view.Settings} Returns itself to allow chaining
+         */
+        render: function() {
+                View.prototype.render.apply( this, arguments );
+                // Select the correct values.
+                _( this.model.attributes ).chain().keys().each( this.update, this );
+                return this;
+        },
+        /**
+         * @param {string} key
+         */
+        update: function( key ) {
+                var value = this.model.get( key ),
+                        $setting = this.$('[data-setting="' + key + '"]'),
+                        $buttons, $value;
+
+                // Bail if we didn't find a matching setting.
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Attempt to determine how the setting is rendered and update
+                // the selected value.
+
+                // Handle dropdowns.
+                if ( $setting.is('select') ) {
+                        $value = $setting.find('[value="' + value + '"]');
+
+                        if ( $value.length ) {
+                                $setting.find('option').prop( 'selected', false );
+                                $value.prop( 'selected', true );
+                        } else {
+                                // If we can't find the desired value, record what *is* selected.
+                                this.model.set( key, $setting.find(':selected').val() );
+                        }
+
+                // Handle button groups.
+                } else if ( $setting.hasClass('button-group') ) {
+                        $buttons = $setting.find('button').removeClass('active');
+                        $buttons.filter( '[value="' + value + '"]' ).addClass('active');
+
+                // Handle text inputs and textareas.
+                } else if ( $setting.is('input[type="text"], textarea') ) {
+                        if ( ! $setting.is(':focus') ) {
+                                $setting.val( value );
+                        }
+                // Handle checkboxes.
+                } else if ( $setting.is('input[type="checkbox"]') ) {
+                        $setting.prop( 'checked', !! value && 'false' !== value );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateHandler: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        value = event.target.value,
+                        userSetting;
+
+                event.preventDefault();
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Use the correct value for checkboxes.
+                if ( $setting.is('input[type="checkbox"]') ) {
+                        value = $setting[0].checked;
+                }
+
+                // Update the corresponding setting.
+                this.model.set( $setting.data('setting'), value );
+
+                // If the setting has a corresponding user setting,
+                // update that as well.
+                if ( userSetting = $setting.data('userSetting') ) {
+                        setUserSetting( userSetting, value );
+                }
+        },
+
+        updateChanges: function( model ) {
+                if ( model.hasChanged() ) {
+                        _( model.changed ).chain().keys().each( this.update, this );
+                }
+        }
+});
+
+module.exports = Settings;
+},{"./view.js":55}],45:[function(require,module,exports){
+/**
+ * wp.media.view.Settings.AttachmentDisplay
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        AttachmentDisplay;
+
+AttachmentDisplay = Settings.extend({
+        className: 'attachment-display-settings',
+        template:  wp.template('attachment-display-settings'),
+
+        initialize: function() {
+                var attachment = this.options.attachment;
+
+                _.defaults( this.options, {
+                        userSettings: false
+                });
+                // Call 'initialize' directly on the parent class.
+                Settings.prototype.initialize.apply( this, arguments );
+                this.model.on( 'change:link', this.updateLinkTo, this );
+
+                if ( attachment ) {
+                        attachment.on( 'change:uploading', this.render, this );
+                }
+        },
+
+        dispose: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        attachment.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                Settings.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentDisplay} Returns itself to allow chaining
+         */
+        render: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        _.extend( this.options, {
+                                sizes: attachment.get('sizes'),
+                                type:  attachment.get('type')
+                        });
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                Settings.prototype.render.call( this );
+                this.updateLinkTo();
+                return this;
+        },
+
+        updateLinkTo: function() {
+                var linkTo = this.model.get('link'),
+                        $input = this.$('.link-to-custom'),
+                        attachment = this.options.attachment;
+
+                if ( 'none' === linkTo || 'embed' === linkTo || ( ! attachment && 'custom' !== linkTo ) ) {
+                        $input.addClass( 'hidden' );
+                        return;
+                }
+
+                if ( attachment ) {
+                        if ( 'post' === linkTo ) {
+                                $input.val( attachment.get('link') );
+                        } else if ( 'file' === linkTo ) {
+                                $input.val( attachment.get('url') );
+                        } else if ( ! this.model.get('linkUrl') ) {
+                                $input.val('http://');
+                        }
+
+                        $input.prop( 'readonly', 'custom' !== linkTo );
+                }
+
+                $input.removeClass( 'hidden' );
+
+                // If the input is visible, focus and select its contents.
+                if ( ! wp.media.isTouchDevice && $input.is(':visible') ) {
+                        $input.focus()[0].select();
+                }
+        }
+});
+
+module.exports = AttachmentDisplay;
+},{"../settings.js":44}],46:[function(require,module,exports){
+/**
+ * wp.media.view.Sidebar
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var PriorityList = require( './priority-list.js' ),
+        Sidebar;
+
+Sidebar = PriorityList.extend({
+        className: 'media-sidebar'
+});
+
+module.exports = Sidebar;
+},{"./priority-list.js":40}],47:[function(require,module,exports){
+/**
+ * wp.media.view.Spinner
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Spinner;
+
+Spinner = View.extend({
+        tagName:   'span',
+        className: 'spinner',
+        spinnerTimeout: false,
+        delay: 400,
+
+        show: function() {
+                if ( ! this.spinnerTimeout ) {
+                        this.spinnerTimeout = _.delay(function( $el ) {
+                                $el.show();
+                        }, this.delay, this.$el );
+                }
+
+                return this;
+        },
+
+        hide: function() {
+                this.$el.hide();
+                this.spinnerTimeout = clearTimeout( this.spinnerTimeout );
+
+                return this;
+        }
+});
+
+module.exports = Spinner;
+},{"./view.js":55}],48:[function(require,module,exports){
+/**
+ * wp.media.view.Toolbar
+ *
+ * A toolbar which consists of a primary and a secondary section. Each sections
+ * can be filled with views.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button = require( './button.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Toolbar;
+
+Toolbar = View.extend({
+        tagName:   'div',
+        className: 'media-toolbar',
+
+        initialize: function() {
+                var state = this.controller.state(),
+                        selection = this.selection = state.get('selection'),
+                        library = this.library = state.get('library');
+
+                this._views = {};
+
+                // The toolbar is composed of two `PriorityList` views.
+                this.primary   = new PriorityList();
+                this.secondary = new PriorityList();
+                this.primary.$el.addClass('media-toolbar-primary search-form');
+                this.secondary.$el.addClass('media-toolbar-secondary');
+
+                this.views.set([ this.secondary, this.primary ]);
+
+                if ( this.options.items ) {
+                        this.set( this.options.items, { silent: true });
+                }
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+
+                if ( selection ) {
+                        selection.on( 'add remove reset', this.refresh, this );
+                }
+
+                if ( library ) {
+                        library.on( 'add remove reset', this.refresh, this );
+                }
+        },
+        /**
+         * @returns {wp.media.view.Toolbar} Returns itsef to allow chaining
+         */
+        dispose: function() {
+                if ( this.selection ) {
+                        this.selection.off( null, null, this );
+                }
+
+                if ( this.library ) {
+                        this.library.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+
+        ready: function() {
+                this.refresh();
+        },
+
+        /**
+         * @param {string} id
+         * @param {Backbone.View|Object} view
+         * @param {Object} [options={}]
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var list;
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view, { silent: true });
+                        }, this );
+
+                } else {
+                        if ( ! ( view instanceof Backbone.View ) ) {
+                                view.classes = [ 'media-button-' + id ].concat( view.classes || [] );
+                                view = new Button( view ).render();
+                        }
+
+                        view.controller = view.controller || this.controller;
+
+                        this._views[ id ] = view;
+
+                        list = view.options.priority < 0 ? 'secondary' : 'primary';
+                        this[ list ].set( id, view, options );
+                }
+
+                if ( ! options.silent ) {
+                        this.refresh();
+                }
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.Button}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @param {Object} options
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        unset: function( id, options ) {
+                delete this._views[ id ];
+                this.primary.unset( id, options );
+                this.secondary.unset( id, options );
+
+                if ( ! options || ! options.silent ) {
+                        this.refresh();
+                }
+                return this;
+        },
+
+        refresh: function() {
+                var state = this.controller.state(),
+                        library = state.get('library'),
+                        selection = state.get('selection');
+
+                _.each( this._views, function( button ) {
+                        if ( ! button.model || ! button.options || ! button.options.requires ) {
+                                return;
+                        }
+
+                        var requires = button.options.requires,
+                                disabled = false;
+
+                        // Prevent insertion of attachments if any of them are still uploading
+                        disabled = _.some( selection.models, function( attachment ) {
+                                return attachment.get('uploading') === true;
+                        });
+
+                        if ( requires.selection && selection && ! selection.length ) {
+                                disabled = true;
+                        } else if ( requires.library && library && ! library.length ) {
+                                disabled = true;
+                        }
+                        button.model.set( 'disabled', disabled );
+                });
+        }
+});
+
+module.exports = Toolbar;
+},{"./button.js":26,"./priority-list.js":40,"./view.js":55}],49:[function(require,module,exports){
+/**
+ * wp.media.view.Toolbar.Select
+ *
+ * @class
+ * @augments wp.media.view.Toolbar
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Toolbar = require( '../toolbar.js' ),
+        l10n = wp.media.view.l10n,
+        Select;
+
+Select = Toolbar.extend({
+        initialize: function() {
+                var options = this.options;
+
+                _.bindAll( this, 'clickSelect' );
+
+                _.defaults( options, {
+                        event: 'select',
+                        state: false,
+                        reset: true,
+                        close: true,
+                        text:  l10n.select,
+
+                        // Does the button rely on the selection?
+                        requires: {
+                                selection: true
+                        }
+                });
+
+                options.items = _.defaults( options.items || {}, {
+                        select: {
+                                style:    'primary',
+                                text:     options.text,
+                                priority: 80,
+                                click:    this.clickSelect,
+                                requires: options.requires
+                        }
+                });
+                // Call 'initialize' directly on the parent class.
+                Toolbar.prototype.initialize.apply( this, arguments );
+        },
+
+        clickSelect: function() {
+                var options = this.options,
+                        controller = this.controller;
+
+                if ( options.close ) {
+                        controller.close();
+                }
+
+                if ( options.event ) {
+                        controller.state().trigger( options.event );
+                }
+
+                if ( options.state ) {
+                        controller.setState( options.state );
+                }
+
+                if ( options.reset ) {
+                        controller.reset();
+                }
+        }
+});
+
+module.exports = Select;
+},{"../toolbar.js":48}],50:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderInline
+ *
+ * The inline uploader that shows up in the 'Upload Files' tab.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatus = require( './status.js' ),
+        UploaderInline;
+
+UploaderInline = View.extend({
+        tagName:   'div',
+        className: 'uploader-inline',
+        template:  wp.template('uploader-inline'),
+
+        events: {
+                'click .close': 'hide'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        message: '',
+                        status:  true,
+                        canClose: false
+                });
+
+                if ( ! this.options.$browser && this.controller.uploader ) {
+                        this.options.$browser = this.controller.uploader.$browser;
+                }
+
+                if ( _.isUndefined( this.options.postId ) ) {
+                        this.options.postId = wp.media.view.settings.post.id;
+                }
+
+                if ( this.options.status ) {
+                        this.views.set( '.upload-inline-status', new UploaderStatus({
+                                controller: this.controller
+                        }) );
+                }
+        },
+
+        prepare: function() {
+                var suggestedWidth = this.controller.state().get('suggestedWidth'),
+                        suggestedHeight = this.controller.state().get('suggestedHeight'),
+                        data = {};
+
+                data.message = this.options.message;
+                data.canClose = this.options.canClose;
+
+                if ( suggestedWidth && suggestedHeight ) {
+                        data.suggestedWidth = suggestedWidth;
+                        data.suggestedHeight = suggestedHeight;
+                }
+
+                return data;
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.disposing ) {
+                        /**
+                         * call 'dispose' directly on the parent class
+                         */
+                        return View.prototype.dispose.apply( this, arguments );
+                }
+
+                // Run remove on `dispose`, so we can be sure to refresh the
+                // uploader with a view-less DOM. Track whether we're disposing
+                // so we don't trigger an infinite loop.
+                this.disposing = true;
+                return this.remove();
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        remove: function() {
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                var result = View.prototype.remove.apply( this, arguments );
+
+                _.defer( _.bind( this.refresh, this ) );
+                return result;
+        },
+
+        refresh: function() {
+                var uploader = this.controller.uploader;
+
+                if ( uploader ) {
+                        uploader.refresh();
+                }
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline}
+         */
+        ready: function() {
+                var $browser = this.options.$browser,
+                        $placeholder;
+
+                if ( this.controller.uploader ) {
+                        $placeholder = this.$('.browser');
+
+                        // Check if we've already replaced the placeholder.
+                        if ( $placeholder[0] === $browser[0] ) {
+                                return;
+                        }
+
+                        $browser.detach().text( $placeholder.text() );
+                        $browser[0].className = $placeholder[0].className;
+                        $placeholder.replaceWith( $browser.show() );
+                }
+
+                this.refresh();
+                return this;
+        },
+        show: function() {
+                this.$el.removeClass( 'hidden' );
+        },
+        hide: function() {
+                this.$el.addClass( 'hidden' );
+        }
+
+});
+
+module.exports = UploaderInline;
+},{"../view.js":55,"./status.js":52}],51:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderStatusError
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError;
+
+UploaderStatusError = View.extend({
+        className: 'upload-error',
+        template:  wp.template('uploader-status-error')
+});
+
+module.exports = UploaderStatusError;
+},{"../view.js":55}],52:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderStatus
+ *
+ * An uploader status for on-going uploads.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError = require( './status-error.js' ),
+        UploaderStatus;
+
+UploaderStatus = View.extend({
+        className: 'media-uploader-status',
+        template:  wp.template('uploader-status'),
+
+        events: {
+                'click .upload-dismiss-errors': 'dismiss'
+        },
+
+        initialize: function() {
+                this.queue = wp.Uploader.queue;
+                this.queue.on( 'add remove reset', this.visibility, this );
+                this.queue.on( 'add remove reset change:percent', this.progress, this );
+                this.queue.on( 'add remove reset change:uploading', this.info, this );
+
+                this.errors = wp.Uploader.errors;
+                this.errors.reset();
+                this.errors.on( 'add remove reset', this.visibility, this );
+                this.errors.on( 'add', this.error, this );
+        },
+        /**
+         * @global wp.Uploader
+         * @returns {wp.media.view.UploaderStatus}
+         */
+        dispose: function() {
+                wp.Uploader.queue.off( null, null, this );
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        visibility: function() {
+                this.$el.toggleClass( 'uploading', !! this.queue.length );
+                this.$el.toggleClass( 'errors', !! this.errors.length );
+                this.$el.toggle( !! this.queue.length || !! this.errors.length );
+        },
+
+        ready: function() {
+                _.each({
+                        '$bar':      '.media-progress-bar div',
+                        '$index':    '.upload-index',
+                        '$total':    '.upload-total',
+                        '$filename': '.upload-filename'
+                }, function( selector, key ) {
+                        this[ key ] = this.$( selector );
+                }, this );
+
+                this.visibility();
+                this.progress();
+                this.info();
+        },
+
+        progress: function() {
+                var queue = this.queue,
+                        $bar = this.$bar;
+
+                if ( ! $bar || ! queue.length ) {
+                        return;
+                }
+
+                $bar.width( ( queue.reduce( function( memo, attachment ) {
+                        if ( ! attachment.get('uploading') ) {
+                                return memo + 100;
+                        }
+
+                        var percent = attachment.get('percent');
+                        return memo + ( _.isNumber( percent ) ? percent : 100 );
+                }, 0 ) / queue.length ) + '%' );
+        },
+
+        info: function() {
+                var queue = this.queue,
+                        index = 0, active;
+
+                if ( ! queue.length ) {
+                        return;
+                }
+
+                active = this.queue.find( function( attachment, i ) {
+                        index = i;
+                        return attachment.get('uploading');
+                });
+
+                this.$index.text( index + 1 );
+                this.$total.text( queue.length );
+                this.$filename.html( active ? this.filename( active.get('filename') ) : '' );
+        },
+        /**
+         * @param {string} filename
+         * @returns {string}
+         */
+        filename: function( filename ) {
+                return wp.media.truncate( _.escape( filename ), 24 );
+        },
+        /**
+         * @param {Backbone.Model} error
+         */
+        error: function( error ) {
+                this.views.add( '.upload-errors', new UploaderStatusError({
+                        filename: this.filename( error.get('file').name ),
+                        message:  error.get('message')
+                }), { at: 0 });
+        },
+
+        /**
+         * @global wp.Uploader
+         *
+         * @param {Object} event
+         */
+        dismiss: function( event ) {
+                var errors = this.views.get('.upload-errors');
+
+                event.preventDefault();
+
+                if ( errors ) {
+                        _.invoke( errors, 'remove' );
+                }
+                wp.Uploader.errors.reset();
+        }
+});
+
+module.exports = UploaderStatus;
+},{"../view.js":55,"./status-error.js":51}],53:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderWindow
+ *
+ * An uploader window that allows for dragging and dropping media.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object} [options]                   Options hash passed to the view.
+ * @param {object} [options.uploader]          Uploader properties.
+ * @param {jQuery} [options.uploader.browser]
+ * @param {jQuery} [options.uploader.dropzone] jQuery collection of the dropzone.
+ * @param {object} [options.uploader.params]
+ */
+var View = require( '../view.js' ),
+        $ = jQuery,
+        UploaderWindow;
+
+UploaderWindow = View.extend({
+        tagName:   'div',
+        className: 'uploader-window',
+        template:  wp.template('uploader-window'),
+
+        initialize: function() {
+                var uploader;
+
+                this.$browser = $('<a href="#" class="browser" />').hide().appendTo('body');
+
+                uploader = this.options.uploader = _.defaults( this.options.uploader || {}, {
+                        dropzone:  this.$el,
+                        browser:   this.$browser,
+                        params:    {}
+                });
+
+                // Ensure the dropzone is a jQuery collection.
+                if ( uploader.dropzone && ! (uploader.dropzone instanceof $) ) {
+                        uploader.dropzone = $( uploader.dropzone );
+                }
+
+                this.controller.on( 'activate', this.refresh, this );
+
+                this.controller.on( 'detach', function() {
+                        this.$browser.remove();
+                }, this );
+        },
+
+        refresh: function() {
+                if ( this.uploader ) {
+                        this.uploader.refresh();
+                }
+        },
+
+        ready: function() {
+                var postId = wp.media.view.settings.post.id,
+                        dropzone;
+
+                // If the uploader already exists, bail.
+                if ( this.uploader ) {
+                        return;
+                }
+
+                if ( postId ) {
+                        this.options.uploader.params.post_id = postId;
+                }
+                this.uploader = new wp.Uploader( this.options.uploader );
+
+                dropzone = this.uploader.dropzone;
+                dropzone.on( 'dropzone:enter', _.bind( this.show, this ) );
+                dropzone.on( 'dropzone:leave', _.bind( this.hide, this ) );
+
+                $( this.uploader ).on( 'uploader:ready', _.bind( this._ready, this ) );
+        },
+
+        _ready: function() {
+                this.controller.trigger( 'uploader:ready' );
+        },
+
+        show: function() {
+                var $el = this.$el.show();
+
+                // Ensure that the animation is triggered by waiting until
+                // the transparent element is painted into the DOM.
+                _.defer( function() {
+                        $el.css({ opacity: 1 });
+                });
+        },
+
+        hide: function() {
+                var $el = this.$el.css({ opacity: 0 });
+
+                wp.media.transition( $el ).done( function() {
+                        // Transition end events are subject to race conditions.
+                        // Make sure that the value is set as intended.
+                        if ( '0' === $el.css('opacity') ) {
+                                $el.hide();
+                        }
+                });
+
+                // https://core.trac.wordpress.org/ticket/27341
+                _.delay( function() {
+                        if ( '0' === $el.css('opacity') && $el.is(':visible') ) {
+                                $el.hide();
+                        }
+                }, 500 );
+        }
+});
+
+module.exports = UploaderWindow;
+},{"../view.js":55}],54:[function(require,module,exports){
+/**
+ * wp.media.view.VideoDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaDetails
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MediaDetails = require( './media-details' ),
+        VideoDetails;
+
+VideoDetails = MediaDetails.extend({
+        className: 'video-details',
+        template:  wp.template('video-details'),
+
+        setMedia: function() {
+                var video = this.$('.wp-video-shortcode');
+
+                if ( video.find( 'source' ).length ) {
+                        if ( video.is(':hidden') ) {
+                                video.show();
+                        }
+
+                        if ( ! video.hasClass('youtube-video') ) {
+                                this.media = MediaDetails.prepareSrc( video.get(0) );
+                        } else {
+                                this.media = video.get(0);
+                        }
+                } else {
+                        video.hide();
+                        this.media = false;
+                }
+
+                return this;
+        }
+});
+
+module.exports = VideoDetails;
+},{"./media-details":35}],55:[function(require,module,exports){
+/**
+ * wp.media.View
+ *
+ * The base view class for media.
+ *
+ * Undelegating events, removing events from the model, and
+ * removing events from the controller mirror the code for
+ * `Backbone.View.dispose` in Backbone 0.9.8 development.
+ *
+ * This behavior has since been removed, and should not be used
+ * outside of the media manager.
+ *
+ * @class
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = wp.Backbone.View.extend({
+        constructor: function( options ) {
+                if ( options && options.controller ) {
+                        this.controller = options.controller;
+                }
+                wp.Backbone.View.apply( this, arguments );
+        },
+        /**
+         * @todo The internal comment mentions this might have been a stop-gap
+         *       before Backbone 0.9.8 came out. Figure out if Backbone core takes
+         *       care of this in Backbone.View now.
+         *
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        dispose: function() {
+                // Undelegating events, removing events from the model, and
+                // removing events from the controller mirror the code for
+                // `Backbone.View.dispose` in Backbone 0.9.8 development.
+                this.undelegateEvents();
+
+                if ( this.model && this.model.off ) {
+                        this.model.off( null, null, this );
+                }
+
+                if ( this.collection && this.collection.off ) {
+                        this.collection.off( null, null, this );
+                }
+
+                // Unbind controller events.
+                if ( this.controller && this.controller.off ) {
+                        this.controller.off( null, null, this );
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        remove: function() {
+                this.dispose();
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                return wp.Backbone.View.prototype.remove.apply( this, arguments );
+        }
+});
+
+module.exports = View;
+},{}]},{},[1]);

src/wp-includes/js/media/audio-video.manifest.js

@@ +1 @@
+/* global _wpMediaViewsL10n, _wpmejsSettings, MediaElementPlayer */
+
+(function($, _, Backbone) {
+        var media = wp.media,
+                baseSettings = {},
+                l10n = typeof _wpMediaViewsL10n === 'undefined' ? {} : _wpMediaViewsL10n;
+
+        if ( ! _.isUndefined( window._wpmejsSettings ) ) {
+                baseSettings = _wpmejsSettings;
+        }
+
+        /**
+         * @mixin
+         */
+        wp.media.mixin = {
+                mejsSettings: baseSettings,
+
+                removeAllPlayers: function() {
+                        var p;
+
+                        if ( window.mejs && window.mejs.players ) {
+                                for ( p in window.mejs.players ) {
+                                        window.mejs.players[p].pause();
+                                        this.removePlayer( window.mejs.players[p] );
+                                }
+                        }
+                },
+
+                /**
+                 * Override the MediaElement method for removing a player.
+                 *      MediaElement tries to pull the audio/video tag out of
+                 *      its container and re-add it to the DOM.
+                 */
+                removePlayer: function(t) {
+                        var featureIndex, feature;
+
+                        if ( ! t.options ) {
+                                return;
+                        }
+
+                        // invoke features cleanup
+                        for ( featureIndex in t.options.features ) {
+                                feature = t.options.features[featureIndex];
+                                if ( t['clean' + feature] ) {
+                                        try {
+                                                t['clean' + feature](t);
+                                        } catch (e) {}
+                                }
+                        }
+
+                        if ( ! t.isDynamic ) {
+                                t.$node.remove();
+                        }
+
+                        if ( 'native' !== t.media.pluginType ) {
+                                t.media.remove();
+                        }
+
+                        delete window.mejs.players[t.id];
+
+                        t.container.remove();
+                        t.globalUnbind();
+                        delete t.node.player;
+                },
+
+                /**
+                 * Allows any class that has set 'player' to a MediaElementPlayer
+                 *  instance to remove the player when listening to events.
+                 *
+                 *  Examples: modal closes, shortcode properties are removed, etc.
+                 */
+                unsetPlayers : function() {
+                        if ( this.players && this.players.length ) {
+                                _.each( this.players, function (player) {
+                                        player.pause();
+                                        wp.media.mixin.removePlayer( player );
+                                } );
+                                this.players = [];
+                        }
+                }
+        };
+
+        /**
+         * Autowire "collection"-type shortcodes
+         */
+        wp.media.playlist = new wp.media.collection({
+                tag: 'playlist',
+                editTitle : l10n.editPlaylistTitle,
+                defaults : {
+                        id: wp.media.view.settings.post.id,
+                        style: 'light',
+                        tracklist: true,
+                        tracknumbers: true,
+                        images: true,
+                        artists: true,
+                        type: 'audio'
+                }
+        });
+
+        /**
+         * Shortcode modeling for audio
+         *  `edit()` prepares the shortcode for the media modal
+         *  `shortcode()` builds the new shortcode after update
+         *
+         * @namespace
+         */
+        wp.media.audio = {
+                coerce : wp.media.coerce,
+
+                defaults : {
+                        id : wp.media.view.settings.post.id,
+                        src : '',
+                        loop : false,
+                        autoplay : false,
+                        preload : 'none',
+                        width : 400
+                },
+
+                edit : function( data ) {
+                        var frame, shortcode = wp.shortcode.next( 'audio', data ).shortcode;
+                        console.log( 'woo' );
+
+                        frame = wp.media({
+                                frame: 'audio',
+                                state: 'audio-details',
+                                metadata: _.defaults( shortcode.attrs.named, this.defaults )
+                        });
+
+                        console.log( frame );
+
+                        return frame;
+                },
+
+                shortcode : function( model ) {
+                        var self = this, content;
+
+                        _.each( this.defaults, function( value, key ) {
+                                model[ key ] = self.coerce( model, key );
+
+                                if ( value === model[ key ] ) {
+                                        delete model[ key ];
+                                }
+                        });
+
+                        content = model.content;
+                        delete model.content;
+
+                        return new wp.shortcode({
+                                tag: 'audio',
+                                attrs: model,
+                                content: content
+                        });
+                }
+        };
+
+        /**
+         * Shortcode modeling for video
+         *  `edit()` prepares the shortcode for the media modal
+         *  `shortcode()` builds the new shortcode after update
+         *
+         * @namespace
+         */
+        wp.media.video = {
+                coerce : wp.media.coerce,
+
+                defaults : {
+                        id : wp.media.view.settings.post.id,
+                        src : '',
+                        poster : '',
+                        loop : false,
+                        autoplay : false,
+                        preload : 'metadata',
+                        content : '',
+                        width : 640,
+                        height : 360
+                },
+
+                edit : function( data ) {
+                        var frame,
+                                shortcode = wp.shortcode.next( 'video', data ).shortcode,
+                                attrs;
+
+                        attrs = shortcode.attrs.named;
+                        attrs.content = shortcode.content;
+
+                        frame = wp.media({
+                                frame: 'video',
+                                state: 'video-details',
+                                metadata: _.defaults( attrs, this.defaults )
+                        });
+
+                        return frame;
+                },
+
+                shortcode : function( model ) {
+                        var self = this, content;
+
+                        _.each( this.defaults, function( value, key ) {
+                                model[ key ] = self.coerce( model, key );
+
+                                if ( value === model[ key ] ) {
+                                        delete model[ key ];
+                                }
+                        });
+
+                        content = model.content;
+                        delete model.content;
+
+                        return new wp.shortcode({
+                                tag: 'video',
+                                attrs: model,
+                                content: content
+                        });
+                }
+        };
+
+        media.model.PostMedia = require( './models/post-media.js' );
+        media.controller.AudioDetails = require( './controllers/audio-details.js' );
+        media.controller.VideoDetails = require( './controllers/video-details.js' );
+        media.view.MediaFrame.MediaDetails = require( './views/frame/media-details.js' );
+        media.view.MediaFrame.AudioDetails = require( './views/frame/audio-details.js' );
+        media.view.MediaFrame.VideoDetails = require( './views/frame/video-details.js' );
+        media.view.MediaDetails = require( './views/media-details.js' );
+        media.view.AudioDetails = require( './views/audio-details.js' );
+        media.view.VideoDetails = require( './views/video-details.js' );
+
+}(jQuery, _, Backbone));

src/wp-includes/js/media/controllers/audio-details.js

@@ +1 @@
+/**
+ * The controller for the Audio Details state
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        AudioDetails;
+
+AudioDetails = State.extend({
+        defaults: {
+                id: 'audio-details',
+                toolbar: 'audio-details',
+                title: l10n.audioDetailsTitle,
+                content: 'audio-details',
+                menu: 'audio-details',
+                router: false,
+                priority: 60
+        },
+
+        initialize: function( options ) {
+                this.media = options.media;
+                State.prototype.initialize.apply( this, arguments );
+        }
+});
+
+module.exports = AudioDetails;

src/wp-includes/js/media/controllers/collection-add.js

@@ +1 @@
+/**
+ * wp.media.controller.CollectionAdd
+ *
+ * A state for adding attachments to a collection (e.g. video playlist).
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                         The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=library]      Unique identifier.
+ * @param {string}                     attributes.title                    Title for the state. Displays in the frame's title region.
+ * @param {boolean}                    [attributes.multiple=add]            Whether multi-select is enabled. @todo 'add' doesn't seem do anything special, and gets used as a boolean.
+ * @param {wp.media.model.Attachments} [attributes.library]                 The attachments collection to browse.
+ *                                                                          If one is not supplied, a collection of attachments of the specified type will be created.
+ * @param {boolean|string}             [attributes.filterable=uploaded]     Whether the library is filterable, and if so what filters should be shown.
+ *                                                                          Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {string}                     [attributes.menu=gallery]            Initial mode for the menu region.
+ * @param {string}                     [attributes.content=upload]          Initial mode for the content region.
+ *                                                                          Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=gallery-add]     Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {int}                        [attributes.priority=100]            The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]     Whether the Attachments selection should be persisted from the last state.
+ *                                                                          Defaults to false because for this state, because the library of the Edit Gallery state is the selection.
+ * @param {string}                     attributes.type                   The collection's media type. (e.g. 'video').
+ * @param {string}                     attributes.collectionType         The collection type. (e.g. 'playlist').
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        CollectionAdd;
+
+CollectionAdd = Library.extend({
+        defaults: _.defaults( {
+                // Selection defaults. @see media.model.Selection
+                multiple:      'add',
+                // Attachments browser defaults. @see media.view.AttachmentsBrowser
+                filterable:    'uploaded',
+
+                priority:      100,
+                syncSelection: false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         */
+        initialize: function() {
+                var collectionType = this.get('collectionType');
+
+                if ( 'video' === this.get( 'type' ) ) {
+                        collectionType = 'video-' + collectionType;
+                }
+
+                this.set( 'id', collectionType + '-library' );
+                this.set( 'toolbar', collectionType + '-add' );
+                this.set( 'menu', collectionType );
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query({ type: this.get('type') }) );
+                }
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                var library = this.get('library'),
+                        editLibrary = this.get('editLibrary'),
+                        edit = this.frame.state( this.get('collectionType') + '-edit' ).get('library');
+
+                if ( editLibrary && editLibrary !== edit ) {
+                        library.unobserve( editLibrary );
+                }
+
+                // Accepts attachments that exist in the original library and
+                // that do not exist in gallery's library.
+                library.validator = function( attachment ) {
+                        return !! this.mirroring.get( attachment.cid ) && ! edit.get( attachment.cid ) && Selection.prototype.validator.apply( this, arguments );
+                };
+
+                // Reset the library to ensure that all attachments are re-added
+                // to the collection. Do so silently, as calling `observe` will
+                // trigger the `reset` event.
+                library.reset( library.mirroring.models, { silent: true });
+                library.observe( edit );
+                this.set('editLibrary', edit);
+
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = CollectionAdd;
+ No newline at end of file

src/wp-includes/js/media/controllers/collection-edit.js

@@ +1 @@
+/**
+ * wp.media.controller.CollectionEdit
+ *
+ * A state for editing a collection, which is used by audio and video playlists,
+ * and can be used for other collections.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                      The attributes hash passed to the state.
+ * @param {string}                     attributes.title                  Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]              The attachments collection to edit.
+ *                                                                       If one is not supplied, an empty media.model.Selection collection is created.
+ * @param {boolean}                    [attributes.multiple=false]       Whether multi-select is enabled.
+ * @param {string}                     [attributes.content=browse]       Initial mode for the content region.
+ * @param {string}                     attributes.menu                   Initial mode for the menu region. @todo this needs a better explanation.
+ * @param {boolean}                    [attributes.searchable=false]     Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]        Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.describe=true]        Whether to offer UI to describe the attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.dragInfo=true]        Whether to show instructional text about the attachments being sortable.
+ * @param {boolean}                    [attributes.dragInfoText]         Instructional text about the attachments being sortable.
+ * @param {int}                        [attributes.idealColumnWidth=170] The ideal column width in pixels for attachments.
+ * @param {boolean}                    [attributes.editing=false]        Whether the gallery is being created, or editing an existing instance.
+ * @param {int}                        [attributes.priority=60]          The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]  Whether the Attachments selection should be persisted from the last state.
+ *                                                                       Defaults to false for this state, because the library passed in  *is* the selection.
+ * @param {view}                       [attributes.SettingsView]         The view to edit the collection instance settings (e.g. Playlist settings with "Show tracklist" checkbox).
+ * @param {view}                       [attributes.AttachmentView]       The single `Attachment` view to be used in the `Attachments`.
+ *                                                                       If none supplied, defaults to wp.media.view.Attachment.EditLibrary.
+ * @param {string}                     attributes.type                   The collection's media type. (e.g. 'video').
+ * @param {string}                     attributes.collectionType         The collection type. (e.g. 'playlist').
+ */
+var SelectionModel = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        View = require( '../views/view.js' ),
+        EditLibraryView = require( '../views/attachment/edit-library.js' ),
+        l10n = wp.media.view.l10n,
+        CollectionEdit;
+
+CollectionEdit = Library.extend({
+        defaults: {
+                multiple:         false,
+                sortable:         true,
+                searchable:       false,
+                content:          'browse',
+                describe:         true,
+                dragInfo:         true,
+                idealColumnWidth: 170,
+                editing:          false,
+                priority:         60,
+                SettingsView:     false,
+                syncSelection:    false
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        initialize: function() {
+                var collectionType = this.get('collectionType');
+
+                if ( 'video' === this.get( 'type' ) ) {
+                        collectionType = 'video-' + collectionType;
+                }
+
+                this.set( 'id', collectionType + '-edit' );
+                this.set( 'toolbar', collectionType + '-edit' );
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', new SelectionModel() );
+                }
+                // The single `Attachment` view to be used in the `Attachments` view.
+                if ( ! this.get('AttachmentView') ) {
+                        this.set( 'AttachmentView', EditLibraryView );
+                }
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                var library = this.get('library');
+
+                // Limit the library to images only.
+                library.props.set( 'type', this.get( 'type' ) );
+
+                // Watch for uploaded attachments.
+                this.get('library').observe( wp.Uploader.queue );
+
+                this.frame.on( 'content:render:browse', this.renderSettings, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        deactivate: function() {
+                // Stop watching for uploaded attachments.
+                this.get('library').unobserve( wp.Uploader.queue );
+
+                this.frame.off( 'content:render:browse', this.renderSettings, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * Render the collection embed settings view in the browser sidebar.
+         *
+         * @todo This is against the pattern elsewhere in media. Typically the frame
+         *       is responsible for adding region mode callbacks. Explain.
+         *
+         * @since 3.9.0
+         *
+         * @param {wp.media.view.attachmentsBrowser} The attachments browser view.
+         */
+        renderSettings: function( attachmentsBrowserView ) {
+                var library = this.get('library'),
+                        collectionType = this.get('collectionType'),
+                        dragInfoText = this.get('dragInfoText'),
+                        SettingsView = this.get('SettingsView'),
+                        obj = {};
+
+                if ( ! library || ! attachmentsBrowserView ) {
+                        return;
+                }
+
+                library[ collectionType ] = library[ collectionType ] || new Backbone.Model();
+
+                obj[ collectionType ] = new SettingsView({
+                        controller: this,
+                        model:      library[ collectionType ],
+                        priority:   40
+                });
+
+                attachmentsBrowserView.sidebar.set( obj );
+
+                if ( dragInfoText ) {
+                        attachmentsBrowserView.toolbar.set( 'dragInfo', new View({
+                                el: $( '<div class="instructions">' + dragInfoText + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+
+                // Add the 'Reverse order' button to the toolbar.
+                attachmentsBrowserView.toolbar.set( 'reverse', {
+                        text:     l10n.reverseOrder,
+                        priority: 80,
+
+                        click: function() {
+                                library.reset( library.toArray().reverse() );
+                        }
+                });
+        }
+});
+
+module.exports = CollectionEdit;
+ No newline at end of file

src/wp-includes/js/media/controllers/cropper.js

@@ +1 @@
+/**
+ * wp.media.controller.Cropper
+ *
+ * A state for cropping an image.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        ToolbarView = require( '../views/toolbar.js' ),
+        CropperView = require( '../views/cropper.js' ),
+        l10n = wp.media.view.l10n,
+        Cropper;
+
+Cropper = State.extend({
+        defaults: {
+                id:          'cropper',
+                title:       l10n.cropImage,
+                // Region mode defaults.
+                toolbar:     'crop',
+                content:     'crop',
+                router:      false,
+
+                canSkipCrop: false
+        },
+
+        activate: function() {
+                this.frame.on( 'content:create:crop', this.createCropContent, this );
+                this.frame.on( 'close', this.removeCropper, this );
+                this.set('selection', new Backbone.Collection(this.frame._selection.single));
+        },
+
+        deactivate: function() {
+                this.frame.toolbar.mode('browse');
+        },
+
+        createCropContent: function() {
+                this.cropperView = new CropperView({
+                        controller: this,
+                        attachment: this.get('selection').first()
+                });
+                this.cropperView.on('image-loaded', this.createCropToolbar, this);
+                this.frame.content.set(this.cropperView);
+
+        },
+        removeCropper: function() {
+                this.imgSelect.cancelSelection();
+                this.imgSelect.setOptions({remove: true});
+                this.imgSelect.update();
+                this.cropperView.remove();
+        },
+        createCropToolbar: function() {
+                var canSkipCrop, toolbarOptions;
+
+                canSkipCrop = this.get('canSkipCrop') || false;
+
+                toolbarOptions = {
+                        controller: this.frame,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     l10n.cropImage,
+                                        priority: 80,
+                                        requires: { library: false, selection: false },
+
+                                        click: function() {
+                                                var self = this,
+                                                        selection = this.controller.state().get('selection').first();
+
+                                                selection.set({cropDetails: this.controller.state().imgSelect.getSelection()});
+
+                                                this.$el.text(l10n.cropping);
+                                                this.$el.attr('disabled', true);
+                                                this.controller.state().doCrop( selection ).done( function( croppedImage ) {
+                                                        self.controller.trigger('cropped', croppedImage );
+                                                        self.controller.close();
+                                                }).fail( function() {
+                                                        self.controller.trigger('content:error:crop');
+                                                });
+                                        }
+                                }
+                        }
+                };
+
+                if ( canSkipCrop ) {
+                        _.extend( toolbarOptions.items, {
+                                skip: {
+                                        style:      'secondary',
+                                        text:       l10n.skipCropping,
+                                        priority:   70,
+                                        requires:   { library: false, selection: false },
+                                        click:      function() {
+                                                var selection = this.controller.state().get('selection').first();
+                                                this.controller.state().cropperView.remove();
+                                                this.controller.trigger('skippedcrop', selection);
+                                                this.controller.close();
+                                        }
+                                }
+                        });
+                }
+
+                this.frame.toolbar.set( new ToolbarView(toolbarOptions) );
+        },
+
+        doCrop: function( attachment ) {
+                return wp.ajax.post( 'custom-header-crop', {
+                        nonce: attachment.get('nonces').edit,
+                        id: attachment.get('id'),
+                        cropDetails: attachment.get('cropDetails')
+                } );
+        }
+});
+
+module.exports = Cropper;
+ No newline at end of file

src/wp-includes/js/media/controllers/edit-attachment-metadata.js

@@ +1 @@
+/**
+ * wp.media.controller.EditAttachmentMetadata
+ *
+ * A state for editing an attachment's metadata.
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        EditAttachmentMetadata;
+
+EditAttachmentMetadata = State.extend({
+        defaults: {
+                id:      'edit-attachment',
+                // Title string passed to the frame's title region view.
+                title:   l10n.attachmentDetails,
+                // Region mode defaults.
+                content: 'edit-metadata',
+                menu:    false,
+                toolbar: false,
+                router:  false
+        }
+});
+
+module.exports = EditAttachmentMetadata;
+ No newline at end of file

src/wp-includes/js/media/controllers/edit-image.js

@@ +1 @@
+/**
+ * wp.media.controller.EditImage
+ *
+ * A state for editing (cropping, etc.) an image.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                    attributes                      The attributes hash passed to the state.
+ * @param {wp.media.model.Attachment} attributes.model                The attachment.
+ * @param {string}                    [attributes.id=edit-image]      Unique identifier.
+ * @param {string}                    [attributes.title=Edit Image]   Title for the state. Displays in the media menu and the frame's title region.
+ * @param {string}                    [attributes.content=edit-image] Initial mode for the content region.
+ * @param {string}                    [attributes.toolbar=edit-image] Initial mode for the toolbar region.
+ * @param {string}                    [attributes.menu=false]         Initial mode for the menu region.
+ * @param {string}                    [attributes.url]                Unused. @todo Consider removal.
+ */
+var State = require( './state.js' ),
+        ToolbarView = require( '../views/toolbar.js' ),
+        l10n = wp.media.view.l10n,
+        EditImage;
+
+EditImage = State.extend({
+        defaults: {
+                id:      'edit-image',
+                title:   l10n.editImage,
+                menu:    false,
+                toolbar: 'edit-image',
+                content: 'edit-image',
+                url:     ''
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.listenTo( this.frame, 'toolbar:render:edit-image', this.toolbar );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        deactivate: function() {
+                this.stopListening( this.frame );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        toolbar: function() {
+                var frame = this.frame,
+                        lastState = frame.lastState(),
+                        previous = lastState && lastState.id;
+
+                frame.toolbar.set( new ToolbarView({
+                        controller: frame,
+                        items: {
+                                back: {
+                                        style: 'primary',
+                                        text:     l10n.back,
+                                        priority: 20,
+                                        click:    function() {
+                                                if ( previous ) {
+                                                        frame.setState( previous );
+                                                } else {
+                                                        frame.close();
+                                                }
+                                        }
+                                }
+                        }
+                }) );
+        }
+});
+
+module.exports = EditImage;
+ No newline at end of file

src/wp-includes/js/media/controllers/embed.js

@@ +1 @@
+/**
+ * wp.media.controller.Embed
+ *
+ * A state for embedding media from a URL.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object} attributes                         The attributes hash passed to the state.
+ * @param {string} [attributes.id=embed]              Unique identifier.
+ * @param {string} [attributes.title=Insert From URL] Title for the state. Displays in the media menu and the frame's title region.
+ * @param {string} [attributes.content=embed]         Initial mode for the content region.
+ * @param {string} [attributes.menu=default]          Initial mode for the menu region.
+ * @param {string} [attributes.toolbar=main-embed]    Initial mode for the toolbar region.
+ * @param {string} [attributes.menu=false]            Initial mode for the menu region.
+ * @param {int}    [attributes.priority=120]          The priority for the state link in the media menu.
+ * @param {string} [attributes.type=link]             The type of embed. Currently only link is supported.
+ * @param {string} [attributes.url]                   The embed URL.
+ * @param {object} [attributes.metadata={}]           Properties of the embed, which will override attributes.url if set.
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Embed;
+
+Embed = State.extend({
+        defaults: {
+                id:       'embed',
+                title:    l10n.insertFromUrlTitle,
+                content:  'embed',
+                menu:     'default',
+                toolbar:  'main-embed',
+                priority: 120,
+                type:     'link',
+                url:      '',
+                metadata: {}
+        },
+
+        // The amount of time used when debouncing the scan.
+        sensitivity: 200,
+
+        initialize: function(options) {
+                this.metadata = options.metadata;
+                this.debouncedScan = _.debounce( _.bind( this.scan, this ), this.sensitivity );
+                this.props = new Backbone.Model( this.metadata || { url: '' });
+                this.props.on( 'change:url', this.debouncedScan, this );
+                this.props.on( 'change:url', this.refresh, this );
+                this.on( 'scan', this.scanImage, this );
+        },
+
+        /**
+         * Trigger a scan of the embedded URL's content for metadata required to embed.
+         *
+         * @fires wp.media.controller.Embed#scan
+         */
+        scan: function() {
+                var scanners,
+                        embed = this,
+                        attributes = {
+                                type: 'link',
+                                scanners: []
+                        };
+
+                // Scan is triggered with the list of `attributes` to set on the
+                // state, useful for the 'type' attribute and 'scanners' attribute,
+                // an array of promise objects for asynchronous scan operations.
+                if ( this.props.get('url') ) {
+                        this.trigger( 'scan', attributes );
+                }
+
+                if ( attributes.scanners.length ) {
+                        scanners = attributes.scanners = $.when.apply( $, attributes.scanners );
+                        scanners.always( function() {
+                                if ( embed.get('scanners') === scanners ) {
+                                        embed.set( 'loading', false );
+                                }
+                        });
+                } else {
+                        attributes.scanners = null;
+                }
+
+                attributes.loading = !! attributes.scanners;
+                this.set( attributes );
+        },
+        /**
+         * Try scanning the embed as an image to discover its dimensions.
+         *
+         * @param {Object} attributes
+         */
+        scanImage: function( attributes ) {
+                var frame = this.frame,
+                        state = this,
+                        url = this.props.get('url'),
+                        image = new Image(),
+                        deferred = $.Deferred();
+
+                attributes.scanners.push( deferred.promise() );
+
+                // Try to load the image and find its width/height.
+                image.onload = function() {
+                        deferred.resolve();
+
+                        if ( state !== frame.state() || url !== state.props.get('url') ) {
+                                return;
+                        }
+
+                        state.set({
+                                type: 'image'
+                        });
+
+                        state.props.set({
+                                width:  image.width,
+                                height: image.height
+                        });
+                };
+
+                image.onerror = deferred.reject;
+                image.src = url;
+        },
+
+        refresh: function() {
+                this.frame.toolbar.get().refresh();
+        },
+
+        reset: function() {
+                this.props.clear().set({ url: '' });
+
+                if ( this.active ) {
+                        this.refresh();
+                }
+        }
+});
+
+module.exports = Embed;
+ No newline at end of file

src/wp-includes/js/media/controllers/featured-image.js

@@ +1 @@
+/**
+ * wp.media.controller.FeaturedImage
+ *
+ * A state for selecting a featured image for a post.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                          The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=featured-image]        Unique identifier.
+ * @param {string}                     [attributes.title=Set Featured Image] Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]                  The attachments collection to browse.
+ *                                                                           If one is not supplied, a collection of all images will be created.
+ * @param {boolean}                    [attributes.multiple=false]           Whether multi-select is enabled.
+ * @param {string}                     [attributes.content=upload]           Initial mode for the content region.
+ *                                                                           Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.menu=default]             Initial mode for the menu region.
+ * @param {string}                     [attributes.router=browse]            Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=featured-image]   Initial mode for the toolbar region.
+ * @param {int}                        [attributes.priority=60]              The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.searchable=true]          Whether the library is searchable.
+ * @param {boolean|string}             [attributes.filterable=false]         Whether the library is filterable, and if so what filters should be shown.
+ *                                                                           Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                    [attributes.sortable=true]            Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]          Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.describe=false]           Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.contentUserSetting=true]  Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                    [attributes.syncSelection=true]       Whether the Attachments selection should be persisted from the last state.
+ */
+var Attachment = require( '../models/attachment.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        FeaturedImage;
+
+FeaturedImage = Library.extend({
+        defaults: _.defaults({
+                id:            'featured-image',
+                title:         l10n.setFeaturedImageTitle,
+                multiple:      false,
+                filterable:    'uploaded',
+                toolbar:       'featured-image',
+                priority:      60,
+                syncSelection: true
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var library, comparator;
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query({ type: 'image' }) );
+                }
+
+                Library.prototype.initialize.apply( this, arguments );
+
+                library    = this.get('library');
+                comparator = library.comparator;
+
+                // Overload the library's comparator to push items that are not in
+                // the mirrored query to the front of the aggregate collection.
+                library.comparator = function( a, b ) {
+                        var aInQuery = !! this.mirroring.get( a.cid ),
+                                bInQuery = !! this.mirroring.get( b.cid );
+
+                        if ( ! aInQuery && bInQuery ) {
+                                return -1;
+                        } else if ( aInQuery && ! bInQuery ) {
+                                return 1;
+                        } else {
+                                return comparator.apply( this, arguments );
+                        }
+                };
+
+                // Add all items in the selection to the library, so any featured
+                // images that are not initially loaded still appear.
+                library.observe( this.get('selection') );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.updateSelection();
+                this.frame.on( 'open', this.updateSelection, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.frame.off( 'open', this.updateSelection, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        updateSelection: function() {
+                var selection = this.get('selection'),
+                        id = wp.media.view.settings.post.featuredImageId,
+                        attachment;
+
+                if ( '' !== id && -1 !== id ) {
+                        attachment = Attachment.get( id );
+                        attachment.fetch();
+                }
+
+                selection.reset( attachment ? [ attachment ] : [] );
+        }
+});
+
+module.exports = FeaturedImage;
+ No newline at end of file

src/wp-includes/js/media/controllers/gallery-add.js

@@ +1 @@
+/**
+ * A state for selecting more images to add to a gallery.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                         The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=gallery-library]      Unique identifier.
+ * @param {string}                     [attributes.title=Add to Gallery]    Title for the state. Displays in the frame's title region.
+ * @param {boolean}                    [attributes.multiple=add]            Whether multi-select is enabled. @todo 'add' doesn't seem do anything special, and gets used as a boolean.
+ * @param {wp.media.model.Attachments} [attributes.library]                 The attachments collection to browse.
+ *                                                                          If one is not supplied, a collection of all images will be created.
+ * @param {boolean|string}             [attributes.filterable=uploaded]     Whether the library is filterable, and if so what filters should be shown.
+ *                                                                          Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {string}                     [attributes.menu=gallery]            Initial mode for the menu region.
+ * @param {string}                     [attributes.content=upload]          Initial mode for the content region.
+ *                                                                          Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=gallery-add]     Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {int}                        [attributes.priority=100]            The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]     Whether the Attachments selection should be persisted from the last state.
+ *                                                                          Defaults to false because for this state, because the library of the Edit Gallery state is the selection.
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        GalleryAdd;
+
+GalleryAdd = Library.extend({
+        defaults: _.defaults({
+                id:            'gallery-library',
+                title:         l10n.addToGalleryTitle,
+                multiple:      'add',
+                filterable:    'uploaded',
+                menu:          'gallery',
+                toolbar:       'gallery-add',
+                priority:      100,
+                syncSelection: false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                // If a library wasn't supplied, create a library of images.
+                if ( ! this.get('library') )
+                        this.set( 'library', wp.media.query({ type: 'image' }) );
+
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                var library = this.get('library'),
+                        edit    = this.frame.state('gallery-edit').get('library');
+
+                if ( this.editLibrary && this.editLibrary !== edit )
+                        library.unobserve( this.editLibrary );
+
+                // Accepts attachments that exist in the original library and
+                // that do not exist in gallery's library.
+                library.validator = function( attachment ) {
+                        return !! this.mirroring.get( attachment.cid ) && ! edit.get( attachment.cid ) && Selection.prototype.validator.apply( this, arguments );
+                };
+
+                // Reset the library to ensure that all attachments are re-added
+                // to the collection. Do so silently, as calling `observe` will
+                // trigger the `reset` event.
+                library.reset( library.mirroring.models, { silent: true });
+                library.observe( edit );
+                this.editLibrary = edit;
+
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = GalleryAdd;
+ No newline at end of file

src/wp-includes/js/media/controllers/gallery-edit.js

@@ +1 @@
+/**
+ * wp.media.controller.GalleryEdit
+ *
+ * A state for editing a gallery's images and settings.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                       The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=gallery-edit]       Unique identifier.
+ * @param {string}                     [attributes.title=Edit Gallery]    Title for the state. Displays in the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]               The collection of attachments in the gallery.
+ *                                                                        If one is not supplied, an empty media.model.Selection collection is created.
+ * @param {boolean}                    [attributes.multiple=false]        Whether multi-select is enabled.
+ * @param {boolean}                    [attributes.searchable=false]      Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]         Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {string|false}               [attributes.content=browse]        Initial mode for the content region.
+ * @param {string|false}               [attributes.toolbar=image-details] Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.describe=true]         Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.displaySettings=true]  Whether to show the attachment display settings interface.
+ * @param {boolean}                    [attributes.dragInfo=true]         Whether to show instructional text about the attachments being sortable.
+ * @param {int}                        [attributes.idealColumnWidth=170]  The ideal column width in pixels for attachments.
+ * @param {boolean}                    [attributes.editing=false]         Whether the gallery is being created, or editing an existing instance.
+ * @param {int}                        [attributes.priority=60]           The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]   Whether the Attachments selection should be persisted from the last state.
+ *                                                                        Defaults to false for this state, because the library passed in  *is* the selection.
+ * @param {view}                       [attributes.AttachmentView]        The single `Attachment` view to be used in the `Attachments`.
+ *                                                                        If none supplied, defaults to wp.media.view.Attachment.EditLibrary.
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        EditLibraryView = require( '../views/attachment/edit-library.js' ),
+        GallerySettingsView = require( '../views/settings/gallery.js' ),
+        l10n = wp.media.view.l10n,
+        GalleryEdit;
+
+GalleryEdit = Library.extend({
+        defaults: {
+                id:               'gallery-edit',
+                title:            l10n.editGalleryTitle,
+                multiple:         false,
+                searchable:       false,
+                sortable:         true,
+                display:          false,
+                content:          'browse',
+                toolbar:          'gallery-edit',
+                describe:         true,
+                displaySettings:  true,
+                dragInfo:         true,
+                idealColumnWidth: 170,
+                editing:          false,
+                priority:         60,
+                syncSelection:    false
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') )
+                        this.set( 'library', new Selection() );
+
+                // The single `Attachment` view to be used in the `Attachments` view.
+                if ( ! this.get('AttachmentView') )
+                        this.set( 'AttachmentView', EditLibraryView );
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                var library = this.get('library');
+
+                // Limit the library to images only.
+                library.props.set( 'type', 'image' );
+
+                // Watch for uploaded attachments.
+                this.get('library').observe( wp.Uploader.queue );
+
+                this.frame.on( 'content:render:browse', this.gallerySettings, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                // Stop watching for uploaded attachments.
+                this.get('library').unobserve( wp.Uploader.queue );
+
+                this.frame.off( 'content:render:browse', this.gallerySettings, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         *
+         * @param browser
+         */
+        gallerySettings: function( browser ) {
+                if ( ! this.get('displaySettings') ) {
+                        return;
+                }
+
+                var library = this.get('library');
+
+                if ( ! library || ! browser ) {
+                        return;
+                }
+
+                library.gallery = library.gallery || new Backbone.Model();
+
+                browser.sidebar.set({
+                        gallery: new GallerySettingsView({
+                                controller: this,
+                                model:      library.gallery,
+                                priority:   40
+                        })
+                });
+
+                browser.toolbar.set( 'reverse', {
+                        text:     l10n.reverseOrder,
+                        priority: 80,
+
+                        click: function() {
+                                library.reset( library.toArray().reverse() );
+                        }
+                });
+        }
+});
+
+module.exports = GalleryEdit;
+ No newline at end of file

src/wp-includes/js/media/controllers/image-details.js

@@ +1 @@
+/**
+ * wp.media.controller.ImageDetails
+ *
+ * A state for editing the attachment display settings of an image that's been
+ * inserted into the editor.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                    [attributes]                       The attributes hash passed to the state.
+ * @param {string}                    [attributes.id=image-details]      Unique identifier.
+ * @param {string}                    [attributes.title=Image Details]   Title for the state. Displays in the frame's title region.
+ * @param {wp.media.model.Attachment} attributes.image                   The image's model.
+ * @param {string|false}              [attributes.content=image-details] Initial mode for the content region.
+ * @param {string|false}              [attributes.menu=false]            Initial mode for the menu region.
+ * @param {string|false}              [attributes.router=false]          Initial mode for the router region.
+ * @param {string|false}              [attributes.toolbar=image-details] Initial mode for the toolbar region.
+ * @param {boolean}                   [attributes.editing=false]         Unused.
+ * @param {int}                       [attributes.priority=60]           Unused.
+ *
+ * @todo This state inherits some defaults from media.controller.Library.prototype.defaults,
+ *       however this may not do anything.
+ */
+var State = require( './state.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        ImageDetails;
+
+ImageDetails = State.extend({
+        defaults: _.defaults({
+                id:       'image-details',
+                title:    l10n.imageDetailsTitle,
+                content:  'image-details',
+                menu:     false,
+                router:   false,
+                toolbar:  'image-details',
+                editing:  false,
+                priority: 60
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         *
+         * @param options Attributes
+         */
+        initialize: function( options ) {
+                this.image = options.image;
+                State.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.frame.modal.$el.addClass('image-details');
+        }
+});
+
+module.exports = ImageDetails;
+ No newline at end of file

src/wp-includes/js/media/controllers/library.js

@@ +1 @@
+/**
+ * wp.media.controller.Library
+ *
+ * A state for choosing an attachment or group of attachments from the media library.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ * @mixes media.selectionSync
+ *
+ * @param {object}                          [attributes]                         The attributes hash passed to the state.
+ * @param {string}                          [attributes.id=library]              Unique identifier.
+ * @param {string}                          [attributes.title=Media library]     Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments}      [attributes.library]                 The attachments collection to browse.
+ *                                                                               If one is not supplied, a collection of all attachments will be created.
+ * @param {wp.media.model.Selection|object} [attributes.selection]               A collection to contain attachment selections within the state.
+ *                                                                               If the 'selection' attribute is a plain JS object,
+ *                                                                               a Selection will be created using its values as the selection instance's `props` model.
+ *                                                                               Otherwise, it will copy the library's `props` model.
+ * @param {boolean}                         [attributes.multiple=false]          Whether multi-select is enabled.
+ * @param {string}                          [attributes.content=upload]          Initial mode for the content region.
+ *                                                                               Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                          [attributes.menu=default]            Initial mode for the menu region.
+ * @param {string}                          [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                          [attributes.toolbar=select]          Initial mode for the toolbar region.
+ * @param {boolean}                         [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean|string}                  [attributes.filterable=false]        Whether the library is filterable, and if so what filters should be shown.
+ *                                                                               Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                         [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                         [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                         [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                         [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                         [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.
+ */
+var selectionSync = require( '../utils/selection-sync.js' ),
+        SelectionModel = require( '../models/selection.js' ),
+        State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Library;
+
+Library = State.extend({
+        defaults: {
+                id:                 'library',
+                title:              l10n.mediaLibraryTitle,
+                multiple:           false,
+                content:            'upload',
+                menu:               'default',
+                router:             'browse',
+                toolbar:            'select',
+                searchable:         true,
+                filterable:         false,
+                sortable:           true,
+                autoSelect:         true,
+                describe:           false,
+                contentUserSetting: true,
+                syncSelection:      true
+        },
+
+        /**
+         * If a library isn't provided, query all media items.
+         * If a selection instance isn't provided, create one.
+         *
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var selection = this.get('selection'),
+                        props;
+
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query() );
+                }
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        props = selection;
+
+                        if ( ! props ) {
+                                props = this.get('library').props.toJSON();
+                                props = _.omit( props, 'orderby', 'query' );
+                        }
+
+                        this.set( 'selection', new SelectionModel( null, {
+                                multiple: this.get('multiple'),
+                                props: props
+                        }) );
+                }
+
+                this.resetDisplays();
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.syncSelection();
+
+                wp.Uploader.queue.on( 'add', this.uploading, this );
+
+                this.get('selection').on( 'add remove reset', this.refreshContent, this );
+
+                if ( this.get( 'router' ) && this.get('contentUserSetting') ) {
+                        this.frame.on( 'content:activate', this.saveContentMode, this );
+                        this.set( 'content', getUserSetting( 'libraryContent', this.get('content') ) );
+                }
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.recordSelection();
+
+                this.frame.off( 'content:activate', this.saveContentMode, this );
+
+                // Unbind all event handlers that use this state as the context
+                // from the selection.
+                this.get('selection').off( null, null, this );
+
+                wp.Uploader.queue.off( null, null, this );
+        },
+
+        /**
+         * Reset the library to its initial state.
+         *
+         * @since 3.5.0
+         */
+        reset: function() {
+                this.get('selection').reset();
+                this.resetDisplays();
+                this.refreshContent();
+        },
+
+        /**
+         * Reset the attachment display settings defaults to the site options.
+         *
+         * If site options don't define them, fall back to a persistent user setting.
+         *
+         * @since 3.5.0
+         */
+        resetDisplays: function() {
+                var defaultProps = wp.media.view.settings.defaultProps;
+                this._displays = [];
+                this._defaultDisplaySettings = {
+                        align: defaultProps.align || getUserSetting( 'align', 'none' ),
+                        size:  defaultProps.size  || getUserSetting( 'imgsize', 'medium' ),
+                        link:  defaultProps.link  || getUserSetting( 'urlbutton', 'file' )
+                };
+        },
+
+        /**
+         * Create a model to represent display settings (alignment, etc.) for an attachment.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Backbone.Model}
+         */
+        display: function( attachment ) {
+                var displays = this._displays;
+
+                if ( ! displays[ attachment.cid ] ) {
+                        displays[ attachment.cid ] = new Backbone.Model( this.defaultDisplaySettings( attachment ) );
+                }
+                return displays[ attachment.cid ];
+        },
+
+        /**
+         * Given an attachment, create attachment display settings properties.
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Object}
+         */
+        defaultDisplaySettings: function( attachment ) {
+                var settings = this._defaultDisplaySettings;
+                if ( settings.canEmbed = this.canEmbed( attachment ) ) {
+                        settings.link = 'embed';
+                }
+                return settings;
+        },
+
+        /**
+         * Whether an attachment can be embedded (audio or video).
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        canEmbed: function( attachment ) {
+                // If uploading, we know the filename but not the mime type.
+                if ( ! attachment.get('uploading') ) {
+                        var type = attachment.get('type');
+                        if ( type !== 'audio' && type !== 'video' ) {
+                                return false;
+                        }
+                }
+
+                return _.contains( wp.media.view.settings.embedExts, attachment.get('filename').split('.').pop() );
+        },
+
+
+        /**
+         * If the state is active, no items are selected, and the current
+         * content mode is not an option in the state's router (provided
+         * the state has a router), reset the content mode to the default.
+         *
+         * @since 3.5.0
+         */
+        refreshContent: function() {
+                var selection = this.get('selection'),
+                        frame = this.frame,
+                        router = frame.router.get(),
+                        mode = frame.content.mode();
+
+                if ( this.active && ! selection.length && router && ! router.get( mode ) ) {
+                        this.frame.content.render( this.get('content') );
+                }
+        },
+
+        /**
+         * Callback handler when an attachment is uploaded.
+         *
+         * Switch to the Media Library if uploaded from the 'Upload Files' tab.
+         *
+         * Adds any uploading attachments to the selection.
+         *
+         * If the state only supports one attachment to be selected and multiple
+         * attachments are uploaded, the last attachment in the upload queue will
+         * be selected.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         */
+        uploading: function( attachment ) {
+                var content = this.frame.content;
+
+                if ( 'upload' === content.mode() ) {
+                        this.frame.content.mode('browse');
+                }
+
+                if ( this.get( 'autoSelect' ) ) {
+                        this.get('selection').add( attachment );
+                        this.frame.trigger( 'library:selection:add' );
+                }
+        },
+
+        /**
+         * Persist the mode of the content region as a user setting.
+         *
+         * @since 3.5.0
+         */
+        saveContentMode: function() {
+                if ( 'browse' !== this.get('router') ) {
+                        return;
+                }
+
+                var mode = this.frame.content.mode(),
+                        view = this.frame.router.get();
+
+                if ( view && view.get( mode ) ) {
+                        setUserSetting( 'libraryContent', mode );
+                }
+        }
+});
+
+// Make selectionSync available on any Media Library state.
+_.extend( Library.prototype, selectionSync );
+
+module.exports = Library;
+ No newline at end of file

src/wp-includes/js/media/controllers/media-library.js

@@ +1 @@
+/**
+ * wp.media.controller.MediaLibrary
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var Library = require( './library.js' ),
+        MediaLibrary;
+
+MediaLibrary = Library.extend({
+        defaults: _.defaults({
+                // Attachments browser defaults. @see media.view.AttachmentsBrowser
+                filterable:      'uploaded',
+
+                displaySettings: false,
+                priority:        80,
+                syncSelection:   false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         *
+         * @param options
+         */
+        initialize: function( options ) {
+                this.media = options.media;
+                this.type = options.type;
+                this.set( 'library', wp.media.query({ type: this.type }) );
+
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                // @todo this should use this.frame.
+                if ( wp.media.frame.lastMime ) {
+                        this.set( 'library', wp.media.query({ type: wp.media.frame.lastMime }) );
+                        delete wp.media.frame.lastMime;
+                }
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = MediaLibrary;
+ No newline at end of file

src/wp-includes/js/media/controllers/region.js

@@ +1 @@
+/**
+ * wp.media.controller.Region
+ *
+ * A region is a persistent application layout area.
+ *
+ * A region assumes one mode at any time, and can be switched to another.
+ *
+ * When mode changes, events are triggered on the region's parent view.
+ * The parent view will listen to specific events and fill the region with an
+ * appropriate view depending on mode. For example, a frame listens for the
+ * 'browse' mode t be activated on the 'content' view and then fills the region
+ * with an AttachmentsBrowser view.
+ *
+ * @class
+ *
+ * @param {object}        options          Options hash for the region.
+ * @param {string}        options.id       Unique identifier for the region.
+ * @param {Backbone.View} options.view     A parent view the region exists within.
+ * @param {string}        options.selector jQuery selector for the region within the parent view.
+ */
+var Region = function( options ) {
+        _.extend( this, _.pick( options || {}, 'id', 'view', 'selector' ) );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+Region.extend = Backbone.Model.extend;
+
+_.extend( Region.prototype, {
+        /**
+         * Activate a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:activate:{this._mode}
+         * @fires this.view#{this.id}:activate
+         * @fires this.view#{this.id}:deactivate:{this._mode}
+         * @fires this.view#{this.id}:deactivate
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        mode: function( mode ) {
+                if ( ! mode ) {
+                        return this._mode;
+                }
+                // Bail if we're trying to change to the current mode.
+                if ( mode === this._mode ) {
+                        return this;
+                }
+
+                /**
+                 * Region mode deactivation event.
+                 *
+                 * @event this.view#{this.id}:deactivate:{this._mode}
+                 * @event this.view#{this.id}:deactivate
+                 */
+                this.trigger('deactivate');
+
+                this._mode = mode;
+                this.render( mode );
+
+                /**
+                 * Region mode activation event.
+                 *
+                 * @event this.view#{this.id}:activate:{this._mode}
+                 * @event this.view#{this.id}:activate
+                 */
+                this.trigger('activate');
+                return this;
+        },
+        /**
+         * Render a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:create:{this._mode}
+         * @fires this.view#{this.id}:create
+         * @fires this.view#{this.id}:render:{this._mode}
+         * @fires this.view#{this.id}:render
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining
+         */
+        render: function( mode ) {
+                // If the mode isn't active, activate it.
+                if ( mode && mode !== this._mode ) {
+                        return this.mode( mode );
+                }
+
+                var set = { view: null },
+                        view;
+
+                /**
+                 * Create region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'create', set );
+                view = set.view;
+
+                /**
+                 * Render region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'render', view );
+                if ( view ) {
+                        this.set( view );
+                }
+                return this;
+        },
+
+        /**
+         * Get the region's view.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.View}
+         */
+        get: function() {
+                return this.view.views.first( this.selector );
+        },
+
+        /**
+         * Set the region's view as a subview of the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {Array|Object} views
+         * @param {Object} [options={}]
+         * @returns {wp.Backbone.Subviews} Subviews is returned to allow chaining
+         */
+        set: function( views, options ) {
+                if ( options ) {
+                        options.add = false;
+                }
+                return this.view.views.set( this.selector, views, options );
+        },
+
+        /**
+         * Trigger regional view events on the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} event
+         * @returns {undefined|wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        trigger: function( event ) {
+                var base, args;
+
+                if ( ! this._mode ) {
+                        return;
+                }
+
+                args = _.toArray( arguments );
+                base = this.id + ':' + event;
+
+                // Trigger `{this.id}:{event}:{this._mode}` event on the frame.
+                args[0] = base + ':' + this._mode;
+                this.view.trigger.apply( this.view, args );
+
+                // Trigger `{this.id}:{event}` event on the frame.
+                args[0] = base;
+                this.view.trigger.apply( this.view, args );
+                return this;
+        }
+});
+
+module.exports = Region;
+ No newline at end of file

src/wp-includes/js/media/controllers/replace-image.js

@@ +1 @@
+/**
+ * wp.media.controller.ReplaceImage
+ *
+ * A state for replacing an image.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                         The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=replace-image]        Unique identifier.
+ * @param {string}                     [attributes.title=Replace Image]     Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]                 The attachments collection to browse.
+ *                                                                          If one is not supplied, a collection of all images will be created.
+ * @param {boolean}                    [attributes.multiple=false]          Whether multi-select is enabled.
+ * @param {string}                     [attributes.content=upload]          Initial mode for the content region.
+ *                                                                          Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.menu=default]            Initial mode for the menu region.
+ * @param {string}                     [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=replace]         Initial mode for the toolbar region.
+ * @param {int}                        [attributes.priority=60]             The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean|string}             [attributes.filterable=uploaded]     Whether the library is filterable, and if so what filters should be shown.
+ *                                                                          Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                    [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                    [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.
+ */
+var Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        ReplaceImage;
+
+ReplaceImage = Library.extend({
+        defaults: _.defaults({
+                id:            'replace-image',
+                title:         l10n.replaceImageTitle,
+                multiple:      false,
+                filterable:    'uploaded',
+                toolbar:       'replace',
+                menu:          false,
+                priority:      60,
+                syncSelection: true
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         *
+         * @param options
+         */
+        initialize: function( options ) {
+                var library, comparator;
+
+                this.image = options.image;
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query({ type: 'image' }) );
+                }
+
+                Library.prototype.initialize.apply( this, arguments );
+
+                library    = this.get('library');
+                comparator = library.comparator;
+
+                // Overload the library's comparator to push items that are not in
+                // the mirrored query to the front of the aggregate collection.
+                library.comparator = function( a, b ) {
+                        var aInQuery = !! this.mirroring.get( a.cid ),
+                                bInQuery = !! this.mirroring.get( b.cid );
+
+                        if ( ! aInQuery && bInQuery ) {
+                                return -1;
+                        } else if ( aInQuery && ! bInQuery ) {
+                                return 1;
+                        } else {
+                                return comparator.apply( this, arguments );
+                        }
+                };
+
+                // Add all items in the selection to the library, so any featured
+                // images that are not initially loaded still appear.
+                library.observe( this.get('selection') );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.updateSelection();
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        updateSelection: function() {
+                var selection = this.get('selection'),
+                        attachment = this.image.attachment;
+
+                selection.reset( attachment ? [ attachment ] : [] );
+        }
+});
+
+module.exports = ReplaceImage;
+ No newline at end of file

src/wp-includes/js/media/controllers/state-machine.js

@@ +1 @@
+/**
+ * wp.media.controller.StateMachine
+ *
+ * A state machine keeps track of state. It is in one state at a time,
+ * and can change from one state to another.
+ *
+ * States are stored as models in a Backbone collection.
+ *
+ * @since 3.5.0
+ *
+ * @class
+ * @augments Backbone.Model
+ * @mixin
+ * @mixes Backbone.Events
+ *
+ * @param {Array} states
+ */
+var StateMachine = function( states ) {
+        // @todo This is dead code. The states collection gets created in media.view.Frame._createStates.
+        this.states = new Backbone.Collection( states );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+StateMachine.extend = Backbone.Model.extend;
+
+_.extend( StateMachine.prototype, Backbone.Events, {
+        /**
+         * Fetch a state.
+         *
+         * If no `id` is provided, returns the active state.
+         *
+         * Implicitly creates states.
+         *
+         * Ensure that the `states` collection exists so the `StateMachine`
+         *   can be used as a mixin.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         * @returns {wp.media.controller.State} Returns a State model
+         *   from the StateMachine collection
+         */
+        state: function( id ) {
+                this.states = this.states || new Backbone.Collection();
+
+                // Default to the active state.
+                id = id || this._state;
+
+                if ( id && ! this.states.get( id ) ) {
+                        this.states.add({ id: id });
+                }
+                return this.states.get( id );
+        },
+
+        /**
+         * Sets the active state.
+         *
+         * Bail if we're trying to select the current state, if we haven't
+         * created the `states` collection, or are trying to select a state
+         * that does not exist.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         *
+         * @fires wp.media.controller.State#deactivate
+         * @fires wp.media.controller.State#activate
+         *
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining
+         */
+        setState: function( id ) {
+                var previous = this.state();
+
+                if ( ( previous && id === previous.id ) || ! this.states || ! this.states.get( id ) ) {
+                        return this;
+                }
+
+                if ( previous ) {
+                        previous.trigger('deactivate');
+                        this._lastState = previous.id;
+                }
+
+                this._state = id;
+                this.state().trigger('activate');
+
+                return this;
+        },
+
+        /**
+         * Returns the previous active state.
+         *
+         * Call the `state()` method with no parameters to retrieve the current
+         * active state.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.controller.State} Returns a State model
+         *    from the StateMachine collection
+         */
+        lastState: function() {
+                if ( this._lastState ) {
+                        return this.state( this._lastState );
+                }
+        }
+});
+
+// Map all event binding and triggering on a StateMachine to its `states` collection.
+_.each([ 'on', 'off', 'trigger' ], function( method ) {
+        /**
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.
+         */
+        StateMachine.prototype[ method ] = function() {
+                // Ensure that the `states` collection exists so the `StateMachine`
+                // can be used as a mixin.
+                this.states = this.states || new Backbone.Collection();
+                // Forward the method to the `states` collection.
+                this.states[ method ].apply( this.states, arguments );
+                return this;
+        };
+});
+
+module.exports = StateMachine;
+ No newline at end of file

src/wp-includes/js/media/controllers/state.js

@@ +1 @@
+/**
+ * wp.media.controller.State
+ *
+ * A state is a step in a workflow that when set will trigger the controllers
+ * for the regions to be updated as specified in the frame.
+ *
+ * A state has an event-driven lifecycle:
+ *
+ *     'ready'      triggers when a state is added to a state machine's collection.
+ *     'activate'   triggers when a state is activated by a state machine.
+ *     'deactivate' triggers when a state is deactivated by a state machine.
+ *     'reset'      is not triggered automatically. It should be invoked by the
+ *                  proper controller to reset the state to its default.
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var State = Backbone.Model.extend({
+        /**
+         * Constructor.
+         *
+         * @since 3.5.0
+         */
+        constructor: function() {
+                this.on( 'activate', this._preActivate, this );
+                this.on( 'activate', this.activate, this );
+                this.on( 'activate', this._postActivate, this );
+                this.on( 'deactivate', this._deactivate, this );
+                this.on( 'deactivate', this.deactivate, this );
+                this.on( 'reset', this.reset, this );
+                this.on( 'ready', this._ready, this );
+                this.on( 'ready', this.ready, this );
+                /**
+                 * Call parent constructor with passed arguments
+                 */
+                Backbone.Model.apply( this, arguments );
+                this.on( 'change:menu', this._updateMenu, this );
+        },
+        /**
+         * Ready event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        ready: function() {},
+
+        /**
+         * Activate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        activate: function() {},
+
+        /**
+         * Deactivate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        deactivate: function() {},
+
+        /**
+         * Reset event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        reset: function() {},
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _ready: function() {
+                this._updateMenu();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+        */
+        _preActivate: function() {
+                this.active = true;
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _postActivate: function() {
+                this.on( 'change:menu', this._menu, this );
+                this.on( 'change:titleMode', this._title, this );
+                this.on( 'change:content', this._content, this );
+                this.on( 'change:toolbar', this._toolbar, this );
+
+                this.frame.on( 'title:render:default', this._renderTitle, this );
+
+                this._title();
+                this._menu();
+                this._toolbar();
+                this._content();
+                this._router();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _deactivate: function() {
+                this.active = false;
+
+                this.frame.off( 'title:render:default', this._renderTitle, this );
+
+                this.off( 'change:menu', this._menu, this );
+                this.off( 'change:titleMode', this._title, this );
+                this.off( 'change:content', this._content, this );
+                this.off( 'change:toolbar', this._toolbar, this );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _title: function() {
+                this.frame.title.render( this.get('titleMode') || 'default' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _renderTitle: function( view ) {
+                view.$el.text( this.get('title') || '' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _router: function() {
+                var router = this.frame.router,
+                        mode = this.get('router'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-router', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                this.frame.router.render( mode );
+
+                view = router.get();
+                if ( view && view.select ) {
+                        view.select( this.frame.content.mode() );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _menu: function() {
+                var menu = this.frame.menu,
+                        mode = this.get('menu'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-menu', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                menu.mode( mode );
+
+                view = menu.get();
+                if ( view && view.select ) {
+                        view.select( this.id );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _updateMenu: function() {
+                var previous = this.previous('menu'),
+                        menu = this.get('menu');
+
+                if ( previous ) {
+                        this.frame.off( 'menu:render:' + previous, this._renderMenu, this );
+                }
+
+                if ( menu ) {
+                        this.frame.on( 'menu:render:' + menu, this._renderMenu, this );
+                }
+        },
+
+        /**
+         * Create a view in the media menu for the state.
+         *
+         * @access private
+         * @since 3.5.0
+         *
+         * @param {media.view.Menu} view The menu view.
+         */
+        _renderMenu: function( view ) {
+                var menuItem = this.get('menuItem'),
+                        title = this.get('title'),
+                        priority = this.get('priority');
+
+                if ( ! menuItem && title ) {
+                        menuItem = { text: title };
+
+                        if ( priority ) {
+                                menuItem.priority = priority;
+                        }
+                }
+
+                if ( ! menuItem ) {
+                        return;
+                }
+
+                view.set( this.id, menuItem );
+        }
+});
+
+_.each(['toolbar','content'], function( region ) {
+        /**
+         * @access private
+         */
+        State.prototype[ '_' + region ] = function() {
+                var mode = this.get( region );
+                if ( mode ) {
+                        this.frame[ region ].render( mode );
+                }
+        };
+});
+
+module.exports = State;
+ No newline at end of file

src/wp-includes/js/media/controllers/video-details.js

@@ +1 @@
+/**
+ * The controller for the Video Details state
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        VideoDetails;
+
+VideoDetails = State.extend({
+        defaults: {
+                id: 'video-details',
+                toolbar: 'video-details',
+                title: l10n.videoDetailsTitle,
+                content: 'video-details',
+                menu: 'video-details',
+                router: false,
+                priority: 60
+        },
+
+        initialize: function( options ) {
+                this.media = options.media;
+                State.prototype.initialize.apply( this, arguments );
+        }
+});
+
+module.exports = VideoDetails;
+ No newline at end of file

src/wp-includes/js/media/grid.js

@@ +1 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/**
+ * wp.media.controller.EditAttachmentMetadata
+ *
+ * A state for editing an attachment's metadata.
+ *
+ * @constructor
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        EditAttachmentMetadata;
+
+EditAttachmentMetadata = State.extend({
+        defaults: {
+                id:      'edit-attachment',
+                // Title string passed to the frame's title region view.
+                title:   l10n.attachmentDetails,
+                // Region mode defaults.
+                content: 'edit-metadata',
+                menu:    false,
+                toolbar: false,
+                router:  false
+        }
+});
+
+module.exports = EditAttachmentMetadata;
+},{"./state.js":6}],2:[function(require,module,exports){
+/**
+ * wp.media.controller.EditImage
+ *
+ * A state for editing (cropping, etc.) an image.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                    attributes                      The attributes hash passed to the state.
+ * @param {wp.media.model.Attachment} attributes.model                The attachment.
+ * @param {string}                    [attributes.id=edit-image]      Unique identifier.
+ * @param {string}                    [attributes.title=Edit Image]   Title for the state. Displays in the media menu and the frame's title region.
+ * @param {string}                    [attributes.content=edit-image] Initial mode for the content region.
+ * @param {string}                    [attributes.toolbar=edit-image] Initial mode for the toolbar region.
+ * @param {string}                    [attributes.menu=false]         Initial mode for the menu region.
+ * @param {string}                    [attributes.url]                Unused. @todo Consider removal.
+ */
+var State = require( './state.js' ),
+        ToolbarView = require( '../views/toolbar.js' ),
+        l10n = wp.media.view.l10n,
+        EditImage;
+
+EditImage = State.extend({
+        defaults: {
+                id:      'edit-image',
+                title:   l10n.editImage,
+                menu:    false,
+                toolbar: 'edit-image',
+                content: 'edit-image',
+                url:     ''
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.listenTo( this.frame, 'toolbar:render:edit-image', this.toolbar );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        deactivate: function() {
+                this.stopListening( this.frame );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        toolbar: function() {
+                var frame = this.frame,
+                        lastState = frame.lastState(),
+                        previous = lastState && lastState.id;
+
+                frame.toolbar.set( new ToolbarView({
+                        controller: frame,
+                        items: {
+                                back: {
+                                        style: 'primary',
+                                        text:     l10n.back,
+                                        priority: 20,
+                                        click:    function() {
+                                                if ( previous ) {
+                                                        frame.setState( previous );
+                                                } else {
+                                                        frame.close();
+                                                }
+                                        }
+                                }
+                        }
+                }) );
+        }
+});
+
+module.exports = EditImage;
+},{"../views/toolbar.js":50,"./state.js":6}],3:[function(require,module,exports){
+/**
+ * wp.media.controller.Library
+ *
+ * A state for choosing an attachment or group of attachments from the media library.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ * @mixes media.selectionSync
+ *
+ * @param {object}                          [attributes]                         The attributes hash passed to the state.
+ * @param {string}                          [attributes.id=library]              Unique identifier.
+ * @param {string}                          [attributes.title=Media library]     Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments}      [attributes.library]                 The attachments collection to browse.
+ *                                                                               If one is not supplied, a collection of all attachments will be created.
+ * @param {wp.media.model.Selection|object} [attributes.selection]               A collection to contain attachment selections within the state.
+ *                                                                               If the 'selection' attribute is a plain JS object,
+ *                                                                               a Selection will be created using its values as the selection instance's `props` model.
+ *                                                                               Otherwise, it will copy the library's `props` model.
+ * @param {boolean}                         [attributes.multiple=false]          Whether multi-select is enabled.
+ * @param {string}                          [attributes.content=upload]          Initial mode for the content region.
+ *                                                                               Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                          [attributes.menu=default]            Initial mode for the menu region.
+ * @param {string}                          [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                          [attributes.toolbar=select]          Initial mode for the toolbar region.
+ * @param {boolean}                         [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean|string}                  [attributes.filterable=false]        Whether the library is filterable, and if so what filters should be shown.
+ *                                                                               Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                         [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                         [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                         [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                         [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                         [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.
+ */
+var selectionSync = require( '../utils/selection-sync.js' ),
+        SelectionModel = require( '../models/selection.js' ),
+        State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Library;
+
+Library = State.extend({
+        defaults: {
+                id:                 'library',
+                title:              l10n.mediaLibraryTitle,
+                multiple:           false,
+                content:            'upload',
+                menu:               'default',
+                router:             'browse',
+                toolbar:            'select',
+                searchable:         true,
+                filterable:         false,
+                sortable:           true,
+                autoSelect:         true,
+                describe:           false,
+                contentUserSetting: true,
+                syncSelection:      true
+        },
+
+        /**
+         * If a library isn't provided, query all media items.
+         * If a selection instance isn't provided, create one.
+         *
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var selection = this.get('selection'),
+                        props;
+
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query() );
+                }
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        props = selection;
+
+                        if ( ! props ) {
+                                props = this.get('library').props.toJSON();
+                                props = _.omit( props, 'orderby', 'query' );
+                        }
+
+                        this.set( 'selection', new SelectionModel( null, {
+                                multiple: this.get('multiple'),
+                                props: props
+                        }) );
+                }
+
+                this.resetDisplays();
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.syncSelection();
+
+                wp.Uploader.queue.on( 'add', this.uploading, this );
+
+                this.get('selection').on( 'add remove reset', this.refreshContent, this );
+
+                if ( this.get( 'router' ) && this.get('contentUserSetting') ) {
+                        this.frame.on( 'content:activate', this.saveContentMode, this );
+                        this.set( 'content', getUserSetting( 'libraryContent', this.get('content') ) );
+                }
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.recordSelection();
+
+                this.frame.off( 'content:activate', this.saveContentMode, this );
+
+                // Unbind all event handlers that use this state as the context
+                // from the selection.
+                this.get('selection').off( null, null, this );
+
+                wp.Uploader.queue.off( null, null, this );
+        },
+
+        /**
+         * Reset the library to its initial state.
+         *
+         * @since 3.5.0
+         */
+        reset: function() {
+                this.get('selection').reset();
+                this.resetDisplays();
+                this.refreshContent();
+        },
+
+        /**
+         * Reset the attachment display settings defaults to the site options.
+         *
+         * If site options don't define them, fall back to a persistent user setting.
+         *
+         * @since 3.5.0
+         */
+        resetDisplays: function() {
+                var defaultProps = wp.media.view.settings.defaultProps;
+                this._displays = [];
+                this._defaultDisplaySettings = {
+                        align: defaultProps.align || getUserSetting( 'align', 'none' ),
+                        size:  defaultProps.size  || getUserSetting( 'imgsize', 'medium' ),
+                        link:  defaultProps.link  || getUserSetting( 'urlbutton', 'file' )
+                };
+        },
+
+        /**
+         * Create a model to represent display settings (alignment, etc.) for an attachment.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Backbone.Model}
+         */
+        display: function( attachment ) {
+                var displays = this._displays;
+
+                if ( ! displays[ attachment.cid ] ) {
+                        displays[ attachment.cid ] = new Backbone.Model( this.defaultDisplaySettings( attachment ) );
+                }
+                return displays[ attachment.cid ];
+        },
+
+        /**
+         * Given an attachment, create attachment display settings properties.
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Object}
+         */
+        defaultDisplaySettings: function( attachment ) {
+                var settings = this._defaultDisplaySettings;
+                if ( settings.canEmbed = this.canEmbed( attachment ) ) {
+                        settings.link = 'embed';
+                }
+                return settings;
+        },
+
+        /**
+         * Whether an attachment can be embedded (audio or video).
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        canEmbed: function( attachment ) {
+                // If uploading, we know the filename but not the mime type.
+                if ( ! attachment.get('uploading') ) {
+                        var type = attachment.get('type');
+                        if ( type !== 'audio' && type !== 'video' ) {
+                                return false;
+                        }
+                }
+
+                return _.contains( wp.media.view.settings.embedExts, attachment.get('filename').split('.').pop() );
+        },
+
+
+        /**
+         * If the state is active, no items are selected, and the current
+         * content mode is not an option in the state's router (provided
+         * the state has a router), reset the content mode to the default.
+         *
+         * @since 3.5.0
+         */
+        refreshContent: function() {
+                var selection = this.get('selection'),
+                        frame = this.frame,
+                        router = frame.router.get(),
+                        mode = frame.content.mode();
+
+                if ( this.active && ! selection.length && router && ! router.get( mode ) ) {
+                        this.frame.content.render( this.get('content') );
+                }
+        },
+
+        /**
+         * Callback handler when an attachment is uploaded.
+         *
+         * Switch to the Media Library if uploaded from the 'Upload Files' tab.
+         *
+         * Adds any uploading attachments to the selection.
+         *
+         * If the state only supports one attachment to be selected and multiple
+         * attachments are uploaded, the last attachment in the upload queue will
+         * be selected.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         */
+        uploading: function( attachment ) {
+                var content = this.frame.content;
+
+                if ( 'upload' === content.mode() ) {
+                        this.frame.content.mode('browse');
+                }
+
+                if ( this.get( 'autoSelect' ) ) {
+                        this.get('selection').add( attachment );
+                        this.frame.trigger( 'library:selection:add' );
+                }
+        },
+
+        /**
+         * Persist the mode of the content region as a user setting.
+         *
+         * @since 3.5.0
+         */
+        saveContentMode: function() {
+                if ( 'browse' !== this.get('router') ) {
+                        return;
+                }
+
+                var mode = this.frame.content.mode(),
+                        view = this.frame.router.get();
+
+                if ( view && view.get( mode ) ) {
+                        setUserSetting( 'libraryContent', mode );
+                }
+        }
+});
+
+// Make selectionSync available on any Media Library state.
+_.extend( Library.prototype, selectionSync );
+
+module.exports = Library;
+},{"../models/selection.js":11,"../utils/selection-sync.js":13,"./state.js":6}],4:[function(require,module,exports){
+/**
+ * wp.media.controller.Region
+ *
+ * A region is a persistent application layout area.
+ *
+ * A region assumes one mode at any time, and can be switched to another.
+ *
+ * When mode changes, events are triggered on the region's parent view.
+ * The parent view will listen to specific events and fill the region with an
+ * appropriate view depending on mode. For example, a frame listens for the
+ * 'browse' mode t be activated on the 'content' view and then fills the region
+ * with an AttachmentsBrowser view.
+ *
+ * @class
+ *
+ * @param {object}        options          Options hash for the region.
+ * @param {string}        options.id       Unique identifier for the region.
+ * @param {Backbone.View} options.view     A parent view the region exists within.
+ * @param {string}        options.selector jQuery selector for the region within the parent view.
+ */
+var Region = function( options ) {
+        _.extend( this, _.pick( options || {}, 'id', 'view', 'selector' ) );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+Region.extend = Backbone.Model.extend;
+
+_.extend( Region.prototype, {
+        /**
+         * Activate a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:activate:{this._mode}
+         * @fires this.view#{this.id}:activate
+         * @fires this.view#{this.id}:deactivate:{this._mode}
+         * @fires this.view#{this.id}:deactivate
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        mode: function( mode ) {
+                if ( ! mode ) {
+                        return this._mode;
+                }
+                // Bail if we're trying to change to the current mode.
+                if ( mode === this._mode ) {
+                        return this;
+                }
+
+                /**
+                 * Region mode deactivation event.
+                 *
+                 * @event this.view#{this.id}:deactivate:{this._mode}
+                 * @event this.view#{this.id}:deactivate
+                 */
+                this.trigger('deactivate');
+
+                this._mode = mode;
+                this.render( mode );
+
+                /**
+                 * Region mode activation event.
+                 *
+                 * @event this.view#{this.id}:activate:{this._mode}
+                 * @event this.view#{this.id}:activate
+                 */
+                this.trigger('activate');
+                return this;
+        },
+        /**
+         * Render a mode.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} mode
+         *
+         * @fires this.view#{this.id}:create:{this._mode}
+         * @fires this.view#{this.id}:create
+         * @fires this.view#{this.id}:render:{this._mode}
+         * @fires this.view#{this.id}:render
+         *
+         * @returns {wp.media.controller.Region} Returns itself to allow chaining
+         */
+        render: function( mode ) {
+                // If the mode isn't active, activate it.
+                if ( mode && mode !== this._mode ) {
+                        return this.mode( mode );
+                }
+
+                var set = { view: null },
+                        view;
+
+                /**
+                 * Create region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'create', set );
+                view = set.view;
+
+                /**
+                 * Render region view event.
+                 *
+                 * Region view creation takes place in an event callback on the frame.
+                 *
+                 * @event this.view#{this.id}:create:{this._mode}
+                 * @event this.view#{this.id}:create
+                 */
+                this.trigger( 'render', view );
+                if ( view ) {
+                        this.set( view );
+                }
+                return this;
+        },
+
+        /**
+         * Get the region's view.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.View}
+         */
+        get: function() {
+                return this.view.views.first( this.selector );
+        },
+
+        /**
+         * Set the region's view as a subview of the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {Array|Object} views
+         * @param {Object} [options={}]
+         * @returns {wp.Backbone.Subviews} Subviews is returned to allow chaining
+         */
+        set: function( views, options ) {
+                if ( options ) {
+                        options.add = false;
+                }
+                return this.view.views.set( this.selector, views, options );
+        },
+
+        /**
+         * Trigger regional view events on the frame.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} event
+         * @returns {undefined|wp.media.controller.Region} Returns itself to allow chaining.
+         */
+        trigger: function( event ) {
+                var base, args;
+
+                if ( ! this._mode ) {
+                        return;
+                }
+
+                args = _.toArray( arguments );
+                base = this.id + ':' + event;
+
+                // Trigger `{this.id}:{event}:{this._mode}` event on the frame.
+                args[0] = base + ':' + this._mode;
+                this.view.trigger.apply( this.view, args );
+
+                // Trigger `{this.id}:{event}` event on the frame.
+                args[0] = base;
+                this.view.trigger.apply( this.view, args );
+                return this;
+        }
+});
+
+module.exports = Region;
+},{}],5:[function(require,module,exports){
+/**
+ * wp.media.controller.StateMachine
+ *
+ * A state machine keeps track of state. It is in one state at a time,
+ * and can change from one state to another.
+ *
+ * States are stored as models in a Backbone collection.
+ *
+ * @since 3.5.0
+ *
+ * @class
+ * @augments Backbone.Model
+ * @mixin
+ * @mixes Backbone.Events
+ *
+ * @param {Array} states
+ */
+var StateMachine = function( states ) {
+        // @todo This is dead code. The states collection gets created in media.view.Frame._createStates.
+        this.states = new Backbone.Collection( states );
+};
+
+// Use Backbone's self-propagating `extend` inheritance method.
+StateMachine.extend = Backbone.Model.extend;
+
+_.extend( StateMachine.prototype, Backbone.Events, {
+        /**
+         * Fetch a state.
+         *
+         * If no `id` is provided, returns the active state.
+         *
+         * Implicitly creates states.
+         *
+         * Ensure that the `states` collection exists so the `StateMachine`
+         *   can be used as a mixin.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         * @returns {wp.media.controller.State} Returns a State model
+         *   from the StateMachine collection
+         */
+        state: function( id ) {
+                this.states = this.states || new Backbone.Collection();
+
+                // Default to the active state.
+                id = id || this._state;
+
+                if ( id && ! this.states.get( id ) ) {
+                        this.states.add({ id: id });
+                }
+                return this.states.get( id );
+        },
+
+        /**
+         * Sets the active state.
+         *
+         * Bail if we're trying to select the current state, if we haven't
+         * created the `states` collection, or are trying to select a state
+         * that does not exist.
+         *
+         * @since 3.5.0
+         *
+         * @param {string} id
+         *
+         * @fires wp.media.controller.State#deactivate
+         * @fires wp.media.controller.State#activate
+         *
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining
+         */
+        setState: function( id ) {
+                var previous = this.state();
+
+                if ( ( previous && id === previous.id ) || ! this.states || ! this.states.get( id ) ) {
+                        return this;
+                }
+
+                if ( previous ) {
+                        previous.trigger('deactivate');
+                        this._lastState = previous.id;
+                }
+
+                this._state = id;
+                this.state().trigger('activate');
+
+                return this;
+        },
+
+        /**
+         * Returns the previous active state.
+         *
+         * Call the `state()` method with no parameters to retrieve the current
+         * active state.
+         *
+         * @since 3.5.0
+         *
+         * @returns {wp.media.controller.State} Returns a State model
+         *    from the StateMachine collection
+         */
+        lastState: function() {
+                if ( this._lastState ) {
+                        return this.state( this._lastState );
+                }
+        }
+});
+
+// Map all event binding and triggering on a StateMachine to its `states` collection.
+_.each([ 'on', 'off', 'trigger' ], function( method ) {
+        /**
+         * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.
+         */
+        StateMachine.prototype[ method ] = function() {
+                // Ensure that the `states` collection exists so the `StateMachine`
+                // can be used as a mixin.
+                this.states = this.states || new Backbone.Collection();
+                // Forward the method to the `states` collection.
+                this.states[ method ].apply( this.states, arguments );
+                return this;
+        };
+});
+
+module.exports = StateMachine;
+},{}],6:[function(require,module,exports){
+/**
+ * wp.media.controller.State
+ *
+ * A state is a step in a workflow that when set will trigger the controllers
+ * for the regions to be updated as specified in the frame.
+ *
+ * A state has an event-driven lifecycle:
+ *
+ *     'ready'      triggers when a state is added to a state machine's collection.
+ *     'activate'   triggers when a state is activated by a state machine.
+ *     'deactivate' triggers when a state is deactivated by a state machine.
+ *     'reset'      is not triggered automatically. It should be invoked by the
+ *                  proper controller to reset the state to its default.
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var State = Backbone.Model.extend({
+        /**
+         * Constructor.
+         *
+         * @since 3.5.0
+         */
+        constructor: function() {
+                this.on( 'activate', this._preActivate, this );
+                this.on( 'activate', this.activate, this );
+                this.on( 'activate', this._postActivate, this );
+                this.on( 'deactivate', this._deactivate, this );
+                this.on( 'deactivate', this.deactivate, this );
+                this.on( 'reset', this.reset, this );
+                this.on( 'ready', this._ready, this );
+                this.on( 'ready', this.ready, this );
+                /**
+                 * Call parent constructor with passed arguments
+                 */
+                Backbone.Model.apply( this, arguments );
+                this.on( 'change:menu', this._updateMenu, this );
+        },
+        /**
+         * Ready event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        ready: function() {},
+
+        /**
+         * Activate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        activate: function() {},
+
+        /**
+         * Deactivate event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        deactivate: function() {},
+
+        /**
+         * Reset event callback.
+         *
+         * @abstract
+         * @since 3.5.0
+         */
+        reset: function() {},
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _ready: function() {
+                this._updateMenu();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+        */
+        _preActivate: function() {
+                this.active = true;
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _postActivate: function() {
+                this.on( 'change:menu', this._menu, this );
+                this.on( 'change:titleMode', this._title, this );
+                this.on( 'change:content', this._content, this );
+                this.on( 'change:toolbar', this._toolbar, this );
+
+                this.frame.on( 'title:render:default', this._renderTitle, this );
+
+                this._title();
+                this._menu();
+                this._toolbar();
+                this._content();
+                this._router();
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _deactivate: function() {
+                this.active = false;
+
+                this.frame.off( 'title:render:default', this._renderTitle, this );
+
+                this.off( 'change:menu', this._menu, this );
+                this.off( 'change:titleMode', this._title, this );
+                this.off( 'change:content', this._content, this );
+                this.off( 'change:toolbar', this._toolbar, this );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _title: function() {
+                this.frame.title.render( this.get('titleMode') || 'default' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _renderTitle: function( view ) {
+                view.$el.text( this.get('title') || '' );
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _router: function() {
+                var router = this.frame.router,
+                        mode = this.get('router'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-router', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                this.frame.router.render( mode );
+
+                view = router.get();
+                if ( view && view.select ) {
+                        view.select( this.frame.content.mode() );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _menu: function() {
+                var menu = this.frame.menu,
+                        mode = this.get('menu'),
+                        view;
+
+                this.frame.$el.toggleClass( 'hide-menu', ! mode );
+                if ( ! mode ) {
+                        return;
+                }
+
+                menu.mode( mode );
+
+                view = menu.get();
+                if ( view && view.select ) {
+                        view.select( this.id );
+                }
+        },
+
+        /**
+         * @access private
+         * @since 3.5.0
+         */
+        _updateMenu: function() {
+                var previous = this.previous('menu'),
+                        menu = this.get('menu');
+
+                if ( previous ) {
+                        this.frame.off( 'menu:render:' + previous, this._renderMenu, this );
+                }
+
+                if ( menu ) {
+                        this.frame.on( 'menu:render:' + menu, this._renderMenu, this );
+                }
+        },
+
+        /**
+         * Create a view in the media menu for the state.
+         *
+         * @access private
+         * @since 3.5.0
+         *
+         * @param {media.view.Menu} view The menu view.
+         */
+        _renderMenu: function( view ) {
+                var menuItem = this.get('menuItem'),
+                        title = this.get('title'),
+                        priority = this.get('priority');
+
+                if ( ! menuItem && title ) {
+                        menuItem = { text: title };
+
+                        if ( priority ) {
+                                menuItem.priority = priority;
+                        }
+                }
+
+                if ( ! menuItem ) {
+                        return;
+                }
+
+                view.set( this.id, menuItem );
+        }
+});
+
+_.each(['toolbar','content'], function( region ) {
+        /**
+         * @access private
+         */
+        State.prototype[ '_' + region ] = function() {
+                var mode = this.get( region );
+                if ( mode ) {
+                        this.frame[ region ].render( mode );
+                }
+        };
+});
+
+module.exports = State;
+},{}],7:[function(require,module,exports){
+/* global _wpMediaViewsL10n, MediaElementPlayer, _wpMediaGridSettings */
+(function($, _, Backbone, wp) {
+        var media = wp.media;
+
+        media.controller.EditAttachmentMetadata = require( './controllers/edit-attachment-metadata.js' );
+        media.view.MediaFrame.Manage = require( './views/frame/manage.js' );
+        media.view.Attachment.Details.TwoColumn = require( './views/attachment/details-two-column.js' );
+        media.view.MediaFrame.Manage.Router = require( './router/manage.js' );
+        media.view.EditImage.Details = require( './views/edit-image-details.js' );
+        media.view.MediaFrame.EditAttachments = require( './views/frame/edit-attachments.js' );
+        media.view.SelectModeToggleButton = require( './views/button/select-mode-toggle.js' );
+        media.view.DeleteSelectedButton = require( './views/button/delete-selected.js' );
+        media.view.DeleteSelectedPermanentlyButton = require( './views/button/delete-selected-permanently.js' );
+
+}(jQuery, _, Backbone, wp));
+
+},{"./controllers/edit-attachment-metadata.js":1,"./router/manage.js":12,"./views/attachment/details-two-column.js":20,"./views/button/delete-selected-permanently.js":26,"./views/button/delete-selected.js":27,"./views/button/select-mode-toggle.js":28,"./views/edit-image-details.js":29,"./views/frame/edit-attachments.js":33,"./views/frame/manage.js":34}],8:[function(require,module,exports){
+/**
+ * wp.media.model.Attachment
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var $ = jQuery,
+        Attachment;
+
+Attachment = Backbone.Model.extend({
+        /**
+         * Triggered when attachment details change
+         * Overrides Backbone.Model.sync
+         *
+         * @param {string} method
+         * @param {wp.media.model.Attachment} model
+         * @param {Object} [options={}]
+         *
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                // If the attachment does not yet have an `id`, return an instantly
+                // rejected promise. Otherwise, all of our requests will fail.
+                if ( _.isUndefined( this.id ) ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                // Overload the `read` request so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action: 'get-attachment',
+                                id: this.id
+                        });
+                        return wp.media.ajax( options );
+
+                // Overload the `update` request so properties can be saved.
+                } else if ( 'update' === method ) {
+                        // If we do not have the necessary nonce, fail immeditately.
+                        if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                                return $.Deferred().rejectWith( this ).promise();
+                        }
+
+                        options = options || {};
+                        options.context = this;
+
+                        // Set the action and ID.
+                        options.data = _.extend( options.data || {}, {
+                                action:  'save-attachment',
+                                id:      this.id,
+                                nonce:   this.get('nonces').update,
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Record the values of the changed attributes.
+                        if ( model.hasChanged() ) {
+                                options.data.changes = {};
+
+                                _.each( model.changed, function( value, key ) {
+                                        options.data.changes[ key ] = this.get( key );
+                                }, this );
+                        }
+
+                        return wp.media.ajax( options );
+
+                // Overload the `delete` request so attachments can be removed.
+                // This will permanently delete an attachment.
+                } else if ( 'delete' === method ) {
+                        options = options || {};
+
+                        if ( ! options.wait ) {
+                                this.destroyed = true;
+                        }
+
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:   'delete-post',
+                                id:       this.id,
+                                _wpnonce: this.get('nonces')['delete']
+                        });
+
+                        return wp.media.ajax( options ).done( function() {
+                                this.destroyed = true;
+                        }).fail( function() {
+                                this.destroyed = false;
+                        });
+
+                // Otherwise, fall back to `Backbone.sync()`.
+                } else {
+                        /**
+                         * Call `sync` directly on Backbone.Model
+                         */
+                        return Backbone.Model.prototype.sync.apply( this, arguments );
+                }
+        },
+        /**
+         * Convert date strings into Date objects.
+         *
+         * @param {Object} resp The raw response object, typically returned by fetch()
+         * @returns {Object} The modified response object, which is the attributes hash
+         *    to be set on the model.
+         */
+        parse: function( resp ) {
+                if ( ! resp ) {
+                        return resp;
+                }
+
+                resp.date = new Date( resp.date );
+                resp.modified = new Date( resp.modified );
+                return resp;
+        },
+        /**
+         * @param {Object} data The properties to be saved.
+         * @param {Object} options Sync options. e.g. patch, wait, success, error.
+         *
+         * @this Backbone.Model
+         *
+         * @returns {Promise}
+         */
+        saveCompat: function( data, options ) {
+                var model = this;
+
+                // If we do not have the necessary nonce, fail immeditately.
+                if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                return media.post( 'save-attachment-compat', _.defaults({
+                        id:      this.id,
+                        nonce:   this.get('nonces').update,
+                        post_id: wp.media.model.settings.post.id
+                }, data ) ).done( function( resp, status, xhr ) {
+                        model.set( model.parse( resp, xhr ), options );
+                });
+        }
+}, {
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * @static
+         * @param {Object} attrs
+         * @returns {wp.media.model.Attachment}
+         */
+        create: function( attrs ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attrs );
+        },
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * If this function has already been called for the id,
+         * it returns the specified attachment.
+         *
+         * @static
+         * @param {string} id A string used to identify a model.
+         * @param {Backbone.Model|undefined} attachment
+         * @returns {wp.media.model.Attachment}
+         */
+        get: _.memoize( function( id, attachment ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attachment || { id: id } );
+        })
+});
+
+module.exports = Attachment;
+},{"./attachments.js":9}],9:[function(require,module,exports){
+/**
+ * wp.media.model.Attachments
+ *
+ * A collection of attachments.
+ *
+ * This collection has no persistence with the server without supplying
+ * 'options.props.query = true', which will mirror the collection
+ * to an Attachments Query collection - @see wp.media.model.Attachments.mirror().
+ *
+ * @class
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                Models to initialize with the collection.
+ * @param {object} [options]               Options hash for the collection.
+ * @param {string} [options.props]         Options hash for the initial query properties.
+ * @param {string} [options.props.order]   Initial order (ASC or DESC) for the collection.
+ * @param {string} [options.props.orderby] Initial attribute key to order the collection by.
+ * @param {string} [options.props.query]   Whether the collection is linked to an attachments query.
+ * @param {string} [options.observe]
+ * @param {string} [options.filters]
+ *
+ */
+var Attachment = require( './attachment.js' ),
+        Attachments;
+
+Attachments = Backbone.Collection.extend({
+        /**
+         * @type {wp.media.model.Attachment}
+         */
+        model: Attachment,
+        /**
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                options = options || {};
+
+                this.props   = new Backbone.Model();
+                this.filters = options.filters || {};
+
+                // Bind default `change` events to the `props` model.
+                this.props.on( 'change', this._changeFilteredProps, this );
+
+                this.props.on( 'change:order',   this._changeOrder,   this );
+                this.props.on( 'change:orderby', this._changeOrderby, this );
+                this.props.on( 'change:query',   this._changeQuery,   this );
+
+                this.props.set( _.defaults( options.props || {} ) );
+
+                if ( options.observe ) {
+                        this.observe( options.observe );
+                }
+        },
+        /**
+         * Sort the collection when the order attribute changes.
+         *
+         * @access private
+         */
+        _changeOrder: function() {
+                if ( this.comparator ) {
+                        this.sort();
+                }
+        },
+        /**
+         * Set the default comparator only when the `orderby` property is set.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {string} orderby
+         */
+        _changeOrderby: function( model, orderby ) {
+                // If a different comparator is defined, bail.
+                if ( this.comparator && this.comparator !== Attachments.comparator ) {
+                        return;
+                }
+
+                if ( orderby && 'post__in' !== orderby ) {
+                        this.comparator = Attachments.comparator;
+                } else {
+                        delete this.comparator;
+                }
+        },
+        /**
+         * If the `query` property is set to true, query the server using
+         * the `props` values, and sync the results to this collection.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {Boolean} query
+         */
+        _changeQuery: function( model, query ) {
+                if ( query ) {
+                        this.props.on( 'change', this._requery, this );
+                        this._requery();
+                } else {
+                        this.props.off( 'change', this._requery, this );
+                }
+        },
+        /**
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         */
+        _changeFilteredProps: function( model ) {
+                // If this is a query, updating the collection will be handled by
+                // `this._requery()`.
+                if ( this.props.get('query') ) {
+                        return;
+                }
+
+                var changed = _.chain( model.changed ).map( function( t, prop ) {
+                        var filter = Attachments.filters[ prop ],
+                                term = model.get( prop );
+
+                        if ( ! filter ) {
+                                return;
+                        }
+
+                        if ( term && ! this.filters[ prop ] ) {
+                                this.filters[ prop ] = filter;
+                        } else if ( ! term && this.filters[ prop ] === filter ) {
+                                delete this.filters[ prop ];
+                        } else {
+                                return;
+                        }
+
+                        // Record the change.
+                        return true;
+                }, this ).any().value();
+
+                if ( ! changed ) {
+                        return;
+                }
+
+                // If no `Attachments` model is provided to source the searches
+                // from, then automatically generate a source from the existing
+                // models.
+                if ( ! this._source ) {
+                        this._source = new Attachments( this.models );
+                }
+
+                this.reset( this._source.filter( this.validator, this ) );
+        },
+
+        validateDestroyed: false,
+        /**
+         * Checks whether an attachment is valid.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        validator: function( attachment ) {
+                if ( ! this.validateDestroyed && attachment.destroyed ) {
+                        return false;
+                }
+                return _.all( this.filters, function( filter ) {
+                        return !! filter.call( this, attachment );
+                }, this );
+        },
+        /**
+         * Add or remove an attachment to the collection depending on its validity.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validate: function( attachment, options ) {
+                var valid = this.validator( attachment ),
+                        hasAttachment = !! this.get( attachment.cid );
+
+                if ( ! valid && hasAttachment ) {
+                        this.remove( attachment, options );
+                } else if ( valid && ! hasAttachment ) {
+                        this.add( attachment, options );
+                }
+
+                return this;
+        },
+
+        /**
+         * Add or remove all attachments from another collection depending on each one's validity.
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {object} [options={}]
+         *
+         * @fires wp.media.model.Attachments#reset
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validateAll: function( attachments, options ) {
+                options = options || {};
+
+                _.each( attachments.models, function( attachment ) {
+                        this.validate( attachment, { silent: true });
+                }, this );
+
+                if ( ! options.silent ) {
+                        this.trigger( 'reset', this, options );
+                }
+                return this;
+        },
+        /**
+         * Start observing another attachments collection change events
+         * and replicate them on this collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to observe.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining.
+         */
+        observe: function( attachments ) {
+                this.observers = this.observers || [];
+                this.observers.push( attachments );
+
+                attachments.on( 'add change remove', this._validateHandler, this );
+                attachments.on( 'reset', this._validateAllHandler, this );
+                this.validateAll( attachments );
+                return this;
+        },
+        /**
+         * Stop replicating collection change events from another attachments collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to stop observing.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        unobserve: function( attachments ) {
+                if ( attachments ) {
+                        attachments.off( null, null, this );
+                        this.observers = _.without( this.observers, attachments );
+
+                } else {
+                        _.each( this.observers, function( attachments ) {
+                                attachments.off( null, null, this );
+                        }, this );
+                        delete this.observers;
+                }
+
+                return this;
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachment
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateHandler: function( attachment, attachments, options ) {
+                // If we're not mirroring this `attachments` collection,
+                // only retain the `silent` option.
+                options = attachments === this.mirroring ? options : {
+                        silent: options && options.silent
+                };
+
+                return this.validate( attachment, options );
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateAllHandler: function( attachments, options ) {
+                return this.validateAll( attachments, options );
+        },
+        /**
+         * Start mirroring another attachments collection, clearing out any models already
+         * in the collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to mirror.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        mirror: function( attachments ) {
+                if ( this.mirroring && this.mirroring === attachments ) {
+                        return this;
+                }
+
+                this.unmirror();
+                this.mirroring = attachments;
+
+                // Clear the collection silently. A `reset` event will be fired
+                // when `observe()` calls `validateAll()`.
+                this.reset( [], { silent: true } );
+                this.observe( attachments );
+
+                return this;
+        },
+        /**
+         * Stop mirroring another attachments collection.
+         */
+        unmirror: function() {
+                if ( ! this.mirroring ) {
+                        return;
+                }
+
+                this.unobserve( this.mirroring );
+                delete this.mirroring;
+        },
+        /**
+         * Retrive more attachments from the server for the collection.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `more` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @param {object} options
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var deferred = jQuery.Deferred(),
+                        mirroring = this.mirroring,
+                        attachments = this;
+
+                if ( ! mirroring || ! mirroring.more ) {
+                        return deferred.resolveWith( this ).promise();
+                }
+                // If we're mirroring another collection, forward `more` to
+                // the mirrored collection. Account for a race condition by
+                // checking if we're still mirroring that collection when
+                // the request resolves.
+                mirroring.more( options ).done( function() {
+                        if ( this === attachments.mirroring )
+                                deferred.resolveWith( this );
+                });
+
+                return deferred.promise();
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `hasMore` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this.mirroring ? this.mirroring.hasMore() : false;
+        },
+        /**
+         * A custom AJAX-response parser.
+         *
+         * See trac ticket #24753
+         *
+         * @param {Object|Array} resp The raw response Object/Array.
+         * @param {Object} xhr
+         * @returns {Array} The array of model attributes to be added to the collection
+         */
+        parse: function( resp, xhr ) {
+                if ( ! _.isArray( resp ) ) {
+                        resp = [resp];
+                }
+
+                return _.map( resp, function( attrs ) {
+                        var id, attachment, newAttributes;
+
+                        if ( attrs instanceof Backbone.Model ) {
+                                id = attrs.get( 'id' );
+                                attrs = attrs.attributes;
+                        } else {
+                                id = attrs.id;
+                        }
+
+                        attachment = Attachment.get( id );
+                        newAttributes = attachment.parse( attrs, xhr );
+
+                        if ( ! _.isEqual( attachment.attributes, newAttributes ) ) {
+                                attachment.set( newAttributes );
+                        }
+
+                        return attachment;
+                });
+        },
+        /**
+         * If the collection is a query, create and mirror an Attachments Query collection.
+         *
+         * @access private
+         */
+        _requery: function( refresh ) {
+                var props, Query;
+                if ( this.props.get('query') ) {
+                        Query = require( './query.js' );
+                        props = this.props.toJSON();
+                        props.cache = ( true !== refresh );
+                        this.mirror( Query.get( props ) );
+                }
+        },
+        /**
+         * If this collection is sorted by `menuOrder`, recalculates and saves
+         * the menu order to the database.
+         *
+         * @returns {undefined|Promise}
+         */
+        saveMenuOrder: function() {
+                if ( 'menuOrder' !== this.props.get('orderby') ) {
+                        return;
+                }
+
+                // Removes any uploading attachments, updates each attachment's
+                // menu order, and returns an object with an { id: menuOrder }
+                // mapping to pass to the request.
+                var attachments = this.chain().filter( function( attachment ) {
+                        return ! _.isUndefined( attachment.id );
+                }).map( function( attachment, index ) {
+                        // Indices start at 1.
+                        index = index + 1;
+                        attachment.set( 'menuOrder', index );
+                        return [ attachment.id, index ];
+                }).object().value();
+
+                if ( _.isEmpty( attachments ) ) {
+                        return;
+                }
+
+                return wp.media.post( 'save-attachment-order', {
+                        nonce:       wp.media.model.settings.post.nonce,
+                        post_id:     wp.media.model.settings.post.id,
+                        attachments: attachments
+                });
+        }
+}, {
+        /**
+         * A function to compare two attachment models in an attachments collection.
+         *
+         * Used as the default comparator for instances of wp.media.model.Attachments
+         * and its subclasses. @see wp.media.model.Attachments._changeOrderby().
+         *
+         * @static
+         *
+         * @param {Backbone.Model} a
+         * @param {Backbone.Model} b
+         * @param {Object} options
+         * @returns {Number} -1 if the first model should come before the second,
+         *    0 if they are of the same rank and
+         *    1 if the first model should come after.
+         */
+        comparator: function( a, b, options ) {
+                var key   = this.props.get('orderby'),
+                        order = this.props.get('order') || 'DESC',
+                        ac    = a.cid,
+                        bc    = b.cid;
+
+                a = a.get( key );
+                b = b.get( key );
+
+                if ( 'date' === key || 'modified' === key ) {
+                        a = a || new Date();
+                        b = b || new Date();
+                }
+
+                // If `options.ties` is set, don't enforce the `cid` tiebreaker.
+                if ( options && options.ties ) {
+                        ac = bc = null;
+                }
+
+                return ( 'DESC' === order ) ? wp.media.compare( a, b, ac, bc ) : wp.media.compare( b, a, bc, ac );
+        },
+        /**
+         * @namespace
+         */
+        filters: {
+                /**
+                 * @static
+                 * Note that this client-side searching is *not* equivalent
+                 * to our server-side searching.
+                 *
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                search: function( attachment ) {
+                        if ( ! this.props.get('search') ) {
+                                return true;
+                        }
+
+                        return _.any(['title','filename','description','caption','name'], function( key ) {
+                                var value = attachment.get( key );
+                                return value && -1 !== value.search( this.props.get('search') );
+                        }, this );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                type: function( attachment ) {
+                        var type = this.props.get('type');
+                        return ! type || -1 !== type.indexOf( attachment.get('type') );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                uploadedTo: function( attachment ) {
+                        var uploadedTo = this.props.get('uploadedTo');
+                        if ( _.isUndefined( uploadedTo ) ) {
+                                return true;
+                        }
+
+                        return uploadedTo === attachment.get('uploadedTo');
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                status: function( attachment ) {
+                        var status = this.props.get('status');
+                        if ( _.isUndefined( status ) ) {
+                                return true;
+                        }
+
+                        return status === attachment.get('status');
+                }
+        }
+});
+
+module.exports = Attachments;
+},{"./attachment.js":8,"./query.js":10}],10:[function(require,module,exports){
+/**
+ * wp.media.model.Query
+ *
+ * A collection of attachments that match the supplied query arguments.
+ *
+ * Note: Do NOT change this.args after the query has been initialized.
+ *       Things will break.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                      Models to initialize with the collection.
+ * @param {object} [options]                     Options hash.
+ * @param {object} [options.args]                Attachments query arguments.
+ * @param {object} [options.args.posts_per_page]
+ */
+var Attachments = require( './attachments.js' ),
+        Query;
+
+Query = Attachments.extend({
+        /**
+         * @global wp.Uploader
+         *
+         * @param {array}  [models=[]]  Array of initial models to populate the collection.
+         * @param {object} [options={}]
+         */
+        initialize: function( models, options ) {
+                var allowed;
+
+                options = options || {};
+                Attachments.prototype.initialize.apply( this, arguments );
+
+                this.args     = options.args;
+                this._hasMore = true;
+                this.created  = new Date();
+
+                this.filters.order = function( attachment ) {
+                        var orderby = this.props.get('orderby'),
+                                order = this.props.get('order');
+
+                        if ( ! this.comparator ) {
+                                return true;
+                        }
+
+                        // We want any items that can be placed before the last
+                        // item in the set. If we add any items after the last
+                        // item, then we can't guarantee the set is complete.
+                        if ( this.length ) {
+                                return 1 !== this.comparator( attachment, this.last(), { ties: true });
+
+                        // Handle the case where there are no items yet and
+                        // we're sorting for recent items. In that case, we want
+                        // changes that occurred after we created the query.
+                        } else if ( 'DESC' === order && ( 'date' === orderby || 'modified' === orderby ) ) {
+                                return attachment.get( orderby ) >= this.created;
+
+                        // If we're sorting by menu order and we have no items,
+                        // accept any items that have the default menu order (0).
+                        } else if ( 'ASC' === order && 'menuOrder' === orderby ) {
+                                return attachment.get( orderby ) === 0;
+                        }
+
+                        // Otherwise, we don't want any items yet.
+                        return false;
+                };
+
+                // Observe the central `wp.Uploader.queue` collection to watch for
+                // new matches for the query.
+                //
+                // Only observe when a limited number of query args are set. There
+                // are no filters for other properties, so observing will result in
+                // false positives in those queries.
+                allowed = [ 's', 'order', 'orderby', 'posts_per_page', 'post_mime_type', 'post_parent' ];
+                if ( wp.Uploader && _( this.args ).chain().keys().difference( allowed ).isEmpty().value() ) {
+                        this.observe( wp.Uploader.queue );
+                }
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this._hasMore;
+        },
+        /**
+         * Fetch more attachments from the server for the collection.
+         *
+         * @param   {object}  [options={}]
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var query = this;
+
+                // If there is already a request pending, return early with the Deferred object.
+                if ( this._more && 'pending' === this._more.state() ) {
+                        return this._more;
+                }
+
+                if ( ! this.hasMore() ) {
+                        return jQuery.Deferred().resolveWith( this ).promise();
+                }
+
+                options = options || {};
+                options.remove = false;
+
+                return this._more = this.fetch( options ).done( function( resp ) {
+                        if ( _.isEmpty( resp ) || -1 === this.args.posts_per_page || resp.length < this.args.posts_per_page ) {
+                                query._hasMore = false;
+                        }
+                });
+        },
+        /**
+         * Overrides Backbone.Collection.sync
+         * Overrides wp.media.model.Attachments.sync
+         *
+         * @param {String} method
+         * @param {Backbone.Model} model
+         * @param {Object} [options={}]
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                var args, fallback;
+
+                // Overload the read method so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:  'query-attachments',
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Clone the args so manipulation is non-destructive.
+                        args = _.clone( this.args );
+
+                        // Determine which page to query.
+                        if ( -1 !== args.posts_per_page ) {
+                                args.paged = Math.floor( this.length / args.posts_per_page ) + 1;
+                        }
+
+                        options.data.query = args;
+                        return wp.media.ajax( options );
+
+                // Otherwise, fall back to Backbone.sync()
+                } else {
+                        /**
+                         * Call wp.media.model.Attachments.sync or Backbone.sync
+                         */
+                        fallback = Attachments.prototype.sync ? Attachments.prototype : Backbone;
+                        return fallback.sync.apply( this, arguments );
+                }
+        }
+}, {
+        /**
+         * @readonly
+         */
+        defaultProps: {
+                orderby: 'date',
+                order:   'DESC'
+        },
+        /**
+         * @readonly
+         */
+        defaultArgs: {
+                posts_per_page: 40
+        },
+        /**
+         * @readonly
+         */
+        orderby: {
+                allowed:  [ 'name', 'author', 'date', 'title', 'modified', 'uploadedTo', 'id', 'post__in', 'menuOrder' ],
+                /**
+                 * A map of JavaScript orderby values to their WP_Query equivalents.
+                 * @type {Object}
+                 */
+                valuemap: {
+                        'id':         'ID',
+                        'uploadedTo': 'parent',
+                        'menuOrder':  'menu_order ID'
+                }
+        },
+        /**
+         * A map of JavaScript query properties to their WP_Query equivalents.
+         *
+         * @readonly
+         */
+        propmap: {
+                'search':    's',
+                'type':      'post_mime_type',
+                'perPage':   'posts_per_page',
+                'menuOrder': 'menu_order',
+                'uploadedTo': 'post_parent',
+                'status':     'post_status',
+                'include':    'post__in',
+                'exclude':    'post__not_in'
+        },
+        /**
+         * Creates and returns an Attachments Query collection given the properties.
+         *
+         * Caches query objects and reuses where possible.
+         *
+         * @static
+         * @method
+         *
+         * @param {object} [props]
+         * @param {Object} [props.cache=true]   Whether to use the query cache or not.
+         * @param {Object} [props.order]
+         * @param {Object} [props.orderby]
+         * @param {Object} [props.include]
+         * @param {Object} [props.exclude]
+         * @param {Object} [props.s]
+         * @param {Object} [props.post_mime_type]
+         * @param {Object} [props.posts_per_page]
+         * @param {Object} [props.menu_order]
+         * @param {Object} [props.post_parent]
+         * @param {Object} [props.post_status]
+         * @param {Object} [options]
+         *
+         * @returns {wp.media.model.Query} A new Attachments Query collection.
+         */
+        get: (function(){
+                /**
+                 * @static
+                 * @type Array
+                 */
+                var queries = [];
+
+                /**
+                 * @returns {Query}
+                 */
+                return function( props, options ) {
+                        var args     = {},
+                                orderby  = Query.orderby,
+                                defaults = Query.defaultProps,
+                                query,
+                                cache    = !! props.cache || _.isUndefined( props.cache );
+
+                        // Remove the `query` property. This isn't linked to a query,
+                        // this *is* the query.
+                        delete props.query;
+                        delete props.cache;
+
+                        // Fill default args.
+                        _.defaults( props, defaults );
+
+                        // Normalize the order.
+                        props.order = props.order.toUpperCase();
+                        if ( 'DESC' !== props.order && 'ASC' !== props.order ) {
+                                props.order = defaults.order.toUpperCase();
+                        }
+
+                        // Ensure we have a valid orderby value.
+                        if ( ! _.contains( orderby.allowed, props.orderby ) ) {
+                                props.orderby = defaults.orderby;
+                        }
+
+                        _.each( [ 'include', 'exclude' ], function( prop ) {
+                                if ( props[ prop ] && ! _.isArray( props[ prop ] ) ) {
+                                        props[ prop ] = [ props[ prop ] ];
+                                }
+                        } );
+
+                        // Generate the query `args` object.
+                        // Correct any differing property names.
+                        _.each( props, function( value, prop ) {
+                                if ( _.isNull( value ) ) {
+                                        return;
+                                }
+
+                                args[ Query.propmap[ prop ] || prop ] = value;
+                        });
+
+                        // Fill any other default query args.
+                        _.defaults( args, Query.defaultArgs );
+
+                        // `props.orderby` does not always map directly to `args.orderby`.
+                        // Substitute exceptions specified in orderby.keymap.
+                        args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;
+
+                        // Search the query cache for a matching query.
+                        if ( cache ) {
+                                query = _.find( queries, function( query ) {
+                                        return _.isEqual( query.args, args );
+                                });
+                        } else {
+                                queries = [];
+                        }
+
+                        // Otherwise, create a new query and add it to the cache.
+                        if ( ! query ) {
+                                query = new Query( [], _.extend( options || {}, {
+                                        props: props,
+                                        args:  args
+                                } ) );
+                                queries.push( query );
+                        }
+
+                        return query;
+                };
+        }())
+});
+
+module.exports = Query;
+},{"./attachments.js":9}],11:[function(require,module,exports){
+/**
+ * wp.media.model.Selection
+ *
+ * A selection of attachments.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ */
+var Attachments = require( './attachments.js' ),
+        Selection;
+
+Selection = Attachments.extend({
+        /**
+         * Refresh the `single` model whenever the selection changes.
+         * Binds `single` instead of using the context argument to ensure
+         * it receives no parameters.
+         *
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                /**
+                 * call 'initialize' directly on the parent class
+                 */
+                Attachments.prototype.initialize.apply( this, arguments );
+                this.multiple = options && options.multiple;
+
+                this.on( 'add remove reset', _.bind( this.single, this, false ) );
+        },
+
+        /**
+         * If the workflow does not support multi-select, clear out the selection
+         * before adding a new attachment to it.
+         *
+         * @param {Array} models
+         * @param {Object} options
+         * @returns {wp.media.model.Attachment[]}
+         */
+        add: function( models, options ) {
+                if ( ! this.multiple ) {
+                        this.remove( this.models );
+                }
+                /**
+                 * call 'add' directly on the parent class
+                 */
+                return Attachments.prototype.add.call( this, models, options );
+        },
+
+        /**
+         * Fired when toggling (clicking on) an attachment in the modal.
+         *
+         * @param {undefined|boolean|wp.media.model.Attachment} model
+         *
+         * @fires wp.media.model.Selection#selection:single
+         * @fires wp.media.model.Selection#selection:unsingle
+         *
+         * @returns {Backbone.Model}
+         */
+        single: function( model ) {
+                var previous = this._single;
+
+                // If a `model` is provided, use it as the single model.
+                if ( model ) {
+                        this._single = model;
+                }
+                // If the single model isn't in the selection, remove it.
+                if ( this._single && ! this.get( this._single.cid ) ) {
+                        delete this._single;
+                }
+
+                this._single = this._single || this.last();
+
+                // If single has changed, fire an event.
+                if ( this._single !== previous ) {
+                        if ( previous ) {
+                                previous.trigger( 'selection:unsingle', previous, this );
+
+                                // If the model was already removed, trigger the collection
+                                // event manually.
+                                if ( ! this.get( previous.cid ) ) {
+                                        this.trigger( 'selection:unsingle', previous, this );
+                                }
+                        }
+                        if ( this._single ) {
+                                this._single.trigger( 'selection:single', this._single, this );
+                        }
+                }
+
+                // Return the single model, or the last model as a fallback.
+                return this._single;
+        }
+});
+
+module.exports = Selection;
+},{"./attachments.js":9}],12:[function(require,module,exports){
+/**
+ * A router for handling the browser history and application state.
+ *
+ * @constructor
+ * @augments Backbone.Router
+ */
+var Router = Backbone.Router.extend({
+        routes: {
+                'upload.php?item=:slug':    'showItem',
+                'upload.php?search=:query': 'search'
+        },
+
+        // Map routes against the page URL
+        baseUrl: function( url ) {
+                return 'upload.php' + url;
+        },
+
+        // Respond to the search route by filling the search field and trigggering the input event
+        search: function( query ) {
+                jQuery( '#media-search-input' ).val( query ).trigger( 'input' );
+        },
+
+        // Show the modal with a specific item
+        showItem: function( query ) {
+                var media = wp.media,
+                        library = media.frame.state().get('library'),
+                        item;
+
+                // Trigger the media frame to open the correct item
+                item = library.findWhere( { id: parseInt( query, 10 ) } );
+                if ( item ) {
+                        media.frame.trigger( 'edit:attachment', item );
+                } else {
+                        item = media.attachment( query );
+                        media.frame.listenTo( item, 'change', function( model ) {
+                                media.frame.stopListening( item );
+                                media.frame.trigger( 'edit:attachment', model );
+                        } );
+                        item.fetch();
+                }
+        }
+});
+
+module.exports = Router;
+},{}],13:[function(require,module,exports){
+/**
+ * wp.media.selectionSync
+ *
+ * Sync an attachments selection in a state with another state.
+ *
+ * Allows for selecting multiple images in the Insert Media workflow, and then
+ * switching to the Insert Gallery workflow while preserving the attachments selection.
+ *
+ * @mixin
+ */
+var selectionSync = {
+        /**
+         * @since 3.5.0
+         */
+        syncSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                // If the selection supports multiple items, validate the stored
+                // attachments based on the new selection's conditions. Record
+                // the attachments that are not included; we'll maintain a
+                // reference to those. Other attachments are considered in flux.
+                if ( selection.multiple ) {
+                        selection.reset( [], { silent: true });
+                        selection.validateAll( manager.attachments );
+                        manager.difference = _.difference( manager.attachments.models, selection.models );
+                }
+
+                // Sync the selection's single item with the master.
+                selection.single( manager.single );
+        },
+
+        /**
+         * Record the currently active attachments, which is a combination
+         * of the selection's attachments and the set of selected
+         * attachments that this specific selection considered invalid.
+         * Reset the difference and record the single attachment.
+         *
+         * @since 3.5.0
+         */
+        recordSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                if ( selection.multiple ) {
+                        manager.attachments.reset( selection.toArray().concat( manager.difference ) );
+                        manager.difference = [];
+                } else {
+                        manager.attachments.add( selection.toArray() );
+                }
+
+                manager.single = selection._single;
+        }
+};
+
+module.exports = selectionSync;
+},{}],14:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentCompat
+ *
+ * A view to display fields added via the `attachment_fields_to_edit` filter.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        AttachmentCompat;
+
+AttachmentCompat = View.extend({
+        tagName:   'form',
+        className: 'compat-item',
+
+        events: {
+                'submit':          'preventDefault',
+                'change input':    'save',
+                'change select':   'save',
+                'change textarea': 'save'
+        },
+
+        initialize: function() {
+                this.model.on( 'change:compat', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.$(':focus').length ) {
+                        this.save();
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        render: function() {
+                var compat = this.model.get('compat');
+                if ( ! compat || ! compat.item ) {
+                        return;
+                }
+
+                this.views.detach();
+                this.$el.html( compat.item );
+                this.views.render();
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {Object} event
+         */
+        save: function( event ) {
+                var data = {};
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                _.each( this.$el.serializeArray(), function( pair ) {
+                        data[ pair.name ] = pair.value;
+                });
+
+                this.controller.trigger( 'attachment:compat:waiting', ['waiting'] );
+                this.model.saveCompat( data ).always( _.bind( this.postSave, this ) );
+        },
+
+        postSave: function() {
+                this.controller.trigger( 'attachment:compat:ready', ['ready'] );
+        }
+});
+
+module.exports = AttachmentCompat;
+},{"./view.js":55}],15:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        AttachmentFilters;
+
+AttachmentFilters = View.extend({
+        tagName:   'select',
+        className: 'attachment-filters',
+        id:        'media-attachment-filters',
+
+        events: {
+                change: 'change'
+        },
+
+        keys: [],
+
+        initialize: function() {
+                this.createFilters();
+                _.extend( this.filters, this.options.filters );
+
+                // Build `<option>` elements.
+                this.$el.html( _.chain( this.filters ).map( function( filter, value ) {
+                        return {
+                                el: $( '<option></option>' ).val( value ).html( filter.text )[0],
+                                priority: filter.priority || 50
+                        };
+                }, this ).sortBy('priority').pluck('el').value() );
+
+                this.model.on( 'change', this.select, this );
+                this.select();
+        },
+
+        /**
+         * @abstract
+         */
+        createFilters: function() {
+                this.filters = {};
+        },
+
+        /**
+         * When the selected filter changes, update the Attachment Query properties to match.
+         */
+        change: function() {
+                var filter = this.filters[ this.el.value ];
+                if ( filter ) {
+                        this.model.set( filter.props );
+                }
+        },
+
+        select: function() {
+                var model = this.model,
+                        value = 'all',
+                        props = model.toJSON();
+
+                _.find( this.filters, function( filter, id ) {
+                        var equal = _.all( filter.props, function( prop, key ) {
+                                return prop === ( _.isUndefined( props[ key ] ) ? null : props[ key ] );
+                        });
+
+                        if ( equal ) {
+                                return value = id;
+                        }
+                });
+
+                this.$el.val( value );
+        }
+});
+
+module.exports = AttachmentFilters;
+},{"./view.js":55}],16:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters.All
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        All;
+
+All = AttachmentFilters.extend({
+        createFilters: function() {
+                var filters = {};
+
+                _.each( wp.media.view.settings.mimeTypes || {}, function( text, key ) {
+                        filters[ key ] = {
+                                text: text,
+                                props: {
+                                        status:  null,
+                                        type:    key,
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                }
+                        };
+                });
+
+                filters.all = {
+                        text:  l10n.allMediaItems,
+                        props: {
+                                status:  null,
+                                type:    null,
+                                uploadedTo: null,
+                                orderby: 'date',
+                                order:   'DESC'
+                        },
+                        priority: 10
+                };
+
+                if ( wp.media.view.settings.post.id ) {
+                        filters.uploaded = {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        status:  null,
+                                        type:    null,
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        };
+                }
+
+                filters.unattached = {
+                        text:  l10n.unattached,
+                        props: {
+                                status:     null,
+                                uploadedTo: 0,
+                                type:       null,
+                                orderby:    'menuOrder',
+                                order:      'ASC'
+                        },
+                        priority: 50
+                };
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        this.controller.isModeActive( 'grid' ) ) {
+
+                        filters.trash = {
+                                text:  l10n.trash,
+                                props: {
+                                        uploadedTo: null,
+                                        status:     'trash',
+                                        type:       null,
+                                        orderby:    'date',
+                                        order:      'DESC'
+                                },
+                                priority: 50
+                        };
+                }
+
+                this.filters = filters;
+        }
+});
+
+module.exports = All;
+},{"../attachment-filters.js":15}],17:[function(require,module,exports){
+/**
+ * A filter dropdown for month/dates.
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        DateFilter;
+
+DateFilter = AttachmentFilters.extend({
+        id: 'media-attachment-date-filters',
+
+        createFilters: function() {
+                var filters = {};
+                _.each( wp.media.view.settings.months || {}, function( value, index ) {
+                        filters[ index ] = {
+                                text: value.text,
+                                props: {
+                                        year: value.year,
+                                        monthnum: value.month
+                                }
+                        };
+                });
+                filters.all = {
+                        text:  l10n.allDates,
+                        props: {
+                                monthnum: false,
+                                year:  false
+                        },
+                        priority: 10
+                };
+                this.filters = filters;
+        }
+});
+
+module.exports = DateFilter;
+},{"../attachment-filters.js":15}],18:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentFilters.Uploaded
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        Uploaded;
+
+Uploaded = AttachmentFilters.extend({
+        createFilters: function() {
+                var type = this.model.get('type'),
+                        types = wp.media.view.settings.mimeTypes,
+                        text;
+
+                if ( types && type ) {
+                        text = types[ type ];
+                }
+
+                this.filters = {
+                        all: {
+                                text:  text || l10n.allMediaItems,
+                                props: {
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                },
+                                priority: 10
+                        },
+
+                        uploaded: {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        },
+
+                        unattached: {
+                                text:  l10n.unattached,
+                                props: {
+                                        uploadedTo: 0,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 50
+                        }
+                };
+        }
+});
+
+module.exports = Uploaded;
+},{"../attachment-filters.js":15}],19:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Attachment;
+
+Attachment = View.extend({
+        tagName:   'li',
+        className: 'attachment',
+        template:  wp.template('attachment'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'role':         'checkbox',
+                        'aria-label':   this.model.get( 'title' ),
+                        'aria-checked': false,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'click .js--select-attachment':   'toggleSelectionHandler',
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .close':                   'removeFromLibrary',
+                'click .check':                   'checkClickHandler',
+                'click a':                        'preventDefault',
+                'keydown .close':                 'removeFromLibrary',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        buttons: {},
+
+        initialize: function() {
+                var selection = this.options.selection,
+                        options = _.defaults( this.options, {
+                                rerenderOnModelChange: true
+                        } );
+
+                if ( options.rerenderOnModelChange ) {
+                        this.model.on( 'change', this.render, this );
+                } else {
+                        this.model.on( 'change:percent', this.progress, this );
+                }
+                this.model.on( 'change:title', this._syncTitle, this );
+                this.model.on( 'change:caption', this._syncCaption, this );
+                this.model.on( 'change:artist', this._syncArtist, this );
+                this.model.on( 'change:album', this._syncAlbum, this );
+
+                // Update the selection.
+                this.model.on( 'add', this.select, this );
+                this.model.on( 'remove', this.deselect, this );
+                if ( selection ) {
+                        selection.on( 'reset', this.updateSelect, this );
+                        // Update the model's details view.
+                        this.model.on( 'selection:single selection:unsingle', this.details, this );
+                        this.details( this.model, this.controller.state().get('selection') );
+                }
+
+                this.listenTo( this.controller, 'attachment:compat:waiting attachment:compat:ready', this.updateSave );
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        dispose: function() {
+                var selection = this.options.selection;
+
+                // Make sure all settings are saved before removing the view.
+                this.updateAll();
+
+                if ( selection ) {
+                        selection.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        render: function() {
+                var options = _.defaults( this.model.toJSON(), {
+                                orientation:   'landscape',
+                                uploading:     false,
+                                type:          '',
+                                subtype:       '',
+                                icon:          '',
+                                filename:      '',
+                                caption:       '',
+                                title:         '',
+                                dateFormatted: '',
+                                width:         '',
+                                height:        '',
+                                compat:        false,
+                                alt:           '',
+                                description:   ''
+                        }, this.options );
+
+                options.buttons  = this.buttons;
+                options.describe = this.controller.state().get('describe');
+
+                if ( 'image' === options.type ) {
+                        options.size = this.imageSize();
+                }
+
+                options.can = {};
+                if ( options.nonces ) {
+                        options.can.remove = !! options.nonces['delete'];
+                        options.can.save = !! options.nonces.update;
+                }
+
+                if ( this.controller.state().get('allowLocalEdits') ) {
+                        options.allowLocalEdits = true;
+                }
+
+                if ( options.uploading && ! options.percent ) {
+                        options.percent = 0;
+                }
+
+                this.views.detach();
+                this.$el.html( this.template( options ) );
+
+                this.$el.toggleClass( 'uploading', options.uploading );
+
+                if ( options.uploading ) {
+                        this.$bar = this.$('.media-progress-bar div');
+                } else {
+                        delete this.$bar;
+                }
+
+                // Check if the model is selected.
+                this.updateSelect();
+
+                // Update the save status.
+                this.updateSave();
+
+                this.views.render();
+
+                return this;
+        },
+
+        progress: function() {
+                if ( this.$bar && this.$bar.length ) {
+                        this.$bar.width( this.model.get('percent') + '%' );
+                }
+        },
+
+        /**
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                var method;
+
+                // Don't do anything inside inputs.
+                if ( 'INPUT' === event.target.nodeName ) {
+                        return;
+                }
+
+                // Catch arrow events
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                event.preventDefault();
+
+                // In the grid view, bubble up an edit:attachment event to the controller.
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        if ( this.controller.isModeActive( 'edit' ) ) {
+                                // Pass the current target to restore focus when closing
+                                this.controller.trigger( 'edit:attachment', this.model, event.currentTarget );
+                                return;
+                        }
+
+                        if ( this.controller.isModeActive( 'select' ) ) {
+                                method = 'toggle';
+                        }
+                }
+
+                if ( event.shiftKey ) {
+                        method = 'between';
+                } else if ( event.ctrlKey || event.metaKey ) {
+                        method = 'toggle';
+                }
+
+                this.toggleSelection({
+                        method: method
+                });
+
+                this.controller.trigger( 'selection:toggle' );
+        },
+        /**
+         * @param {Object} options
+         */
+        toggleSelection: function( options ) {
+                var collection = this.collection,
+                        selection = this.options.selection,
+                        model = this.model,
+                        method = options && options.method,
+                        single, models, singleIndex, modelIndex;
+
+                if ( ! selection ) {
+                        return;
+                }
+
+                single = selection.single();
+                method = _.isUndefined( method ) ? selection.multiple : method;
+
+                // If the `method` is set to `between`, select all models that
+                // exist between the current and the selected model.
+                if ( 'between' === method && single && selection.multiple ) {
+                        // If the models are the same, short-circuit.
+                        if ( single === model ) {
+                                return;
+                        }
+
+                        singleIndex = collection.indexOf( single );
+                        modelIndex  = collection.indexOf( this.model );
+
+                        if ( singleIndex < modelIndex ) {
+                                models = collection.models.slice( singleIndex, modelIndex + 1 );
+                        } else {
+                                models = collection.models.slice( modelIndex, singleIndex + 1 );
+                        }
+
+                        selection.add( models );
+                        selection.single( model );
+                        return;
+
+                // If the `method` is set to `toggle`, just flip the selection
+                // status, regardless of whether the model is the single model.
+                } else if ( 'toggle' === method ) {
+                        selection[ this.selected() ? 'remove' : 'add' ]( model );
+                        selection.single( model );
+                        return;
+                } else if ( 'add' === method ) {
+                        selection.add( model );
+                        selection.single( model );
+                        return;
+                }
+
+                // Fixes bug that loses focus when selecting a featured image
+                if ( ! method ) {
+                        method = 'add';
+                }
+
+                if ( method !== 'add' ) {
+                        method = 'reset';
+                }
+
+                if ( this.selected() ) {
+                        // If the model is the single model, remove it.
+                        // If it is not the same as the single model,
+                        // it now becomes the single model.
+                        selection[ single === model ? 'remove' : 'single' ]( model );
+                } else {
+                        // If the model is not selected, run the `method` on the
+                        // selection. By default, we `reset` the selection, but the
+                        // `method` can be set to `add` the model to the selection.
+                        selection[ method ]( model );
+                        selection.single( model );
+                }
+        },
+
+        updateSelect: function() {
+                this[ this.selected() ? 'select' : 'deselect' ]();
+        },
+        /**
+         * @returns {unresolved|Boolean}
+         */
+        selected: function() {
+                var selection = this.options.selection;
+                if ( selection ) {
+                        return !! selection.get( this.model.cid );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        select: function( model, collection ) {
+                var selection = this.options.selection,
+                        controller = this.controller;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+
+                // Bail if the model is already selected.
+                if ( this.$el.hasClass( 'selected' ) ) {
+                        return;
+                }
+
+                // Add 'selected' class to model, set aria-checked to true.
+                this.$el.addClass( 'selected' ).attr( 'aria-checked', true );
+                //  Make the checkbox tabable, except in media grid (bulk select mode).
+                if ( ! ( controller.isModeActive( 'grid' ) && controller.isModeActive( 'select' ) ) ) {
+                        this.$( '.check' ).attr( 'tabindex', '0' );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        deselect: function( model, collection ) {
+                var selection = this.options.selection;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+                this.$el.removeClass( 'selected' ).attr( 'aria-checked', false )
+                        .find( '.check' ).attr( 'tabindex', '-1' );
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        details: function( model, collection ) {
+                var selection = this.options.selection,
+                        details;
+
+                if ( selection !== collection ) {
+                        return;
+                }
+
+                details = selection.single();
+                this.$el.toggleClass( 'details', details === this.model );
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {string} size
+         * @returns {Object}
+         */
+        imageSize: function( size ) {
+                var sizes = this.model.get('sizes');
+
+                size = size || 'medium';
+
+                // Use the provided image size if possible.
+                if ( sizes && sizes[ size ] ) {
+                        return _.clone( sizes[ size ] );
+                } else {
+                        return {
+                                url:         this.model.get('url'),
+                                width:       this.model.get('width'),
+                                height:      this.model.get('height'),
+                                orientation: this.model.get('orientation')
+                        };
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateSetting: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        setting, value;
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                setting = $setting.data('setting');
+                value   = event.target.value;
+
+                if ( this.model.get( setting ) !== value ) {
+                        this.save( setting, value );
+                }
+        },
+
+        /**
+         * Pass all the arguments to the model's save method.
+         *
+         * Records the aggregate status of all save requests and updates the
+         * view's classes accordingly.
+         */
+        save: function() {
+                var view = this,
+                        save = this._save = this._save || { status: 'ready' },
+                        request = this.model.save.apply( this.model, arguments ),
+                        requests = save.requests ? $.when( request, save.requests ) : request;
+
+                // If we're waiting to remove 'Saved.', stop.
+                if ( save.savedTimer ) {
+                        clearTimeout( save.savedTimer );
+                }
+
+                this.updateSave('waiting');
+                save.requests = requests;
+                requests.always( function() {
+                        // If we've performed another request since this one, bail.
+                        if ( save.requests !== requests ) {
+                                return;
+                        }
+
+                        view.updateSave( requests.state() === 'resolved' ? 'complete' : 'error' );
+                        save.savedTimer = setTimeout( function() {
+                                view.updateSave('ready');
+                                delete save.savedTimer;
+                        }, 2000 );
+                });
+        },
+        /**
+         * @param {string} status
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        updateSave: function( status ) {
+                var save = this._save = this._save || { status: 'ready' };
+
+                if ( status && status !== save.status ) {
+                        this.$el.removeClass( 'save-' + save.status );
+                        save.status = status;
+                }
+
+                this.$el.addClass( 'save-' + save.status );
+                return this;
+        },
+
+        updateAll: function() {
+                var $settings = this.$('[data-setting]'),
+                        model = this.model,
+                        changed;
+
+                changed = _.chain( $settings ).map( function( el ) {
+                        var $input = $('input, textarea, select, [value]', el ),
+                                setting, value;
+
+                        if ( ! $input.length ) {
+                                return;
+                        }
+
+                        setting = $(el).data('setting');
+                        value = $input.val();
+
+                        // Record the value if it changed.
+                        if ( model.get( setting ) !== value ) {
+                                return [ setting, value ];
+                        }
+                }).compact().object().value();
+
+                if ( ! _.isEmpty( changed ) ) {
+                        model.save( changed );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        removeFromLibrary: function( event ) {
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                // Stop propagation so the model isn't selected.
+                event.stopPropagation();
+
+                this.collection.remove( this.model );
+        },
+
+        /**
+         * Add the model if it isn't in the selection, if it is in the selection,
+         * remove it.
+         *
+         * @param  {[type]} event [description]
+         * @return {[type]}       [description]
+         */
+        checkClickHandler: function ( event ) {
+                var selection = this.options.selection;
+                if ( ! selection ) {
+                        return;
+                }
+                event.stopPropagation();
+                if ( selection.where( { id: this.model.get( 'id' ) } ).length ) {
+                        selection.remove( this.model );
+                        // Move focus back to the attachment tile (from the check).
+                        this.$el.focus();
+                } else {
+                        selection.add( this.model );
+                }
+        }
+});
+
+// Ensure settings remain in sync between attachment views.
+_.each({
+        caption: '_syncCaption',
+        title:   '_syncTitle',
+        artist:  '_syncArtist',
+        album:   '_syncAlbum'
+}, function( method, setting ) {
+        /**
+         * @param {Backbone.Model} model
+         * @param {string} value
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        Attachment.prototype[ method ] = function( model, value ) {
+                var $setting = this.$('[data-setting="' + setting + '"]');
+
+                if ( ! $setting.length ) {
+                        return this;
+                }
+
+                // If the updated value is in sync with the value in the DOM, there
+                // is no need to re-render. If we're currently editing the value,
+                // it will automatically be in sync, suppressing the re-render for
+                // the view we're editing, while updating any others.
+                if ( value === $setting.find('input, textarea, select, [value]').val() ) {
+                        return this;
+                }
+
+                return this.render();
+        };
+});
+
+module.exports = Attachment;
+},{"./view.js":55}],20:[function(require,module,exports){
+/**
+ * A similar view to media.view.Attachment.Details
+ * for use in the Edit Attachment modal.
+ *
+ * @constructor
+ * @augments wp.media.view.Attachment.Details
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Details = require( './details.js' ),
+        MediaDetails = require( '../media-details.js' ),
+        TwoColumn;
+
+TwoColumn = Details.extend({
+        template: wp.template( 'attachment-details-two-column' ),
+
+        editAttachment: function( event ) {
+                event.preventDefault();
+                this.controller.content.mode( 'edit-image' );
+        },
+
+        /**
+         * Noop this from parent class, doesn't apply here.
+         */
+        toggleSelectionHandler: function() {},
+
+        render: function() {
+                Details.prototype.render.apply( this, arguments );
+
+                wp.media.mixin.removeAllPlayers();
+                this.$( 'audio, video' ).each( function (i, elem) {
+                        var el = MediaDetails.prepareSrc( elem );
+                        new MediaElementPlayer( el, wp.media.mixin.mejsSettings );
+                } );
+        }
+});
+
+module.exports = TwoColumn;
+},{"../media-details.js":37,"./details.js":21}],21:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment.Details
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        l10n = wp.media.view.l10n,
+        Details;
+
+Details = Attachment.extend({
+        tagName:   'div',
+        className: 'attachment-details',
+        template:  wp.template('attachment-details'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .delete-attachment':       'deleteAttachment',
+                'click .trash-attachment':        'trashAttachment',
+                'click .untrash-attachment':      'untrashAttachment',
+                'click .edit-attachment':         'editAttachment',
+                'click .refresh-attachment':      'refreshAttachment',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        initialize: function() {
+                this.options = _.defaults( this.options, {
+                        rerenderOnModelChange: false
+                });
+
+                this.on( 'ready', this.initialFocus );
+                // Call 'initialize' directly on the parent class.
+                Attachment.prototype.initialize.apply( this, arguments );
+        },
+
+        initialFocus: function() {
+                if ( ! wp.media.isTouchDevice ) {
+                        this.$( ':input' ).eq( 0 ).focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        deleteAttachment: function( event ) {
+                event.preventDefault();
+
+                if ( confirm( l10n.warnDelete ) ) {
+                        this.model.destroy();
+                        // Keep focus inside media modal
+                        // after image is deleted
+                        this.controller.modal.focusManager.focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        trashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        'edit-metadata' === this.controller.content.mode() ) {
+
+                        this.model.set( 'status', 'trash' );
+                        this.model.save().done( function() {
+                                library._requery( true );
+                        } );
+                }  else {
+                        this.model.destroy();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        untrashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                this.model.set( 'status', 'inherit' );
+                this.model.save().done( function() {
+                        library._requery( true );
+                } );
+        },
+        /**
+         * @param {Object} event
+         */
+        editAttachment: function( event ) {
+                var editState = this.controller.states.get( 'edit-image' );
+                if ( window.imageEdit && editState ) {
+                        event.preventDefault();
+
+                        editState.set( 'image', this.model );
+                        this.controller.setState( 'edit-image' );
+                } else {
+                        this.$el.addClass('needs-refresh');
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        refreshAttachment: function( event ) {
+                this.$el.removeClass('needs-refresh');
+                event.preventDefault();
+                this.model.fetch();
+        },
+        /**
+         * When reverse tabbing(shift+tab) out of the right details panel, deliver
+         * the focus to the item in the list that was being edited.
+         *
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                if ( 'keydown' === event.type && 9 === event.keyCode && event.shiftKey && event.target === this.$( ':tabbable' ).get( 0 ) ) {
+                        this.controller.trigger( 'attachment:details:shift-tab', event );
+                        return false;
+                }
+
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+        }
+});
+
+module.exports = Details;
+},{"../attachment.js":19}],22:[function(require,module,exports){
+/**
+ * wp.media.view.Attachment.Library
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        Library;
+
+Library = Attachment.extend({
+        buttons: {
+                check: true
+        }
+});
+
+module.exports = Library;
+},{"../attachment.js":19}],23:[function(require,module,exports){
+/**
+ * wp.media.view.Attachments
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Attachment = require( './attachment.js' ),
+        $ = jQuery,
+        Attachments;
+
+Attachments = View.extend({
+        tagName:   'ul',
+        className: 'attachments',
+
+        attributes: {
+                tabIndex: -1
+        },
+
+        initialize: function() {
+                this.el.id = _.uniqueId('__attachments-view-');
+
+                _.defaults( this.options, {
+                        refreshSensitivity: wp.media.isTouchDevice ? 300 : 200,
+                        refreshThreshold:   3,
+                        AttachmentView:     Attachment,
+                        sortable:           false,
+                        resize:             true,
+                        idealColumnWidth:   $( window ).width() < 640 ? 135 : 150
+                });
+
+                this._viewsByCid = {};
+                this.$window = $( window );
+                this.resizeEvent = 'resize.media-modal-columns';
+
+                this.collection.on( 'add', function( attachment ) {
+                        this.views.add( this.createAttachmentView( attachment ), {
+                                at: this.collection.indexOf( attachment )
+                        });
+                }, this );
+
+                this.collection.on( 'remove', function( attachment ) {
+                        var view = this._viewsByCid[ attachment.cid ];
+                        delete this._viewsByCid[ attachment.cid ];
+
+                        if ( view ) {
+                                view.remove();
+                        }
+                }, this );
+
+                this.collection.on( 'reset', this.render, this );
+
+                this.listenTo( this.controller, 'library:selection:add',    this.attachmentFocus );
+
+                // Throttle the scroll handler and bind this.
+                this.scroll = _.chain( this.scroll ).bind( this ).throttle( this.options.refreshSensitivity ).value();
+
+                this.options.scrollElement = this.options.scrollElement || this.el;
+                $( this.options.scrollElement ).on( 'scroll', this.scroll );
+
+                this.initSortable();
+
+                _.bindAll( this, 'setColumns' );
+
+                if ( this.options.resize ) {
+                        this.on( 'ready', this.bindEvents );
+                        this.controller.on( 'open', this.setColumns );
+
+                        // Call this.setColumns() after this view has been rendered in the DOM so
+                        // attachments get proper width applied.
+                        _.defer( this.setColumns, this );
+                }
+        },
+
+        bindEvents: function() {
+                this.$window.off( this.resizeEvent ).on( this.resizeEvent, _.debounce( this.setColumns, 50 ) );
+        },
+
+        attachmentFocus: function() {
+                this.$( 'li:first' ).focus();
+        },
+
+        restoreFocus: function() {
+                this.$( 'li.selected:first' ).focus();
+        },
+
+        arrowEvent: function( event ) {
+                var attachments = this.$el.children( 'li' ),
+                        perRow = this.columns,
+                        index = attachments.filter( ':focus' ).index(),
+                        row = ( index + 1 ) <= perRow ? 1 : Math.ceil( ( index + 1 ) / perRow );
+
+                if ( index === -1 ) {
+                        return;
+                }
+
+                // Left arrow
+                if ( 37 === event.keyCode ) {
+                        if ( 0 === index ) {
+                                return;
+                        }
+                        attachments.eq( index - 1 ).focus();
+                }
+
+                // Up arrow
+                if ( 38 === event.keyCode ) {
+                        if ( 1 === row ) {
+                                return;
+                        }
+                        attachments.eq( index - perRow ).focus();
+                }
+
+                // Right arrow
+                if ( 39 === event.keyCode ) {
+                        if ( attachments.length === index ) {
+                                return;
+                        }
+                        attachments.eq( index + 1 ).focus();
+                }
+
+                // Down arrow
+                if ( 40 === event.keyCode ) {
+                        if ( Math.ceil( attachments.length / perRow ) === row ) {
+                                return;
+                        }
+                        attachments.eq( index + perRow ).focus();
+                }
+        },
+
+        dispose: function() {
+                this.collection.props.off( null, null, this );
+                if ( this.options.resize ) {
+                        this.$window.off( this.resizeEvent );
+                }
+
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+        },
+
+        setColumns: function() {
+                var prev = this.columns,
+                        width = this.$el.width();
+
+                if ( width ) {
+                        this.columns = Math.min( Math.round( width / this.options.idealColumnWidth ), 12 ) || 1;
+
+                        if ( ! prev || prev !== this.columns ) {
+                                this.$el.closest( '.media-frame-content' ).attr( 'data-columns', this.columns );
+                        }
+                }
+        },
+
+        initSortable: function() {
+                var collection = this.collection;
+
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                this.$el.sortable( _.extend({
+                        // If the `collection` has a `comparator`, disable sorting.
+                        disabled: !! collection.comparator,
+
+                        // Change the position of the attachment as soon as the
+                        // mouse pointer overlaps a thumbnail.
+                        tolerance: 'pointer',
+
+                        // Record the initial `index` of the dragged model.
+                        start: function( event, ui ) {
+                                ui.item.data('sortableIndexStart', ui.item.index());
+                        },
+
+                        // Update the model's index in the collection.
+                        // Do so silently, as the view is already accurate.
+                        update: function( event, ui ) {
+                                var model = collection.at( ui.item.data('sortableIndexStart') ),
+                                        comparator = collection.comparator;
+
+                                // Temporarily disable the comparator to prevent `add`
+                                // from re-sorting.
+                                delete collection.comparator;
+
+                                // Silently shift the model to its new index.
+                                collection.remove( model, {
+                                        silent: true
+                                });
+                                collection.add( model, {
+                                        silent: true,
+                                        at:     ui.item.index()
+                                });
+
+                                // Restore the comparator.
+                                collection.comparator = comparator;
+
+                                // Fire the `reset` event to ensure other collections sync.
+                                collection.trigger( 'reset', collection );
+
+                                // If the collection is sorted by menu order,
+                                // update the menu order.
+                                collection.saveMenuOrder();
+                        }
+                }, this.options.sortable ) );
+
+                // If the `orderby` property is changed on the `collection`,
+                // check to see if we have a `comparator`. If so, disable sorting.
+                collection.props.on( 'change:orderby', function() {
+                        this.$el.sortable( 'option', 'disabled', !! collection.comparator );
+                }, this );
+
+                this.collection.props.on( 'change:orderby', this.refreshSortable, this );
+                this.refreshSortable();
+        },
+
+        refreshSortable: function() {
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                // If the `collection` has a `comparator`, disable sorting.
+                var collection = this.collection,
+                        orderby = collection.props.get('orderby'),
+                        enabled = 'menuOrder' === orderby || ! collection.comparator;
+
+                this.$el.sortable( 'option', 'disabled', ! enabled );
+        },
+
+        /**
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {wp.media.View}
+         */
+        createAttachmentView: function( attachment ) {
+                var view = new this.options.AttachmentView({
+                        controller:           this.controller,
+                        model:                attachment,
+                        collection:           this.collection,
+                        selection:            this.options.selection
+                });
+
+                return this._viewsByCid[ attachment.cid ] = view;
+        },
+
+        prepare: function() {
+                // Create all of the Attachment views, and replace
+                // the list in a single DOM operation.
+                if ( this.collection.length ) {
+                        this.views.set( this.collection.map( this.createAttachmentView, this ) );
+
+                // If there are no elements, clear the views and load some.
+                } else {
+                        this.views.unset();
+                        this.collection.more().done( this.scroll );
+                }
+        },
+
+        ready: function() {
+                // Trigger the scroll event to check if we're within the
+                // threshold to query for additional attachments.
+                this.scroll();
+        },
+
+        scroll: function() {
+                var view = this,
+                        el = this.options.scrollElement,
+                        scrollTop = el.scrollTop,
+                        toolbar;
+
+                // The scroll event occurs on the document, but the element
+                // that should be checked is the document body.
+                if ( el == document ) {
+                        el = document.body;
+                        scrollTop = $(document).scrollTop();
+                }
+
+                if ( ! $(el).is(':visible') || ! this.collection.hasMore() ) {
+                        return;
+                }
+
+                toolbar = this.views.parent.toolbar;
+
+                // Show the spinner only if we are close to the bottom.
+                if ( el.scrollHeight - ( scrollTop + el.clientHeight ) < el.clientHeight / 3 ) {
+                        toolbar.get('spinner').show();
+                }
+
+                if ( el.scrollHeight < scrollTop + ( el.clientHeight * this.options.refreshThreshold ) ) {
+                        this.collection.more().done(function() {
+                                view.scroll();
+                                toolbar.get('spinner').hide();
+                        });
+                }
+        }
+});
+
+module.exports = Attachments;
+},{"./attachment.js":19,"./view.js":55}],24:[function(require,module,exports){
+/**
+ * wp.media.view.AttachmentsBrowser
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object}      options
+ * @param {object}      [options.filters=false] Which filters to show in the browser's toolbar.
+ *                                              Accepts 'uploaded' and 'all'.
+ * @param {object}      [options.search=true]   Whether to show the search interface in the
+ *                                              browser's toolbar.
+ * @param {object}      [options.display=false] Whether to show the attachments display settings
+ *                                              view in the sidebar.
+ * @param {bool|string} [options.sidebar=true]  Whether to create a sidebar for the browser.
+ *                                              Accepts true, false, and 'errors'.
+ */
+var View = require( '../view.js' ),
+        Library = require( '../attachment/library.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        Spinner = require( '../spinner.js' ),
+        Search = require( '../search.js' ),
+        Label = require( '../label.js' ),
+        Uploaded = require( '../attachment-filters/uploaded.js' ),
+        All = require( '../attachment-filters/all.js' ),
+        DateFilter = require( '../attachment-filters/date.js' ),
+        UploaderInline = require( '../uploader/inline.js' ),
+        Attachments = require( '../attachments.js' ),
+        Sidebar = require( '../sidebar.js' ),
+        UploaderStatus = require( '../uploader/status.js' ),
+        Details = require( '../attachment/details.js' ),
+        AttachmentCompat = require( '../attachment-compat.js' ),
+        AttachmentDisplay = require( '../settings/attachment-display.js' ),
+        mediaTrash = wp.media.view.settings.mediaTrash,
+        l10n = wp.media.view.l10n,
+        $ = jQuery,
+        AttachmentsBrowser;
+
+AttachmentsBrowser = View.extend({
+        tagName:   'div',
+        className: 'attachments-browser',
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        filters: false,
+                        search:  true,
+                        display: false,
+                        sidebar: true,
+                        AttachmentView: Library
+                });
+
+                this.listenTo( this.controller, 'toggle:upload:attachment', _.bind( this.toggleUploader, this ) );
+                this.controller.on( 'edit:selection', this.editSelection );
+                this.createToolbar();
+                if ( this.options.sidebar ) {
+                        this.createSidebar();
+                }
+                this.createUploader();
+                this.createAttachments();
+                this.updateContent();
+
+                if ( ! this.options.sidebar || 'errors' === this.options.sidebar ) {
+                        this.$el.addClass( 'hide-sidebar' );
+
+                        if ( 'errors' === this.options.sidebar ) {
+                                this.$el.addClass( 'sidebar-for-errors' );
+                        }
+                }
+
+                this.collection.on( 'add remove reset', this.updateContent, this );
+        },
+
+        editSelection: function( modal ) {
+                modal.$( '.media-button-backToLibrary' ).focus();
+        },
+
+        /**
+         * @returns {wp.media.view.AttachmentsBrowser} Returns itself to allow chaining
+         */
+        dispose: function() {
+                this.options.selection.off( null, null, this );
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        createToolbar: function() {
+                var LibraryViewSwitcher, Filters, toolbarOptions;
+
+                toolbarOptions = {
+                        controller: this.controller
+                };
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        toolbarOptions.className = 'media-toolbar wp-filter';
+                }
+
+                /**
+                * @member {wp.media.view.Toolbar}
+                */
+                this.toolbar = new Toolbar( toolbarOptions );
+
+                this.views.add( this.toolbar );
+
+                this.toolbar.set( 'spinner', new Spinner({
+                        priority: -60
+                }) );
+
+                if ( -1 !== $.inArray( this.options.filters, [ 'uploaded', 'all' ] ) ) {
+                        // "Filters" will return a <select>, need to render
+                        // screen reader text before
+                        this.toolbar.set( 'filtersLabel', new Label({
+                                value: l10n.filterByType,
+                                attributes: {
+                                        'for':  'media-attachment-filters'
+                                },
+                                priority:   -80
+                        }).render() );
+
+                        if ( 'uploaded' === this.options.filters ) {
+                                this.toolbar.set( 'filters', new Uploaded({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                }).render() );
+                        } else {
+                                Filters = new All({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                });
+
+                                this.toolbar.set( 'filters', Filters.render() );
+                        }
+                }
+
+                // Feels odd to bring the global media library switcher into the Attachment
+                // browser view. Is this a use case for doAction( 'add:toolbar-items:attachments-browser', this.toolbar );
+                // which the controller can tap into and add this view?
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        LibraryViewSwitcher = View.extend({
+                                className: 'view-switch media-grid-view-switch',
+                                template: wp.template( 'media-library-view-switcher')
+                        });
+
+                        this.toolbar.set( 'libraryViewSwitcher', new LibraryViewSwitcher({
+                                controller: this.controller,
+                                priority: -90
+                        }).render() );
+
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+
+                        // BulkSelection is a <div> with subviews, including screen reader text
+                        this.toolbar.set( 'selectModeToggleButton', new wp.media.view.SelectModeToggleButton({
+                                text: l10n.bulkSelect,
+                                controller: this.controller,
+                                priority: -70
+                        }).render() );
+
+                        this.toolbar.set( 'deleteSelectedButton', new wp.media.view.DeleteSelectedButton({
+                                filters: Filters,
+                                style: 'primary',
+                                disabled: true,
+                                text: mediaTrash ? l10n.trashSelected : l10n.deleteSelected,
+                                controller: this.controller,
+                                priority: -60,
+                                click: function() {
+                                        var changed = [], removed = [], self = this,
+                                                selection = this.controller.state().get( 'selection' ),
+                                                library = this.controller.state().get( 'library' );
+
+                                        if ( ! selection.length ) {
+                                                return;
+                                        }
+
+                                        if ( ! mediaTrash && ! confirm( l10n.warnBulkDelete ) ) {
+                                                return;
+                                        }
+
+                                        if ( mediaTrash &&
+                                                'trash' !== selection.at( 0 ).get( 'status' ) &&
+                                                ! confirm( l10n.warnBulkTrash ) ) {
+
+                                                return;
+                                        }
+
+                                        selection.each( function( model ) {
+                                                if ( ! model.get( 'nonces' )['delete'] ) {
+                                                        removed.push( model );
+                                                        return;
+                                                }
+
+                                                if ( mediaTrash && 'trash' === model.get( 'status' ) ) {
+                                                        model.set( 'status', 'inherit' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else if ( mediaTrash ) {
+                                                        model.set( 'status', 'trash' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else {
+                                                        model.destroy({wait: true});
+                                                }
+                                        } );
+
+                                        if ( changed.length ) {
+                                                selection.remove( removed );
+
+                                                $.when.apply( null, changed ).then( function() {
+                                                        library._requery( true );
+                                                        self.controller.trigger( 'selection:action:done' );
+                                                } );
+                                        } else {
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }
+                        }).render() );
+
+                        if ( mediaTrash ) {
+                                this.toolbar.set( 'deleteSelectedPermanentlyButton', new wp.media.view.DeleteSelectedPermanentlyButton({
+                                        filters: Filters,
+                                        style: 'primary',
+                                        disabled: true,
+                                        text: l10n.deleteSelected,
+                                        controller: this.controller,
+                                        priority: -55,
+                                        click: function() {
+                                                var removed = [], selection = this.controller.state().get( 'selection' );
+
+                                                if ( ! selection.length || ! confirm( l10n.warnBulkDelete ) ) {
+                                                        return;
+                                                }
+
+                                                selection.each( function( model ) {
+                                                        if ( ! model.get( 'nonces' )['delete'] ) {
+                                                                removed.push( model );
+                                                                return;
+                                                        }
+
+                                                        model.destroy();
+                                                } );
+
+                                                selection.remove( removed );
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }).render() );
+                        }
+
+                } else {
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+                }
+
+                if ( this.options.search ) {
+                        // Search is an input, screen reader text needs to be rendered before
+                        this.toolbar.set( 'searchLabel', new Label({
+                                value: l10n.searchMediaLabel,
+                                attributes: {
+                                        'for': 'media-search-input'
+                                },
+                                priority:   60
+                        }).render() );
+                        this.toolbar.set( 'search', new Search({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority:   60
+                        }).render() );
+                }
+
+                if ( this.options.dragInfo ) {
+                        this.toolbar.set( 'dragInfo', new View({
+                                el: $( '<div class="instructions">' + l10n.dragInfo + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+
+                if ( this.options.suggestedWidth && this.options.suggestedHeight ) {
+                        this.toolbar.set( 'suggestedDimensions', new View({
+                                el: $( '<div class="instructions">' + l10n.suggestedDimensions + ' ' + this.options.suggestedWidth + ' &times; ' + this.options.suggestedHeight + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+        },
+
+        updateContent: function() {
+                var view = this,
+                        noItemsView;
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        noItemsView = view.attachmentsNoResults;
+                } else {
+                        noItemsView = view.uploader;
+                }
+
+                if ( ! this.collection.length ) {
+                        this.toolbar.get( 'spinner' ).show();
+                        this.dfd = this.collection.more().done( function() {
+                                if ( ! view.collection.length ) {
+                                        noItemsView.$el.removeClass( 'hidden' );
+                                } else {
+                                        noItemsView.$el.addClass( 'hidden' );
+                                }
+                                view.toolbar.get( 'spinner' ).hide();
+                        } );
+                } else {
+                        noItemsView.$el.addClass( 'hidden' );
+                        view.toolbar.get( 'spinner' ).hide();
+                }
+        },
+
+        createUploader: function() {
+                this.uploader = new UploaderInline({
+                        controller: this.controller,
+                        status:     false,
+                        message:    this.controller.isModeActive( 'grid' ) ? '' : l10n.noItemsFound,
+                        canClose:   this.controller.isModeActive( 'grid' )
+                });
+
+                this.uploader.hide();
+                this.views.add( this.uploader );
+        },
+
+        toggleUploader: function() {
+                if ( this.uploader.$el.hasClass( 'hidden' ) ) {
+                        this.uploader.show();
+                } else {
+                        this.uploader.hide();
+                }
+        },
+
+        createAttachments: function() {
+                this.attachments = new Attachments({
+                        controller:           this.controller,
+                        collection:           this.collection,
+                        selection:            this.options.selection,
+                        model:                this.model,
+                        sortable:             this.options.sortable,
+                        scrollElement:        this.options.scrollElement,
+                        idealColumnWidth:     this.options.idealColumnWidth,
+
+                        // The single `Attachment` view to be used in the `Attachments` view.
+                        AttachmentView: this.options.AttachmentView
+                });
+
+                // Add keydown listener to the instance of the Attachments view
+                this.attachments.listenTo( this.controller, 'attachment:keydown:arrow',     this.attachments.arrowEvent );
+                this.attachments.listenTo( this.controller, 'attachment:details:shift-tab', this.attachments.restoreFocus );
+
+                this.views.add( this.attachments );
+
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        this.attachmentsNoResults = new View({
+                                controller: this.controller,
+                                tagName: 'p'
+                        });
+
+                        this.attachmentsNoResults.$el.addClass( 'hidden no-media' );
+                        this.attachmentsNoResults.$el.html( l10n.noMedia );
+
+                        this.views.add( this.attachmentsNoResults );
+                }
+        },
+
+        createSidebar: function() {
+                var options = this.options,
+                        selection = options.selection,
+                        sidebar = this.sidebar = new Sidebar({
+                                controller: this.controller
+                        });
+
+                this.views.add( sidebar );
+
+                if ( this.controller.uploader ) {
+                        sidebar.set( 'uploads', new UploaderStatus({
+                                controller: this.controller,
+                                priority:   40
+                        }) );
+                }
+
+                selection.on( 'selection:single', this.createSingle, this );
+                selection.on( 'selection:unsingle', this.disposeSingle, this );
+
+                if ( selection.single() ) {
+                        this.createSingle();
+                }
+        },
+
+        createSingle: function() {
+                var sidebar = this.sidebar,
+                        single = this.options.selection.single();
+
+                sidebar.set( 'details', new Details({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   80
+                }) );
+
+                sidebar.set( 'compat', new AttachmentCompat({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   120
+                }) );
+
+                if ( this.options.display ) {
+                        sidebar.set( 'display', new AttachmentDisplay({
+                                controller:   this.controller,
+                                model:        this.model.display( single ),
+                                attachment:   single,
+                                priority:     160,
+                                userSettings: this.model.get('displayUserSettings')
+                        }) );
+                }
+
+                // Show the sidebar on mobile
+                if ( this.model.id === 'insert' ) {
+                        sidebar.$el.addClass( 'visible' );
+                }
+        },
+
+        disposeSingle: function() {
+                var sidebar = this.sidebar;
+                sidebar.unset('details');
+                sidebar.unset('compat');
+                sidebar.unset('display');
+                // Hide the sidebar on mobile
+                sidebar.$el.removeClass( 'visible' );
+        }
+});
+
+module.exports = AttachmentsBrowser;
+},{"../attachment-compat.js":14,"../attachment-filters/all.js":16,"../attachment-filters/date.js":17,"../attachment-filters/uploaded.js":18,"../attachment/details.js":21,"../attachment/library.js":22,"../attachments.js":23,"../label.js":36,"../search.js":45,"../settings/attachment-display.js":47,"../sidebar.js":48,"../spinner.js":49,"../toolbar.js":50,"../uploader/inline.js":51,"../uploader/status.js":53,"../view.js":55}],25:[function(require,module,exports){
+/**
+ * wp.media.view.Button
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button;
+
+Button = View.extend({
+        tagName:    'a',
+        className:  'media-button',
+        attributes: { href: '#' },
+
+        events: {
+                'click': 'click'
+        },
+
+        defaults: {
+                text:     '',
+                style:    '',
+                size:     'large',
+                disabled: false
+        },
+
+        initialize: function() {
+                /**
+                 * Create a model with the provided `defaults`.
+                 *
+                 * @member {Backbone.Model}
+                 */
+                this.model = new Backbone.Model( this.defaults );
+
+                // If any of the `options` have a key from `defaults`, apply its
+                // value to the `model` and remove it from the `options object.
+                _.each( this.defaults, function( def, key ) {
+                        var value = this.options[ key ];
+                        if ( _.isUndefined( value ) ) {
+                                return;
+                        }
+
+                        this.model.set( key, value );
+                        delete this.options[ key ];
+                }, this );
+
+                this.model.on( 'change', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.Button} Returns itself to allow chaining
+         */
+        render: function() {
+                var classes = [ 'button', this.className ],
+                        model = this.model.toJSON();
+
+                if ( model.style ) {
+                        classes.push( 'button-' + model.style );
+                }
+
+                if ( model.size ) {
+                        classes.push( 'button-' + model.size );
+                }
+
+                classes = _.uniq( classes.concat( this.options.classes ) );
+                this.el.className = classes.join(' ');
+
+                this.$el.attr( 'disabled', model.disabled );
+                this.$el.text( this.model.get('text') );
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        click: function( event ) {
+                if ( '#' === this.attributes.href ) {
+                        event.preventDefault();
+                }
+
+                if ( this.options.click && ! this.model.get('disabled') ) {
+                        this.options.click.apply( this, arguments );
+                }
+        }
+});
+
+module.exports = Button;
+},{"./view.js":55}],26:[function(require,module,exports){
+/**
+ * When MEDIA_TRASH is true, a button that handles bulk Delete Permanently logic
+ *
+ * @constructor
+ * @augments wp.media.view.DeleteSelectedButton
+ * @augments wp.media.view.Button
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Button = require( '../button.js' ),
+        DeleteSelected = require( './delete-selected.js' ),
+        DeleteSelectedPermanently;
+
+DeleteSelectedPermanently = DeleteSelected.extend({
+        initialize: function() {
+                DeleteSelected.prototype.initialize.apply( this, arguments );
+                this.listenTo( this.controller, 'select:activate', this.selectActivate );
+                this.listenTo( this.controller, 'select:deactivate', this.selectDeactivate );
+        },
+
+        filterChange: function( model ) {
+                this.canShow = ( 'trash' === model.get( 'status' ) );
+        },
+
+        selectActivate: function() {
+                this.toggleDisabled();
+                this.$el.toggleClass( 'hidden', ! this.canShow );
+        },
+
+        selectDeactivate: function() {
+                this.toggleDisabled();
+                this.$el.addClass( 'hidden' );
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                this.selectActivate();
+                return this;
+        }
+});
+
+module.exports = DeleteSelectedPermanently;
+},{"../button.js":25,"./delete-selected.js":27}],27:[function(require,module,exports){
+/**
+ * A button that handles bulk Delete/Trash logic
+ *
+ * @constructor
+ * @augments wp.media.view.Button
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Button = require( '../button.js' ),
+        l10n = wp.media.view.l10n,
+        DeleteSelected;
+
+DeleteSelected = Button.extend({
+        initialize: function() {
+                Button.prototype.initialize.apply( this, arguments );
+                if ( this.options.filters ) {
+                        this.listenTo( this.options.filters.model, 'change', this.filterChange );
+                }
+                this.listenTo( this.controller, 'selection:toggle', this.toggleDisabled );
+        },
+
+        filterChange: function( model ) {
+                if ( 'trash' === model.get( 'status' ) ) {
+                        this.model.set( 'text', l10n.untrashSelected );
+                } else if ( wp.media.view.settings.mediaTrash ) {
+                        this.model.set( 'text', l10n.trashSelected );
+                } else {
+                        this.model.set( 'text', l10n.deleteSelected );
+                }
+        },
+
+        toggleDisabled: function() {
+                this.model.set( 'disabled', ! this.controller.state().get( 'selection' ).length );
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.$el.addClass( 'delete-selected-button' );
+                } else {
+                        this.$el.addClass( 'delete-selected-button hidden' );
+                }
+                this.toggleDisabled();
+                return this;
+        }
+});
+
+module.exports = DeleteSelected;
+},{"../button.js":25}],28:[function(require,module,exports){
+var Button = require( '../button.js' ),
+        l10n = wp.media.view.l10n,
+        SelectModeToggle;
+
+SelectModeToggle = Button.extend({
+        initialize: function() {
+                Button.prototype.initialize.apply( this, arguments );
+                this.listenTo( this.controller, 'select:activate select:deactivate', this.toggleBulkEditHandler );
+                this.listenTo( this.controller, 'selection:action:done', this.back );
+        },
+
+        back: function () {
+                this.controller.deactivateMode( 'select' ).activateMode( 'edit' );
+        },
+
+        click: function() {
+                Button.prototype.click.apply( this, arguments );
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.back();
+                } else {
+                        this.controller.deactivateMode( 'edit' ).activateMode( 'select' );
+                }
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                this.$el.addClass( 'select-mode-toggle-button' );
+                return this;
+        },
+
+        toggleBulkEditHandler: function() {
+                var toolbar = this.controller.content.get().toolbar, children;
+
+                children = toolbar.$( '.media-toolbar-secondary > *, .media-toolbar-primary > *' );
+
+                // TODO: the Frame should be doing all of this.
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.model.set( 'text', l10n.cancelSelection );
+                        children.not( '.media-button' ).hide();
+                        this.$el.show();
+                        toolbar.$( '.delete-selected-button' ).removeClass( 'hidden' );
+                } else {
+                        this.model.set( 'text', l10n.bulkSelect );
+                        this.controller.content.get().$el.removeClass( 'fixed' );
+                        toolbar.$el.css( 'width', '' );
+                        toolbar.$( '.delete-selected-button' ).addClass( 'hidden' );
+                        children.not( '.spinner, .media-button' ).show();
+                        this.controller.state().get( 'selection' ).reset();
+                }
+        }
+});
+
+module.exports = SelectModeToggle;
+},{"../button.js":25}],29:[function(require,module,exports){
+var View = require( './view.js' ),
+        EditImage = require( './edit-image.js' ),
+        Details;
+
+Details = EditImage.extend({
+        initialize: function( options ) {
+                this.editor = window.imageEdit;
+                this.frame = options.frame;
+                this.controller = options.controller;
+                View.prototype.initialize.apply( this, arguments );
+        },
+
+        back: function() {
+                this.frame.content.mode( 'edit-metadata' );
+        },
+
+        save: function() {
+                var self = this;
+
+                this.model.fetch().done( function() {
+                        self.frame.content.mode( 'edit-metadata' );
+                });
+        }
+});
+
+module.exports = Details;
+},{"./edit-image.js":30,"./view.js":55}],30:[function(require,module,exports){
+var View = require( './view.js' ),
+        EditImage;
+
+EditImage = View.extend({
+        className: 'image-editor',
+        template: wp.template('image-editor'),
+
+        initialize: function( options ) {
+                this.editor = window.imageEdit;
+                this.controller = options.controller;
+                View.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                return this.model.toJSON();
+        },
+
+        render: function() {
+                View.prototype.render.apply( this, arguments );
+                return this;
+        },
+
+        loadEditor: function() {
+                var dfd = this.editor.open( this.model.get('id'), this.model.get('nonces').edit, this );
+                dfd.done( _.bind( this.focus, this ) );
+        },
+
+        focus: function() {
+                this.$( '.imgedit-submit .button' ).eq( 0 ).focus();
+        },
+
+        back: function() {
+                var lastState = this.controller.lastState();
+                this.controller.setState( lastState );
+        },
+
+        refresh: function() {
+                this.model.fetch();
+        },
+
+        save: function() {
+                var self = this,
+                        lastState = this.controller.lastState();
+
+                this.model.fetch().done( function() {
+                        self.controller.setState( lastState );
+                });
+        }
+
+});
+
+module.exports = EditImage;
+},{"./view.js":55}],31:[function(require,module,exports){
+/**
+ * wp.media.view.FocusManager
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager;
+
+FocusManager = View.extend({
+
+        events: {
+                'keydown': 'constrainTabbing'
+        },
+
+        focus: function() { // Reset focus on first left menu item
+                this.$('.media-menu-item').first().focus();
+        },
+        /**
+         * @param {Object} event
+         */
+        constrainTabbing: function( event ) {
+                var tabbables;
+
+                // Look for the tab key.
+                if ( 9 !== event.keyCode ) {
+                        return;
+                }
+
+                tabbables = this.$( ':tabbable' );
+
+                // Keep tab focus within media modal while it's open
+                if ( tabbables.last()[0] === event.target && ! event.shiftKey ) {
+                        tabbables.first().focus();
+                        return false;
+                } else if ( tabbables.first()[0] === event.target && event.shiftKey ) {
+                        tabbables.last().focus();
+                        return false;
+                }
+        }
+
+});
+
+module.exports = FocusManager;
+},{"./view.js":55}],32:[function(require,module,exports){
+/**
+ * wp.media.view.Frame
+ *
+ * A frame is a composite view consisting of one or more regions and one or more
+ * states.
+ *
+ * @see wp.media.controller.State
+ * @see wp.media.controller.Region
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var StateMachine = require( '../controllers/state-machine.js' ),
+        State = require( '../controllers/state.js' ),
+        Region = require( '../controllers/region.js' ),
+        View = require( './view.js' ),
+        Frame;
+
+Frame = View.extend({
+        initialize: function() {
+                _.defaults( this.options, {
+                        mode: [ 'select' ]
+                });
+                this._createRegions();
+                this._createStates();
+                this._createModes();
+        },
+
+        _createRegions: function() {
+                // Clone the regions array.
+                this.regions = this.regions ? this.regions.slice() : [];
+
+                // Initialize regions.
+                _.each( this.regions, function( region ) {
+                        this[ region ] = new Region({
+                                view:     this,
+                                id:       region,
+                                selector: '.media-frame-' + region
+                        });
+                }, this );
+        },
+        /**
+         * Create the frame's states.
+         *
+         * @see wp.media.controller.State
+         * @see wp.media.controller.StateMachine
+         *
+         * @fires wp.media.controller.State#ready
+         */
+        _createStates: function() {
+                // Create the default `states` collection.
+                this.states = new Backbone.Collection( null, {
+                        model: State
+                });
+
+                // Ensure states have a reference to the frame.
+                this.states.on( 'add', function( model ) {
+                        model.frame = this;
+                        model.trigger('ready');
+                }, this );
+
+                if ( this.options.states ) {
+                        this.states.add( this.options.states );
+                }
+        },
+
+        /**
+         * A frame can be in a mode or multiple modes at one time.
+         *
+         * For example, the manage media frame can be in the `Bulk Select` or `Edit` mode.
+         */
+        _createModes: function() {
+                // Store active "modes" that the frame is in. Unrelated to region modes.
+                this.activeModes = new Backbone.Collection();
+                this.activeModes.on( 'add remove reset', _.bind( this.triggerModeEvents, this ) );
+
+                _.each( this.options.mode, function( mode ) {
+                        this.activateMode( mode );
+                }, this );
+        },
+        /**
+         * Reset all states on the frame to their defaults.
+         *
+         * @returns {wp.media.view.Frame} Returns itself to allow chaining
+         */
+        reset: function() {
+                this.states.invoke( 'trigger', 'reset' );
+                return this;
+        },
+        /**
+         * Map activeMode collection events to the frame.
+         */
+        triggerModeEvents: function( model, collection, options ) {
+                var collectionEvent,
+                        modeEventMap = {
+                                add: 'activate',
+                                remove: 'deactivate'
+                        },
+                        eventToTrigger;
+                // Probably a better way to do this.
+                _.each( options, function( value, key ) {
+                        if ( value ) {
+                                collectionEvent = key;
+                        }
+                } );
+
+                if ( ! _.has( modeEventMap, collectionEvent ) ) {
+                        return;
+                }
+
+                eventToTrigger = model.get('id') + ':' + modeEventMap[collectionEvent];
+                this.trigger( eventToTrigger );
+        },
+        /**
+         * Activate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        activateMode: function( mode ) {
+                // Bail if the mode is already active.
+                if ( this.isModeActive( mode ) ) {
+                        return;
+                }
+                this.activeModes.add( [ { id: mode } ] );
+                // Add a CSS class to the frame so elements can be styled for the mode.
+                this.$el.addClass( 'mode-' + mode );
+
+                return this;
+        },
+        /**
+         * Deactivate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        deactivateMode: function( mode ) {
+                // Bail if the mode isn't active.
+                if ( ! this.isModeActive( mode ) ) {
+                        return this;
+                }
+                this.activeModes.remove( this.activeModes.where( { id: mode } ) );
+                this.$el.removeClass( 'mode-' + mode );
+                /**
+                 * Frame mode deactivation event.
+                 *
+                 * @event this#{mode}:deactivate
+                 */
+                this.trigger( mode + ':deactivate' );
+
+                return this;
+        },
+        /**
+         * Check if a mode is enabled on the frame.
+         *
+         * @param  string mode Mode ID.
+         * @return bool
+         */
+        isModeActive: function( mode ) {
+                return Boolean( this.activeModes.where( { id: mode } ).length );
+        }
+});
+
+// Make the `Frame` a `StateMachine`.
+_.extend( Frame.prototype, StateMachine.prototype );
+
+module.exports = Frame;
+},{"../controllers/region.js":4,"../controllers/state-machine.js":5,"../controllers/state.js":6,"./view.js":55}],33:[function(require,module,exports){
+/**
+ * A frame for editing the details of a specific media item.
+ *
+ * Opens in a modal by default.
+ *
+ * Requires an attachment model to be passed in the options hash under `model`.
+ *
+ * @constructor
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var Frame = require( '../frame.js' ),
+        MediaFrame = require( '../media-frame.js' ),
+        Modal = require( '../modal.js' ),
+        EditAttachmentMetadata = require( '../../controllers/edit-attachment-metadata.js' ),
+        TwoColumn = require( '../attachment/details-two-column.js' ),
+        AttachmentCompat = require( '../attachment-compat.js' ),
+        EditImageController = require( '../../controllers/edit-image.js' ),
+        DetailsView = require( '../edit-image-details.js' ),
+        $ = jQuery,
+        EditAttachments;
+
+EditAttachments = MediaFrame.extend({
+
+        className: 'edit-attachment-frame',
+        template:  wp.template( 'edit-attachment-frame' ),
+        regions:   [ 'title', 'content' ],
+
+        events: {
+                'click .left':  'previousMediaItem',
+                'click .right': 'nextMediaItem'
+        },
+
+        initialize: function() {
+                Frame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        modal: true,
+                        state: 'edit-attachment'
+                });
+
+                this.controller = this.options.controller;
+                this.gridRouter = this.controller.gridRouter;
+                this.library = this.options.library;
+
+                if ( this.options.model ) {
+                        this.model = this.options.model;
+                }
+
+                this.bindHandlers();
+                this.createStates();
+                this.createModal();
+
+                this.title.mode( 'default' );
+                this.toggleNav();
+        },
+
+        bindHandlers: function() {
+                // Bind default title creation.
+                this.on( 'title:create:default', this.createTitle, this );
+
+                // Close the modal if the attachment is deleted.
+                this.listenTo( this.model, 'change:status destroy', this.close, this );
+
+                this.on( 'content:create:edit-metadata', this.editMetadataMode, this );
+                this.on( 'content:create:edit-image', this.editImageMode, this );
+                this.on( 'content:render:edit-image', this.editImageModeRender, this );
+                this.on( 'close', this.detach );
+        },
+
+        createModal: function() {
+                var self = this;
+
+                // Initialize modal container view.
+                if ( this.options.modal ) {
+                        this.modal = new Modal({
+                                controller: this,
+                                title:      this.options.title
+                        });
+
+                        this.modal.on( 'open', function () {
+                                $( 'body' ).on( 'keydown.media-modal', _.bind( self.keyEvent, self ) );
+                        } );
+
+                        // Completely destroy the modal DOM element when closing it.
+                        this.modal.on( 'close', function() {
+                                self.modal.remove();
+                                $( 'body' ).off( 'keydown.media-modal' ); /* remove the keydown event */
+                                // Restore the original focus item if possible
+                                $( 'li.attachment[data-id="' + self.model.get( 'id' ) +'"]' ).focus();
+                                self.resetRoute();
+                        } );
+
+                        // Set this frame as the modal's content.
+                        this.modal.content( this );
+                        this.modal.open();
+                }
+        },
+
+        /**
+         * Add the default states to the frame.
+         */
+        createStates: function() {
+                this.states.add([
+                        new EditAttachmentMetadata( { model: this.model } )
+                ]);
+        },
+
+        /**
+         * Content region rendering callback for the `edit-metadata` mode.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         */
+        editMetadataMode: function( contentRegion ) {
+                contentRegion.view = new TwoColumn({
+                        controller: this,
+                        model:      this.model
+                });
+
+                /**
+                 * Attach a subview to display fields added via the
+                 * `attachment_fields_to_edit` filter.
+                 */
+                contentRegion.view.views.set( '.attachment-compat', new AttachmentCompat({
+                        controller: this,
+                        model:      this.model
+                }) );
+
+                // Update browser url when navigating media details
+                if ( this.model ) {
+                        this.gridRouter.navigate( this.gridRouter.baseUrl( '?item=' + this.model.id ) );
+                }
+        },
+
+        /**
+         * Render the EditImage view into the frame's content region.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         */
+        editImageMode: function( contentRegion ) {
+                var editImageController = new EditImageController( {
+                        model: this.model,
+                        frame: this
+                } );
+                // Noop some methods.
+                editImageController._toolbar = function() {};
+                editImageController._router = function() {};
+                editImageController._menu = function() {};
+
+                contentRegion.view = new DetailsView( {
+                        model: this.model,
+                        frame: this,
+                        controller: editImageController
+                } );
+        },
+
+        editImageModeRender: function( view ) {
+                view.on( 'ready', view.loadEditor );
+        },
+
+        toggleNav: function() {
+                this.$('.left').toggleClass( 'disabled', ! this.hasPrevious() );
+                this.$('.right').toggleClass( 'disabled', ! this.hasNext() );
+        },
+
+        /**
+         * Rerender the view.
+         */
+        rerender: function() {
+                // Only rerender the `content` region.
+                if ( this.content.mode() !== 'edit-metadata' ) {
+                        this.content.mode( 'edit-metadata' );
+                } else {
+                        this.content.render();
+                }
+
+                this.toggleNav();
+        },
+
+        /**
+         * Click handler to switch to the previous media item.
+         */
+        previousMediaItem: function() {
+                if ( ! this.hasPrevious() ) {
+                        this.$( '.left' ).blur();
+                        return;
+                }
+                this.model = this.library.at( this.getCurrentIndex() - 1 );
+                this.rerender();
+                this.$( '.left' ).focus();
+        },
+
+        /**
+         * Click handler to switch to the next media item.
+         */
+        nextMediaItem: function() {
+                if ( ! this.hasNext() ) {
+                        this.$( '.right' ).blur();
+                        return;
+                }
+                this.model = this.library.at( this.getCurrentIndex() + 1 );
+                this.rerender();
+                this.$( '.right' ).focus();
+        },
+
+        getCurrentIndex: function() {
+                return this.library.indexOf( this.model );
+        },
+
+        hasNext: function() {
+                return ( this.getCurrentIndex() + 1 ) < this.library.length;
+        },
+
+        hasPrevious: function() {
+                return ( this.getCurrentIndex() - 1 ) > -1;
+        },
+        /**
+         * Respond to the keyboard events: right arrow, left arrow, except when
+         * focus is in a textarea or input field.
+         */
+        keyEvent: function( event ) {
+                if ( ( 'INPUT' === event.target.nodeName || 'TEXTAREA' === event.target.nodeName ) && ! ( event.target.readOnly || event.target.disabled ) ) {
+                        return;
+                }
+
+                // The right arrow key
+                if ( 39 === event.keyCode ) {
+                        this.nextMediaItem();
+                }
+                // The left arrow key
+                if ( 37 === event.keyCode ) {
+                        this.previousMediaItem();
+                }
+        },
+
+        resetRoute: function() {
+                this.gridRouter.navigate( this.gridRouter.baseUrl( '' ) );
+        }
+});
+
+module.exports = EditAttachments;
+},{"../../controllers/edit-attachment-metadata.js":1,"../../controllers/edit-image.js":2,"../attachment-compat.js":14,"../attachment/details-two-column.js":20,"../edit-image-details.js":29,"../frame.js":32,"../media-frame.js":38,"../modal.js":41}],34:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame.Manage
+ *
+ * A generic management frame workflow.
+ *
+ * Used in the media grid view.
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaFrame = require( '../media-frame.js' ),
+        UploaderWindow = require( '../uploader/window.js' ),
+        AttachmentsBrowser = require( '../attachments/browser.js' ),
+        Router = require( '../../router/manage.js' ),
+        Library = require( '../../controllers/library.js' ),
+        $ = jQuery,
+        Manage;
+
+Manage = MediaFrame.extend({
+        /**
+         * @global wp.Uploader
+         */
+        initialize: function() {
+                var self = this;
+                _.defaults( this.options, {
+                        title:     '',
+                        modal:     false,
+                        selection: [],
+                        library:   {}, // Options hash for the query to the media library.
+                        multiple:  'add',
+                        state:     'library',
+                        uploader:  true,
+                        mode:      [ 'grid', 'edit' ]
+                });
+
+                this.$body = $( document.body );
+                this.$window = $( window );
+                this.$adminBar = $( '#wpadminbar' );
+                this.$window.on( 'scroll resize', _.debounce( _.bind( this.fixPosition, this ), 15 ) );
+                $( document ).on( 'click', '.add-new-h2', _.bind( this.addNewClickHandler, this ) );
+
+                // Ensure core and media grid view UI is enabled.
+                this.$el.addClass('wp-core-ui');
+
+                // Force the uploader off if the upload limit has been exceeded or
+                // if the browser isn't supported.
+                if ( wp.Uploader.limitExceeded || ! wp.Uploader.browser.supported ) {
+                        this.options.uploader = false;
+                }
+
+                // Initialize a window-wide uploader.
+                if ( this.options.uploader ) {
+                        this.uploader = new UploaderWindow({
+                                controller: this,
+                                uploader: {
+                                        dropzone:  document.body,
+                                        container: document.body
+                                }
+                        }).render();
+                        this.uploader.ready();
+                        $('body').append( this.uploader.el );
+
+                        this.options.uploader = false;
+                }
+
+                this.gridRouter = new Router();
+
+                // Call 'initialize' directly on the parent class.
+                MediaFrame.prototype.initialize.apply( this, arguments );
+
+                // Append the frame view directly the supplied container.
+                this.$el.appendTo( this.options.container );
+
+                this.createStates();
+                this.bindRegionModeHandlers();
+                this.render();
+
+                // Update the URL when entering search string (at most once per second)
+                $( '#media-search-input' ).on( 'input', _.debounce( function(e) {
+                        var val = $( e.currentTarget ).val(), url = '';
+                        if ( val ) {
+                                url += '?search=' + val;
+                        }
+                        self.gridRouter.navigate( self.gridRouter.baseUrl( url ) );
+                }, 1000 ) );
+        },
+
+        /**
+         * Create the default states for the frame.
+         */
+        createStates: function() {
+                var options = this.options;
+
+                if ( this.options.states ) {
+                        return;
+                }
+
+                // Add the default states.
+                this.states.add([
+                        new Library({
+                                library:            wp.media.query( options.library ),
+                                multiple:           options.multiple,
+                                title:              options.title,
+                                content:            'browse',
+                                toolbar:            'select',
+                                contentUserSetting: false,
+                                filterable:         'all',
+                                autoSelect:         false
+                        })
+                ]);
+        },
+
+        /**
+         * Bind region mode activation events to proper handlers.
+         */
+        bindRegionModeHandlers: function() {
+                this.on( 'content:create:browse', this.browseContent, this );
+
+                // Handle a frame-level event for editing an attachment.
+                this.on( 'edit:attachment', this.openEditAttachmentModal, this );
+
+                this.on( 'select:activate', this.bindKeydown, this );
+                this.on( 'select:deactivate', this.unbindKeydown, this );
+        },
+
+        handleKeydown: function( e ) {
+                if ( 27 === e.which ) {
+                        e.preventDefault();
+                        this.deactivateMode( 'select' ).activateMode( 'edit' );
+                }
+        },
+
+        bindKeydown: function() {
+                this.$body.on( 'keydown.select', _.bind( this.handleKeydown, this ) );
+        },
+
+        unbindKeydown: function() {
+                this.$body.off( 'keydown.select' );
+        },
+
+        fixPosition: function() {
+                var $browser, $toolbar;
+                if ( ! this.isModeActive( 'select' ) ) {
+                        return;
+                }
+
+                $browser = this.$('.attachments-browser');
+                $toolbar = $browser.find('.media-toolbar');
+
+                // Offset doesn't appear to take top margin into account, hence +16
+                if ( ( $browser.offset().top + 16 ) < this.$window.scrollTop() + this.$adminBar.height() ) {
+                        $browser.addClass( 'fixed' );
+                        $toolbar.css('width', $browser.width() + 'px');
+                } else {
+                        $browser.removeClass( 'fixed' );
+                        $toolbar.css('width', '');
+                }
+        },
+
+        /**
+         * Click handler for the `Add New` button.
+         */
+        addNewClickHandler: function( event ) {
+                event.preventDefault();
+                this.trigger( 'toggle:upload:attachment' );
+        },
+
+        /**
+         * Open the Edit Attachment modal.
+         */
+        openEditAttachmentModal: function( model ) {
+                // Create a new EditAttachment frame, passing along the library and the attachment model.
+                wp.media( {
+                        frame:       'edit-attachments',
+                        controller:  this,
+                        library:     this.state().get('library'),
+                        model:       model
+                } );
+        },
+
+        /**
+         * Create an attachments browser view within the content region.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         * @this wp.media.controller.Region
+         */
+        browseContent: function( contentRegion ) {
+                var state = this.state();
+
+                // Browse our library of attachments.
+                this.browserView = contentRegion.view = new AttachmentsBrowser({
+                        controller: this,
+                        collection: state.get('library'),
+                        selection:  state.get('selection'),
+                        model:      state,
+                        sortable:   state.get('sortable'),
+                        search:     state.get('searchable'),
+                        filters:    state.get('filterable'),
+                        display:    state.get('displaySettings'),
+                        dragInfo:   state.get('dragInfo'),
+                        sidebar:    'errors',
+
+                        suggestedWidth:  state.get('suggestedWidth'),
+                        suggestedHeight: state.get('suggestedHeight'),
+
+                        AttachmentView: state.get('AttachmentView'),
+
+                        scrollElement: document
+                });
+                this.browserView.on( 'ready', _.bind( this.bindDeferred, this ) );
+
+                this.errors = wp.Uploader.errors;
+                this.errors.on( 'add remove reset', this.sidebarVisibility, this );
+        },
+
+        sidebarVisibility: function() {
+                this.browserView.$( '.media-sidebar' ).toggle( !! this.errors.length );
+        },
+
+        bindDeferred: function() {
+                if ( ! this.browserView.dfd ) {
+                        return;
+                }
+                this.browserView.dfd.done( _.bind( this.startHistory, this ) );
+        },
+
+        startHistory: function() {
+                // Verify pushState support and activate
+                if ( window.history && window.history.pushState ) {
+                        Backbone.history.start( {
+                                root: _wpMediaGridSettings.adminUrl,
+                                pushState: true
+                        } );
+                }
+        }
+});
+
+module.exports = Manage;
+},{"../../controllers/library.js":3,"../../router/manage.js":12,"../attachments/browser.js":24,"../media-frame.js":38,"../uploader/window.js":54}],35:[function(require,module,exports){
+/**
+ * wp.media.view.Iframe
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Iframe;
+
+Iframe = View.extend({
+        className: 'media-iframe',
+        /**
+         * @returns {wp.media.view.Iframe} Returns itself to allow chaining
+         */
+        render: function() {
+                this.views.detach();
+                this.$el.html( '<iframe src="' + this.controller.state().get('src') + '" />' );
+                this.views.render();
+                return this;
+        }
+});
+
+module.exports = Iframe;
+},{"./view.js":55}],36:[function(require,module,exports){
+/**
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Label;
+
+Label = View.extend({
+        tagName: 'label',
+        className: 'screen-reader-text',
+
+        initialize: function() {
+                this.value = this.options.value;
+        },
+
+        render: function() {
+                this.$el.html( this.value );
+
+                return this;
+        }
+});
+
+module.exports = Label;
+},{"./view.js":55}],37:[function(require,module,exports){
+/**
+ * wp.media.view.MediaDetails
+ *
+ * @constructor
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentDisplay = require( './settings/attachment-display.js' ),
+        $ = jQuery,
+        MediaDetails;
+
+MediaDetails = AttachmentDisplay.extend({
+        initialize: function() {
+                _.bindAll(this, 'success');
+                this.players = [];
+                this.listenTo( this.controller, 'close', wp.media.mixin.unsetPlayers );
+                this.on( 'ready', this.setPlayer );
+                this.on( 'media:setting:remove', wp.media.mixin.unsetPlayers, this );
+                this.on( 'media:setting:remove', this.render );
+                this.on( 'media:setting:remove', this.setPlayer );
+                this.events = _.extend( this.events, {
+                        'click .remove-setting' : 'removeSetting',
+                        'change .content-track' : 'setTracks',
+                        'click .remove-track' : 'setTracks',
+                        'click .add-media-source' : 'addSource'
+                } );
+
+                AttachmentDisplay.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+
+        /**
+         * Remove a setting's UI when the model unsets it
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         *
+         * @param {Event} e
+         */
+        removeSetting : function(e) {
+                var wrap = $( e.currentTarget ).parent(), setting;
+                setting = wrap.find( 'input' ).data( 'setting' );
+
+                if ( setting ) {
+                        this.model.unset( setting );
+                        this.trigger( 'media:setting:remove', this );
+                }
+
+                wrap.remove();
+        },
+
+        /**
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         */
+        setTracks : function() {
+                var tracks = '';
+
+                _.each( this.$('.content-track'), function(track) {
+                        tracks += $( track ).val();
+                } );
+
+                this.model.set( 'content', tracks );
+                this.trigger( 'media:setting:remove', this );
+        },
+
+        addSource : function( e ) {
+                this.controller.lastMime = $( e.currentTarget ).data( 'mime' );
+                this.controller.setState( 'add-' + this.controller.defaults.id + '-source' );
+        },
+
+        /**
+         * @global MediaElementPlayer
+         */
+        setPlayer : function() {
+                if ( ! this.players.length && this.media ) {
+                        this.players.push( new MediaElementPlayer( this.media, this.settings ) );
+                }
+        },
+
+        /**
+         * @abstract
+         */
+        setMedia : function() {
+                return this;
+        },
+
+        success : function(mejs) {
+                var autoplay = mejs.attributes.autoplay && 'false' !== mejs.attributes.autoplay;
+
+                if ( 'flash' === mejs.pluginType && autoplay ) {
+                        mejs.addEventListener( 'canplay', function() {
+                                mejs.play();
+                        }, false );
+                }
+
+                this.mejs = mejs;
+        },
+
+        /**
+         * @returns {media.view.MediaDetails} Returns itself to allow chaining
+         */
+        render: function() {
+                var self = this;
+
+                AttachmentDisplay.prototype.render.apply( this, arguments );
+                setTimeout( function() { self.resetFocus(); }, 10 );
+
+                this.settings = _.defaults( {
+                        success : this.success
+                }, wp.media.mixin.mejsSettings );
+
+                return this.setMedia();
+        },
+
+        resetFocus: function() {
+                this.$( '.embed-media-settings' ).scrollTop( 0 );
+        }
+}, {
+        instances : 0,
+        /**
+         * When multiple players in the DOM contain the same src, things get weird.
+         *
+         * @param {HTMLElement} elem
+         * @returns {HTMLElement}
+         */
+        prepareSrc : function( elem ) {
+                var i = MediaDetails.instances++;
+                _.each( $( elem ).find( 'source' ), function( source ) {
+                        source.src = [
+                                source.src,
+                                source.src.indexOf('?') > -1 ? '&' : '?',
+                                '_=',
+                                i
+                        ].join('');
+                } );
+
+                return elem;
+        }
+});
+
+module.exports = MediaDetails;
+},{"./settings/attachment-display.js":47}],38:[function(require,module,exports){
+/**
+ * wp.media.view.MediaFrame
+ *
+ * The frame used to create the media modal.
+ *
+ * @class
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( './view.js' ),
+        Frame = require( './frame.js' ),
+        Modal = require( './modal.js' ),
+        UploaderWindow = require( './uploader/window.js' ),
+        Menu = require( './menu.js' ),
+        Toolbar = require( './toolbar.js' ),
+        Router = require( './router.js' ),
+        Iframe = require( './iframe.js' ),
+        $ = jQuery,
+        MediaFrame;
+
+MediaFrame = Frame.extend({
+        className: 'media-frame',
+        template:  wp.template('media-frame'),
+        regions:   ['menu','title','content','toolbar','router'],
+
+        events: {
+                'click div.media-frame-title h1': 'toggleMenu'
+        },
+
+        /**
+         * @global wp.Uploader
+         */
+        initialize: function() {
+                Frame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        title:    '',
+                        modal:    true,
+                        uploader: true
+                });
+
+                // Ensure core UI is enabled.
+                this.$el.addClass('wp-core-ui');
+
+                // Initialize modal container view.
+                if ( this.options.modal ) {
+                        this.modal = new Modal({
+                                controller: this,
+                                title:      this.options.title
+                        });
+
+                        this.modal.content( this );
+                }
+
+                // Force the uploader off if the upload limit has been exceeded or
+                // if the browser isn't supported.
+                if ( wp.Uploader.limitExceeded || ! wp.Uploader.browser.supported ) {
+                        this.options.uploader = false;
+                }
+
+                // Initialize window-wide uploader.
+                if ( this.options.uploader ) {
+                        this.uploader = new UploaderWindow({
+                                controller: this,
+                                uploader: {
+                                        dropzone:  this.modal ? this.modal.$el : this.$el,
+                                        container: this.$el
+                                }
+                        });
+                        this.views.set( '.media-frame-uploader', this.uploader );
+                }
+
+                this.on( 'attach', _.bind( this.views.ready, this.views ), this );
+
+                // Bind default title creation.
+                this.on( 'title:create:default', this.createTitle, this );
+                this.title.mode('default');
+
+                this.on( 'title:render', function( view ) {
+                        view.$el.append( '<span class="dashicons dashicons-arrow-down"></span>' );
+                });
+
+                // Bind default menu.
+                this.on( 'menu:create:default', this.createMenu, this );
+        },
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        render: function() {
+                // Activate the default state if no active state exists.
+                if ( ! this.state() && this.options.state ) {
+                        this.setState( this.options.state );
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                return Frame.prototype.render.apply( this, arguments );
+        },
+        /**
+         * @param {Object} title
+         * @this wp.media.controller.Region
+         */
+        createTitle: function( title ) {
+                title.view = new View({
+                        controller: this,
+                        tagName: 'h1'
+                });
+        },
+        /**
+         * @param {Object} menu
+         * @this wp.media.controller.Region
+         */
+        createMenu: function( menu ) {
+                menu.view = new Menu({
+                        controller: this
+                });
+        },
+
+        toggleMenu: function() {
+                this.$el.find( '.media-menu' ).toggleClass( 'visible' );
+        },
+
+        /**
+         * @param {Object} toolbar
+         * @this wp.media.controller.Region
+         */
+        createToolbar: function( toolbar ) {
+                toolbar.view = new Toolbar({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} router
+         * @this wp.media.controller.Region
+         */
+        createRouter: function( router ) {
+                router.view = new Router({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} options
+         */
+        createIframeStates: function( options ) {
+                var settings = wp.media.view.settings,
+                        tabs = settings.tabs,
+                        tabUrl = settings.tabUrl,
+                        $postId;
+
+                if ( ! tabs || ! tabUrl ) {
+                        return;
+                }
+
+                // Add the post ID to the tab URL if it exists.
+                $postId = $('#post_ID');
+                if ( $postId.length ) {
+                        tabUrl += '&post_id=' + $postId.val();
+                }
+
+                // Generate the tab states.
+                _.each( tabs, function( title, id ) {
+                        this.state( 'iframe:' + id ).set( _.defaults({
+                                tab:     id,
+                                src:     tabUrl + '&tab=' + id,
+                                title:   title,
+                                content: 'iframe',
+                                menu:    'default'
+                        }, options ) );
+                }, this );
+
+                this.on( 'content:create:iframe', this.iframeContent, this );
+                this.on( 'content:deactivate:iframe', this.iframeContentCleanup, this );
+                this.on( 'menu:render:default', this.iframeMenu, this );
+                this.on( 'open', this.hijackThickbox, this );
+                this.on( 'close', this.restoreThickbox, this );
+        },
+
+        /**
+         * @param {Object} content
+         * @this wp.media.controller.Region
+         */
+        iframeContent: function( content ) {
+                this.$el.addClass('hide-toolbar');
+                content.view = new Iframe({
+                        controller: this
+                });
+        },
+
+        iframeContentCleanup: function() {
+                this.$el.removeClass('hide-toolbar');
+        },
+
+        iframeMenu: function( view ) {
+                var views = {};
+
+                if ( ! view ) {
+                        return;
+                }
+
+                _.each( wp.media.view.settings.tabs, function( title, id ) {
+                        views[ 'iframe:' + id ] = {
+                                text: this.state( 'iframe:' + id ).get('title'),
+                                priority: 200
+                        };
+                }, this );
+
+                view.set( views );
+        },
+
+        hijackThickbox: function() {
+                var frame = this;
+
+                if ( ! window.tb_remove || this._tb_remove ) {
+                        return;
+                }
+
+                this._tb_remove = window.tb_remove;
+                window.tb_remove = function() {
+                        frame.close();
+                        frame.reset();
+                        frame.setState( frame.options.state );
+                        frame._tb_remove.call( window );
+                };
+        },
+
+        restoreThickbox: function() {
+                if ( ! this._tb_remove ) {
+                        return;
+                }
+
+                window.tb_remove = this._tb_remove;
+                delete this._tb_remove;
+        }
+});
+
+// Map some of the modal's methods to the frame.
+_.each(['open','close','attach','detach','escape'], function( method ) {
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        MediaFrame.prototype[ method ] = function() {
+                if ( this.modal ) {
+                        this.modal[ method ].apply( this.modal, arguments );
+                }
+                return this;
+        };
+});
+
+module.exports = MediaFrame;
+},{"./frame.js":32,"./iframe.js":35,"./menu.js":40,"./modal.js":41,"./router.js":44,"./toolbar.js":50,"./uploader/window.js":54,"./view.js":55}],39:[function(require,module,exports){
+/**
+ * wp.media.view.MenuItem
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        MenuItem;
+
+MenuItem = View.extend({
+        tagName:   'a',
+        className: 'media-menu-item',
+
+        attributes: {
+                href: '#'
+        },
+
+        events: {
+                'click': '_click'
+        },
+        /**
+         * @param {Object} event
+         */
+        _click: function( event ) {
+                var clickOverride = this.options.click;
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                if ( clickOverride ) {
+                        clickOverride.call( this );
+                } else {
+                        this.click();
+                }
+
+                // When selecting a tab along the left side,
+                // focus should be transferred into the main panel
+                if ( ! wp.media.isTouchDevice ) {
+                        $('.media-frame-content input').first().focus();
+                }
+        },
+
+        click: function() {
+                var state = this.options.state;
+
+                if ( state ) {
+                        this.controller.setState( state );
+                        this.views.parent.$el.removeClass( 'visible' ); // TODO: or hide on any click, see below
+                }
+        },
+        /**
+         * @returns {wp.media.view.MenuItem} returns itself to allow chaining
+         */
+        render: function() {
+                var options = this.options;
+
+                if ( options.text ) {
+                        this.$el.text( options.text );
+                } else if ( options.html ) {
+                        this.$el.html( options.html );
+                }
+
+                return this;
+        }
+});
+
+module.exports = MenuItem;
+},{"./view.js":55}],40:[function(require,module,exports){
+/**
+ * wp.media.view.Menu
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Menu;
+
+Menu = PriorityList.extend({
+        tagName:   'div',
+        className: 'media-menu',
+        property:  'state',
+        ItemView:  MenuItem,
+        region:    'menu',
+
+        /* TODO: alternatively hide on any click anywhere
+        events: {
+                'click': 'click'
+        },
+
+        click: function() {
+                this.$el.removeClass( 'visible' );
+        },
+        */
+
+        /**
+         * @param {Object} options
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        toView: function( options, id ) {
+                options = options || {};
+                options[ this.property ] = options[ this.property ] || id;
+                return new this.ItemView( options ).render();
+        },
+
+        ready: function() {
+                /**
+                 * call 'ready' directly on the parent class
+                 */
+                PriorityList.prototype.ready.apply( this, arguments );
+                this.visibility();
+        },
+
+        set: function() {
+                /**
+                 * call 'set' directly on the parent class
+                 */
+                PriorityList.prototype.set.apply( this, arguments );
+                this.visibility();
+        },
+
+        unset: function() {
+                /**
+                 * call 'unset' directly on the parent class
+                 */
+                PriorityList.prototype.unset.apply( this, arguments );
+                this.visibility();
+        },
+
+        visibility: function() {
+                var region = this.region,
+                        view = this.controller[ region ].get(),
+                        views = this.views.get(),
+                        hide = ! views || views.length < 2;
+
+                if ( this === view ) {
+                        this.controller.$el.toggleClass( 'hide-' + region, hide );
+                }
+        },
+        /**
+         * @param {string} id
+         */
+        select: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                this.deselect();
+                view.$el.addClass('active');
+        },
+
+        deselect: function() {
+                this.$el.children().removeClass('active');
+        },
+
+        hide: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.addClass('hidden');
+        },
+
+        show: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.removeClass('hidden');
+        }
+});
+
+module.exports = Menu;
+},{"./menu-item.js":39,"./priority-list.js":42}],41:[function(require,module,exports){
+/**
+ * wp.media.view.Modal
+ *
+ * A modal view, which the media modal uses as its default container.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager = require( './focus-manager.js' ),
+        $ = jQuery,
+        Modal;
+
+Modal = View.extend({
+        tagName:  'div',
+        template: wp.template('media-modal'),
+
+        attributes: {
+                tabindex: 0
+        },
+
+        events: {
+                'click .media-modal-backdrop, .media-modal-close': 'escapeHandler',
+                'keydown': 'keydown'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        container: document.body,
+                        title:     '',
+                        propagate: true,
+                        freeze:    true
+                });
+
+                this.focusManager = new FocusManager({
+                        el: this.el
+                });
+        },
+        /**
+         * @returns {Object}
+         */
+        prepare: function() {
+                return {
+                        title: this.options.title
+                };
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        attach: function() {
+                if ( this.views.attached ) {
+                        return this;
+                }
+
+                if ( ! this.views.rendered ) {
+                        this.render();
+                }
+
+                this.$el.appendTo( this.options.container );
+
+                // Manually mark the view as attached and trigger ready.
+                this.views.attached = true;
+                this.views.ready();
+
+                return this.propagate('attach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        detach: function() {
+                if ( this.$el.is(':visible') ) {
+                        this.close();
+                }
+
+                this.$el.detach();
+                this.views.attached = false;
+                return this.propagate('detach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        open: function() {
+                var $el = this.$el,
+                        options = this.options,
+                        mceEditor;
+
+                if ( $el.is(':visible') ) {
+                        return this;
+                }
+
+                if ( ! this.views.attached ) {
+                        this.attach();
+                }
+
+                // If the `freeze` option is set, record the window's scroll position.
+                if ( options.freeze ) {
+                        this._freeze = {
+                                scrollTop: $( window ).scrollTop()
+                        };
+                }
+
+                // Disable page scrolling.
+                $( 'body' ).addClass( 'modal-open' );
+
+                $el.show();
+
+                // Try to close the onscreen keyboard
+                if ( 'ontouchend' in document ) {
+                        if ( ( mceEditor = window.tinymce && window.tinymce.activeEditor )  && ! mceEditor.isHidden() && mceEditor.iframeElement ) {
+                                mceEditor.iframeElement.focus();
+                                mceEditor.iframeElement.blur();
+
+                                setTimeout( function() {
+                                        mceEditor.iframeElement.blur();
+                                }, 100 );
+                        }
+                }
+
+                this.$el.focus();
+
+                return this.propagate('open');
+        },
+
+        /**
+         * @param {Object} options
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        close: function( options ) {
+                var freeze = this._freeze;
+
+                if ( ! this.views.attached || ! this.$el.is(':visible') ) {
+                        return this;
+                }
+
+                // Enable page scrolling.
+                $( 'body' ).removeClass( 'modal-open' );
+
+                // Hide modal and remove restricted media modal tab focus once it's closed
+                this.$el.hide().undelegate( 'keydown' );
+
+                // Put focus back in useful location once modal is closed
+                $('#wpbody-content').focus();
+
+                this.propagate('close');
+
+                // If the `freeze` option is set, restore the container's scroll position.
+                if ( freeze ) {
+                        $( window ).scrollTop( freeze.scrollTop );
+                }
+
+                if ( options && options.escape ) {
+                        this.propagate('escape');
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        escape: function() {
+                return this.close({ escape: true });
+        },
+        /**
+         * @param {Object} event
+         */
+        escapeHandler: function( event ) {
+                event.preventDefault();
+                this.escape();
+        },
+
+        /**
+         * @param {Array|Object} content Views to register to '.media-modal-content'
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        content: function( content ) {
+                this.views.set( '.media-modal-content', content );
+                return this;
+        },
+
+        /**
+         * Triggers a modal event and if the `propagate` option is set,
+         * forwards events to the modal's controller.
+         *
+         * @param {string} id
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        propagate: function( id ) {
+                this.trigger( id );
+
+                if ( this.options.propagate ) {
+                        this.controller.trigger( id );
+                }
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        keydown: function( event ) {
+                // Close the modal when escape is pressed.
+                if ( 27 === event.which && this.$el.is(':visible') ) {
+                        this.escape();
+                        event.stopImmediatePropagation();
+                }
+        }
+});
+
+module.exports = Modal;
+},{"./focus-manager.js":31,"./view.js":55}],42:[function(require,module,exports){
+/**
+ * wp.media.view.PriorityList
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        PriorityList;
+
+PriorityList = View.extend({
+        tagName:   'div',
+
+        initialize: function() {
+                this._views = {};
+
+                this.set( _.extend( {}, this._views, this.options.views ), { silent: true });
+                delete this.options.views;
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+        },
+        /**
+         * @param {string} id
+         * @param {wp.media.View|Object} view
+         * @param {Object} options
+         * @returns {wp.media.view.PriorityList} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var priority, views, index;
+
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view );
+                        }, this );
+                        return this;
+                }
+
+                if ( ! (view instanceof Backbone.View) ) {
+                        view = this.toView( view, id, options );
+                }
+                view.controller = view.controller || this.controller;
+
+                this.unset( id );
+
+                priority = view.options.priority || 10;
+                views = this.views.get() || [];
+
+                _.find( views, function( existing, i ) {
+                        if ( existing.options.priority > priority ) {
+                                index = i;
+                                return true;
+                        }
+                });
+
+                this._views[ id ] = view;
+                this.views.add( view, {
+                        at: _.isNumber( index ) ? index : views.length || 0
+                });
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.PriorityList}
+         */
+        unset: function( id ) {
+                var view = this.get( id );
+
+                if ( view ) {
+                        view.remove();
+                }
+
+                delete this._views[ id ];
+                return this;
+        },
+        /**
+         * @param {Object} options
+         * @returns {wp.media.View}
+         */
+        toView: function( options ) {
+                return new View( options );
+        }
+});
+
+module.exports = PriorityList;
+},{"./view.js":55}],43:[function(require,module,exports){
+/**
+ * wp.media.view.RouterItem
+ *
+ * @class
+ * @augments wp.media.view.MenuItem
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        RouterItem;
+
+RouterItem = MenuItem.extend({
+        /**
+         * On click handler to activate the content region's corresponding mode.
+         */
+        click: function() {
+                var contentMode = this.options.contentMode;
+                if ( contentMode ) {
+                        this.controller.content.mode( contentMode );
+                }
+        }
+});
+
+module.exports = RouterItem;
+},{"./menu-item.js":39}],44:[function(require,module,exports){
+/**
+ * wp.media.view.Router
+ *
+ * @class
+ * @augments wp.media.view.Menu
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Menu = require( './menu.js' ),
+        RouterItem = require( './router-item.js' ),
+        Router;
+
+Router = Menu.extend({
+        tagName:   'div',
+        className: 'media-router',
+        property:  'contentMode',
+        ItemView:  RouterItem,
+        region:    'router',
+
+        initialize: function() {
+                this.controller.on( 'content:render', this.update, this );
+                // Call 'initialize' directly on the parent class.
+                Menu.prototype.initialize.apply( this, arguments );
+        },
+
+        update: function() {
+                var mode = this.controller.content.mode();
+                if ( mode ) {
+                        this.select( mode );
+                }
+        }
+});
+
+module.exports = Router;
+},{"./menu.js":40,"./router-item.js":43}],45:[function(require,module,exports){
+/**
+ * wp.media.view.Search
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        l10n = wp.media.view.l10n,
+        Search;
+
+Search = View.extend({
+        tagName:   'input',
+        className: 'search',
+        id:        'media-search-input',
+
+        attributes: {
+                type:        'search',
+                placeholder: l10n.search
+        },
+
+        events: {
+                'input':  'search',
+                'keyup':  'search',
+                'change': 'search',
+                'search': 'search'
+        },
+
+        /**
+         * @returns {wp.media.view.Search} Returns itself to allow chaining
+         */
+        render: function() {
+                this.el.value = this.model.escape('search');
+                return this;
+        },
+
+        search: function( event ) {
+                if ( event.target.value ) {
+                        this.model.set( 'search', event.target.value );
+                } else {
+                        this.model.unset('search');
+                }
+        }
+});
+
+module.exports = Search;
+},{"./view.js":55}],46:[function(require,module,exports){
+/**
+ * wp.media.view.Settings
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Settings;
+
+Settings = View.extend({
+        events: {
+                'click button':    'updateHandler',
+                'change input':    'updateHandler',
+                'change select':   'updateHandler',
+                'change textarea': 'updateHandler'
+        },
+
+        initialize: function() {
+                this.model = this.model || new Backbone.Model();
+                this.model.on( 'change', this.updateChanges, this );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+        /**
+         * @returns {wp.media.view.Settings} Returns itself to allow chaining
+         */
+        render: function() {
+                View.prototype.render.apply( this, arguments );
+                // Select the correct values.
+                _( this.model.attributes ).chain().keys().each( this.update, this );
+                return this;
+        },
+        /**
+         * @param {string} key
+         */
+        update: function( key ) {
+                var value = this.model.get( key ),
+                        $setting = this.$('[data-setting="' + key + '"]'),
+                        $buttons, $value;
+
+                // Bail if we didn't find a matching setting.
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Attempt to determine how the setting is rendered and update
+                // the selected value.
+
+                // Handle dropdowns.
+                if ( $setting.is('select') ) {
+                        $value = $setting.find('[value="' + value + '"]');
+
+                        if ( $value.length ) {
+                                $setting.find('option').prop( 'selected', false );
+                                $value.prop( 'selected', true );
+                        } else {
+                                // If we can't find the desired value, record what *is* selected.
+                                this.model.set( key, $setting.find(':selected').val() );
+                        }
+
+                // Handle button groups.
+                } else if ( $setting.hasClass('button-group') ) {
+                        $buttons = $setting.find('button').removeClass('active');
+                        $buttons.filter( '[value="' + value + '"]' ).addClass('active');
+
+                // Handle text inputs and textareas.
+                } else if ( $setting.is('input[type="text"], textarea') ) {
+                        if ( ! $setting.is(':focus') ) {
+                                $setting.val( value );
+                        }
+                // Handle checkboxes.
+                } else if ( $setting.is('input[type="checkbox"]') ) {
+                        $setting.prop( 'checked', !! value && 'false' !== value );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateHandler: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        value = event.target.value,
+                        userSetting;
+
+                event.preventDefault();
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Use the correct value for checkboxes.
+                if ( $setting.is('input[type="checkbox"]') ) {
+                        value = $setting[0].checked;
+                }
+
+                // Update the corresponding setting.
+                this.model.set( $setting.data('setting'), value );
+
+                // If the setting has a corresponding user setting,
+                // update that as well.
+                if ( userSetting = $setting.data('userSetting') ) {
+                        setUserSetting( userSetting, value );
+                }
+        },
+
+        updateChanges: function( model ) {
+                if ( model.hasChanged() ) {
+                        _( model.changed ).chain().keys().each( this.update, this );
+                }
+        }
+});
+
+module.exports = Settings;
+},{"./view.js":55}],47:[function(require,module,exports){
+/**
+ * wp.media.view.Settings.AttachmentDisplay
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        AttachmentDisplay;
+
+AttachmentDisplay = Settings.extend({
+        className: 'attachment-display-settings',
+        template:  wp.template('attachment-display-settings'),
+
+        initialize: function() {
+                var attachment = this.options.attachment;
+
+                _.defaults( this.options, {
+                        userSettings: false
+                });
+                // Call 'initialize' directly on the parent class.
+                Settings.prototype.initialize.apply( this, arguments );
+                this.model.on( 'change:link', this.updateLinkTo, this );
+
+                if ( attachment ) {
+                        attachment.on( 'change:uploading', this.render, this );
+                }
+        },
+
+        dispose: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        attachment.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                Settings.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentDisplay} Returns itself to allow chaining
+         */
+        render: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        _.extend( this.options, {
+                                sizes: attachment.get('sizes'),
+                                type:  attachment.get('type')
+                        });
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                Settings.prototype.render.call( this );
+                this.updateLinkTo();
+                return this;
+        },
+
+        updateLinkTo: function() {
+                var linkTo = this.model.get('link'),
+                        $input = this.$('.link-to-custom'),
+                        attachment = this.options.attachment;
+
+                if ( 'none' === linkTo || 'embed' === linkTo || ( ! attachment && 'custom' !== linkTo ) ) {
+                        $input.addClass( 'hidden' );
+                        return;
+                }
+
+                if ( attachment ) {
+                        if ( 'post' === linkTo ) {
+                                $input.val( attachment.get('link') );
+                        } else if ( 'file' === linkTo ) {
+                                $input.val( attachment.get('url') );
+                        } else if ( ! this.model.get('linkUrl') ) {
+                                $input.val('http://');
+                        }
+
+                        $input.prop( 'readonly', 'custom' !== linkTo );
+                }
+
+                $input.removeClass( 'hidden' );
+
+                // If the input is visible, focus and select its contents.
+                if ( ! wp.media.isTouchDevice && $input.is(':visible') ) {
+                        $input.focus()[0].select();
+                }
+        }
+});
+
+module.exports = AttachmentDisplay;
+},{"../settings.js":46}],48:[function(require,module,exports){
+/**
+ * wp.media.view.Sidebar
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var PriorityList = require( './priority-list.js' ),
+        Sidebar;
+
+Sidebar = PriorityList.extend({
+        className: 'media-sidebar'
+});
+
+module.exports = Sidebar;
+},{"./priority-list.js":42}],49:[function(require,module,exports){
+/**
+ * wp.media.view.Spinner
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Spinner;
+
+Spinner = View.extend({
+        tagName:   'span',
+        className: 'spinner',
+        spinnerTimeout: false,
+        delay: 400,
+
+        show: function() {
+                if ( ! this.spinnerTimeout ) {
+                        this.spinnerTimeout = _.delay(function( $el ) {
+                                $el.show();
+                        }, this.delay, this.$el );
+                }
+
+                return this;
+        },
+
+        hide: function() {
+                this.$el.hide();
+                this.spinnerTimeout = clearTimeout( this.spinnerTimeout );
+
+                return this;
+        }
+});
+
+module.exports = Spinner;
+},{"./view.js":55}],50:[function(require,module,exports){
+/**
+ * wp.media.view.Toolbar
+ *
+ * A toolbar which consists of a primary and a secondary section. Each sections
+ * can be filled with views.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button = require( './button.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Toolbar;
+
+Toolbar = View.extend({
+        tagName:   'div',
+        className: 'media-toolbar',
+
+        initialize: function() {
+                var state = this.controller.state(),
+                        selection = this.selection = state.get('selection'),
+                        library = this.library = state.get('library');
+
+                this._views = {};
+
+                // The toolbar is composed of two `PriorityList` views.
+                this.primary   = new PriorityList();
+                this.secondary = new PriorityList();
+                this.primary.$el.addClass('media-toolbar-primary search-form');
+                this.secondary.$el.addClass('media-toolbar-secondary');
+
+                this.views.set([ this.secondary, this.primary ]);
+
+                if ( this.options.items ) {
+                        this.set( this.options.items, { silent: true });
+                }
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+
+                if ( selection ) {
+                        selection.on( 'add remove reset', this.refresh, this );
+                }
+
+                if ( library ) {
+                        library.on( 'add remove reset', this.refresh, this );
+                }
+        },
+        /**
+         * @returns {wp.media.view.Toolbar} Returns itsef to allow chaining
+         */
+        dispose: function() {
+                if ( this.selection ) {
+                        this.selection.off( null, null, this );
+                }
+
+                if ( this.library ) {
+                        this.library.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+
+        ready: function() {
+                this.refresh();
+        },
+
+        /**
+         * @param {string} id
+         * @param {Backbone.View|Object} view
+         * @param {Object} [options={}]
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var list;
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view, { silent: true });
+                        }, this );
+
+                } else {
+                        if ( ! ( view instanceof Backbone.View ) ) {
+                                view.classes = [ 'media-button-' + id ].concat( view.classes || [] );
+                                view = new Button( view ).render();
+                        }
+
+                        view.controller = view.controller || this.controller;
+
+                        this._views[ id ] = view;
+
+                        list = view.options.priority < 0 ? 'secondary' : 'primary';
+                        this[ list ].set( id, view, options );
+                }
+
+                if ( ! options.silent ) {
+                        this.refresh();
+                }
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.Button}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @param {Object} options
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        unset: function( id, options ) {
+                delete this._views[ id ];
+                this.primary.unset( id, options );
+                this.secondary.unset( id, options );
+
+                if ( ! options || ! options.silent ) {
+                        this.refresh();
+                }
+                return this;
+        },
+
+        refresh: function() {
+                var state = this.controller.state(),
+                        library = state.get('library'),
+                        selection = state.get('selection');
+
+                _.each( this._views, function( button ) {
+                        if ( ! button.model || ! button.options || ! button.options.requires ) {
+                                return;
+                        }
+
+                        var requires = button.options.requires,
+                                disabled = false;
+
+                        // Prevent insertion of attachments if any of them are still uploading
+                        disabled = _.some( selection.models, function( attachment ) {
+                                return attachment.get('uploading') === true;
+                        });
+
+                        if ( requires.selection && selection && ! selection.length ) {
+                                disabled = true;
+                        } else if ( requires.library && library && ! library.length ) {
+                                disabled = true;
+                        }
+                        button.model.set( 'disabled', disabled );
+                });
+        }
+});
+
+module.exports = Toolbar;
+},{"./button.js":25,"./priority-list.js":42,"./view.js":55}],51:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderInline
+ *
+ * The inline uploader that shows up in the 'Upload Files' tab.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatus = require( './status.js' ),
+        UploaderInline;
+
+UploaderInline = View.extend({
+        tagName:   'div',
+        className: 'uploader-inline',
+        template:  wp.template('uploader-inline'),
+
+        events: {
+                'click .close': 'hide'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        message: '',
+                        status:  true,
+                        canClose: false
+                });
+
+                if ( ! this.options.$browser && this.controller.uploader ) {
+                        this.options.$browser = this.controller.uploader.$browser;
+                }
+
+                if ( _.isUndefined( this.options.postId ) ) {
+                        this.options.postId = wp.media.view.settings.post.id;
+                }
+
+                if ( this.options.status ) {
+                        this.views.set( '.upload-inline-status', new UploaderStatus({
+                                controller: this.controller
+                        }) );
+                }
+        },
+
+        prepare: function() {
+                var suggestedWidth = this.controller.state().get('suggestedWidth'),
+                        suggestedHeight = this.controller.state().get('suggestedHeight'),
+                        data = {};
+
+                data.message = this.options.message;
+                data.canClose = this.options.canClose;
+
+                if ( suggestedWidth && suggestedHeight ) {
+                        data.suggestedWidth = suggestedWidth;
+                        data.suggestedHeight = suggestedHeight;
+                }
+
+                return data;
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.disposing ) {
+                        /**
+                         * call 'dispose' directly on the parent class
+                         */
+                        return View.prototype.dispose.apply( this, arguments );
+                }
+
+                // Run remove on `dispose`, so we can be sure to refresh the
+                // uploader with a view-less DOM. Track whether we're disposing
+                // so we don't trigger an infinite loop.
+                this.disposing = true;
+                return this.remove();
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        remove: function() {
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                var result = View.prototype.remove.apply( this, arguments );
+
+                _.defer( _.bind( this.refresh, this ) );
+                return result;
+        },
+
+        refresh: function() {
+                var uploader = this.controller.uploader;
+
+                if ( uploader ) {
+                        uploader.refresh();
+                }
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline}
+         */
+        ready: function() {
+                var $browser = this.options.$browser,
+                        $placeholder;
+
+                if ( this.controller.uploader ) {
+                        $placeholder = this.$('.browser');
+
+                        // Check if we've already replaced the placeholder.
+                        if ( $placeholder[0] === $browser[0] ) {
+                                return;
+                        }
+
+                        $browser.detach().text( $placeholder.text() );
+                        $browser[0].className = $placeholder[0].className;
+                        $placeholder.replaceWith( $browser.show() );
+                }
+
+                this.refresh();
+                return this;
+        },
+        show: function() {
+                this.$el.removeClass( 'hidden' );
+        },
+        hide: function() {
+                this.$el.addClass( 'hidden' );
+        }
+
+});
+
+module.exports = UploaderInline;
+},{"../view.js":55,"./status.js":53}],52:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderStatusError
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError;
+
+UploaderStatusError = View.extend({
+        className: 'upload-error',
+        template:  wp.template('uploader-status-error')
+});
+
+module.exports = UploaderStatusError;
+},{"../view.js":55}],53:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderStatus
+ *
+ * An uploader status for on-going uploads.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError = require( './status-error.js' ),
+        UploaderStatus;
+
+UploaderStatus = View.extend({
+        className: 'media-uploader-status',
+        template:  wp.template('uploader-status'),
+
+        events: {
+                'click .upload-dismiss-errors': 'dismiss'
+        },
+
+        initialize: function() {
+                this.queue = wp.Uploader.queue;
+                this.queue.on( 'add remove reset', this.visibility, this );
+                this.queue.on( 'add remove reset change:percent', this.progress, this );
+                this.queue.on( 'add remove reset change:uploading', this.info, this );
+
+                this.errors = wp.Uploader.errors;
+                this.errors.reset();
+                this.errors.on( 'add remove reset', this.visibility, this );
+                this.errors.on( 'add', this.error, this );
+        },
+        /**
+         * @global wp.Uploader
+         * @returns {wp.media.view.UploaderStatus}
+         */
+        dispose: function() {
+                wp.Uploader.queue.off( null, null, this );
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        visibility: function() {
+                this.$el.toggleClass( 'uploading', !! this.queue.length );
+                this.$el.toggleClass( 'errors', !! this.errors.length );
+                this.$el.toggle( !! this.queue.length || !! this.errors.length );
+        },
+
+        ready: function() {
+                _.each({
+                        '$bar':      '.media-progress-bar div',
+                        '$index':    '.upload-index',
+                        '$total':    '.upload-total',
+                        '$filename': '.upload-filename'
+                }, function( selector, key ) {
+                        this[ key ] = this.$( selector );
+                }, this );
+
+                this.visibility();
+                this.progress();
+                this.info();
+        },
+
+        progress: function() {
+                var queue = this.queue,
+                        $bar = this.$bar;
+
+                if ( ! $bar || ! queue.length ) {
+                        return;
+                }
+
+                $bar.width( ( queue.reduce( function( memo, attachment ) {
+                        if ( ! attachment.get('uploading') ) {
+                                return memo + 100;
+                        }
+
+                        var percent = attachment.get('percent');
+                        return memo + ( _.isNumber( percent ) ? percent : 100 );
+                }, 0 ) / queue.length ) + '%' );
+        },
+
+        info: function() {
+                var queue = this.queue,
+                        index = 0, active;
+
+                if ( ! queue.length ) {
+                        return;
+                }
+
+                active = this.queue.find( function( attachment, i ) {
+                        index = i;
+                        return attachment.get('uploading');
+                });
+
+                this.$index.text( index + 1 );
+                this.$total.text( queue.length );
+                this.$filename.html( active ? this.filename( active.get('filename') ) : '' );
+        },
+        /**
+         * @param {string} filename
+         * @returns {string}
+         */
+        filename: function( filename ) {
+                return wp.media.truncate( _.escape( filename ), 24 );
+        },
+        /**
+         * @param {Backbone.Model} error
+         */
+        error: function( error ) {
+                this.views.add( '.upload-errors', new UploaderStatusError({
+                        filename: this.filename( error.get('file').name ),
+                        message:  error.get('message')
+                }), { at: 0 });
+        },
+
+        /**
+         * @global wp.Uploader
+         *
+         * @param {Object} event
+         */
+        dismiss: function( event ) {
+                var errors = this.views.get('.upload-errors');
+
+                event.preventDefault();
+
+                if ( errors ) {
+                        _.invoke( errors, 'remove' );
+                }
+                wp.Uploader.errors.reset();
+        }
+});
+
+module.exports = UploaderStatus;
+},{"../view.js":55,"./status-error.js":52}],54:[function(require,module,exports){
+/**
+ * wp.media.view.UploaderWindow
+ *
+ * An uploader window that allows for dragging and dropping media.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object} [options]                   Options hash passed to the view.
+ * @param {object} [options.uploader]          Uploader properties.
+ * @param {jQuery} [options.uploader.browser]
+ * @param {jQuery} [options.uploader.dropzone] jQuery collection of the dropzone.
+ * @param {object} [options.uploader.params]
+ */
+var View = require( '../view.js' ),
+        $ = jQuery,
+        UploaderWindow;
+
+UploaderWindow = View.extend({
+        tagName:   'div',
+        className: 'uploader-window',
+        template:  wp.template('uploader-window'),
+
+        initialize: function() {
+                var uploader;
+
+                this.$browser = $('<a href="#" class="browser" />').hide().appendTo('body');
+
+                uploader = this.options.uploader = _.defaults( this.options.uploader || {}, {
+                        dropzone:  this.$el,
+                        browser:   this.$browser,
+                        params:    {}
+                });
+
+                // Ensure the dropzone is a jQuery collection.
+                if ( uploader.dropzone && ! (uploader.dropzone instanceof $) ) {
+                        uploader.dropzone = $( uploader.dropzone );
+                }
+
+                this.controller.on( 'activate', this.refresh, this );
+
+                this.controller.on( 'detach', function() {
+                        this.$browser.remove();
+                }, this );
+        },
+
+        refresh: function() {
+                if ( this.uploader ) {
+                        this.uploader.refresh();
+                }
+        },
+
+        ready: function() {
+                var postId = wp.media.view.settings.post.id,
+                        dropzone;
+
+                // If the uploader already exists, bail.
+                if ( this.uploader ) {
+                        return;
+                }
+
+                if ( postId ) {
+                        this.options.uploader.params.post_id = postId;
+                }
+                this.uploader = new wp.Uploader( this.options.uploader );
+
+                dropzone = this.uploader.dropzone;
+                dropzone.on( 'dropzone:enter', _.bind( this.show, this ) );
+                dropzone.on( 'dropzone:leave', _.bind( this.hide, this ) );
+
+                $( this.uploader ).on( 'uploader:ready', _.bind( this._ready, this ) );
+        },
+
+        _ready: function() {
+                this.controller.trigger( 'uploader:ready' );
+        },
+
+        show: function() {
+                var $el = this.$el.show();
+
+                // Ensure that the animation is triggered by waiting until
+                // the transparent element is painted into the DOM.
+                _.defer( function() {
+                        $el.css({ opacity: 1 });
+                });
+        },
+
+        hide: function() {
+                var $el = this.$el.css({ opacity: 0 });
+
+                wp.media.transition( $el ).done( function() {
+                        // Transition end events are subject to race conditions.
+                        // Make sure that the value is set as intended.
+                        if ( '0' === $el.css('opacity') ) {
+                                $el.hide();
+                        }
+                });
+
+                // https://core.trac.wordpress.org/ticket/27341
+                _.delay( function() {
+                        if ( '0' === $el.css('opacity') && $el.is(':visible') ) {
+                                $el.hide();
+                        }
+                }, 500 );
+        }
+});
+
+module.exports = UploaderWindow;
+},{"../view.js":55}],55:[function(require,module,exports){
+/**
+ * wp.media.View
+ *
+ * The base view class for media.
+ *
+ * Undelegating events, removing events from the model, and
+ * removing events from the controller mirror the code for
+ * `Backbone.View.dispose` in Backbone 0.9.8 development.
+ *
+ * This behavior has since been removed, and should not be used
+ * outside of the media manager.
+ *
+ * @class
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = wp.Backbone.View.extend({
+        constructor: function( options ) {
+                if ( options && options.controller ) {
+                        this.controller = options.controller;
+                }
+                wp.Backbone.View.apply( this, arguments );
+        },
+        /**
+         * @todo The internal comment mentions this might have been a stop-gap
+         *       before Backbone 0.9.8 came out. Figure out if Backbone core takes
+         *       care of this in Backbone.View now.
+         *
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        dispose: function() {
+                // Undelegating events, removing events from the model, and
+                // removing events from the controller mirror the code for
+                // `Backbone.View.dispose` in Backbone 0.9.8 development.
+                this.undelegateEvents();
+
+                if ( this.model && this.model.off ) {
+                        this.model.off( null, null, this );
+                }
+
+                if ( this.collection && this.collection.off ) {
+                        this.collection.off( null, null, this );
+                }
+
+                // Unbind controller events.
+                if ( this.controller && this.controller.off ) {
+                        this.controller.off( null, null, this );
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        remove: function() {
+                this.dispose();
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                return wp.Backbone.View.prototype.remove.apply( this, arguments );
+        }
+});
+
+module.exports = View;
+},{}]},{},[7]);

src/wp-includes/js/media/grid.manifest.js

@@ +1 @@
+/* global _wpMediaViewsL10n, MediaElementPlayer, _wpMediaGridSettings */
+(function($, _, Backbone, wp) {
+        var media = wp.media;
+
+        media.controller.EditAttachmentMetadata = require( './controllers/edit-attachment-metadata.js' );
+        media.view.MediaFrame.Manage = require( './views/frame/manage.js' );
+        media.view.Attachment.Details.TwoColumn = require( './views/attachment/details-two-column.js' );
+        media.view.MediaFrame.Manage.Router = require( './router/manage.js' );
+        media.view.EditImage.Details = require( './views/edit-image-details.js' );
+        media.view.MediaFrame.EditAttachments = require( './views/frame/edit-attachments.js' );
+        media.view.SelectModeToggleButton = require( './views/button/select-mode-toggle.js' );
+        media.view.DeleteSelectedButton = require( './views/button/delete-selected.js' );
+        media.view.DeleteSelectedPermanentlyButton = require( './views/button/delete-selected-permanently.js' );
+
+}(jQuery, _, Backbone, wp));

src/wp-includes/js/media/models/attachment.js

@@ +1 @@
+/**
+ * wp.media.model.Attachment
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var $ = jQuery,
+        Attachment;
+
+Attachment = Backbone.Model.extend({
+        /**
+         * Triggered when attachment details change
+         * Overrides Backbone.Model.sync
+         *
+         * @param {string} method
+         * @param {wp.media.model.Attachment} model
+         * @param {Object} [options={}]
+         *
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                // If the attachment does not yet have an `id`, return an instantly
+                // rejected promise. Otherwise, all of our requests will fail.
+                if ( _.isUndefined( this.id ) ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                // Overload the `read` request so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action: 'get-attachment',
+                                id: this.id
+                        });
+                        return wp.media.ajax( options );
+
+                // Overload the `update` request so properties can be saved.
+                } else if ( 'update' === method ) {
+                        // If we do not have the necessary nonce, fail immeditately.
+                        if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                                return $.Deferred().rejectWith( this ).promise();
+                        }
+
+                        options = options || {};
+                        options.context = this;
+
+                        // Set the action and ID.
+                        options.data = _.extend( options.data || {}, {
+                                action:  'save-attachment',
+                                id:      this.id,
+                                nonce:   this.get('nonces').update,
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Record the values of the changed attributes.
+                        if ( model.hasChanged() ) {
+                                options.data.changes = {};
+
+                                _.each( model.changed, function( value, key ) {
+                                        options.data.changes[ key ] = this.get( key );
+                                }, this );
+                        }
+
+                        return wp.media.ajax( options );
+
+                // Overload the `delete` request so attachments can be removed.
+                // This will permanently delete an attachment.
+                } else if ( 'delete' === method ) {
+                        options = options || {};
+
+                        if ( ! options.wait ) {
+                                this.destroyed = true;
+                        }
+
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:   'delete-post',
+                                id:       this.id,
+                                _wpnonce: this.get('nonces')['delete']
+                        });
+
+                        return wp.media.ajax( options ).done( function() {
+                                this.destroyed = true;
+                        }).fail( function() {
+                                this.destroyed = false;
+                        });
+
+                // Otherwise, fall back to `Backbone.sync()`.
+                } else {
+                        /**
+                         * Call `sync` directly on Backbone.Model
+                         */
+                        return Backbone.Model.prototype.sync.apply( this, arguments );
+                }
+        },
+        /**
+         * Convert date strings into Date objects.
+         *
+         * @param {Object} resp The raw response object, typically returned by fetch()
+         * @returns {Object} The modified response object, which is the attributes hash
+         *    to be set on the model.
+         */
+        parse: function( resp ) {
+                if ( ! resp ) {
+                        return resp;
+                }
+
+                resp.date = new Date( resp.date );
+                resp.modified = new Date( resp.modified );
+                return resp;
+        },
+        /**
+         * @param {Object} data The properties to be saved.
+         * @param {Object} options Sync options. e.g. patch, wait, success, error.
+         *
+         * @this Backbone.Model
+         *
+         * @returns {Promise}
+         */
+        saveCompat: function( data, options ) {
+                var model = this;
+
+                // If we do not have the necessary nonce, fail immeditately.
+                if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                return media.post( 'save-attachment-compat', _.defaults({
+                        id:      this.id,
+                        nonce:   this.get('nonces').update,
+                        post_id: wp.media.model.settings.post.id
+                }, data ) ).done( function( resp, status, xhr ) {
+                        model.set( model.parse( resp, xhr ), options );
+                });
+        }
+}, {
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * @static
+         * @param {Object} attrs
+         * @returns {wp.media.model.Attachment}
+         */
+        create: function( attrs ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attrs );
+        },
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * If this function has already been called for the id,
+         * it returns the specified attachment.
+         *
+         * @static
+         * @param {string} id A string used to identify a model.
+         * @param {Backbone.Model|undefined} attachment
+         * @returns {wp.media.model.Attachment}
+         */
+        get: _.memoize( function( id, attachment ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attachment || { id: id } );
+        })
+});
+
+module.exports = Attachment;
+ No newline at end of file

src/wp-includes/js/media/models/attachments.js

@@ +1 @@
+/**
+ * wp.media.model.Attachments
+ *
+ * A collection of attachments.
+ *
+ * This collection has no persistence with the server without supplying
+ * 'options.props.query = true', which will mirror the collection
+ * to an Attachments Query collection - @see wp.media.model.Attachments.mirror().
+ *
+ * @class
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                Models to initialize with the collection.
+ * @param {object} [options]               Options hash for the collection.
+ * @param {string} [options.props]         Options hash for the initial query properties.
+ * @param {string} [options.props.order]   Initial order (ASC or DESC) for the collection.
+ * @param {string} [options.props.orderby] Initial attribute key to order the collection by.
+ * @param {string} [options.props.query]   Whether the collection is linked to an attachments query.
+ * @param {string} [options.observe]
+ * @param {string} [options.filters]
+ *
+ */
+var Attachment = require( './attachment.js' ),
+        Attachments;
+
+Attachments = Backbone.Collection.extend({
+        /**
+         * @type {wp.media.model.Attachment}
+         */
+        model: Attachment,
+        /**
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                options = options || {};
+
+                this.props   = new Backbone.Model();
+                this.filters = options.filters || {};
+
+                // Bind default `change` events to the `props` model.
+                this.props.on( 'change', this._changeFilteredProps, this );
+
+                this.props.on( 'change:order',   this._changeOrder,   this );
+                this.props.on( 'change:orderby', this._changeOrderby, this );
+                this.props.on( 'change:query',   this._changeQuery,   this );
+
+                this.props.set( _.defaults( options.props || {} ) );
+
+                if ( options.observe ) {
+                        this.observe( options.observe );
+                }
+        },
+        /**
+         * Sort the collection when the order attribute changes.
+         *
+         * @access private
+         */
+        _changeOrder: function() {
+                if ( this.comparator ) {
+                        this.sort();
+                }
+        },
+        /**
+         * Set the default comparator only when the `orderby` property is set.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {string} orderby
+         */
+        _changeOrderby: function( model, orderby ) {
+                // If a different comparator is defined, bail.
+                if ( this.comparator && this.comparator !== Attachments.comparator ) {
+                        return;
+                }
+
+                if ( orderby && 'post__in' !== orderby ) {
+                        this.comparator = Attachments.comparator;
+                } else {
+                        delete this.comparator;
+                }
+        },
+        /**
+         * If the `query` property is set to true, query the server using
+         * the `props` values, and sync the results to this collection.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {Boolean} query
+         */
+        _changeQuery: function( model, query ) {
+                if ( query ) {
+                        this.props.on( 'change', this._requery, this );
+                        this._requery();
+                } else {
+                        this.props.off( 'change', this._requery, this );
+                }
+        },
+        /**
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         */
+        _changeFilteredProps: function( model ) {
+                // If this is a query, updating the collection will be handled by
+                // `this._requery()`.
+                if ( this.props.get('query') ) {
+                        return;
+                }
+
+                var changed = _.chain( model.changed ).map( function( t, prop ) {
+                        var filter = Attachments.filters[ prop ],
+                                term = model.get( prop );
+
+                        if ( ! filter ) {
+                                return;
+                        }
+
+                        if ( term && ! this.filters[ prop ] ) {
+                                this.filters[ prop ] = filter;
+                        } else if ( ! term && this.filters[ prop ] === filter ) {
+                                delete this.filters[ prop ];
+                        } else {
+                                return;
+                        }
+
+                        // Record the change.
+                        return true;
+                }, this ).any().value();
+
+                if ( ! changed ) {
+                        return;
+                }
+
+                // If no `Attachments` model is provided to source the searches
+                // from, then automatically generate a source from the existing
+                // models.
+                if ( ! this._source ) {
+                        this._source = new Attachments( this.models );
+                }
+
+                this.reset( this._source.filter( this.validator, this ) );
+        },
+
+        validateDestroyed: false,
+        /**
+         * Checks whether an attachment is valid.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        validator: function( attachment ) {
+                if ( ! this.validateDestroyed && attachment.destroyed ) {
+                        return false;
+                }
+                return _.all( this.filters, function( filter ) {
+                        return !! filter.call( this, attachment );
+                }, this );
+        },
+        /**
+         * Add or remove an attachment to the collection depending on its validity.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validate: function( attachment, options ) {
+                var valid = this.validator( attachment ),
+                        hasAttachment = !! this.get( attachment.cid );
+
+                if ( ! valid && hasAttachment ) {
+                        this.remove( attachment, options );
+                } else if ( valid && ! hasAttachment ) {
+                        this.add( attachment, options );
+                }
+
+                return this;
+        },
+
+        /**
+         * Add or remove all attachments from another collection depending on each one's validity.
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {object} [options={}]
+         *
+         * @fires wp.media.model.Attachments#reset
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validateAll: function( attachments, options ) {
+                options = options || {};
+
+                _.each( attachments.models, function( attachment ) {
+                        this.validate( attachment, { silent: true });
+                }, this );
+
+                if ( ! options.silent ) {
+                        this.trigger( 'reset', this, options );
+                }
+                return this;
+        },
+        /**
+         * Start observing another attachments collection change events
+         * and replicate them on this collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to observe.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining.
+         */
+        observe: function( attachments ) {
+                this.observers = this.observers || [];
+                this.observers.push( attachments );
+
+                attachments.on( 'add change remove', this._validateHandler, this );
+                attachments.on( 'reset', this._validateAllHandler, this );
+                this.validateAll( attachments );
+                return this;
+        },
+        /**
+         * Stop replicating collection change events from another attachments collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to stop observing.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        unobserve: function( attachments ) {
+                if ( attachments ) {
+                        attachments.off( null, null, this );
+                        this.observers = _.without( this.observers, attachments );
+
+                } else {
+                        _.each( this.observers, function( attachments ) {
+                                attachments.off( null, null, this );
+                        }, this );
+                        delete this.observers;
+                }
+
+                return this;
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachment
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateHandler: function( attachment, attachments, options ) {
+                // If we're not mirroring this `attachments` collection,
+                // only retain the `silent` option.
+                options = attachments === this.mirroring ? options : {
+                        silent: options && options.silent
+                };
+
+                return this.validate( attachment, options );
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateAllHandler: function( attachments, options ) {
+                return this.validateAll( attachments, options );
+        },
+        /**
+         * Start mirroring another attachments collection, clearing out any models already
+         * in the collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to mirror.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        mirror: function( attachments ) {
+                if ( this.mirroring && this.mirroring === attachments ) {
+                        return this;
+                }
+
+                this.unmirror();
+                this.mirroring = attachments;
+
+                // Clear the collection silently. A `reset` event will be fired
+                // when `observe()` calls `validateAll()`.
+                this.reset( [], { silent: true } );
+                this.observe( attachments );
+
+                return this;
+        },
+        /**
+         * Stop mirroring another attachments collection.
+         */
+        unmirror: function() {
+                if ( ! this.mirroring ) {
+                        return;
+                }
+
+                this.unobserve( this.mirroring );
+                delete this.mirroring;
+        },
+        /**
+         * Retrive more attachments from the server for the collection.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `more` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @param {object} options
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var deferred = jQuery.Deferred(),
+                        mirroring = this.mirroring,
+                        attachments = this;
+
+                if ( ! mirroring || ! mirroring.more ) {
+                        return deferred.resolveWith( this ).promise();
+                }
+                // If we're mirroring another collection, forward `more` to
+                // the mirrored collection. Account for a race condition by
+                // checking if we're still mirroring that collection when
+                // the request resolves.
+                mirroring.more( options ).done( function() {
+                        if ( this === attachments.mirroring )
+                                deferred.resolveWith( this );
+                });
+
+                return deferred.promise();
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `hasMore` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this.mirroring ? this.mirroring.hasMore() : false;
+        },
+        /**
+         * A custom AJAX-response parser.
+         *
+         * See trac ticket #24753
+         *
+         * @param {Object|Array} resp The raw response Object/Array.
+         * @param {Object} xhr
+         * @returns {Array} The array of model attributes to be added to the collection
+         */
+        parse: function( resp, xhr ) {
+                if ( ! _.isArray( resp ) ) {
+                        resp = [resp];
+                }
+
+                return _.map( resp, function( attrs ) {
+                        var id, attachment, newAttributes;
+
+                        if ( attrs instanceof Backbone.Model ) {
+                                id = attrs.get( 'id' );
+                                attrs = attrs.attributes;
+                        } else {
+                                id = attrs.id;
+                        }
+
+                        attachment = Attachment.get( id );
+                        newAttributes = attachment.parse( attrs, xhr );
+
+                        if ( ! _.isEqual( attachment.attributes, newAttributes ) ) {
+                                attachment.set( newAttributes );
+                        }
+
+                        return attachment;
+                });
+        },
+        /**
+         * If the collection is a query, create and mirror an Attachments Query collection.
+         *
+         * @access private
+         */
+        _requery: function( refresh ) {
+                var props, Query;
+                if ( this.props.get('query') ) {
+                        Query = require( './query.js' );
+                        props = this.props.toJSON();
+                        props.cache = ( true !== refresh );
+                        this.mirror( Query.get( props ) );
+                }
+        },
+        /**
+         * If this collection is sorted by `menuOrder`, recalculates and saves
+         * the menu order to the database.
+         *
+         * @returns {undefined|Promise}
+         */
+        saveMenuOrder: function() {
+                if ( 'menuOrder' !== this.props.get('orderby') ) {
+                        return;
+                }
+
+                // Removes any uploading attachments, updates each attachment's
+                // menu order, and returns an object with an { id: menuOrder }
+                // mapping to pass to the request.
+                var attachments = this.chain().filter( function( attachment ) {
+                        return ! _.isUndefined( attachment.id );
+                }).map( function( attachment, index ) {
+                        // Indices start at 1.
+                        index = index + 1;
+                        attachment.set( 'menuOrder', index );
+                        return [ attachment.id, index ];
+                }).object().value();
+
+                if ( _.isEmpty( attachments ) ) {
+                        return;
+                }
+
+                return wp.media.post( 'save-attachment-order', {
+                        nonce:       wp.media.model.settings.post.nonce,
+                        post_id:     wp.media.model.settings.post.id,
+                        attachments: attachments
+                });
+        }
+}, {
+        /**
+         * A function to compare two attachment models in an attachments collection.
+         *
+         * Used as the default comparator for instances of wp.media.model.Attachments
+         * and its subclasses. @see wp.media.model.Attachments._changeOrderby().
+         *
+         * @static
+         *
+         * @param {Backbone.Model} a
+         * @param {Backbone.Model} b
+         * @param {Object} options
+         * @returns {Number} -1 if the first model should come before the second,
+         *    0 if they are of the same rank and
+         *    1 if the first model should come after.
+         */
+        comparator: function( a, b, options ) {
+                var key   = this.props.get('orderby'),
+                        order = this.props.get('order') || 'DESC',
+                        ac    = a.cid,
+                        bc    = b.cid;
+
+                a = a.get( key );
+                b = b.get( key );
+
+                if ( 'date' === key || 'modified' === key ) {
+                        a = a || new Date();
+                        b = b || new Date();
+                }
+
+                // If `options.ties` is set, don't enforce the `cid` tiebreaker.
+                if ( options && options.ties ) {
+                        ac = bc = null;
+                }
+
+                return ( 'DESC' === order ) ? wp.media.compare( a, b, ac, bc ) : wp.media.compare( b, a, bc, ac );
+        },
+        /**
+         * @namespace
+         */
+        filters: {
+                /**
+                 * @static
+                 * Note that this client-side searching is *not* equivalent
+                 * to our server-side searching.
+                 *
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                search: function( attachment ) {
+                        if ( ! this.props.get('search') ) {
+                                return true;
+                        }
+
+                        return _.any(['title','filename','description','caption','name'], function( key ) {
+                                var value = attachment.get( key );
+                                return value && -1 !== value.search( this.props.get('search') );
+                        }, this );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                type: function( attachment ) {
+                        var type = this.props.get('type');
+                        return ! type || -1 !== type.indexOf( attachment.get('type') );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                uploadedTo: function( attachment ) {
+                        var uploadedTo = this.props.get('uploadedTo');
+                        if ( _.isUndefined( uploadedTo ) ) {
+                                return true;
+                        }
+
+                        return uploadedTo === attachment.get('uploadedTo');
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                status: function( attachment ) {
+                        var status = this.props.get('status');
+                        if ( _.isUndefined( status ) ) {
+                                return true;
+                        }
+
+                        return status === attachment.get('status');
+                }
+        }
+});
+
+module.exports = Attachments;
+ No newline at end of file

src/wp-includes/js/media/models/post-image.js

@@ +1 @@
+/**
+ * wp.media.model.PostImage
+ *
+ * An instance of an image that's been embedded into a post.
+ *
+ * Used in the embedded image attachment display settings modal - @see wp.media.view.MediaFrame.ImageDetails.
+ *
+ * @class
+ * @augments Backbone.Model
+ *
+ * @param {int} [attributes]               Initial model attributes.
+ * @param {int} [attributes.attachment_id] ID of the attachment.
+ **/
+var Attachment = require( './attachment' ),
+        PostImage;
+
+PostImage = Backbone.Model.extend({
+
+        initialize: function( attributes ) {
+                this.attachment = false;
+
+                if ( attributes.attachment_id ) {
+                        this.attachment = Attachment.get( attributes.attachment_id );
+                        if ( this.attachment.get( 'url' ) ) {
+                                this.dfd = jQuery.Deferred();
+                                this.dfd.resolve();
+                        } else {
+                                this.dfd = this.attachment.fetch();
+                        }
+                        this.bindAttachmentListeners();
+                }
+
+                // keep url in sync with changes to the type of link
+                this.on( 'change:link', this.updateLinkUrl, this );
+                this.on( 'change:size', this.updateSize, this );
+
+                this.setLinkTypeFromUrl();
+                this.setAspectRatio();
+
+                this.set( 'originalUrl', attributes.url );
+        },
+
+        bindAttachmentListeners: function() {
+                this.listenTo( this.attachment, 'sync', this.setLinkTypeFromUrl );
+                this.listenTo( this.attachment, 'sync', this.setAspectRatio );
+                this.listenTo( this.attachment, 'change', this.updateSize );
+        },
+
+        changeAttachment: function( attachment, props ) {
+                this.stopListening( this.attachment );
+                this.attachment = attachment;
+                this.bindAttachmentListeners();
+
+                this.set( 'attachment_id', this.attachment.get( 'id' ) );
+                this.set( 'caption', this.attachment.get( 'caption' ) );
+                this.set( 'alt', this.attachment.get( 'alt' ) );
+                this.set( 'size', props.get( 'size' ) );
+                this.set( 'align', props.get( 'align' ) );
+                this.set( 'link', props.get( 'link' ) );
+                this.updateLinkUrl();
+                this.updateSize();
+        },
+
+        setLinkTypeFromUrl: function() {
+                var linkUrl = this.get( 'linkUrl' ),
+                        type;
+
+                if ( ! linkUrl ) {
+                        this.set( 'link', 'none' );
+                        return;
+                }
+
+                // default to custom if there is a linkUrl
+                type = 'custom';
+
+                if ( this.attachment ) {
+                        if ( this.attachment.get( 'url' ) === linkUrl ) {
+                                type = 'file';
+                        } else if ( this.attachment.get( 'link' ) === linkUrl ) {
+                                type = 'post';
+                        }
+                } else {
+                        if ( this.get( 'url' ) === linkUrl ) {
+                                type = 'file';
+                        }
+                }
+
+                this.set( 'link', type );
+        },
+
+        updateLinkUrl: function() {
+                var link = this.get( 'link' ),
+                        url;
+
+                switch( link ) {
+                        case 'file':
+                                if ( this.attachment ) {
+                                        url = this.attachment.get( 'url' );
+                                } else {
+                                        url = this.get( 'url' );
+                                }
+                                this.set( 'linkUrl', url );
+                                break;
+                        case 'post':
+                                this.set( 'linkUrl', this.attachment.get( 'link' ) );
+                                break;
+                        case 'none':
+                                this.set( 'linkUrl', '' );
+                                break;
+                }
+        },
+
+        updateSize: function() {
+                var size;
+
+                if ( ! this.attachment ) {
+                        return;
+                }
+
+                if ( this.get( 'size' ) === 'custom' ) {
+                        this.set( 'width', this.get( 'customWidth' ) );
+                        this.set( 'height', this.get( 'customHeight' ) );
+                        this.set( 'url', this.get( 'originalUrl' ) );
+                        return;
+                }
+
+                size = this.attachment.get( 'sizes' )[ this.get( 'size' ) ];
+
+                if ( ! size ) {
+                        return;
+                }
+
+                this.set( 'url', size.url );
+                this.set( 'width', size.width );
+                this.set( 'height', size.height );
+        },
+
+        setAspectRatio: function() {
+                var full;
+
+                if ( this.attachment && this.attachment.get( 'sizes' ) ) {
+                        full = this.attachment.get( 'sizes' ).full;
+
+                        if ( full ) {
+                                this.set( 'aspectRatio', full.width / full.height );
+                                return;
+                        }
+                }
+
+                this.set( 'aspectRatio', this.get( 'customWidth' ) / this.get( 'customHeight' ) );
+        }
+});
+
+module.exports = PostImage;
+ No newline at end of file

src/wp-includes/js/media/models/post-media.js

@@ +1 @@
+/**
+ * Shared model class for audio and video. Updates the model after
+ *   "Add Audio|Video Source" and "Replace Audio|Video" states return
+ *
+ * @constructor
+ * @augments Backbone.Model
+ */
+var PostMedia = Backbone.Model.extend({
+        initialize: function() {
+                this.attachment = false;
+        },
+
+        setSource: function( attachment ) {
+                this.attachment = attachment;
+                this.extension = attachment.get( 'filename' ).split('.').pop();
+
+                if ( this.get( 'src' ) && this.extension === this.get( 'src' ).split('.').pop() ) {
+                        this.unset( 'src' );
+                }
+
+                if ( _.contains( wp.media.view.settings.embedExts, this.extension ) ) {
+                        this.set( this.extension, this.attachment.get( 'url' ) );
+                } else {
+                        this.unset( this.extension );
+                }
+        },
+
+        changeAttachment: function( attachment ) {
+                var self = this;
+
+                this.setSource( attachment );
+
+                this.unset( 'src' );
+                _.each( _.without( wp.media.view.settings.embedExts, this.extension ), function( ext ) {
+                        self.unset( ext );
+                } );
+        }
+});
+
+module.exports = PostMedia;
+ No newline at end of file

src/wp-includes/js/media/models/query.js

@@ +1 @@
+/**
+ * wp.media.model.Query
+ *
+ * A collection of attachments that match the supplied query arguments.
+ *
+ * Note: Do NOT change this.args after the query has been initialized.
+ *       Things will break.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                      Models to initialize with the collection.
+ * @param {object} [options]                     Options hash.
+ * @param {object} [options.args]                Attachments query arguments.
+ * @param {object} [options.args.posts_per_page]
+ */
+var Attachments = require( './attachments.js' ),
+        Query;
+
+Query = Attachments.extend({
+        /**
+         * @global wp.Uploader
+         *
+         * @param {array}  [models=[]]  Array of initial models to populate the collection.
+         * @param {object} [options={}]
+         */
+        initialize: function( models, options ) {
+                var allowed;
+
+                options = options || {};
+                Attachments.prototype.initialize.apply( this, arguments );
+
+                this.args     = options.args;
+                this._hasMore = true;
+                this.created  = new Date();
+
+                this.filters.order = function( attachment ) {
+                        var orderby = this.props.get('orderby'),
+                                order = this.props.get('order');
+
+                        if ( ! this.comparator ) {
+                                return true;
+                        }
+
+                        // We want any items that can be placed before the last
+                        // item in the set. If we add any items after the last
+                        // item, then we can't guarantee the set is complete.
+                        if ( this.length ) {
+                                return 1 !== this.comparator( attachment, this.last(), { ties: true });
+
+                        // Handle the case where there are no items yet and
+                        // we're sorting for recent items. In that case, we want
+                        // changes that occurred after we created the query.
+                        } else if ( 'DESC' === order && ( 'date' === orderby || 'modified' === orderby ) ) {
+                                return attachment.get( orderby ) >= this.created;
+
+                        // If we're sorting by menu order and we have no items,
+                        // accept any items that have the default menu order (0).
+                        } else if ( 'ASC' === order && 'menuOrder' === orderby ) {
+                                return attachment.get( orderby ) === 0;
+                        }
+
+                        // Otherwise, we don't want any items yet.
+                        return false;
+                };
+
+                // Observe the central `wp.Uploader.queue` collection to watch for
+                // new matches for the query.
+                //
+                // Only observe when a limited number of query args are set. There
+                // are no filters for other properties, so observing will result in
+                // false positives in those queries.
+                allowed = [ 's', 'order', 'orderby', 'posts_per_page', 'post_mime_type', 'post_parent' ];
+                if ( wp.Uploader && _( this.args ).chain().keys().difference( allowed ).isEmpty().value() ) {
+                        this.observe( wp.Uploader.queue );
+                }
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this._hasMore;
+        },
+        /**
+         * Fetch more attachments from the server for the collection.
+         *
+         * @param   {object}  [options={}]
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var query = this;
+
+                // If there is already a request pending, return early with the Deferred object.
+                if ( this._more && 'pending' === this._more.state() ) {
+                        return this._more;
+                }
+
+                if ( ! this.hasMore() ) {
+                        return jQuery.Deferred().resolveWith( this ).promise();
+                }
+
+                options = options || {};
+                options.remove = false;
+
+                return this._more = this.fetch( options ).done( function( resp ) {
+                        if ( _.isEmpty( resp ) || -1 === this.args.posts_per_page || resp.length < this.args.posts_per_page ) {
+                                query._hasMore = false;
+                        }
+                });
+        },
+        /**
+         * Overrides Backbone.Collection.sync
+         * Overrides wp.media.model.Attachments.sync
+         *
+         * @param {String} method
+         * @param {Backbone.Model} model
+         * @param {Object} [options={}]
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                var args, fallback;
+
+                // Overload the read method so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:  'query-attachments',
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Clone the args so manipulation is non-destructive.
+                        args = _.clone( this.args );
+
+                        // Determine which page to query.
+                        if ( -1 !== args.posts_per_page ) {
+                                args.paged = Math.floor( this.length / args.posts_per_page ) + 1;
+                        }
+
+                        options.data.query = args;
+                        return wp.media.ajax( options );
+
+                // Otherwise, fall back to Backbone.sync()
+                } else {
+                        /**
+                         * Call wp.media.model.Attachments.sync or Backbone.sync
+                         */
+                        fallback = Attachments.prototype.sync ? Attachments.prototype : Backbone;
+                        return fallback.sync.apply( this, arguments );
+                }
+        }
+}, {
+        /**
+         * @readonly
+         */
+        defaultProps: {
+                orderby: 'date',
+                order:   'DESC'
+        },
+        /**
+         * @readonly
+         */
+        defaultArgs: {
+                posts_per_page: 40
+        },
+        /**
+         * @readonly
+         */
+        orderby: {
+                allowed:  [ 'name', 'author', 'date', 'title', 'modified', 'uploadedTo', 'id', 'post__in', 'menuOrder' ],
+                /**
+                 * A map of JavaScript orderby values to their WP_Query equivalents.
+                 * @type {Object}
+                 */
+                valuemap: {
+                        'id':         'ID',
+                        'uploadedTo': 'parent',
+                        'menuOrder':  'menu_order ID'
+                }
+        },
+        /**
+         * A map of JavaScript query properties to their WP_Query equivalents.
+         *
+         * @readonly
+         */
+        propmap: {
+                'search':    's',
+                'type':      'post_mime_type',
+                'perPage':   'posts_per_page',
+                'menuOrder': 'menu_order',
+                'uploadedTo': 'post_parent',
+                'status':     'post_status',
+                'include':    'post__in',
+                'exclude':    'post__not_in'
+        },
+        /**
+         * Creates and returns an Attachments Query collection given the properties.
+         *
+         * Caches query objects and reuses where possible.
+         *
+         * @static
+         * @method
+         *
+         * @param {object} [props]
+         * @param {Object} [props.cache=true]   Whether to use the query cache or not.
+         * @param {Object} [props.order]
+         * @param {Object} [props.orderby]
+         * @param {Object} [props.include]
+         * @param {Object} [props.exclude]
+         * @param {Object} [props.s]
+         * @param {Object} [props.post_mime_type]
+         * @param {Object} [props.posts_per_page]
+         * @param {Object} [props.menu_order]
+         * @param {Object} [props.post_parent]
+         * @param {Object} [props.post_status]
+         * @param {Object} [options]
+         *
+         * @returns {wp.media.model.Query} A new Attachments Query collection.
+         */
+        get: (function(){
+                /**
+                 * @static
+                 * @type Array
+                 */
+                var queries = [];
+
+                /**
+                 * @returns {Query}
+                 */
+                return function( props, options ) {
+                        var args     = {},
+                                orderby  = Query.orderby,
+                                defaults = Query.defaultProps,
+                                query,
+                                cache    = !! props.cache || _.isUndefined( props.cache );
+
+                        // Remove the `query` property. This isn't linked to a query,
+                        // this *is* the query.
+                        delete props.query;
+                        delete props.cache;
+
+                        // Fill default args.
+                        _.defaults( props, defaults );
+
+                        // Normalize the order.
+                        props.order = props.order.toUpperCase();
+                        if ( 'DESC' !== props.order && 'ASC' !== props.order ) {
+                                props.order = defaults.order.toUpperCase();
+                        }
+
+                        // Ensure we have a valid orderby value.
+                        if ( ! _.contains( orderby.allowed, props.orderby ) ) {
+                                props.orderby = defaults.orderby;
+                        }
+
+                        _.each( [ 'include', 'exclude' ], function( prop ) {
+                                if ( props[ prop ] && ! _.isArray( props[ prop ] ) ) {
+                                        props[ prop ] = [ props[ prop ] ];
+                                }
+                        } );
+
+                        // Generate the query `args` object.
+                        // Correct any differing property names.
+                        _.each( props, function( value, prop ) {
+                                if ( _.isNull( value ) ) {
+                                        return;
+                                }
+
+                                args[ Query.propmap[ prop ] || prop ] = value;
+                        });
+
+                        // Fill any other default query args.
+                        _.defaults( args, Query.defaultArgs );
+
+                        // `props.orderby` does not always map directly to `args.orderby`.
+                        // Substitute exceptions specified in orderby.keymap.
+                        args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;
+
+                        // Search the query cache for a matching query.
+                        if ( cache ) {
+                                query = _.find( queries, function( query ) {
+                                        return _.isEqual( query.args, args );
+                                });
+                        } else {
+                                queries = [];
+                        }
+
+                        // Otherwise, create a new query and add it to the cache.
+                        if ( ! query ) {
+                                query = new Query( [], _.extend( options || {}, {
+                                        props: props,
+                                        args:  args
+                                } ) );
+                                queries.push( query );
+                        }
+
+                        return query;
+                };
+        }())
+});
+
+module.exports = Query;
+ No newline at end of file

src/wp-includes/js/media/models/selection.js

@@ +1 @@
+/**
+ * wp.media.model.Selection
+ *
+ * A selection of attachments.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ */
+var Attachments = require( './attachments.js' ),
+        Selection;
+
+Selection = Attachments.extend({
+        /**
+         * Refresh the `single` model whenever the selection changes.
+         * Binds `single` instead of using the context argument to ensure
+         * it receives no parameters.
+         *
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                /**
+                 * call 'initialize' directly on the parent class
+                 */
+                Attachments.prototype.initialize.apply( this, arguments );
+                this.multiple = options && options.multiple;
+
+                this.on( 'add remove reset', _.bind( this.single, this, false ) );
+        },
+
+        /**
+         * If the workflow does not support multi-select, clear out the selection
+         * before adding a new attachment to it.
+         *
+         * @param {Array} models
+         * @param {Object} options
+         * @returns {wp.media.model.Attachment[]}
+         */
+        add: function( models, options ) {
+                if ( ! this.multiple ) {
+                        this.remove( this.models );
+                }
+                /**
+                 * call 'add' directly on the parent class
+                 */
+                return Attachments.prototype.add.call( this, models, options );
+        },
+
+        /**
+         * Fired when toggling (clicking on) an attachment in the modal.
+         *
+         * @param {undefined|boolean|wp.media.model.Attachment} model
+         *
+         * @fires wp.media.model.Selection#selection:single
+         * @fires wp.media.model.Selection#selection:unsingle
+         *
+         * @returns {Backbone.Model}
+         */
+        single: function( model ) {
+                var previous = this._single;
+
+                // If a `model` is provided, use it as the single model.
+                if ( model ) {
+                        this._single = model;
+                }
+                // If the single model isn't in the selection, remove it.
+                if ( this._single && ! this.get( this._single.cid ) ) {
+                        delete this._single;
+                }
+
+                this._single = this._single || this.last();
+
+                // If single has changed, fire an event.
+                if ( this._single !== previous ) {
+                        if ( previous ) {
+                                previous.trigger( 'selection:unsingle', previous, this );
+
+                                // If the model was already removed, trigger the collection
+                                // event manually.
+                                if ( ! this.get( previous.cid ) ) {
+                                        this.trigger( 'selection:unsingle', previous, this );
+                                }
+                        }
+                        if ( this._single ) {
+                                this._single.trigger( 'selection:single', this._single, this );
+                        }
+                }
+
+                // Return the single model, or the last model as a fallback.
+                return this._single;
+        }
+});
+
+module.exports = Selection;
+ No newline at end of file

src/wp-includes/js/media/models.js

@@ +1 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/* global _wpMediaModelsL10n:false */
+window.wp = window.wp || {};
+
+(function($){
+        var Attachment, Attachments, l10n, media;
+
+        /**
+         * Create and return a media frame.
+         *
+         * Handles the default media experience.
+         *
+         * @param  {object} attributes The properties passed to the main media controller.
+         * @return {wp.media.view.MediaFrame} A media workflow.
+         */
+        media = wp.media = function( attributes ) {
+                var MediaFrame = media.view.MediaFrame,
+                        frame;
+
+                if ( ! MediaFrame ) {
+                        return;
+                }
+
+                attributes = _.defaults( attributes || {}, {
+                        frame: 'select'
+                });
+
+                if ( 'select' === attributes.frame && MediaFrame.Select ) {
+                        frame = new MediaFrame.Select( attributes );
+                } else if ( 'post' === attributes.frame && MediaFrame.Post ) {
+                        frame = new MediaFrame.Post( attributes );
+                } else if ( 'manage' === attributes.frame && MediaFrame.Manage ) {
+                        frame = new MediaFrame.Manage( attributes );
+                } else if ( 'image' === attributes.frame && MediaFrame.ImageDetails ) {
+                        frame = new MediaFrame.ImageDetails( attributes );
+                } else if ( 'audio' === attributes.frame && MediaFrame.AudioDetails ) {
+                        frame = new MediaFrame.AudioDetails( attributes );
+                } else if ( 'video' === attributes.frame && MediaFrame.VideoDetails ) {
+                        frame = new MediaFrame.VideoDetails( attributes );
+                } else if ( 'edit-attachments' === attributes.frame && MediaFrame.EditAttachments ) {
+                        frame = new MediaFrame.EditAttachments( attributes );
+                }
+
+                delete attributes.frame;
+
+                media.frame = frame;
+
+                return frame;
+        };
+
+        _.extend( media, { model: {}, view: {}, controller: {}, frames: {} });
+
+        // Link any localized strings.
+        l10n = media.model.l10n = typeof _wpMediaModelsL10n === 'undefined' ? {} : _wpMediaModelsL10n;
+
+        // Link any settings.
+        media.model.settings = l10n.settings || {};
+        delete l10n.settings;
+
+        Attachments = media.model.Attachments = require( './models/attachments.js' );
+        Attachment = media.model.Attachment = require( './models/attachment.js' );
+
+        media.model.Query = require( './models/query.js' );
+        media.model.PostImage = require( './models/post-image.js' );
+        media.model.Selection = require( './models/selection.js' );
+
+        /**
+         * ========================================================================
+         * UTILITIES
+         * ========================================================================
+         */
+
+        /**
+         * A basic equality comparator for Backbone models.
+         *
+         * Used to order models within a collection - @see wp.media.model.Attachments.comparator().
+         *
+         * @param  {mixed}  a  The primary parameter to compare.
+         * @param  {mixed}  b  The primary parameter to compare.
+         * @param  {string} ac The fallback parameter to compare, a's cid.
+         * @param  {string} bc The fallback parameter to compare, b's cid.
+         * @return {number}    -1: a should come before b.
+         *                      0: a and b are of the same rank.
+         *                      1: b should come before a.
+         */
+        media.compare = function( a, b, ac, bc ) {
+                if ( _.isEqual( a, b ) ) {
+                        return ac === bc ? 0 : (ac > bc ? -1 : 1);
+                } else {
+                        return a > b ? -1 : 1;
+                }
+        };
+
+        _.extend( media, {
+                /**
+                 * media.template( id )
+                 *
+                 * Fetch a JavaScript template for an id, and return a templating function for it.
+                 *
+                 * See wp.template() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.template as template
+                 */
+                template: wp.template,
+
+                /**
+                 * media.post( [action], [data] )
+                 *
+                 * Sends a POST request to WordPress.
+                 * See wp.ajax.post() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.ajax.post as post
+                 */
+                post: wp.ajax.post,
+
+                /**
+                 * media.ajax( [action], [options] )
+                 *
+                 * Sends an XHR request to WordPress.
+                 * See wp.ajax.send() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.ajax.send as ajax
+                 */
+                ajax: wp.ajax.send,
+
+                /**
+                 * Scales a set of dimensions to fit within bounding dimensions.
+                 *
+                 * @param {Object} dimensions
+                 * @returns {Object}
+                 */
+                fit: function( dimensions ) {
+                        var width     = dimensions.width,
+                                height    = dimensions.height,
+                                maxWidth  = dimensions.maxWidth,
+                                maxHeight = dimensions.maxHeight,
+                                constraint;
+
+                        // Compare ratios between the two values to determine which
+                        // max to constrain by. If a max value doesn't exist, then the
+                        // opposite side is the constraint.
+                        if ( ! _.isUndefined( maxWidth ) && ! _.isUndefined( maxHeight ) ) {
+                                constraint = ( width / height > maxWidth / maxHeight ) ? 'width' : 'height';
+                        } else if ( _.isUndefined( maxHeight ) ) {
+                                constraint = 'width';
+                        } else if (  _.isUndefined( maxWidth ) && height > maxHeight ) {
+                                constraint = 'height';
+                        }
+
+                        // If the value of the constrained side is larger than the max,
+                        // then scale the values. Otherwise return the originals; they fit.
+                        if ( 'width' === constraint && width > maxWidth ) {
+                                return {
+                                        width : maxWidth,
+                                        height: Math.round( maxWidth * height / width )
+                                };
+                        } else if ( 'height' === constraint && height > maxHeight ) {
+                                return {
+                                        width : Math.round( maxHeight * width / height ),
+                                        height: maxHeight
+                                };
+                        } else {
+                                return {
+                                        width : width,
+                                        height: height
+                                };
+                        }
+                },
+                /**
+                 * Truncates a string by injecting an ellipsis into the middle.
+                 * Useful for filenames.
+                 *
+                 * @param {String} string
+                 * @param {Number} [length=30]
+                 * @param {String} [replacement=&hellip;]
+                 * @returns {String} The string, unless length is greater than string.length.
+                 */
+                truncate: function( string, length, replacement ) {
+                        length = length || 30;
+                        replacement = replacement || '&hellip;';
+
+                        if ( string.length <= length ) {
+                                return string;
+                        }
+
+                        return string.substr( 0, length / 2 ) + replacement + string.substr( -1 * length / 2 );
+                }
+        });
+
+        /**
+         * ========================================================================
+         * MODELS
+         * ========================================================================
+         */
+        /**
+         * wp.media.attachment
+         *
+         * @static
+         * @param {String} id A string used to identify a model.
+         * @returns {wp.media.model.Attachment}
+         */
+        media.attachment = function( id ) {
+                return Attachment.get( id );
+        };
+
+        /**
+         * A collection of all attachments that have been fetched from the server.
+         *
+         * @static
+         * @member {wp.media.model.Attachments}
+         */
+        Attachments.all = new Attachments();
+
+        /**
+         * wp.media.query
+         *
+         * Shorthand for creating a new Attachments Query.
+         *
+         * @param {object} [props]
+         * @returns {wp.media.model.Attachments}
+         */
+        media.query = function( props ) {
+                return new Attachments( null, {
+                        props: _.extend( _.defaults( props || {}, { orderby: 'date' } ), { query: true } )
+                });
+        };
+
+        // Clean up. Prevents mobile browsers caching
+        $(window).on('unload', function(){
+                window.wp = null;
+        });
+
+}(jQuery));
+
+},{"./models/attachment.js":2,"./models/attachments.js":3,"./models/post-image.js":4,"./models/query.js":5,"./models/selection.js":6}],2:[function(require,module,exports){
+/**
+ * wp.media.model.Attachment
+ *
+ * @class
+ * @augments Backbone.Model
+ */
+var $ = jQuery,
+        Attachment;
+
+Attachment = Backbone.Model.extend({
+        /**
+         * Triggered when attachment details change
+         * Overrides Backbone.Model.sync
+         *
+         * @param {string} method
+         * @param {wp.media.model.Attachment} model
+         * @param {Object} [options={}]
+         *
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                // If the attachment does not yet have an `id`, return an instantly
+                // rejected promise. Otherwise, all of our requests will fail.
+                if ( _.isUndefined( this.id ) ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                // Overload the `read` request so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action: 'get-attachment',
+                                id: this.id
+                        });
+                        return wp.media.ajax( options );
+
+                // Overload the `update` request so properties can be saved.
+                } else if ( 'update' === method ) {
+                        // If we do not have the necessary nonce, fail immeditately.
+                        if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                                return $.Deferred().rejectWith( this ).promise();
+                        }
+
+                        options = options || {};
+                        options.context = this;
+
+                        // Set the action and ID.
+                        options.data = _.extend( options.data || {}, {
+                                action:  'save-attachment',
+                                id:      this.id,
+                                nonce:   this.get('nonces').update,
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Record the values of the changed attributes.
+                        if ( model.hasChanged() ) {
+                                options.data.changes = {};
+
+                                _.each( model.changed, function( value, key ) {
+                                        options.data.changes[ key ] = this.get( key );
+                                }, this );
+                        }
+
+                        return wp.media.ajax( options );
+
+                // Overload the `delete` request so attachments can be removed.
+                // This will permanently delete an attachment.
+                } else if ( 'delete' === method ) {
+                        options = options || {};
+
+                        if ( ! options.wait ) {
+                                this.destroyed = true;
+                        }
+
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:   'delete-post',
+                                id:       this.id,
+                                _wpnonce: this.get('nonces')['delete']
+                        });
+
+                        return wp.media.ajax( options ).done( function() {
+                                this.destroyed = true;
+                        }).fail( function() {
+                                this.destroyed = false;
+                        });
+
+                // Otherwise, fall back to `Backbone.sync()`.
+                } else {
+                        /**
+                         * Call `sync` directly on Backbone.Model
+                         */
+                        return Backbone.Model.prototype.sync.apply( this, arguments );
+                }
+        },
+        /**
+         * Convert date strings into Date objects.
+         *
+         * @param {Object} resp The raw response object, typically returned by fetch()
+         * @returns {Object} The modified response object, which is the attributes hash
+         *    to be set on the model.
+         */
+        parse: function( resp ) {
+                if ( ! resp ) {
+                        return resp;
+                }
+
+                resp.date = new Date( resp.date );
+                resp.modified = new Date( resp.modified );
+                return resp;
+        },
+        /**
+         * @param {Object} data The properties to be saved.
+         * @param {Object} options Sync options. e.g. patch, wait, success, error.
+         *
+         * @this Backbone.Model
+         *
+         * @returns {Promise}
+         */
+        saveCompat: function( data, options ) {
+                var model = this;
+
+                // If we do not have the necessary nonce, fail immeditately.
+                if ( ! this.get('nonces') || ! this.get('nonces').update ) {
+                        return $.Deferred().rejectWith( this ).promise();
+                }
+
+                return media.post( 'save-attachment-compat', _.defaults({
+                        id:      this.id,
+                        nonce:   this.get('nonces').update,
+                        post_id: wp.media.model.settings.post.id
+                }, data ) ).done( function( resp, status, xhr ) {
+                        model.set( model.parse( resp, xhr ), options );
+                });
+        }
+}, {
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * @static
+         * @param {Object} attrs
+         * @returns {wp.media.model.Attachment}
+         */
+        create: function( attrs ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attrs );
+        },
+        /**
+         * Create a new model on the static 'all' attachments collection and return it.
+         *
+         * If this function has already been called for the id,
+         * it returns the specified attachment.
+         *
+         * @static
+         * @param {string} id A string used to identify a model.
+         * @param {Backbone.Model|undefined} attachment
+         * @returns {wp.media.model.Attachment}
+         */
+        get: _.memoize( function( id, attachment ) {
+                var Attachments = require( './attachments.js' );
+                return Attachments.all.push( attachment || { id: id } );
+        })
+});
+
+module.exports = Attachment;
+},{"./attachments.js":3}],3:[function(require,module,exports){
+/**
+ * wp.media.model.Attachments
+ *
+ * A collection of attachments.
+ *
+ * This collection has no persistence with the server without supplying
+ * 'options.props.query = true', which will mirror the collection
+ * to an Attachments Query collection - @see wp.media.model.Attachments.mirror().
+ *
+ * @class
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                Models to initialize with the collection.
+ * @param {object} [options]               Options hash for the collection.
+ * @param {string} [options.props]         Options hash for the initial query properties.
+ * @param {string} [options.props.order]   Initial order (ASC or DESC) for the collection.
+ * @param {string} [options.props.orderby] Initial attribute key to order the collection by.
+ * @param {string} [options.props.query]   Whether the collection is linked to an attachments query.
+ * @param {string} [options.observe]
+ * @param {string} [options.filters]
+ *
+ */
+var Attachment = require( './attachment.js' ),
+        Attachments;
+
+Attachments = Backbone.Collection.extend({
+        /**
+         * @type {wp.media.model.Attachment}
+         */
+        model: Attachment,
+        /**
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                options = options || {};
+
+                this.props   = new Backbone.Model();
+                this.filters = options.filters || {};
+
+                // Bind default `change` events to the `props` model.
+                this.props.on( 'change', this._changeFilteredProps, this );
+
+                this.props.on( 'change:order',   this._changeOrder,   this );
+                this.props.on( 'change:orderby', this._changeOrderby, this );
+                this.props.on( 'change:query',   this._changeQuery,   this );
+
+                this.props.set( _.defaults( options.props || {} ) );
+
+                if ( options.observe ) {
+                        this.observe( options.observe );
+                }
+        },
+        /**
+         * Sort the collection when the order attribute changes.
+         *
+         * @access private
+         */
+        _changeOrder: function() {
+                if ( this.comparator ) {
+                        this.sort();
+                }
+        },
+        /**
+         * Set the default comparator only when the `orderby` property is set.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {string} orderby
+         */
+        _changeOrderby: function( model, orderby ) {
+                // If a different comparator is defined, bail.
+                if ( this.comparator && this.comparator !== Attachments.comparator ) {
+                        return;
+                }
+
+                if ( orderby && 'post__in' !== orderby ) {
+                        this.comparator = Attachments.comparator;
+                } else {
+                        delete this.comparator;
+                }
+        },
+        /**
+         * If the `query` property is set to true, query the server using
+         * the `props` values, and sync the results to this collection.
+         *
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         * @param {Boolean} query
+         */
+        _changeQuery: function( model, query ) {
+                if ( query ) {
+                        this.props.on( 'change', this._requery, this );
+                        this._requery();
+                } else {
+                        this.props.off( 'change', this._requery, this );
+                }
+        },
+        /**
+         * @access private
+         *
+         * @param {Backbone.Model} model
+         */
+        _changeFilteredProps: function( model ) {
+                // If this is a query, updating the collection will be handled by
+                // `this._requery()`.
+                if ( this.props.get('query') ) {
+                        return;
+                }
+
+                var changed = _.chain( model.changed ).map( function( t, prop ) {
+                        var filter = Attachments.filters[ prop ],
+                                term = model.get( prop );
+
+                        if ( ! filter ) {
+                                return;
+                        }
+
+                        if ( term && ! this.filters[ prop ] ) {
+                                this.filters[ prop ] = filter;
+                        } else if ( ! term && this.filters[ prop ] === filter ) {
+                                delete this.filters[ prop ];
+                        } else {
+                                return;
+                        }
+
+                        // Record the change.
+                        return true;
+                }, this ).any().value();
+
+                if ( ! changed ) {
+                        return;
+                }
+
+                // If no `Attachments` model is provided to source the searches
+                // from, then automatically generate a source from the existing
+                // models.
+                if ( ! this._source ) {
+                        this._source = new Attachments( this.models );
+                }
+
+                this.reset( this._source.filter( this.validator, this ) );
+        },
+
+        validateDestroyed: false,
+        /**
+         * Checks whether an attachment is valid.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        validator: function( attachment ) {
+                if ( ! this.validateDestroyed && attachment.destroyed ) {
+                        return false;
+                }
+                return _.all( this.filters, function( filter ) {
+                        return !! filter.call( this, attachment );
+                }, this );
+        },
+        /**
+         * Add or remove an attachment to the collection depending on its validity.
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validate: function( attachment, options ) {
+                var valid = this.validator( attachment ),
+                        hasAttachment = !! this.get( attachment.cid );
+
+                if ( ! valid && hasAttachment ) {
+                        this.remove( attachment, options );
+                } else if ( valid && ! hasAttachment ) {
+                        this.add( attachment, options );
+                }
+
+                return this;
+        },
+
+        /**
+         * Add or remove all attachments from another collection depending on each one's validity.
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {object} [options={}]
+         *
+         * @fires wp.media.model.Attachments#reset
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        validateAll: function( attachments, options ) {
+                options = options || {};
+
+                _.each( attachments.models, function( attachment ) {
+                        this.validate( attachment, { silent: true });
+                }, this );
+
+                if ( ! options.silent ) {
+                        this.trigger( 'reset', this, options );
+                }
+                return this;
+        },
+        /**
+         * Start observing another attachments collection change events
+         * and replicate them on this collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to observe.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining.
+         */
+        observe: function( attachments ) {
+                this.observers = this.observers || [];
+                this.observers.push( attachments );
+
+                attachments.on( 'add change remove', this._validateHandler, this );
+                attachments.on( 'reset', this._validateAllHandler, this );
+                this.validateAll( attachments );
+                return this;
+        },
+        /**
+         * Stop replicating collection change events from another attachments collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to stop observing.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        unobserve: function( attachments ) {
+                if ( attachments ) {
+                        attachments.off( null, null, this );
+                        this.observers = _.without( this.observers, attachments );
+
+                } else {
+                        _.each( this.observers, function( attachments ) {
+                                attachments.off( null, null, this );
+                        }, this );
+                        delete this.observers;
+                }
+
+                return this;
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachment
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         *
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateHandler: function( attachment, attachments, options ) {
+                // If we're not mirroring this `attachments` collection,
+                // only retain the `silent` option.
+                options = attachments === this.mirroring ? options : {
+                        silent: options && options.silent
+                };
+
+                return this.validate( attachment, options );
+        },
+        /**
+         * @access private
+         *
+         * @param {wp.media.model.Attachments} attachments
+         * @param {Object} options
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        _validateAllHandler: function( attachments, options ) {
+                return this.validateAll( attachments, options );
+        },
+        /**
+         * Start mirroring another attachments collection, clearing out any models already
+         * in the collection.
+         *
+         * @param {wp.media.model.Attachments} The attachments collection to mirror.
+         * @returns {wp.media.model.Attachments} Returns itself to allow chaining
+         */
+        mirror: function( attachments ) {
+                if ( this.mirroring && this.mirroring === attachments ) {
+                        return this;
+                }
+
+                this.unmirror();
+                this.mirroring = attachments;
+
+                // Clear the collection silently. A `reset` event will be fired
+                // when `observe()` calls `validateAll()`.
+                this.reset( [], { silent: true } );
+                this.observe( attachments );
+
+                return this;
+        },
+        /**
+         * Stop mirroring another attachments collection.
+         */
+        unmirror: function() {
+                if ( ! this.mirroring ) {
+                        return;
+                }
+
+                this.unobserve( this.mirroring );
+                delete this.mirroring;
+        },
+        /**
+         * Retrive more attachments from the server for the collection.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `more` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @param {object} options
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var deferred = jQuery.Deferred(),
+                        mirroring = this.mirroring,
+                        attachments = this;
+
+                if ( ! mirroring || ! mirroring.more ) {
+                        return deferred.resolveWith( this ).promise();
+                }
+                // If we're mirroring another collection, forward `more` to
+                // the mirrored collection. Account for a race condition by
+                // checking if we're still mirroring that collection when
+                // the request resolves.
+                mirroring.more( options ).done( function() {
+                        if ( this === attachments.mirroring )
+                                deferred.resolveWith( this );
+                });
+
+                return deferred.promise();
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * Only works if the collection is mirroring a Query Attachments collection,
+         * and forwards to its `hasMore` method. This collection class doesn't have
+         * server persistence by itself.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this.mirroring ? this.mirroring.hasMore() : false;
+        },
+        /**
+         * A custom AJAX-response parser.
+         *
+         * See trac ticket #24753
+         *
+         * @param {Object|Array} resp The raw response Object/Array.
+         * @param {Object} xhr
+         * @returns {Array} The array of model attributes to be added to the collection
+         */
+        parse: function( resp, xhr ) {
+                if ( ! _.isArray( resp ) ) {
+                        resp = [resp];
+                }
+
+                return _.map( resp, function( attrs ) {
+                        var id, attachment, newAttributes;
+
+                        if ( attrs instanceof Backbone.Model ) {
+                                id = attrs.get( 'id' );
+                                attrs = attrs.attributes;
+                        } else {
+                                id = attrs.id;
+                        }
+
+                        attachment = Attachment.get( id );
+                        newAttributes = attachment.parse( attrs, xhr );
+
+                        if ( ! _.isEqual( attachment.attributes, newAttributes ) ) {
+                                attachment.set( newAttributes );
+                        }
+
+                        return attachment;
+                });
+        },
+        /**
+         * If the collection is a query, create and mirror an Attachments Query collection.
+         *
+         * @access private
+         */
+        _requery: function( refresh ) {
+                var props, Query;
+                if ( this.props.get('query') ) {
+                        Query = require( './query.js' );
+                        props = this.props.toJSON();
+                        props.cache = ( true !== refresh );
+                        this.mirror( Query.get( props ) );
+                }
+        },
+        /**
+         * If this collection is sorted by `menuOrder`, recalculates and saves
+         * the menu order to the database.
+         *
+         * @returns {undefined|Promise}
+         */
+        saveMenuOrder: function() {
+                if ( 'menuOrder' !== this.props.get('orderby') ) {
+                        return;
+                }
+
+                // Removes any uploading attachments, updates each attachment's
+                // menu order, and returns an object with an { id: menuOrder }
+                // mapping to pass to the request.
+                var attachments = this.chain().filter( function( attachment ) {
+                        return ! _.isUndefined( attachment.id );
+                }).map( function( attachment, index ) {
+                        // Indices start at 1.
+                        index = index + 1;
+                        attachment.set( 'menuOrder', index );
+                        return [ attachment.id, index ];
+                }).object().value();
+
+                if ( _.isEmpty( attachments ) ) {
+                        return;
+                }
+
+                return wp.media.post( 'save-attachment-order', {
+                        nonce:       wp.media.model.settings.post.nonce,
+                        post_id:     wp.media.model.settings.post.id,
+                        attachments: attachments
+                });
+        }
+}, {
+        /**
+         * A function to compare two attachment models in an attachments collection.
+         *
+         * Used as the default comparator for instances of wp.media.model.Attachments
+         * and its subclasses. @see wp.media.model.Attachments._changeOrderby().
+         *
+         * @static
+         *
+         * @param {Backbone.Model} a
+         * @param {Backbone.Model} b
+         * @param {Object} options
+         * @returns {Number} -1 if the first model should come before the second,
+         *    0 if they are of the same rank and
+         *    1 if the first model should come after.
+         */
+        comparator: function( a, b, options ) {
+                var key   = this.props.get('orderby'),
+                        order = this.props.get('order') || 'DESC',
+                        ac    = a.cid,
+                        bc    = b.cid;
+
+                a = a.get( key );
+                b = b.get( key );
+
+                if ( 'date' === key || 'modified' === key ) {
+                        a = a || new Date();
+                        b = b || new Date();
+                }
+
+                // If `options.ties` is set, don't enforce the `cid` tiebreaker.
+                if ( options && options.ties ) {
+                        ac = bc = null;
+                }
+
+                return ( 'DESC' === order ) ? wp.media.compare( a, b, ac, bc ) : wp.media.compare( b, a, bc, ac );
+        },
+        /**
+         * @namespace
+         */
+        filters: {
+                /**
+                 * @static
+                 * Note that this client-side searching is *not* equivalent
+                 * to our server-side searching.
+                 *
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                search: function( attachment ) {
+                        if ( ! this.props.get('search') ) {
+                                return true;
+                        }
+
+                        return _.any(['title','filename','description','caption','name'], function( key ) {
+                                var value = attachment.get( key );
+                                return value && -1 !== value.search( this.props.get('search') );
+                        }, this );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                type: function( attachment ) {
+                        var type = this.props.get('type');
+                        return ! type || -1 !== type.indexOf( attachment.get('type') );
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                uploadedTo: function( attachment ) {
+                        var uploadedTo = this.props.get('uploadedTo');
+                        if ( _.isUndefined( uploadedTo ) ) {
+                                return true;
+                        }
+
+                        return uploadedTo === attachment.get('uploadedTo');
+                },
+                /**
+                 * @static
+                 * @param {wp.media.model.Attachment} attachment
+                 *
+                 * @this wp.media.model.Attachments
+                 *
+                 * @returns {Boolean}
+                 */
+                status: function( attachment ) {
+                        var status = this.props.get('status');
+                        if ( _.isUndefined( status ) ) {
+                                return true;
+                        }
+
+                        return status === attachment.get('status');
+                }
+        }
+});
+
+module.exports = Attachments;
+},{"./attachment.js":2,"./query.js":5}],4:[function(require,module,exports){
+/**
+ * wp.media.model.PostImage
+ *
+ * An instance of an image that's been embedded into a post.
+ *
+ * Used in the embedded image attachment display settings modal - @see wp.media.view.MediaFrame.ImageDetails.
+ *
+ * @class
+ * @augments Backbone.Model
+ *
+ * @param {int} [attributes]               Initial model attributes.
+ * @param {int} [attributes.attachment_id] ID of the attachment.
+ **/
+var Attachment = require( './attachment' ),
+        PostImage;
+
+PostImage = Backbone.Model.extend({
+
+        initialize: function( attributes ) {
+                this.attachment = false;
+
+                if ( attributes.attachment_id ) {
+                        this.attachment = Attachment.get( attributes.attachment_id );
+                        if ( this.attachment.get( 'url' ) ) {
+                                this.dfd = jQuery.Deferred();
+                                this.dfd.resolve();
+                        } else {
+                                this.dfd = this.attachment.fetch();
+                        }
+                        this.bindAttachmentListeners();
+                }
+
+                // keep url in sync with changes to the type of link
+                this.on( 'change:link', this.updateLinkUrl, this );
+                this.on( 'change:size', this.updateSize, this );
+
+                this.setLinkTypeFromUrl();
+                this.setAspectRatio();
+
+                this.set( 'originalUrl', attributes.url );
+        },
+
+        bindAttachmentListeners: function() {
+                this.listenTo( this.attachment, 'sync', this.setLinkTypeFromUrl );
+                this.listenTo( this.attachment, 'sync', this.setAspectRatio );
+                this.listenTo( this.attachment, 'change', this.updateSize );
+        },
+
+        changeAttachment: function( attachment, props ) {
+                this.stopListening( this.attachment );
+                this.attachment = attachment;
+                this.bindAttachmentListeners();
+
+                this.set( 'attachment_id', this.attachment.get( 'id' ) );
+                this.set( 'caption', this.attachment.get( 'caption' ) );
+                this.set( 'alt', this.attachment.get( 'alt' ) );
+                this.set( 'size', props.get( 'size' ) );
+                this.set( 'align', props.get( 'align' ) );
+                this.set( 'link', props.get( 'link' ) );
+                this.updateLinkUrl();
+                this.updateSize();
+        },
+
+        setLinkTypeFromUrl: function() {
+                var linkUrl = this.get( 'linkUrl' ),
+                        type;
+
+                if ( ! linkUrl ) {
+                        this.set( 'link', 'none' );
+                        return;
+                }
+
+                // default to custom if there is a linkUrl
+                type = 'custom';
+
+                if ( this.attachment ) {
+                        if ( this.attachment.get( 'url' ) === linkUrl ) {
+                                type = 'file';
+                        } else if ( this.attachment.get( 'link' ) === linkUrl ) {
+                                type = 'post';
+                        }
+                } else {
+                        if ( this.get( 'url' ) === linkUrl ) {
+                                type = 'file';
+                        }
+                }
+
+                this.set( 'link', type );
+        },
+
+        updateLinkUrl: function() {
+                var link = this.get( 'link' ),
+                        url;
+
+                switch( link ) {
+                        case 'file':
+                                if ( this.attachment ) {
+                                        url = this.attachment.get( 'url' );
+                                } else {
+                                        url = this.get( 'url' );
+                                }
+                                this.set( 'linkUrl', url );
+                                break;
+                        case 'post':
+                                this.set( 'linkUrl', this.attachment.get( 'link' ) );
+                                break;
+                        case 'none':
+                                this.set( 'linkUrl', '' );
+                                break;
+                }
+        },
+
+        updateSize: function() {
+                var size;
+
+                if ( ! this.attachment ) {
+                        return;
+                }
+
+                if ( this.get( 'size' ) === 'custom' ) {
+                        this.set( 'width', this.get( 'customWidth' ) );
+                        this.set( 'height', this.get( 'customHeight' ) );
+                        this.set( 'url', this.get( 'originalUrl' ) );
+                        return;
+                }
+
+                size = this.attachment.get( 'sizes' )[ this.get( 'size' ) ];
+
+                if ( ! size ) {
+                        return;
+                }
+
+                this.set( 'url', size.url );
+                this.set( 'width', size.width );
+                this.set( 'height', size.height );
+        },
+
+        setAspectRatio: function() {
+                var full;
+
+                if ( this.attachment && this.attachment.get( 'sizes' ) ) {
+                        full = this.attachment.get( 'sizes' ).full;
+
+                        if ( full ) {
+                                this.set( 'aspectRatio', full.width / full.height );
+                                return;
+                        }
+                }
+
+                this.set( 'aspectRatio', this.get( 'customWidth' ) / this.get( 'customHeight' ) );
+        }
+});
+
+module.exports = PostImage;
+},{"./attachment":2}],5:[function(require,module,exports){
+/**
+ * wp.media.model.Query
+ *
+ * A collection of attachments that match the supplied query arguments.
+ *
+ * Note: Do NOT change this.args after the query has been initialized.
+ *       Things will break.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ *
+ * @param {array}  [models]                      Models to initialize with the collection.
+ * @param {object} [options]                     Options hash.
+ * @param {object} [options.args]                Attachments query arguments.
+ * @param {object} [options.args.posts_per_page]
+ */
+var Attachments = require( './attachments.js' ),
+        Query;
+
+Query = Attachments.extend({
+        /**
+         * @global wp.Uploader
+         *
+         * @param {array}  [models=[]]  Array of initial models to populate the collection.
+         * @param {object} [options={}]
+         */
+        initialize: function( models, options ) {
+                var allowed;
+
+                options = options || {};
+                Attachments.prototype.initialize.apply( this, arguments );
+
+                this.args     = options.args;
+                this._hasMore = true;
+                this.created  = new Date();
+
+                this.filters.order = function( attachment ) {
+                        var orderby = this.props.get('orderby'),
+                                order = this.props.get('order');
+
+                        if ( ! this.comparator ) {
+                                return true;
+                        }
+
+                        // We want any items that can be placed before the last
+                        // item in the set. If we add any items after the last
+                        // item, then we can't guarantee the set is complete.
+                        if ( this.length ) {
+                                return 1 !== this.comparator( attachment, this.last(), { ties: true });
+
+                        // Handle the case where there are no items yet and
+                        // we're sorting for recent items. In that case, we want
+                        // changes that occurred after we created the query.
+                        } else if ( 'DESC' === order && ( 'date' === orderby || 'modified' === orderby ) ) {
+                                return attachment.get( orderby ) >= this.created;
+
+                        // If we're sorting by menu order and we have no items,
+                        // accept any items that have the default menu order (0).
+                        } else if ( 'ASC' === order && 'menuOrder' === orderby ) {
+                                return attachment.get( orderby ) === 0;
+                        }
+
+                        // Otherwise, we don't want any items yet.
+                        return false;
+                };
+
+                // Observe the central `wp.Uploader.queue` collection to watch for
+                // new matches for the query.
+                //
+                // Only observe when a limited number of query args are set. There
+                // are no filters for other properties, so observing will result in
+                // false positives in those queries.
+                allowed = [ 's', 'order', 'orderby', 'posts_per_page', 'post_mime_type', 'post_parent' ];
+                if ( wp.Uploader && _( this.args ).chain().keys().difference( allowed ).isEmpty().value() ) {
+                        this.observe( wp.Uploader.queue );
+                }
+        },
+        /**
+         * Whether there are more attachments that haven't been sync'd from the server
+         * that match the collection's query.
+         *
+         * @returns {boolean}
+         */
+        hasMore: function() {
+                return this._hasMore;
+        },
+        /**
+         * Fetch more attachments from the server for the collection.
+         *
+         * @param   {object}  [options={}]
+         * @returns {Promise}
+         */
+        more: function( options ) {
+                var query = this;
+
+                // If there is already a request pending, return early with the Deferred object.
+                if ( this._more && 'pending' === this._more.state() ) {
+                        return this._more;
+                }
+
+                if ( ! this.hasMore() ) {
+                        return jQuery.Deferred().resolveWith( this ).promise();
+                }
+
+                options = options || {};
+                options.remove = false;
+
+                return this._more = this.fetch( options ).done( function( resp ) {
+                        if ( _.isEmpty( resp ) || -1 === this.args.posts_per_page || resp.length < this.args.posts_per_page ) {
+                                query._hasMore = false;
+                        }
+                });
+        },
+        /**
+         * Overrides Backbone.Collection.sync
+         * Overrides wp.media.model.Attachments.sync
+         *
+         * @param {String} method
+         * @param {Backbone.Model} model
+         * @param {Object} [options={}]
+         * @returns {Promise}
+         */
+        sync: function( method, model, options ) {
+                var args, fallback;
+
+                // Overload the read method so Attachment.fetch() functions correctly.
+                if ( 'read' === method ) {
+                        options = options || {};
+                        options.context = this;
+                        options.data = _.extend( options.data || {}, {
+                                action:  'query-attachments',
+                                post_id: wp.media.model.settings.post.id
+                        });
+
+                        // Clone the args so manipulation is non-destructive.
+                        args = _.clone( this.args );
+
+                        // Determine which page to query.
+                        if ( -1 !== args.posts_per_page ) {
+                                args.paged = Math.floor( this.length / args.posts_per_page ) + 1;
+                        }
+
+                        options.data.query = args;
+                        return wp.media.ajax( options );
+
+                // Otherwise, fall back to Backbone.sync()
+                } else {
+                        /**
+                         * Call wp.media.model.Attachments.sync or Backbone.sync
+                         */
+                        fallback = Attachments.prototype.sync ? Attachments.prototype : Backbone;
+                        return fallback.sync.apply( this, arguments );
+                }
+        }
+}, {
+        /**
+         * @readonly
+         */
+        defaultProps: {
+                orderby: 'date',
+                order:   'DESC'
+        },
+        /**
+         * @readonly
+         */
+        defaultArgs: {
+                posts_per_page: 40
+        },
+        /**
+         * @readonly
+         */
+        orderby: {
+                allowed:  [ 'name', 'author', 'date', 'title', 'modified', 'uploadedTo', 'id', 'post__in', 'menuOrder' ],
+                /**
+                 * A map of JavaScript orderby values to their WP_Query equivalents.
+                 * @type {Object}
+                 */
+                valuemap: {
+                        'id':         'ID',
+                        'uploadedTo': 'parent',
+                        'menuOrder':  'menu_order ID'
+                }
+        },
+        /**
+         * A map of JavaScript query properties to their WP_Query equivalents.
+         *
+         * @readonly
+         */
+        propmap: {
+                'search':    's',
+                'type':      'post_mime_type',
+                'perPage':   'posts_per_page',
+                'menuOrder': 'menu_order',
+                'uploadedTo': 'post_parent',
+                'status':     'post_status',
+                'include':    'post__in',
+                'exclude':    'post__not_in'
+        },
+        /**
+         * Creates and returns an Attachments Query collection given the properties.
+         *
+         * Caches query objects and reuses where possible.
+         *
+         * @static
+         * @method
+         *
+         * @param {object} [props]
+         * @param {Object} [props.cache=true]   Whether to use the query cache or not.
+         * @param {Object} [props.order]
+         * @param {Object} [props.orderby]
+         * @param {Object} [props.include]
+         * @param {Object} [props.exclude]
+         * @param {Object} [props.s]
+         * @param {Object} [props.post_mime_type]
+         * @param {Object} [props.posts_per_page]
+         * @param {Object} [props.menu_order]
+         * @param {Object} [props.post_parent]
+         * @param {Object} [props.post_status]
+         * @param {Object} [options]
+         *
+         * @returns {wp.media.model.Query} A new Attachments Query collection.
+         */
+        get: (function(){
+                /**
+                 * @static
+                 * @type Array
+                 */
+                var queries = [];
+
+                /**
+                 * @returns {Query}
+                 */
+                return function( props, options ) {
+                        var args     = {},
+                                orderby  = Query.orderby,
+                                defaults = Query.defaultProps,
+                                query,
+                                cache    = !! props.cache || _.isUndefined( props.cache );
+
+                        // Remove the `query` property. This isn't linked to a query,
+                        // this *is* the query.
+                        delete props.query;
+                        delete props.cache;
+
+                        // Fill default args.
+                        _.defaults( props, defaults );
+
+                        // Normalize the order.
+                        props.order = props.order.toUpperCase();
+                        if ( 'DESC' !== props.order && 'ASC' !== props.order ) {
+                                props.order = defaults.order.toUpperCase();
+                        }
+
+                        // Ensure we have a valid orderby value.
+                        if ( ! _.contains( orderby.allowed, props.orderby ) ) {
+                                props.orderby = defaults.orderby;
+                        }
+
+                        _.each( [ 'include', 'exclude' ], function( prop ) {
+                                if ( props[ prop ] && ! _.isArray( props[ prop ] ) ) {
+                                        props[ prop ] = [ props[ prop ] ];
+                                }
+                        } );
+
+                        // Generate the query `args` object.
+                        // Correct any differing property names.
+                        _.each( props, function( value, prop ) {
+                                if ( _.isNull( value ) ) {
+                                        return;
+                                }
+
+                                args[ Query.propmap[ prop ] || prop ] = value;
+                        });
+
+                        // Fill any other default query args.
+                        _.defaults( args, Query.defaultArgs );
+
+                        // `props.orderby` does not always map directly to `args.orderby`.
+                        // Substitute exceptions specified in orderby.keymap.
+                        args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;
+
+                        // Search the query cache for a matching query.
+                        if ( cache ) {
+                                query = _.find( queries, function( query ) {
+                                        return _.isEqual( query.args, args );
+                                });
+                        } else {
+                                queries = [];
+                        }
+
+                        // Otherwise, create a new query and add it to the cache.
+                        if ( ! query ) {
+                                query = new Query( [], _.extend( options || {}, {
+                                        props: props,
+                                        args:  args
+                                } ) );
+                                queries.push( query );
+                        }
+
+                        return query;
+                };
+        }())
+});
+
+module.exports = Query;
+},{"./attachments.js":3}],6:[function(require,module,exports){
+/**
+ * wp.media.model.Selection
+ *
+ * A selection of attachments.
+ *
+ * @class
+ * @augments wp.media.model.Attachments
+ * @augments Backbone.Collection
+ */
+var Attachments = require( './attachments.js' ),
+        Selection;
+
+Selection = Attachments.extend({
+        /**
+         * Refresh the `single` model whenever the selection changes.
+         * Binds `single` instead of using the context argument to ensure
+         * it receives no parameters.
+         *
+         * @param {Array} [models=[]] Array of models used to populate the collection.
+         * @param {Object} [options={}]
+         */
+        initialize: function( models, options ) {
+                /**
+                 * call 'initialize' directly on the parent class
+                 */
+                Attachments.prototype.initialize.apply( this, arguments );
+                this.multiple = options && options.multiple;
+
+                this.on( 'add remove reset', _.bind( this.single, this, false ) );
+        },
+
+        /**
+         * If the workflow does not support multi-select, clear out the selection
+         * before adding a new attachment to it.
+         *
+         * @param {Array} models
+         * @param {Object} options
+         * @returns {wp.media.model.Attachment[]}
+         */
+        add: function( models, options ) {
+                if ( ! this.multiple ) {
+                        this.remove( this.models );
+                }
+                /**
+                 * call 'add' directly on the parent class
+                 */
+                return Attachments.prototype.add.call( this, models, options );
+        },
+
+        /**
+         * Fired when toggling (clicking on) an attachment in the modal.
+         *
+         * @param {undefined|boolean|wp.media.model.Attachment} model
+         *
+         * @fires wp.media.model.Selection#selection:single
+         * @fires wp.media.model.Selection#selection:unsingle
+         *
+         * @returns {Backbone.Model}
+         */
+        single: function( model ) {
+                var previous = this._single;
+
+                // If a `model` is provided, use it as the single model.
+                if ( model ) {
+                        this._single = model;
+                }
+                // If the single model isn't in the selection, remove it.
+                if ( this._single && ! this.get( this._single.cid ) ) {
+                        delete this._single;
+                }
+
+                this._single = this._single || this.last();
+
+                // If single has changed, fire an event.
+                if ( this._single !== previous ) {
+                        if ( previous ) {
+                                previous.trigger( 'selection:unsingle', previous, this );
+
+                                // If the model was already removed, trigger the collection
+                                // event manually.
+                                if ( ! this.get( previous.cid ) ) {
+                                        this.trigger( 'selection:unsingle', previous, this );
+                                }
+                        }
+                        if ( this._single ) {
+                                this._single.trigger( 'selection:single', this._single, this );
+                        }
+                }
+
+                // Return the single model, or the last model as a fallback.
+                return this._single;
+        }
+});
+
+module.exports = Selection;
+},{"./attachments.js":3}]},{},[1]);

src/wp-includes/js/media/models.manifest.js

@@ +1 @@
+/* global _wpMediaModelsL10n:false */
+window.wp = window.wp || {};
+
+(function($){
+        var Attachment, Attachments, l10n, media;
+
+        /**
+         * Create and return a media frame.
+         *
+         * Handles the default media experience.
+         *
+         * @param  {object} attributes The properties passed to the main media controller.
+         * @return {wp.media.view.MediaFrame} A media workflow.
+         */
+        media = wp.media = function( attributes ) {
+                var MediaFrame = media.view.MediaFrame,
+                        frame;
+
+                if ( ! MediaFrame ) {
+                        return;
+                }
+
+                attributes = _.defaults( attributes || {}, {
+                        frame: 'select'
+                });
+
+                if ( 'select' === attributes.frame && MediaFrame.Select ) {
+                        frame = new MediaFrame.Select( attributes );
+                } else if ( 'post' === attributes.frame && MediaFrame.Post ) {
+                        frame = new MediaFrame.Post( attributes );
+                } else if ( 'manage' === attributes.frame && MediaFrame.Manage ) {
+                        frame = new MediaFrame.Manage( attributes );
+                } else if ( 'image' === attributes.frame && MediaFrame.ImageDetails ) {
+                        frame = new MediaFrame.ImageDetails( attributes );
+                } else if ( 'audio' === attributes.frame && MediaFrame.AudioDetails ) {
+                        frame = new MediaFrame.AudioDetails( attributes );
+                } else if ( 'video' === attributes.frame && MediaFrame.VideoDetails ) {
+                        frame = new MediaFrame.VideoDetails( attributes );
+                } else if ( 'edit-attachments' === attributes.frame && MediaFrame.EditAttachments ) {
+                        frame = new MediaFrame.EditAttachments( attributes );
+                }
+
+                delete attributes.frame;
+
+                media.frame = frame;
+
+                return frame;
+        };
+
+        _.extend( media, { model: {}, view: {}, controller: {}, frames: {} });
+
+        // Link any localized strings.
+        l10n = media.model.l10n = typeof _wpMediaModelsL10n === 'undefined' ? {} : _wpMediaModelsL10n;
+
+        // Link any settings.
+        media.model.settings = l10n.settings || {};
+        delete l10n.settings;
+
+        Attachments = media.model.Attachments = require( './models/attachments.js' );
+        Attachment = media.model.Attachment = require( './models/attachment.js' );
+
+        media.model.Query = require( './models/query.js' );
+        media.model.PostImage = require( './models/post-image.js' );
+        media.model.Selection = require( './models/selection.js' );
+
+        /**
+         * ========================================================================
+         * UTILITIES
+         * ========================================================================
+         */
+
+        /**
+         * A basic equality comparator for Backbone models.
+         *
+         * Used to order models within a collection - @see wp.media.model.Attachments.comparator().
+         *
+         * @param  {mixed}  a  The primary parameter to compare.
+         * @param  {mixed}  b  The primary parameter to compare.
+         * @param  {string} ac The fallback parameter to compare, a's cid.
+         * @param  {string} bc The fallback parameter to compare, b's cid.
+         * @return {number}    -1: a should come before b.
+         *                      0: a and b are of the same rank.
+         *                      1: b should come before a.
+         */
+        media.compare = function( a, b, ac, bc ) {
+                if ( _.isEqual( a, b ) ) {
+                        return ac === bc ? 0 : (ac > bc ? -1 : 1);
+                } else {
+                        return a > b ? -1 : 1;
+                }
+        };
+
+        _.extend( media, {
+                /**
+                 * media.template( id )
+                 *
+                 * Fetch a JavaScript template for an id, and return a templating function for it.
+                 *
+                 * See wp.template() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.template as template
+                 */
+                template: wp.template,
+
+                /**
+                 * media.post( [action], [data] )
+                 *
+                 * Sends a POST request to WordPress.
+                 * See wp.ajax.post() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.ajax.post as post
+                 */
+                post: wp.ajax.post,
+
+                /**
+                 * media.ajax( [action], [options] )
+                 *
+                 * Sends an XHR request to WordPress.
+                 * See wp.ajax.send() in `wp-includes/js/wp-util.js`.
+                 *
+                 * @borrows wp.ajax.send as ajax
+                 */
+                ajax: wp.ajax.send,
+
+                /**
+                 * Scales a set of dimensions to fit within bounding dimensions.
+                 *
+                 * @param {Object} dimensions
+                 * @returns {Object}
+                 */
+                fit: function( dimensions ) {
+                        var width     = dimensions.width,
+                                height    = dimensions.height,
+                                maxWidth  = dimensions.maxWidth,
+                                maxHeight = dimensions.maxHeight,
+                                constraint;
+
+                        // Compare ratios between the two values to determine which
+                        // max to constrain by. If a max value doesn't exist, then the
+                        // opposite side is the constraint.
+                        if ( ! _.isUndefined( maxWidth ) && ! _.isUndefined( maxHeight ) ) {
+                                constraint = ( width / height > maxWidth / maxHeight ) ? 'width' : 'height';
+                        } else if ( _.isUndefined( maxHeight ) ) {
+                                constraint = 'width';
+                        } else if (  _.isUndefined( maxWidth ) && height > maxHeight ) {
+                                constraint = 'height';
+                        }
+
+                        // If the value of the constrained side is larger than the max,
+                        // then scale the values. Otherwise return the originals; they fit.
+                        if ( 'width' === constraint && width > maxWidth ) {
+                                return {
+                                        width : maxWidth,
+                                        height: Math.round( maxWidth * height / width )
+                                };
+                        } else if ( 'height' === constraint && height > maxHeight ) {
+                                return {
+                                        width : Math.round( maxHeight * width / height ),
+                                        height: maxHeight
+                                };
+                        } else {
+                                return {
+                                        width : width,
+                                        height: height
+                                };
+                        }
+                },
+                /**
+                 * Truncates a string by injecting an ellipsis into the middle.
+                 * Useful for filenames.
+                 *
+                 * @param {String} string
+                 * @param {Number} [length=30]
+                 * @param {String} [replacement=…]
+                 * @returns {String} The string, unless length is greater than string.length.
+                 */
+                truncate: function( string, length, replacement ) {
+                        length = length || 30;
+                        replacement = replacement || '…';
+
+                        if ( string.length <= length ) {
+                                return string;
+                        }
+
+                        return string.substr( 0, length / 2 ) + replacement + string.substr( -1 * length / 2 );
+                }
+        });
+
+        /**
+         * ========================================================================
+         * MODELS
+         * ========================================================================
+         */
+        /**
+         * wp.media.attachment
+         *
+         * @static
+         * @param {String} id A string used to identify a model.
+         * @returns {wp.media.model.Attachment}
+         */
+        media.attachment = function( id ) {
+                return Attachment.get( id );
+        };
+
+        /**
+         * A collection of all attachments that have been fetched from the server.
+         *
+         * @static
+         * @member {wp.media.model.Attachments}
+         */
+        Attachments.all = new Attachments();
+
+        /**
+         * wp.media.query
+         *
+         * Shorthand for creating a new Attachments Query.
+         *
+         * @param {object} [props]
+         * @returns {wp.media.model.Attachments}
+         */
+        media.query = function( props ) {
+                return new Attachments( null, {
+                        props: _.extend( _.defaults( props || {}, { orderby: 'date' } ), { query: true } )
+                });
+        };
+
+        // Clean up. Prevents mobile browsers caching
+        $(window).on('unload', function(){
+                window.wp = null;
+        });
+
+}(jQuery));

src/wp-includes/js/media/router/manage.js

@@ +1 @@
+/**
+ * A router for handling the browser history and application state.
+ *
+ * @constructor
+ * @augments Backbone.Router
+ */
+var Router = Backbone.Router.extend({
+        routes: {
+                'upload.php?item=:slug':    'showItem',
+                'upload.php?search=:query': 'search'
+        },
+
+        // Map routes against the page URL
+        baseUrl: function( url ) {
+                return 'upload.php' + url;
+        },
+
+        // Respond to the search route by filling the search field and trigggering the input event
+        search: function( query ) {
+                jQuery( '#media-search-input' ).val( query ).trigger( 'input' );
+        },
+
+        // Show the modal with a specific item
+        showItem: function( query ) {
+                var media = wp.media,
+                        library = media.frame.state().get('library'),
+                        item;
+
+                // Trigger the media frame to open the correct item
+                item = library.findWhere( { id: parseInt( query, 10 ) } );
+                if ( item ) {
+                        media.frame.trigger( 'edit:attachment', item );
+                } else {
+                        item = media.attachment( query );
+                        media.frame.listenTo( item, 'change', function( model ) {
+                                media.frame.stopListening( item );
+                                media.frame.trigger( 'edit:attachment', model );
+                        } );
+                        item.fetch();
+                }
+        }
+});
+
+module.exports = Router;
+ No newline at end of file

src/wp-includes/js/media/utils/selection-sync.js

@@ +1 @@
+/**
+ * wp.media.selectionSync
+ *
+ * Sync an attachments selection in a state with another state.
+ *
+ * Allows for selecting multiple images in the Insert Media workflow, and then
+ * switching to the Insert Gallery workflow while preserving the attachments selection.
+ *
+ * @mixin
+ */
+var selectionSync = {
+        /**
+         * @since 3.5.0
+         */
+        syncSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                // If the selection supports multiple items, validate the stored
+                // attachments based on the new selection's conditions. Record
+                // the attachments that are not included; we'll maintain a
+                // reference to those. Other attachments are considered in flux.
+                if ( selection.multiple ) {
+                        selection.reset( [], { silent: true });
+                        selection.validateAll( manager.attachments );
+                        manager.difference = _.difference( manager.attachments.models, selection.models );
+                }
+
+                // Sync the selection's single item with the master.
+                selection.single( manager.single );
+        },
+
+        /**
+         * Record the currently active attachments, which is a combination
+         * of the selection's attachments and the set of selected
+         * attachments that this specific selection considered invalid.
+         * Reset the difference and record the single attachment.
+         *
+         * @since 3.5.0
+         */
+        recordSelection: function() {
+                var selection = this.get('selection'),
+                        manager = this.frame._selection;
+
+                if ( ! this.get('syncSelection') || ! manager || ! selection ) {
+                        return;
+                }
+
+                if ( selection.multiple ) {
+                        manager.attachments.reset( selection.toArray().concat( manager.difference ) );
+                        manager.difference = [];
+                } else {
+                        manager.attachments.add( selection.toArray() );
+                }
+
+                manager.single = selection._single;
+        }
+};
+
+module.exports = selectionSync;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/details-two-column.js

@@ +1 @@
+/**
+ * A similar view to media.view.Attachment.Details
+ * for use in the Edit Attachment modal.
+ *
+ * @constructor
+ * @augments wp.media.view.Attachment.Details
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Details = require( './details.js' ),
+        MediaDetails = require( '../media-details.js' ),
+        TwoColumn;
+
+TwoColumn = Details.extend({
+        template: wp.template( 'attachment-details-two-column' ),
+
+        editAttachment: function( event ) {
+                event.preventDefault();
+                this.controller.content.mode( 'edit-image' );
+        },
+
+        /**
+         * Noop this from parent class, doesn't apply here.
+         */
+        toggleSelectionHandler: function() {},
+
+        render: function() {
+                Details.prototype.render.apply( this, arguments );
+
+                wp.media.mixin.removeAllPlayers();
+                this.$( 'audio, video' ).each( function (i, elem) {
+                        var el = MediaDetails.prepareSrc( elem );
+                        new MediaElementPlayer( el, wp.media.mixin.mejsSettings );
+                } );
+        }
+});
+
+module.exports = TwoColumn;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/details.js

@@ +1 @@
+/**
+ * wp.media.view.Attachment.Details
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        l10n = wp.media.view.l10n,
+        Details;
+
+Details = Attachment.extend({
+        tagName:   'div',
+        className: 'attachment-details',
+        template:  wp.template('attachment-details'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .delete-attachment':       'deleteAttachment',
+                'click .trash-attachment':        'trashAttachment',
+                'click .untrash-attachment':      'untrashAttachment',
+                'click .edit-attachment':         'editAttachment',
+                'click .refresh-attachment':      'refreshAttachment',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        initialize: function() {
+                this.options = _.defaults( this.options, {
+                        rerenderOnModelChange: false
+                });
+
+                this.on( 'ready', this.initialFocus );
+                // Call 'initialize' directly on the parent class.
+                Attachment.prototype.initialize.apply( this, arguments );
+        },
+
+        initialFocus: function() {
+                if ( ! wp.media.isTouchDevice ) {
+                        this.$( ':input' ).eq( 0 ).focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        deleteAttachment: function( event ) {
+                event.preventDefault();
+
+                if ( confirm( l10n.warnDelete ) ) {
+                        this.model.destroy();
+                        // Keep focus inside media modal
+                        // after image is deleted
+                        this.controller.modal.focusManager.focus();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        trashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        'edit-metadata' === this.controller.content.mode() ) {
+
+                        this.model.set( 'status', 'trash' );
+                        this.model.save().done( function() {
+                                library._requery( true );
+                        } );
+                }  else {
+                        this.model.destroy();
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        untrashAttachment: function( event ) {
+                var library = this.controller.library;
+                event.preventDefault();
+
+                this.model.set( 'status', 'inherit' );
+                this.model.save().done( function() {
+                        library._requery( true );
+                } );
+        },
+        /**
+         * @param {Object} event
+         */
+        editAttachment: function( event ) {
+                var editState = this.controller.states.get( 'edit-image' );
+                if ( window.imageEdit && editState ) {
+                        event.preventDefault();
+
+                        editState.set( 'image', this.model );
+                        this.controller.setState( 'edit-image' );
+                } else {
+                        this.$el.addClass('needs-refresh');
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        refreshAttachment: function( event ) {
+                this.$el.removeClass('needs-refresh');
+                event.preventDefault();
+                this.model.fetch();
+        },
+        /**
+         * When reverse tabbing(shift+tab) out of the right details panel, deliver
+         * the focus to the item in the list that was being edited.
+         *
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                if ( 'keydown' === event.type && 9 === event.keyCode && event.shiftKey && event.target === this.$( ':tabbable' ).get( 0 ) ) {
+                        this.controller.trigger( 'attachment:details:shift-tab', event );
+                        return false;
+                }
+
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+        }
+});
+
+module.exports = Details;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/edit-library.js

@@ +1 @@
+/**
+ * wp.media.view.Attachment.EditLibrary
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        EditLibrary;
+
+EditLibrary = Attachment.extend({
+        buttons: {
+                close: true
+        }
+});
+
+module.exports = EditLibrary;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/edit-selection.js

@@ +1 @@
+/**
+ * wp.media.view.Attachments.EditSelection
+ *
+ * @class
+ * @augments wp.media.view.Attachment.Selection
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Selection = require( './selection.js' ),
+        EditSelection;
+
+EditSelection = Selection.extend({
+        buttons: {
+                close: true
+        }
+});
+
+module.exports = EditSelection;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/library.js

@@ +1 @@
+/**
+ * wp.media.view.Attachment.Library
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        Library;
+
+Library = Attachment.extend({
+        buttons: {
+                check: true
+        }
+});
+
+module.exports = Library;
+ No newline at end of file

src/wp-includes/js/media/views/attachment/selection.js

@@ +1 @@
+/**
+ * wp.media.view.Attachment.Selection
+ *
+ * @class
+ * @augments wp.media.view.Attachment
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachment = require( '../attachment.js' ),
+        Selection;
+
+Selection = Attachment.extend({
+        className: 'attachment selection',
+
+        // On click, just select the model, instead of removing the model from
+        // the selection.
+        toggleSelection: function() {
+                this.options.selection.single( this.model );
+        }
+});
+
+module.exports = Selection;
+ No newline at end of file

src/wp-includes/js/media/views/attachment-compat.js

@@ +1 @@
+/**
+ * wp.media.view.AttachmentCompat
+ *
+ * A view to display fields added via the `attachment_fields_to_edit` filter.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        AttachmentCompat;
+
+AttachmentCompat = View.extend({
+        tagName:   'form',
+        className: 'compat-item',
+
+        events: {
+                'submit':          'preventDefault',
+                'change input':    'save',
+                'change select':   'save',
+                'change textarea': 'save'
+        },
+
+        initialize: function() {
+                this.model.on( 'change:compat', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.$(':focus').length ) {
+                        this.save();
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentCompat} Returns itself to allow chaining
+         */
+        render: function() {
+                var compat = this.model.get('compat');
+                if ( ! compat || ! compat.item ) {
+                        return;
+                }
+
+                this.views.detach();
+                this.$el.html( compat.item );
+                this.views.render();
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {Object} event
+         */
+        save: function( event ) {
+                var data = {};
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                _.each( this.$el.serializeArray(), function( pair ) {
+                        data[ pair.name ] = pair.value;
+                });
+
+                this.controller.trigger( 'attachment:compat:waiting', ['waiting'] );
+                this.model.saveCompat( data ).always( _.bind( this.postSave, this ) );
+        },
+
+        postSave: function() {
+                this.controller.trigger( 'attachment:compat:ready', ['ready'] );
+        }
+});
+
+module.exports = AttachmentCompat;
+ No newline at end of file

src/wp-includes/js/media/views/attachment-filters/all.js

@@ +1 @@
+/**
+ * wp.media.view.AttachmentFilters.All
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        All;
+
+All = AttachmentFilters.extend({
+        createFilters: function() {
+                var filters = {};
+
+                _.each( wp.media.view.settings.mimeTypes || {}, function( text, key ) {
+                        filters[ key ] = {
+                                text: text,
+                                props: {
+                                        status:  null,
+                                        type:    key,
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                }
+                        };
+                });
+
+                filters.all = {
+                        text:  l10n.allMediaItems,
+                        props: {
+                                status:  null,
+                                type:    null,
+                                uploadedTo: null,
+                                orderby: 'date',
+                                order:   'DESC'
+                        },
+                        priority: 10
+                };
+
+                if ( wp.media.view.settings.post.id ) {
+                        filters.uploaded = {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        status:  null,
+                                        type:    null,
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        };
+                }
+
+                filters.unattached = {
+                        text:  l10n.unattached,
+                        props: {
+                                status:     null,
+                                uploadedTo: 0,
+                                type:       null,
+                                orderby:    'menuOrder',
+                                order:      'ASC'
+                        },
+                        priority: 50
+                };
+
+                if ( wp.media.view.settings.mediaTrash &&
+                        this.controller.isModeActive( 'grid' ) ) {
+
+                        filters.trash = {
+                                text:  l10n.trash,
+                                props: {
+                                        uploadedTo: null,
+                                        status:     'trash',
+                                        type:       null,
+                                        orderby:    'date',
+                                        order:      'DESC'
+                                },
+                                priority: 50
+                        };
+                }
+
+                this.filters = filters;
+        }
+});
+
+module.exports = All;
+ No newline at end of file

src/wp-includes/js/media/views/attachment-filters/date.js

@@ +1 @@
+/**
+ * A filter dropdown for month/dates.
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        DateFilter;
+
+DateFilter = AttachmentFilters.extend({
+        id: 'media-attachment-date-filters',
+
+        createFilters: function() {
+                var filters = {};
+                _.each( wp.media.view.settings.months || {}, function( value, index ) {
+                        filters[ index ] = {
+                                text: value.text,
+                                props: {
+                                        year: value.year,
+                                        monthnum: value.month
+                                }
+                        };
+                });
+                filters.all = {
+                        text:  l10n.allDates,
+                        props: {
+                                monthnum: false,
+                                year:  false
+                        },
+                        priority: 10
+                };
+                this.filters = filters;
+        }
+});
+
+module.exports = DateFilter;
+ No newline at end of file

src/wp-includes/js/media/views/attachment-filters/uploaded.js

@@ +1 @@
+/**
+ * wp.media.view.AttachmentFilters.Uploaded
+ *
+ * @class
+ * @augments wp.media.view.AttachmentFilters
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentFilters = require( '../attachment-filters.js' ),
+        l10n = wp.media.view.l10n,
+        Uploaded;
+
+Uploaded = AttachmentFilters.extend({
+        createFilters: function() {
+                var type = this.model.get('type'),
+                        types = wp.media.view.settings.mimeTypes,
+                        text;
+
+                if ( types && type ) {
+                        text = types[ type ];
+                }
+
+                this.filters = {
+                        all: {
+                                text:  text || l10n.allMediaItems,
+                                props: {
+                                        uploadedTo: null,
+                                        orderby: 'date',
+                                        order:   'DESC'
+                                },
+                                priority: 10
+                        },
+
+                        uploaded: {
+                                text:  l10n.uploadedToThisPost,
+                                props: {
+                                        uploadedTo: wp.media.view.settings.post.id,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 20
+                        },
+
+                        unattached: {
+                                text:  l10n.unattached,
+                                props: {
+                                        uploadedTo: 0,
+                                        orderby: 'menuOrder',
+                                        order:   'ASC'
+                                },
+                                priority: 50
+                        }
+                };
+        }
+});
+
+module.exports = Uploaded;
+ No newline at end of file

src/wp-includes/js/media/views/attachment-filters.js

@@ +1 @@
+/**
+ * wp.media.view.AttachmentFilters
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        AttachmentFilters;
+
+AttachmentFilters = View.extend({
+        tagName:   'select',
+        className: 'attachment-filters',
+        id:        'media-attachment-filters',
+
+        events: {
+                change: 'change'
+        },
+
+        keys: [],
+
+        initialize: function() {
+                this.createFilters();
+                _.extend( this.filters, this.options.filters );
+
+                // Build `<option>` elements.
+                this.$el.html( _.chain( this.filters ).map( function( filter, value ) {
+                        return {
+                                el: $( '<option></option>' ).val( value ).html( filter.text )[0],
+                                priority: filter.priority || 50
+                        };
+                }, this ).sortBy('priority').pluck('el').value() );
+
+                this.model.on( 'change', this.select, this );
+                this.select();
+        },
+
+        /**
+         * @abstract
+         */
+        createFilters: function() {
+                this.filters = {};
+        },
+
+        /**
+         * When the selected filter changes, update the Attachment Query properties to match.
+         */
+        change: function() {
+                var filter = this.filters[ this.el.value ];
+                if ( filter ) {
+                        this.model.set( filter.props );
+                }
+        },
+
+        select: function() {
+                var model = this.model,
+                        value = 'all',
+                        props = model.toJSON();
+
+                _.find( this.filters, function( filter, id ) {
+                        var equal = _.all( filter.props, function( prop, key ) {
+                                return prop === ( _.isUndefined( props[ key ] ) ? null : props[ key ] );
+                        });
+
+                        if ( equal ) {
+                                return value = id;
+                        }
+                });
+
+                this.$el.val( value );
+        }
+});
+
+module.exports = AttachmentFilters;
+ No newline at end of file

src/wp-includes/js/media/views/attachment.js

@@ +1 @@
+/**
+ * wp.media.view.Attachment
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Attachment;
+
+Attachment = View.extend({
+        tagName:   'li',
+        className: 'attachment',
+        template:  wp.template('attachment'),
+
+        attributes: function() {
+                return {
+                        'tabIndex':     0,
+                        'role':         'checkbox',
+                        'aria-label':   this.model.get( 'title' ),
+                        'aria-checked': false,
+                        'data-id':      this.model.get( 'id' )
+                };
+        },
+
+        events: {
+                'click .js--select-attachment':   'toggleSelectionHandler',
+                'change [data-setting]':          'updateSetting',
+                'change [data-setting] input':    'updateSetting',
+                'change [data-setting] select':   'updateSetting',
+                'change [data-setting] textarea': 'updateSetting',
+                'click .close':                   'removeFromLibrary',
+                'click .check':                   'checkClickHandler',
+                'click a':                        'preventDefault',
+                'keydown .close':                 'removeFromLibrary',
+                'keydown':                        'toggleSelectionHandler'
+        },
+
+        buttons: {},
+
+        initialize: function() {
+                var selection = this.options.selection,
+                        options = _.defaults( this.options, {
+                                rerenderOnModelChange: true
+                        } );
+
+                if ( options.rerenderOnModelChange ) {
+                        this.model.on( 'change', this.render, this );
+                } else {
+                        this.model.on( 'change:percent', this.progress, this );
+                }
+                this.model.on( 'change:title', this._syncTitle, this );
+                this.model.on( 'change:caption', this._syncCaption, this );
+                this.model.on( 'change:artist', this._syncArtist, this );
+                this.model.on( 'change:album', this._syncAlbum, this );
+
+                // Update the selection.
+                this.model.on( 'add', this.select, this );
+                this.model.on( 'remove', this.deselect, this );
+                if ( selection ) {
+                        selection.on( 'reset', this.updateSelect, this );
+                        // Update the model's details view.
+                        this.model.on( 'selection:single selection:unsingle', this.details, this );
+                        this.details( this.model, this.controller.state().get('selection') );
+                }
+
+                this.listenTo( this.controller, 'attachment:compat:waiting attachment:compat:ready', this.updateSave );
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        dispose: function() {
+                var selection = this.options.selection;
+
+                // Make sure all settings are saved before removing the view.
+                this.updateAll();
+
+                if ( selection ) {
+                        selection.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        render: function() {
+                var options = _.defaults( this.model.toJSON(), {
+                                orientation:   'landscape',
+                                uploading:     false,
+                                type:          '',
+                                subtype:       '',
+                                icon:          '',
+                                filename:      '',
+                                caption:       '',
+                                title:         '',
+                                dateFormatted: '',
+                                width:         '',
+                                height:        '',
+                                compat:        false,
+                                alt:           '',
+                                description:   ''
+                        }, this.options );
+
+                options.buttons  = this.buttons;
+                options.describe = this.controller.state().get('describe');
+
+                if ( 'image' === options.type ) {
+                        options.size = this.imageSize();
+                }
+
+                options.can = {};
+                if ( options.nonces ) {
+                        options.can.remove = !! options.nonces['delete'];
+                        options.can.save = !! options.nonces.update;
+                }
+
+                if ( this.controller.state().get('allowLocalEdits') ) {
+                        options.allowLocalEdits = true;
+                }
+
+                if ( options.uploading && ! options.percent ) {
+                        options.percent = 0;
+                }
+
+                this.views.detach();
+                this.$el.html( this.template( options ) );
+
+                this.$el.toggleClass( 'uploading', options.uploading );
+
+                if ( options.uploading ) {
+                        this.$bar = this.$('.media-progress-bar div');
+                } else {
+                        delete this.$bar;
+                }
+
+                // Check if the model is selected.
+                this.updateSelect();
+
+                // Update the save status.
+                this.updateSave();
+
+                this.views.render();
+
+                return this;
+        },
+
+        progress: function() {
+                if ( this.$bar && this.$bar.length ) {
+                        this.$bar.width( this.model.get('percent') + '%' );
+                }
+        },
+
+        /**
+         * @param {Object} event
+         */
+        toggleSelectionHandler: function( event ) {
+                var method;
+
+                // Don't do anything inside inputs.
+                if ( 'INPUT' === event.target.nodeName ) {
+                        return;
+                }
+
+                // Catch arrow events
+                if ( 37 === event.keyCode || 38 === event.keyCode || 39 === event.keyCode || 40 === event.keyCode ) {
+                        this.controller.trigger( 'attachment:keydown:arrow', event );
+                        return;
+                }
+
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                event.preventDefault();
+
+                // In the grid view, bubble up an edit:attachment event to the controller.
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        if ( this.controller.isModeActive( 'edit' ) ) {
+                                // Pass the current target to restore focus when closing
+                                this.controller.trigger( 'edit:attachment', this.model, event.currentTarget );
+                                return;
+                        }
+
+                        if ( this.controller.isModeActive( 'select' ) ) {
+                                method = 'toggle';
+                        }
+                }
+
+                if ( event.shiftKey ) {
+                        method = 'between';
+                } else if ( event.ctrlKey || event.metaKey ) {
+                        method = 'toggle';
+                }
+
+                this.toggleSelection({
+                        method: method
+                });
+
+                this.controller.trigger( 'selection:toggle' );
+        },
+        /**
+         * @param {Object} options
+         */
+        toggleSelection: function( options ) {
+                var collection = this.collection,
+                        selection = this.options.selection,
+                        model = this.model,
+                        method = options && options.method,
+                        single, models, singleIndex, modelIndex;
+
+                if ( ! selection ) {
+                        return;
+                }
+
+                single = selection.single();
+                method = _.isUndefined( method ) ? selection.multiple : method;
+
+                // If the `method` is set to `between`, select all models that
+                // exist between the current and the selected model.
+                if ( 'between' === method && single && selection.multiple ) {
+                        // If the models are the same, short-circuit.
+                        if ( single === model ) {
+                                return;
+                        }
+
+                        singleIndex = collection.indexOf( single );
+                        modelIndex  = collection.indexOf( this.model );
+
+                        if ( singleIndex < modelIndex ) {
+                                models = collection.models.slice( singleIndex, modelIndex + 1 );
+                        } else {
+                                models = collection.models.slice( modelIndex, singleIndex + 1 );
+                        }
+
+                        selection.add( models );
+                        selection.single( model );
+                        return;
+
+                // If the `method` is set to `toggle`, just flip the selection
+                // status, regardless of whether the model is the single model.
+                } else if ( 'toggle' === method ) {
+                        selection[ this.selected() ? 'remove' : 'add' ]( model );
+                        selection.single( model );
+                        return;
+                } else if ( 'add' === method ) {
+                        selection.add( model );
+                        selection.single( model );
+                        return;
+                }
+
+                // Fixes bug that loses focus when selecting a featured image
+                if ( ! method ) {
+                        method = 'add';
+                }
+
+                if ( method !== 'add' ) {
+                        method = 'reset';
+                }
+
+                if ( this.selected() ) {
+                        // If the model is the single model, remove it.
+                        // If it is not the same as the single model,
+                        // it now becomes the single model.
+                        selection[ single === model ? 'remove' : 'single' ]( model );
+                } else {
+                        // If the model is not selected, run the `method` on the
+                        // selection. By default, we `reset` the selection, but the
+                        // `method` can be set to `add` the model to the selection.
+                        selection[ method ]( model );
+                        selection.single( model );
+                }
+        },
+
+        updateSelect: function() {
+                this[ this.selected() ? 'select' : 'deselect' ]();
+        },
+        /**
+         * @returns {unresolved|Boolean}
+         */
+        selected: function() {
+                var selection = this.options.selection;
+                if ( selection ) {
+                        return !! selection.get( this.model.cid );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        select: function( model, collection ) {
+                var selection = this.options.selection,
+                        controller = this.controller;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+
+                // Bail if the model is already selected.
+                if ( this.$el.hasClass( 'selected' ) ) {
+                        return;
+                }
+
+                // Add 'selected' class to model, set aria-checked to true.
+                this.$el.addClass( 'selected' ).attr( 'aria-checked', true );
+                //  Make the checkbox tabable, except in media grid (bulk select mode).
+                if ( ! ( controller.isModeActive( 'grid' ) && controller.isModeActive( 'select' ) ) ) {
+                        this.$( '.check' ).attr( 'tabindex', '0' );
+                }
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        deselect: function( model, collection ) {
+                var selection = this.options.selection;
+
+                // Check if a selection exists and if it's the collection provided.
+                // If they're not the same collection, bail; we're in another
+                // selection's event loop.
+                if ( ! selection || ( collection && collection !== selection ) ) {
+                        return;
+                }
+                this.$el.removeClass( 'selected' ).attr( 'aria-checked', false )
+                        .find( '.check' ).attr( 'tabindex', '-1' );
+        },
+        /**
+         * @param {Backbone.Model} model
+         * @param {Backbone.Collection} collection
+         */
+        details: function( model, collection ) {
+                var selection = this.options.selection,
+                        details;
+
+                if ( selection !== collection ) {
+                        return;
+                }
+
+                details = selection.single();
+                this.$el.toggleClass( 'details', details === this.model );
+        },
+        /**
+         * @param {Object} event
+         */
+        preventDefault: function( event ) {
+                event.preventDefault();
+        },
+        /**
+         * @param {string} size
+         * @returns {Object}
+         */
+        imageSize: function( size ) {
+                var sizes = this.model.get('sizes');
+
+                size = size || 'medium';
+
+                // Use the provided image size if possible.
+                if ( sizes && sizes[ size ] ) {
+                        return _.clone( sizes[ size ] );
+                } else {
+                        return {
+                                url:         this.model.get('url'),
+                                width:       this.model.get('width'),
+                                height:      this.model.get('height'),
+                                orientation: this.model.get('orientation')
+                        };
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateSetting: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        setting, value;
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                setting = $setting.data('setting');
+                value   = event.target.value;
+
+                if ( this.model.get( setting ) !== value ) {
+                        this.save( setting, value );
+                }
+        },
+
+        /**
+         * Pass all the arguments to the model's save method.
+         *
+         * Records the aggregate status of all save requests and updates the
+         * view's classes accordingly.
+         */
+        save: function() {
+                var view = this,
+                        save = this._save = this._save || { status: 'ready' },
+                        request = this.model.save.apply( this.model, arguments ),
+                        requests = save.requests ? $.when( request, save.requests ) : request;
+
+                // If we're waiting to remove 'Saved.', stop.
+                if ( save.savedTimer ) {
+                        clearTimeout( save.savedTimer );
+                }
+
+                this.updateSave('waiting');
+                save.requests = requests;
+                requests.always( function() {
+                        // If we've performed another request since this one, bail.
+                        if ( save.requests !== requests ) {
+                                return;
+                        }
+
+                        view.updateSave( requests.state() === 'resolved' ? 'complete' : 'error' );
+                        save.savedTimer = setTimeout( function() {
+                                view.updateSave('ready');
+                                delete save.savedTimer;
+                        }, 2000 );
+                });
+        },
+        /**
+         * @param {string} status
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        updateSave: function( status ) {
+                var save = this._save = this._save || { status: 'ready' };
+
+                if ( status && status !== save.status ) {
+                        this.$el.removeClass( 'save-' + save.status );
+                        save.status = status;
+                }
+
+                this.$el.addClass( 'save-' + save.status );
+                return this;
+        },
+
+        updateAll: function() {
+                var $settings = this.$('[data-setting]'),
+                        model = this.model,
+                        changed;
+
+                changed = _.chain( $settings ).map( function( el ) {
+                        var $input = $('input, textarea, select, [value]', el ),
+                                setting, value;
+
+                        if ( ! $input.length ) {
+                                return;
+                        }
+
+                        setting = $(el).data('setting');
+                        value = $input.val();
+
+                        // Record the value if it changed.
+                        if ( model.get( setting ) !== value ) {
+                                return [ setting, value ];
+                        }
+                }).compact().object().value();
+
+                if ( ! _.isEmpty( changed ) ) {
+                        model.save( changed );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        removeFromLibrary: function( event ) {
+                // Catch enter and space events
+                if ( 'keydown' === event.type && 13 !== event.keyCode && 32 !== event.keyCode ) {
+                        return;
+                }
+
+                // Stop propagation so the model isn't selected.
+                event.stopPropagation();
+
+                this.collection.remove( this.model );
+        },
+
+        /**
+         * Add the model if it isn't in the selection, if it is in the selection,
+         * remove it.
+         *
+         * @param  {[type]} event [description]
+         * @return {[type]}       [description]
+         */
+        checkClickHandler: function ( event ) {
+                var selection = this.options.selection;
+                if ( ! selection ) {
+                        return;
+                }
+                event.stopPropagation();
+                if ( selection.where( { id: this.model.get( 'id' ) } ).length ) {
+                        selection.remove( this.model );
+                        // Move focus back to the attachment tile (from the check).
+                        this.$el.focus();
+                } else {
+                        selection.add( this.model );
+                }
+        }
+});
+
+// Ensure settings remain in sync between attachment views.
+_.each({
+        caption: '_syncCaption',
+        title:   '_syncTitle',
+        artist:  '_syncArtist',
+        album:   '_syncAlbum'
+}, function( method, setting ) {
+        /**
+         * @param {Backbone.Model} model
+         * @param {string} value
+         * @returns {wp.media.view.Attachment} Returns itself to allow chaining
+         */
+        Attachment.prototype[ method ] = function( model, value ) {
+                var $setting = this.$('[data-setting="' + setting + '"]');
+
+                if ( ! $setting.length ) {
+                        return this;
+                }
+
+                // If the updated value is in sync with the value in the DOM, there
+                // is no need to re-render. If we're currently editing the value,
+                // it will automatically be in sync, suppressing the re-render for
+                // the view we're editing, while updating any others.
+                if ( value === $setting.find('input, textarea, select, [value]').val() ) {
+                        return this;
+                }
+
+                return this.render();
+        };
+});
+
+module.exports = Attachment;
+ No newline at end of file

src/wp-includes/js/media/views/attachments/browser.js

@@ +1 @@
+/**
+ * wp.media.view.AttachmentsBrowser
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object}      options
+ * @param {object}      [options.filters=false] Which filters to show in the browser's toolbar.
+ *                                              Accepts 'uploaded' and 'all'.
+ * @param {object}      [options.search=true]   Whether to show the search interface in the
+ *                                              browser's toolbar.
+ * @param {object}      [options.display=false] Whether to show the attachments display settings
+ *                                              view in the sidebar.
+ * @param {bool|string} [options.sidebar=true]  Whether to create a sidebar for the browser.
+ *                                              Accepts true, false, and 'errors'.
+ */
+var View = require( '../view.js' ),
+        Library = require( '../attachment/library.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        Spinner = require( '../spinner.js' ),
+        Search = require( '../search.js' ),
+        Label = require( '../label.js' ),
+        Uploaded = require( '../attachment-filters/uploaded.js' ),
+        All = require( '../attachment-filters/all.js' ),
+        DateFilter = require( '../attachment-filters/date.js' ),
+        UploaderInline = require( '../uploader/inline.js' ),
+        Attachments = require( '../attachments.js' ),
+        Sidebar = require( '../sidebar.js' ),
+        UploaderStatus = require( '../uploader/status.js' ),
+        Details = require( '../attachment/details.js' ),
+        AttachmentCompat = require( '../attachment-compat.js' ),
+        AttachmentDisplay = require( '../settings/attachment-display.js' ),
+        mediaTrash = wp.media.view.settings.mediaTrash,
+        l10n = wp.media.view.l10n,
+        $ = jQuery,
+        AttachmentsBrowser;
+
+AttachmentsBrowser = View.extend({
+        tagName:   'div',
+        className: 'attachments-browser',
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        filters: false,
+                        search:  true,
+                        display: false,
+                        sidebar: true,
+                        AttachmentView: Library
+                });
+
+                this.listenTo( this.controller, 'toggle:upload:attachment', _.bind( this.toggleUploader, this ) );
+                this.controller.on( 'edit:selection', this.editSelection );
+                this.createToolbar();
+                if ( this.options.sidebar ) {
+                        this.createSidebar();
+                }
+                this.createUploader();
+                this.createAttachments();
+                this.updateContent();
+
+                if ( ! this.options.sidebar || 'errors' === this.options.sidebar ) {
+                        this.$el.addClass( 'hide-sidebar' );
+
+                        if ( 'errors' === this.options.sidebar ) {
+                                this.$el.addClass( 'sidebar-for-errors' );
+                        }
+                }
+
+                this.collection.on( 'add remove reset', this.updateContent, this );
+        },
+
+        editSelection: function( modal ) {
+                modal.$( '.media-button-backToLibrary' ).focus();
+        },
+
+        /**
+         * @returns {wp.media.view.AttachmentsBrowser} Returns itself to allow chaining
+         */
+        dispose: function() {
+                this.options.selection.off( null, null, this );
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        createToolbar: function() {
+                var LibraryViewSwitcher, Filters, toolbarOptions;
+
+                toolbarOptions = {
+                        controller: this.controller
+                };
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        toolbarOptions.className = 'media-toolbar wp-filter';
+                }
+
+                /**
+                * @member {wp.media.view.Toolbar}
+                */
+                this.toolbar = new Toolbar( toolbarOptions );
+
+                this.views.add( this.toolbar );
+
+                this.toolbar.set( 'spinner', new Spinner({
+                        priority: -60
+                }) );
+
+                if ( -1 !== $.inArray( this.options.filters, [ 'uploaded', 'all' ] ) ) {
+                        // "Filters" will return a <select>, need to render
+                        // screen reader text before
+                        this.toolbar.set( 'filtersLabel', new Label({
+                                value: l10n.filterByType,
+                                attributes: {
+                                        'for':  'media-attachment-filters'
+                                },
+                                priority:   -80
+                        }).render() );
+
+                        if ( 'uploaded' === this.options.filters ) {
+                                this.toolbar.set( 'filters', new Uploaded({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                }).render() );
+                        } else {
+                                Filters = new All({
+                                        controller: this.controller,
+                                        model:      this.collection.props,
+                                        priority:   -80
+                                });
+
+                                this.toolbar.set( 'filters', Filters.render() );
+                        }
+                }
+
+                // Feels odd to bring the global media library switcher into the Attachment
+                // browser view. Is this a use case for doAction( 'add:toolbar-items:attachments-browser', this.toolbar );
+                // which the controller can tap into and add this view?
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        LibraryViewSwitcher = View.extend({
+                                className: 'view-switch media-grid-view-switch',
+                                template: wp.template( 'media-library-view-switcher')
+                        });
+
+                        this.toolbar.set( 'libraryViewSwitcher', new LibraryViewSwitcher({
+                                controller: this.controller,
+                                priority: -90
+                        }).render() );
+
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+
+                        // BulkSelection is a <div> with subviews, including screen reader text
+                        this.toolbar.set( 'selectModeToggleButton', new wp.media.view.SelectModeToggleButton({
+                                text: l10n.bulkSelect,
+                                controller: this.controller,
+                                priority: -70
+                        }).render() );
+
+                        this.toolbar.set( 'deleteSelectedButton', new wp.media.view.DeleteSelectedButton({
+                                filters: Filters,
+                                style: 'primary',
+                                disabled: true,
+                                text: mediaTrash ? l10n.trashSelected : l10n.deleteSelected,
+                                controller: this.controller,
+                                priority: -60,
+                                click: function() {
+                                        var changed = [], removed = [], self = this,
+                                                selection = this.controller.state().get( 'selection' ),
+                                                library = this.controller.state().get( 'library' );
+
+                                        if ( ! selection.length ) {
+                                                return;
+                                        }
+
+                                        if ( ! mediaTrash && ! confirm( l10n.warnBulkDelete ) ) {
+                                                return;
+                                        }
+
+                                        if ( mediaTrash &&
+                                                'trash' !== selection.at( 0 ).get( 'status' ) &&
+                                                ! confirm( l10n.warnBulkTrash ) ) {
+
+                                                return;
+                                        }
+
+                                        selection.each( function( model ) {
+                                                if ( ! model.get( 'nonces' )['delete'] ) {
+                                                        removed.push( model );
+                                                        return;
+                                                }
+
+                                                if ( mediaTrash && 'trash' === model.get( 'status' ) ) {
+                                                        model.set( 'status', 'inherit' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else if ( mediaTrash ) {
+                                                        model.set( 'status', 'trash' );
+                                                        changed.push( model.save() );
+                                                        removed.push( model );
+                                                } else {
+                                                        model.destroy({wait: true});
+                                                }
+                                        } );
+
+                                        if ( changed.length ) {
+                                                selection.remove( removed );
+
+                                                $.when.apply( null, changed ).then( function() {
+                                                        library._requery( true );
+                                                        self.controller.trigger( 'selection:action:done' );
+                                                } );
+                                        } else {
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }
+                        }).render() );
+
+                        if ( mediaTrash ) {
+                                this.toolbar.set( 'deleteSelectedPermanentlyButton', new wp.media.view.DeleteSelectedPermanentlyButton({
+                                        filters: Filters,
+                                        style: 'primary',
+                                        disabled: true,
+                                        text: l10n.deleteSelected,
+                                        controller: this.controller,
+                                        priority: -55,
+                                        click: function() {
+                                                var removed = [], selection = this.controller.state().get( 'selection' );
+
+                                                if ( ! selection.length || ! confirm( l10n.warnBulkDelete ) ) {
+                                                        return;
+                                                }
+
+                                                selection.each( function( model ) {
+                                                        if ( ! model.get( 'nonces' )['delete'] ) {
+                                                                removed.push( model );
+                                                                return;
+                                                        }
+
+                                                        model.destroy();
+                                                } );
+
+                                                selection.remove( removed );
+                                                this.controller.trigger( 'selection:action:done' );
+                                        }
+                                }).render() );
+                        }
+
+                } else {
+                        // DateFilter is a <select>, screen reader text needs to be rendered before
+                        this.toolbar.set( 'dateFilterLabel', new Label({
+                                value: l10n.filterByDate,
+                                attributes: {
+                                        'for': 'media-attachment-date-filters'
+                                },
+                                priority: -75
+                        }).render() );
+                        this.toolbar.set( 'dateFilter', new DateFilter({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority: -75
+                        }).render() );
+                }
+
+                if ( this.options.search ) {
+                        // Search is an input, screen reader text needs to be rendered before
+                        this.toolbar.set( 'searchLabel', new Label({
+                                value: l10n.searchMediaLabel,
+                                attributes: {
+                                        'for': 'media-search-input'
+                                },
+                                priority:   60
+                        }).render() );
+                        this.toolbar.set( 'search', new Search({
+                                controller: this.controller,
+                                model:      this.collection.props,
+                                priority:   60
+                        }).render() );
+                }
+
+                if ( this.options.dragInfo ) {
+                        this.toolbar.set( 'dragInfo', new View({
+                                el: $( '<div class="instructions">' + l10n.dragInfo + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+
+                if ( this.options.suggestedWidth && this.options.suggestedHeight ) {
+                        this.toolbar.set( 'suggestedDimensions', new View({
+                                el: $( '<div class="instructions">' + l10n.suggestedDimensions + ' ' + this.options.suggestedWidth + ' &times; ' + this.options.suggestedHeight + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+        },
+
+        updateContent: function() {
+                var view = this,
+                        noItemsView;
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        noItemsView = view.attachmentsNoResults;
+                } else {
+                        noItemsView = view.uploader;
+                }
+
+                if ( ! this.collection.length ) {
+                        this.toolbar.get( 'spinner' ).show();
+                        this.dfd = this.collection.more().done( function() {
+                                if ( ! view.collection.length ) {
+                                        noItemsView.$el.removeClass( 'hidden' );
+                                } else {
+                                        noItemsView.$el.addClass( 'hidden' );
+                                }
+                                view.toolbar.get( 'spinner' ).hide();
+                        } );
+                } else {
+                        noItemsView.$el.addClass( 'hidden' );
+                        view.toolbar.get( 'spinner' ).hide();
+                }
+        },
+
+        createUploader: function() {
+                this.uploader = new UploaderInline({
+                        controller: this.controller,
+                        status:     false,
+                        message:    this.controller.isModeActive( 'grid' ) ? '' : l10n.noItemsFound,
+                        canClose:   this.controller.isModeActive( 'grid' )
+                });
+
+                this.uploader.hide();
+                this.views.add( this.uploader );
+        },
+
+        toggleUploader: function() {
+                if ( this.uploader.$el.hasClass( 'hidden' ) ) {
+                        this.uploader.show();
+                } else {
+                        this.uploader.hide();
+                }
+        },
+
+        createAttachments: function() {
+                this.attachments = new Attachments({
+                        controller:           this.controller,
+                        collection:           this.collection,
+                        selection:            this.options.selection,
+                        model:                this.model,
+                        sortable:             this.options.sortable,
+                        scrollElement:        this.options.scrollElement,
+                        idealColumnWidth:     this.options.idealColumnWidth,
+
+                        // The single `Attachment` view to be used in the `Attachments` view.
+                        AttachmentView: this.options.AttachmentView
+                });
+
+                // Add keydown listener to the instance of the Attachments view
+                this.attachments.listenTo( this.controller, 'attachment:keydown:arrow',     this.attachments.arrowEvent );
+                this.attachments.listenTo( this.controller, 'attachment:details:shift-tab', this.attachments.restoreFocus );
+
+                this.views.add( this.attachments );
+
+
+                if ( this.controller.isModeActive( 'grid' ) ) {
+                        this.attachmentsNoResults = new View({
+                                controller: this.controller,
+                                tagName: 'p'
+                        });
+
+                        this.attachmentsNoResults.$el.addClass( 'hidden no-media' );
+                        this.attachmentsNoResults.$el.html( l10n.noMedia );
+
+                        this.views.add( this.attachmentsNoResults );
+                }
+        },
+
+        createSidebar: function() {
+                var options = this.options,
+                        selection = options.selection,
+                        sidebar = this.sidebar = new Sidebar({
+                                controller: this.controller
+                        });
+
+                this.views.add( sidebar );
+
+                if ( this.controller.uploader ) {
+                        sidebar.set( 'uploads', new UploaderStatus({
+                                controller: this.controller,
+                                priority:   40
+                        }) );
+                }
+
+                selection.on( 'selection:single', this.createSingle, this );
+                selection.on( 'selection:unsingle', this.disposeSingle, this );
+
+                if ( selection.single() ) {
+                        this.createSingle();
+                }
+        },
+
+        createSingle: function() {
+                var sidebar = this.sidebar,
+                        single = this.options.selection.single();
+
+                sidebar.set( 'details', new Details({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   80
+                }) );
+
+                sidebar.set( 'compat', new AttachmentCompat({
+                        controller: this.controller,
+                        model:      single,
+                        priority:   120
+                }) );
+
+                if ( this.options.display ) {
+                        sidebar.set( 'display', new AttachmentDisplay({
+                                controller:   this.controller,
+                                model:        this.model.display( single ),
+                                attachment:   single,
+                                priority:     160,
+                                userSettings: this.model.get('displayUserSettings')
+                        }) );
+                }
+
+                // Show the sidebar on mobile
+                if ( this.model.id === 'insert' ) {
+                        sidebar.$el.addClass( 'visible' );
+                }
+        },
+
+        disposeSingle: function() {
+                var sidebar = this.sidebar;
+                sidebar.unset('details');
+                sidebar.unset('compat');
+                sidebar.unset('display');
+                // Hide the sidebar on mobile
+                sidebar.$el.removeClass( 'visible' );
+        }
+});
+
+module.exports = AttachmentsBrowser;
+ No newline at end of file

src/wp-includes/js/media/views/attachments/selection.js

@@ +1 @@
+/**
+ * wp.media.view.Attachments.Selection
+ *
+ * @class
+ * @augments wp.media.view.Attachments
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Attachments = require( '../attachments.js' ),
+        AttachmentSelection = require( '../attachment/selection.js' ),
+        Selection;
+
+Selection = Attachments.extend({
+        events: {},
+        initialize: function() {
+                _.defaults( this.options, {
+                        sortable:   false,
+                        resize:     false,
+
+                        // The single `Attachment` view to be used in the `Attachments` view.
+                        AttachmentView: AttachmentSelection
+                });
+                // Call 'initialize' directly on the parent class.
+                return Attachments.prototype.initialize.apply( this, arguments );
+        }
+});
+
+module.exports = Selection;
+ No newline at end of file

src/wp-includes/js/media/views/attachments.js

@@ +1 @@
+/**
+ * wp.media.view.Attachments
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Attachment = require( './attachment.js' ),
+        $ = jQuery,
+        Attachments;
+
+Attachments = View.extend({
+        tagName:   'ul',
+        className: 'attachments',
+
+        attributes: {
+                tabIndex: -1
+        },
+
+        initialize: function() {
+                this.el.id = _.uniqueId('__attachments-view-');
+
+                _.defaults( this.options, {
+                        refreshSensitivity: wp.media.isTouchDevice ? 300 : 200,
+                        refreshThreshold:   3,
+                        AttachmentView:     Attachment,
+                        sortable:           false,
+                        resize:             true,
+                        idealColumnWidth:   $( window ).width() < 640 ? 135 : 150
+                });
+
+                this._viewsByCid = {};
+                this.$window = $( window );
+                this.resizeEvent = 'resize.media-modal-columns';
+
+                this.collection.on( 'add', function( attachment ) {
+                        this.views.add( this.createAttachmentView( attachment ), {
+                                at: this.collection.indexOf( attachment )
+                        });
+                }, this );
+
+                this.collection.on( 'remove', function( attachment ) {
+                        var view = this._viewsByCid[ attachment.cid ];
+                        delete this._viewsByCid[ attachment.cid ];
+
+                        if ( view ) {
+                                view.remove();
+                        }
+                }, this );
+
+                this.collection.on( 'reset', this.render, this );
+
+                this.listenTo( this.controller, 'library:selection:add',    this.attachmentFocus );
+
+                // Throttle the scroll handler and bind this.
+                this.scroll = _.chain( this.scroll ).bind( this ).throttle( this.options.refreshSensitivity ).value();
+
+                this.options.scrollElement = this.options.scrollElement || this.el;
+                $( this.options.scrollElement ).on( 'scroll', this.scroll );
+
+                this.initSortable();
+
+                _.bindAll( this, 'setColumns' );
+
+                if ( this.options.resize ) {
+                        this.on( 'ready', this.bindEvents );
+                        this.controller.on( 'open', this.setColumns );
+
+                        // Call this.setColumns() after this view has been rendered in the DOM so
+                        // attachments get proper width applied.
+                        _.defer( this.setColumns, this );
+                }
+        },
+
+        bindEvents: function() {
+                this.$window.off( this.resizeEvent ).on( this.resizeEvent, _.debounce( this.setColumns, 50 ) );
+        },
+
+        attachmentFocus: function() {
+                this.$( 'li:first' ).focus();
+        },
+
+        restoreFocus: function() {
+                this.$( 'li.selected:first' ).focus();
+        },
+
+        arrowEvent: function( event ) {
+                var attachments = this.$el.children( 'li' ),
+                        perRow = this.columns,
+                        index = attachments.filter( ':focus' ).index(),
+                        row = ( index + 1 ) <= perRow ? 1 : Math.ceil( ( index + 1 ) / perRow );
+
+                if ( index === -1 ) {
+                        return;
+                }
+
+                // Left arrow
+                if ( 37 === event.keyCode ) {
+                        if ( 0 === index ) {
+                                return;
+                        }
+                        attachments.eq( index - 1 ).focus();
+                }
+
+                // Up arrow
+                if ( 38 === event.keyCode ) {
+                        if ( 1 === row ) {
+                                return;
+                        }
+                        attachments.eq( index - perRow ).focus();
+                }
+
+                // Right arrow
+                if ( 39 === event.keyCode ) {
+                        if ( attachments.length === index ) {
+                                return;
+                        }
+                        attachments.eq( index + 1 ).focus();
+                }
+
+                // Down arrow
+                if ( 40 === event.keyCode ) {
+                        if ( Math.ceil( attachments.length / perRow ) === row ) {
+                                return;
+                        }
+                        attachments.eq( index + perRow ).focus();
+                }
+        },
+
+        dispose: function() {
+                this.collection.props.off( null, null, this );
+                if ( this.options.resize ) {
+                        this.$window.off( this.resizeEvent );
+                }
+
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+        },
+
+        setColumns: function() {
+                var prev = this.columns,
+                        width = this.$el.width();
+
+                if ( width ) {
+                        this.columns = Math.min( Math.round( width / this.options.idealColumnWidth ), 12 ) || 1;
+
+                        if ( ! prev || prev !== this.columns ) {
+                                this.$el.closest( '.media-frame-content' ).attr( 'data-columns', this.columns );
+                        }
+                }
+        },
+
+        initSortable: function() {
+                var collection = this.collection;
+
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                this.$el.sortable( _.extend({
+                        // If the `collection` has a `comparator`, disable sorting.
+                        disabled: !! collection.comparator,
+
+                        // Change the position of the attachment as soon as the
+                        // mouse pointer overlaps a thumbnail.
+                        tolerance: 'pointer',
+
+                        // Record the initial `index` of the dragged model.
+                        start: function( event, ui ) {
+                                ui.item.data('sortableIndexStart', ui.item.index());
+                        },
+
+                        // Update the model's index in the collection.
+                        // Do so silently, as the view is already accurate.
+                        update: function( event, ui ) {
+                                var model = collection.at( ui.item.data('sortableIndexStart') ),
+                                        comparator = collection.comparator;
+
+                                // Temporarily disable the comparator to prevent `add`
+                                // from re-sorting.
+                                delete collection.comparator;
+
+                                // Silently shift the model to its new index.
+                                collection.remove( model, {
+                                        silent: true
+                                });
+                                collection.add( model, {
+                                        silent: true,
+                                        at:     ui.item.index()
+                                });
+
+                                // Restore the comparator.
+                                collection.comparator = comparator;
+
+                                // Fire the `reset` event to ensure other collections sync.
+                                collection.trigger( 'reset', collection );
+
+                                // If the collection is sorted by menu order,
+                                // update the menu order.
+                                collection.saveMenuOrder();
+                        }
+                }, this.options.sortable ) );
+
+                // If the `orderby` property is changed on the `collection`,
+                // check to see if we have a `comparator`. If so, disable sorting.
+                collection.props.on( 'change:orderby', function() {
+                        this.$el.sortable( 'option', 'disabled', !! collection.comparator );
+                }, this );
+
+                this.collection.props.on( 'change:orderby', this.refreshSortable, this );
+                this.refreshSortable();
+        },
+
+        refreshSortable: function() {
+                if ( wp.media.isTouchDevice || ! this.options.sortable || ! $.fn.sortable ) {
+                        return;
+                }
+
+                // If the `collection` has a `comparator`, disable sorting.
+                var collection = this.collection,
+                        orderby = collection.props.get('orderby'),
+                        enabled = 'menuOrder' === orderby || ! collection.comparator;
+
+                this.$el.sortable( 'option', 'disabled', ! enabled );
+        },
+
+        /**
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {wp.media.View}
+         */
+        createAttachmentView: function( attachment ) {
+                var view = new this.options.AttachmentView({
+                        controller:           this.controller,
+                        model:                attachment,
+                        collection:           this.collection,
+                        selection:            this.options.selection
+                });
+
+                return this._viewsByCid[ attachment.cid ] = view;
+        },
+
+        prepare: function() {
+                // Create all of the Attachment views, and replace
+                // the list in a single DOM operation.
+                if ( this.collection.length ) {
+                        this.views.set( this.collection.map( this.createAttachmentView, this ) );
+
+                // If there are no elements, clear the views and load some.
+                } else {
+                        this.views.unset();
+                        this.collection.more().done( this.scroll );
+                }
+        },
+
+        ready: function() {
+                // Trigger the scroll event to check if we're within the
+                // threshold to query for additional attachments.
+                this.scroll();
+        },
+
+        scroll: function() {
+                var view = this,
+                        el = this.options.scrollElement,
+                        scrollTop = el.scrollTop,
+                        toolbar;
+
+                // The scroll event occurs on the document, but the element
+                // that should be checked is the document body.
+                if ( el == document ) {
+                        el = document.body;
+                        scrollTop = $(document).scrollTop();
+                }
+
+                if ( ! $(el).is(':visible') || ! this.collection.hasMore() ) {
+                        return;
+                }
+
+                toolbar = this.views.parent.toolbar;
+
+                // Show the spinner only if we are close to the bottom.
+                if ( el.scrollHeight - ( scrollTop + el.clientHeight ) < el.clientHeight / 3 ) {
+                        toolbar.get('spinner').show();
+                }
+
+                if ( el.scrollHeight < scrollTop + ( el.clientHeight * this.options.refreshThreshold ) ) {
+                        this.collection.more().done(function() {
+                                view.scroll();
+                                toolbar.get('spinner').hide();
+                        });
+                }
+        }
+});
+
+module.exports = Attachments;
+ No newline at end of file

src/wp-includes/js/media/views/audio-details.js

@@ +1 @@
+/**
+ * wp.media.view.AudioDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaDetails
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MediaDetails = require( './media-details' ),
+        AudioDetails;
+
+AudioDetails = MediaDetails.extend({
+        className: 'audio-details',
+        template:  wp.template('audio-details'),
+
+        setMedia: function() {
+                var audio = this.$('.wp-audio-shortcode');
+
+                if ( audio.find( 'source' ).length ) {
+                        if ( audio.is(':hidden') ) {
+                                audio.show();
+                        }
+                        this.media = MediaDetails.prepareSrc( audio.get(0) );
+                } else {
+                        audio.hide();
+                        this.media = false;
+                }
+
+                return this;
+        }
+});
+
+module.exports = AudioDetails;
+ No newline at end of file

src/wp-includes/js/media/views/button/delete-selected-permanently.js

@@ +1 @@
+/**
+ * When MEDIA_TRASH is true, a button that handles bulk Delete Permanently logic
+ *
+ * @constructor
+ * @augments wp.media.view.DeleteSelectedButton
+ * @augments wp.media.view.Button
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Button = require( '../button.js' ),
+        DeleteSelected = require( './delete-selected.js' ),
+        DeleteSelectedPermanently;
+
+DeleteSelectedPermanently = DeleteSelected.extend({
+        initialize: function() {
+                DeleteSelected.prototype.initialize.apply( this, arguments );
+                this.listenTo( this.controller, 'select:activate', this.selectActivate );
+                this.listenTo( this.controller, 'select:deactivate', this.selectDeactivate );
+        },
+
+        filterChange: function( model ) {
+                this.canShow = ( 'trash' === model.get( 'status' ) );
+        },
+
+        selectActivate: function() {
+                this.toggleDisabled();
+                this.$el.toggleClass( 'hidden', ! this.canShow );
+        },
+
+        selectDeactivate: function() {
+                this.toggleDisabled();
+                this.$el.addClass( 'hidden' );
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                this.selectActivate();
+                return this;
+        }
+});
+
+module.exports = DeleteSelectedPermanently;
+ No newline at end of file

src/wp-includes/js/media/views/button/delete-selected.js

@@ +1 @@
+/**
+ * A button that handles bulk Delete/Trash logic
+ *
+ * @constructor
+ * @augments wp.media.view.Button
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Button = require( '../button.js' ),
+        l10n = wp.media.view.l10n,
+        DeleteSelected;
+
+DeleteSelected = Button.extend({
+        initialize: function() {
+                Button.prototype.initialize.apply( this, arguments );
+                if ( this.options.filters ) {
+                        this.listenTo( this.options.filters.model, 'change', this.filterChange );
+                }
+                this.listenTo( this.controller, 'selection:toggle', this.toggleDisabled );
+        },
+
+        filterChange: function( model ) {
+                if ( 'trash' === model.get( 'status' ) ) {
+                        this.model.set( 'text', l10n.untrashSelected );
+                } else if ( wp.media.view.settings.mediaTrash ) {
+                        this.model.set( 'text', l10n.trashSelected );
+                } else {
+                        this.model.set( 'text', l10n.deleteSelected );
+                }
+        },
+
+        toggleDisabled: function() {
+                this.model.set( 'disabled', ! this.controller.state().get( 'selection' ).length );
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.$el.addClass( 'delete-selected-button' );
+                } else {
+                        this.$el.addClass( 'delete-selected-button hidden' );
+                }
+                this.toggleDisabled();
+                return this;
+        }
+});
+
+module.exports = DeleteSelected;
+ No newline at end of file

src/wp-includes/js/media/views/button/select-mode-toggle.js

@@ +1 @@
+var Button = require( '../button.js' ),
+        l10n = wp.media.view.l10n,
+        SelectModeToggle;
+
+SelectModeToggle = Button.extend({
+        initialize: function() {
+                Button.prototype.initialize.apply( this, arguments );
+                this.listenTo( this.controller, 'select:activate select:deactivate', this.toggleBulkEditHandler );
+                this.listenTo( this.controller, 'selection:action:done', this.back );
+        },
+
+        back: function () {
+                this.controller.deactivateMode( 'select' ).activateMode( 'edit' );
+        },
+
+        click: function() {
+                Button.prototype.click.apply( this, arguments );
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.back();
+                } else {
+                        this.controller.deactivateMode( 'edit' ).activateMode( 'select' );
+                }
+        },
+
+        render: function() {
+                Button.prototype.render.apply( this, arguments );
+                this.$el.addClass( 'select-mode-toggle-button' );
+                return this;
+        },
+
+        toggleBulkEditHandler: function() {
+                var toolbar = this.controller.content.get().toolbar, children;
+
+                children = toolbar.$( '.media-toolbar-secondary > *, .media-toolbar-primary > *' );
+
+                // TODO: the Frame should be doing all of this.
+                if ( this.controller.isModeActive( 'select' ) ) {
+                        this.model.set( 'text', l10n.cancelSelection );
+                        children.not( '.media-button' ).hide();
+                        this.$el.show();
+                        toolbar.$( '.delete-selected-button' ).removeClass( 'hidden' );
+                } else {
+                        this.model.set( 'text', l10n.bulkSelect );
+                        this.controller.content.get().$el.removeClass( 'fixed' );
+                        toolbar.$el.css( 'width', '' );
+                        toolbar.$( '.delete-selected-button' ).addClass( 'hidden' );
+                        children.not( '.spinner, .media-button' ).show();
+                        this.controller.state().get( 'selection' ).reset();
+                }
+        }
+});
+
+module.exports = SelectModeToggle;
+ No newline at end of file

src/wp-includes/js/media/views/button-group.js

@@ +1 @@
+/**
+ * wp.media.view.ButtonGroup
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button = require( './button.js' ),
+        $ = jQuery,
+        ButtonGroup;
+
+ButtonGroup = View.extend({
+        tagName:   'div',
+        className: 'button-group button-large media-button-group',
+
+        initialize: function() {
+                /**
+                 * @member {wp.media.view.Button[]}
+                 */
+                this.buttons = _.map( this.options.buttons || [], function( button ) {
+                        if ( button instanceof Backbone.View ) {
+                                return button;
+                        } else {
+                                return new Button( button ).render();
+                        }
+                });
+
+                delete this.options.buttons;
+
+                if ( this.options.classes ) {
+                        this.$el.addClass( this.options.classes );
+                }
+        },
+
+        /**
+         * @returns {wp.media.view.ButtonGroup}
+         */
+        render: function() {
+                this.$el.html( $( _.pluck( this.buttons, 'el' ) ).detach() );
+                return this;
+        }
+});
+
+module.exports = ButtonGroup;
+ No newline at end of file

src/wp-includes/js/media/views/button.js

@@ +1 @@
+/**
+ * wp.media.view.Button
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button;
+
+Button = View.extend({
+        tagName:    'a',
+        className:  'media-button',
+        attributes: { href: '#' },
+
+        events: {
+                'click': 'click'
+        },
+
+        defaults: {
+                text:     '',
+                style:    '',
+                size:     'large',
+                disabled: false
+        },
+
+        initialize: function() {
+                /**
+                 * Create a model with the provided `defaults`.
+                 *
+                 * @member {Backbone.Model}
+                 */
+                this.model = new Backbone.Model( this.defaults );
+
+                // If any of the `options` have a key from `defaults`, apply its
+                // value to the `model` and remove it from the `options object.
+                _.each( this.defaults, function( def, key ) {
+                        var value = this.options[ key ];
+                        if ( _.isUndefined( value ) ) {
+                                return;
+                        }
+
+                        this.model.set( key, value );
+                        delete this.options[ key ];
+                }, this );
+
+                this.model.on( 'change', this.render, this );
+        },
+        /**
+         * @returns {wp.media.view.Button} Returns itself to allow chaining
+         */
+        render: function() {
+                var classes = [ 'button', this.className ],
+                        model = this.model.toJSON();
+
+                if ( model.style ) {
+                        classes.push( 'button-' + model.style );
+                }
+
+                if ( model.size ) {
+                        classes.push( 'button-' + model.size );
+                }
+
+                classes = _.uniq( classes.concat( this.options.classes ) );
+                this.el.className = classes.join(' ');
+
+                this.$el.attr( 'disabled', model.disabled );
+                this.$el.text( this.model.get('text') );
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        click: function( event ) {
+                if ( '#' === this.attributes.href ) {
+                        event.preventDefault();
+                }
+
+                if ( this.options.click && ! this.model.get('disabled') ) {
+                        this.options.click.apply( this, arguments );
+                }
+        }
+});
+
+module.exports = Button;
+ No newline at end of file

src/wp-includes/js/media/views/cropper.js

@@ +1 @@
+/**
+ * wp.media.view.Cropper
+ *
+ * Uses the imgAreaSelect plugin to allow a user to crop an image.
+ *
+ * Takes imgAreaSelect options from
+ * wp.customize.HeaderControl.calculateImageSelectOptions via
+ * wp.customize.HeaderControl.openMM.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        UploaderStatusError = require( './uploader/status-error.js' ),
+        UploaderStatus = require( './uploader/status.js' ),
+        l10n = wp.media.view.l10n,
+        $ = jQuery,
+        Cropper;
+
+Cropper = View.extend({
+        className: 'crop-content',
+        template: wp.template('crop-content'),
+        initialize: function() {
+                _.bindAll(this, 'onImageLoad');
+        },
+        ready: function() {
+                this.controller.frame.on('content:error:crop', this.onError, this);
+                this.$image = this.$el.find('.crop-image');
+                this.$image.on('load', this.onImageLoad);
+                $(window).on('resize.cropper', _.debounce(this.onImageLoad, 250));
+        },
+        remove: function() {
+                $(window).off('resize.cropper');
+                this.$el.remove();
+                this.$el.off();
+                View.prototype.remove.apply(this, arguments);
+        },
+        prepare: function() {
+                return {
+                        title: l10n.cropYourImage,
+                        url: this.options.attachment.get('url')
+                };
+        },
+        onImageLoad: function() {
+                var imgOptions = this.controller.get('imgSelectOptions');
+                if (typeof imgOptions === 'function') {
+                        imgOptions = imgOptions(this.options.attachment, this.controller);
+                }
+
+                imgOptions = _.extend(imgOptions, {parent: this.$el});
+                this.trigger('image-loaded');
+                this.controller.imgSelect = this.$image.imgAreaSelect(imgOptions);
+        },
+        onError: function() {
+                var filename = this.options.attachment.get('filename');
+
+                this.views.add( '.upload-errors', new UploaderStatusError({
+                        filename: UploaderStatus.prototype.filename(filename),
+                        message: _wpMediaViewsL10n.cropError
+                }), { at: 0 });
+        }
+});
+
+module.exports = Cropper;
+ No newline at end of file

src/wp-includes/js/media/views/edit-image-details.js

@@ +1 @@
+var View = require( './view.js' ),
+        EditImage = require( './edit-image.js' ),
+        Details;
+
+Details = EditImage.extend({
+        initialize: function( options ) {
+                this.editor = window.imageEdit;
+                this.frame = options.frame;
+                this.controller = options.controller;
+                View.prototype.initialize.apply( this, arguments );
+        },
+
+        back: function() {
+                this.frame.content.mode( 'edit-metadata' );
+        },
+
+        save: function() {
+                var self = this;
+
+                this.model.fetch().done( function() {
+                        self.frame.content.mode( 'edit-metadata' );
+                });
+        }
+});
+
+module.exports = Details;
+ No newline at end of file

src/wp-includes/js/media/views/edit-image.js

@@ +1 @@
+var View = require( './view.js' ),
+        EditImage;
+
+EditImage = View.extend({
+        className: 'image-editor',
+        template: wp.template('image-editor'),
+
+        initialize: function( options ) {
+                this.editor = window.imageEdit;
+                this.controller = options.controller;
+                View.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                return this.model.toJSON();
+        },
+
+        render: function() {
+                View.prototype.render.apply( this, arguments );
+                return this;
+        },
+
+        loadEditor: function() {
+                var dfd = this.editor.open( this.model.get('id'), this.model.get('nonces').edit, this );
+                dfd.done( _.bind( this.focus, this ) );
+        },
+
+        focus: function() {
+                this.$( '.imgedit-submit .button' ).eq( 0 ).focus();
+        },
+
+        back: function() {
+                var lastState = this.controller.lastState();
+                this.controller.setState( lastState );
+        },
+
+        refresh: function() {
+                this.model.fetch();
+        },
+
+        save: function() {
+                var self = this,
+                        lastState = this.controller.lastState();
+
+                this.model.fetch().done( function() {
+                        self.controller.setState( lastState );
+                });
+        }
+
+});
+
+module.exports = EditImage;
+ No newline at end of file

src/wp-includes/js/media/views/embed/image.js

@@ +1 @@
+/**
+ * wp.media.view.EmbedImage
+ *
+ * @class
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentDisplay = require( '../settings/attachment-display.js' ),
+        EmbedImage;
+
+EmbedImage = AttachmentDisplay.extend({
+        className: 'embed-media-settings',
+        template:  wp.template('embed-image-settings'),
+
+        initialize: function() {
+                /**
+                 * Call `initialize` directly on parent class with passed arguments
+                 */
+                AttachmentDisplay.prototype.initialize.apply( this, arguments );
+                this.model.on( 'change:url', this.updateImage, this );
+        },
+
+        updateImage: function() {
+                this.$('img').attr( 'src', this.model.get('url') );
+        }
+});
+
+module.exports = EmbedImage;
+ No newline at end of file

src/wp-includes/js/media/views/embed/link.js

@@ +1 @@
+/**
+ * wp.media.view.EmbedLink
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        $ = jQuery,
+        EmbedLink;
+
+EmbedLink = Settings.extend({
+        className: 'embed-link-settings',
+        template:  wp.template('embed-link-settings'),
+
+        initialize: function() {
+                this.spinner = $('<span class="spinner" />');
+                this.$el.append( this.spinner[0] );
+                this.listenTo( this.model, 'change:url', this.updateoEmbed );
+        },
+
+        updateoEmbed: function() {
+                var url = this.model.get( 'url' );
+
+                this.$('.setting.title').show();
+                // clear out previous results
+                this.$('.embed-container').hide().find('.embed-preview').html('');
+
+                // only proceed with embed if the field contains more than 6 characters
+                if ( url && url.length < 6 ) {
+                        return;
+                }
+
+                this.spinner.show();
+
+                setTimeout( _.bind( this.fetch, this ), 500 );
+        },
+
+        fetch: function() {
+                // check if they haven't typed in 500 ms
+                if ( $('#embed-url-field').val() !== this.model.get('url') ) {
+                        return;
+                }
+
+                wp.ajax.send( 'parse-embed', {
+                        data : {
+                                post_ID: wp.media.view.settings.post.id,
+                                shortcode: '[embed]' + this.model.get('url') + '[/embed]'
+                        }
+                } ).done( _.bind( this.renderoEmbed, this ) );
+        },
+
+        renderoEmbed: function( response ) {
+                var html = ( response && response.body ) || '';
+
+                this.spinner.hide();
+
+                this.$('.setting.title').hide();
+                this.$('.embed-container').show().find('.embed-preview').html( html );
+        }
+});
+
+module.exports = EmbedLink;
+ No newline at end of file

src/wp-includes/js/media/views/embed/url.js

@@ +1 @@
+/**
+ * wp.media.view.EmbedUrl
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        $ = jQuery,
+        EmbedUrl;
+
+EmbedUrl = View.extend({
+        tagName:   'label',
+        className: 'embed-url',
+
+        events: {
+                'input':  'url',
+                'keyup':  'url',
+                'change': 'url'
+        },
+
+        initialize: function() {
+                var self = this;
+
+                this.$input = $('<input id="embed-url-field" type="url" />').val( this.model.get('url') );
+                this.input = this.$input[0];
+
+                this.spinner = $('<span class="spinner" />')[0];
+                this.$el.append([ this.input, this.spinner ]);
+
+                this.model.on( 'change:url', this.render, this );
+
+                if ( this.model.get( 'url' ) ) {
+                        _.delay( function () {
+                                self.model.trigger( 'change:url' );
+                        }, 500 );
+                }
+        },
+        /**
+         * @returns {wp.media.view.EmbedUrl} Returns itself to allow chaining
+         */
+        render: function() {
+                var $input = this.$input;
+
+                if ( $input.is(':focus') ) {
+                        return;
+                }
+
+                this.input.value = this.model.get('url') || 'http://';
+                /**
+                 * Call `render` directly on parent class with passed arguments
+                 */
+                View.prototype.render.apply( this, arguments );
+                return this;
+        },
+
+        ready: function() {
+                if ( ! wp.media.isTouchDevice ) {
+                        this.focus();
+                }
+        },
+
+        url: function( event ) {
+                this.model.set( 'url', event.target.value );
+        },
+
+        /**
+         * If the input is visible, focus and select its contents.
+         */
+        focus: function() {
+                var $input = this.$input;
+                if ( $input.is(':visible') ) {
+                        $input.focus()[0].select();
+                }
+        }
+});
+
+module.exports = EmbedUrl;
+ No newline at end of file

src/wp-includes/js/media/views/embed.js

@@ +1 @@
+/**
+ * wp.media.view.Embed
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        EmbedImage = require( './embed/image.js' ),
+        EmbedLink = require( './embed/link.js' ),
+        EmbedUrl = require( './embed/url.js' ),
+        Embed;
+
+Embed = View.extend({
+        className: 'media-embed',
+
+        initialize: function() {
+                /**
+                 * @member {wp.media.view.EmbedUrl}
+                 */
+                this.url = new EmbedUrl({
+                        controller: this.controller,
+                        model:      this.model.props
+                }).render();
+
+                this.views.set([ this.url ]);
+                this.refresh();
+                this.model.on( 'change:type', this.refresh, this );
+                this.model.on( 'change:loading', this.loading, this );
+        },
+
+        /**
+         * @param {Object} view
+         */
+        settings: function( view ) {
+                if ( this._settings ) {
+                        this._settings.remove();
+                }
+                this._settings = view;
+                this.views.add( view );
+        },
+
+        refresh: function() {
+                var type = this.model.get('type'),
+                        constructor;
+
+                if ( 'image' === type ) {
+                        constructor = EmbedImage;
+                } else if ( 'link' === type ) {
+                        constructor = EmbedLink;
+                } else {
+                        return;
+                }
+
+                this.settings( new constructor({
+                        controller: this.controller,
+                        model:      this.model.props,
+                        priority:   40
+                }) );
+        },
+
+        loading: function() {
+                this.$el.toggleClass( 'embed-loading', this.model.get('loading') );
+        }
+});
+
+module.exports = Embed;
+ No newline at end of file

src/wp-includes/js/media/views/focus-manager.js

@@ +1 @@
+/**
+ * wp.media.view.FocusManager
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager;
+
+FocusManager = View.extend({
+
+        events: {
+                'keydown': 'constrainTabbing'
+        },
+
+        focus: function() { // Reset focus on first left menu item
+                this.$('.media-menu-item').first().focus();
+        },
+        /**
+         * @param {Object} event
+         */
+        constrainTabbing: function( event ) {
+                var tabbables;
+
+                // Look for the tab key.
+                if ( 9 !== event.keyCode ) {
+                        return;
+                }
+
+                tabbables = this.$( ':tabbable' );
+
+                // Keep tab focus within media modal while it's open
+                if ( tabbables.last()[0] === event.target && ! event.shiftKey ) {
+                        tabbables.first().focus();
+                        return false;
+                } else if ( tabbables.first()[0] === event.target && event.shiftKey ) {
+                        tabbables.last().focus();
+                        return false;
+                }
+        }
+
+});
+
+module.exports = FocusManager;
+ No newline at end of file

src/wp-includes/js/media/views/frame/audio-details.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.AudioDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.MediaDetails
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaDetails = require( './media-details' ),
+        MediaLibrary = require( '../../controllers/media-library.js' ),
+        AudioDetailsView = require( '../audio-details.js' ),
+        AudioDetailsController = require( '../../controllers/audio-details.js' ),
+        l10n = wp.media.view.l10n,
+        AudioDetails;
+
+AudioDetails = MediaDetails.extend({
+        defaults: {
+                id:      'audio',
+                url:     '',
+                menu:    'audio-details',
+                content: 'audio-details',
+                toolbar: 'audio-details',
+                type:    'link',
+                title:    l10n.audioDetailsTitle,
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                options.DetailsView = AudioDetailsView;
+                options.cancelText = l10n.audioDetailsCancel;
+                options.addText = l10n.audioAddSourceTitle;
+
+                MediaDetails.prototype.initialize.call( this, options );
+        },
+
+        bindHandlers: function() {
+                MediaDetails.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'toolbar:render:replace-audio', this.renderReplaceToolbar, this );
+                this.on( 'toolbar:render:add-audio-source', this.renderAddSourceToolbar, this );
+        },
+
+        createStates: function() {
+                this.states.add([
+                        new AudioDetailsController( {
+                                media: this.media
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'audio',
+                                id: 'replace-audio',
+                                title: l10n.audioReplaceTitle,
+                                toolbar: 'replace-audio',
+                                media: this.media,
+                                menu: 'audio-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'audio',
+                                id: 'add-audio-source',
+                                title: l10n.audioAddSourceTitle,
+                                toolbar: 'add-audio-source',
+                                media: this.media,
+                                menu: false
+                        } )
+                ]);
+        }
+});
+
+module.exports = AudioDetails;
+ No newline at end of file

src/wp-includes/js/media/views/frame/edit-attachments.js

@@ +1 @@
+/**
+ * A frame for editing the details of a specific media item.
+ *
+ * Opens in a modal by default.
+ *
+ * Requires an attachment model to be passed in the options hash under `model`.
+ *
+ * @constructor
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var Frame = require( '../frame.js' ),
+        MediaFrame = require( '../media-frame.js' ),
+        Modal = require( '../modal.js' ),
+        EditAttachmentMetadata = require( '../../controllers/edit-attachment-metadata.js' ),
+        TwoColumn = require( '../attachment/details-two-column.js' ),
+        AttachmentCompat = require( '../attachment-compat.js' ),
+        EditImageController = require( '../../controllers/edit-image.js' ),
+        DetailsView = require( '../edit-image-details.js' ),
+        $ = jQuery,
+        EditAttachments;
+
+EditAttachments = MediaFrame.extend({
+
+        className: 'edit-attachment-frame',
+        template:  wp.template( 'edit-attachment-frame' ),
+        regions:   [ 'title', 'content' ],
+
+        events: {
+                'click .left':  'previousMediaItem',
+                'click .right': 'nextMediaItem'
+        },
+
+        initialize: function() {
+                Frame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        modal: true,
+                        state: 'edit-attachment'
+                });
+
+                this.controller = this.options.controller;
+                this.gridRouter = this.controller.gridRouter;
+                this.library = this.options.library;
+
+                if ( this.options.model ) {
+                        this.model = this.options.model;
+                }
+
+                this.bindHandlers();
+                this.createStates();
+                this.createModal();
+
+                this.title.mode( 'default' );
+                this.toggleNav();
+        },
+
+        bindHandlers: function() {
+                // Bind default title creation.
+                this.on( 'title:create:default', this.createTitle, this );
+
+                // Close the modal if the attachment is deleted.
+                this.listenTo( this.model, 'change:status destroy', this.close, this );
+
+                this.on( 'content:create:edit-metadata', this.editMetadataMode, this );
+                this.on( 'content:create:edit-image', this.editImageMode, this );
+                this.on( 'content:render:edit-image', this.editImageModeRender, this );
+                this.on( 'close', this.detach );
+        },
+
+        createModal: function() {
+                var self = this;
+
+                // Initialize modal container view.
+                if ( this.options.modal ) {
+                        this.modal = new Modal({
+                                controller: this,
+                                title:      this.options.title
+                        });
+
+                        this.modal.on( 'open', function () {
+                                $( 'body' ).on( 'keydown.media-modal', _.bind( self.keyEvent, self ) );
+                        } );
+
+                        // Completely destroy the modal DOM element when closing it.
+                        this.modal.on( 'close', function() {
+                                self.modal.remove();
+                                $( 'body' ).off( 'keydown.media-modal' ); /* remove the keydown event */
+                                // Restore the original focus item if possible
+                                $( 'li.attachment[data-id="' + self.model.get( 'id' ) +'"]' ).focus();
+                                self.resetRoute();
+                        } );
+
+                        // Set this frame as the modal's content.
+                        this.modal.content( this );
+                        this.modal.open();
+                }
+        },
+
+        /**
+         * Add the default states to the frame.
+         */
+        createStates: function() {
+                this.states.add([
+                        new EditAttachmentMetadata( { model: this.model } )
+                ]);
+        },
+
+        /**
+         * Content region rendering callback for the `edit-metadata` mode.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         */
+        editMetadataMode: function( contentRegion ) {
+                contentRegion.view = new TwoColumn({
+                        controller: this,
+                        model:      this.model
+                });
+
+                /**
+                 * Attach a subview to display fields added via the
+                 * `attachment_fields_to_edit` filter.
+                 */
+                contentRegion.view.views.set( '.attachment-compat', new AttachmentCompat({
+                        controller: this,
+                        model:      this.model
+                }) );
+
+                // Update browser url when navigating media details
+                if ( this.model ) {
+                        this.gridRouter.navigate( this.gridRouter.baseUrl( '?item=' + this.model.id ) );
+                }
+        },
+
+        /**
+         * Render the EditImage view into the frame's content region.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         */
+        editImageMode: function( contentRegion ) {
+                var editImageController = new EditImageController( {
+                        model: this.model,
+                        frame: this
+                } );
+                // Noop some methods.
+                editImageController._toolbar = function() {};
+                editImageController._router = function() {};
+                editImageController._menu = function() {};
+
+                contentRegion.view = new DetailsView( {
+                        model: this.model,
+                        frame: this,
+                        controller: editImageController
+                } );
+        },
+
+        editImageModeRender: function( view ) {
+                view.on( 'ready', view.loadEditor );
+        },
+
+        toggleNav: function() {
+                this.$('.left').toggleClass( 'disabled', ! this.hasPrevious() );
+                this.$('.right').toggleClass( 'disabled', ! this.hasNext() );
+        },
+
+        /**
+         * Rerender the view.
+         */
+        rerender: function() {
+                // Only rerender the `content` region.
+                if ( this.content.mode() !== 'edit-metadata' ) {
+                        this.content.mode( 'edit-metadata' );
+                } else {
+                        this.content.render();
+                }
+
+                this.toggleNav();
+        },
+
+        /**
+         * Click handler to switch to the previous media item.
+         */
+        previousMediaItem: function() {
+                if ( ! this.hasPrevious() ) {
+                        this.$( '.left' ).blur();
+                        return;
+                }
+                this.model = this.library.at( this.getCurrentIndex() - 1 );
+                this.rerender();
+                this.$( '.left' ).focus();
+        },
+
+        /**
+         * Click handler to switch to the next media item.
+         */
+        nextMediaItem: function() {
+                if ( ! this.hasNext() ) {
+                        this.$( '.right' ).blur();
+                        return;
+                }
+                this.model = this.library.at( this.getCurrentIndex() + 1 );
+                this.rerender();
+                this.$( '.right' ).focus();
+        },
+
+        getCurrentIndex: function() {
+                return this.library.indexOf( this.model );
+        },
+
+        hasNext: function() {
+                return ( this.getCurrentIndex() + 1 ) < this.library.length;
+        },
+
+        hasPrevious: function() {
+                return ( this.getCurrentIndex() - 1 ) > -1;
+        },
+        /**
+         * Respond to the keyboard events: right arrow, left arrow, except when
+         * focus is in a textarea or input field.
+         */
+        keyEvent: function( event ) {
+                if ( ( 'INPUT' === event.target.nodeName || 'TEXTAREA' === event.target.nodeName ) && ! ( event.target.readOnly || event.target.disabled ) ) {
+                        return;
+                }
+
+                // The right arrow key
+                if ( 39 === event.keyCode ) {
+                        this.nextMediaItem();
+                }
+                // The left arrow key
+                if ( 37 === event.keyCode ) {
+                        this.previousMediaItem();
+                }
+        },
+
+        resetRoute: function() {
+                this.gridRouter.navigate( this.gridRouter.baseUrl( '' ) );
+        }
+});
+
+module.exports = EditAttachments;
+ No newline at end of file

src/wp-includes/js/media/views/frame/image-details.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.ImageDetails
+ *
+ * A media frame for manipulating an image that's already been inserted
+ * into a post.
+ *
+ * @class
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var Select = require( './select.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        PostImage = require( '../../models/post-image.js' ),
+        Selection = require( '../../models/selection.js' ),
+        ImageDetailsController = require( '../../controllers/image-details.js' ),
+        ReplaceImageController = require( '../../controllers/replace-image.js' ),
+        EditImageController = require( '../../controllers/edit-image.js' ),
+        ImageDetailsView = require( '../image-details.js' ),
+        EditImageView = require( '../edit-image.js' ),
+        l10n = wp.media.view.l10n,
+        ImageDetails;
+
+ImageDetails = Select.extend({
+        defaults: {
+                id:      'image',
+                url:     '',
+                menu:    'image-details',
+                content: 'image-details',
+                toolbar: 'image-details',
+                type:    'link',
+                title:    l10n.imageDetailsTitle,
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                this.image = new PostImage( options.metadata );
+                this.options.selection = new Selection( this.image.attachment, { multiple: false } );
+                Select.prototype.initialize.apply( this, arguments );
+        },
+
+        bindHandlers: function() {
+                Select.prototype.bindHandlers.apply( this, arguments );
+                this.on( 'menu:create:image-details', this.createMenu, this );
+                this.on( 'content:create:image-details', this.imageDetailsContent, this );
+                this.on( 'content:render:edit-image', this.editImageContent, this );
+                this.on( 'toolbar:render:image-details', this.renderImageDetailsToolbar, this );
+                // override the select toolbar
+                this.on( 'toolbar:render:replace', this.renderReplaceImageToolbar, this );
+        },
+
+        createStates: function() {
+                this.states.add([
+                        new ImageDetailsController({
+                                image: this.image,
+                                editable: false
+                        }),
+                        new ReplaceImageController({
+                                id: 'replace-image',
+                                library: wp.media.query( { type: 'image' } ),
+                                image: this.image,
+                                multiple:  false,
+                                title:     l10n.imageReplaceTitle,
+                                toolbar: 'replace',
+                                priority:  80,
+                                displaySettings: true
+                        }),
+                        new EditImageController( {
+                                image: this.image,
+                                selection: this.options.selection
+                        } )
+                ]);
+        },
+
+        imageDetailsContent: function( options ) {
+                options.view = new ImageDetailsView({
+                        controller: this,
+                        model: this.state().image,
+                        attachment: this.state().image.attachment
+                });
+        },
+
+        editImageContent: function() {
+                var state = this.state(),
+                        model = state.get('image'),
+                        view;
+
+                if ( ! model ) {
+                        return;
+                }
+
+                view = new EditImageView( { model: model, controller: this } ).render();
+
+                this.content.set( view );
+
+                // after bringing in the frame, load the actual editor via an ajax call
+                view.loadEditor();
+
+        },
+
+        renderImageDetailsToolbar: function() {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                select: {
+                                        style:    'primary',
+                                        text:     l10n.update,
+                                        priority: 80,
+
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state();
+
+                                                controller.close();
+
+                                                // not sure if we want to use wp.media.string.image which will create a shortcode or
+                                                // perhaps wp.html.string to at least to build the <img />
+                                                state.trigger( 'update', controller.image.toJSON() );
+
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        renderReplaceImageToolbar: function() {
+                var frame = this,
+                        lastState = frame.lastState(),
+                        previous = lastState && lastState.id;
+
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                back: {
+                                        text:     l10n.back,
+                                        priority: 20,
+                                        click:    function() {
+                                                if ( previous ) {
+                                                        frame.setState( previous );
+                                                } else {
+                                                        frame.close();
+                                                }
+                                        }
+                                },
+
+                                replace: {
+                                        style:    'primary',
+                                        text:     l10n.replace,
+                                        priority: 80,
+
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state(),
+                                                        selection = state.get( 'selection' ),
+                                                        attachment = selection.single();
+
+                                                controller.close();
+
+                                                controller.image.changeAttachment( attachment, state.display( attachment ) );
+
+                                                // not sure if we want to use wp.media.string.image which will create a shortcode or
+                                                // perhaps wp.html.string to at least to build the <img />
+                                                state.trigger( 'replace', controller.image.toJSON() );
+
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        }
+
+});
+
+module.exports = ImageDetails;
+ No newline at end of file

src/wp-includes/js/media/views/frame/manage.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.Manage
+ *
+ * A generic management frame workflow.
+ *
+ * Used in the media grid view.
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaFrame = require( '../media-frame.js' ),
+        UploaderWindow = require( '../uploader/window.js' ),
+        AttachmentsBrowser = require( '../attachments/browser.js' ),
+        Router = require( '../../router/manage.js' ),
+        Library = require( '../../controllers/library.js' ),
+        $ = jQuery,
+        Manage;
+
+Manage = MediaFrame.extend({
+        /**
+         * @global wp.Uploader
+         */
+        initialize: function() {
+                var self = this;
+                _.defaults( this.options, {
+                        title:     '',
+                        modal:     false,
+                        selection: [],
+                        library:   {}, // Options hash for the query to the media library.
+                        multiple:  'add',
+                        state:     'library',
+                        uploader:  true,
+                        mode:      [ 'grid', 'edit' ]
+                });
+
+                this.$body = $( document.body );
+                this.$window = $( window );
+                this.$adminBar = $( '#wpadminbar' );
+                this.$window.on( 'scroll resize', _.debounce( _.bind( this.fixPosition, this ), 15 ) );
+                $( document ).on( 'click', '.add-new-h2', _.bind( this.addNewClickHandler, this ) );
+
+                // Ensure core and media grid view UI is enabled.
+                this.$el.addClass('wp-core-ui');
+
+                // Force the uploader off if the upload limit has been exceeded or
+                // if the browser isn't supported.
+                if ( wp.Uploader.limitExceeded || ! wp.Uploader.browser.supported ) {
+                        this.options.uploader = false;
+                }
+
+                // Initialize a window-wide uploader.
+                if ( this.options.uploader ) {
+                        this.uploader = new UploaderWindow({
+                                controller: this,
+                                uploader: {
+                                        dropzone:  document.body,
+                                        container: document.body
+                                }
+                        }).render();
+                        this.uploader.ready();
+                        $('body').append( this.uploader.el );
+
+                        this.options.uploader = false;
+                }
+
+                this.gridRouter = new Router();
+
+                // Call 'initialize' directly on the parent class.
+                MediaFrame.prototype.initialize.apply( this, arguments );
+
+                // Append the frame view directly the supplied container.
+                this.$el.appendTo( this.options.container );
+
+                this.createStates();
+                this.bindRegionModeHandlers();
+                this.render();
+
+                // Update the URL when entering search string (at most once per second)
+                $( '#media-search-input' ).on( 'input', _.debounce( function(e) {
+                        var val = $( e.currentTarget ).val(), url = '';
+                        if ( val ) {
+                                url += '?search=' + val;
+                        }
+                        self.gridRouter.navigate( self.gridRouter.baseUrl( url ) );
+                }, 1000 ) );
+        },
+
+        /**
+         * Create the default states for the frame.
+         */
+        createStates: function() {
+                var options = this.options;
+
+                if ( this.options.states ) {
+                        return;
+                }
+
+                // Add the default states.
+                this.states.add([
+                        new Library({
+                                library:            wp.media.query( options.library ),
+                                multiple:           options.multiple,
+                                title:              options.title,
+                                content:            'browse',
+                                toolbar:            'select',
+                                contentUserSetting: false,
+                                filterable:         'all',
+                                autoSelect:         false
+                        })
+                ]);
+        },
+
+        /**
+         * Bind region mode activation events to proper handlers.
+         */
+        bindRegionModeHandlers: function() {
+                this.on( 'content:create:browse', this.browseContent, this );
+
+                // Handle a frame-level event for editing an attachment.
+                this.on( 'edit:attachment', this.openEditAttachmentModal, this );
+
+                this.on( 'select:activate', this.bindKeydown, this );
+                this.on( 'select:deactivate', this.unbindKeydown, this );
+        },
+
+        handleKeydown: function( e ) {
+                if ( 27 === e.which ) {
+                        e.preventDefault();
+                        this.deactivateMode( 'select' ).activateMode( 'edit' );
+                }
+        },
+
+        bindKeydown: function() {
+                this.$body.on( 'keydown.select', _.bind( this.handleKeydown, this ) );
+        },
+
+        unbindKeydown: function() {
+                this.$body.off( 'keydown.select' );
+        },
+
+        fixPosition: function() {
+                var $browser, $toolbar;
+                if ( ! this.isModeActive( 'select' ) ) {
+                        return;
+                }
+
+                $browser = this.$('.attachments-browser');
+                $toolbar = $browser.find('.media-toolbar');
+
+                // Offset doesn't appear to take top margin into account, hence +16
+                if ( ( $browser.offset().top + 16 ) < this.$window.scrollTop() + this.$adminBar.height() ) {
+                        $browser.addClass( 'fixed' );
+                        $toolbar.css('width', $browser.width() + 'px');
+                } else {
+                        $browser.removeClass( 'fixed' );
+                        $toolbar.css('width', '');
+                }
+        },
+
+        /**
+         * Click handler for the `Add New` button.
+         */
+        addNewClickHandler: function( event ) {
+                event.preventDefault();
+                this.trigger( 'toggle:upload:attachment' );
+        },
+
+        /**
+         * Open the Edit Attachment modal.
+         */
+        openEditAttachmentModal: function( model ) {
+                // Create a new EditAttachment frame, passing along the library and the attachment model.
+                wp.media( {
+                        frame:       'edit-attachments',
+                        controller:  this,
+                        library:     this.state().get('library'),
+                        model:       model
+                } );
+        },
+
+        /**
+         * Create an attachments browser view within the content region.
+         *
+         * @param {Object} contentRegion Basic object with a `view` property, which
+         *                               should be set with the proper region view.
+         * @this wp.media.controller.Region
+         */
+        browseContent: function( contentRegion ) {
+                var state = this.state();
+
+                // Browse our library of attachments.
+                this.browserView = contentRegion.view = new AttachmentsBrowser({
+                        controller: this,
+                        collection: state.get('library'),
+                        selection:  state.get('selection'),
+                        model:      state,
+                        sortable:   state.get('sortable'),
+                        search:     state.get('searchable'),
+                        filters:    state.get('filterable'),
+                        display:    state.get('displaySettings'),
+                        dragInfo:   state.get('dragInfo'),
+                        sidebar:    'errors',
+
+                        suggestedWidth:  state.get('suggestedWidth'),
+                        suggestedHeight: state.get('suggestedHeight'),
+
+                        AttachmentView: state.get('AttachmentView'),
+
+                        scrollElement: document
+                });
+                this.browserView.on( 'ready', _.bind( this.bindDeferred, this ) );
+
+                this.errors = wp.Uploader.errors;
+                this.errors.on( 'add remove reset', this.sidebarVisibility, this );
+        },
+
+        sidebarVisibility: function() {
+                this.browserView.$( '.media-sidebar' ).toggle( !! this.errors.length );
+        },
+
+        bindDeferred: function() {
+                if ( ! this.browserView.dfd ) {
+                        return;
+                }
+                this.browserView.dfd.done( _.bind( this.startHistory, this ) );
+        },
+
+        startHistory: function() {
+                // Verify pushState support and activate
+                if ( window.history && window.history.pushState ) {
+                        Backbone.history.start( {
+                                root: _wpMediaGridSettings.adminUrl,
+                                pushState: true
+                        } );
+                }
+        }
+});
+
+module.exports = Manage;
+ No newline at end of file

src/wp-includes/js/media/views/frame/media-details.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.MediaDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( '../view.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        Select = require( './select.js' ),
+        Selection = require( '../../models/selection.js' ),
+        PostMedia = require( '../../models/post-media.js' ),
+        l10n = wp.media.view.l10n,
+        MediaDetails;
+
+MediaDetails = Select.extend({
+        defaults: {
+                id:      'media',
+                url:     '',
+                menu:    'media-details',
+                content: 'media-details',
+                toolbar: 'media-details',
+                type:    'link',
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                this.DetailsView = options.DetailsView;
+                this.cancelText = options.cancelText;
+                this.addText = options.addText;
+
+                this.media = new PostMedia( options.metadata );
+                this.options.selection = new Selection( this.media.attachment, { multiple: false } );
+                Select.prototype.initialize.apply( this, arguments );
+        },
+
+        bindHandlers: function() {
+                var menu = this.defaults.menu;
+
+                Select.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'menu:create:' + menu, this.createMenu, this );
+                this.on( 'content:render:' + menu, this.renderDetailsContent, this );
+                this.on( 'menu:render:' + menu, this.renderMenu, this );
+                this.on( 'toolbar:render:' + menu, this.renderDetailsToolbar, this );
+        },
+
+        renderDetailsContent: function() {
+                var view = new this.DetailsView({
+                        controller: this,
+                        model: this.state().media,
+                        attachment: this.state().media.attachment
+                }).render();
+
+                this.content.set( view );
+        },
+
+        renderMenu: function( view ) {
+                var lastState = this.lastState(),
+                        previous = lastState && lastState.id,
+                        frame = this;
+
+                view.set({
+                        cancel: {
+                                text:     this.cancelText,
+                                priority: 20,
+                                click:    function() {
+                                        if ( previous ) {
+                                                frame.setState( previous );
+                                        } else {
+                                                frame.close();
+                                        }
+                                }
+                        },
+                        separateCancel: new View({
+                                className: 'separator',
+                                priority: 40
+                        })
+                });
+
+        },
+
+        setPrimaryButton: function(text, handler) {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                button: {
+                                        style:    'primary',
+                                        text:     text,
+                                        priority: 80,
+                                        click:    function() {
+                                                var controller = this.controller;
+                                                handler.call( this, controller, controller.state() );
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        renderDetailsToolbar: function() {
+                this.setPrimaryButton( l10n.update, function( controller, state ) {
+                        controller.close();
+                        state.trigger( 'update', controller.media.toJSON() );
+                } );
+        },
+
+        renderReplaceToolbar: function() {
+                this.setPrimaryButton( l10n.replace, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single();
+                        controller.media.changeAttachment( attachment );
+                        state.trigger( 'replace', controller.media.toJSON() );
+                } );
+        },
+
+        renderAddSourceToolbar: function() {
+                this.setPrimaryButton( this.addText, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single();
+                        controller.media.setSource( attachment );
+                        state.trigger( 'add-source', controller.media.toJSON() );
+                } );
+        }
+});
+
+module.exports = MediaDetails;
+ No newline at end of file

src/wp-includes/js/media/views/frame/post.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.Post
+ *
+ * The frame for manipulating media on the Edit Post page.
+ *
+ * @class
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( '../view.js' ),
+        Select = require( './select.js' ),
+        Library = require( '../../controllers/library.js' ),
+        Embed = require( '../embed.js' ),
+        EditImage = require( '../edit-image.js' ),
+        EditSelection = require( '../attachment/edit-selection.js' ),
+        Toolbar = require( '../toolbar.js' ),
+        ToolbarEmbed = require( '../toolbar/embed.js' ),
+        PlaylistSettings = require( '../settings/playlist.js' ),
+        AttachmentsBrowser = require( '../attachments/browser.js' ),
+        SelectionModel = require( '../../models/selection.js' ),
+        SelectionView = require( '../selection.js' ),
+        EmbedController = require( '../../controllers/embed.js' ),
+        EditImageController = require( '../../controllers/edit-image.js' ),
+        GalleryEditController = require( '../../controllers/gallery-edit.js' ),
+        GalleryAddController = require( '../../controllers/gallery-add.js' ),
+        CollectionEditController = require( '../../controllers/collection-edit.js' ),
+        CollectionAddController = require( '../../controllers/collection-add.js' ),
+        FeaturedImageController = require( '../../controllers/featured-image.js' ),
+        l10n = wp.media.view.l10n,
+        Post;
+
+Post = Select.extend({
+        initialize: function() {
+                this.counts = {
+                        audio: {
+                                count: wp.media.view.settings.attachmentCounts.audio,
+                                state: 'playlist'
+                        },
+                        video: {
+                                count: wp.media.view.settings.attachmentCounts.video,
+                                state: 'video-playlist'
+                        }
+                };
+
+                _.defaults( this.options, {
+                        multiple:  true,
+                        editing:   false,
+                        state:    'insert',
+                        metadata:  {}
+                });
+
+                // Call 'initialize' directly on the parent class.
+                Select.prototype.initialize.apply( this, arguments );
+                this.createIframeStates();
+
+        },
+
+        /**
+         * Create the default states.
+         */
+        createStates: function() {
+                var options = this.options;
+
+                this.states.add([
+                        // Main states.
+                        new Library({
+                                id:         'insert',
+                                title:      l10n.insertMediaTitle,
+                                priority:   20,
+                                toolbar:    'main-insert',
+                                filterable: 'all',
+                                library:    wp.media.query( options.library ),
+                                multiple:   options.multiple ? 'reset' : false,
+                                editable:   true,
+
+                                // If the user isn't allowed to edit fields,
+                                // can they still edit it locally?
+                                allowLocalEdits: true,
+
+                                // Show the attachment display settings.
+                                displaySettings: true,
+                                // Update user settings when users adjust the
+                                // attachment display settings.
+                                displayUserSettings: true
+                        }),
+
+                        new Library({
+                                id:         'gallery',
+                                title:      l10n.createGalleryTitle,
+                                priority:   40,
+                                toolbar:    'main-gallery',
+                                filterable: 'uploaded',
+                                multiple:   'add',
+                                editable:   false,
+
+                                library:  wp.media.query( _.defaults({
+                                        type: 'image'
+                                }, options.library ) )
+                        }),
+
+                        // Embed states.
+                        new EmbedController( { metadata: options.metadata } ),
+
+                        new EditImageController( { model: options.editImage } ),
+
+                        // Gallery states.
+                        new GalleryEditController({
+                                library: options.selection,
+                                editing: options.editing,
+                                menu:    'gallery'
+                        }),
+
+                        new GalleryAddController(),
+
+                        new Library({
+                                id:         'playlist',
+                                title:      l10n.createPlaylistTitle,
+                                priority:   60,
+                                toolbar:    'main-playlist',
+                                filterable: 'uploaded',
+                                multiple:   'add',
+                                editable:   false,
+
+                                library:  wp.media.query( _.defaults({
+                                        type: 'audio'
+                                }, options.library ) )
+                        }),
+
+                        // Playlist states.
+                        new CollectionEditController({
+                                type: 'audio',
+                                collectionType: 'playlist',
+                                title:          l10n.editPlaylistTitle,
+                                SettingsView:   PlaylistSettings,
+                                library:        options.selection,
+                                editing:        options.editing,
+                                menu:           'playlist',
+                                dragInfoText:   l10n.playlistDragInfo,
+                                dragInfo:       false
+                        }),
+
+                        new CollectionAddController({
+                                type: 'audio',
+                                collectionType: 'playlist',
+                                title: l10n.addToPlaylistTitle
+                        }),
+
+                        new Library({
+                                id:         'video-playlist',
+                                title:      l10n.createVideoPlaylistTitle,
+                                priority:   60,
+                                toolbar:    'main-video-playlist',
+                                filterable: 'uploaded',
+                                multiple:   'add',
+                                editable:   false,
+
+                                library:  wp.media.query( _.defaults({
+                                        type: 'video'
+                                }, options.library ) )
+                        }),
+
+                        new CollectionEditController({
+                                type: 'video',
+                                collectionType: 'playlist',
+                                title:          l10n.editVideoPlaylistTitle,
+                                SettingsView:   PlaylistSettings,
+                                library:        options.selection,
+                                editing:        options.editing,
+                                menu:           'video-playlist',
+                                dragInfoText:   l10n.videoPlaylistDragInfo,
+                                dragInfo:       false
+                        }),
+
+                        new CollectionAddController({
+                                type: 'video',
+                                collectionType: 'playlist',
+                                title: l10n.addToVideoPlaylistTitle
+                        })
+                ]);
+
+                if ( wp.media.view.settings.post.featuredImageId ) {
+                        this.states.add( new FeaturedImageController() );
+                }
+        },
+
+        bindHandlers: function() {
+                var handlers, checkCounts;
+
+                Select.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'activate', this.activate, this );
+
+                // Only bother checking media type counts if one of the counts is zero
+                checkCounts = _.find( this.counts, function( type ) {
+                        return type.count === 0;
+                } );
+
+                if ( typeof checkCounts !== 'undefined' ) {
+                        this.listenTo( wp.media.model.Attachments.all, 'change:type', this.mediaTypeCounts );
+                }
+
+                this.on( 'menu:create:gallery', this.createMenu, this );
+                this.on( 'menu:create:playlist', this.createMenu, this );
+                this.on( 'menu:create:video-playlist', this.createMenu, this );
+                this.on( 'toolbar:create:main-insert', this.createToolbar, this );
+                this.on( 'toolbar:create:main-gallery', this.createToolbar, this );
+                this.on( 'toolbar:create:main-playlist', this.createToolbar, this );
+                this.on( 'toolbar:create:main-video-playlist', this.createToolbar, this );
+                this.on( 'toolbar:create:featured-image', this.featuredImageToolbar, this );
+                this.on( 'toolbar:create:main-embed', this.mainEmbedToolbar, this );
+
+                handlers = {
+                        menu: {
+                                'default': 'mainMenu',
+                                'gallery': 'galleryMenu',
+                                'playlist': 'playlistMenu',
+                                'video-playlist': 'videoPlaylistMenu'
+                        },
+
+                        content: {
+                                'embed':          'embedContent',
+                                'edit-image':     'editImageContent',
+                                'edit-selection': 'editSelectionContent'
+                        },
+
+                        toolbar: {
+                                'main-insert':      'mainInsertToolbar',
+                                'main-gallery':     'mainGalleryToolbar',
+                                'gallery-edit':     'galleryEditToolbar',
+                                'gallery-add':      'galleryAddToolbar',
+                                'main-playlist':        'mainPlaylistToolbar',
+                                'playlist-edit':        'playlistEditToolbar',
+                                'playlist-add':         'playlistAddToolbar',
+                                'main-video-playlist': 'mainVideoPlaylistToolbar',
+                                'video-playlist-edit': 'videoPlaylistEditToolbar',
+                                'video-playlist-add': 'videoPlaylistAddToolbar'
+                        }
+                };
+
+                _.each( handlers, function( regionHandlers, region ) {
+                        _.each( regionHandlers, function( callback, handler ) {
+                                this.on( region + ':render:' + handler, this[ callback ], this );
+                        }, this );
+                }, this );
+        },
+
+        activate: function() {
+                // Hide menu items for states tied to particular media types if there are no items
+                _.each( this.counts, function( type ) {
+                        if ( type.count < 1 ) {
+                                this.menuItemVisibility( type.state, 'hide' );
+                        }
+                }, this );
+        },
+
+        mediaTypeCounts: function( model, attr ) {
+                if ( typeof this.counts[ attr ] !== 'undefined' && this.counts[ attr ].count < 1 ) {
+                        this.counts[ attr ].count++;
+                        this.menuItemVisibility( this.counts[ attr ].state, 'show' );
+                }
+        },
+
+        // Menus
+        /**
+         * @param {wp.Backbone.View} view
+         */
+        mainMenu: function( view ) {
+                view.set({
+                        'library-separator': new View({
+                                className: 'separator',
+                                priority: 100
+                        })
+                });
+        },
+
+        menuItemVisibility: function( state, visibility ) {
+                var menu = this.menu.get();
+                if ( visibility === 'hide' ) {
+                        menu.hide( state );
+                } else if ( visibility === 'show' ) {
+                        menu.show( state );
+                }
+        },
+        /**
+         * @param {wp.Backbone.View} view
+         */
+        galleryMenu: function( view ) {
+                var lastState = this.lastState(),
+                        previous = lastState && lastState.id,
+                        frame = this;
+
+                view.set({
+                        cancel: {
+                                text:     l10n.cancelGalleryTitle,
+                                priority: 20,
+                                click:    function() {
+                                        if ( previous ) {
+                                                frame.setState( previous );
+                                        } else {
+                                                frame.close();
+                                        }
+
+                                        // Keep focus inside media modal
+                                        // after canceling a gallery
+                                        this.controller.modal.focusManager.focus();
+                                }
+                        },
+                        separateCancel: new View({
+                                className: 'separator',
+                                priority: 40
+                        })
+                });
+        },
+
+        playlistMenu: function( view ) {
+                var lastState = this.lastState(),
+                        previous = lastState && lastState.id,
+                        frame = this;
+
+                view.set({
+                        cancel: {
+                                text:     l10n.cancelPlaylistTitle,
+                                priority: 20,
+                                click:    function() {
+                                        if ( previous ) {
+                                                frame.setState( previous );
+                                        } else {
+                                                frame.close();
+                                        }
+                                }
+                        },
+                        separateCancel: new View({
+                                className: 'separator',
+                                priority: 40
+                        })
+                });
+        },
+
+        videoPlaylistMenu: function( view ) {
+                var lastState = this.lastState(),
+                        previous = lastState && lastState.id,
+                        frame = this;
+
+                view.set({
+                        cancel: {
+                                text:     l10n.cancelVideoPlaylistTitle,
+                                priority: 20,
+                                click:    function() {
+                                        if ( previous ) {
+                                                frame.setState( previous );
+                                        } else {
+                                                frame.close();
+                                        }
+                                }
+                        },
+                        separateCancel: new View({
+                                className: 'separator',
+                                priority: 40
+                        })
+                });
+        },
+
+        // Content
+        embedContent: function() {
+                var view = new Embed({
+                        controller: this,
+                        model:      this.state()
+                }).render();
+
+                this.content.set( view );
+
+                if ( ! wp.media.isTouchDevice ) {
+                        view.url.focus();
+                }
+        },
+
+        editSelectionContent: function() {
+                var state = this.state(),
+                        selection = state.get('selection'),
+                        view;
+
+                view = new AttachmentsBrowser({
+                        controller: this,
+                        collection: selection,
+                        selection:  selection,
+                        model:      state,
+                        sortable:   true,
+                        search:     false,
+                        dragInfo:   true,
+
+                        AttachmentView: EditSelection
+                }).render();
+
+                view.toolbar.set( 'backToLibrary', {
+                        text:     l10n.returnToLibrary,
+                        priority: -100,
+
+                        click: function() {
+                                this.controller.content.mode('browse');
+                        }
+                });
+
+                // Browse our library of attachments.
+                this.content.set( view );
+
+                // Trigger the controller to set focus
+                this.trigger( 'edit:selection', this );
+        },
+
+        editImageContent: function() {
+                var image = this.state().get('image'),
+                        view = new EditImage( { model: image, controller: this } ).render();
+
+                this.content.set( view );
+
+                // after creating the wrapper view, load the actual editor via an ajax call
+                view.loadEditor();
+
+        },
+
+        // Toolbars
+
+        /**
+         * @param {wp.Backbone.View} view
+         */
+        selectionStatusToolbar: function( view ) {
+                var editable = this.state().get('editable');
+
+                view.set( 'selection', new SelectionView({
+                        controller: this,
+                        collection: this.state().get('selection'),
+                        priority:   -40,
+
+                        // If the selection is editable, pass the callback to
+                        // switch the content mode.
+                        editable: editable && function() {
+                                this.controller.content.mode('edit-selection');
+                        }
+                }).render() );
+        },
+
+        /**
+         * @param {wp.Backbone.View} view
+         */
+        mainInsertToolbar: function( view ) {
+                var controller = this;
+
+                this.selectionStatusToolbar( view );
+
+                view.set( 'insert', {
+                        style:    'primary',
+                        priority: 80,
+                        text:     l10n.insertIntoPost,
+                        requires: { selection: true },
+
+                        /**
+                         * @fires wp.media.controller.State#insert
+                         */
+                        click: function() {
+                                var state = controller.state(),
+                                        selection = state.get('selection');
+
+                                controller.close();
+                                state.trigger( 'insert', selection ).reset();
+                        }
+                });
+        },
+
+        /**
+         * @param {wp.Backbone.View} view
+         */
+        mainGalleryToolbar: function( view ) {
+                var controller = this;
+
+                this.selectionStatusToolbar( view );
+
+                view.set( 'gallery', {
+                        style:    'primary',
+                        text:     l10n.createNewGallery,
+                        priority: 60,
+                        requires: { selection: true },
+
+                        click: function() {
+                                var selection = controller.state().get('selection'),
+                                        edit = controller.state('gallery-edit'),
+                                        models = selection.where({ type: 'image' });
+
+                                edit.set( 'library', new SelectionModel( models, {
+                                        props:    selection.props.toJSON(),
+                                        multiple: true
+                                }) );
+
+                                this.controller.setState('gallery-edit');
+
+                                // Keep focus inside media modal
+                                // after jumping to gallery view
+                                this.controller.modal.focusManager.focus();
+                        }
+                });
+        },
+
+        mainPlaylistToolbar: function( view ) {
+                var controller = this;
+
+                this.selectionStatusToolbar( view );
+
+                view.set( 'playlist', {
+                        style:    'primary',
+                        text:     l10n.createNewPlaylist,
+                        priority: 100,
+                        requires: { selection: true },
+
+                        click: function() {
+                                var selection = controller.state().get('selection'),
+                                        edit = controller.state('playlist-edit'),
+                                        models = selection.where({ type: 'audio' });
+
+                                edit.set( 'library', new SelectionModel( models, {
+                                        props:    selection.props.toJSON(),
+                                        multiple: true
+                                }) );
+
+                                this.controller.setState('playlist-edit');
+
+                                // Keep focus inside media modal
+                                // after jumping to playlist view
+                                this.controller.modal.focusManager.focus();
+                        }
+                });
+        },
+
+        mainVideoPlaylistToolbar: function( view ) {
+                var controller = this;
+
+                this.selectionStatusToolbar( view );
+
+                view.set( 'video-playlist', {
+                        style:    'primary',
+                        text:     l10n.createNewVideoPlaylist,
+                        priority: 100,
+                        requires: { selection: true },
+
+                        click: function() {
+                                var selection = controller.state().get('selection'),
+                                        edit = controller.state('video-playlist-edit'),
+                                        models = selection.where({ type: 'video' });
+
+                                edit.set( 'library', new SelectionModel( models, {
+                                        props:    selection.props.toJSON(),
+                                        multiple: true
+                                }) );
+
+                                this.controller.setState('video-playlist-edit');
+
+                                // Keep focus inside media modal
+                                // after jumping to video playlist view
+                                this.controller.modal.focusManager.focus();
+                        }
+                });
+        },
+
+        featuredImageToolbar: function( toolbar ) {
+                this.createSelectToolbar( toolbar, {
+                        text:  l10n.setFeaturedImage,
+                        state: this.options.state
+                });
+        },
+
+        mainEmbedToolbar: function( toolbar ) {
+                toolbar.view = new ToolbarEmbed({
+                        controller: this
+                });
+        },
+
+        galleryEditToolbar: function() {
+                var editing = this.state().get('editing');
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     editing ? l10n.updateGallery : l10n.insertGallery,
+                                        priority: 80,
+                                        requires: { library: true },
+
+                                        /**
+                                         * @fires wp.media.controller.State#update
+                                         */
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state();
+
+                                                controller.close();
+                                                state.trigger( 'update', state.get('library') );
+
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        galleryAddToolbar: function() {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     l10n.addToGallery,
+                                        priority: 80,
+                                        requires: { selection: true },
+
+                                        /**
+                                         * @fires wp.media.controller.State#reset
+                                         */
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state(),
+                                                        edit = controller.state('gallery-edit');
+
+                                                edit.get('library').add( state.get('selection').models );
+                                                state.trigger('reset');
+                                                controller.setState('gallery-edit');
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        playlistEditToolbar: function() {
+                var editing = this.state().get('editing');
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     editing ? l10n.updatePlaylist : l10n.insertPlaylist,
+                                        priority: 80,
+                                        requires: { library: true },
+
+                                        /**
+                                         * @fires wp.media.controller.State#update
+                                         */
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state();
+
+                                                controller.close();
+                                                state.trigger( 'update', state.get('library') );
+
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        playlistAddToolbar: function() {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     l10n.addToPlaylist,
+                                        priority: 80,
+                                        requires: { selection: true },
+
+                                        /**
+                                         * @fires wp.media.controller.State#reset
+                                         */
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state(),
+                                                        edit = controller.state('playlist-edit');
+
+                                                edit.get('library').add( state.get('selection').models );
+                                                state.trigger('reset');
+                                                controller.setState('playlist-edit');
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        videoPlaylistEditToolbar: function() {
+                var editing = this.state().get('editing');
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     editing ? l10n.updateVideoPlaylist : l10n.insertVideoPlaylist,
+                                        priority: 140,
+                                        requires: { library: true },
+
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state(),
+                                                        library = state.get('library');
+
+                                                library.type = 'video';
+
+                                                controller.close();
+                                                state.trigger( 'update', library );
+
+                                                // Restore and reset the default state.
+                                                controller.setState( controller.options.state );
+                                                controller.reset();
+                                        }
+                                }
+                        }
+                }) );
+        },
+
+        videoPlaylistAddToolbar: function() {
+                this.toolbar.set( new Toolbar({
+                        controller: this,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     l10n.addToVideoPlaylist,
+                                        priority: 140,
+                                        requires: { selection: true },
+
+                                        click: function() {
+                                                var controller = this.controller,
+                                                        state = controller.state(),
+                                                        edit = controller.state('video-playlist-edit');
+
+                                                edit.get('library').add( state.get('selection').models );
+                                                state.trigger('reset');
+                                                controller.setState('video-playlist-edit');
+                                        }
+                                }
+                        }
+                }) );
+        }
+});
+
+module.exports = Post;
+ No newline at end of file

src/wp-includes/js/media/views/frame/select.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.Select
+ *
+ * A frame for selecting an item or items from the media library.
+ *
+ * @class
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+
+var MediaFrame = require( '../media-frame.js' ),
+        Library = require( '../../controllers/library.js' ),
+        AttachmentsModel = require( '../../models/attachments.js' ),
+        SelectionModel = require( '../../models/selection.js' ),
+        AttachmentsBrowser = require( '../attachments/browser.js' ),
+        UploaderInline = require( '../uploader/inline.js' ),
+        ToolbarSelect = require( '../toolbar/select.js' ),
+        l10n = wp.media.view.l10n,
+        Select;
+
+Select = MediaFrame.extend({
+        initialize: function() {
+                // Call 'initialize' directly on the parent class.
+                MediaFrame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        selection: [],
+                        library:   {},
+                        multiple:  false,
+                        state:    'library'
+                });
+
+                this.createSelection();
+                this.createStates();
+                this.bindHandlers();
+        },
+
+        /**
+         * Attach a selection collection to the frame.
+         *
+         * A selection is a collection of attachments used for a specific purpose
+         * by a media frame. e.g. Selecting an attachment (or many) to insert into
+         * post content.
+         *
+         * @see media.model.Selection
+         */
+        createSelection: function() {
+                var selection = this.options.selection;
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        this.options.selection = new SelectionModel( selection, {
+                                multiple: this.options.multiple
+                        });
+                }
+
+                this._selection = {
+                        attachments: new AttachmentsModel(),
+                        difference: []
+                };
+        },
+
+        /**
+         * Create the default states on the frame.
+         */
+        createStates: function() {
+                var options = this.options;
+
+                if ( this.options.states ) {
+                        return;
+                }
+
+                // Add the default states.
+                this.states.add([
+                        // Main states.
+                        new Library({
+                                library:   wp.media.query( options.library ),
+                                multiple:  options.multiple,
+                                title:     options.title,
+                                priority:  20
+                        })
+                ]);
+        },
+
+        /**
+         * Bind region mode event callbacks.
+         *
+         * @see media.controller.Region.render
+         */
+        bindHandlers: function() {
+                this.on( 'router:create:browse', this.createRouter, this );
+                this.on( 'router:render:browse', this.browseRouter, this );
+                this.on( 'content:create:browse', this.browseContent, this );
+                this.on( 'content:render:upload', this.uploadContent, this );
+                this.on( 'toolbar:create:select', this.createSelectToolbar, this );
+        },
+
+        /**
+         * Render callback for the router region in the `browse` mode.
+         *
+         * @param {wp.media.view.Router} routerView
+         */
+        browseRouter: function( routerView ) {
+                routerView.set({
+                        upload: {
+                                text:     l10n.uploadFilesTitle,
+                                priority: 20
+                        },
+                        browse: {
+                                text:     l10n.mediaLibraryTitle,
+                                priority: 40
+                        }
+                });
+        },
+
+        /**
+         * Render callback for the content region in the `browse` mode.
+         *
+         * @param {wp.media.controller.Region} contentRegion
+         */
+        browseContent: function( contentRegion ) {
+                var state = this.state();
+
+                this.$el.removeClass('hide-toolbar');
+
+                // Browse our library of attachments.
+                contentRegion.view = new AttachmentsBrowser({
+                        controller: this,
+                        collection: state.get('library'),
+                        selection:  state.get('selection'),
+                        model:      state,
+                        sortable:   state.get('sortable'),
+                        search:     state.get('searchable'),
+                        filters:    state.get('filterable'),
+                        display:    state.has('display') ? state.get('display') : state.get('displaySettings'),
+                        dragInfo:   state.get('dragInfo'),
+
+                        idealColumnWidth: state.get('idealColumnWidth'),
+                        suggestedWidth:   state.get('suggestedWidth'),
+                        suggestedHeight:  state.get('suggestedHeight'),
+
+                        AttachmentView: state.get('AttachmentView')
+                });
+        },
+
+        /**
+         * Render callback for the content region in the `upload` mode.
+         */
+        uploadContent: function() {
+                this.$el.removeClass( 'hide-toolbar' );
+                this.content.set( new UploaderInline({
+                        controller: this
+                }) );
+        },
+
+        /**
+         * Toolbars
+         *
+         * @param {Object} toolbar
+         * @param {Object} [options={}]
+         * @this wp.media.controller.Region
+         */
+        createSelectToolbar: function( toolbar, options ) {
+                options = options || this.options.button || {};
+                options.controller = this;
+
+                toolbar.view = new ToolbarSelect( options );
+        }
+});
+
+module.exports = Select;
+ No newline at end of file

src/wp-includes/js/media/views/frame/video-details.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame.VideoDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaFrame.MediaDetails
+ * @augments wp.media.view.MediaFrame.Select
+ * @augments wp.media.view.MediaFrame
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var MediaDetails = require( './media-details' ),
+        MediaLibrary = require( '../../controllers/media-library.js' ),
+        VideoDetailsView = require( '../video-details.js' ),
+        VideoDetailsController = require( '../../controllers/video-details.js' ),
+        l10n = wp.media.view.l10n,
+        VideoDetails;
+
+VideoDetails = MediaDetails.extend({
+        defaults: {
+                id:      'video',
+                url:     '',
+                menu:    'video-details',
+                content: 'video-details',
+                toolbar: 'video-details',
+                type:    'link',
+                title:    l10n.videoDetailsTitle,
+                priority: 120
+        },
+
+        initialize: function( options ) {
+                options.DetailsView = VideoDetailsView;
+                options.cancelText = l10n.videoDetailsCancel;
+                options.addText = l10n.videoAddSourceTitle;
+
+                MediaDetails.prototype.initialize.call( this, options );
+        },
+
+        bindHandlers: function() {
+                MediaDetails.prototype.bindHandlers.apply( this, arguments );
+
+                this.on( 'toolbar:render:replace-video', this.renderReplaceToolbar, this );
+                this.on( 'toolbar:render:add-video-source', this.renderAddSourceToolbar, this );
+                this.on( 'toolbar:render:select-poster-image', this.renderSelectPosterImageToolbar, this );
+                this.on( 'toolbar:render:add-track', this.renderAddTrackToolbar, this );
+        },
+
+        createStates: function() {
+                this.states.add([
+                        new VideoDetailsController({
+                                media: this.media
+                        }),
+
+                        new MediaLibrary( {
+                                type: 'video',
+                                id: 'replace-video',
+                                title: l10n.videoReplaceTitle,
+                                toolbar: 'replace-video',
+                                media: this.media,
+                                menu: 'video-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'video',
+                                id: 'add-video-source',
+                                title: l10n.videoAddSourceTitle,
+                                toolbar: 'add-video-source',
+                                media: this.media,
+                                menu: false
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'image',
+                                id: 'select-poster-image',
+                                title: l10n.videoSelectPosterImageTitle,
+                                toolbar: 'select-poster-image',
+                                media: this.media,
+                                menu: 'video-details'
+                        } ),
+
+                        new MediaLibrary( {
+                                type: 'text',
+                                id: 'add-track',
+                                title: l10n.videoAddTrackTitle,
+                                toolbar: 'add-track',
+                                media: this.media,
+                                menu: 'video-details'
+                        } )
+                ]);
+        },
+
+        renderSelectPosterImageToolbar: function() {
+                this.setPrimaryButton( l10n.videoSelectPosterImageTitle, function( controller, state ) {
+                        var urls = [], attachment = state.get( 'selection' ).single();
+
+                        controller.media.set( 'poster', attachment.get( 'url' ) );
+                        state.trigger( 'set-poster-image', controller.media.toJSON() );
+
+                        _.each( wp.media.view.settings.embedExts, function (ext) {
+                                if ( controller.media.get( ext ) ) {
+                                        urls.push( controller.media.get( ext ) );
+                                }
+                        } );
+
+                        wp.ajax.send( 'set-attachment-thumbnail', {
+                                data : {
+                                        urls: urls,
+                                        thumbnail_id: attachment.get( 'id' )
+                                }
+                        } );
+                } );
+        },
+
+        renderAddTrackToolbar: function() {
+                this.setPrimaryButton( l10n.videoAddTrackTitle, function( controller, state ) {
+                        var attachment = state.get( 'selection' ).single(),
+                                content = controller.media.get( 'content' );
+
+                        if ( -1 === content.indexOf( attachment.get( 'url' ) ) ) {
+                                content += [
+                                        '<track srclang="en" label="English"kind="subtitles" src="',
+                                        attachment.get( 'url' ),
+                                        '" />'
+                                ].join('');
+
+                                controller.media.set( 'content', content );
+                        }
+                        state.trigger( 'add-track', controller.media.toJSON() );
+                } );
+        }
+});
+
+module.exports = VideoDetails;
+ No newline at end of file

src/wp-includes/js/media/views/frame.js

@@ +1 @@
+/**
+ * wp.media.view.Frame
+ *
+ * A frame is a composite view consisting of one or more regions and one or more
+ * states.
+ *
+ * @see wp.media.controller.State
+ * @see wp.media.controller.Region
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var StateMachine = require( '../controllers/state-machine.js' ),
+        State = require( '../controllers/state.js' ),
+        Region = require( '../controllers/region.js' ),
+        View = require( './view.js' ),
+        Frame;
+
+Frame = View.extend({
+        initialize: function() {
+                _.defaults( this.options, {
+                        mode: [ 'select' ]
+                });
+                this._createRegions();
+                this._createStates();
+                this._createModes();
+        },
+
+        _createRegions: function() {
+                // Clone the regions array.
+                this.regions = this.regions ? this.regions.slice() : [];
+
+                // Initialize regions.
+                _.each( this.regions, function( region ) {
+                        this[ region ] = new Region({
+                                view:     this,
+                                id:       region,
+                                selector: '.media-frame-' + region
+                        });
+                }, this );
+        },
+        /**
+         * Create the frame's states.
+         *
+         * @see wp.media.controller.State
+         * @see wp.media.controller.StateMachine
+         *
+         * @fires wp.media.controller.State#ready
+         */
+        _createStates: function() {
+                // Create the default `states` collection.
+                this.states = new Backbone.Collection( null, {
+                        model: State
+                });
+
+                // Ensure states have a reference to the frame.
+                this.states.on( 'add', function( model ) {
+                        model.frame = this;
+                        model.trigger('ready');
+                }, this );
+
+                if ( this.options.states ) {
+                        this.states.add( this.options.states );
+                }
+        },
+
+        /**
+         * A frame can be in a mode or multiple modes at one time.
+         *
+         * For example, the manage media frame can be in the `Bulk Select` or `Edit` mode.
+         */
+        _createModes: function() {
+                // Store active "modes" that the frame is in. Unrelated to region modes.
+                this.activeModes = new Backbone.Collection();
+                this.activeModes.on( 'add remove reset', _.bind( this.triggerModeEvents, this ) );
+
+                _.each( this.options.mode, function( mode ) {
+                        this.activateMode( mode );
+                }, this );
+        },
+        /**
+         * Reset all states on the frame to their defaults.
+         *
+         * @returns {wp.media.view.Frame} Returns itself to allow chaining
+         */
+        reset: function() {
+                this.states.invoke( 'trigger', 'reset' );
+                return this;
+        },
+        /**
+         * Map activeMode collection events to the frame.
+         */
+        triggerModeEvents: function( model, collection, options ) {
+                var collectionEvent,
+                        modeEventMap = {
+                                add: 'activate',
+                                remove: 'deactivate'
+                        },
+                        eventToTrigger;
+                // Probably a better way to do this.
+                _.each( options, function( value, key ) {
+                        if ( value ) {
+                                collectionEvent = key;
+                        }
+                } );
+
+                if ( ! _.has( modeEventMap, collectionEvent ) ) {
+                        return;
+                }
+
+                eventToTrigger = model.get('id') + ':' + modeEventMap[collectionEvent];
+                this.trigger( eventToTrigger );
+        },
+        /**
+         * Activate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        activateMode: function( mode ) {
+                // Bail if the mode is already active.
+                if ( this.isModeActive( mode ) ) {
+                        return;
+                }
+                this.activeModes.add( [ { id: mode } ] );
+                // Add a CSS class to the frame so elements can be styled for the mode.
+                this.$el.addClass( 'mode-' + mode );
+
+                return this;
+        },
+        /**
+         * Deactivate a mode on the frame.
+         *
+         * @param string mode Mode ID.
+         * @returns {this} Returns itself to allow chaining.
+         */
+        deactivateMode: function( mode ) {
+                // Bail if the mode isn't active.
+                if ( ! this.isModeActive( mode ) ) {
+                        return this;
+                }
+                this.activeModes.remove( this.activeModes.where( { id: mode } ) );
+                this.$el.removeClass( 'mode-' + mode );
+                /**
+                 * Frame mode deactivation event.
+                 *
+                 * @event this#{mode}:deactivate
+                 */
+                this.trigger( mode + ':deactivate' );
+
+                return this;
+        },
+        /**
+         * Check if a mode is enabled on the frame.
+         *
+         * @param  string mode Mode ID.
+         * @return bool
+         */
+        isModeActive: function( mode ) {
+                return Boolean( this.activeModes.where( { id: mode } ).length );
+        }
+});
+
+// Make the `Frame` a `StateMachine`.
+_.extend( Frame.prototype, StateMachine.prototype );
+
+module.exports = Frame;
+ No newline at end of file

src/wp-includes/js/media/views/iframe.js

@@ +1 @@
+/**
+ * wp.media.view.Iframe
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Iframe;
+
+Iframe = View.extend({
+        className: 'media-iframe',
+        /**
+         * @returns {wp.media.view.Iframe} Returns itself to allow chaining
+         */
+        render: function() {
+                this.views.detach();
+                this.$el.html( '<iframe src="' + this.controller.state().get('src') + '" />' );
+                this.views.render();
+                return this;
+        }
+});
+
+module.exports = Iframe;
+ No newline at end of file

src/wp-includes/js/media/views/image-details.js

@@ +1 @@
+/**
+ * wp.media.view.ImageDetails
+ *
+ * @class
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentDisplay = require( './settings/attachment-display.js' ),
+        $ = jQuery,
+        ImageDetails;
+
+ImageDetails = AttachmentDisplay.extend({
+        className: 'image-details',
+        template:  wp.template('image-details'),
+        events: _.defaults( AttachmentDisplay.prototype.events, {
+                'click .edit-attachment': 'editAttachment',
+                'click .replace-attachment': 'replaceAttachment',
+                'click .advanced-toggle': 'onToggleAdvanced',
+                'change [data-setting="customWidth"]': 'onCustomSize',
+                'change [data-setting="customHeight"]': 'onCustomSize',
+                'keyup [data-setting="customWidth"]': 'onCustomSize',
+                'keyup [data-setting="customHeight"]': 'onCustomSize'
+        } ),
+        initialize: function() {
+                // used in AttachmentDisplay.prototype.updateLinkTo
+                this.options.attachment = this.model.attachment;
+                this.listenTo( this.model, 'change:url', this.updateUrl );
+                this.listenTo( this.model, 'change:link', this.toggleLinkSettings );
+                this.listenTo( this.model, 'change:size', this.toggleCustomSize );
+
+                AttachmentDisplay.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                var attachment = false;
+
+                if ( this.model.attachment ) {
+                        attachment = this.model.attachment.toJSON();
+                }
+                return _.defaults({
+                        model: this.model.toJSON(),
+                        attachment: attachment
+                }, this.options );
+        },
+
+        render: function() {
+                var self = this,
+                        args = arguments;
+
+                if ( this.model.attachment && 'pending' === this.model.dfd.state() ) {
+                        this.model.dfd.done( function() {
+                                AttachmentDisplay.prototype.render.apply( self, args );
+                                self.postRender();
+                        } ).fail( function() {
+                                self.model.attachment = false;
+                                AttachmentDisplay.prototype.render.apply( self, args );
+                                self.postRender();
+                        } );
+                } else {
+                        AttachmentDisplay.prototype.render.apply( this, arguments );
+                        this.postRender();
+                }
+
+                return this;
+        },
+
+        postRender: function() {
+                setTimeout( _.bind( this.resetFocus, this ), 10 );
+                this.toggleLinkSettings();
+                if ( getUserSetting( 'advImgDetails' ) === 'show' ) {
+                        this.toggleAdvanced( true );
+                }
+                this.trigger( 'post-render' );
+        },
+
+        resetFocus: function() {
+                this.$( '.link-to-custom' ).blur();
+                this.$( '.embed-media-settings' ).scrollTop( 0 );
+        },
+
+        updateUrl: function() {
+                this.$( '.image img' ).attr( 'src', this.model.get( 'url' ) );
+                this.$( '.url' ).val( this.model.get( 'url' ) );
+        },
+
+        toggleLinkSettings: function() {
+                if ( this.model.get( 'link' ) === 'none' ) {
+                        this.$( '.link-settings' ).addClass('hidden');
+                } else {
+                        this.$( '.link-settings' ).removeClass('hidden');
+                }
+        },
+
+        toggleCustomSize: function() {
+                if ( this.model.get( 'size' ) !== 'custom' ) {
+                        this.$( '.custom-size' ).addClass('hidden');
+                } else {
+                        this.$( '.custom-size' ).removeClass('hidden');
+                }
+        },
+
+        onCustomSize: function( event ) {
+                var dimension = $( event.target ).data('setting'),
+                        num = $( event.target ).val(),
+                        value;
+
+                // Ignore bogus input
+                if ( ! /^\d+/.test( num ) || parseInt( num, 10 ) < 1 ) {
+                        event.preventDefault();
+                        return;
+                }
+
+                if ( dimension === 'customWidth' ) {
+                        value = Math.round( 1 / this.model.get( 'aspectRatio' ) * num );
+                        this.model.set( 'customHeight', value, { silent: true } );
+                        this.$( '[data-setting="customHeight"]' ).val( value );
+                } else {
+                        value = Math.round( this.model.get( 'aspectRatio' ) * num );
+                        this.model.set( 'customWidth', value, { silent: true  } );
+                        this.$( '[data-setting="customWidth"]' ).val( value );
+                }
+        },
+
+        onToggleAdvanced: function( event ) {
+                event.preventDefault();
+                this.toggleAdvanced();
+        },
+
+        toggleAdvanced: function( show ) {
+                var $advanced = this.$el.find( '.advanced-section' ),
+                        mode;
+
+                if ( $advanced.hasClass('advanced-visible') || show === false ) {
+                        $advanced.removeClass('advanced-visible');
+                        $advanced.find('.advanced-settings').addClass('hidden');
+                        mode = 'hide';
+                } else {
+                        $advanced.addClass('advanced-visible');
+                        $advanced.find('.advanced-settings').removeClass('hidden');
+                        mode = 'show';
+                }
+
+                setUserSetting( 'advImgDetails', mode );
+        },
+
+        editAttachment: function( event ) {
+                var editState = this.controller.states.get( 'edit-image' );
+
+                if ( window.imageEdit && editState ) {
+                        event.preventDefault();
+                        editState.set( 'image', this.model.attachment );
+                        this.controller.setState( 'edit-image' );
+                }
+        },
+
+        replaceAttachment: function( event ) {
+                event.preventDefault();
+                this.controller.setState( 'replace-image' );
+        }
+});
+
+module.exports = AttachmentDisplay;
+ No newline at end of file

src/wp-includes/js/media/views/label.js

@@ +1 @@
+/**
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Label;
+
+Label = View.extend({
+        tagName: 'label',
+        className: 'screen-reader-text',
+
+        initialize: function() {
+                this.value = this.options.value;
+        },
+
+        render: function() {
+                this.$el.html( this.value );
+
+                return this;
+        }
+});
+
+module.exports = Label;
+ No newline at end of file

src/wp-includes/js/media/views/media-details.js

@@ +1 @@
+/**
+ * wp.media.view.MediaDetails
+ *
+ * @constructor
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var AttachmentDisplay = require( './settings/attachment-display.js' ),
+        $ = jQuery,
+        MediaDetails;
+
+MediaDetails = AttachmentDisplay.extend({
+        initialize: function() {
+                _.bindAll(this, 'success');
+                this.players = [];
+                this.listenTo( this.controller, 'close', wp.media.mixin.unsetPlayers );
+                this.on( 'ready', this.setPlayer );
+                this.on( 'media:setting:remove', wp.media.mixin.unsetPlayers, this );
+                this.on( 'media:setting:remove', this.render );
+                this.on( 'media:setting:remove', this.setPlayer );
+                this.events = _.extend( this.events, {
+                        'click .remove-setting' : 'removeSetting',
+                        'change .content-track' : 'setTracks',
+                        'click .remove-track' : 'setTracks',
+                        'click .add-media-source' : 'addSource'
+                } );
+
+                AttachmentDisplay.prototype.initialize.apply( this, arguments );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+
+        /**
+         * Remove a setting's UI when the model unsets it
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         *
+         * @param {Event} e
+         */
+        removeSetting : function(e) {
+                var wrap = $( e.currentTarget ).parent(), setting;
+                setting = wrap.find( 'input' ).data( 'setting' );
+
+                if ( setting ) {
+                        this.model.unset( setting );
+                        this.trigger( 'media:setting:remove', this );
+                }
+
+                wrap.remove();
+        },
+
+        /**
+         *
+         * @fires wp.media.view.MediaDetails#media:setting:remove
+         */
+        setTracks : function() {
+                var tracks = '';
+
+                _.each( this.$('.content-track'), function(track) {
+                        tracks += $( track ).val();
+                } );
+
+                this.model.set( 'content', tracks );
+                this.trigger( 'media:setting:remove', this );
+        },
+
+        addSource : function( e ) {
+                this.controller.lastMime = $( e.currentTarget ).data( 'mime' );
+                this.controller.setState( 'add-' + this.controller.defaults.id + '-source' );
+        },
+
+        /**
+         * @global MediaElementPlayer
+         */
+        setPlayer : function() {
+                if ( ! this.players.length && this.media ) {
+                        this.players.push( new MediaElementPlayer( this.media, this.settings ) );
+                }
+        },
+
+        /**
+         * @abstract
+         */
+        setMedia : function() {
+                return this;
+        },
+
+        success : function(mejs) {
+                var autoplay = mejs.attributes.autoplay && 'false' !== mejs.attributes.autoplay;
+
+                if ( 'flash' === mejs.pluginType && autoplay ) {
+                        mejs.addEventListener( 'canplay', function() {
+                                mejs.play();
+                        }, false );
+                }
+
+                this.mejs = mejs;
+        },
+
+        /**
+         * @returns {media.view.MediaDetails} Returns itself to allow chaining
+         */
+        render: function() {
+                var self = this;
+
+                AttachmentDisplay.prototype.render.apply( this, arguments );
+                setTimeout( function() { self.resetFocus(); }, 10 );
+
+                this.settings = _.defaults( {
+                        success : this.success
+                }, wp.media.mixin.mejsSettings );
+
+                return this.setMedia();
+        },
+
+        resetFocus: function() {
+                this.$( '.embed-media-settings' ).scrollTop( 0 );
+        }
+}, {
+        instances : 0,
+        /**
+         * When multiple players in the DOM contain the same src, things get weird.
+         *
+         * @param {HTMLElement} elem
+         * @returns {HTMLElement}
+         */
+        prepareSrc : function( elem ) {
+                var i = MediaDetails.instances++;
+                _.each( $( elem ).find( 'source' ), function( source ) {
+                        source.src = [
+                                source.src,
+                                source.src.indexOf('?') > -1 ? '&' : '?',
+                                '_=',
+                                i
+                        ].join('');
+                } );
+
+                return elem;
+        }
+});
+
+module.exports = MediaDetails;
+ No newline at end of file

src/wp-includes/js/media/views/media-frame.js

@@ +1 @@
+/**
+ * wp.media.view.MediaFrame
+ *
+ * The frame used to create the media modal.
+ *
+ * @class
+ * @augments wp.media.view.Frame
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ * @mixes wp.media.controller.StateMachine
+ */
+var View = require( './view.js' ),
+        Frame = require( './frame.js' ),
+        Modal = require( './modal.js' ),
+        UploaderWindow = require( './uploader/window.js' ),
+        Menu = require( './menu.js' ),
+        Toolbar = require( './toolbar.js' ),
+        Router = require( './router.js' ),
+        Iframe = require( './iframe.js' ),
+        $ = jQuery,
+        MediaFrame;
+
+MediaFrame = Frame.extend({
+        className: 'media-frame',
+        template:  wp.template('media-frame'),
+        regions:   ['menu','title','content','toolbar','router'],
+
+        events: {
+                'click div.media-frame-title h1': 'toggleMenu'
+        },
+
+        /**
+         * @global wp.Uploader
+         */
+        initialize: function() {
+                Frame.prototype.initialize.apply( this, arguments );
+
+                _.defaults( this.options, {
+                        title:    '',
+                        modal:    true,
+                        uploader: true
+                });
+
+                // Ensure core UI is enabled.
+                this.$el.addClass('wp-core-ui');
+
+                // Initialize modal container view.
+                if ( this.options.modal ) {
+                        this.modal = new Modal({
+                                controller: this,
+                                title:      this.options.title
+                        });
+
+                        this.modal.content( this );
+                }
+
+                // Force the uploader off if the upload limit has been exceeded or
+                // if the browser isn't supported.
+                if ( wp.Uploader.limitExceeded || ! wp.Uploader.browser.supported ) {
+                        this.options.uploader = false;
+                }
+
+                // Initialize window-wide uploader.
+                if ( this.options.uploader ) {
+                        this.uploader = new UploaderWindow({
+                                controller: this,
+                                uploader: {
+                                        dropzone:  this.modal ? this.modal.$el : this.$el,
+                                        container: this.$el
+                                }
+                        });
+                        this.views.set( '.media-frame-uploader', this.uploader );
+                }
+
+                this.on( 'attach', _.bind( this.views.ready, this.views ), this );
+
+                // Bind default title creation.
+                this.on( 'title:create:default', this.createTitle, this );
+                this.title.mode('default');
+
+                this.on( 'title:render', function( view ) {
+                        view.$el.append( '<span class="dashicons dashicons-arrow-down"></span>' );
+                });
+
+                // Bind default menu.
+                this.on( 'menu:create:default', this.createMenu, this );
+        },
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        render: function() {
+                // Activate the default state if no active state exists.
+                if ( ! this.state() && this.options.state ) {
+                        this.setState( this.options.state );
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                return Frame.prototype.render.apply( this, arguments );
+        },
+        /**
+         * @param {Object} title
+         * @this wp.media.controller.Region
+         */
+        createTitle: function( title ) {
+                title.view = new View({
+                        controller: this,
+                        tagName: 'h1'
+                });
+        },
+        /**
+         * @param {Object} menu
+         * @this wp.media.controller.Region
+         */
+        createMenu: function( menu ) {
+                menu.view = new Menu({
+                        controller: this
+                });
+        },
+
+        toggleMenu: function() {
+                this.$el.find( '.media-menu' ).toggleClass( 'visible' );
+        },
+
+        /**
+         * @param {Object} toolbar
+         * @this wp.media.controller.Region
+         */
+        createToolbar: function( toolbar ) {
+                toolbar.view = new Toolbar({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} router
+         * @this wp.media.controller.Region
+         */
+        createRouter: function( router ) {
+                router.view = new Router({
+                        controller: this
+                });
+        },
+        /**
+         * @param {Object} options
+         */
+        createIframeStates: function( options ) {
+                var settings = wp.media.view.settings,
+                        tabs = settings.tabs,
+                        tabUrl = settings.tabUrl,
+                        $postId;
+
+                if ( ! tabs || ! tabUrl ) {
+                        return;
+                }
+
+                // Add the post ID to the tab URL if it exists.
+                $postId = $('#post_ID');
+                if ( $postId.length ) {
+                        tabUrl += '&post_id=' + $postId.val();
+                }
+
+                // Generate the tab states.
+                _.each( tabs, function( title, id ) {
+                        this.state( 'iframe:' + id ).set( _.defaults({
+                                tab:     id,
+                                src:     tabUrl + '&tab=' + id,
+                                title:   title,
+                                content: 'iframe',
+                                menu:    'default'
+                        }, options ) );
+                }, this );
+
+                this.on( 'content:create:iframe', this.iframeContent, this );
+                this.on( 'content:deactivate:iframe', this.iframeContentCleanup, this );
+                this.on( 'menu:render:default', this.iframeMenu, this );
+                this.on( 'open', this.hijackThickbox, this );
+                this.on( 'close', this.restoreThickbox, this );
+        },
+
+        /**
+         * @param {Object} content
+         * @this wp.media.controller.Region
+         */
+        iframeContent: function( content ) {
+                this.$el.addClass('hide-toolbar');
+                content.view = new Iframe({
+                        controller: this
+                });
+        },
+
+        iframeContentCleanup: function() {
+                this.$el.removeClass('hide-toolbar');
+        },
+
+        iframeMenu: function( view ) {
+                var views = {};
+
+                if ( ! view ) {
+                        return;
+                }
+
+                _.each( wp.media.view.settings.tabs, function( title, id ) {
+                        views[ 'iframe:' + id ] = {
+                                text: this.state( 'iframe:' + id ).get('title'),
+                                priority: 200
+                        };
+                }, this );
+
+                view.set( views );
+        },
+
+        hijackThickbox: function() {
+                var frame = this;
+
+                if ( ! window.tb_remove || this._tb_remove ) {
+                        return;
+                }
+
+                this._tb_remove = window.tb_remove;
+                window.tb_remove = function() {
+                        frame.close();
+                        frame.reset();
+                        frame.setState( frame.options.state );
+                        frame._tb_remove.call( window );
+                };
+        },
+
+        restoreThickbox: function() {
+                if ( ! this._tb_remove ) {
+                        return;
+                }
+
+                window.tb_remove = this._tb_remove;
+                delete this._tb_remove;
+        }
+});
+
+// Map some of the modal's methods to the frame.
+_.each(['open','close','attach','detach','escape'], function( method ) {
+        /**
+         * @returns {wp.media.view.MediaFrame} Returns itself to allow chaining
+         */
+        MediaFrame.prototype[ method ] = function() {
+                if ( this.modal ) {
+                        this.modal[ method ].apply( this.modal, arguments );
+                }
+                return this;
+        };
+});
+
+module.exports = MediaFrame;
+ No newline at end of file

src/wp-includes/js/media/views/menu-item.js

@@ +1 @@
+/**
+ * wp.media.view.MenuItem
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        MenuItem;
+
+MenuItem = View.extend({
+        tagName:   'a',
+        className: 'media-menu-item',
+
+        attributes: {
+                href: '#'
+        },
+
+        events: {
+                'click': '_click'
+        },
+        /**
+         * @param {Object} event
+         */
+        _click: function( event ) {
+                var clickOverride = this.options.click;
+
+                if ( event ) {
+                        event.preventDefault();
+                }
+
+                if ( clickOverride ) {
+                        clickOverride.call( this );
+                } else {
+                        this.click();
+                }
+
+                // When selecting a tab along the left side,
+                // focus should be transferred into the main panel
+                if ( ! wp.media.isTouchDevice ) {
+                        $('.media-frame-content input').first().focus();
+                }
+        },
+
+        click: function() {
+                var state = this.options.state;
+
+                if ( state ) {
+                        this.controller.setState( state );
+                        this.views.parent.$el.removeClass( 'visible' ); // TODO: or hide on any click, see below
+                }
+        },
+        /**
+         * @returns {wp.media.view.MenuItem} returns itself to allow chaining
+         */
+        render: function() {
+                var options = this.options;
+
+                if ( options.text ) {
+                        this.$el.text( options.text );
+                } else if ( options.html ) {
+                        this.$el.html( options.html );
+                }
+
+                return this;
+        }
+});
+
+module.exports = MenuItem;
+ No newline at end of file

src/wp-includes/js/media/views/menu.js

@@ +1 @@
+/**
+ * wp.media.view.Menu
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Menu;
+
+Menu = PriorityList.extend({
+        tagName:   'div',
+        className: 'media-menu',
+        property:  'state',
+        ItemView:  MenuItem,
+        region:    'menu',
+
+        /* TODO: alternatively hide on any click anywhere
+        events: {
+                'click': 'click'
+        },
+
+        click: function() {
+                this.$el.removeClass( 'visible' );
+        },
+        */
+
+        /**
+         * @param {Object} options
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        toView: function( options, id ) {
+                options = options || {};
+                options[ this.property ] = options[ this.property ] || id;
+                return new this.ItemView( options ).render();
+        },
+
+        ready: function() {
+                /**
+                 * call 'ready' directly on the parent class
+                 */
+                PriorityList.prototype.ready.apply( this, arguments );
+                this.visibility();
+        },
+
+        set: function() {
+                /**
+                 * call 'set' directly on the parent class
+                 */
+                PriorityList.prototype.set.apply( this, arguments );
+                this.visibility();
+        },
+
+        unset: function() {
+                /**
+                 * call 'unset' directly on the parent class
+                 */
+                PriorityList.prototype.unset.apply( this, arguments );
+                this.visibility();
+        },
+
+        visibility: function() {
+                var region = this.region,
+                        view = this.controller[ region ].get(),
+                        views = this.views.get(),
+                        hide = ! views || views.length < 2;
+
+                if ( this === view ) {
+                        this.controller.$el.toggleClass( 'hide-' + region, hide );
+                }
+        },
+        /**
+         * @param {string} id
+         */
+        select: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                this.deselect();
+                view.$el.addClass('active');
+        },
+
+        deselect: function() {
+                this.$el.children().removeClass('active');
+        },
+
+        hide: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.addClass('hidden');
+        },
+
+        show: function( id ) {
+                var view = this.get( id );
+
+                if ( ! view ) {
+                        return;
+                }
+
+                view.$el.removeClass('hidden');
+        }
+});
+
+module.exports = Menu;
+ No newline at end of file

src/wp-includes/js/media/views/modal.js

@@ +1 @@
+/**
+ * wp.media.view.Modal
+ *
+ * A modal view, which the media modal uses as its default container.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        FocusManager = require( './focus-manager.js' ),
+        $ = jQuery,
+        Modal;
+
+Modal = View.extend({
+        tagName:  'div',
+        template: wp.template('media-modal'),
+
+        attributes: {
+                tabindex: 0
+        },
+
+        events: {
+                'click .media-modal-backdrop, .media-modal-close': 'escapeHandler',
+                'keydown': 'keydown'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        container: document.body,
+                        title:     '',
+                        propagate: true,
+                        freeze:    true
+                });
+
+                this.focusManager = new FocusManager({
+                        el: this.el
+                });
+        },
+        /**
+         * @returns {Object}
+         */
+        prepare: function() {
+                return {
+                        title: this.options.title
+                };
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        attach: function() {
+                if ( this.views.attached ) {
+                        return this;
+                }
+
+                if ( ! this.views.rendered ) {
+                        this.render();
+                }
+
+                this.$el.appendTo( this.options.container );
+
+                // Manually mark the view as attached and trigger ready.
+                this.views.attached = true;
+                this.views.ready();
+
+                return this.propagate('attach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        detach: function() {
+                if ( this.$el.is(':visible') ) {
+                        this.close();
+                }
+
+                this.$el.detach();
+                this.views.attached = false;
+                return this.propagate('detach');
+        },
+
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        open: function() {
+                var $el = this.$el,
+                        options = this.options,
+                        mceEditor;
+
+                if ( $el.is(':visible') ) {
+                        return this;
+                }
+
+                if ( ! this.views.attached ) {
+                        this.attach();
+                }
+
+                // If the `freeze` option is set, record the window's scroll position.
+                if ( options.freeze ) {
+                        this._freeze = {
+                                scrollTop: $( window ).scrollTop()
+                        };
+                }
+
+                // Disable page scrolling.
+                $( 'body' ).addClass( 'modal-open' );
+
+                $el.show();
+
+                // Try to close the onscreen keyboard
+                if ( 'ontouchend' in document ) {
+                        if ( ( mceEditor = window.tinymce && window.tinymce.activeEditor )  && ! mceEditor.isHidden() && mceEditor.iframeElement ) {
+                                mceEditor.iframeElement.focus();
+                                mceEditor.iframeElement.blur();
+
+                                setTimeout( function() {
+                                        mceEditor.iframeElement.blur();
+                                }, 100 );
+                        }
+                }
+
+                this.$el.focus();
+
+                return this.propagate('open');
+        },
+
+        /**
+         * @param {Object} options
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        close: function( options ) {
+                var freeze = this._freeze;
+
+                if ( ! this.views.attached || ! this.$el.is(':visible') ) {
+                        return this;
+                }
+
+                // Enable page scrolling.
+                $( 'body' ).removeClass( 'modal-open' );
+
+                // Hide modal and remove restricted media modal tab focus once it's closed
+                this.$el.hide().undelegate( 'keydown' );
+
+                // Put focus back in useful location once modal is closed
+                $('#wpbody-content').focus();
+
+                this.propagate('close');
+
+                // If the `freeze` option is set, restore the container's scroll position.
+                if ( freeze ) {
+                        $( window ).scrollTop( freeze.scrollTop );
+                }
+
+                if ( options && options.escape ) {
+                        this.propagate('escape');
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        escape: function() {
+                return this.close({ escape: true });
+        },
+        /**
+         * @param {Object} event
+         */
+        escapeHandler: function( event ) {
+                event.preventDefault();
+                this.escape();
+        },
+
+        /**
+         * @param {Array|Object} content Views to register to '.media-modal-content'
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        content: function( content ) {
+                this.views.set( '.media-modal-content', content );
+                return this;
+        },
+
+        /**
+         * Triggers a modal event and if the `propagate` option is set,
+         * forwards events to the modal's controller.
+         *
+         * @param {string} id
+         * @returns {wp.media.view.Modal} Returns itself to allow chaining
+         */
+        propagate: function( id ) {
+                this.trigger( id );
+
+                if ( this.options.propagate ) {
+                        this.controller.trigger( id );
+                }
+
+                return this;
+        },
+        /**
+         * @param {Object} event
+         */
+        keydown: function( event ) {
+                // Close the modal when escape is pressed.
+                if ( 27 === event.which && this.$el.is(':visible') ) {
+                        this.escape();
+                        event.stopImmediatePropagation();
+                }
+        }
+});
+
+module.exports = Modal;
+ No newline at end of file

src/wp-includes/js/media/views/priority-list.js

@@ +1 @@
+/**
+ * wp.media.view.PriorityList
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        PriorityList;
+
+PriorityList = View.extend({
+        tagName:   'div',
+
+        initialize: function() {
+                this._views = {};
+
+                this.set( _.extend( {}, this._views, this.options.views ), { silent: true });
+                delete this.options.views;
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+        },
+        /**
+         * @param {string} id
+         * @param {wp.media.View|Object} view
+         * @param {Object} options
+         * @returns {wp.media.view.PriorityList} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var priority, views, index;
+
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view );
+                        }, this );
+                        return this;
+                }
+
+                if ( ! (view instanceof Backbone.View) ) {
+                        view = this.toView( view, id, options );
+                }
+                view.controller = view.controller || this.controller;
+
+                this.unset( id );
+
+                priority = view.options.priority || 10;
+                views = this.views.get() || [];
+
+                _.find( views, function( existing, i ) {
+                        if ( existing.options.priority > priority ) {
+                                index = i;
+                                return true;
+                        }
+                });
+
+                this._views[ id ] = view;
+                this.views.add( view, {
+                        at: _.isNumber( index ) ? index : views.length || 0
+                });
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.View}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.PriorityList}
+         */
+        unset: function( id ) {
+                var view = this.get( id );
+
+                if ( view ) {
+                        view.remove();
+                }
+
+                delete this._views[ id ];
+                return this;
+        },
+        /**
+         * @param {Object} options
+         * @returns {wp.media.View}
+         */
+        toView: function( options ) {
+                return new View( options );
+        }
+});
+
+module.exports = PriorityList;
+ No newline at end of file

src/wp-includes/js/media/views/router-item.js

@@ +1 @@
+/**
+ * wp.media.view.RouterItem
+ *
+ * @class
+ * @augments wp.media.view.MenuItem
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MenuItem = require( './menu-item.js' ),
+        RouterItem;
+
+RouterItem = MenuItem.extend({
+        /**
+         * On click handler to activate the content region's corresponding mode.
+         */
+        click: function() {
+                var contentMode = this.options.contentMode;
+                if ( contentMode ) {
+                        this.controller.content.mode( contentMode );
+                }
+        }
+});
+
+module.exports = RouterItem;
+ No newline at end of file

src/wp-includes/js/media/views/router.js

@@ +1 @@
+/**
+ * wp.media.view.Router
+ *
+ * @class
+ * @augments wp.media.view.Menu
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Menu = require( './menu.js' ),
+        RouterItem = require( './router-item.js' ),
+        Router;
+
+Router = Menu.extend({
+        tagName:   'div',
+        className: 'media-router',
+        property:  'contentMode',
+        ItemView:  RouterItem,
+        region:    'router',
+
+        initialize: function() {
+                this.controller.on( 'content:render', this.update, this );
+                // Call 'initialize' directly on the parent class.
+                Menu.prototype.initialize.apply( this, arguments );
+        },
+
+        update: function() {
+                var mode = this.controller.content.mode();
+                if ( mode ) {
+                        this.select( mode );
+                }
+        }
+});
+
+module.exports = Router;
+ No newline at end of file

src/wp-includes/js/media/views/search.js

@@ +1 @@
+/**
+ * wp.media.view.Search
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        l10n = wp.media.view.l10n,
+        Search;
+
+Search = View.extend({
+        tagName:   'input',
+        className: 'search',
+        id:        'media-search-input',
+
+        attributes: {
+                type:        'search',
+                placeholder: l10n.search
+        },
+
+        events: {
+                'input':  'search',
+                'keyup':  'search',
+                'change': 'search',
+                'search': 'search'
+        },
+
+        /**
+         * @returns {wp.media.view.Search} Returns itself to allow chaining
+         */
+        render: function() {
+                this.el.value = this.model.escape('search');
+                return this;
+        },
+
+        search: function( event ) {
+                if ( event.target.value ) {
+                        this.model.set( 'search', event.target.value );
+                } else {
+                        this.model.unset('search');
+                }
+        }
+});
+
+module.exports = Search;
+ No newline at end of file

src/wp-includes/js/media/views/selection.js

@@ +1 @@
+/**
+ * wp.media.view.Selection
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        AttachmentsSelection = require( './attachments/selection.js' ),
+        l10n = wp.media.view.l10n,
+        Selection;
+
+Selection = View.extend({
+        tagName:   'div',
+        className: 'media-selection',
+        template:  wp.template('media-selection'),
+
+        events: {
+                'click .edit-selection':  'edit',
+                'click .clear-selection': 'clear'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        editable:  false,
+                        clearable: true
+                });
+
+                /**
+                 * @member {wp.media.view.Attachments.Selection}
+                 */
+                this.attachments = new AttachmentsSelection({
+                        controller: this.controller,
+                        collection: this.collection,
+                        selection:  this.collection,
+                        model:      new Backbone.Model()
+                });
+
+                this.views.set( '.selection-view', this.attachments );
+                this.collection.on( 'add remove reset', this.refresh, this );
+                this.controller.on( 'content:activate', this.refresh, this );
+        },
+
+        ready: function() {
+                this.refresh();
+        },
+
+        refresh: function() {
+                // If the selection hasn't been rendered, bail.
+                if ( ! this.$el.children().length ) {
+                        return;
+                }
+
+                var collection = this.collection,
+                        editing = 'edit-selection' === this.controller.content.mode();
+
+                // If nothing is selected, display nothing.
+                this.$el.toggleClass( 'empty', ! collection.length );
+                this.$el.toggleClass( 'one', 1 === collection.length );
+                this.$el.toggleClass( 'editing', editing );
+
+                this.$('.count').text( l10n.selected.replace('%d', collection.length) );
+        },
+
+        edit: function( event ) {
+                event.preventDefault();
+                if ( this.options.editable ) {
+                        this.options.editable.call( this, this.collection );
+                }
+        },
+
+        clear: function( event ) {
+                event.preventDefault();
+                this.collection.reset();
+
+                // Keep focus inside media modal
+                // after clear link is selected
+                this.controller.modal.focusManager.focus();
+        }
+});
+
+module.exports = Selection;
+ No newline at end of file

src/wp-includes/js/media/views/settings/attachment-display.js

@@ +1 @@
+/**
+ * wp.media.view.Settings.AttachmentDisplay
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        AttachmentDisplay;
+
+AttachmentDisplay = Settings.extend({
+        className: 'attachment-display-settings',
+        template:  wp.template('attachment-display-settings'),
+
+        initialize: function() {
+                var attachment = this.options.attachment;
+
+                _.defaults( this.options, {
+                        userSettings: false
+                });
+                // Call 'initialize' directly on the parent class.
+                Settings.prototype.initialize.apply( this, arguments );
+                this.model.on( 'change:link', this.updateLinkTo, this );
+
+                if ( attachment ) {
+                        attachment.on( 'change:uploading', this.render, this );
+                }
+        },
+
+        dispose: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        attachment.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                Settings.prototype.dispose.apply( this, arguments );
+        },
+        /**
+         * @returns {wp.media.view.AttachmentDisplay} Returns itself to allow chaining
+         */
+        render: function() {
+                var attachment = this.options.attachment;
+                if ( attachment ) {
+                        _.extend( this.options, {
+                                sizes: attachment.get('sizes'),
+                                type:  attachment.get('type')
+                        });
+                }
+                /**
+                 * call 'render' directly on the parent class
+                 */
+                Settings.prototype.render.call( this );
+                this.updateLinkTo();
+                return this;
+        },
+
+        updateLinkTo: function() {
+                var linkTo = this.model.get('link'),
+                        $input = this.$('.link-to-custom'),
+                        attachment = this.options.attachment;
+
+                if ( 'none' === linkTo || 'embed' === linkTo || ( ! attachment && 'custom' !== linkTo ) ) {
+                        $input.addClass( 'hidden' );
+                        return;
+                }
+
+                if ( attachment ) {
+                        if ( 'post' === linkTo ) {
+                                $input.val( attachment.get('link') );
+                        } else if ( 'file' === linkTo ) {
+                                $input.val( attachment.get('url') );
+                        } else if ( ! this.model.get('linkUrl') ) {
+                                $input.val('http://');
+                        }
+
+                        $input.prop( 'readonly', 'custom' !== linkTo );
+                }
+
+                $input.removeClass( 'hidden' );
+
+                // If the input is visible, focus and select its contents.
+                if ( ! wp.media.isTouchDevice && $input.is(':visible') ) {
+                        $input.focus()[0].select();
+                }
+        }
+});
+
+module.exports = AttachmentDisplay;
+ No newline at end of file

src/wp-includes/js/media/views/settings/gallery.js

@@ +1 @@
+/**
+ * wp.media.view.Settings.Gallery
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        Gallery;
+
+Gallery = Settings.extend({
+        className: 'collection-settings gallery-settings',
+        template:  wp.template('gallery-settings')
+});
+
+module.exports = Gallery;
+ No newline at end of file

src/wp-includes/js/media/views/settings/playlist.js

@@ +1 @@
+/**
+ * wp.media.view.Settings.Playlist
+ *
+ * @class
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Settings = require( '../settings.js' ),
+        Playlist;
+
+Playlist = Settings.extend({
+        className: 'collection-settings playlist-settings',
+        template:  wp.template('playlist-settings')
+});
+
+module.exports = Playlist;
+ No newline at end of file

src/wp-includes/js/media/views/settings.js

@@ +1 @@
+/**
+ * wp.media.view.Settings
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        $ = jQuery,
+        Settings;
+
+Settings = View.extend({
+        events: {
+                'click button':    'updateHandler',
+                'change input':    'updateHandler',
+                'change select':   'updateHandler',
+                'change textarea': 'updateHandler'
+        },
+
+        initialize: function() {
+                this.model = this.model || new Backbone.Model();
+                this.model.on( 'change', this.updateChanges, this );
+        },
+
+        prepare: function() {
+                return _.defaults({
+                        model: this.model.toJSON()
+                }, this.options );
+        },
+        /**
+         * @returns {wp.media.view.Settings} Returns itself to allow chaining
+         */
+        render: function() {
+                View.prototype.render.apply( this, arguments );
+                // Select the correct values.
+                _( this.model.attributes ).chain().keys().each( this.update, this );
+                return this;
+        },
+        /**
+         * @param {string} key
+         */
+        update: function( key ) {
+                var value = this.model.get( key ),
+                        $setting = this.$('[data-setting="' + key + '"]'),
+                        $buttons, $value;
+
+                // Bail if we didn't find a matching setting.
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Attempt to determine how the setting is rendered and update
+                // the selected value.
+
+                // Handle dropdowns.
+                if ( $setting.is('select') ) {
+                        $value = $setting.find('[value="' + value + '"]');
+
+                        if ( $value.length ) {
+                                $setting.find('option').prop( 'selected', false );
+                                $value.prop( 'selected', true );
+                        } else {
+                                // If we can't find the desired value, record what *is* selected.
+                                this.model.set( key, $setting.find(':selected').val() );
+                        }
+
+                // Handle button groups.
+                } else if ( $setting.hasClass('button-group') ) {
+                        $buttons = $setting.find('button').removeClass('active');
+                        $buttons.filter( '[value="' + value + '"]' ).addClass('active');
+
+                // Handle text inputs and textareas.
+                } else if ( $setting.is('input[type="text"], textarea') ) {
+                        if ( ! $setting.is(':focus') ) {
+                                $setting.val( value );
+                        }
+                // Handle checkboxes.
+                } else if ( $setting.is('input[type="checkbox"]') ) {
+                        $setting.prop( 'checked', !! value && 'false' !== value );
+                }
+        },
+        /**
+         * @param {Object} event
+         */
+        updateHandler: function( event ) {
+                var $setting = $( event.target ).closest('[data-setting]'),
+                        value = event.target.value,
+                        userSetting;
+
+                event.preventDefault();
+
+                if ( ! $setting.length ) {
+                        return;
+                }
+
+                // Use the correct value for checkboxes.
+                if ( $setting.is('input[type="checkbox"]') ) {
+                        value = $setting[0].checked;
+                }
+
+                // Update the corresponding setting.
+                this.model.set( $setting.data('setting'), value );
+
+                // If the setting has a corresponding user setting,
+                // update that as well.
+                if ( userSetting = $setting.data('userSetting') ) {
+                        setUserSetting( userSetting, value );
+                }
+        },
+
+        updateChanges: function( model ) {
+                if ( model.hasChanged() ) {
+                        _( model.changed ).chain().keys().each( this.update, this );
+                }
+        }
+});
+
+module.exports = Settings;
+ No newline at end of file

src/wp-includes/js/media/views/sidebar.js

@@ +1 @@
+/**
+ * wp.media.view.Sidebar
+ *
+ * @class
+ * @augments wp.media.view.PriorityList
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var PriorityList = require( './priority-list.js' ),
+        Sidebar;
+
+Sidebar = PriorityList.extend({
+        className: 'media-sidebar'
+});
+
+module.exports = Sidebar;
+ No newline at end of file

src/wp-includes/js/media/views/spinner.js

@@ +1 @@
+/**
+ * wp.media.view.Spinner
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Spinner;
+
+Spinner = View.extend({
+        tagName:   'span',
+        className: 'spinner',
+        spinnerTimeout: false,
+        delay: 400,
+
+        show: function() {
+                if ( ! this.spinnerTimeout ) {
+                        this.spinnerTimeout = _.delay(function( $el ) {
+                                $el.show();
+                        }, this.delay, this.$el );
+                }
+
+                return this;
+        },
+
+        hide: function() {
+                this.$el.hide();
+                this.spinnerTimeout = clearTimeout( this.spinnerTimeout );
+
+                return this;
+        }
+});
+
+module.exports = Spinner;
+ No newline at end of file

src/wp-includes/js/media/views/toolbar/embed.js

@@ +1 @@
+/**
+ * wp.media.view.Toolbar.Embed
+ *
+ * @class
+ * @augments wp.media.view.Toolbar.Select
+ * @augments wp.media.view.Toolbar
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Select = require( './select.js' ),
+        l10n = wp.media.view.l10n,
+        Embed;
+
+Embed = Select.extend({
+        initialize: function() {
+                _.defaults( this.options, {
+                        text: l10n.insertIntoPost,
+                        requires: false
+                });
+                // Call 'initialize' directly on the parent class.
+                Select.prototype.initialize.apply( this, arguments );
+        },
+
+        refresh: function() {
+                var url = this.controller.state().props.get('url');
+                this.get('select').model.set( 'disabled', ! url || url === 'http://' );
+                /**
+                 * call 'refresh' directly on the parent class
+                 */
+                Select.prototype.refresh.apply( this, arguments );
+        }
+});
+
+module.exports = Embed;
+ No newline at end of file

src/wp-includes/js/media/views/toolbar/select.js

@@ +1 @@
+/**
+ * wp.media.view.Toolbar.Select
+ *
+ * @class
+ * @augments wp.media.view.Toolbar
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var Toolbar = require( '../toolbar.js' ),
+        l10n = wp.media.view.l10n,
+        Select;
+
+Select = Toolbar.extend({
+        initialize: function() {
+                var options = this.options;
+
+                _.bindAll( this, 'clickSelect' );
+
+                _.defaults( options, {
+                        event: 'select',
+                        state: false,
+                        reset: true,
+                        close: true,
+                        text:  l10n.select,
+
+                        // Does the button rely on the selection?
+                        requires: {
+                                selection: true
+                        }
+                });
+
+                options.items = _.defaults( options.items || {}, {
+                        select: {
+                                style:    'primary',
+                                text:     options.text,
+                                priority: 80,
+                                click:    this.clickSelect,
+                                requires: options.requires
+                        }
+                });
+                // Call 'initialize' directly on the parent class.
+                Toolbar.prototype.initialize.apply( this, arguments );
+        },
+
+        clickSelect: function() {
+                var options = this.options,
+                        controller = this.controller;
+
+                if ( options.close ) {
+                        controller.close();
+                }
+
+                if ( options.event ) {
+                        controller.state().trigger( options.event );
+                }
+
+                if ( options.state ) {
+                        controller.setState( options.state );
+                }
+
+                if ( options.reset ) {
+                        controller.reset();
+                }
+        }
+});
+
+module.exports = Select;
+ No newline at end of file

src/wp-includes/js/media/views/toolbar.js

@@ +1 @@
+/**
+ * wp.media.view.Toolbar
+ *
+ * A toolbar which consists of a primary and a secondary section. Each sections
+ * can be filled with views.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( './view.js' ),
+        Button = require( './button.js' ),
+        PriorityList = require( './priority-list.js' ),
+        Toolbar;
+
+Toolbar = View.extend({
+        tagName:   'div',
+        className: 'media-toolbar',
+
+        initialize: function() {
+                var state = this.controller.state(),
+                        selection = this.selection = state.get('selection'),
+                        library = this.library = state.get('library');
+
+                this._views = {};
+
+                // The toolbar is composed of two `PriorityList` views.
+                this.primary   = new PriorityList();
+                this.secondary = new PriorityList();
+                this.primary.$el.addClass('media-toolbar-primary search-form');
+                this.secondary.$el.addClass('media-toolbar-secondary');
+
+                this.views.set([ this.secondary, this.primary ]);
+
+                if ( this.options.items ) {
+                        this.set( this.options.items, { silent: true });
+                }
+
+                if ( ! this.options.silent ) {
+                        this.render();
+                }
+
+                if ( selection ) {
+                        selection.on( 'add remove reset', this.refresh, this );
+                }
+
+                if ( library ) {
+                        library.on( 'add remove reset', this.refresh, this );
+                }
+        },
+        /**
+         * @returns {wp.media.view.Toolbar} Returns itsef to allow chaining
+         */
+        dispose: function() {
+                if ( this.selection ) {
+                        this.selection.off( null, null, this );
+                }
+
+                if ( this.library ) {
+                        this.library.off( null, null, this );
+                }
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                return View.prototype.dispose.apply( this, arguments );
+        },
+
+        ready: function() {
+                this.refresh();
+        },
+
+        /**
+         * @param {string} id
+         * @param {Backbone.View|Object} view
+         * @param {Object} [options={}]
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        set: function( id, view, options ) {
+                var list;
+                options = options || {};
+
+                // Accept an object with an `id` : `view` mapping.
+                if ( _.isObject( id ) ) {
+                        _.each( id, function( view, id ) {
+                                this.set( id, view, { silent: true });
+                        }, this );
+
+                } else {
+                        if ( ! ( view instanceof Backbone.View ) ) {
+                                view.classes = [ 'media-button-' + id ].concat( view.classes || [] );
+                                view = new Button( view ).render();
+                        }
+
+                        view.controller = view.controller || this.controller;
+
+                        this._views[ id ] = view;
+
+                        list = view.options.priority < 0 ? 'secondary' : 'primary';
+                        this[ list ].set( id, view, options );
+                }
+
+                if ( ! options.silent ) {
+                        this.refresh();
+                }
+
+                return this;
+        },
+        /**
+         * @param {string} id
+         * @returns {wp.media.view.Button}
+         */
+        get: function( id ) {
+                return this._views[ id ];
+        },
+        /**
+         * @param {string} id
+         * @param {Object} options
+         * @returns {wp.media.view.Toolbar} Returns itself to allow chaining
+         */
+        unset: function( id, options ) {
+                delete this._views[ id ];
+                this.primary.unset( id, options );
+                this.secondary.unset( id, options );
+
+                if ( ! options || ! options.silent ) {
+                        this.refresh();
+                }
+                return this;
+        },
+
+        refresh: function() {
+                var state = this.controller.state(),
+                        library = state.get('library'),
+                        selection = state.get('selection');
+
+                _.each( this._views, function( button ) {
+                        if ( ! button.model || ! button.options || ! button.options.requires ) {
+                                return;
+                        }
+
+                        var requires = button.options.requires,
+                                disabled = false;
+
+                        // Prevent insertion of attachments if any of them are still uploading
+                        disabled = _.some( selection.models, function( attachment ) {
+                                return attachment.get('uploading') === true;
+                        });
+
+                        if ( requires.selection && selection && ! selection.length ) {
+                                disabled = true;
+                        } else if ( requires.library && library && ! library.length ) {
+                                disabled = true;
+                        }
+                        button.model.set( 'disabled', disabled );
+                });
+        }
+});
+
+module.exports = Toolbar;
+ No newline at end of file

src/wp-includes/js/media/views/uploader/editor.js

@@ +1 @@
+/**
+ * Creates a dropzone on WP editor instances (elements with .wp-editor-wrap
+ * or #wp-fullscreen-body) and relays drag'n'dropped files to a media workflow.
+ *
+ * wp.media.view.EditorUploader
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        l10n = wp.media.view.l10n,
+        $ = jQuery,
+        EditorUploader;
+
+EditorUploader = View.extend({
+        tagName:   'div',
+        className: 'uploader-editor',
+        template:  wp.template( 'uploader-editor' ),
+
+        localDrag: false,
+        overContainer: false,
+        overDropzone: false,
+        draggingFile: null,
+
+        /**
+         * Bind drag'n'drop events to callbacks.
+         */
+        initialize: function() {
+                var self = this;
+
+                this.initialized = false;
+
+                // Bail if not enabled or UA does not support drag'n'drop or File API.
+                if ( ! window.tinyMCEPreInit || ! window.tinyMCEPreInit.dragDropUpload || ! this.browserSupport() ) {
+                        return this;
+                }
+
+                this.$document = $(document);
+                this.dropzones = [];
+                this.files = [];
+
+                this.$document.on( 'drop', '.uploader-editor', _.bind( this.drop, this ) );
+                this.$document.on( 'dragover', '.uploader-editor', _.bind( this.dropzoneDragover, this ) );
+                this.$document.on( 'dragleave', '.uploader-editor', _.bind( this.dropzoneDragleave, this ) );
+                this.$document.on( 'click', '.uploader-editor', _.bind( this.click, this ) );
+
+                this.$document.on( 'dragover', _.bind( this.containerDragover, this ) );
+                this.$document.on( 'dragleave', _.bind( this.containerDragleave, this ) );
+
+                this.$document.on( 'dragstart dragend drop', function( event ) {
+                        self.localDrag = event.type === 'dragstart';
+                });
+
+                this.initialized = true;
+                return this;
+        },
+
+        /**
+         * Check browser support for drag'n'drop.
+         *
+         * @return Boolean
+         */
+        browserSupport: function() {
+                var supports = false, div = document.createElement('div');
+
+                supports = ( 'draggable' in div ) || ( 'ondragstart' in div && 'ondrop' in div );
+                supports = supports && !! ( window.File && window.FileList && window.FileReader );
+                return supports;
+        },
+
+        isDraggingFile: function( event ) {
+                if ( this.draggingFile !== null ) {
+                        return this.draggingFile;
+                }
+
+                if ( _.isUndefined( event.originalEvent ) || _.isUndefined( event.originalEvent.dataTransfer ) ) {
+                        return false;
+                }
+
+                this.draggingFile = _.indexOf( event.originalEvent.dataTransfer.types, 'Files' ) > -1 &&
+                        _.indexOf( event.originalEvent.dataTransfer.types, 'text/plain' ) === -1;
+
+                return this.draggingFile;
+        },
+
+        refresh: function( e ) {
+                var dropzone_id;
+                for ( dropzone_id in this.dropzones ) {
+                        // Hide the dropzones only if dragging has left the screen.
+                        this.dropzones[ dropzone_id ].toggle( this.overContainer || this.overDropzone );
+                }
+
+                if ( ! _.isUndefined( e ) ) {
+                        $( e.target ).closest( '.uploader-editor' ).toggleClass( 'droppable', this.overDropzone );
+                }
+
+                if ( ! this.overContainer && ! this.overDropzone ) {
+                        this.draggingFile = null;
+                }
+
+                return this;
+        },
+
+        render: function() {
+                if ( ! this.initialized ) {
+                        return this;
+                }
+
+                View.prototype.render.apply( this, arguments );
+                $( '.wp-editor-wrap, #wp-fullscreen-body' ).each( _.bind( this.attach, this ) );
+                return this;
+        },
+
+        attach: function( index, editor ) {
+                // Attach a dropzone to an editor.
+                var dropzone = this.$el.clone();
+                this.dropzones.push( dropzone );
+                $( editor ).append( dropzone );
+                return this;
+        },
+
+        /**
+         * When a file is dropped on the editor uploader, open up an editor media workflow
+         * and upload the file immediately.
+         *
+         * @param  {jQuery.Event} event The 'drop' event.
+         */
+        drop: function( event ) {
+                var $wrap = null, uploadView;
+
+                this.containerDragleave( event );
+                this.dropzoneDragleave( event );
+
+                this.files = event.originalEvent.dataTransfer.files;
+                if ( this.files.length < 1 ) {
+                        return;
+                }
+
+                // Set the active editor to the drop target.
+                $wrap = $( event.target ).parents( '.wp-editor-wrap' );
+                if ( $wrap.length > 0 && $wrap[0].id ) {
+                        window.wpActiveEditor = $wrap[0].id.slice( 3, -5 );
+                }
+
+                if ( ! this.workflow ) {
+                        this.workflow = wp.media.editor.open( 'content', {
+                                frame:    'post',
+                                state:    'insert',
+                                title:    l10n.addMedia,
+                                multiple: true
+                        });
+                        uploadView = this.workflow.uploader;
+                        if ( uploadView.uploader && uploadView.uploader.ready ) {
+                                this.addFiles.apply( this );
+                        } else {
+                                this.workflow.on( 'uploader:ready', this.addFiles, this );
+                        }
+                } else {
+                        this.workflow.state().reset();
+                        this.addFiles.apply( this );
+                        this.workflow.open();
+                }
+
+                return false;
+        },
+
+        /**
+         * Add the files to the uploader.
+         */
+        addFiles: function() {
+                if ( this.files.length ) {
+                        this.workflow.uploader.uploader.uploader.addFile( _.toArray( this.files ) );
+                        this.files = [];
+                }
+                return this;
+        },
+
+        containerDragover: function( event ) {
+                if ( this.localDrag || ! this.isDraggingFile( event ) ) {
+                        return;
+                }
+
+                this.overContainer = true;
+                this.refresh();
+        },
+
+        containerDragleave: function() {
+                this.overContainer = false;
+
+                // Throttle dragleave because it's called when bouncing from some elements to others.
+                _.delay( _.bind( this.refresh, this ), 50 );
+        },
+
+        dropzoneDragover: function( event ) {
+                if ( this.localDrag || ! this.isDraggingFile( event ) ) {
+                        return;
+                }
+
+                this.overDropzone = true;
+                this.refresh( event );
+                return false;
+        },
+
+        dropzoneDragleave: function( e ) {
+                this.overDropzone = false;
+                _.delay( _.bind( this.refresh, this, e ), 50 );
+        },
+
+        click: function( e ) {
+                // In the rare case where the dropzone gets stuck, hide it on click.
+                this.containerDragleave( e );
+                this.dropzoneDragleave( e );
+                this.localDrag = false;
+        }
+});
+
+module.exports = EditorUploader;
+ No newline at end of file

src/wp-includes/js/media/views/uploader/inline.js

@@ +1 @@
+/**
+ * wp.media.view.UploaderInline
+ *
+ * The inline uploader that shows up in the 'Upload Files' tab.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatus = require( './status.js' ),
+        UploaderInline;
+
+UploaderInline = View.extend({
+        tagName:   'div',
+        className: 'uploader-inline',
+        template:  wp.template('uploader-inline'),
+
+        events: {
+                'click .close': 'hide'
+        },
+
+        initialize: function() {
+                _.defaults( this.options, {
+                        message: '',
+                        status:  true,
+                        canClose: false
+                });
+
+                if ( ! this.options.$browser && this.controller.uploader ) {
+                        this.options.$browser = this.controller.uploader.$browser;
+                }
+
+                if ( _.isUndefined( this.options.postId ) ) {
+                        this.options.postId = wp.media.view.settings.post.id;
+                }
+
+                if ( this.options.status ) {
+                        this.views.set( '.upload-inline-status', new UploaderStatus({
+                                controller: this.controller
+                        }) );
+                }
+        },
+
+        prepare: function() {
+                var suggestedWidth = this.controller.state().get('suggestedWidth'),
+                        suggestedHeight = this.controller.state().get('suggestedHeight'),
+                        data = {};
+
+                data.message = this.options.message;
+                data.canClose = this.options.canClose;
+
+                if ( suggestedWidth && suggestedHeight ) {
+                        data.suggestedWidth = suggestedWidth;
+                        data.suggestedHeight = suggestedHeight;
+                }
+
+                return data;
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        dispose: function() {
+                if ( this.disposing ) {
+                        /**
+                         * call 'dispose' directly on the parent class
+                         */
+                        return View.prototype.dispose.apply( this, arguments );
+                }
+
+                // Run remove on `dispose`, so we can be sure to refresh the
+                // uploader with a view-less DOM. Track whether we're disposing
+                // so we don't trigger an infinite loop.
+                this.disposing = true;
+                return this.remove();
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline} Returns itself to allow chaining
+         */
+        remove: function() {
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                var result = View.prototype.remove.apply( this, arguments );
+
+                _.defer( _.bind( this.refresh, this ) );
+                return result;
+        },
+
+        refresh: function() {
+                var uploader = this.controller.uploader;
+
+                if ( uploader ) {
+                        uploader.refresh();
+                }
+        },
+        /**
+         * @returns {wp.media.view.UploaderInline}
+         */
+        ready: function() {
+                var $browser = this.options.$browser,
+                        $placeholder;
+
+                if ( this.controller.uploader ) {
+                        $placeholder = this.$('.browser');
+
+                        // Check if we've already replaced the placeholder.
+                        if ( $placeholder[0] === $browser[0] ) {
+                                return;
+                        }
+
+                        $browser.detach().text( $placeholder.text() );
+                        $browser[0].className = $placeholder[0].className;
+                        $placeholder.replaceWith( $browser.show() );
+                }
+
+                this.refresh();
+                return this;
+        },
+        show: function() {
+                this.$el.removeClass( 'hidden' );
+        },
+        hide: function() {
+                this.$el.addClass( 'hidden' );
+        }
+
+});
+
+module.exports = UploaderInline;
+ No newline at end of file

src/wp-includes/js/media/views/uploader/status-error.js

@@ +1 @@
+/**
+ * wp.media.view.UploaderStatusError
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError;
+
+UploaderStatusError = View.extend({
+        className: 'upload-error',
+        template:  wp.template('uploader-status-error')
+});
+
+module.exports = UploaderStatusError;
+ No newline at end of file

src/wp-includes/js/media/views/uploader/status.js

@@ +1 @@
+/**
+ * wp.media.view.UploaderStatus
+ *
+ * An uploader status for on-going uploads.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = require( '../view.js' ),
+        UploaderStatusError = require( './status-error.js' ),
+        UploaderStatus;
+
+UploaderStatus = View.extend({
+        className: 'media-uploader-status',
+        template:  wp.template('uploader-status'),
+
+        events: {
+                'click .upload-dismiss-errors': 'dismiss'
+        },
+
+        initialize: function() {
+                this.queue = wp.Uploader.queue;
+                this.queue.on( 'add remove reset', this.visibility, this );
+                this.queue.on( 'add remove reset change:percent', this.progress, this );
+                this.queue.on( 'add remove reset change:uploading', this.info, this );
+
+                this.errors = wp.Uploader.errors;
+                this.errors.reset();
+                this.errors.on( 'add remove reset', this.visibility, this );
+                this.errors.on( 'add', this.error, this );
+        },
+        /**
+         * @global wp.Uploader
+         * @returns {wp.media.view.UploaderStatus}
+         */
+        dispose: function() {
+                wp.Uploader.queue.off( null, null, this );
+                /**
+                 * call 'dispose' directly on the parent class
+                 */
+                View.prototype.dispose.apply( this, arguments );
+                return this;
+        },
+
+        visibility: function() {
+                this.$el.toggleClass( 'uploading', !! this.queue.length );
+                this.$el.toggleClass( 'errors', !! this.errors.length );
+                this.$el.toggle( !! this.queue.length || !! this.errors.length );
+        },
+
+        ready: function() {
+                _.each({
+                        '$bar':      '.media-progress-bar div',
+                        '$index':    '.upload-index',
+                        '$total':    '.upload-total',
+                        '$filename': '.upload-filename'
+                }, function( selector, key ) {
+                        this[ key ] = this.$( selector );
+                }, this );
+
+                this.visibility();
+                this.progress();
+                this.info();
+        },
+
+        progress: function() {
+                var queue = this.queue,
+                        $bar = this.$bar;
+
+                if ( ! $bar || ! queue.length ) {
+                        return;
+                }
+
+                $bar.width( ( queue.reduce( function( memo, attachment ) {
+                        if ( ! attachment.get('uploading') ) {
+                                return memo + 100;
+                        }
+
+                        var percent = attachment.get('percent');
+                        return memo + ( _.isNumber( percent ) ? percent : 100 );
+                }, 0 ) / queue.length ) + '%' );
+        },
+
+        info: function() {
+                var queue = this.queue,
+                        index = 0, active;
+
+                if ( ! queue.length ) {
+                        return;
+                }
+
+                active = this.queue.find( function( attachment, i ) {
+                        index = i;
+                        return attachment.get('uploading');
+                });
+
+                this.$index.text( index + 1 );
+                this.$total.text( queue.length );
+                this.$filename.html( active ? this.filename( active.get('filename') ) : '' );
+        },
+        /**
+         * @param {string} filename
+         * @returns {string}
+         */
+        filename: function( filename ) {
+                return wp.media.truncate( _.escape( filename ), 24 );
+        },
+        /**
+         * @param {Backbone.Model} error
+         */
+        error: function( error ) {
+                this.views.add( '.upload-errors', new UploaderStatusError({
+                        filename: this.filename( error.get('file').name ),
+                        message:  error.get('message')
+                }), { at: 0 });
+        },
+
+        /**
+         * @global wp.Uploader
+         *
+         * @param {Object} event
+         */
+        dismiss: function( event ) {
+                var errors = this.views.get('.upload-errors');
+
+                event.preventDefault();
+
+                if ( errors ) {
+                        _.invoke( errors, 'remove' );
+                }
+                wp.Uploader.errors.reset();
+        }
+});
+
+module.exports = UploaderStatus;
+ No newline at end of file

src/wp-includes/js/media/views/uploader/window.js

@@ +1 @@
+/**
+ * wp.media.view.UploaderWindow
+ *
+ * An uploader window that allows for dragging and dropping media.
+ *
+ * @class
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ *
+ * @param {object} [options]                   Options hash passed to the view.
+ * @param {object} [options.uploader]          Uploader properties.
+ * @param {jQuery} [options.uploader.browser]
+ * @param {jQuery} [options.uploader.dropzone] jQuery collection of the dropzone.
+ * @param {object} [options.uploader.params]
+ */
+var View = require( '../view.js' ),
+        $ = jQuery,
+        UploaderWindow;
+
+UploaderWindow = View.extend({
+        tagName:   'div',
+        className: 'uploader-window',
+        template:  wp.template('uploader-window'),
+
+        initialize: function() {
+                var uploader;
+
+                this.$browser = $('<a href="#" class="browser" />').hide().appendTo('body');
+
+                uploader = this.options.uploader = _.defaults( this.options.uploader || {}, {
+                        dropzone:  this.$el,
+                        browser:   this.$browser,
+                        params:    {}
+                });
+
+                // Ensure the dropzone is a jQuery collection.
+                if ( uploader.dropzone && ! (uploader.dropzone instanceof $) ) {
+                        uploader.dropzone = $( uploader.dropzone );
+                }
+
+                this.controller.on( 'activate', this.refresh, this );
+
+                this.controller.on( 'detach', function() {
+                        this.$browser.remove();
+                }, this );
+        },
+
+        refresh: function() {
+                if ( this.uploader ) {
+                        this.uploader.refresh();
+                }
+        },
+
+        ready: function() {
+                var postId = wp.media.view.settings.post.id,
+                        dropzone;
+
+                // If the uploader already exists, bail.
+                if ( this.uploader ) {
+                        return;
+                }
+
+                if ( postId ) {
+                        this.options.uploader.params.post_id = postId;
+                }
+                this.uploader = new wp.Uploader( this.options.uploader );
+
+                dropzone = this.uploader.dropzone;
+                dropzone.on( 'dropzone:enter', _.bind( this.show, this ) );
+                dropzone.on( 'dropzone:leave', _.bind( this.hide, this ) );
+
+                $( this.uploader ).on( 'uploader:ready', _.bind( this._ready, this ) );
+        },
+
+        _ready: function() {
+                this.controller.trigger( 'uploader:ready' );
+        },
+
+        show: function() {
+                var $el = this.$el.show();
+
+                // Ensure that the animation is triggered by waiting until
+                // the transparent element is painted into the DOM.
+                _.defer( function() {
+                        $el.css({ opacity: 1 });
+                });
+        },
+
+        hide: function() {
+                var $el = this.$el.css({ opacity: 0 });
+
+                wp.media.transition( $el ).done( function() {
+                        // Transition end events are subject to race conditions.
+                        // Make sure that the value is set as intended.
+                        if ( '0' === $el.css('opacity') ) {
+                                $el.hide();
+                        }
+                });
+
+                // https://core.trac.wordpress.org/ticket/27341
+                _.delay( function() {
+                        if ( '0' === $el.css('opacity') && $el.is(':visible') ) {
+                                $el.hide();
+                        }
+                }, 500 );
+        }
+});
+
+module.exports = UploaderWindow;
+ No newline at end of file

src/wp-includes/js/media/views/video-details.js

@@ +1 @@
+/**
+ * wp.media.view.VideoDetails
+ *
+ * @constructor
+ * @augments wp.media.view.MediaDetails
+ * @augments wp.media.view.Settings.AttachmentDisplay
+ * @augments wp.media.view.Settings
+ * @augments wp.media.View
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var MediaDetails = require( './media-details' ),
+        VideoDetails;
+
+VideoDetails = MediaDetails.extend({
+        className: 'video-details',
+        template:  wp.template('video-details'),
+
+        setMedia: function() {
+                var video = this.$('.wp-video-shortcode');
+
+                if ( video.find( 'source' ).length ) {
+                        if ( video.is(':hidden') ) {
+                                video.show();
+                        }
+
+                        if ( ! video.hasClass('youtube-video') ) {
+                                this.media = MediaDetails.prepareSrc( video.get(0) );
+                        } else {
+                                this.media = video.get(0);
+                        }
+                } else {
+                        video.hide();
+                        this.media = false;
+                }
+
+                return this;
+        }
+});
+
+module.exports = VideoDetails;
+ No newline at end of file

src/wp-includes/js/media/views/view.js

@@ +1 @@
+/**
+ * wp.media.View
+ *
+ * The base view class for media.
+ *
+ * Undelegating events, removing events from the model, and
+ * removing events from the controller mirror the code for
+ * `Backbone.View.dispose` in Backbone 0.9.8 development.
+ *
+ * This behavior has since been removed, and should not be used
+ * outside of the media manager.
+ *
+ * @class
+ * @augments wp.Backbone.View
+ * @augments Backbone.View
+ */
+var View = wp.Backbone.View.extend({
+        constructor: function( options ) {
+                if ( options && options.controller ) {
+                        this.controller = options.controller;
+                }
+                wp.Backbone.View.apply( this, arguments );
+        },
+        /**
+         * @todo The internal comment mentions this might have been a stop-gap
+         *       before Backbone 0.9.8 came out. Figure out if Backbone core takes
+         *       care of this in Backbone.View now.
+         *
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        dispose: function() {
+                // Undelegating events, removing events from the model, and
+                // removing events from the controller mirror the code for
+                // `Backbone.View.dispose` in Backbone 0.9.8 development.
+                this.undelegateEvents();
+
+                if ( this.model && this.model.off ) {
+                        this.model.off( null, null, this );
+                }
+
+                if ( this.collection && this.collection.off ) {
+                        this.collection.off( null, null, this );
+                }
+
+                // Unbind controller events.
+                if ( this.controller && this.controller.off ) {
+                        this.controller.off( null, null, this );
+                }
+
+                return this;
+        },
+        /**
+         * @returns {wp.media.View} Returns itself to allow chaining
+         */
+        remove: function() {
+                this.dispose();
+                /**
+                 * call 'remove' directly on the parent class
+                 */
+                return wp.Backbone.View.prototype.remove.apply( this, arguments );
+        }
+});
+
+module.exports = View;
+ No newline at end of file

src/wp-includes/js/media/views.js

@@ +1 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/**
+ * wp.media.controller.CollectionAdd
+ *
+ * A state for adding attachments to a collection (e.g. video playlist).
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                         The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=library]      Unique identifier.
+ * @param {string}                     attributes.title                    Title for the state. Displays in the frame's title region.
+ * @param {boolean}                    [attributes.multiple=add]            Whether multi-select is enabled. @todo 'add' doesn't seem do anything special, and gets used as a boolean.
+ * @param {wp.media.model.Attachments} [attributes.library]                 The attachments collection to browse.
+ *                                                                          If one is not supplied, a collection of attachments of the specified type will be created.
+ * @param {boolean|string}             [attributes.filterable=uploaded]     Whether the library is filterable, and if so what filters should be shown.
+ *                                                                          Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {string}                     [attributes.menu=gallery]            Initial mode for the menu region.
+ * @param {string}                     [attributes.content=upload]          Initial mode for the content region.
+ *                                                                          Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=gallery-add]     Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {int}                        [attributes.priority=100]            The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]     Whether the Attachments selection should be persisted from the last state.
+ *                                                                          Defaults to false because for this state, because the library of the Edit Gallery state is the selection.
+ * @param {string}                     attributes.type                   The collection's media type. (e.g. 'video').
+ * @param {string}                     attributes.collectionType         The collection type. (e.g. 'playlist').
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        CollectionAdd;
+
+CollectionAdd = Library.extend({
+        defaults: _.defaults( {
+                // Selection defaults. @see media.model.Selection
+                multiple:      'add',
+                // Attachments browser defaults. @see media.view.AttachmentsBrowser
+                filterable:    'uploaded',
+
+                priority:      100,
+                syncSelection: false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         */
+        initialize: function() {
+                var collectionType = this.get('collectionType');
+
+                if ( 'video' === this.get( 'type' ) ) {
+                        collectionType = 'video-' + collectionType;
+                }
+
+                this.set( 'id', collectionType + '-library' );
+                this.set( 'toolbar', collectionType + '-add' );
+                this.set( 'menu', collectionType );
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query({ type: this.get('type') }) );
+                }
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                var library = this.get('library'),
+                        editLibrary = this.get('editLibrary'),
+                        edit = this.frame.state( this.get('collectionType') + '-edit' ).get('library');
+
+                if ( editLibrary && editLibrary !== edit ) {
+                        library.unobserve( editLibrary );
+                }
+
+                // Accepts attachments that exist in the original library and
+                // that do not exist in gallery's library.
+                library.validator = function( attachment ) {
+                        return !! this.mirroring.get( attachment.cid ) && ! edit.get( attachment.cid ) && Selection.prototype.validator.apply( this, arguments );
+                };
+
+                // Reset the library to ensure that all attachments are re-added
+                // to the collection. Do so silently, as calling `observe` will
+                // trigger the `reset` event.
+                library.reset( library.mirroring.models, { silent: true });
+                library.observe( edit );
+                this.set('editLibrary', edit);
+
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = CollectionAdd;
+},{"../models/selection.js":20,"./library.js":10}],2:[function(require,module,exports){
+/**
+ * wp.media.controller.CollectionEdit
+ *
+ * A state for editing a collection, which is used by audio and video playlists,
+ * and can be used for other collections.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                      The attributes hash passed to the state.
+ * @param {string}                     attributes.title                  Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]              The attachments collection to edit.
+ *                                                                       If one is not supplied, an empty media.model.Selection collection is created.
+ * @param {boolean}                    [attributes.multiple=false]       Whether multi-select is enabled.
+ * @param {string}                     [attributes.content=browse]       Initial mode for the content region.
+ * @param {string}                     attributes.menu                   Initial mode for the menu region. @todo this needs a better explanation.
+ * @param {boolean}                    [attributes.searchable=false]     Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]        Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.describe=true]        Whether to offer UI to describe the attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.dragInfo=true]        Whether to show instructional text about the attachments being sortable.
+ * @param {boolean}                    [attributes.dragInfoText]         Instructional text about the attachments being sortable.
+ * @param {int}                        [attributes.idealColumnWidth=170] The ideal column width in pixels for attachments.
+ * @param {boolean}                    [attributes.editing=false]        Whether the gallery is being created, or editing an existing instance.
+ * @param {int}                        [attributes.priority=60]          The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]  Whether the Attachments selection should be persisted from the last state.
+ *                                                                       Defaults to false for this state, because the library passed in  *is* the selection.
+ * @param {view}                       [attributes.SettingsView]         The view to edit the collection instance settings (e.g. Playlist settings with "Show tracklist" checkbox).
+ * @param {view}                       [attributes.AttachmentView]       The single `Attachment` view to be used in the `Attachments`.
+ *                                                                       If none supplied, defaults to wp.media.view.Attachment.EditLibrary.
+ * @param {string}                     attributes.type                   The collection's media type. (e.g. 'video').
+ * @param {string}                     attributes.collectionType         The collection type. (e.g. 'playlist').
+ */
+var SelectionModel = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        View = require( '../views/view.js' ),
+        EditLibraryView = require( '../views/attachment/edit-library.js' ),
+        l10n = wp.media.view.l10n,
+        CollectionEdit;
+
+CollectionEdit = Library.extend({
+        defaults: {
+                multiple:         false,
+                sortable:         true,
+                searchable:       false,
+                content:          'browse',
+                describe:         true,
+                dragInfo:         true,
+                idealColumnWidth: 170,
+                editing:          false,
+                priority:         60,
+                SettingsView:     false,
+                syncSelection:    false
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        initialize: function() {
+                var collectionType = this.get('collectionType');
+
+                if ( 'video' === this.get( 'type' ) ) {
+                        collectionType = 'video-' + collectionType;
+                }
+
+                this.set( 'id', collectionType + '-edit' );
+                this.set( 'toolbar', collectionType + '-edit' );
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', new SelectionModel() );
+                }
+                // The single `Attachment` view to be used in the `Attachments` view.
+                if ( ! this.get('AttachmentView') ) {
+                        this.set( 'AttachmentView', EditLibraryView );
+                }
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                var library = this.get('library');
+
+                // Limit the library to images only.
+                library.props.set( 'type', this.get( 'type' ) );
+
+                // Watch for uploaded attachments.
+                this.get('library').observe( wp.Uploader.queue );
+
+                this.frame.on( 'content:render:browse', this.renderSettings, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        deactivate: function() {
+                // Stop watching for uploaded attachments.
+                this.get('library').unobserve( wp.Uploader.queue );
+
+                this.frame.off( 'content:render:browse', this.renderSettings, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * Render the collection embed settings view in the browser sidebar.
+         *
+         * @todo This is against the pattern elsewhere in media. Typically the frame
+         *       is responsible for adding region mode callbacks. Explain.
+         *
+         * @since 3.9.0
+         *
+         * @param {wp.media.view.attachmentsBrowser} The attachments browser view.
+         */
+        renderSettings: function( attachmentsBrowserView ) {
+                var library = this.get('library'),
+                        collectionType = this.get('collectionType'),
+                        dragInfoText = this.get('dragInfoText'),
+                        SettingsView = this.get('SettingsView'),
+                        obj = {};
+
+                if ( ! library || ! attachmentsBrowserView ) {
+                        return;
+                }
+
+                library[ collectionType ] = library[ collectionType ] || new Backbone.Model();
+
+                obj[ collectionType ] = new SettingsView({
+                        controller: this,
+                        model:      library[ collectionType ],
+                        priority:   40
+                });
+
+                attachmentsBrowserView.sidebar.set( obj );
+
+                if ( dragInfoText ) {
+                        attachmentsBrowserView.toolbar.set( 'dragInfo', new View({
+                                el: $( '<div class="instructions">' + dragInfoText + '</div>' )[0],
+                                priority: -40
+                        }) );
+                }
+
+                // Add the 'Reverse order' button to the toolbar.
+                attachmentsBrowserView.toolbar.set( 'reverse', {
+                        text:     l10n.reverseOrder,
+                        priority: 80,
+
+                        click: function() {
+                                library.reset( library.toArray().reverse() );
+                        }
+                });
+        }
+});
+
+module.exports = CollectionEdit;
+},{"../models/selection.js":20,"../views/attachment/edit-library.js":30,"../views/view.js":76,"./library.js":10}],3:[function(require,module,exports){
+/**
+ * wp.media.controller.Cropper
+ *
+ * A state for cropping an image.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ */
+var State = require( './state.js' ),
+        ToolbarView = require( '../views/toolbar.js' ),
+        CropperView = require( '../views/cropper.js' ),
+        l10n = wp.media.view.l10n,
+        Cropper;
+
+Cropper = State.extend({
+        defaults: {
+                id:          'cropper',
+                title:       l10n.cropImage,
+                // Region mode defaults.
+                toolbar:     'crop',
+                content:     'crop',
+                router:      false,
+
+                canSkipCrop: false
+        },
+
+        activate: function() {
+                this.frame.on( 'content:create:crop', this.createCropContent, this );
+                this.frame.on( 'close', this.removeCropper, this );
+                this.set('selection', new Backbone.Collection(this.frame._selection.single));
+        },
+
+        deactivate: function() {
+                this.frame.toolbar.mode('browse');
+        },
+
+        createCropContent: function() {
+                this.cropperView = new CropperView({
+                        controller: this,
+                        attachment: this.get('selection').first()
+                });
+                this.cropperView.on('image-loaded', this.createCropToolbar, this);
+                this.frame.content.set(this.cropperView);
+
+        },
+        removeCropper: function() {
+                this.imgSelect.cancelSelection();
+                this.imgSelect.setOptions({remove: true});
+                this.imgSelect.update();
+                this.cropperView.remove();
+        },
+        createCropToolbar: function() {
+                var canSkipCrop, toolbarOptions;
+
+                canSkipCrop = this.get('canSkipCrop') || false;
+
+                toolbarOptions = {
+                        controller: this.frame,
+                        items: {
+                                insert: {
+                                        style:    'primary',
+                                        text:     l10n.cropImage,
+                                        priority: 80,
+                                        requires: { library: false, selection: false },
+
+                                        click: function() {
+                                                var self = this,
+                                                        selection = this.controller.state().get('selection').first();
+
+                                                selection.set({cropDetails: this.controller.state().imgSelect.getSelection()});
+
+                                                this.$el.text(l10n.cropping);
+                                                this.$el.attr('disabled', true);
+                                                this.controller.state().doCrop( selection ).done( function( croppedImage ) {
+                                                        self.controller.trigger('cropped', croppedImage );
+                                                        self.controller.close();
+                                                }).fail( function() {
+                                                        self.controller.trigger('content:error:crop');
+                                                });
+                                        }
+                                }
+                        }
+                };
+
+                if ( canSkipCrop ) {
+                        _.extend( toolbarOptions.items, {
+                                skip: {
+                                        style:      'secondary',
+                                        text:       l10n.skipCropping,
+                                        priority:   70,
+                                        requires:   { library: false, selection: false },
+                                        click:      function() {
+                                                var selection = this.controller.state().get('selection').first();
+                                                this.controller.state().cropperView.remove();
+                                                this.controller.trigger('skippedcrop', selection);
+                                                this.controller.close();
+                                        }
+                                }
+                        });
+                }
+
+                this.frame.toolbar.set( new ToolbarView(toolbarOptions) );
+        },
+
+        doCrop: function( attachment ) {
+                return wp.ajax.post( 'custom-header-crop', {
+                        nonce: attachment.get('nonces').edit,
+                        id: attachment.get('id'),
+                        cropDetails: attachment.get('cropDetails')
+                } );
+        }
+});
+
+module.exports = Cropper;
+},{"../views/cropper.js":39,"../views/toolbar.js":68,"./state.js":15}],4:[function(require,module,exports){
+/**
+ * wp.media.controller.EditImage
+ *
+ * A state for editing (cropping, etc.) an image.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                    attributes                      The attributes hash passed to the state.
+ * @param {wp.media.model.Attachment} attributes.model                The attachment.
+ * @param {string}                    [attributes.id=edit-image]      Unique identifier.
+ * @param {string}                    [attributes.title=Edit Image]   Title for the state. Displays in the media menu and the frame's title region.
+ * @param {string}                    [attributes.content=edit-image] Initial mode for the content region.
+ * @param {string}                    [attributes.toolbar=edit-image] Initial mode for the toolbar region.
+ * @param {string}                    [attributes.menu=false]         Initial mode for the menu region.
+ * @param {string}                    [attributes.url]                Unused. @todo Consider removal.
+ */
+var State = require( './state.js' ),
+        ToolbarView = require( '../views/toolbar.js' ),
+        l10n = wp.media.view.l10n,
+        EditImage;
+
+EditImage = State.extend({
+        defaults: {
+                id:      'edit-image',
+                title:   l10n.editImage,
+                menu:    false,
+                toolbar: 'edit-image',
+                content: 'edit-image',
+                url:     ''
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.listenTo( this.frame, 'toolbar:render:edit-image', this.toolbar );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        deactivate: function() {
+                this.stopListening( this.frame );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        toolbar: function() {
+                var frame = this.frame,
+                        lastState = frame.lastState(),
+                        previous = lastState && lastState.id;
+
+                frame.toolbar.set( new ToolbarView({
+                        controller: frame,
+                        items: {
+                                back: {
+                                        style: 'primary',
+                                        text:     l10n.back,
+                                        priority: 20,
+                                        click:    function() {
+                                                if ( previous ) {
+                                                        frame.setState( previous );
+                                                } else {
+                                                        frame.close();
+                                                }
+                                        }
+                                }
+                        }
+                }) );
+        }
+});
+
+module.exports = EditImage;
+},{"../views/toolbar.js":68,"./state.js":15}],5:[function(require,module,exports){
+/**
+ * wp.media.controller.Embed
+ *
+ * A state for embedding media from a URL.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object} attributes                         The attributes hash passed to the state.
+ * @param {string} [attributes.id=embed]              Unique identifier.
+ * @param {string} [attributes.title=Insert From URL] Title for the state. Displays in the media menu and the frame's title region.
+ * @param {string} [attributes.content=embed]         Initial mode for the content region.
+ * @param {string} [attributes.menu=default]          Initial mode for the menu region.
+ * @param {string} [attributes.toolbar=main-embed]    Initial mode for the toolbar region.
+ * @param {string} [attributes.menu=false]            Initial mode for the menu region.
+ * @param {int}    [attributes.priority=120]          The priority for the state link in the media menu.
+ * @param {string} [attributes.type=link]             The type of embed. Currently only link is supported.
+ * @param {string} [attributes.url]                   The embed URL.
+ * @param {object} [attributes.metadata={}]           Properties of the embed, which will override attributes.url if set.
+ */
+var State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Embed;
+
+Embed = State.extend({
+        defaults: {
+                id:       'embed',
+                title:    l10n.insertFromUrlTitle,
+                content:  'embed',
+                menu:     'default',
+                toolbar:  'main-embed',
+                priority: 120,
+                type:     'link',
+                url:      '',
+                metadata: {}
+        },
+
+        // The amount of time used when debouncing the scan.
+        sensitivity: 200,
+
+        initialize: function(options) {
+                this.metadata = options.metadata;
+                this.debouncedScan = _.debounce( _.bind( this.scan, this ), this.sensitivity );
+                this.props = new Backbone.Model( this.metadata || { url: '' });
+                this.props.on( 'change:url', this.debouncedScan, this );
+                this.props.on( 'change:url', this.refresh, this );
+                this.on( 'scan', this.scanImage, this );
+        },
+
+        /**
+         * Trigger a scan of the embedded URL's content for metadata required to embed.
+         *
+         * @fires wp.media.controller.Embed#scan
+         */
+        scan: function() {
+                var scanners,
+                        embed = this,
+                        attributes = {
+                                type: 'link',
+                                scanners: []
+                        };
+
+                // Scan is triggered with the list of `attributes` to set on the
+                // state, useful for the 'type' attribute and 'scanners' attribute,
+                // an array of promise objects for asynchronous scan operations.
+                if ( this.props.get('url') ) {
+                        this.trigger( 'scan', attributes );
+                }
+
+                if ( attributes.scanners.length ) {
+                        scanners = attributes.scanners = $.when.apply( $, attributes.scanners );
+                        scanners.always( function() {
+                                if ( embed.get('scanners') === scanners ) {
+                                        embed.set( 'loading', false );
+                                }
+                        });
+                } else {
+                        attributes.scanners = null;
+                }
+
+                attributes.loading = !! attributes.scanners;
+                this.set( attributes );
+        },
+        /**
+         * Try scanning the embed as an image to discover its dimensions.
+         *
+         * @param {Object} attributes
+         */
+        scanImage: function( attributes ) {
+                var frame = this.frame,
+                        state = this,
+                        url = this.props.get('url'),
+                        image = new Image(),
+                        deferred = $.Deferred();
+
+                attributes.scanners.push( deferred.promise() );
+
+                // Try to load the image and find its width/height.
+                image.onload = function() {
+                        deferred.resolve();
+
+                        if ( state !== frame.state() || url !== state.props.get('url') ) {
+                                return;
+                        }
+
+                        state.set({
+                                type: 'image'
+                        });
+
+                        state.props.set({
+                                width:  image.width,
+                                height: image.height
+                        });
+                };
+
+                image.onerror = deferred.reject;
+                image.src = url;
+        },
+
+        refresh: function() {
+                this.frame.toolbar.get().refresh();
+        },
+
+        reset: function() {
+                this.props.clear().set({ url: '' });
+
+                if ( this.active ) {
+                        this.refresh();
+                }
+        }
+});
+
+module.exports = Embed;
+},{"./state.js":15}],6:[function(require,module,exports){
+/**
+ * wp.media.controller.FeaturedImage
+ *
+ * A state for selecting a featured image for a post.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                          The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=featured-image]        Unique identifier.
+ * @param {string}                     [attributes.title=Set Featured Image] Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]                  The attachments collection to browse.
+ *                                                                           If one is not supplied, a collection of all images will be created.
+ * @param {boolean}                    [attributes.multiple=false]           Whether multi-select is enabled.
+ * @param {string}                     [attributes.content=upload]           Initial mode for the content region.
+ *                                                                           Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.menu=default]             Initial mode for the menu region.
+ * @param {string}                     [attributes.router=browse]            Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=featured-image]   Initial mode for the toolbar region.
+ * @param {int}                        [attributes.priority=60]              The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.searchable=true]          Whether the library is searchable.
+ * @param {boolean|string}             [attributes.filterable=false]         Whether the library is filterable, and if so what filters should be shown.
+ *                                                                           Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                    [attributes.sortable=true]            Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]          Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.describe=false]           Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.contentUserSetting=true]  Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                    [attributes.syncSelection=true]       Whether the Attachments selection should be persisted from the last state.
+ */
+var Attachment = require( '../models/attachment.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        FeaturedImage;
+
+FeaturedImage = Library.extend({
+        defaults: _.defaults({
+                id:            'featured-image',
+                title:         l10n.setFeaturedImageTitle,
+                multiple:      false,
+                filterable:    'uploaded',
+                toolbar:       'featured-image',
+                priority:      60,
+                syncSelection: true
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var library, comparator;
+
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query({ type: 'image' }) );
+                }
+
+                Library.prototype.initialize.apply( this, arguments );
+
+                library    = this.get('library');
+                comparator = library.comparator;
+
+                // Overload the library's comparator to push items that are not in
+                // the mirrored query to the front of the aggregate collection.
+                library.comparator = function( a, b ) {
+                        var aInQuery = !! this.mirroring.get( a.cid ),
+                                bInQuery = !! this.mirroring.get( b.cid );
+
+                        if ( ! aInQuery && bInQuery ) {
+                                return -1;
+                        } else if ( aInQuery && ! bInQuery ) {
+                                return 1;
+                        } else {
+                                return comparator.apply( this, arguments );
+                        }
+                };
+
+                // Add all items in the selection to the library, so any featured
+                // images that are not initially loaded still appear.
+                library.observe( this.get('selection') );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.updateSelection();
+                this.frame.on( 'open', this.updateSelection, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.frame.off( 'open', this.updateSelection, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        updateSelection: function() {
+                var selection = this.get('selection'),
+                        id = wp.media.view.settings.post.featuredImageId,
+                        attachment;
+
+                if ( '' !== id && -1 !== id ) {
+                        attachment = Attachment.get( id );
+                        attachment.fetch();
+                }
+
+                selection.reset( attachment ? [ attachment ] : [] );
+        }
+});
+
+module.exports = FeaturedImage;
+},{"../models/attachment.js":16,"./library.js":10}],7:[function(require,module,exports){
+/**
+ * A state for selecting more images to add to a gallery.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                         The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=gallery-library]      Unique identifier.
+ * @param {string}                     [attributes.title=Add to Gallery]    Title for the state. Displays in the frame's title region.
+ * @param {boolean}                    [attributes.multiple=add]            Whether multi-select is enabled. @todo 'add' doesn't seem do anything special, and gets used as a boolean.
+ * @param {wp.media.model.Attachments} [attributes.library]                 The attachments collection to browse.
+ *                                                                          If one is not supplied, a collection of all images will be created.
+ * @param {boolean|string}             [attributes.filterable=uploaded]     Whether the library is filterable, and if so what filters should be shown.
+ *                                                                          Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {string}                     [attributes.menu=gallery]            Initial mode for the menu region.
+ * @param {string}                     [attributes.content=upload]          Initial mode for the content region.
+ *                                                                          Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                     [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                     [attributes.toolbar=gallery-add]     Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                    [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                    [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {int}                        [attributes.priority=100]            The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]     Whether the Attachments selection should be persisted from the last state.
+ *                                                                          Defaults to false because for this state, because the library of the Edit Gallery state is the selection.
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        GalleryAdd;
+
+GalleryAdd = Library.extend({
+        defaults: _.defaults({
+                id:            'gallery-library',
+                title:         l10n.addToGalleryTitle,
+                multiple:      'add',
+                filterable:    'uploaded',
+                menu:          'gallery',
+                toolbar:       'gallery-add',
+                priority:      100,
+                syncSelection: false
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                // If a library wasn't supplied, create a library of images.
+                if ( ! this.get('library') )
+                        this.set( 'library', wp.media.query({ type: 'image' }) );
+
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                var library = this.get('library'),
+                        edit    = this.frame.state('gallery-edit').get('library');
+
+                if ( this.editLibrary && this.editLibrary !== edit )
+                        library.unobserve( this.editLibrary );
+
+                // Accepts attachments that exist in the original library and
+                // that do not exist in gallery's library.
+                library.validator = function( attachment ) {
+                        return !! this.mirroring.get( attachment.cid ) && ! edit.get( attachment.cid ) && Selection.prototype.validator.apply( this, arguments );
+                };
+
+                // Reset the library to ensure that all attachments are re-added
+                // to the collection. Do so silently, as calling `observe` will
+                // trigger the `reset` event.
+                library.reset( library.mirroring.models, { silent: true });
+                library.observe( edit );
+                this.editLibrary = edit;
+
+                Library.prototype.activate.apply( this, arguments );
+        }
+});
+
+module.exports = GalleryAdd;
+},{"../models/selection.js":20,"./library.js":10}],8:[function(require,module,exports){
+/**
+ * wp.media.controller.GalleryEdit
+ *
+ * A state for editing a gallery's images and settings.
+ *
+ * @class
+ * @augments wp.media.controller.Library
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                     [attributes]                       The attributes hash passed to the state.
+ * @param {string}                     [attributes.id=gallery-edit]       Unique identifier.
+ * @param {string}                     [attributes.title=Edit Gallery]    Title for the state. Displays in the frame's title region.
+ * @param {wp.media.model.Attachments} [attributes.library]               The collection of attachments in the gallery.
+ *                                                                        If one is not supplied, an empty media.model.Selection collection is created.
+ * @param {boolean}                    [attributes.multiple=false]        Whether multi-select is enabled.
+ * @param {boolean}                    [attributes.searchable=false]      Whether the library is searchable.
+ * @param {boolean}                    [attributes.sortable=true]         Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {string|false}               [attributes.content=browse]        Initial mode for the content region.
+ * @param {string|false}               [attributes.toolbar=image-details] Initial mode for the toolbar region.
+ * @param {boolean}                    [attributes.describe=true]         Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                    [attributes.displaySettings=true]  Whether to show the attachment display settings interface.
+ * @param {boolean}                    [attributes.dragInfo=true]         Whether to show instructional text about the attachments being sortable.
+ * @param {int}                        [attributes.idealColumnWidth=170]  The ideal column width in pixels for attachments.
+ * @param {boolean}                    [attributes.editing=false]         Whether the gallery is being created, or editing an existing instance.
+ * @param {int}                        [attributes.priority=60]           The priority for the state link in the media menu.
+ * @param {boolean}                    [attributes.syncSelection=false]   Whether the Attachments selection should be persisted from the last state.
+ *                                                                        Defaults to false for this state, because the library passed in  *is* the selection.
+ * @param {view}                       [attributes.AttachmentView]        The single `Attachment` view to be used in the `Attachments`.
+ *                                                                        If none supplied, defaults to wp.media.view.Attachment.EditLibrary.
+ */
+var Selection = require( '../models/selection.js' ),
+        Library = require( './library.js' ),
+        EditLibraryView = require( '../views/attachment/edit-library.js' ),
+        GallerySettingsView = require( '../views/settings/gallery.js' ),
+        l10n = wp.media.view.l10n,
+        GalleryEdit;
+
+GalleryEdit = Library.extend({
+        defaults: {
+                id:               'gallery-edit',
+                title:            l10n.editGalleryTitle,
+                multiple:         false,
+                searchable:       false,
+                sortable:         true,
+                display:          false,
+                content:          'browse',
+                toolbar:          'gallery-edit',
+                describe:         true,
+                displaySettings:  true,
+                dragInfo:         true,
+                idealColumnWidth: 170,
+                editing:          false,
+                priority:         60,
+                syncSelection:    false
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        initialize: function() {
+                // If we haven't been provided a `library`, create a `Selection`.
+                if ( ! this.get('library') )
+                        this.set( 'library', new Selection() );
+
+                // The single `Attachment` view to be used in the `Attachments` view.
+                if ( ! this.get('AttachmentView') )
+                        this.set( 'AttachmentView', EditLibraryView );
+                Library.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                var library = this.get('library');
+
+                // Limit the library to images only.
+                library.props.set( 'type', 'image' );
+
+                // Watch for uploaded attachments.
+                this.get('library').observe( wp.Uploader.queue );
+
+                this.frame.on( 'content:render:browse', this.gallerySettings, this );
+
+                Library.prototype.activate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                // Stop watching for uploaded attachments.
+                this.get('library').unobserve( wp.Uploader.queue );
+
+                this.frame.off( 'content:render:browse', this.gallerySettings, this );
+
+                Library.prototype.deactivate.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.5.0
+         *
+         * @param browser
+         */
+        gallerySettings: function( browser ) {
+                if ( ! this.get('displaySettings') ) {
+                        return;
+                }
+
+                var library = this.get('library');
+
+                if ( ! library || ! browser ) {
+                        return;
+                }
+
+                library.gallery = library.gallery || new Backbone.Model();
+
+                browser.sidebar.set({
+                        gallery: new GallerySettingsView({
+                                controller: this,
+                                model:      library.gallery,
+                                priority:   40
+                        })
+                });
+
+                browser.toolbar.set( 'reverse', {
+                        text:     l10n.reverseOrder,
+                        priority: 80,
+
+                        click: function() {
+                                library.reset( library.toArray().reverse() );
+                        }
+                });
+        }
+});
+
+module.exports = GalleryEdit;
+},{"../models/selection.js":20,"../views/attachment/edit-library.js":30,"../views/settings/gallery.js":64,"./library.js":10}],9:[function(require,module,exports){
+/**
+ * wp.media.controller.ImageDetails
+ *
+ * A state for editing the attachment display settings of an image that's been
+ * inserted into the editor.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ *
+ * @param {object}                    [attributes]                       The attributes hash passed to the state.
+ * @param {string}                    [attributes.id=image-details]      Unique identifier.
+ * @param {string}                    [attributes.title=Image Details]   Title for the state. Displays in the frame's title region.
+ * @param {wp.media.model.Attachment} attributes.image                   The image's model.
+ * @param {string|false}              [attributes.content=image-details] Initial mode for the content region.
+ * @param {string|false}              [attributes.menu=false]            Initial mode for the menu region.
+ * @param {string|false}              [attributes.router=false]          Initial mode for the router region.
+ * @param {string|false}              [attributes.toolbar=image-details] Initial mode for the toolbar region.
+ * @param {boolean}                   [attributes.editing=false]         Unused.
+ * @param {int}                       [attributes.priority=60]           Unused.
+ *
+ * @todo This state inherits some defaults from media.controller.Library.prototype.defaults,
+ *       however this may not do anything.
+ */
+var State = require( './state.js' ),
+        Library = require( './library.js' ),
+        l10n = wp.media.view.l10n,
+        ImageDetails;
+
+ImageDetails = State.extend({
+        defaults: _.defaults({
+                id:       'image-details',
+                title:    l10n.imageDetailsTitle,
+                content:  'image-details',
+                menu:     false,
+                router:   false,
+                toolbar:  'image-details',
+                editing:  false,
+                priority: 60
+        }, Library.prototype.defaults ),
+
+        /**
+         * @since 3.9.0
+         *
+         * @param options Attributes
+         */
+        initialize: function( options ) {
+                this.image = options.image;
+                State.prototype.initialize.apply( this, arguments );
+        },
+
+        /**
+         * @since 3.9.0
+         */
+        activate: function() {
+                this.frame.modal.$el.addClass('image-details');
+        }
+});
+
+module.exports = ImageDetails;
+},{"./library.js":10,"./state.js":15}],10:[function(require,module,exports){
+/**
+ * wp.media.controller.Library
+ *
+ * A state for choosing an attachment or group of attachments from the media library.
+ *
+ * @class
+ * @augments wp.media.controller.State
+ * @augments Backbone.Model
+ * @mixes media.selectionSync
+ *
+ * @param {object}                          [attributes]                         The attributes hash passed to the state.
+ * @param {string}                          [attributes.id=library]              Unique identifier.
+ * @param {string}                          [attributes.title=Media library]     Title for the state. Displays in the media menu and the frame's title region.
+ * @param {wp.media.model.Attachments}      [attributes.library]                 The attachments collection to browse.
+ *                                                                               If one is not supplied, a collection of all attachments will be created.
+ * @param {wp.media.model.Selection|object} [attributes.selection]               A collection to contain attachment selections within the state.
+ *                                                                               If the 'selection' attribute is a plain JS object,
+ *                                                                               a Selection will be created using its values as the selection instance's `props` model.
+ *                                                                               Otherwise, it will copy the library's `props` model.
+ * @param {boolean}                         [attributes.multiple=false]          Whether multi-select is enabled.
+ * @param {string}                          [attributes.content=upload]          Initial mode for the content region.
+ *                                                                               Overridden by persistent user setting if 'contentUserSetting' is true.
+ * @param {string}                          [attributes.menu=default]            Initial mode for the menu region.
+ * @param {string}                          [attributes.router=browse]           Initial mode for the router region.
+ * @param {string}                          [attributes.toolbar=select]          Initial mode for the toolbar region.
+ * @param {boolean}                         [attributes.searchable=true]         Whether the library is searchable.
+ * @param {boolean|string}                  [attributes.filterable=false]        Whether the library is filterable, and if so what filters should be shown.
+ *                                                                               Accepts 'all', 'uploaded', or 'unattached'.
+ * @param {boolean}                         [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.
+ * @param {boolean}                         [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.
+ * @param {boolean}                         [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.
+ * @param {boolean}                         [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.
+ * @param {boolean}                         [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.
+ */
+var selectionSync = require( '../utils/selection-sync.js' ),
+        SelectionModel = require( '../models/selection.js' ),
+        State = require( './state.js' ),
+        l10n = wp.media.view.l10n,
+        Library;
+
+Library = State.extend({
+        defaults: {
+                id:                 'library',
+                title:              l10n.mediaLibraryTitle,
+                multiple:           false,
+                content:            'upload',
+                menu:               'default',
+                router:             'browse',
+                toolbar:            'select',
+                searchable:         true,
+                filterable:         false,
+                sortable:           true,
+                autoSelect:         true,
+                describe:           false,
+                contentUserSetting: true,
+                syncSelection:      true
+        },
+
+        /**
+         * If a library isn't provided, query all media items.
+         * If a selection instance isn't provided, create one.
+         *
+         * @since 3.5.0
+         */
+        initialize: function() {
+                var selection = this.get('selection'),
+                        props;
+
+                if ( ! this.get('library') ) {
+                        this.set( 'library', wp.media.query() );
+                }
+
+                if ( ! (selection instanceof SelectionModel) ) {
+                        props = selection;
+
+                        if ( ! props ) {
+                                props = this.get('library').props.toJSON();
+                                props = _.omit( props, 'orderby', 'query' );
+                        }
+
+                        this.set( 'selection', new SelectionModel( null, {
+                                multiple: this.get('multiple'),
+                                props: props
+                        }) );
+                }
+
+                this.resetDisplays();
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        activate: function() {
+                this.syncSelection();
+
+                wp.Uploader.queue.on( 'add', this.uploading, this );
+
+                this.get('selection').on( 'add remove reset', this.refreshContent, this );
+
+                if ( this.get( 'router' ) && this.get('contentUserSetting') ) {
+                        this.frame.on( 'content:activate', this.saveContentMode, this );
+                        this.set( 'content', getUserSetting( 'libraryContent', this.get('content') ) );
+                }
+        },
+
+        /**
+         * @since 3.5.0
+         */
+        deactivate: function() {
+                this.recordSelection();
+
+                this.frame.off( 'content:activate', this.saveContentMode, this );
+
+                // Unbind all event handlers that use this state as the context
+                // from the selection.
+                this.get('selection').off( null, null, this );
+
+                wp.Uploader.queue.off( null, null, this );
+        },
+
+        /**
+         * Reset the library to its initial state.
+         *
+         * @since 3.5.0
+         */
+        reset: function() {
+                this.get('selection').reset();
+                this.resetDisplays();
+                this.refreshContent();
+        },
+
+        /**
+         * Reset the attachment display settings defaults to the site options.
+         *
+         * If site options don't define them, fall back to a persistent user setting.
+         *
+         * @since 3.5.0
+         */
+        resetDisplays: function() {
+                var defaultProps = wp.media.view.settings.defaultProps;
+                this._displays = [];
+                this._defaultDisplaySettings = {
+                        align: defaultProps.align || getUserSetting( 'align', 'none' ),
+                        size:  defaultProps.size  || getUserSetting( 'imgsize', 'medium' ),
+                        link:  defaultProps.link  || getUserSetting( 'urlbutton', 'file' )
+                };
+        },
+
+        /**
+         * Create a model to represent display settings (alignment, etc.) for an attachment.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Backbone.Model}
+         */
+        display: function( attachment ) {
+                var displays = this._displays;
+
+                if ( ! displays[ attachment.cid ] ) {
+                        displays[ attachment.cid ] = new Backbone.Model( this.defaultDisplaySettings( attachment ) );
+                }
+                return displays[ attachment.cid ];
+        },
+
+        /**
+         * Given an attachment, create attachment display settings properties.
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Object}
+         */
+        defaultDisplaySettings: function( attachment ) {
+                var settings = this._defaultDisplaySettings;
+                if ( settings.canEmbed = this.canEmbed( attachment ) ) {
+                        settings.link = 'embed';
+                }
+                return settings;
+        },
+
+        /**
+         * Whether an attachment can be embedded (audio or video).
+         *
+         * @since 3.6.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         * @returns {Boolean}
+         */
+        canEmbed: function( attachment ) {
+                // If uploading, we know the filename but not the mime type.
+                if ( ! attachment.get('uploading') ) {
+                        var type = attachment.get('type');
+                        if ( type !== 'audio' && type !== 'video' ) {
+                                return false;
+                        }
+                }
+
+                return _.contains( wp.media.view.settings.embedExts, attachment.get('filename').split('.').pop() );
+        },
+
+
+        /**
+         * If the state is active, no items are selected, and the current
+         * content mode is not an option in the state's router (provided
+         * the state has a router), reset the content mode to the default.
+         *
+         * @since 3.5.0
+         */
+        refreshContent: function() {
+                var selection = this.get('selection'),
+                        frame = this.frame,
+                        router = frame.router.get(),
+                        mode = frame.content.mode();
+
+                if ( this.active && ! selection.length && router && ! router.get( mode ) ) {
+                        this.frame.content.render( this.get('content') );
+                }
+        },
+
+        /**
+         * Callback handler when an attachment is uploaded.
+         *
+         * Switch to the Media Library if uploaded from the 'Upload Files' tab.
+         *
+         * Adds any uploading attachments to the selection.
+         *
+         * If the state only supports one attachment to be selected and multiple
+         * attachments are uploaded, the last attachment in the upload queue will
+         * be selected.
+         *
+         * @since 3.5.0
+         *
+         * @param {wp.media.model.Attachment} attachment
+         */
+        uploading: function( attachment ) {
+                var content = this.frame.content;
+
+                if ( 'upload' === content.mode() ) {
+                        this.frame.content.mode('browse');
+                }
+
+                if ( this.get( 'autoSelect' ) ) {
+                        this.get('selection').add( attachment );
+                        this.frame.trigger( 'library:selection:add' );
+                }
+        },
+
+        /**
+         * Persist the mode of the content region as a user setting.
+         *
+         * @since 3.5.0
+         */
+        saveContentMode: function() {
+                if ( 'browse' !== this.get('router') ) {
+                        return;
+                }
+
+                var mode = this.frame.content.mode(),
+                        view = this.frame.router.get();
+
+                if ( view && view.get( mode ) ) {
+                        setUserSetting( 'libraryContent', mode );
+                }
+        }
+});
+
+// Make selectionSync available on any Media Library state.
+_.extend( Library.prototype, selectionSync );
+
+module.exports = Library;
+},{"../models/selection.js":20,"../utils/selection-sync.js":21,"./state.js":15}],11:[function(require,module,exports){
+/**
+ * wp.media.controller.MediaLibrary
+ *