SGH / COMPONENTS

  define([

  	"../core",
  	"../var/rnotwhite",

  	"./accepts"
  ], function( jQuery, rnotwhite ) {

  
  function Data() {

  	// Support: Android<4,
  	// Old WebKit does not have Object.preventExtensions/freeze method,
  	// return new empty object instead with no [[set]] accessor
  	Object.defineProperty( this.cache = {}, 0, {
  		get: function() {
  			return {};
  		}
  	});
  

  	this.expando = jQuery.expando + Data.uid++;
  }
  
  Data.uid = 1;

  Data.accepts = jQuery.acceptData;

  
  Data.prototype = {

  	key: function( owner ) {

  		// We can accept data for non-element nodes in modern browsers,
  		// but we should not, see #8335.

  		// Always return the key for a frozen object.
  		if ( !Data.accepts( owner ) ) {
  			return 0;

  		}
  

  		var descriptor = {},
  			// Check if the owner object already has a cache key
  			unlock = owner[ this.expando ];

  
  		// If not, create one

  		if ( !unlock ) {
  			unlock = Data.uid++;
  
  			// Secure it in a non-enumerable, non-writable property
  			try {
  				descriptor[ this.expando ] = { value: unlock };
  				Object.defineProperties( owner, descriptor );
  
  			// Support: Android<4
  			// Fallback to a less secure definition
  			} catch ( e ) {
  				descriptor[ this.expando ] = unlock;
  				jQuery.extend( owner, descriptor );

  			}
  		}
  

  		// Ensure the cache object
  		if ( !this.cache[ unlock ] ) {
  			this.cache[ unlock ] = {};
  		}
  
  		return unlock;

  	},
  	set: function( owner, data, value ) {
  		var prop,

  			// There may be an unlock assigned to this node,
  			// if there is no entry for this "owner", create one inline
  			// and set the unlock as though an owner entry had always existed
  			unlock = this.key( owner ),
  			cache = this.cache[ unlock ];

  
  		// Handle: [ owner, key, value ] args
  		if ( typeof data === "string" ) {
  			cache[ data ] = value;
  
  		// Handle: [ owner, { properties } ] args
  		} else {

  			// Fresh assignments by object are shallow copied
  			if ( jQuery.isEmptyObject( cache ) ) {
  				jQuery.extend( this.cache[ unlock ], data );
  			// Otherwise, copy the properties one-by-one to the cache object
  			} else {
  				for ( prop in data ) {
  					cache[ prop ] = data[ prop ];
  				}

  			}
  		}
  		return cache;
  	},
  	get: function( owner, key ) {

  		// Either a valid cache is found, or will be created.
  		// New caches will be created and the unlock returned,
  		// allowing direct access to the newly created
  		// empty data object. A valid owner object must be provided.
  		var cache = this.cache[ this.key( owner ) ];
  

  		return key === undefined ?

  			cache : cache[ key ];

  	},
  	access: function( owner, key, value ) {
  		var stored;

  		// In cases where either:
  		//
  		//   1. No key was specified
  		//   2. A string key was specified, but no value provided
  		//
  		// Take the "read" path and allow the get method to determine
  		// which value to return, respectively either:
  		//
  		//   1. The entire cache object
  		//   2. The data stored at the key
  		//
  		if ( key === undefined ||

  				((key && typeof key === "string") && value === undefined) ) {

  
  			stored = this.get( owner, key );
  
  			return stored !== undefined ?

  				stored : this.get( owner, jQuery.camelCase(key) );

  		}
  

  		// [*]When the key is not a string, or both a key and value

  		// are specified, set or extend (existing objects) with either:
  		//
  		//   1. An object of properties
  		//   2. A key and value
  		//
  		this.set( owner, key, value );
  
  		// Since the "set" path can have two possible entry points
  		// return the expected data based on which path was taken[*]
  		return value !== undefined ? value : key;
  	},
  	remove: function( owner, key ) {
  		var i, name, camel,

  			unlock = this.key( owner ),
  			cache = this.cache[ unlock ];

  
  		if ( key === undefined ) {

  			this.cache[ unlock ] = {};

  
  		} else {

  			// Support array or space separated string of keys
  			if ( jQuery.isArray( key ) ) {

  				// If "name" is an array of keys...
  				// When data is initially created, via ("key", "val") signature,
  				// keys will be converted to camelCase.
  				// Since there is no way to tell _how_ a key was added, remove
  				// both plain key and camelCase key. #12786
  				// This will only penalize the array argument path.
  				name = key.concat( key.map( jQuery.camelCase ) );
  			} else {
  				camel = jQuery.camelCase( key );

  				// Try the string as a key before any manipulation
  				if ( key in cache ) {
  					name = [ key, camel ];
  				} else {

  					// If a key with the spaces exists, use it.
  					// Otherwise, create an array by matching non-whitespace
  					name = camel;
  					name = name in cache ?
  						[ name ] : ( name.match( rnotwhite ) || [] );
  				}
  			}
  
  			i = name.length;

  			while ( i-- ) {
  				delete cache[ name[ i ] ];
  			}
  		}

  	},
  	hasData: function( owner ) {

  		return !jQuery.isEmptyObject(
  			this.cache[ owner[ this.expando ] ] || {}
  		);
  	},
  	discard: function( owner ) {
  		if ( owner[ this.expando ] ) {
  			delete this.cache[ owner[ this.expando ] ];
  		}

  	}
  };
  
  return Data;

  });