84 /******/ 	return __webpack_require__(__webpack_require__.s = 29);

    84 /******/ 	return __webpack_require__(__webpack_require__.s = 3);

    87 /******/ (Array(29).concat([

    87 /******/ ({

    88 /* 29 */

    88 

    89 /***/ (function(module, exports, __webpack_require__) {

    89 /***/ "+B8m":

    90 

    90 /***/ (function(module, exports) {

    91 module.exports = __webpack_require__(30);

    91 

    92 

    92 var AttachmentDisplay = wp.media.view.Settings.AttachmentDisplay,

    93 

    93 	EmbedImage;

    94 /***/ }),

    95 /* 30 */

    96 /***/ (function(module, exports, __webpack_require__) {

    99  * @output wp-includes/js/media-views.js

    96  * wp.media.view.EmbedImage

    97  *

    98  * @memberOf wp.media.view

    99  *

   100  * @class

   101  * @augments wp.media.view.Settings.AttachmentDisplay

   102  * @augments wp.media.view.Settings

   103  * @augments wp.media.View

   104  * @augments wp.Backbone.View

   105  * @augments Backbone.View

   101 

   107 EmbedImage = AttachmentDisplay.extend(/** @lends wp.media.view.EmbedImage.prototype */{

   102 var media = wp.media,

   108 	className: 'embed-media-settings',

   103 	$ = jQuery,

   109 	template:  wp.template('embed-image-settings'),

   104 	l10n;

   110 

   105 

   111 	initialize: function() {

   106 media.isTouchDevice = ( 'ontouchend' in document );

   107 

   108 // Link any localized strings.

   109 l10n = media.view.l10n = window._wpMediaViewsL10n || {};

   110 

   111 // Link any settings.

   112 media.view.settings = l10n.settings || {};

   113 delete l10n.settings;

   114 

   115 // Copy the `post` setting over to the model settings.

   116 media.model.settings.post = media.view.settings.post;

   117 

   118 // Check if the browser supports CSS 3.0 transitions.

   119 $.support.transition = (function(){

   120 	var style = document.documentElement.style,

   121 		transitions = {

   122 			WebkitTransition: 'webkitTransitionEnd',

   123 			MozTransition:    'transitionend',

   124 			OTransition:      'oTransitionEnd otransitionend',

   125 			transition:       'transitionend'

   126 		}, transition;

   127 

   128 	transition = _.find( _.keys( transitions ), function( transition ) {

   129 		return ! _.isUndefined( style[ transition ] );

   130 	});

   131 

   132 	return transition && {

   133 		end: transitions[ transition ]

   134 	};

   135 }());

   136 

   137 /**

   138  * A shared event bus used to provide events into

   139  * the media workflows that 3rd-party devs can use to hook

   140  * in.

   141  */

   142 media.events = _.extend( {}, Backbone.Events );

   143 

   144 /**

   145  * Makes it easier to bind events using transitions.

   146  *

   147  * @param {string} selector

   148  * @param {number} sensitivity

   149  * @return {Promise}

   150  */

   151 media.transition = function( selector, sensitivity ) {

   152 	var deferred = $.Deferred();

   153 

   154 	sensitivity = sensitivity || 2000;

   155 

   156 	if ( $.support.transition ) {

   157 		if ( ! (selector instanceof $) ) {

   158 			selector = $( selector );

   159 		}

   160 

   161 		// Resolve the deferred when the first element finishes animating.

   162 		selector.first().one( $.support.transition.end, deferred.resolve );

   163 

   164 		// Just in case the event doesn't trigger, fire a callback.

   165 		_.delay( deferred.resolve, sensitivity );

   166 

   167 	// Otherwise, execute on the spot.

   168 	} else {

   169 		deferred.resolve();

   170 	}

   171 

   172 	return deferred.promise();

   173 };

   174 

   175 media.controller.Region = __webpack_require__( 31 );

   176 media.controller.StateMachine = __webpack_require__( 32 );

   177 media.controller.State = __webpack_require__( 33 );

   178 

   179 media.selectionSync = __webpack_require__( 34 );

   180 media.controller.Library = __webpack_require__( 35 );

   181 media.controller.ImageDetails = __webpack_require__( 36 );

   182 media.controller.GalleryEdit = __webpack_require__( 37 );

   183 media.controller.GalleryAdd = __webpack_require__( 38 );

   184 media.controller.CollectionEdit = __webpack_require__( 39 );

   185 media.controller.CollectionAdd = __webpack_require__( 40 );

   186 media.controller.FeaturedImage = __webpack_require__( 41 );

   187 media.controller.ReplaceImage = __webpack_require__( 42 );

   188 media.controller.EditImage = __webpack_require__( 43 );

   189 media.controller.MediaLibrary = __webpack_require__( 44 );

   190 media.controller.Embed = __webpack_require__( 45 );

   191 media.controller.Cropper = __webpack_require__( 46 );

   192 media.controller.CustomizeImageCropper = __webpack_require__( 47 );

   193 media.controller.SiteIconCropper = __webpack_require__( 48 );

   194 

   195 media.View = __webpack_require__( 49 );

   196 media.view.Frame = __webpack_require__( 50 );

   197 media.view.MediaFrame = __webpack_require__( 51 );

   198 media.view.MediaFrame.Select = __webpack_require__( 52 );

   199 media.view.MediaFrame.Post = __webpack_require__( 53 );

   200 media.view.MediaFrame.ImageDetails = __webpack_require__( 54 );

   201 media.view.Modal = __webpack_require__( 55 );

   202 media.view.FocusManager = __webpack_require__( 56 );

   203 media.view.UploaderWindow = __webpack_require__( 57 );

   204 media.view.EditorUploader = __webpack_require__( 58 );

   205 media.view.UploaderInline = __webpack_require__( 59 );

   206 media.view.UploaderStatus = __webpack_require__( 60 );

   207 media.view.UploaderStatusError = __webpack_require__( 61 );

   208 media.view.Toolbar = __webpack_require__( 62 );

   209 media.view.Toolbar.Select = __webpack_require__( 63 );

   210 media.view.Toolbar.Embed = __webpack_require__( 64 );

   211 media.view.Button = __webpack_require__( 65 );

   212 media.view.ButtonGroup = __webpack_require__( 66 );

   213 media.view.PriorityList = __webpack_require__( 67 );

   214 media.view.MenuItem = __webpack_require__( 68 );

   215 media.view.Menu = __webpack_require__( 69 );

   216 media.view.RouterItem = __webpack_require__( 70 );

   217 media.view.Router = __webpack_require__( 71 );

   218 media.view.Sidebar = __webpack_require__( 72 );

   219 media.view.Attachment = __webpack_require__( 73 );

   220 media.view.Attachment.Library = __webpack_require__( 74 );

   221 media.view.Attachment.EditLibrary = __webpack_require__( 75 );

   222 media.view.Attachments = __webpack_require__( 76 );

   223 media.view.Search = __webpack_require__( 77 );

   224 media.view.AttachmentFilters = __webpack_require__( 78 );

   225 media.view.DateFilter = __webpack_require__( 79 );

   226 media.view.AttachmentFilters.Uploaded = __webpack_require__( 80 );

   227 media.view.AttachmentFilters.All = __webpack_require__( 81 );

   228 media.view.AttachmentsBrowser = __webpack_require__( 82 );

   229 media.view.Selection = __webpack_require__( 83 );

   230 media.view.Attachment.Selection = __webpack_require__( 84 );

   231 media.view.Attachments.Selection = __webpack_require__( 85 );

   232 media.view.Attachment.EditSelection = __webpack_require__( 86 );

   233 media.view.Settings = __webpack_require__( 87 );

   234 media.view.Settings.AttachmentDisplay = __webpack_require__( 88 );

   235 media.view.Settings.Gallery = __webpack_require__( 89 );

   236 media.view.Settings.Playlist = __webpack_require__( 90 );

   237 media.view.Attachment.Details = __webpack_require__( 91 );

   238 media.view.AttachmentCompat = __webpack_require__( 92 );

   239 media.view.Iframe = __webpack_require__( 93 );

   240 media.view.Embed = __webpack_require__( 94 );

   241 media.view.Label = __webpack_require__( 95 );

   242 media.view.EmbedUrl = __webpack_require__( 96 );

   243 media.view.EmbedLink = __webpack_require__( 97 );

   244 media.view.EmbedImage = __webpack_require__( 98 );

   245 media.view.ImageDetails = __webpack_require__( 99 );

   246 media.view.Cropper = __webpack_require__( 100 );

   247 media.view.SiteIconCropper = __webpack_require__( 101 );

   248 media.view.SiteIconPreview = __webpack_require__( 102 );

   249 media.view.EditImage = __webpack_require__( 103 );

   250 media.view.Spinner = __webpack_require__( 104 );

   251 media.view.Heading = __webpack_require__( 105 );

   252 

   253 

   254 /***/ }),

   255 /* 31 */

   256 /***/ (function(module, exports) {

   257 

   258 /**

   259  * wp.media.controller.Region

   260  *

   261  * A region is a persistent application layout area.

   262  *

   263  * A region assumes one mode at any time, and can be switched to another.

   264  *

   265  * When mode changes, events are triggered on the region's parent view.

   266  * The parent view will listen to specific events and fill the region with an

   267  * appropriate view depending on mode. For example, a frame listens for the

   268  * 'browse' mode t be activated on the 'content' view and then fills the region

   269  * with an AttachmentsBrowser view.

   270  *

   271  * @memberOf wp.media.controller

   272  *

   273  * @class

   274  *

   275  * @param {Object}        options          Options hash for the region.

   276  * @param {string}        options.id       Unique identifier for the region.

   277  * @param {Backbone.View} options.view     A parent view the region exists within.

   278  * @param {string}        options.selector jQuery selector for the region within the parent view.

   279  */

   280 var Region = function( options ) {

   281 	_.extend( this, _.pick( options || {}, 'id', 'view', 'selector' ) );

   282 };

   283 

   284 // Use Backbone's self-propagating `extend` inheritance method.

   285 Region.extend = Backbone.Model.extend;

   286 

   287 _.extend( Region.prototype,/** @lends wp.media.controller.Region.prototype */{

   288 	/**

   289 	 * Activate a mode.

   290 	 *

   291 	 * @since 3.5.0

   292 	 *

   293 	 * @param {string} mode

   294 	 *

   295 	 * @fires Region#activate

   296 	 * @fires Region#deactivate

   297 	 *

   298 	 * @return {wp.media.controller.Region} Returns itself to allow chaining.

   299 	 */

   300 	mode: function( mode ) {

   301 		if ( ! mode ) {

   302 			return this._mode;

   303 		}

   304 		// Bail if we're trying to change to the current mode.

   305 		if ( mode === this._mode ) {

   306 			return this;

   307 		}

   308 

   310 		 * Region mode deactivation event.

   113 		 * Call `initialize` directly on parent class with passed arguments

   311 		 *

   312 		 * @event wp.media.controller.Region#deactivate

   314 		this.trigger('deactivate');

   115 		AttachmentDisplay.prototype.initialize.apply( this, arguments );

   315 

   116 		this.listenTo( this.model, 'change:url', this.updateImage );

   316 		this._mode = mode;

   117 	},

   317 		this.render( mode );

   118 

   318 

   119 	updateImage: function() {

   319 		/**

   120 		this.$('img').attr( 'src', this.model.get('url') );

   320 		 * Region mode activation event.

   321 		 *

   322 		 * @event wp.media.controller.Region#activate

   323 		 */

   324 		this.trigger('activate');

   325 		return this;

   326 	},

   327 	/**

   328 	 * Render a mode.

   329 	 *

   330 	 * @since 3.5.0

   331 	 *

   332 	 * @param {string} mode

   333 	 *

   334 	 * @fires Region#create

   335 	 * @fires Region#render

   336 	 *

   337 	 * @return {wp.media.controller.Region} Returns itself to allow chaining.

   338 	 */

   339 	render: function( mode ) {

   340 		// If the mode isn't active, activate it.

   341 		if ( mode && mode !== this._mode ) {

   342 			return this.mode( mode );

   343 		}

   344 

   345 		var set = { view: null },

   346 			view;

   347 

   348 		/**

   349 		 * Create region view event.

   350 		 *

   351 		 * Region view creation takes place in an event callback on the frame.

   352 		 *

   353 		 * @event wp.media.controller.Region#create

   354 		 * @type {object}

   355 		 * @property {object} view

   356 		 */

   357 		this.trigger( 'create', set );

   358 		view = set.view;

   359 

   360 		/**

   361 		 * Render region view event.

   362 		 *

   363 		 * Region view creation takes place in an event callback on the frame.

   364 		 *

   365 		 * @event wp.media.controller.Region#render

   366 		 * @type {object}

   367 		 */

   368 		this.trigger( 'render', view );

   369 		if ( view ) {

   370 			this.set( view );

   371 		}

   372 		return this;

   373 	},

   374 

   375 	/**

   376 	 * Get the region's view.

   377 	 *

   378 	 * @since 3.5.0

   379 	 *

   380 	 * @return {wp.media.View}

   381 	 */

   382 	get: function() {

   383 		return this.view.views.first( this.selector );

   384 	},

   385 

   386 	/**

   387 	 * Set the region's view as a subview of the frame.

   388 	 *

   389 	 * @since 3.5.0

   390 	 *

   391 	 * @param {Array|Object} views

   392 	 * @param {Object} [options={}]

   393 	 * @return {wp.Backbone.Subviews} Subviews is returned to allow chaining.

   394 	 */

   395 	set: function( views, options ) {

   396 		if ( options ) {

   397 			options.add = false;

   398 		}

   399 		return this.view.views.set( this.selector, views, options );

   400 	},

   401 

   402 	/**

   403 	 * Trigger regional view events on the frame.

   404 	 *

   405 	 * @since 3.5.0

   406 	 *

   407 	 * @param {string} event

   408 	 * @return {undefined|wp.media.controller.Region} Returns itself to allow chaining.

   409 	 */

   410 	trigger: function( event ) {

   411 		var base, args;

   412 

   413 		if ( ! this._mode ) {

   414 			return;

   415 		}

   416 

   417 		args = _.toArray( arguments );

   418 		base = this.id + ':' + event;

   419 

   420 		// Trigger `{this.id}:{event}:{this._mode}` event on the frame.

   421 		args[0] = base + ':' + this._mode;

   422 		this.view.trigger.apply( this.view, args );

   423 

   424 		// Trigger `{this.id}:{event}` event on the frame.

   425 		args[0] = base;

   426 		this.view.trigger.apply( this.view, args );

   427 		return this;

   431 module.exports = Region;

   124 module.exports = EmbedImage;

   435 /* 32 */

   128 

   129 /***/ "+mQJ":

   439  * wp.media.controller.StateMachine

   138  * wp.media.view.EmbedUrl

   440  *

   139  *

   441  * A state machine keeps track of state. It is in one state at a time,

   140  * @memberOf wp.media.view

   442  * and can change from one state to another.

   443  *

   444  * States are stored as models in a Backbone collection.

   445  *

   446  * @memberOf wp.media.controller

   447  *

   448  * @since 3.5.0

   451  * @augments Backbone.Model

   143  * @augments wp.media.View

   452  * @mixin

   144  * @augments wp.Backbone.View

   453  * @mixes Backbone.Events

   145  * @augments Backbone.View

   455 var StateMachine = function() {

   147 EmbedUrl = View.extend(/** @lends wp.media.view.EmbedUrl.prototype */{

   456 	return {

   148 	tagName:   'span',

   457 		// Use Backbone's self-propagating `extend` inheritance method.

   149 	className: 'embed-url',

   458 		extend: Backbone.Model.extend

   150 

   459 	};

   151 	events: {

   460 };

   152 		'input': 'url'

   461 

   153 	},

   462 _.extend( StateMachine.prototype, Backbone.Events,/** @lends wp.media.controller.StateMachine.prototype */{

   154 

   463 	/**

   155 	initialize: function() {

   464 	 * Fetch a state.

   156 		this.$input = $( '<input id="embed-url-field" type="url" />' )

   465 	 *

   157 			.attr( 'aria-label', l10n.insertFromUrlTitle )

   466 	 * If no `id` is provided, returns the active state.

   158 			.val( this.model.get('url') );

   467 	 *

   159 		this.input = this.$input[0];

   468 	 * Implicitly creates states.

   160 

   469 	 *

   161 		this.spinner = $('<span class="spinner" />')[0];

   470 	 * Ensure that the `states` collection exists so the `StateMachine`

   162 		this.$el.append([ this.input, this.spinner ]);

   471 	 * can be used as a mixin.

   163 

   472 	 *

   164 		this.listenTo( this.model, 'change:url', this.render );

   473 	 * @since 3.5.0

   165 

   474 	 *

   166 		if ( this.model.get( 'url' ) ) {

   475 	 * @param {string} id

   167 			_.delay( _.bind( function () {

   476 	 * @return {wp.media.controller.State} Returns a State model from

   168 				this.model.trigger( 'change:url' );

   477 	 *                                     the StateMachine collection.

   169 			}, this ), 500 );

   478 	 */

   170 		}

   479 	state: function( id ) {

   171 	},

   480 		this.states = this.states || new Backbone.Collection();

   172 	/**

   481 

   173 	 * @return {wp.media.view.EmbedUrl} Returns itself to allow chaining.

   482 		// Default to the active state.

   174 	 */

   483 		id = id || this._state;

   175 	render: function() {

   484 

   176 		var $input = this.$input;

   485 		if ( id && ! this.states.get( id ) ) {

   177 

   486 			this.states.add({ id: id });

   178 		if ( $input.is(':focus') ) {

   487 		}

   179 			return;

   488 		return this.states.get( id );

   180 		}

   489 	},

   181 

   490 

   182 		this.input.value = this.model.get('url') || 'http://';

   491 	/**

   183 		/**

   492 	 * Sets the active state.

   184 		 * Call `render` directly on parent class with passed arguments

   493 	 *

   185 		 */

   494 	 * Bail if we're trying to select the current state, if we haven't

   186 		View.prototype.render.apply( this, arguments );

   495 	 * created the `states` collection, or are trying to select a state

   496 	 * that does not exist.

   497 	 *

   498 	 * @since 3.5.0

   499 	 *

   500 	 * @param {string} id

   501 	 *

   502 	 * @fires wp.media.controller.State#deactivate

   503 	 * @fires wp.media.controller.State#activate

   504 	 *

   505 	 * @return {wp.media.controller.StateMachine} Returns itself to allow chaining.

   506 	 */

   507 	setState: function( id ) {

   508 		var previous = this.state();

   509 

   510 		if ( ( previous && id === previous.id ) || ! this.states || ! this.states.get( id ) ) {

   511 			return this;

   512 		}

   513 

   514 		if ( previous ) {

   515 			previous.trigger('deactivate');

   516 			this._lastState = previous.id;

   517 		}

   518 

   519 		this._state = id;

   520 		this.state().trigger('activate');

   521 

   525 	/**

   190 	url: function( event ) {

   526 	 * Returns the previous active state.

   191 		var url = event.target.value || '';

   527 	 *

   192 		this.model.set( 'url', url.trim() );

   528 	 * Call the `state()` method with no parameters to retrieve the current

   529 	 * active state.

   530 	 *

   531 	 * @since 3.5.0

   532 	 *

   533 	 * @return {wp.media.controller.State} Returns a State model from

   534 	 *                                     the StateMachine collection.

   535 	 */

   536 	lastState: function() {

   537 		if ( this._lastState ) {

   538 			return this.state( this._lastState );

   539 		}

   543 // Map all event binding and triggering on a StateMachine to its `states` collection.

   196 module.exports = EmbedUrl;

   544 _.each([ 'on', 'off', 'trigger' ], function( method ) {

   545 	/**

   546 	 * @function on

   547 	 * @memberOf wp.media.controller.StateMachine

   548 	 * @instance

   549 	 * @return {wp.media.controller.StateMachine} Returns itself to allow chaining.

   550 	 */

   551 	/**

   552 	 * @function off

   553 	 * @memberOf wp.media.controller.StateMachine

   554 	 * @instance

   555 	 * @return {wp.media.controller.StateMachine} Returns itself to allow chaining.

   556 	 */

   557 	/**

   558 	 * @function trigger

   559 	 * @memberOf wp.media.controller.StateMachine

   560 	 * @instance

   561 	 * @return {wp.media.controller.StateMachine} Returns itself to allow chaining.

   562 	 */

   563 	StateMachine.prototype[ method ] = function() {

   564 		// Ensure that the `states` collection exists so the `StateMachine`

   565 		// can be used as a mixin.

   566 		this.states = this.states || new Backbone.Collection();

   567 		// Forward the method to the `states` collection.

   568 		this.states[ method ].apply( this.states, arguments );

   569 		return this;

   570 	};

   571 });

   572 

   573 module.exports = StateMachine;

   577 /* 33 */

   200 

   201 /***/ "04Ix":

   581  * wp.media.controller.State

   209  * wp.media.view.Selection

   582  *

   210  *

   583  * A state is a step in a workflow that when set will trigger the controllers

   211  * @memberOf wp.media.view

   584  * for the regions to be updated as specified in the frame.

   585  *

   586  * A state has an event-driven lifecycle:

   587  *

   588  *     'ready'      triggers when a state is added to a state machine's collection.

   589  *     'activate'   triggers when a state is activated by a state machine.

   590  *     'deactivate' triggers when a state is deactivated by a state machine.

   591  *     'reset'      is not triggered automatically. It should be invoked by the

   592  *                  proper controller to reset the state to its default.

   593  *

   594  * @memberOf wp.media.controller

   597  * @augments Backbone.Model

   214  * @augments wp.media.View

   215  * @augments wp.Backbone.View

   216  * @augments Backbone.View

   599 var State = Backbone.Model.extend(/** @lends wp.media.controller.State.prototype */{

   218 Selection = wp.media.View.extend(/** @lends wp.media.view.Selection.prototype */{

   600 	/**

   219 	tagName:   'div',

   601 	 * Constructor.

   220 	className: 'media-selection',

   602 	 *

   221 	template:  wp.template('media-selection'),

   603 	 * @since 3.5.0

   222 

   604 	 */

   223 	events: {

   605 	constructor: function() {

   224 		'click .edit-selection':  'edit',

   606 		this.on( 'activate', this._preActivate, this );

   225 		'click .clear-selection': 'clear'

   607 		this.on( 'activate', this.activate, this );

   226 	},

   608 		this.on( 'activate', this._postActivate, this );

   227 

   609 		this.on( 'deactivate', this._deactivate, this );

   228 	initialize: function() {

   610 		this.on( 'deactivate', this.deactivate, this );

   229 		_.defaults( this.options, {

   611 		this.on( 'reset', this.reset, this );

   230 			editable:  false,

   612 		this.on( 'ready', this._ready, this );

   231 			clearable: true

   613 		this.on( 'ready', this.ready, this );

   232 		});

   233 

   615 		 * Call parent constructor with passed arguments

   235 		 * @member {wp.media.view.Attachments.Selection}

   617 		Backbone.Model.apply( this, arguments );

   237 		this.attachments = new wp.media.view.Attachments.Selection({

   618 		this.on( 'change:menu', this._updateMenu, this );

   238 			controller: this.controller,

   619 	},

   239 			collection: this.collection,

   620 	/**

   240 			selection:  this.collection,

   621 	 * Ready event callback.

   241 			model:      new Backbone.Model()

   622 	 *

   242 		});

   623 	 * @abstract

   243 

   624 	 * @since 3.5.0

   244 		this.views.set( '.selection-view', this.attachments );

   625 	 */

   245 		this.collection.on( 'add remove reset', this.refresh, this );

   626 	ready: function() {},

   246 		this.controller.on( 'content:activate', this.refresh, this );

   627 

   247 	},

   628 	/**

   248 

   629 	 * Activate event callback.

   249 	ready: function() {

   630 	 *

   250 		this.refresh();

   631 	 * @abstract

   251 	},

   632 	 * @since 3.5.0

   252 

   633 	 */

   253 	refresh: function() {

   634 	activate: function() {},

   254 		// If the selection hasn't been rendered, bail.

   635 

   255 		if ( ! this.$el.children().length ) {

   636 	/**

   637 	 * Deactivate event callback.

   638 	 *

   639 	 * @abstract

   640 	 * @since 3.5.0

   641 	 */

   642 	deactivate: function() {},

   643 

   644 	/**

   645 	 * Reset event callback.

   646 	 *

   647 	 * @abstract

   648 	 * @since 3.5.0

   649 	 */

   650 	reset: function() {},

   651 

   652 	/**

   653 	 * @since 3.5.0

   654 	 * @access private

   655 	 */

   656 	_ready: function() {

   657 		this._updateMenu();

   658 	},

   659 

   660 	/**

   661 	 * @since 3.5.0

   662 	 * @access private

   663 	*/

   664 	_preActivate: function() {

   665 		this.active = true;

   666 	},

   667 

   668 	/**

   669 	 * @since 3.5.0

   670 	 * @access private

   671 	 */

   672 	_postActivate: function() {

   673 		this.on( 'change:menu', this._menu, this );

   674 		this.on( 'change:titleMode', this._title, this );

   675 		this.on( 'change:content', this._content, this );

   676 		this.on( 'change:toolbar', this._toolbar, this );

   677 

   678 		this.frame.on( 'title:render:default', this._renderTitle, this );

   679 

   680 		this._title();

   681 		this._menu();

   682 		this._toolbar();

   683 		this._content();

   684 		this._router();

   685 	},

   686 

   687 	/**

   688 	 * @since 3.5.0

   689 	 * @access private

   690 	 */

   691 	_deactivate: function() {

   692 		this.active = false;

   693 

   694 		this.frame.off( 'title:render:default', this._renderTitle, this );

   695 

   696 		this.off( 'change:menu', this._menu, this );

   697 		this.off( 'change:titleMode', this._title, this );

   698 		this.off( 'change:content', this._content, this );

   699 		this.off( 'change:toolbar', this._toolbar, this );

   700 	},

   701 

   702 	/**

   703 	 * @since 3.5.0

   704 	 * @access private

   705 	 */

   706 	_title: function() {

   707 		this.frame.title.render( this.get('titleMode') || 'default' );

   708 	},

   709 

   710 	/**

   711 	 * @since 3.5.0

   712 	 * @access private

   713 	 */

   714 	_renderTitle: function( view ) {

   715 		view.$el.text( this.get('title') || '' );

   716 	},

   717 

   718 	/**

   719 	 * @since 3.5.0

   720 	 * @access private

   721 	 */

   722 	_router: function() {

   723 		var router = this.frame.router,

   724 			mode = this.get('router'),

   725 			view;

   726 

   727 		this.frame.$el.toggleClass( 'hide-router', ! mode );

   728 		if ( ! mode ) {

   732 		this.frame.router.render( mode );

   259 		var collection = this.collection,

   733 

   260 			editing = 'edit-selection' === this.controller.content.mode();

   734 		view = router.get();

   261 

   735 		if ( view && view.select ) {

   262 		// If nothing is selected, display nothing.

   736 			view.select( this.frame.content.mode() );

   263 		this.$el.toggleClass( 'empty', ! collection.length );

   737 		}

   264 		this.$el.toggleClass( 'one', 1 === collection.length );

   738 	},

   265 		this.$el.toggleClass( 'editing', editing );

   739 

   266 

   740 	/**

   267 		this.$( '.count' ).text(

   741 	 * @since 3.5.0

   268 			/* translators: %s: Number of selected media attachments. */

   742 	 * @access private

   269 			sprintf( _n( '%s item selected', '%s items selected', collection.length ), collection.length )

   743 	 */

   270 		);

   744 	_menu: function() {

   271 	},

   745 		var menu = this.frame.menu,

   272 

   746 			mode = this.get('menu'),

   273 	edit: function( event ) {

   747 			view;

   274 		event.preventDefault();

   748 

   275 		if ( this.options.editable ) {

   749 		this.frame.$el.toggleClass( 'hide-menu', ! mode );

   276 			this.options.editable.call( this, this.collection );

   750 		if ( ! mode ) {

   277 		}

   751 			return;

   278 	},

   752 		}

   279 

   753 

   280 	clear: function( event ) {

   754 		menu.mode( mode );

   281 		event.preventDefault();

   755 

   282 		this.collection.reset();

   756 		view = menu.get();

   283 

   757 		if ( view && view.select ) {

   284 		// Move focus to the modal.

   758 			view.select( this.id );

   285 		this.controller.modal.focusManager.focus();

   759 		}

   760 	},

   761 

   762 	/**

   763 	 * @since 3.5.0

   764 	 * @access private

   765 	 */

   766 	_updateMenu: function() {

   767 		var previous = this.previous('menu'),

   768 			menu = this.get('menu');

   769 

   770 		if ( previous ) {

   771 			this.frame.off( 'menu:render:' + previous, this._renderMenu, this );

   772 		}

   773 

   774 		if ( menu ) {

   775 			this.frame.on( 'menu:render:' + menu, this._renderMenu, this );

   776 		}

   777 	},

   778 

   779 	/**

   780 	 * Create a view in the media menu for the state.

   781 	 *

   782 	 * @since 3.5.0

   783 	 * @access private

   784 	 *

   785 	 * @param {media.view.Menu} view The menu view.

   786 	 */

   787 	_renderMenu: function( view ) {

   788 		var menuItem = this.get('menuItem'),

   789 			title = this.get('title'),

   790 			priority = this.get('priority');

   791 

   792 		if ( ! menuItem && title ) {

   793 			menuItem = { text: title };

   794 

   795 			if ( priority ) {

   796 				menuItem.priority = priority;

   797 			}

   798 		}

   799 

   800 		if ( ! menuItem ) {

   801 			return;

   802 		}

   803 

   804 		view.set( this.id, menuItem );

   808 _.each(['toolbar','content'], function( region ) {

   289 module.exports = Selection;

   809 	/**

   290 

   810 	 * @access private

   291 

   811 	 */

   292 /***/ }),

   812 	State.prototype[ '_' + region ] = function() {

   293 

   813 		var mode = this.get( region );

   294 /***/ "1S4+":

   295 /***/ (function(module, exports) {

   296 

   297 var $ = jQuery,

   298 	AttachmentFilters;

   299 

   300 /**

   301  * wp.media.view.AttachmentFilters

   302  *

   303  * @memberOf wp.media.view

   304  *

   305  * @class

   306  * @augments wp.media.View

   307  * @augments wp.Backbone.View

   308  * @augments Backbone.View

   309  */

   310 AttachmentFilters = wp.media.View.extend(/** @lends wp.media.view.AttachmentFilters.prototype */{

   311 	tagName:   'select',

   312 	className: 'attachment-filters',

   313 	id:        'media-attachment-filters',

   314 

   315 	events: {

   316 		change: 'change'

   317 	},

   318 

   319 	keys: [],

   320 

   321 	initialize: function() {

   322 		this.createFilters();

   323 		_.extend( this.filters, this.options.filters );

   324 

   325 		// Build `<option>` elements.

   326 		this.$el.html( _.chain( this.filters ).map( function( filter, value ) {

   327 			return {

   328 				el: $( '<option></option>' ).val( value ).html( filter.text )[0],

   329 				priority: filter.priority || 50

   330 			};

   331 		}, this ).sortBy('priority').pluck('el').value() );

   332 

   333 		this.listenTo( this.model, 'change', this.select );

   334 		this.select();

   335 	},

   336 

   337 	/**

   338 	 * @abstract

   339 	 */

   340 	createFilters: function() {

   341 		this.filters = {};

   342 	},

   343 

   344 	/**

   345 	 * When the selected filter changes, update the Attachment Query properties to match.

   346 	 */

   347 	change: function() {

   348 		var filter = this.filters[ this.el.value ];

   349 		if ( filter ) {

   350 			this.model.set( filter.props );

   351 		}

   352 	},

   353 

   354 	select: function() {

   355 		var model = this.model,

   356 			value = 'all',

   357 			props = model.toJSON();

   358 

   359 		_.find( this.filters, function( filter, id ) {

   360 			var equal = _.all( filter.props, function( prop, key ) {

   361 				return prop === ( _.isUndefined( props[ key ] ) ? null : props[ key ] );

   362 			});

   363 

   364 			if ( equal ) {

   365 				return value = id;

   366 			}

   367 		});

   368 

   369 		this.$el.val( value );

   370 	}

   371 });

   372 

   373 module.exports = AttachmentFilters;

   374 

   375 

   376 /***/ }),

   377 

   378 /***/ "2AvB":

   379 /***/ (function(module, exports) {

   380 

   381 var Settings = wp.media.view.Settings,

   382 	AttachmentDisplay;

   383 

   384 /**

   385  * wp.media.view.Settings.AttachmentDisplay

   386  *

   387  * @memberOf wp.media.view.Settings

   388  *

   389  * @class

   390  * @augments wp.media.view.Settings

   391  * @augments wp.media.View

   392  * @augments wp.Backbone.View

   393  * @augments Backbone.View

   394  */

   395 AttachmentDisplay = Settings.extend(/** @lends wp.media.view.Settings.AttachmentDisplay.prototype */{

   396 	className: 'attachment-display-settings',

   397 	template:  wp.template('attachment-display-settings'),

   398 

   399 	initialize: function() {

   400 		var attachment = this.options.attachment;

   401 

   402 		_.defaults( this.options, {

   403 			userSettings: false

   404 		});

   405 		// Call 'initialize' directly on the parent class.

   406 		Settings.prototype.initialize.apply( this, arguments );

   407 		this.listenTo( this.model, 'change:link', this.updateLinkTo );

   408 

   409 		if ( attachment ) {

   410 			attachment.on( 'change:uploading', this.render, this );

   411 		}

   412 	},

   413 

   414 	dispose: function() {

   415 		var attachment = this.options.attachment;

   416 		if ( attachment ) {

   417 			attachment.off( null, null, this );

   418 		}

   419 		/**

   420 		 * call 'dispose' directly on the parent class

   421 		 */

   422 		Settings.prototype.dispose.apply( this, arguments );

   423 	},

   424 	/**

   425 	 * @return {wp.media.view.AttachmentDisplay} Returns itself to allow chaining.

   426 	 */

   427 	render: function() {

   428 		var attachment = this.options.attachment;

   429 		if ( attachment ) {

   430 			_.extend( this.options, {

   431 				sizes: attachment.get('sizes'),

   432 				type:  attachment.get('type')

   433 			});

   434 		}

   435 		/**

   436 		 * call 'render' directly on the parent class

   437 		 */

   438 		Settings.prototype.render.call( this );

   439 		this.updateLinkTo();

   440 		return this;

   441 	},

   442 

   443 	updateLinkTo: function() {

   444 		var linkTo = this.model.get('link'),

   445 			$input = this.$('.link-to-custom'),

   446 			attachment = this.options.attachment;

   447 

   448 		if ( 'none' === linkTo || 'embed' === linkTo || ( ! attachment && 'custom' !== linkTo ) ) {

   449 			$input.closest( '.setting' ).addClass( 'hidden' );

   450 			return;

   451 		}

   452 

   453 		if ( attachment ) {

   454 			if ( 'post' === linkTo ) {

   455 				$input.val( attachment.get('link') );

   456 			} else if ( 'file' === linkTo ) {

   457 				$input.val( attachment.get('url') );

   458 			} else if ( ! this.model.get('linkUrl') ) {

   459 				$input.val('http://');

   460 			}

   461 

   462 			$input.prop( 'readonly', 'custom' !== linkTo );

   463 		}

   464 

   465 		$input.closest( '.setting' ).removeClass( 'hidden' );

   466 		if ( $input.length ) {

   467 			$input[0].scrollIntoView();

   468 		}

   469 	}

   470 });

   471 

   472 module.exports = AttachmentDisplay;

   473 

   474 

   475 /***/ }),

   476 

   477 /***/ "2NU8":

   478 /***/ (function(module, exports) {

   479 

   480 var View = wp.media.View,

   481 	Toolbar;

   482 

   483 /**

   484  * wp.media.view.Toolbar

   485  *

   486  * A toolbar which consists of a primary and a secondary section. Each sections

   487  * can be filled with views.

   488  *

   489  * @memberOf wp.media.view

   490  *

   491  * @class

   492  * @augments wp.media.View

   493  * @augments wp.Backbone.View

   494  * @augments Backbone.View

   495  */

   496 Toolbar = View.extend(/** @lends wp.media.view.Toolbar.prototype */{

   497 	tagName:   'div',

   498 	className: 'media-toolbar',

   499 

   500 	initialize: function() {

   501 		var state = this.controller.state(),

   502 			selection = this.selection = state.get('selection'),

   503 			library = this.library = state.get('library');

   504 

   505 		this._views = {};

   506 

   507 		// The toolbar is composed of two `PriorityList` views.

   508 		this.primary   = new wp.media.view.PriorityList();

   509 		this.secondary = new wp.media.view.PriorityList();

   510 		this.primary.$el.addClass('media-toolbar-primary search-form');

   511 		this.secondary.$el.addClass('media-toolbar-secondary');

   512 

   513 		this.views.set([ this.secondary, this.primary ]);

   514 

   515 		if ( this.options.items ) {

   516 			this.set( this.options.items, { silent: true });

   517 		}

   518 

   519 		if ( ! this.options.silent ) {

   520 			this.render();

   521 		}

   522 

   523 		if ( selection ) {

   524 			selection.on( 'add remove reset', this.refresh, this );

   525 		}

   526 

   527 		if ( library ) {

   528 			library.on( 'add remove reset', this.refresh, this );

   529 		}

   530 	},

   531 	/**

   532 	 * @return {wp.media.view.Toolbar} Returns itsef to allow chaining

   533 	 */

   534 	dispose: function() {

   535 		if ( this.selection ) {

   536 			this.selection.off( null, null, this );

   537 		}

   538 

   539 		if ( this.library ) {

   540 			this.library.off( null, null, this );

   541 		}

   542 		/**

   543 		 * call 'dispose' directly on the parent class

   544 		 */

   545 		return View.prototype.dispose.apply( this, arguments );

   546 	},

   547 

   548 	ready: function() {

   549 		this.refresh();

   550 	},

   551 

   552 	/**

   553 	 * @param {string} id

   554 	 * @param {Backbone.View|Object} view

   555 	 * @param {Object} [options={}]

   556 	 * @return {wp.media.view.Toolbar} Returns itself to allow chaining.

   557 	 */

   558 	set: function( id, view, options ) {

   559 		var list;

   560 		options = options || {};

   561 

   562 		// Accept an object with an `id` : `view` mapping.

   563 		if ( _.isObject( id ) ) {

   564 			_.each( id, function( view, id ) {

   565 				this.set( id, view, { silent: true });

   566 			}, this );

   567 

   568 		} else {

   569 			if ( ! ( view instanceof Backbone.View ) ) {

   570 				view.classes = [ 'media-button-' + id ].concat( view.classes || [] );

   571 				view = new wp.media.view.Button( view ).render();

   572 			}

   573 

   574 			view.controller = view.controller || this.controller;

   575 

   576 			this._views[ id ] = view;

   577 

   578 			list = view.options.priority < 0 ? 'secondary' : 'primary';

   579 			this[ list ].set( id, view, options );

   580 		}

   581 

   582 		if ( ! options.silent ) {

   583 			this.refresh();

   584 		}

   585 

   586 		return this;

   587 	},

   588 	/**

   589 	 * @param {string} id

   590 	 * @return {wp.media.view.Button}

   591 	 */

   592 	get: function( id ) {

   593 		return this._views[ id ];

   594 	},

   595 	/**

   596 	 * @param {string} id

   597 	 * @param {Object} options

   598 	 * @return {wp.media.view.Toolbar} Returns itself to allow chaining.

   599 	 */

   600 	unset: function( id, options ) {

   601 		delete this._views[ id ];

   602 		this.primary.unset( id, options );

   603 		this.secondary.unset( id, options );

   604 

   605 		if ( ! options || ! options.silent ) {

   606 			this.refresh();

   607 		}

   608 		return this;

   609 	},

   610 

   611 	refresh: function() {

   612 		var state = this.controller.state(),

   613 			library = state.get('library'),

   614 			selection = state.get('selection');

   615 

   616 		_.each( this._views, function( button ) {

   617 			if ( ! button.model || ! button.options || ! button.options.requires ) {

   618 				return;

   619 			}

   620 

   621 			var requires = button.options.requires,

   622 				disabled = false;

   623 

   624 			// Prevent insertion of attachments if any of them are still uploading.

   625 			if ( selection && selection.models ) {

   626 				disabled = _.some( selection.models, function( attachment ) {

   627 					return attachment.get('uploading') === true;

   628 				});

   629 			}

   630 

   631 			if ( requires.selection && selection && ! selection.length ) {

   632 				disabled = true;

   633 			} else if ( requires.library && library && ! library.length ) {

   634 				disabled = true;

   635 			}

   636 			button.model.set( 'disabled', disabled );

   637 		});

   638 	}

   639 });

   640 

   641 module.exports = Toolbar;

   642 

   643 

   644 /***/ }),

   645 

   646 /***/ "2jku":

   647 /***/ (function(module, exports) {

   648 

   649 /**

   650  * wp.media.view.Attachment.Library

   651  *

   652  * @memberOf wp.media.view.Attachment

   653  *

   654  * @class

   655  * @augments wp.media.view.Attachment

   656  * @augments wp.media.View

   657  * @augments wp.Backbone.View

   658  * @augments Backbone.View

   659  */

   660 var Library = wp.media.view.Attachment.extend(/** @lends wp.media.view.Attachment.Library.prototype */{

   661 	buttons: {

   662 		check: true

   663 	}

   664 });

   665 

   666 module.exports = Library;

   667 

   668 

   669 /***/ }),

   670