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

(function( exports, $ ){

		slice = Array.prototype.slice;

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

	ctor = function() {};

	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;

	};

	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 ( this.instance ) {

			magic = function() {

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

			};

			$.extend( magic, this );

		}

		magic.initialize.apply( magic, args );

		return magic;

	};

	api.Class.applicator = {};

	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;

	};

	api.Events = {

		trigger: function( id ) {

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

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

			return this;

		},

			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;

		},

			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.

	api.Value = api.Class.extend({

		initialize: function( initial, options ) {

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

			this.callbacks = $.Callbacks();

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

			this.set = $.proxy( this.set, 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: function() {

			return this._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.

				return this;

			this._value = to;

			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;

		},

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

			return this;

		},

			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.

	api.Values = api.Class.extend({

		defaultConstructor: api.Value,

		initialize: function( options ) {

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

			this._value = {};

			this._deferreds = {};

		},

		instance: function( id ) {

			if ( arguments.length === 1 )

				return this.value( id );

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

		},

		value: function( id ) {

			return this._value[ id ];

		},

		has: function( id ) {

			return typeof this._value[ id ] !== 'undefined';

		},

		add: function( id, value ) {

			if ( this.has( id ) )

				return this.value( id );

			this._value[ id ] = value;

			value.parent = this;

			if ( value.extended( api.Value ) )

				value.bind( this._change );

			this.trigger( 'add', value );

			if ( this._deferreds[ id ] )

				this._deferreds[ id ].resolve();

			return this._value[ id ];

		},

		create: function( id ) {

			return this.add( id, new this.defaultConstructor( api.Class.applicator, slice.call( arguments, 1 ) ) );

		},

		each: function( callback, context ) {

			context = typeof context === 'undefined' ? this : context;

			$.each( this._value, function( key, obj ) {

				callback.call( context, obj, key );

			});

		},

		remove: function( id ) {

			var value;

			if ( this.has( id ) ) {

				value = this.value( id );

				this.trigger( 'remove', value );

				if ( value.extended( api.Value ) )

					value.unbind( this._change );

				delete value.parent;

			}

			delete this._value[ id ];

			delete this._deferreds[ id ];

		},

		/**

		 * Runs a callback once all requested values exist.

		 *

		 * when( ids*, [callback] );

		 *

		 * For example:

		 *     when( id1, id2, id3, function( value1, value2, value3 ) {} );

		 *

		 * @returns $.Deferred.promise();

		 */

		when: function() {

			var self = this,

				ids  = slice.call( arguments ),

				dfd  = $.Deferred();

			// If the last argument is a callback, bind it to .done()

			if ( $.isFunction( ids[ ids.length - 1 ] ) )

				dfd.done( ids.pop() );

			$.when.apply( $, $.map( ids, function( id ) {

				if ( self.has( id ) )

					return;