YUI.add('node-base', function (Y, NAME) {

/**

 * @module node

 * @submodule node-base

 */

var methods = [

/**

 * Determines whether each node has the given className.

 * @method hasClass

 * @for Node

 * @param {String} className the class name to search for

 * @return {Boolean} Whether or not the element has the specified class

 */

 'hasClass',

/**

 * Adds a class name to each node.

 * @method addClass

 * @param {String} className the class name to add to the node's class attribute

 * @chainable

 */

 'addClass',

/**

 * Removes a class name from each 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 for each 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 the 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 the 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

 */

/**

 * 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.

     * @method appendTo

     * @param {Node | HTMLElement} node The node to append to

     * @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, [