3.0.0

* Fixed hasImpl method on built classes, to look up the class
  hierarchy for applied extensions.

* Plugin.Host removed from base-base module and delivered as it's 
  own module - "pluginhost"

* base broken up into..

     base-base: Provides class hierarchy support for ATTRS and 
     initialization

     base-build: Provides Extension support in the form of 
     Base.build

     base-pluginhost: Augments Plugin.Host to Base, adding plugin
     support

3.0.0 beta 1

* Config argument for init event now merged into the event facade, 
  instead of being passed separately (available as e.cfg).
  
* Removed Base.create. On review, considered to be overkill.
  Users can easily create new instances, using Base.build

* Moved PluginHost down from Widget to Base, since utils and 
  Node will also support Plugins.

* PluginHost.plug and unplug now accept the plugin class as 
  arguments [plug(pluginClass, cfg) and unplug(pluginClass)].

* Split base module up into base-base and base-build.

* Added lazy attribute initialization support, to improve performance.
  
  This also removes order dependency when processing ATTRS for a 
  particular class.

  If a get/set call is made for an uninitialized attribute A, in the 
  getter/setter/validator or valueFns of another attribute B, A will 
  be intiailized on the fly. 

* Added ability to subscribe to on/after events through the 
  constructor config object, e.g.:
  
      new MyBaseObject({ 
         on: {
            init: handlerFn,
            myAttrChange: handlerFn
	 },
	 after: {
	    init: handlerFn,
	    myAttrChange: handlerFn
	 },
	 ...
	 
      });

* Developers can now override the default clone behavior we use to
  isolate default ATTRS config values, using cloneDefaultValue, e.g.:

  ATTRS = {
      myAttr : {
      	value: AnObjectOrArrayReference
	    cloneDefaultValue: true|false|"deep"|"shallow"
      }
  }

  If the cloneDefaultValue property is not defined, Base will clone
  any Arrays or Object literals which are used as default values when
  configuring attributes for an instance, so that updates to instance 
  values do not modify the default value.

  This behavior can be over-ridden using the cloneDefaultValue property:

  true, deep: 

     Use Y.clone to protect the default value.

  shallow:

     Use Y.merge, to protect the default value.

  false:

     Don't clone Arrays or Object literals. The value is intended
     to be used by reference, for example, when it points to
     a utility object.

* Base.plug and Base.unplug used to add static Plugins (default plugins
  for a class). Replaces static PLUGINS array, allowing subclasses to 
  easily unplug static plugins added higher up in the hierarchy.

* Base adds all attributes lazily. This means attributes don't get
  initialized until the first call to get/set, speeding up construction
  of Base based objects.

  Attributes which have setters which set some other state in the object, 
  can configure the attribute to disable lazy initialization, by setting
  lazyAdd:false as part of their attribute configuration, so that the setter
  gets invoked during construction.

3.0.0PR1 - Initial release

Module Name: "base"
Documentation: http://developer.yahoo.com/yui/3/base

Base is designed to be a low level class from which other attribute 
and event target based classes in the YUI library can be derived. 
It provides a standard template for creating attribute based objects 
across the library and provides a consistent init() and destroy() 
sequence, by chaining initialization (initializer) and destruction 
(destructor) methods for the class hierarcy.
