jQuery.extend = jQuery.fn.extend = function() {
	// copy reference to target object
	var target = arguments[0] || {}, a = 1, al = arguments.length, deep = false;
 
	// Handle a deep copy situation
	if ( target.constructor == Boolean ) {
		deep = target;
		target = arguments[1] || {};
	}
 
	// extend jQuery itself if only one argument is passed
	if ( al == 1 ) {
		target = this;
		a = 0;
	}
 
	var prop;
 
	for ( ; a < al; a++ )
		// Only deal with non-null/undefined values
		if ( (prop = arguments[a]) != null )
 
			// ACTUAL COPY BEGINS HERE
 
			// Extend the base object
			for ( var i in prop ) {
				// Prevent never-ending loop
				if ( target == prop[i] )
					continue;
 
				// Recurse if we're merging object values
				if ( deep && typeof prop[i] == 'object' && target[i] )
					jQuery.extend( target[i], prop[i] );
 
				// Don't bring in undefined values
				else if ( prop[i] != undefined )
					target[i] = prop[i];
			}
 
			// ACTUAL COPY ENDS HERE
 
	// Return the modified object
	return target;
};

/**
  * Utility to set up the prototype, constructor and superclass properties to
  * support an inheritance strategy that can chain constructors and methods.
  * Static members will not be inherited.
  *
  * @method extend
  * @static
  * @param {Function} subc   the object to modify
  * @param {Function} superc the object to inherit
  * @param {Object} overrides  additional properties/methods to add to the
  *                              subclass prototype.  These will override the
  *                              matching items obtained from the superclass
  *                              if present.
  */
extend: function(subc, superc, overrides) {
	if (! superc || ! subc) {
		throw new Error(”YAHOO.lang.extend failed, please check that ” +
						“all dependencies are included.”);
	}
 
	var F = function() {};
	F.prototype = superc.prototype;
	subc.prototype = new F();
	subc.prototype.constructor = subc;
	subc.superclass = superc.prototype;
 
	if (superc.prototype.constructor == Object.prototype.constructor) {
		superc.prototype.constructor = superc;
	}
 
	if (overrides) {
		for (var i in overrides) {
			subc.prototype[i] = overrides[i];
		}
 
		YAHOO.lang._IEEnumFix(subc.prototype, overrides);
	}
},

Core.extend = function(subc, superc, overrides) {
	if (! superc || ! subc) {
		throw new Error(”Core.extend failed, please check that all dependencies are included.”);
	}
 
	var F = function() {};
	F.prototype = superc.prototype;
	subc.prototype = new F();
 
	if (overrides) {
		for (var i in overrides) {
			subc.prototype[i] = overrides[i];
		}
	}
 
};

var Item= {};
var Book = {};
 
Core.extend(Item, Object, {
	toString: function() {
		var sb = [];
 
		for (var i in this) {
			if (typeof this[i] !== ‘function’) {
				sb.push(’&');
				sb.push(i);
				sb.push(’=');
				sb.push(this[i]);
		}
 
		return sb.join(”);
	}
});
 
Core.extend(Book, Item, {
	getTitle: function() {
		return this.title;
	},
 
	setTitle: function(s) {
		this.title = s;
 
	}
});

Core.Model.XJsonArray = function(data) {
	this.update(data);
};
 
Core.extend(Core.Model.XJsonArray, Core.Model.Model, {
	length: 0,
 
	… /* More to come in my Tuesday Article */
 
	/**
	 * Updates the object to use the passed data set
	 *
	 * @method update
	 * @param data {object} xjsonarray object
	 * @public
	 */
	update: function(data) {
		if (! (data && isType(data, ‘object’) && isType(data.scheme, ‘array’) && isType(data.set, ‘array’))) {throw(’XJsonArray - Invalid data passed into Update’);}
		this.parent.update.call(this, data.set);
		this.length = this.data.length;
		this.scheme = data.scheme;
	}
});