text: YUI.add('node-base', function (Y, NAME) {
  
  /**
   * @module node
   * @submodule node-base
   */
  
  var methods = [
  /**
   * Determines whether the node has the given className.
   * @method hasClass
   * @for Node
   * @param {String} className the class name to search for
   * @return {Boolean} Whether or not the node has the specified class
   */
   'hasClass',
  
  /**
   * Adds a class name to the node.
   * @method addClass
   * @param {String} className the class name to add to the node's class attribute
   * @chainable
   */
   'addClass',
  
  /**
   * Removes a class name from the node.
   * @method removeClass
   * @param {String} className the class name to remove from the node's class attribute
   * @chainable
   */
   'removeClass',
  
  /**
   * Replace a class with another class on the node.
   * If no oldClassName is present, the newClassName is simply added.
   * @method replaceClass
   * @param {String} oldClassName the class name to be replaced
   * @param {String} newClassName the class name that will be replacing the old class name
   * @chainable
   */
   'replaceClass',
  
  /**
   * If the className exists on the node it is removed, if it doesn't exist it is added.
   * @method toggleClass
   * @param {String} className the class name to be toggled
   * @param {Boolean} force Option to force adding or removing the class.
   * @chainable
   */
   'toggleClass'
  ];
  
  Y.Node.importMethod(Y.DOM, methods);
  /**
   * Determines whether each node has the given className.
   * @method hasClass
   * @see Node.hasClass
   * @for NodeList
   * @param {String} className the class name to search for
   * @return {Array} An array of booleans for each node bound to the NodeList.
   */
  
  /**
   * Adds a class name to each node.
   * @method addClass
   * @see Node.addClass
   * @param {String} className the class name to add to each node's class attribute
   * @chainable
   */
  
  /**
   * Removes a class name from each node.
   * @method removeClass
   * @see Node.removeClass
   * @param {String} className the class name to remove from each node's class attribute
   * @chainable
   */
  
  /**
   * Replace a class with another class for each node.
   * If no oldClassName is present, the newClassName is simply added.
   * @method replaceClass
   * @see Node.replaceClass
   * @param {String} oldClassName the class name to be replaced
   * @param {String} newClassName the class name that will be replacing the old class name
   * @chainable
   */
  
  /**
   * For each node, if the className exists on the node it is removed, if it doesn't exist it is added.
   * @method toggleClass
   * @see Node.toggleClass
   * @param {String} className the class name to be toggled
   * @chainable
   */
  Y.NodeList.importMethod(Y.Node.prototype, methods);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node,
      Y_DOM = Y.DOM;
  
  /**
   * Returns a new dom node using the provided markup string.
   * @method create
   * @static
   * @param {String} html The markup used to create the element.
   * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
   * to escape html content.
   * @param {HTMLDocument} doc An optional document context
   * @return {Node} A Node instance bound to a DOM node or fragment
   * @for Node
   */
  Y_Node.create = function(html, doc) {
      if (doc && doc._node) {
          doc = doc._node;
      }
      return Y.one(Y_DOM.create(html, doc));
  };
  
  Y.mix(Y_Node.prototype, {
      /**
       * Creates a new Node using the provided markup string.
       * @method create
       * @param {String} html The markup used to create the element.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @param {HTMLDocument} doc An optional document context
       * @return {Node} A Node instance bound to a DOM node or fragment
       */
      create: Y_Node.create,
  
      /**
       * Inserts the content before the reference node.
       * @method insert
       * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @param {Int | Node | HTMLElement | String} where The position to insert at.
       * Possible "where" arguments
       * <dl>
       * <dt>Y.Node</dt>
       * <dd>The Node to insert before</dd>
       * <dt>HTMLElement</dt>
       * <dd>The element to insert before</dd>
       * <dt>Int</dt>
       * <dd>The index of the child element to insert before</dd>
       * <dt>"replace"</dt>
       * <dd>Replaces the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts before the existing HTML</dd>
       * <dt>"before"</dt>
       * <dd>Inserts content before the node</dd>
       * <dt>"after"</dt>
       * <dd>Inserts content after the node</dd>
       * </dl>
       * @chainable
       */
      insert: function(content, where) {
          this._insert(content, where);
          return this;
      },
  
      _insert: function(content, where) {
          var node = this._node,
              ret = null;
  
          if (typeof where == 'number') { // allow index
              where = this._node.childNodes[where];
          } else if (where && where._node) { // Node
              where = where._node;
          }
  
          if (content && typeof content != 'string') { // allow Node or NodeList/Array instances
              content = content._node || content._nodes || content;
          }
          ret = Y_DOM.addHTML(node, content, where);
  
          return ret;
      },
  
      /**
       * Inserts the content as the firstChild of the node.
       * @method prepend
       * @param {String | Node | HTMLElement} content The content to insert.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @chainable
       */
      prepend: function(content) {
          return this.insert(content, 0);
      },
  
      /**
       * Inserts the content as the lastChild of the node.
       * @method append
       * @param {String | Node | HTMLElement} content The content to insert.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @chainable
       */
      append: function(content) {
          return this.insert(content, null);
      },
  
      /**
       * @method appendChild
       * @param {String | HTMLElement | Node} node Node to be appended.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @return {Node} The appended node
       */
      appendChild: function(node) {
          return Y_Node.scrubVal(this._insert(node));
      },
  
      /**
       * @method insertBefore
       * @param {String | HTMLElement | Node} newNode Node to be appended
       * @param {HTMLElement | Node} refNode Node to be inserted before.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content.
       * @return {Node} The inserted node
       */
      insertBefore: function(newNode, refNode) {
          return Y.Node.scrubVal(this._insert(newNode, refNode));
      },
  
      /**
       * Appends the node to the given node.
       * @example
       *      // appendTo returns the node that has been created beforehand
       *      Y.Node.create('<p></p>').appendTo('body').set('text', 'hello world!');
       * @method appendTo
       * @param {Node | HTMLElement | String} node The node to append to.
       *  If `node` is a string it will be considered as a css selector and only the first matching node will be used.
       * @chainable
       */
      appendTo: function(node) {
          Y.one(node).append(this);
          return this;
      },
      
      // This method is deprecated, and is intentionally left undocumented.
      // Use `setHTML` instead.
      setContent: function(content) {
          this._insert(content, 'replace');
          return this;
      },
      
      // This method is deprecated, and is intentionally left undocumented.
      // Use `getHTML` instead.
      getContent: function() {
          var node = this;
  
          if (node._node.nodeType === 11) { // 11 === Node.DOCUMENT_FRAGMENT_NODE
              // "this", when it is a document fragment, must be cloned because
              // the nodes contained in the fragment actually disappear once
              // the fragment is appended anywhere
              node = node.create("<div/>").append(node.cloneNode(true));
          }
  
          return node.get("innerHTML");
      }
  });
  
  /**
   * Replaces the node's current html content with the content provided.
   * Note that this passes to innerHTML and is not escaped.
   * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
   * to escape html content or `set('text')` to add as text.
   * @method setHTML
   * @param {String | Node | HTMLElement | NodeList | HTMLCollection} content The content to insert
   * @chainable
   */
  Y.Node.prototype.setHTML = Y.Node.prototype.setContent;
  
  /**
   * Returns the node's current html content (e.g. innerHTML)
   * @method getHTML
   * @return {String} The html content
   */
  Y.Node.prototype.getHTML = Y.Node.prototype.getContent;
  
  Y.NodeList.importMethod(Y.Node.prototype, [
      /**
       * Called on each Node instance
       * @for NodeList
       * @method append
       * @see Node.append
       */
      'append',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method insert
       * @see Node.insert
       */
      'insert',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method appendChild
       * @see Node.appendChild
       */
      'appendChild',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method insertBefore
       * @see Node.insertBefore
       */
      'insertBefore',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method prepend
       * @see Node.prepend
       */
      'prepend',
  
      'setContent',
  
      'getContent',
  
      /**
       * Called on each Node instance
       * Note that this passes to innerHTML and is not escaped.
       * Use <a href="../classes/Escape.html#method_html">`Y.Escape.html()`</a>
       * to escape html content or `set('text')` to add as text.
       * @for NodeList
       * @method setHTML
       * @see Node.setHTML
       */
      'setHTML',
  
      /**
       * Called on each Node instance
       * @for NodeList
       * @method getHTML
       * @see Node.getHTML
       */
      'getHTML'
  ]);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node,
      Y_DOM = Y.DOM;
  
  /**
   * Static collection of configuration attributes for special handling
   * @property ATTRS
   * @static
   * @type object
   */
  Y_Node.ATTRS = {
      /**
       * Allows for getting and setting the text of an element.
       * Formatting is preserved and special characters are treated literally.
       * @config text
       * @type String
       */
      text: {
          getter: function() {
              return Y_DOM.getText(this._node);
          },
  
          setter: function(content) {
              Y_DOM.setText(this._node, content);
              return content;
          }
      },
  
      /**
       * Allows for getting and setting the text of an element.
       * Formatting is preserved and special characters are treated literally.
       * @config for
       * @type String
       */
      'for': {
          getter: function() {
              return Y_DOM.getAttribute(this._node, 'for');
          },
  
          setter: function(val) {
              Y_DOM.setAttribute(this._node, 'for', val);
              return val;
          }
      },
  
      'options': {
          getter: function() {
              return this._node.getElementsByTagName('option');
          }
      },
  
      /**
       * Returns a NodeList instance of all HTMLElement children.
       * @readOnly
       * @config children
       * @type NodeList
       */
      'children': {
          getter: function() {
              var node = this._node,
                  children = node.children,
                  childNodes, i, len;
  
              if (!children) {
                  childNodes = node.childNodes;
                  children = [];
  
                  for (i = 0, len = childNodes.length; i < len; ++i) {
                      if (childNodes[i].tagName) {
                          children[children.length] = childNodes[i];
                      }
                  }
              }
              return Y.all(children);
          }
      },
  
      value: {
          getter: function() {
              return Y_DOM.getValue(this._node);
          },
  
          setter: function(val) {
              Y_DOM.setValue(this._node, val);
              return val;
          }
      }
  };
  
  Y.Node.importMethod(Y.DOM, [
      /**
       * Allows setting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method setAttribute
       * @for Node
       * @for NodeList
       * @chainable
       * @param {string} name The attribute name
       * @param {string} value The value to set
       */
      'setAttribute',
      /**
       * Allows getting attributes on DOM nodes, normalizing in some cases.
       * This passes through to the DOM node, allowing for custom attributes.
       * @method getAttribute
       * @for Node
       * @for NodeList
       * @param {string} name The attribute name
       * @return {string} The attribute value
       */
      'getAttribute'
  
  ]);
  /**
   * @module node
   * @submodule node-base
   */
  
  var Y_Node = Y.Node;
  var Y_NodeList = Y.NodeList;
  /**
   * List of events that route to DOM events
   * @static
   * @property DOM_EVENTS
   * @for Node
   */
  
  Y_Node.DOM_EVENTS = {
      abort: 1,
      beforeunload: 1,
      blur: 1,
      change: 1,
      click: 1,
      close: 1,
      command: 1,
      contextmenu: 1,
      copy: 1,
      cut: 1,
      dblclick: 1,
      DOMMouseScroll: 1,
      drag: 1,
      dragstart: 1,
      dragenter: 1,
      dragover: 1,
      dragleave: 1,
      dragend: 1,
      drop: 1,
      error: 1,
      focus: 1,
      key: 1,
      keydown: 1,
      keypress: 1,
      keyup: 1,
      load: 1,
      message: 1,
      mousedown: 1,
      mouseenter: 1,
      mouseleave: 1,
      mousemove: 1,
      mousemultiwheel: 1,
      mouseout: 1,
      mouseover: 1,
      mouseup: 1,
      mousewheel: 1,
      orientationchange: 1,
      paste: 1,
      reset: 1,
      resize: 1,
      select: 1,
      selectstart: 1,
      submit: 1,
      scroll: 1,
      textInput: 1,
      unload: 1,
      invalid: 1
  };
  
  // Add custom event adaptors to this list.  This will make it so
  // that delegate, key, available, contentready, etc all will
  // be available through Node.on
  Y.mix(Y_Node.DOM_EVENTS, Y.Env.evt.plugins);
  
  Y.augment(Y_Node, Y.EventTarget);
  
  Y.mix(Y_Node.prototype, {
      /**
       * Removes event listeners from the node and (optionally) its subtree
       * @method purge
       * @param {Boolean} recurse (optional) Whether or not to remove listeners from the
       * node's subtree
       * @param {String} type (optional) Only remove listeners of the specified type
       * @chainable
       *
       */
      purge: function(recurse, type) {
          Y.Event.purgeElement(this._node, recurse, type);
          return this;
      }
  
  });
  
  Y.mix(Y.NodeList.prototype, {
      _prepEvtArgs: function(type, fn, context) {
          // map to Y.on/after signature (type, fn, nodes, context, arg1, arg2, etc)
          var args = Y.Array(arguments, 0, true);
  
          if (args.length < 2) { // type only (event hash) just add nodes
              args[2] = this._nodes;
          } else {
              args.splice(2, 0, this._nodes);
          }
  
          args[3] = context || this; // default to NodeList instance as context
  
          return args;
      },
  
      /**
      Subscribe a callback function for each `Node` in the collection to execute
      in response to a DOM event.
  
      NOTE: Generally, the `on()` method should be avoided on `NodeLists`, in
      favor of using event delegation from a parent Node.  See the Event user
      guide for details.
  
      Most DOM events are associated with a preventable default behavior, such as
      link clicks navigating to a new page.  Callbacks are passed a
      `DOMEventFacade` object as their first argument (usually called `e`) that
      can be used to prevent this default behavior with `e.preventDefault()`. See
      the `DOMEventFacade` API for all available properties and methods on the
      object.
  
      By default, the `this` object will be the `NodeList` that the subscription
      came from, <em>not the `Node` that received the event</em>.  Use
      `e.currentTarget` to refer to the `Node`.
  
      Returning `false` from a callback is supported as an alternative to calling
      `e.preventDefault(); e.stopPropagation();`.  However, it is recommended to
      use the event methods.
  
      @example
  
          Y.all(".sku").on("keydown", function (e) {
              if (e.keyCode === 13) {
                  e.preventDefault();
  
                  // Use e.currentTarget to refer to the individual Node
                  var item = Y.MyApp.searchInventory( e.currentTarget.get('value') );
                  // etc ...
              }
          });
  
      @method on
      @param {String} type The name of the event
      @param {Function} fn The callback to execute in response to the event
      @param {Object} [context] Override `this` object in callback
      @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
      @return {EventHandle} A subscription handle capable of detaching that
                            subscription
      @for NodeList
      **/
      on: function(type, fn, context) {
          return Y.on.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an one-time event listener to each Node bound to the NodeList.
       * @method once
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      once: function(type, fn, context) {
          return Y.once.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an event listener to each Node bound to the NodeList.
       * The handler is called only after all on() handlers are called
       * and the event is not prevented.
       * @method after
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      after: function(type, fn, context) {
          return Y.after.apply(Y, this._prepEvtArgs.apply(this, arguments));
      },
  
      /**
       * Applies an one-time event listener to each Node bound to the NodeList
       * that will be called only after all on() handlers are called and the
       * event is not prevented.
       *
       * @method onceAfter
       * @param {String} type The event being listened for
       * @param {Function} fn The handler to call when the event fires
       * @param {Object} context The context to call the handler with.
       * Default is the NodeList instance.
       * @return {EventHandle} A subscription handle capable of detaching that
       *                    subscription
       * @for NodeList
       */
      onceAfter: function(type, fn, context) {
          return Y.onceAfter.apply(Y, this._prepEvtArgs.apply(this, arguments));
      }
  });
  
  Y_NodeList.importMethod(Y.Node.prototype, [
      /**
        * Called on each Node instance
        * @method detach
        * @see Node.detach
        * @for NodeList
        */
      'detach',
  
      /** Called on each Node instance
        * @method detachAll
        * @see Node.detachAll
        * @for NodeList
        */
      'detachAll'
  ]);
  
  /**
  Subscribe a callback function to execute in response to a DOM event or custom
  event.
  
  Most DOM events are associated with a preventable default behavior such as
  link clicks navigating to a new page.  Callbacks are passed a `DOMEventFacade`
  object as their first argument (usually called `e`) that can be used to
  prevent this default behavior with `e.preventDefault()`. See the
  `DOMEventFacade` API for all available properties and methods on the object.
  
  If the event name passed as the first parameter is not a whitelisted DOM event,
  it will be treated as a custom event subscriptions, allowing
  `node.fire('customEventName')` later in the code.  Refer to the Event user guide
  for the full DOM event whitelist.
  
  By default, the `this` object in the callback will refer to the subscribed
  `Node`.
  
  Returning `false` from a callback is supported as an alternative to calling
  `e.preventDefault(); e.stopPropagation();`.  However, it is recommended to use
  the event methods.
  
  @example
  
      Y.one("#my-form").on("submit", function (e) {
          e.preventDefault();
  
          // proceed with ajax form submission instead...
      });
  
  @method on
  @param {String} type The name of the event
  @param {Function} fn The callback to execute in response to the event
  @param {Object} [context] Override `this` object in callback
  @param {Any} [arg*] 0..n additional arguments to supply to the subscriber
  @return {EventHandle} A subscription handle capable of detaching that
                        subscription
  @for Node
  **/
  
  Y.mix(Y.Node.ATTRS, {
      offsetHeight: {
          setter: function(h) {
              Y.DOM.setHeight(this._node, h);
              return h;
          },
  
          getter: function() {
              return this._node.offsetHeight;
          }
      },
  
      offsetWidth: {
          setter: function(w) {
              Y.DOM.setWidth(this._node, w);
              return w;
          },
  
          getter: function() {
              return this._node.offsetWidth;
          }
      }
  });
  
  Y.mix(Y.Node.prototype, {
      sizeTo: function(w, h) {
          var node;
          if (arguments.length < 2) {
              node = Y.one(w);
              w = node.get('offsetWidth');
              h = node.get('offsetHeight');
          }
  
          this.setAttrs({
              offsetWidth: w,
              offsetHeight: h
          });
      }
  });
  
  if (!Y.config.doc.documentElement.hasAttribute) { // IE < 8
      Y.Node.prototype.hasAttribute = function(attr) {
          if (attr === 'value') {
              if (this.get('value') !== "") { // IE < 8 fails to populate specified when set in HTML
                  return true;
              }
          }
          return !!(this._node.attributes[attr] &&
                  this._node.attributes[attr].specified);
      };
  }
  
  // IE throws an error when calling focus() on an element that's invisible, not
  // displayed, or disabled.
  Y.Node.prototype.focus = function () {
      try {
          this._node.focus();
      } catch (e) {
          Y.log('error focusing node: ' + e.toString(), 'error', 'node');
      }
  
      return this;
  };
  
  // IE throws error when setting input.type = 'hidden',
  // input.setAttribute('type', 'hidden') and input.attributes.type.value = 'hidden'
  Y.Node.ATTRS.type = {
      setter: function(val) {
          if (val === 'hidden') {
              try {
                  this._node.type = 'hidden';
              } catch(e) {
                  this._node.style.display = 'none';
                  this._inputType = 'hidden';
              }
          } else {
              try { // IE errors when changing the type from "hidden'
                  this._node.type = val;
              } catch (e) {
                  Y.log('error setting type: ' + val, 'info', 'node');
              }
          }
          return val;
      },
  
      getter: function() {
          return this._inputType || this._node.type;
      },
  
      _bypassProxy: true // don't update DOM when using with Attribute
  };
  
  if (Y.config.doc.createElement('form').elements.nodeType) {
      // IE: elements collection is also FORM node which trips up scrubVal.
      Y.Node.ATTRS.elements = {
              getter: function() {
                  return this.all('input, textarea, button, select');
              }
      };
  }
  /**
   * Provides methods for managing custom Node data.
   *
   * @module node
   * @main node
   * @submodule node-data
   */
  
  Y.mix(Y.Node.prototype, {
      _initData: function() {
          if (! ('_data' in this)) {
              this._data = {};
          }
      },
  
      /**
      * @method getData
      * @for Node
      * @description Retrieves arbitrary data stored on a Node instance.
      * If no data is associated with the Node, it will attempt to retrieve
      * a value from the corresponding HTML data attribute. (e.g. node.getData('foo')
      * will check node.getAttribute('data-foo')).
      * @param {string} name Optional name of the data field to retrieve.
      * If no name is given, all data is returned.
      * @return {any | Object} Whatever is stored at the given field,
      * or an object hash of all fields.
      */
      getData: function(name) {
          this._initData();
          var data = this._data,
              ret = data;
  
          if (arguments.length) { // single field
              if (name in data) {
                  ret = data[name];
              } else { // initialize from HTML attribute
                  ret = this._getDataAttribute(name);
              }
          } else if (typeof data == 'object' && data !== null) { // all fields
              ret = {};
              Y.Object.each(data, function(v, n) {
                  ret[n] = v;
              });
  
              ret = this._getDataAttributes(ret);
          }
  
          return ret;
  
      },
  
      _getDataAttributes: function(ret) {
          ret = ret || {};
          var i = 0,
              attrs = this._node.attributes,
              len = attrs.length,
              prefix = this.DATA_PREFIX,
              prefixLength = prefix.length,
              name;
  
          while (i < len) {
              name = attrs[i].name;
              if (name.indexOf(prefix) === 0) {
                  name = name.substr(prefixLength);
                  if (!(name in ret)) { // only merge if not already stored
                      ret[name] = this._getDataAttribute(name);
                  }
              }
  
              i += 1;
          }
  
          return ret;
      },
  
      _getDataAttribute: function(name) {
          name = this.DATA_PREFIX + name;
  
          var node = this._node,
              attrs = node.attributes,
              data = attrs && attrs[name] && attrs[name].value;
  
          return data;
      },
  
      /**
      * @method setData
      * @for Node
      * @description Stores arbitrary data on a Node instance.
      * This is not stored with the DOM node.
      * @param {string} name The name of the field to set. If no val
      * is given, name is treated as the data and overrides any existing data.
      * @param {any} val The value to be assigned to the field.
      * @chainable
      */
      setData: function(name, val) {
          this._initData();
          if (arguments.length > 1) {
              this._data[name] = val;
          } else {
              this._data = name;
          }
  
         return this;
      },
  
      /**
      * @method clearData
      * @for Node
      * @description Clears internally stored data.
      * @param {string} name The name of the field to clear. If no name
      * is given, all data is cleared.
      * @chainable
      */
      clearData: function(name) {
          if ('_data' in this) {
              if (typeof name != 'undefined') {
                  delete this._data[name];
              } else {
                  delete this._data;
              }
          }
  
          return this;
      }
  });
  
  Y.mix(Y.NodeList.prototype, {
      /**
      * @method getData
      * @for NodeList
      * @description Retrieves arbitrary data stored on each Node instance
      * bound to the NodeList.
      * @see Node
      * @param {string} name Optional name of the data field to retrieve.
      * If no name is given, all data is returned.
      * @return {Array} An array containing all of the data for each Node instance.
      * or an object hash of all fields.
      */
      getData: function(name) {
          var args = (arguments.length) ? [name] : [];
          return this._invoke('getData', args, true);
      },
  
      /**
      * @method setData
      * @for NodeList
      * @description Stores arbitrary data on each Node instance bound to the
      *  NodeList. This is not stored with the DOM node.
      * @param {string} name The name of the field to set. If no name
      * is given, name is treated as the data and overrides any existing data.
      * @param {any} val The value to be assigned to the field.
      * @chainable
      */
      setData: function(name, val) {
          var args = (arguments.length > 1) ? [name, val] : [name];
          return this._invoke('setData', args);
      },
  
      /**
      * @method clearData
      * @for NodeList
      * @description Clears data on all Node instances bound to the NodeList.
      * @param {string} name The name of the field to clear. If no name
      * is given, all data is cleared.
      * @chainable
      */
      clearData: function(name) {
          var args = (arguments.length) ? [name] : [];
          return this._invoke('clearData', [name]);
      }
  });
  
  
  }, '@VERSION@', {"requires": ["event-base", "node-core", "dom-base", "dom-style"]});
  