/**

 * @output wp-includes/js/customize-base.js

 */

/** @namespace wp */

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

(function( exports, $ ){

	var api = {}, ctor, inherits,

		slice = Array.prototype.slice;

	// Shared empty constructor function to aid in prototype-chain creation.

	ctor = function() {};

	/**

	 * Helper function to correctly set up the prototype chain, for subclasses.

	 * Similar to `goog.inherits`, but uses a hash of prototype properties and

	 * class properties to be extended.

	 *

	 * @param object parent      Parent class constructor to inherit from.

	 * @param object protoProps  Properties to apply to the prototype for use as class instance properties.

	 * @param object staticProps Properties to apply directly to the class constructor.

	 * @return child The subclassed constructor.

	 */

	inherits = function( parent, protoProps, staticProps ) {

		var child;

		/*

		 * The constructor function for the new subclass is either defined by you

		 * (the "constructor" property in your `extend` definition), or defaulted

		 * by us to simply call `super()`.

		 */

		if ( protoProps && protoProps.hasOwnProperty( 'constructor' ) ) {

			child = protoProps.constructor;

		} else {

			child = function() {

				/*

				 * Storing the result `super()` before returning the value

				 * prevents a bug in Opera where, if the constructor returns

				 * a function, Opera will reject the return value in favor of

				 * the original object. This causes all sorts of trouble.

				 */

				var result = parent.apply( this, arguments );

				return result;

			};

		}

		// Inherit class (static) properties from parent.

		$.extend( child, parent );

		// Set the prototype chain to inherit from `parent`,

		// without calling `parent`'s constructor function.

		ctor.prototype  = parent.prototype;

		child.prototype = new ctor();

		// Add prototype properties (instance properties) to the subclass,

		// if supplied.

		if ( protoProps ) {

			$.extend( child.prototype, protoProps );

		}

		// Add static properties to the constructor function, if supplied.

		if ( staticProps ) {

			$.extend( child, staticProps );

		}

		// Correctly set child's `prototype.constructor`.

		child.prototype.constructor = child;

		// Set a convenience property in case the parent's prototype is needed later.

		child.__super__ = parent.prototype;

		return child;

	};

	/**

	 * Base class for object inheritance.

	 */

	api.Class = function( applicator, argsArray, options ) {

		var magic, args = arguments;

		if ( applicator && argsArray && api.Class.applicator === applicator ) {

			args = argsArray;

			$.extend( this, options || {} );

		}

		magic = this;

		/*

		 * If the class has a method called "instance",

		 * the return value from the class' constructor will be a function that

		 * calls the "instance" method.

		 *

		 * It is also an object that has properties and methods inside it.

		 */

		if ( this.instance ) {

			magic = function() {

				return magic.instance.apply( magic, arguments );

			};

			$.extend( magic, this );

		}

		magic.initialize.apply( magic, args );

		return magic;

	};

	/**

	 * Creates a subclass of the class.

	 *

	 * @param object protoProps  Properties to apply to the prototype.

	 * @param object staticProps Properties to apply directly to the class.

	 * @return child The subclass.

	 */

	api.Class.extend = function( protoProps, staticProps ) {

		var child = inherits( this, protoProps, staticProps );

		child.extend = this.extend;

		return child;

	};

	api.Class.applicator = {};

	/**

	 * Initialize a class instance.

	 *

	 * Override this function in a subclass as needed.

	 */

	api.Class.prototype.initialize = function() {};

	/*

	 * Checks whether a given instance extended a constructor.

	 *

	 * The magic surrounding the instance parameter causes the instanceof

	 * keyword to return inaccurate results; it defaults to the function's

	 * prototype instead of the constructor chain. Hence this function.

	 */

	api.Class.prototype.extended = function( constructor ) {

		var proto = this;

		while ( typeof proto.constructor !== 'undefined' ) {

			if ( proto.constructor === constructor ) {

				return true;

			}

			if ( typeof proto.constructor.__super__ === 'undefined' ) {

				return false;

			}

			proto = proto.constructor.__super__;

		}

		return false;

	};

	/**

	 * An events manager object, offering the ability to bind to and trigger events.

	 *

	 * Used as a mixin.

	 */

	api.Events = {

		trigger: function( id ) {

			if ( this.topics && this.topics[ id ] ) {

				this.topics[ id ].fireWith( this, slice.call( arguments, 1 ) );

			}

			return this;

		},

		bind: function( id ) {

			this.topics = this.topics || {};

			this.topics[ id ] = this.topics[ id ] || $.Callbacks();

			this.topics[ id ].add.apply( this.topics[ id ], slice.call( arguments, 1 ) );

			return this;

		},

		unbind: function( id ) {

			if ( this.topics && this.topics[ id ] ) {

				this.topics[ id ].remove.apply( this.topics[ id ], slice.call( arguments, 1 ) );

			}

			return this;

		}

	};

	/**

	 * Observable values that support two-way binding.

	 *

	 * @memberOf wp.customize

	 * @alias wp.customize.Value

	 *

	 * @constructor

	 */

	api.Value = api.Class.extend(/** @lends wp.customize.Value.prototype */{

		/**

		 * @param {mixed}  initial The initial value.

		 * @param {Object} options

		 */

		initialize: function( initial, options ) {

			this._value = initial; // @todo Potentially change this to a this.set() call.

			this.callbacks = $.Callbacks();

			this._dirty = false;

			$.extend( this, options || {} );

			this.set = this.set.bind( this );

		},

		/*

		 * Magic. Returns a function that will become the instance.

		 * Set to null to prevent the instance from extending a function.

		 */

		instance: function() {

			return arguments.length ? this.set.apply( this, arguments ) : this.get();

		},

		/**

		 * Get the value.

		 *

		 * @return {mixed}

		 */

		get: function() {

			return this._value;

		},

		/**

		 * Set the value and trigger all bound callbacks.

		 *

		 * @param {Object} to New value.

		 */

		set: function( to ) {

			var from = this._value;

			to = this._setter.apply( this, arguments );

			to = this.validate( to );

			// Bail if the sanitized value is null or unchanged.

			if ( null === to || _.isEqual( from, to ) ) {

				return this;

			}

			this._value = to;

			this._dirty = true;

			this.callbacks.fireWith( this, [ to, from ] );

			return this;

		},

		_setter: function( to ) {

			return to;

		},

		setter: function( callback ) {

			var from = this.get();

			this._setter = callback;

			// Temporarily clear value so setter can decide if it's valid.

			this._value = null;

			this.set( from );

			return this;

		},

		resetSetter: function() {

			this._setter = this.constructor.prototype._setter;

			this.set( this.get() );

			return this;

		},

		validate: function( value ) {

			return value;

		},

		/**

		 * Bind a function to be invoked whenever the value changes.

		 *

		 * @param {...Function} A function, or multiple functions, to add to the callback stack.

		 */

		bind: function() {

			this.callbacks.add.apply( this.callbacks, arguments );

			return this;

		},

		/**

		 * Unbind a previously bound function.

		 *

		 * @param {...Function} A function, or multiple functions, to remove from the callback stack.

		 */

		unbind: function() {

			this.callbacks.remove.apply( this.callbacks, arguments );

			return this;

		},

		link: function() { // values*

			var set = this.set;

			$.each( arguments, function() {

				this.bind( set );

			});

			return this;

		},

		unlink: function() { // values*

			var set = this.set;

			$.each( arguments, function() {

				this.unbind( set );

			});

			return this;

		},

		sync: function() { // values*

			var that = this;

			$.each( arguments, function() {

				that.link( this );

				this.link( that );

			});

			return this;

		},

		unsync: function() { // values*

			var that = this;

			$.each( arguments, function() {

				that.unlink( this );

				this.unlink( that );

			});

			return this;

		}

	});

	/**

	 * A collection of observable values.

	 *

	 * @memberOf wp.customize

	 * @alias wp.customize.Values

	 *

	 * @constructor

	 * @augments wp.customize.Class

	 * @mixes wp.customize.Events

	 */

	api.Values = api.Class.extend(/** @lends wp.customize.Values.prototype */{

		/**

		 * The default constructor for items of the collection.

		 *

		 * @type {object}

		 */

		defaultConstructor: api.Value,

		initialize: function( options ) {

			$.extend( this, options || {} );

			this._value = {};

			this._deferreds = {};

		},

		/**

		 * Get the instance of an item from the collection if only ID is specified.

		 *

		 * If more than one argument is supplied, all are expected to be IDs and

		 * the last to be a function callback that will be invoked when the requested

		 * items are available.

		 *

		 * @see {api.Values.when}

		 *

		 * @param {string} id ID of the item.

		 * @param {...}       Zero or more IDs of items to wait for and a callback

		 *                    function to invoke when they're available. Optional.

		 * @return {mixed} The item instance if only one ID was supplied.

		 *                 A Deferred Promise object if a callback function is supplied.

		 */

		instance: function( id ) {

			if ( arguments.length === 1 ) {

				return this.value( id );

			}

			return this.when.apply( this, arguments );

		},

		/**

		 * Get the instance of an item.

		 *

		 * @param {string} id The ID of the item.

		 * @return {[type]} [description]

		 */

		value: function( id ) {

			return this._value[ id ];

		},

		/**

		 * Whether the collection has an item with the given ID.