YUI.add('stylesheet', function (Y, NAME) {

/**

 * The StyleSheet component is a module for creating and modifying CSS

 * stylesheets.

 *

 * @module stylesheet

 */

var d      = Y.config.doc,

    p      = d.createElement('p'), // Have to hold the node (see notes)

    workerStyle = p.style, // worker style collection

    isString = Y.Lang.isString,

    selectors = {},

    sheets = {},

    floatAttr = ('cssFloat' in workerStyle) ? 'cssFloat' : 'styleFloat',

    _toCssText,

    _unsetOpacity,

    _unsetProperty,

    OPACITY = 'opacity',

    FLOAT   = 'float',

    EMPTY   = '';

// Normalizes the removal of an assigned style for opacity.  IE uses the filter

// property.

_unsetOpacity = (OPACITY in workerStyle) ?

    function (style) { style.opacity = EMPTY; } :

    function (style) { style.filter = EMPTY; };

// Normalizes the removal of an assigned style for a given property.  Expands

// shortcut properties if necessary and handles the various names for the float

// property.

workerStyle.border = "1px solid red";

workerStyle.border = EMPTY; // IE doesn't unset child properties

_unsetProperty = workerStyle.borderLeft ?

    function (style,prop) {

        var p;

        if (prop !== floatAttr && prop.toLowerCase().indexOf(FLOAT) != -1) {

            prop = floatAttr;

        }

        if (isString(style[prop])) {

            switch (prop) {

                case OPACITY:

                case 'filter' : _unsetOpacity(style); break;

                case 'font'   :

                    style.font       = style.fontStyle = style.fontVariant =

                    style.fontWeight = style.fontSize  = style.lineHeight  =

                    style.fontFamily = EMPTY;

                    break;

                default       :

                    for (p in style) {

                        if (p.indexOf(prop) === 0) {

                            style[p] = EMPTY;

                        }

                    }

            }

        }

    } :

    function (style,prop) {

        if (prop !== floatAttr && prop.toLowerCase().indexOf(FLOAT) != -1) {

            prop = floatAttr;

        }

        if (isString(style[prop])) {

            if (prop === OPACITY) {

                _unsetOpacity(style);

            } else {

                style[prop] = EMPTY;

            }

        }

    };

/**

 * Create an instance of StyleSheet to encapsulate a css stylesheet.

 * The constructor can be called using function or constructor syntax.

 * <pre><code>var sheet = Y.StyleSheet(..);</pre></code>

 * or

 * <pre><code>var sheet = new Y.StyleSheet(..);</pre></code>

 *

 * The first parameter passed can be any of the following things:

 * <ul>

 *   <li>The desired string name to register a new empty sheet</li>

 *   <li>The string name of an existing StyleSheet instance</li>

 *   <li>The unique guid generated for an existing StyleSheet instance</li>

 *   <li>The id of an existing <code>&lt;link&gt;</code> or <code>&lt;style&gt;</code> node</li>

 *   <li>The node reference for an existing <code>&lt;link&gt;</code> or <code>&lt;style&gt;</code> node</li>

 *   <li>The Y.Node instance wrapping an existing <code>&lt;link&gt;</code> or <code>&lt;style&gt;</code> node</li>

 *   <li>A chunk of css text to create a new stylesheet from</li>

 * </ul>

 *

 * <p>If a string is passed, StyleSheet will first look in its static name

 * registry for an existing sheet, then in the DOM for an element with that id.

 * If neither are found and the string contains the { character, it will be

 * used as a the initial cssText for a new StyleSheet.  Otherwise, a new empty

 * StyleSheet is created, assigned the string value as a name, and registered

 * statically by that name.</p>

 *

 * <p>The optional second parameter is a string name to register the sheet as.

 * This param is largely useful when providing a node id/ref or chunk of css

 * text to create a populated instance.</p>

 *

 * @class StyleSheet

 * @constructor

 * @param seed {String|HTMLElement|Node} a style or link node, its id, or a

 *              name or guid of a StyleSheet, or a string of css text

 * @param name {String} (optional) name to register instance for future static

 *              access

 */

function StyleSheet(seed, name) {

    var head,

        node,

        sheet,

        cssRules = {},

        _rules,

        _insertRule,

        _deleteRule,

        i,r,sel;

    // Factory or constructor

    if (!(Y.instanceOf(this, StyleSheet))) {

        return new StyleSheet(seed,name);

    }

    // Extract the DOM node from Node instances

    if (seed) {

        if (Y.Node && seed instanceof Y.Node) {

            node = seed._node;

        } else if (seed.nodeName) {

            node = seed;

        // capture the DOM node if the string is an id

        } else if (isString(seed)) {

            if (seed && sheets[seed]) {

                return sheets[seed];

            }

            node = d.getElementById(seed.replace(/^#/,EMPTY));

        }

        // Check for the StyleSheet in the static registry

        if (node && sheets[Y.stamp(node)]) {

            return sheets[Y.stamp(node)];

        }

    }

    // Create a style node if necessary

    if (!node || !/^(?:style|link)$/i.test(node.nodeName)) {

        node = d.createElement('style');

        node.type = 'text/css';

    }

    if (isString(seed)) {

        // Create entire sheet from seed cssText

        if (seed.indexOf('{') != -1) {

            // Not a load-time fork because low run-time impact and IE fails

            // test for s.styleSheet at page load time (oddly)

            if (node.styleSheet) {

                node.styleSheet.cssText = seed;

            } else {

                node.appendChild(d.createTextNode(seed));

            }

        } else if (!name) {

            name = seed;

        }

    }

    // Make sure the node is attached to the appropriate head element

    if (!node.parentNode || node.parentNode.nodeName.toLowerCase() !== 'head') {

        head = (node.ownerDocument || d).getElementsByTagName('head')[0];

        // styleSheet isn't available on the style node in FF2 until appended

        // to the head element.  style nodes appended to body do not affect

        // change in Safari.

        head.appendChild(node);

    }

    // Begin setting up private aliases to the important moving parts

    // 1. The stylesheet object

    // IE stores StyleSheet under the "styleSheet" property

    // Safari doesn't populate sheet for xdomain link elements

    sheet = node.sheet || node.styleSheet;

    // 2. The style rules collection

    // IE stores the rules collection under the "rules" property

    _rules = sheet && ('cssRules' in sheet) ? 'cssRules' : 'rules';

    // 3. The method to remove a rule from the stylesheet

    // IE supports removeRule

    _deleteRule = ('deleteRule' in sheet) ?

        function (i) { sheet.deleteRule(i); } :

        function (i) { sheet.removeRule(i); };

    // 4. The method to add a new rule to the stylesheet

    // IE supports addRule with different signature

    _insertRule = ('insertRule' in sheet) ?

        function (sel,css,i) { sheet.insertRule(sel+' {'+css+'}',i); } :

        function (sel,css,i) { sheet.addRule(sel,css,i); };

    // 5. Initialize the cssRules map from the node

    // xdomain link nodes forbid access to the cssRules collection, so this

    // will throw an error.

    // TODO: research alternate stylesheet, @media

    for (i = sheet[_rules].length - 1; i >= 0; --i) {

        r   = sheet[_rules][i];

        sel = r.selectorText;

        if (cssRules[sel]) {

            cssRules[sel].style.cssText += ';' + r.style.cssText;

            _deleteRule(i);

        } else {

            cssRules[sel] = r;

        }

    }

    // Cache the instance by the generated Id

    StyleSheet.register(Y.stamp(node),this);

    // Register the instance by name if provided or defaulted from seed

    if (name) {

        StyleSheet.register(name,this);

    }

    // Public API

    Y.mix(this,{

        /**

         * Get the unique stamp for this StyleSheet instance

         *

         * @method getId

         * @return {Number} the static id

         */

        getId : function () { return Y.stamp(node); },

        /**

         * Enable all the rules in the sheet

         *

         * @method enable

         * @return {StyleSheet}

         * @chainable

         */

        enable : function () { sheet.disabled = false; return this; },

        /**

         * Disable all the rules in the sheet.  Rules may be changed while the

         * StyleSheet is disabled.

         *

         * @method disable

         * @return {StyleSheet}

         * @chainable

         */

        disable : function () { sheet.disabled = true; return this; },

        /**

         * Returns false if the StyleSheet is disabled.  Otherwise true.

         *

         * @method isEnabled

         * @return {Boolean}

         */

        isEnabled : function () { return !sheet.disabled; },

        /**

         * <p>Set style properties for a provided selector string.

         * If the selector includes commas, it will be split into individual

         * selectors and applied accordingly.  If the selector string does not

         * have a corresponding rule in the sheet, it will be added.</p>

         *

         * <p>The object properties in the second parameter must be the JavaScript

         * names of style properties.  E.g. fontSize rather than font-size.</p>

         *

         * <p>The float style property will be set by any of &quot;float&quot;,

         * &quot;styleFloat&quot;, or &quot;cssFloat&quot;.</p>

         *

         * @method set

         * @param sel {String} the selector string to apply the changes to

         * @param css {Object} Object literal of style properties and new values

         * @return {StyleSheet}

         * @chainable

         */

        set : function (sel,css) {

            var rule = cssRules[sel],

                multi = sel.split(/\s*,\s*/),i,

                idx;

            // IE's addRule doesn't support multiple comma delimited selectors

            if (multi.length > 1) {

                for (i = multi.length - 1; i >= 0; --i) {

                    this.set(multi[i], css);

                }

                return this;

            }

            // Some selector values can cause IE to hang

            if (!StyleSheet.isValidSelector(sel)) {

                return this;

            }

            // Opera throws an error if there's a syntax error in assigned

            // cssText. Avoid this using a worker style collection, then

            // assigning the resulting cssText.

            if (rule) {

                rule.style.cssText = StyleSheet.toCssText(css,rule.style.cssText);

            } else {

                idx = sheet[_rules].length;

                css = StyleSheet.toCssText(css);

                // IE throws an error when attempting to addRule(sel,'',n)

                // which would crop up if no, or only invalid values are used

                if (css) {

                    _insertRule(sel, css, idx);

                    // Safari replaces the rules collection, but maintains the

                    // rule instances in the new collection when rules are

                    // added/removed

                    cssRules[sel] = sheet[_rules][idx];

                }

            }

            return this;

        },

        /**

         * <p>Unset style properties for a provided selector string, removing

         * their effect from the style cascade.</p>

         *

         * <p>If the selector includes commas, it will be split into individual

         * selectors and applied accordingly.  If there are no properties

         * remaining in the rule after unsetting, the rule is removed.</p>

         *

         * <p>The style property or properties in the second parameter must be the

         * JavaScript style property names. E.g. fontSize rather than font-size.</p>

         *

         * <p>The float style property will be unset by any of &quot;float&quot;,

         * &quot;styleFloat&quot;, or &quot;cssFloat&quot;.</p>

         *

         * @method unset

         * @param sel {String} the selector string to apply the changes to

         * @param css {String|Array} style property name or Array of names

         * @return {StyleSheet}

         * @chainable

         */

        unset : function (sel,css) {

            var rule = cssRules[sel],

                multi = sel.split(/\s*,\s*/),

                remove = !css,

                rules, i;

            // IE's addRule doesn't support multiple comma delimited selectors

            // so rules are mapped internally by atomic selectors

            if (multi.length > 1) {

                for (i = multi.length - 1; i >= 0; --i) {

                    this.unset(multi[i], css);

                }

                return this;

            }

            if (rule) {

                if (!remove) {

                    css = Y.Array(css);

                    workerStyle.cssText = rule.style.cssText;

                    for (i = css.length - 1; i >= 0; --i) {

                        _unsetProperty(workerStyle,css[i]);

                    }

                    if (workerStyle.cssText) {

                        rule.style.cssText = workerStyle.cssText;

                    } else {

                        remove = true;

                    }

                }

                if (remove) { // remove the rule altogether

                    rules = sheet[_rules];

                    for (i = rules.length - 1; i >= 0; --i) {

                        if (rules[i] === rule) {

                            delete cssRules[sel];

                            _deleteRule(i);

                            break;

                        }

                    }

                }

            }

            return this;

        },

        /**

         * Get the current cssText for a rule or the entire sheet.  If the

         * selector param is supplied, only the cssText for that rule will be

         * returned, if found.  If the selector string targets multiple

         * selectors separated by commas, the cssText of the first rule only

         * will be returned.  If no selector string, the stylesheet's full

         * cssText will be returned.

         *

         * @method getCssText

         * @param sel {String} Selector string

         * @return {String}