text: YUI.add('base-base', function(Y) {
  
      /**
       * The base module provides the Base class, which objects requiring attribute and custom event support can extend. 
       * The module also provides two ways to reuse code - It augments Base with the Plugin.Host interface which provides 
       * plugin support and also provides the BaseCore.build method which provides a way to build custom classes using extensions.
       *
       * @module base
       */
  
      /**
       * The base-base submodule provides the Base class without the Plugin support, provided by Plugin.Host, 
       * and without the extension support provided by BaseCore.build.
       *
       * @module base
       * @submodule base-base
       */
  
      /**
       * The base module provides the Base class, which objects requiring attribute and custom event support can extend. 
       * The module also provides two ways to reuse code - It augments Base with the Plugin.Host interface which provides 
       * plugin support and also provides the Base.build method which provides a way to build custom classes using extensions.
       *
       * @module base
       */
  
      /**
       * The base-base submodule provides the Base class without the Plugin support, provided by Plugin.Host, 
       * and without the extension support provided by Base.build.
       *
       * @module base
       * @submodule base-base
       */
      var L = Y.Lang,
  
          DESTROY = "destroy",
          INIT = "init",
  
          BUBBLETARGETS = "bubbleTargets",
          _BUBBLETARGETS = "_bubbleTargets",
  
          BaseCore = Y.BaseCore,
          AttributeCore = Y.AttributeCore,
          Attribute = Y.Attribute;
  
      /**
       * <p>
       * A base class which objects requiring attributes and custom event support can 
       * extend. Base also handles the chaining of initializer and destructor methods across 
       * the hierarchy as part of object construction and destruction. Additionally, attributes configured 
       * through the static <a href="#property_Base.ATTRS">ATTRS</a> property for each class 
       * in the hierarchy will be initialized by Base.
       * </p>
       *
       * <p>
       * The static <a href="#property_Base.NAME">NAME</a> property of each class extending 
       * from Base will be used as the identifier for the class, and is used by Base to prefix 
       * all events fired by instances of that class.
       * </p>
       *
       * @class Base
       * @constructor
       * @uses BaseCore
       * @uses Attribute
       *
       * @param {Object} config Object with configuration property name/value pairs. The object can be 
       * used to provide default values for the objects published attributes.
       *
       * <p>
       * The config object can also contain the following non-attribute properties, providing a convenient 
       * way to configure events listeners and plugins for the instance, as part of the constructor call:
       * </p>
       *
       * <dl>
       *     <dt>on</dt>
       *     <dd>An event name to listener function map, to register event listeners for the "on" moment of the event. A constructor convenience property for the <a href="Base.html#method_on">on</a> method.</dd>
       *     <dt>after</dt>
       *     <dd>An event name to listener function map, to register event listeners for the "after" moment of the event. A constructor convenience property for the <a href="Base.html#method_after">after</a> method.</dd>
       *     <dt>bubbleTargets</dt>
       *     <dd>An object, or array of objects, to register as bubble targets for bubbled events fired by this instance. A constructor convenience property for the <a href="EventTarget.html#method_addTarget">addTarget</a> method.</dd>
       *     <dt>plugins</dt>
       *     <dd>A plugin, or array of plugins to be plugged into the instance (see PluginHost's plug method for signature details). A constructor convenience property for the <a href="Plugin.Host.html#method_plug">plug</a> method.</dd>
       * </dl>
       */
      function Base() {
          BaseCore.apply(this, arguments);
      }
  
      /**
       * The list of properties which can be configured for 
       * each attribute (e.g. setter, getter, writeOnce, readOnly etc.)
       *
       * @property _ATTR_CFG
       * @type Array
       * @static
       * @private
       */
      Base._ATTR_CFG = Attribute._ATTR_CFG.concat("cloneDefaultValue");
      Base._ATTR_CFG_HASH = Y.Array.hash(Base._ATTR_CFG);
  
      /**
       * The array of non-attribute configuration properties supported by this class. 
       * 
       * `Base` supports "on", "after", "plugins" and "bubbleTargets" properties, 
       * which are not set up as attributes. 
       *
       * This property is primarily required so that when 
       * <a href="#property__allowAdHocAttrs">`_allowAdHocAttrs`</a> is enabled by
       * a class, non-attribute configurations don't get added as ad-hoc attributes.  
       *
       * @property _NON_ATTRS_CFG
       * @type Array
       * @static
       * @private
       */
      Base._NON_ATTRS_CFG = BaseCore._NON_ATTRS_CFG.concat(["on", "after", "bubbleTargets"]);
  
      /**
       * <p>
       * The string to be used to identify instances of 
       * this class, for example in prefixing events.
       * </p>
       * <p>
       * Classes extending Base, should define their own
       * static NAME property, which should be camelCase by
       * convention (e.g. MyClass.NAME = "myClass";).
       * </p>
       * @property NAME
       * @type String
       * @static
       */
      Base.NAME = "base";
  
      /**
       * The default set of attributes which will be available for instances of this class, and 
       * their configuration. In addition to the configuration properties listed by 
       * Attribute's <a href="Attribute.html#method_addAttr">addAttr</a> method, the attribute 
       * can also be configured with a "cloneDefaultValue" property, which defines how the statically
       * defined value field should be protected ("shallow", "deep" and false are supported values). 
       *
       * By default if the value is an object literal or an array it will be "shallow" cloned, to 
       * protect the default value.
       *
       * @property ATTRS
       * @type Object
       * @static
       */
      Base.ATTRS = AttributeCore.prototype._protectAttrs(BaseCore.ATTRS);
  
      Base.prototype = {
  
          /**
           * Internal construction logic for Base.
           *
           * @method _initBase
           * @param {Object} config The constructor configuration object
           * @private
           */
          _initBase: function(cfg) {
              Y.log('init called', 'life', 'base');
  
              this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME;
  
              Y.BaseCore.prototype._initBase.call(this, cfg);
          },
  
          /**
           * Initializes Attribute 
           * 
           * @method _initAttribute
           * @private
           */
          _initAttribute: function(cfg) {
              Attribute.call(this);
              this._yuievt.config.prefix = this._eventPrefix;
          },
  
          /**
           * Utility method to define the attribute hash used to filter/whitelist property mixes for 
           * this class. 
           * 
           * @method _attrCfgHash
           * @private
           */
          _attrCfgHash: function() {
              return Base._ATTR_CFG_HASH;
          },
  
          /**
           * Init lifecycle method, invoked during construction.
           * Fires the init event prior to setting up attributes and 
           * invoking initializers for the class hierarchy.
           *
           * @method init
           * @chainable
           * @param {Object} config Object with configuration property name/value pairs
           * @return {Base} A reference to this object
           */
          init: function(config) {
              /**
               * <p>
               * Lifecycle event for the init phase, fired prior to initialization. 
               * Invoking the preventDefault() method on the event object provided 
               * to subscribers will prevent initialization from occuring.
               * </p>
               * <p>
               * Subscribers to the "after" momemt of this event, will be notified
               * after initialization of the object is complete (and therefore
               * cannot prevent initialization).
               * </p>
               *
               * @event init
               * @preventable _defInitFn
               * @param {EventFacade} e Event object, with a cfg property which 
               * refers to the configuration object passed to the constructor.
               */
              this.publish(INIT, {
                  queuable:false,
                  fireOnce:true,
                  defaultTargetOnly:true,
                  defaultFn:this._defInitFn
              });
  
              this._preInitEventCfg(config);
  
              this.fire(INIT, {cfg: config});
  
              return this;
          },
  
          /**
           * Handles the special on, after and target properties which allow the user to
           * easily configure on and after listeners as well as bubble targets during 
           * construction, prior to init.
           *
           * @private
           * @method _preInitEventCfg
           * @param {Object} config The user configuration object
           */
          _preInitEventCfg : function(config) {
              if (config) {
                  if (config.on) {
                      this.on(config.on);
                  }
                  if (config.after) {
                      this.after(config.after);
                  }
              }
  
              var i, l, target,
                  userTargets = (config && BUBBLETARGETS in config);
  
              if (userTargets || _BUBBLETARGETS in this) {
                  target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets;
                  if (L.isArray(target)) {
                      for (i = 0, l = target.length; i < l; i++) { 
                          this.addTarget(target[i]);
                      }
                  } else if (target) {
                      this.addTarget(target);
                  }
              }
          },
  
          /**
           * <p>
           * Destroy lifecycle method. Fires the destroy
           * event, prior to invoking destructors for the
           * class hierarchy.
           * </p>
           * <p>
           * Subscribers to the destroy
           * event can invoke preventDefault on the event object, to prevent destruction
           * from proceeding.
           * </p>
           * @method destroy
           * @return {Base} A reference to this object
           * @chainable
           */
          destroy: function() {
              Y.log('destroy called', 'life', 'base');
  
              /**
               * <p>
               * Lifecycle event for the destroy phase, 
               * fired prior to destruction. Invoking the preventDefault 
               * method on the event object provided to subscribers will 
               * prevent destruction from proceeding.
               * </p>
               * <p>
               * Subscribers to the "after" moment of this event, will be notified
               * after destruction is complete (and as a result cannot prevent
               * destruction).
               * </p>
               * @event destroy
               * @preventable _defDestroyFn
               * @param {EventFacade} e Event object
               */
              this.publish(DESTROY, {
                  queuable:false,
                  fireOnce:true,
                  defaultTargetOnly:true,
                  defaultFn: this._defDestroyFn
              });
              this.fire(DESTROY);
  
              this.detachAll();
              return this;
          },
  
          /**
           * Default init event handler
           *
           * @method _defInitFn
           * @param {EventFacade} e Event object, with a cfg property which 
           * refers to the configuration object passed to the constructor.
           * @protected
           */
          _defInitFn : function(e) {
              this._baseInit(e.cfg);
          },
  
          /**
           * Default destroy event handler
           *
           * @method _defDestroyFn
           * @param {EventFacade} e Event object
           * @protected
           */
          _defDestroyFn : function(e) {
              this._baseDestroy(e.cfg);
          }
      };
  
      Y.mix(Base, Attribute, false, null, 1);
      Y.mix(Base, BaseCore, false, null, 1);
  
      // Fix constructor
      Base.prototype.constructor = Base;
  
      Y.Base = Base;
  
  
  }, '@VERSION@' ,{requires:['base-core', 'attribute-base']});
  