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

     1 /******/ (function(modules) { // webpackBootstrap

     2 /*globals wp, _ */

     2 /******/ 	// The module cache

     3 /******/ 	var installedModules = {};

     4 /******/

     5 /******/ 	// The require function

     6 /******/ 	function __webpack_require__(moduleId) {

     7 /******/

     8 /******/ 		// Check if module is in cache

     9 /******/ 		if(installedModules[moduleId]) {

    10 /******/ 			return installedModules[moduleId].exports;

    11 /******/ 		}

    12 /******/ 		// Create a new module (and put it into the cache)

    13 /******/ 		var module = installedModules[moduleId] = {

    14 /******/ 			i: moduleId,

    15 /******/ 			l: false,

    16 /******/ 			exports: {}

    17 /******/ 		};

    18 /******/

    19 /******/ 		// Execute the module function

    20 /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

    21 /******/

    22 /******/ 		// Flag the module as loaded

    23 /******/ 		module.l = true;

    24 /******/

    25 /******/ 		// Return the exports of the module

    26 /******/ 		return module.exports;

    27 /******/ 	}

    28 /******/

    29 /******/

    30 /******/ 	// expose the modules object (__webpack_modules__)

    31 /******/ 	__webpack_require__.m = modules;

    32 /******/

    33 /******/ 	// expose the module cache

    34 /******/ 	__webpack_require__.c = installedModules;

    35 /******/

    36 /******/ 	// define getter function for harmony exports

    37 /******/ 	__webpack_require__.d = function(exports, name, getter) {

    38 /******/ 		if(!__webpack_require__.o(exports, name)) {

    39 /******/ 			Object.defineProperty(exports, name, {

    40 /******/ 				configurable: false,

    41 /******/ 				enumerable: true,

    42 /******/ 				get: getter

    43 /******/ 			});

    44 /******/ 		}

    45 /******/ 	};

    46 /******/

    47 /******/ 	// getDefaultExport function for compatibility with non-harmony modules

    48 /******/ 	__webpack_require__.n = function(module) {

    49 /******/ 		var getter = module && module.__esModule ?

    50 /******/ 			function getDefault() { return module['default']; } :

    51 /******/ 			function getModuleExports() { return module; };

    52 /******/ 		__webpack_require__.d(getter, 'a', getter);

    53 /******/ 		return getter;

    54 /******/ 	};

    55 /******/

    56 /******/ 	// Object.prototype.hasOwnProperty.call

    57 /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

    58 /******/

    59 /******/ 	// __webpack_public_path__

    60 /******/ 	__webpack_require__.p = "";

    61 /******/

    62 /******/ 	// Load entry module and return exports

    63 /******/ 	return __webpack_require__(__webpack_require__.s = 26);

    64 /******/ })

    65 /************************************************************************/

    66 /******/ (Array(26).concat([

    67 /* 26 */

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

    69 

    70 var media = wp.media,

    71 	$ = jQuery,

    72 	l10n;

    73 

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

    75 

    76 // Link any localized strings.

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

    78 

    79 // Link any settings.

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

    81 delete l10n.settings;

    82 

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

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

    85 

    86 // Check if the browser supports CSS 3.0 transitions

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

    88 	var style = document.documentElement.style,

    89 		transitions = {

    90 			WebkitTransition: 'webkitTransitionEnd',

    91 			MozTransition:    'transitionend',

    92 			OTransition:      'oTransitionEnd otransitionend',

    93 			transition:       'transitionend'

    94 		}, transition;

    95 

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

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

    98 	});

    99 

   100 	return transition && {

   101 		end: transitions[ transition ]

   102 	};

   103 }());

     5  * wp.media.controller.CollectionAdd

   106  * A shared event bus used to provide events into

     6  *

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

     7  * A state for adding attachments to a collection (e.g. video playlist).

   108  * in.

   109  */

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

   111 

   112 /**

   113  * Makes it easier to bind events using transitions.

   114  *

   115  * @param {string} selector

   116  * @param {Number} sensitivity

   117  * @returns {Promise}

   118  */

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

   120 	var deferred = $.Deferred();

   121 

   122 	sensitivity = sensitivity || 2000;

   123 

   124 	if ( $.support.transition ) {

   125 		if ( ! (selector instanceof $) ) {

   126 			selector = $( selector );

   127 		}

   128 

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

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

   131 

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

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

   134 

   135 	// Otherwise, execute on the spot.

   136 	} else {

   137 		deferred.resolve();

   138 	}

   139 

   140 	return deferred.promise();

   141 };

   142 

   143 media.controller.Region = __webpack_require__( 27 );

   144 media.controller.StateMachine = __webpack_require__( 28 );

   145 media.controller.State = __webpack_require__( 29 );

   146 

   147 media.selectionSync = __webpack_require__( 30 );

   148 media.controller.Library = __webpack_require__( 31 );

   149 media.controller.ImageDetails = __webpack_require__( 32 );

   150 media.controller.GalleryEdit = __webpack_require__( 33 );

   151 media.controller.GalleryAdd = __webpack_require__( 34 );

   152 media.controller.CollectionEdit = __webpack_require__( 35 );

   153 media.controller.CollectionAdd = __webpack_require__( 36 );

   154 media.controller.FeaturedImage = __webpack_require__( 37 );

   155 media.controller.ReplaceImage = __webpack_require__( 38 );

   156 media.controller.EditImage = __webpack_require__( 39 );

   157 media.controller.MediaLibrary = __webpack_require__( 40 );

   158 media.controller.Embed = __webpack_require__( 41 );

   159 media.controller.Cropper = __webpack_require__( 42 );

   160 media.controller.CustomizeImageCropper = __webpack_require__( 43 );

   161 media.controller.SiteIconCropper = __webpack_require__( 44 );

   162 

   163 media.View = __webpack_require__( 45 );

   164 media.view.Frame = __webpack_require__( 46 );

   165 media.view.MediaFrame = __webpack_require__( 47 );

   166 media.view.MediaFrame.Select = __webpack_require__( 48 );

   167 media.view.MediaFrame.Post = __webpack_require__( 49 );

   168 media.view.MediaFrame.ImageDetails = __webpack_require__( 50 );

   169 media.view.Modal = __webpack_require__( 51 );

   170 media.view.FocusManager = __webpack_require__( 52 );

   171 media.view.UploaderWindow = __webpack_require__( 53 );

   172 media.view.EditorUploader = __webpack_require__( 54 );

   173 media.view.UploaderInline = __webpack_require__( 55 );

   174 media.view.UploaderStatus = __webpack_require__( 56 );

   175 media.view.UploaderStatusError = __webpack_require__( 57 );

   176 media.view.Toolbar = __webpack_require__( 58 );

   177 media.view.Toolbar.Select = __webpack_require__( 59 );

   178 media.view.Toolbar.Embed = __webpack_require__( 60 );

   179 media.view.Button = __webpack_require__( 61 );

   180 media.view.ButtonGroup = __webpack_require__( 62 );

   181 media.view.PriorityList = __webpack_require__( 63 );

   182 media.view.MenuItem = __webpack_require__( 64 );

   183 media.view.Menu = __webpack_require__( 65 );

   184 media.view.RouterItem = __webpack_require__( 66 );

   185 media.view.Router = __webpack_require__( 67 );

   186 media.view.Sidebar = __webpack_require__( 68 );

   187 media.view.Attachment = __webpack_require__( 69 );

   188 media.view.Attachment.Library = __webpack_require__( 70 );

   189 media.view.Attachment.EditLibrary = __webpack_require__( 71 );

   190 media.view.Attachments = __webpack_require__( 72 );

   191 media.view.Search = __webpack_require__( 73 );

   192 media.view.AttachmentFilters = __webpack_require__( 74 );

   193 media.view.DateFilter = __webpack_require__( 75 );

   194 media.view.AttachmentFilters.Uploaded = __webpack_require__( 76 );

   195 media.view.AttachmentFilters.All = __webpack_require__( 77 );

   196 media.view.AttachmentsBrowser = __webpack_require__( 78 );

   197 media.view.Selection = __webpack_require__( 79 );

   198 media.view.Attachment.Selection = __webpack_require__( 80 );

   199 media.view.Attachments.Selection = __webpack_require__( 81 );

   200 media.view.Attachment.EditSelection = __webpack_require__( 82 );

   201 media.view.Settings = __webpack_require__( 83 );

   202 media.view.Settings.AttachmentDisplay = __webpack_require__( 84 );

   203 media.view.Settings.Gallery = __webpack_require__( 85 );

   204 media.view.Settings.Playlist = __webpack_require__( 86 );

   205 media.view.Attachment.Details = __webpack_require__( 87 );

   206 media.view.AttachmentCompat = __webpack_require__( 88 );

   207 media.view.Iframe = __webpack_require__( 89 );

   208 media.view.Embed = __webpack_require__( 90 );

   209 media.view.Label = __webpack_require__( 91 );

   210 media.view.EmbedUrl = __webpack_require__( 92 );

   211 media.view.EmbedLink = __webpack_require__( 93 );

   212 media.view.EmbedImage = __webpack_require__( 94 );

   213 media.view.ImageDetails = __webpack_require__( 95 );

   214 media.view.Cropper = __webpack_require__( 96 );

   215 media.view.SiteIconCropper = __webpack_require__( 97 );

   216 media.view.SiteIconPreview = __webpack_require__( 98 );

   217 media.view.EditImage = __webpack_require__( 99 );

   218 media.view.Spinner = __webpack_require__( 100 );

   219 

   220 

   221 /***/ }),

   222 /* 27 */

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

   224 

   225 /**

   226  * wp.media.controller.Region

   227  *

   228  * A region is a persistent application layout area.

   229  *

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

   231  *

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

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

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

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

   236  * with an AttachmentsBrowser view.

   237  *

   238  * @memberOf wp.media.controller

   239  *

   240  * @class

   241  *

   242  * @param {object}        options          Options hash for the region.

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

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

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

   246  */

   247 var Region = function( options ) {

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

   249 };

   250 

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

   252 Region.extend = Backbone.Model.extend;

   253 

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

   255 	/**

   256 	 * Activate a mode.

   257 	 *

   258 	 * @since 3.5.0

   259 	 *

   260 	 * @param {string} mode

   261 	 *

   262 	 * @fires Region#activate

   263 	 * @fires Region#deactivate

   264 	 *

   265 	 * @returns {wp.media.controller.Region} Returns itself to allow chaining.

   266 	 */

   267 	mode: function( mode ) {

   268 		if ( ! mode ) {

   269 			return this._mode;

   270 		}

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

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

   273 			return this;

   274 		}

   275 

   276 		/**

   277 		 * Region mode deactivation event.

   278 		 *

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

   280 		 */

   281 		this.trigger('deactivate');

   282 

   283 		this._mode = mode;

   284 		this.render( mode );

   285 

   286 		/**

   287 		 * Region mode activation event.

   288 		 *

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

   290 		 */

   291 		this.trigger('activate');

   292 		return this;

   293 	},

   294 	/**

   295 	 * Render a mode.

   296 	 *

   297 	 * @since 3.5.0

   298 	 *

   299 	 * @param {string} mode

   300 	 *

   301 	 * @fires Region#create

   302 	 * @fires Region#render

   303 	 *

   304 	 * @returns {wp.media.controller.Region} Returns itself to allow chaining

   305 	 */

   306 	render: function( mode ) {

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

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

   309 			return this.mode( mode );

   310 		}

   311 

   312 		var set = { view: null },

   313 			view;

   314 

   315 		/**

   316 		 * Create region view event.

   317 		 *

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

   319 		 *

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

   321 		 * @type {object}

   322 		 * @property {object} view

   323 		 */

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

   325 		view = set.view;

   326 

   327 		/**

   328 		 * Render region view event.

   329 		 *

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

   331 		 *

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

   333 		 * @type {object}

   334 		 */

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

   336 		if ( view ) {

   337 			this.set( view );

   338 		}

   339 		return this;

   340 	},

   341 

   342 	/**

   343 	 * Get the region's view.

   344 	 *

   345 	 * @since 3.5.0

   346 	 *

   347 	 * @returns {wp.media.View}

   348 	 */

   349 	get: function() {

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

   351 	},

   352 

   353 	/**

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

   355 	 *

   356 	 * @since 3.5.0

   357 	 *

   358 	 * @param {Array|Object} views

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

   360 	 * @returns {wp.Backbone.Subviews} Subviews is returned to allow chaining

   361 	 */

   362 	set: function( views, options ) {

   363 		if ( options ) {

   364 			options.add = false;

   365 		}

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

   367 	},

   368 

   369 	/**

   370 	 * Trigger regional view events on the frame.

   371 	 *

   372 	 * @since 3.5.0

   373 	 *

   374 	 * @param {string} event

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

   376 	 */

   377 	trigger: function( event ) {

   378 		var base, args;

   379 

   380 		if ( ! this._mode ) {

   381 			return;

   382 		}

   383 

   384 		args = _.toArray( arguments );

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

   386 

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

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

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

   390 

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

   392 		args[0] = base;

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

   394 		return this;

   395 	}

   396 });

   397 

   398 module.exports = Region;

   399 

   400 

   401 /***/ }),

   402 /* 28 */

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

   404 

   405 /**

   406  * wp.media.controller.StateMachine

   407  *

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

   409  * and can change from one state to another.

   410  *

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

   412  *

   413  * @memberOf wp.media.controller

   414  *

   415  * @since 3.5.0

   416  *

   417  * @class

   418  * @augments Backbone.Model

   419  * @mixin

   420  * @mixes Backbone.Events

   421  *

   422  * @param {Array} states

   423  */

   424 var StateMachine = function( states ) {

   425 	// @todo This is dead code. The states collection gets created in media.view.Frame._createStates.

   426 	this.states = new Backbone.Collection( states );

   427 };

   428 

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

   430 StateMachine.extend = Backbone.Model.extend;

   431 

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

   433 	/**

   434 	 * Fetch a state.

   435 	 *

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

   437 	 *

   438 	 * Implicitly creates states.

   439 	 *

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

   441 	 *   can be used as a mixin.

   442 	 *

   443 	 * @since 3.5.0

   444 	 *

   445 	 * @param {string} id

   446 	 * @returns {wp.media.controller.State} Returns a State model

   447 	 *   from the StateMachine collection

   448 	 */

   449 	state: function( id ) {

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

   451 

   452 		// Default to the active state.

   453 		id = id || this._state;

   454 

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

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

   457 		}

   458 		return this.states.get( id );

   459 	},

   460 

   461 	/**

   462 	 * Sets the active state.

   463 	 *

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

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

   466 	 * that does not exist.

   467 	 *

   468 	 * @since 3.5.0

   469 	 *

   470 	 * @param {string} id

   471 	 *

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

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

   474 	 *

   475 	 * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining

   476 	 */

   477 	setState: function( id ) {

   478 		var previous = this.state();

   479 

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

   481 			return this;

   482 		}

   483 

   484 		if ( previous ) {

   485 			previous.trigger('deactivate');

   486 			this._lastState = previous.id;

   487 		}

   488 

   489 		this._state = id;

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

   491 

   492 		return this;

   493 	},

   494 

   495 	/**

   496 	 * Returns the previous active state.

   497 	 *

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

   499 	 * active state.

   500 	 *

   501 	 * @since 3.5.0

   502 	 *

   503 	 * @returns {wp.media.controller.State} Returns a State model

   504 	 *    from the StateMachine collection

   505 	 */

   506 	lastState: function() {

   507 		if ( this._lastState ) {

   508 			return this.state( this._lastState );

   509 		}

   510 	}

   511 });

   512 

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

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

   515 	/**

   516 	 * @function on

   517 	 * @memberOf wp.media.controller.StateMachine

   518 	 * @instance

   519 	 * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.

   520 	 */

   521 	/**

   522 	 * @function off

   523 	 * @memberOf wp.media.controller.StateMachine

   524 	 * @instance

   525 	 * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.

   526 	 */

   527 	/**

   528 	 * @function trigger

   529 	 * @memberOf wp.media.controller.StateMachine

   530 	 * @instance

   531 	 * @returns {wp.media.controller.StateMachine} Returns itself to allow chaining.

   532 	 */

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

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

   535 		// can be used as a mixin.

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

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

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

   539 		return this;

   540 	};

   541 });

   542 

   543 module.exports = StateMachine;

   544 

   545 

   546 /***/ }),

   547 /* 29 */

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

   549 

   550 /**

   551  * wp.media.controller.State

   552  *

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

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

   555  *

   556  * A state has an event-driven lifecycle:

   557  *

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

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

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

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

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

   563  *

   564  * @memberOf wp.media.controller

   565  *

   566  * @class

   567  * @augments Backbone.Model

   568  */

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

   570 	/**

   571 	 * Constructor.

   572 	 *

   573 	 * @since 3.5.0

   574 	 */

   575 	constructor: function() {

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

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

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

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

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

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

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

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

   584 		/**

   585 		 * Call parent constructor with passed arguments

   586 		 */

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

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

   589 	},

   590 	/**

   591 	 * Ready event callback.

   592 	 *

   593 	 * @abstract

   594 	 * @since 3.5.0

   595 	 */

   596 	ready: function() {},

   597 

   598 	/**

   599 	 * Activate event callback.

   600 	 *

   601 	 * @abstract

   602 	 * @since 3.5.0

   603 	 */

   604 	activate: function() {},

   605 

   606 	/**

   607 	 * Deactivate event callback.

   608 	 *

   609 	 * @abstract

   610 	 * @since 3.5.0

   611 	 */

   612 	deactivate: function() {},

   613 

   614 	/**

   615 	 * Reset event callback.

   616 	 *

   617 	 * @abstract

   618 	 * @since 3.5.0

   619 	 */

   620 	reset: function() {},

   621 

   622 	/**

   623 	 * @access private

   624 	 * @since 3.5.0

   625 	 */

   626 	_ready: function() {

   627 		this._updateMenu();

   628 	},

   629 

   630 	/**

   631 	 * @access private

   632 	 * @since 3.5.0

   633 	*/

   634 	_preActivate: function() {

   635 		this.active = true;

   636 	},

   637 

   638 	/**

   639 	 * @access private

   640 	 * @since 3.5.0

   641 	 */

   642 	_postActivate: function() {

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

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

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

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

   647 

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

   649 

   650 		this._title();

   651 		this._menu();

   652 		this._toolbar();

   653 		this._content();

   654 		this._router();

   655 	},

   656 

   657 	/**

   658 	 * @access private

   659 	 * @since 3.5.0

   660 	 */

   661 	_deactivate: function() {

   662 		this.active = false;

   663 

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

   665 

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

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

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

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

   670 	},

   671 

   672 	/**

   673 	 * @access private

   674 	 * @since 3.5.0

   675 	 */

   676 	_title: function() {

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

   678 	},

   679 

   680 	/**

   681 	 * @access private

   682 	 * @since 3.5.0

   683 	 */

   684 	_renderTitle: function( view ) {

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

   686 	},

   687 

   688 	/**

   689 	 * @access private

   690 	 * @since 3.5.0

   691 	 */

   692 	_router: function() {

   693 		var router = this.frame.router,

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

   695 			view;

   696 

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

   698 		if ( ! mode ) {

   699 			return;

   700 		}

   701 

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

   703 

   704 		view = router.get();

   705 		if ( view && view.select ) {

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

   707 		}

   708 	},

   709 

   710 	/**

   711 	 * @access private

   712 	 * @since 3.5.0

   713 	 */

   714 	_menu: function() {

   715 		var menu = this.frame.menu,

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

   717 			view;

   718 

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

   720 		if ( ! mode ) {

   721 			return;

   722 		}

   723 

   724 		menu.mode( mode );

   725 

   726 		view = menu.get();

   727 		if ( view && view.select ) {

   728 			view.select( this.id );

   729 		}

   730 	},

   731 

   732 	/**

   733 	 * @access private

   734 	 * @since 3.5.0

   735 	 */

   736 	_updateMenu: function() {

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

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

   739 

   740 		if ( previous ) {

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

   742 		}

   743 

   744 		if ( menu ) {

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

   746 		}

   747 	},

   748 

   749 	/**

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

   751 	 *

   752 	 * @access private

   753 	 * @since 3.5.0

   754 	 *

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

   756 	 */

   757 	_renderMenu: function( view ) {

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

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

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

   761 

   762 		if ( ! menuItem && title ) {

   763 			menuItem = { text: title };

   764 

   765 			if ( priority ) {

   766 				menuItem.priority = priority;

   767 			}

   768 		}

   769 

   770 		if ( ! menuItem ) {

   771 			return;

   772 		}

   773 

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

   775 	}

   776 });

   777 

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

   779 	/**

   780 	 * @access private

   781 	 */

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

   783 		var mode = this.get( region );

   784 		if ( mode ) {

   785 			this.frame[ region ].render( mode );

   786 		}

   787 	};

   788 });

   789 

   790 module.exports = State;

   791 

   792 

   793 /***/ }),

   794 /* 30 */

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

   796 

   797 /**

   798  * wp.media.selectionSync

   799  *

   800  * Sync an attachments selection in a state with another state.

   801  *

   802  * Allows for selecting multiple images in the Add Media workflow, and then

   803  * switching to the Insert Gallery workflow while preserving the attachments selection.

   804  *

   805  * @memberOf wp.media

   806  *

   807  * @mixin

   808  */

   809 var selectionSync = {

   810 	/**

   811 	 * @since 3.5.0

   812 	 */

   813 	syncSelection: function() {

   814 		var selection = this.get('selection'),

   815 			manager = this.frame._selection;

   816 

   817 		if ( ! this.get('syncSelection') || ! manager || ! selection ) {

   818 			return;

   819 		}

   820 

   821 		// If the selection supports multiple items, validate the stored

   822 		// attachments based on the new selection's conditions. Record

   823 		// the attachments that are not included; we'll maintain a

   824 		// reference to those. Other attachments are considered in flux.

   825 		if ( selection.multiple ) {

   826 			selection.reset( [], { silent: true });

   827 			selection.validateAll( manager.attachments );

   828 			manager.difference = _.difference( manager.attachments.models, selection.models );

   829 		}

   830 

   831 		// Sync the selection's single item with the master.

   832 		selection.single( manager.single );

   833 	},

   834 

   835 	/**

   836 	 * Record the currently active attachments, which is a combination

   837 	 * of the selection's attachments and the set of selected

   838 	 * attachments that this specific selection considered invalid.

   839 	 * Reset the difference and record the single attachment.

   840 	 *

   841 	 * @since 3.5.0

   842 	 */

   843 	recordSelection: function() {

   844 		var selection = this.get('selection'),

   845 			manager = this.frame._selection;

   846 

   847 		if ( ! this.get('syncSelection') || ! manager || ! selection ) {

   848 			return;

   849 		}

   850 

   851 		if ( selection.multiple ) {

   852 			manager.attachments.reset( selection.toArray().concat( manager.difference ) );

   853 			manager.difference = [];

   854 		} else {

   855 			manager.attachments.add( selection.toArray() );

   856 		}

   857 

   858 		manager.single = selection._single;

   859 	}

   860 };

   861 

   862 module.exports = selectionSync;

   863 

   864 

   865 /***/ }),

   866 /* 31 */

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

   868 

   869 var l10n = wp.media.view.l10n,

   870 	getUserSetting = window.getUserSetting,

   871 	setUserSetting = window.setUserSetting,

   872 	Library;

   873 

   874 /**

   875  * wp.media.controller.Library

   876  *

   877  * A state for choosing an attachment or group of attachments from the media library.

   878  *

   879  * @memberOf wp.media.controller

   880  *

   881  * @class

   882  * @augments wp.media.controller.State

   883  * @augments Backbone.Model

   884  * @mixes media.selectionSync

   885  *

   886  * @param {object}                          [attributes]                         The attributes hash passed to the state.

   887  * @param {string}                          [attributes.id=library]              Unique identifier.

   888  * @param {string}                          [attributes.title=Media library]     Title for the state. Displays in the media menu and the frame's title region.

   889  * @param {wp.media.model.Attachments}      [attributes.library]                 The attachments collection to browse.

   890  *                                                                               If one is not supplied, a collection of all attachments will be created.

   891  * @param {wp.media.model.Selection|object} [attributes.selection]               A collection to contain attachment selections within the state.

   892  *                                                                               If the 'selection' attribute is a plain JS object,

   893  *                                                                               a Selection will be created using its values as the selection instance's `props` model.

   894  *                                                                               Otherwise, it will copy the library's `props` model.

   895  * @param {boolean}                         [attributes.multiple=false]          Whether multi-select is enabled.

   896  * @param {string}                          [attributes.content=upload]          Initial mode for the content region.

   897  *                                                                               Overridden by persistent user setting if 'contentUserSetting' is true.

   898  * @param {string}                          [attributes.menu=default]            Initial mode for the menu region.

   899  * @param {string}                          [attributes.router=browse]           Initial mode for the router region.

   900  * @param {string}                          [attributes.toolbar=select]          Initial mode for the toolbar region.

   901  * @param {boolean}                         [attributes.searchable=true]         Whether the library is searchable.

   902  * @param {boolean|string}                  [attributes.filterable=false]        Whether the library is filterable, and if so what filters should be shown.

   903  *                                                                               Accepts 'all', 'uploaded', or 'unattached'.

   904  * @param {boolean}                         [attributes.sortable=true]           Whether the Attachments should be sortable. Depends on the orderby property being set to menuOrder on the attachments collection.

   905  * @param {boolean}                         [attributes.autoSelect=true]         Whether an uploaded attachment should be automatically added to the selection.

   906  * @param {boolean}                         [attributes.describe=false]          Whether to offer UI to describe attachments - e.g. captioning images in a gallery.

   907  * @param {boolean}                         [attributes.contentUserSetting=true] Whether the content region's mode should be set and persisted per user.

   908  * @param {boolean}                         [attributes.syncSelection=true]      Whether the Attachments selection should be persisted from the last state.

   909  */

   910 Library = wp.media.controller.State.extend(/** @lends wp.media.controller.Library.prototype */{

   911 	defaults: {

   912 		id:                 'library',

   913 		title:              l10n.mediaLibraryTitle,

   914 		multiple:           false,

   915 		content:            'upload',

   916 		menu:               'default',

   917 		router:             'browse',

   918 		toolbar:            'select',

   919 		searchable:         true,

   920 		filterable:         false,

   921 		sortable:           true,

   922 		autoSelect:         true,

   923 		describe:           false,

   924 		contentUserSetting: true,

   925 		syncSelection:      true

   926 	},

   927 

   928 	/**

   929 	 * If a library isn't provided, query all media items.

   930 	 * If a selection instance isn't provided, create one.

   931 	 *

   932 	 * @since 3.5.0

   933 	 */

   934 	initialize: function() {

   935 		var selection = this.get('selection'),

   936 			props;

   937 

   938 		if ( ! this.get('library') ) {

   939 			this.set( 'library', wp.media.query() );

   940 		}

   941 

   942 		if ( ! ( selection instanceof wp.media.model.Selection ) ) {

   943 			props = selection;

   944 

   945 			if ( ! props ) {

   946 				props = this.get('library').props.toJSON();

   947 				props = _.omit( props, 'orderby', 'query' );

   948 			}

   949 

   950 			this.set( 'selection', new wp.media.model.Selection( null, {

   951 				multiple: this.get('multiple'),

   952 				props: props

   953 			}) );

   954 		}

   955 

   956 		this.resetDisplays();

   957 	},

   958 

   959 	/**

   960 	 * @since 3.5.0

   961 	 */

   962 	activate: function() {

   963 		this.syncSelection();

   964 

   965 		wp.Uploader.queue.on( 'add', this.uploading, this );

   966 

   967 		this.get('selection').on( 'add remove reset', this.refreshContent, this );

   968 

   969 		if ( this.get( 'router' ) && this.get('contentUserSetting') ) {

   970 			this.frame.on( 'content:activate', this.saveContentMode, this );

   971 			this.set( 'content', getUserSetting( 'libraryContent', this.get('content') ) );

   972 		}

   973 	},

   974 

   975 	/**

   976 	 * @since 3.5.0

   977 	 */

   978 	deactivate: function() {

   979 		this.recordSelection();

   980 

   981 		this.frame.off( 'content:activate', this.saveContentMode, this );

   982 

   983 		// Unbind all event handlers that use this state as the context

   984 		// from the selection.

   985 		this.get('selection').off( null, null, this );

   986 

   987 		wp.Uploader.queue.off( null, null, this );

   988 	},

   989 

   990 	/**

   991 	 * Reset the library to its initial state.

   992 	 *

   993 	 * @since 3.5.0

   994 	 */

   995 	reset: function() {

   996 		this.get('selection').reset();

   997 		this.resetDisplays();

   998 		this.refreshContent();

   999 	},

  1000 

  1001 	/**

  1002 	 * Reset the attachment display settings defaults to the site options.

  1003 	 *

  1004 	 * If site options don't define them, fall back to a persistent user setting.

  1005 	 *

  1006 	 * @since 3.5.0

  1007 	 */

  1008 	resetDisplays: function() {

  1009 		var defaultProps = wp.media.view.settings.defaultProps;

  1010 		this._displays = [];

  1011 		this._defaultDisplaySettings = {

  1012 			align: getUserSetting( 'align', defaultProps.align ) || 'none',

  1013 			size:  getUserSetting( 'imgsize', defaultProps.size ) || 'medium',

  1014 			link:  getUserSetting( 'urlbutton', defaultProps.link ) || 'none'

  1015 		};

  1016 	},

  1017 

  1018 	/**

  1019 	 * Create a model to represent display settings (alignment, etc.) for an attachment.

  1020 	 *

  1021 	 * @since 3.5.0

  1022 	 *

  1023 	 * @param {wp.media.model.Attachment} attachment

  1024 	 * @returns {Backbone.Model}

  1025 	 */

  1026 	display: function( attachment ) {

  1027 		var displays = this._displays;

  1028 

  1029 		if ( ! displays[ attachment.cid ] ) {

  1030 			displays[ attachment.cid ] = new Backbone.Model( this.defaultDisplaySettings( attachment ) );

  1031 		}

  1032 		return displays[ attachment.cid ];

  1033 	},

  1034 

  1035 	/**

  1036 	 * Given an attachment, create attachment display settings properties.

  1037 	 *

  1038 	 * @since 3.6.0

  1039 	 *

  1040 	 * @param {wp.media.model.Attachment} attachment

  1041 	 * @returns {Object}

  1042 	 */

  1043 	defaultDisplaySettings: function( attachment ) {

  1044 		var settings = _.clone( this._defaultDisplaySettings );

  1045 

  1046 		if ( settings.canEmbed = this.canEmbed( attachment ) ) {

  1047 			settings.link = 'embed';

  1048 		} else if ( ! this.isImageAttachment( attachment ) && settings.link === 'none' ) {

  1049 			settings.link = 'file';

  1050 		}

  1051 

  1052 		return settings;

  1053 	},

  1054 

  1055 	/**

  1056 	 * Whether an attachment is image.

  1057 	 *

  1058 	 * @since 4.4.1

  1059 	 *

  1060 	 * @param {wp.media.model.Attachment} attachment

  1061 	 * @returns {Boolean}

  1062 	 */

  1063 	isImageAttachment: function( attachment ) {

  1064 		// If uploading, we know the filename but not the mime type.

  1065 		if ( attachment.get('uploading') ) {

  1066 			return /\.(jpe?g|png|gif)$/i.test( attachment.get('filename') );

  1067 		}

  1068 

  1069 		return attachment.get('type') === 'image';

  1070 	},

  1071 

  1072 	/**

  1073 	 * Whether an attachment can be embedded (audio or video).

  1074 	 *

  1075 	 * @since 3.6.0

  1076 	 *

  1077 	 * @param {wp.media.model.Attachment} attachment

  1078 	 * @returns {Boolean}

  1079 	 */

  1080 	canEmbed: function( attachment ) {

  1081 		// If uploading, we know the filename but not the mime type.

  1082 		if ( ! attachment.get('uploading') ) {

  1083 			var type = attachment.get('type');

  1084 			if ( type !== 'audio' && type !== 'video' ) {

  1085 				return false;

  1086 			}

  1087 		}

  1088 

  1089 		return _.contains( wp.media.view.settings.embedExts, attachment.get('filename').split('.').pop() );

  1090 	},

  1091 

  1092 

  1093 	/**

  1094 	 * If the state is active, no items are selected, and the current

  1095 	 * content mode is not an option in the state's router (provided

  1096 	 * the state has a router), reset the content mode to the default.

  1097 	 *

  1098 	 * @since 3.5.0

  1099 	 */

  1100 	refreshContent: function() {

  1101 		var selection = this.get('selection'),

  1102 			frame = this.frame,

  1103 			router = frame.router.get(),

  1104 			mode = frame.content.mode();

  1105 

  1106 		if ( this.active && ! selection.length && router && ! router.get( mode ) ) {

  1107 			this.frame.content.render( this.get('content') );

  1108 		}

  1109 	},

  1110 

  1111 	/**

  1112 	 * Callback handler when an attachment is uploaded.

  1113 	 *

  1114 	 * Switch to the Media Library if uploaded from the 'Upload Files' tab.

  1115 	 *

  1116 	 * Adds any uploading attachments to the selection.

  1117 	 *

  1118 	 * If the state only supports one attachment to be selected and multiple

  1119 	 * attachments are uploaded, the last attachment in the upload queue will

  1120 	 * be selected.

  1121 	 *

  1122 	 * @since 3.5.0

  1123 	 *

  1124 	 * @param {wp.media.model.Attachment} attachment

  1125 	 */

  1126 	uploading: function( attachment ) {

  1127 		var content = this.frame.content;

  1128 

  1129 		if ( 'upload' === content.mode() ) {

  1130 			this.frame.content.mode('browse');

  1131 		}

  1132 

  1133 		if ( this.get( 'autoSelect' ) ) {

  1134 			this.get('selection').add( attachment );