text: YUI.add('pluginhost-base', function (Y, NAME) {
  
      /**
       * Provides the augmentable PluginHost interface, which can be added to any class.
       * @module pluginhost
       */
  
      /**
       * Provides the augmentable PluginHost interface, which can be added to any class.
       * @module pluginhost-base
       */
  
      /**
       * <p>
       * An augmentable class, which provides the augmented class with the ability to host plugins.
       * It adds <a href="#method_plug">plug</a> and <a href="#method_unplug">unplug</a> methods to the augmented class, which can 
       * be used to add or remove plugins from instances of the class.
       * </p>
       *
       * <p>Plugins can also be added through the constructor configuration object passed to the host class' constructor using
       * the "plugins" property. Supported values for the "plugins" property are those defined by the <a href="#method_plug">plug</a> method. 
       * 
       * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host):
       * <xmp>
       * var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]});
       * </xmp>
       * </p>
       * <p>
       * Plug.Host's protected <a href="#method_initPlugins">_initPlugins</a> and <a href="#method_destroyPlugins">_destroyPlugins</a> 
       * methods should be invoked by the host class at the appropriate point in the host's lifecyle.  
       * </p>
       *
       * @class Plugin.Host
       */
  
      var L = Y.Lang;
  
      function PluginHost() {
          this._plugins = {};
      }
  
      PluginHost.prototype = {
  
          /**
           * Adds a plugin to the host object. This will instantiate the 
           * plugin and attach it to the configured namespace on the host object.
           *
           * @method plug
           * @chainable
           * @param P {Function | Object |Array} Accepts the plugin class, or an 
           * object with a "fn" property specifying the plugin class and 
           * a "cfg" property specifying the configuration for the Plugin.
           * <p>
           * Additionally an Array can also be passed in, with the above function or 
           * object values, allowing the user to add multiple plugins in a single call.
           * </p>
           * @param config (Optional) If the first argument is the plugin class, the second argument
           * can be the configuration for the plugin.
           * @return {Base} A reference to the host object
           */
          plug: function(Plugin, config) {
              var i, ln, ns;
  
              if (L.isArray(Plugin)) {
                  for (i = 0, ln = Plugin.length; i < ln; i++) {
                      this.plug(Plugin[i]);
                  }
              } else {
                  if (Plugin && !L.isFunction(Plugin)) {
                      config = Plugin.cfg;
                      Plugin = Plugin.fn;
                  }
  
                  // Plugin should be fn by now
                  if (Plugin && Plugin.NS) {
                      ns = Plugin.NS;
          
                      config = config || {};
                      config.host = this;
          
                      if (this.hasPlugin(ns)) {
                          // Update config
                          if (this[ns].setAttrs) {
                              this[ns].setAttrs(config);
                          }
                      } else {
                          // Create new instance
                          this[ns] = new Plugin(config);
                          this._plugins[ns] = Plugin;
                      }
                  }
              }
              return this;
          },
  
          /**
           * Removes a plugin from the host object. This will destroy the 
           * plugin instance and delete the namespace from the host object. 
           *
           * @method unplug
           * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided,
           * all registered plugins are unplugged.
           * @return {Base} A reference to the host object
           * @chainable
           */
          unplug: function(plugin) {
              var ns = plugin, 
                  plugins = this._plugins;
              
              if (plugin) {
                  if (L.isFunction(plugin)) {
                      ns = plugin.NS;
                      if (ns && (!plugins[ns] || plugins[ns] !== plugin)) {
                          ns = null;
                      }
                  }
          
                  if (ns) {
                      if (this[ns]) {
                          if (this[ns].destroy) {
                              this[ns].destroy();
                          }
                          delete this[ns];
                      }
                      if (plugins[ns]) {
                          delete plugins[ns];
                      }
                  }
              } else {
                  for (ns in this._plugins) {
                      if (this._plugins.hasOwnProperty(ns)) {
                          this.unplug(ns);
                      }
                  }
              }
              return this;
          },
  
          /**
           * Determines if a plugin has plugged into this host.
           *
           * @method hasPlugin
           * @param {String} ns The plugin's namespace
           * @return {Plugin} Returns a truthy value (the plugin instance) if present, or undefined if not.
           */
          hasPlugin : function(ns) {
              return (this._plugins[ns] && this[ns]);
          },
  
          /**
           * Initializes static plugins registered on the host (using the
           * Base.plug static method) and any plugins passed to the 
           * instance through the "plugins" configuration property.
           *
           * @method _initPlugins
           * @param {Config} config The configuration object with property name/value pairs.
           * @private
           */
          
          _initPlugins: function(config) {
              this._plugins = this._plugins || {};
  
              if (this._initConfigPlugins) {
                  this._initConfigPlugins(config);
              }
          },
  
          /**
           * Unplugs and destroys all plugins on the host
           * @method _destroyPlugins
           * @private
           */
          _destroyPlugins: function() {
              this.unplug();
          }
      };
  
      Y.namespace("Plugin").Host = PluginHost;
  
  
  }, '@VERSION@', {"requires": ["yui-base"]});
  