/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0

build: 1549

*/

YUI.add('selector-native', function(Y) {

(function(Y) {

/**

 * The selector-native module provides support for native querySelector

 * @module dom

 * @submodule selector-native

 * @for Selector

 */

/**

 * Provides support for using CSS selectors to query the DOM 

 * @class Selector 

 * @static

 * @for Selector

 */

Y.namespace('Selector'); // allow native module to standalone

var COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition',

    OWNER_DOCUMENT = 'ownerDocument',

    TMP_PREFIX = 'yui-tmp-',

    g_counter = 0;

var Selector = {

    _foundCache: [],

    useNative: true,

    _compare: ('sourceIndex' in document.documentElement) ?

        function(nodeA, nodeB) {

            var a = nodeA.sourceIndex,

                b = nodeB.sourceIndex;

            if (a === b) {

                return 0;

            } else if (a > b) {

                return 1;

            }

            return -1;

        } : (document.documentElement[COMPARE_DOCUMENT_POSITION] ?

        function(nodeA, nodeB) {

            if (nodeA[COMPARE_DOCUMENT_POSITION](nodeB) & 4) {

                return -1;

            } else {

                return 1;

            }

        } :

        function(nodeA, nodeB) {

            var rangeA, rangeB, compare;

            if (nodeA && nodeB) {

                rangeA = nodeA[OWNER_DOCUMENT].createRange();

                rangeA.setStart(nodeA, 0);

                rangeB = nodeB[OWNER_DOCUMENT].createRange();

                rangeB.setStart(nodeB, 0);

                compare = rangeA.compareBoundaryPoints(1, rangeB); // 1 === Range.START_TO_END

            }

            return compare;

    }),

    _sort: function(nodes) {

        if (nodes) {

            nodes = Y.Array(nodes, 0, true);

            if (nodes.sort) {

                nodes.sort(Selector._compare);

            }

        }

        return nodes;

    },

    _deDupe: function(nodes) {

        var ret = [],

            i, node;

        for (i = 0; (node = nodes[i++]);) {

            if (!node._found) {

                ret[ret.length] = node;

                node._found = true;

            }

        }

        for (i = 0; (node = ret[i++]);) {

            node._found = null;

            node.removeAttribute('_found');

        }

        return ret;

    },

    /**

     * Retrieves a set of nodes based on a given CSS selector. 

     * @method query

     *

     * @param {string} selector The CSS Selector to test the node against.

     * @param {HTMLElement} root optional An HTMLElement to start the query from. Defaults to Y.config.doc

     * @param {Boolean} firstOnly optional Whether or not to return only the first match.

     * @return {Array} An array of nodes that match the given selector.

     * @static

     */

    query: function(selector, root, firstOnly, skipNative) {

        root = root || Y.config.doc;

        var ret = [],

            useNative = (Y.Selector.useNative && document.querySelector && !skipNative),

            queries = [[selector, root]],

            query,

            result,

            i,

            fn = (useNative) ? Y.Selector._nativeQuery : Y.Selector._bruteQuery;

        if (selector && fn) {

            // split group into seperate queries

            if (!skipNative && // already done if skipping

                    (!useNative || root.tagName)) { // split native when element scoping is needed

                queries = Selector._splitQueries(selector, root);

            }

            for (i = 0; (query = queries[i++]);) {

                result = fn(query[0], query[1], firstOnly);

                if (!firstOnly) { // coerce DOM Collection to Array

                    result = Y.Array(result, 0, true);

                }

                if (result) {

                    ret = ret.concat(result);

                }

            }

            if (queries.length > 1) { // remove dupes and sort by doc order 

                ret = Selector._sort(Selector._deDupe(ret));

            }

        }

        Y.log('query: ' + selector + ' returning: ' + ret.length, 'info', 'Selector');

        return (firstOnly) ? (ret[0] || null) : ret;

    },

    // allows element scoped queries to begin with combinator

    // e.g. query('> p', document.body) === query('body > p')

    _splitQueries: function(selector, node) {

        var groups = selector.split(','),

            queries = [],

            prefix = '',

            i, len;

        if (node) {

            // enforce for element scoping

            if (node.tagName) {

                node.id = node.id || Y.guid();

                prefix = '#' + node.id + ' ';

            }

            for (i = 0, len = groups.length; i < len; ++i) {

                selector =  prefix + groups[i];

                queries.push([selector, node]);

            }

        }

        return queries;

    },

    _nativeQuery: function(selector, root, one) {

        try {

            //Y.log('trying native query with: ' + selector, 'info', 'selector-native');

            return root['querySelector' + (one ? '' : 'All')](selector);

        } catch(e) { // fallback to brute if available

            //Y.log('native query error; reverting to brute query with: ' + selector, 'info', 'selector-native');

            return Y.Selector.query(selector, root, one, true); // redo with skipNative true

        }

    },

    filter: function(nodes, selector) {

        var ret = [],

            i, node;

        if (nodes && selector) {

            for (i = 0; (node = nodes[i++]);) {

                if (Y.Selector.test(node, selector)) {

                    ret[ret.length] = node;

                }

            }

        } else {

            Y.log('invalid filter input (nodes: ' + nodes +

                    ', selector: ' + selector + ')', 'warn', 'Selector');

        }

        return ret;

    },

    test: function(node, selector, root) {

        var ret = false,

            groups = selector.split(','),

            item,

            i, group;

        if (node && node.tagName) { // only test HTMLElements

            root = root || node.ownerDocument;

            if (!node.id) {

                node.id = TMP_PREFIX + g_counter++;

            }

            for (i = 0; (group = groups[i++]);) { // TODO: off-dom test

                group += '#' + node.id; // add ID for uniqueness

                item = Y.Selector.query(group, root, true);

                ret = (item === node);

                if (ret) {

                    break;

                }

            }

        }

        return ret;

    }

};

Y.mix(Y.Selector, Selector, true);

})(Y);

}, '3.0.0' ,{requires:['dom-base']});

YUI.add('selector-css2', function(Y) {

/**

 * The selector module provides helper methods allowing CSS2 Selectors to be used with DOM elements.

 * @module dom

 * @submodule selector-css2

 * @for Selector

 */

/**

 * Provides helper methods for collecting and filtering DOM elements.

 */

var PARENT_NODE = 'parentNode',

    TAG_NAME = 'tagName',

    ATTRIBUTES = 'attributes',

    COMBINATOR = 'combinator',

    PSEUDOS = 'pseudos',

    Selector = Y.Selector,

    SelectorCSS2 = {

        SORT_RESULTS: true,

        _children: function(node, tag) {

            var ret = node.children,

                i,

                children = [],

                childNodes,

                child;

            if (node.children && tag && node.children.tags) {

                children = node.children.tags(tag);

            } else if ((!ret && node[TAG_NAME]) || (ret && tag)) { // only HTMLElements have children

                childNodes = ret || node.childNodes;

                ret = [];

                for (i = 0; (child = childNodes[i++]);) {

                    if (child.tagName) {

                        if (!tag || tag === child.tagName) {

                            ret.push(child);

                        }

                    }

                }

            }

            return ret || [];

        },

        _regexCache: {},

        _re: {

            attr: /(\[.*\])/g,

            pseudos: /:([\-\w]+(?:\(?:['"]?(.+)['"]?\)))*/i

        },

        /**

         * Mapping of shorthand tokens to corresponding attribute selector 

         * @property shorthand

         * @type object

         */

        shorthand: {

            '\\#(-?[_a-z]+[-\\w]*)': '[id=$1]',

            '\\.(-?[_a-z]+[-\\w]*)': '[className~=$1]'

        },

        /**

         * List of operators and corresponding boolean functions. 

         * These functions are passed the attribute and the current node's value of the attribute.

         * @property operators

         * @type object

         */

        operators: {

            '': function(node, attr) { return Y.DOM.getAttribute(node, attr) !== ''; }, // Just test for existence of attribute

            //'': '.+',

            //'=': '^{val}$', // equality

            '~=': '(?:^|\\s+){val}(?:\\s+|$)', // space-delimited

            '|=': '^{val}-?' // optional hyphen-delimited

        },

        pseudos: {

           'first-child': function(node) { 

                return Y.Selector._children(node[PARENT_NODE])[0] === node; 

            } 

        },

        _bruteQuery: function(selector, root, firstOnly) {

            var ret = [],

                nodes = [],

                tokens = Selector._tokenize(selector),

                token = tokens[tokens.length - 1],

                rootDoc = Y.DOM._getDoc(root),

                id,

                className,

                tagName;

            // if we have an initial ID, set to root when in document

            if (tokens[0] && rootDoc === root &&  

                    (id = tokens[0].id) &&

                    rootDoc.getElementById(id)) {

                root = rootDoc.getElementById(id);

            }

            if (token) {

                // prefilter nodes

                id = token.id;

                className = token.className;

                tagName = token.tagName || '*';

                // try ID first

                if (id) {

                    if (rootDoc.getElementById(id)) { // if in document

                    nodes = [rootDoc.getElementById(id)]; // TODO: DOM.byId?

                }

                // try className if supported

                } else if (className) {

                    nodes = root.getElementsByClassName(className);

                } else if (tagName) { // default to tagName

                    nodes = root.getElementsByTagName(tagName || '*');

                }

                if (nodes.length) {

                    ret = Selector._filterNodes(nodes, tokens, firstOnly);

                }

            }

            return ret;

        },

        _filterNodes: function(nodes, tokens, firstOnly) {

            var i = 0,

                j,

                len = tokens.length,

                n = len - 1,

                result = [],

                node = nodes[0],

                tmpNode = node,

                getters = Y.Selector.getters,

                operator,

                combinator,

                token,