include/javascript/yui/build/stylesheet/stylesheet.js

   1 /*
   2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.net/yui/license.txt
   5 version: 2.8.0r4
   6 */
   7 /**
   8  * The StyleSheet component is a utility for managing css rules at the
   9  * stylesheet level
  10  *
  11  * @module stylesheet
  12  * @namespace YAHOO.util
  13  * @requires yahoo
  14  * @beta
  15  */
  16 (function () {
  17
  18 var d      = document,
  19     p      = d.createElement('p'), // Have to hold the node (see notes)
  20     workerStyle = p.style, // worker style collection
  21     lang   = YAHOO.lang,
  22     selectors = {},
  23     sheets = {},
  24     ssId   = 0,
  25     floatAttr = ('cssFloat' in workerStyle) ? 'cssFloat' : 'styleFloat',
  26     _toCssText,
  27     _unsetOpacity,
  28     _unsetProperty;
  29
  30 /*
  31  * Normalizes the removal of an assigned style for opacity.  IE uses the filter property.
  32  */
  33 _unsetOpacity = ('opacity' in workerStyle) ?
  34     function (style) { style.opacity = ''; } :
  35     function (style) { style.filter = ''; };
  36
  37 /*
  38  * Normalizes the removal of an assigned style for a given property.  Expands
  39  * shortcut properties if necessary and handles the various names for the float property.
  40  */
  41 workerStyle.border = "1px solid red";
  42 workerStyle.border = ''; // IE doesn't unset child properties
  43 _unsetProperty = workerStyle.borderLeft ?
  44     function (style,prop) {
  45         var p;
  46         if (prop !== floatAttr && prop.toLowerCase().indexOf('float') != -1) {
  47             prop = floatAttr;
  48         }
  49         if (typeof style[prop] === 'string') {
  50             switch (prop) {
  51                 case 'opacity':
  52                 case 'filter' : _unsetOpacity(style); break;
  53                 case 'font'   :
  54                     style.font       = style.fontStyle = style.fontVariant =
  55                     style.fontWeight = style.fontSize  = style.lineHeight  =
  56                     style.fontFamily = '';
  57                     break;
  58                 default       :
  59                     for (p in style) {
  60                         if (p.indexOf(prop) === 0) {
  61                             style[p] = '';
  62                         }
  63                     }
  64             }
  65         }
  66     } :
  67     function (style,prop) {
  68         if (prop !== floatAttr && prop.toLowerCase().indexOf('float') != -1) {
  69             prop = floatAttr;
  70         }
  71         if (lang.isString(style[prop])) {
  72             if (prop === 'opacity') {
  73                 _unsetOpacity(style);
  74             } else {
  75                 style[prop] = '';
  76             }
  77         }
  78     };
  79
  80 /**
  81  * Create an instance of YAHOO.util.StyleSheet to encapsulate a css stylesheet.
  82  * The constructor can be called using function or constructor syntax.
  83  * <pre><code>var sheet = YAHOO.util.StyleSheet(..);</pre></code>
  84  * or
  85  * <pre><code>var sheet = new YAHOO.util.StyleSheet(..);</pre></code>
  86  *
  87  * The first parameter passed can be any of the following things:
  88  * <ul>
  89  *   <li>The desired string name to register a new empty sheet</li>
  90  *   <li>The string name of an existing YAHOO.util.StyleSheet instance</li>
  91  *   <li>The unique yuiSSID generated for an existing YAHOO.util.StyleSheet instance</li>
  92  *   <li>The id of an existing <code>&lt;link&gt;</code> or <code>&lt;style&gt;</code> node</li>
  93  *   <li>The node reference for an existing <code>&lt;link&gt;</code> or <code>&lt;style&gt;</code> node</li>
  94  *   <li>A chunk of css text to create a new stylesheet from</li>
  95  * </ul>
  96  *
  97  * <p>If a string is passed, StyleSheet will first look in its static name
  98  * registry for an existing sheet, then in the DOM for an element with that id.
  99  * If neither are found and the string contains the { character, it will be
 100  * used as a the initial cssText for a new StyleSheet.  Otherwise, a new empty
 101  * StyleSheet is created, assigned the string value as a name, and registered
 102  * statically by that name.</p>
 103  *
 104  * <p>The optional second parameter is a string name to register the sheet as.
 105  * This param is largely useful when providing a node id/ref or chunk of css
 106  * text to create a populated instance.</p>
 107  *
 108  * @class StyleSheet
 109  * @constructor
 110  * @param seed {String|HTMLElement} a style or link node, its id, or a name or
 111  *              yuiSSID of a StyleSheet, or a string of css text (see above)
 112  * @param name {String} OPTIONAL name to register instance for future static
 113  *              access
 114  */
 115 function StyleSheet(seed, name) {
 116     var head,
 117         node,
 118         sheet,
 119         cssRules = {},
 120         _rules,
 121         _insertRule,
 122         _deleteRule,
 123         i,r,sel;
 124
 125     // Factory or constructor
 126     if (!(this instanceof StyleSheet)) {
 127         return new StyleSheet(seed,name);
 128     }
 129
 130     // capture the DOM node if the string is an id
 131     node = seed && (seed.nodeName ? seed : d.getElementById(seed));
 132
 133     // Check for the StyleSheet in the static registry
 134     if (seed && sheets[seed]) {
 135         return sheets[seed];
 136     } else if (node && node.yuiSSID && sheets[node.yuiSSID]) {
 137         return sheets[node.yuiSSID];
 138     }
 139
 140     // Create a style node if necessary
 141     if (!node || !/^(?:style|link)$/i.test(node.nodeName)) {
 142         node = d.createElement('style');
 143         node.type = 'text/css';
 144     }
 145
 146     if (lang.isString(seed)) {
 147         // Create entire sheet from seed cssText
 148         if (seed.indexOf('{') != -1) {
 149             // Not a load-time fork because low run-time impact and IE fails
 150             // test for s.styleSheet at page load time (oddly)
 151             if (node.styleSheet) {
 152                 node.styleSheet.cssText = seed;
 153             } else {
 154                 node.appendChild(d.createTextNode(seed));
 155             }
 156         } else if (!name) {
 157             name = seed;
 158         }
 159     }
 160
 161     if (!node.parentNode || node.parentNode.nodeName.toLowerCase() !== 'head') {
 162         head = (node.ownerDocument || d).getElementsByTagName('head')[0];
 163         // styleSheet isn't available on the style node in FF2 until appended
 164         // to the head element.  style nodes appended to body do not affect
 165         // change in Safari.
 166         head.appendChild(node);
 167     }
 168
 169     // Begin setting up private aliases to the important moving parts
 170     // 1. The stylesheet object
 171     // IE stores StyleSheet under the "styleSheet" property
 172     // Safari doesn't populate sheet for xdomain link elements
 173     sheet = node.sheet || node.styleSheet;
 174
 175     // 2. The style rules collection
 176     // IE stores the rules collection under the "rules" property
 177     _rules = sheet && ('cssRules' in sheet) ? 'cssRules' : 'rules';
 178
 179     // 3. The method to remove a rule from the stylesheet
 180     // IE supports removeRule
 181     _deleteRule = ('deleteRule' in sheet) ?
 182         function (i) { sheet.deleteRule(i); } :
 183         function (i) { sheet.removeRule(i); };
 184
 185     // 4. The method to add a new rule to the stylesheet
 186     // IE supports addRule with different signature
 187     _insertRule = ('insertRule' in sheet) ?
 188         function (sel,css,i) { sheet.insertRule(sel+' {'+css+'}',i); } :
 189         function (sel,css,i) { sheet.addRule(sel,css,i); };
 190
 191     // 5. Initialize the cssRules map from the node
 192     // xdomain link nodes forbid access to the cssRules collection, so this
 193     // will throw an error.
 194     // TODO: research alternate stylesheet, @media
 195     for (i = sheet[_rules].length - 1; i >= 0; --i) {
 196         r   = sheet[_rules][i];
 197         sel = r.selectorText;
 198
 199         if (cssRules[sel]) {
 200             cssRules[sel].style.cssText += ';' + r.style.cssText;
 201             _deleteRule(i);
 202         } else {
 203             cssRules[sel] = r;
 204         }
 205     }
 206
 207     // Cache the instance by the generated Id
 208     node.yuiSSID = 'yui-stylesheet-' + (ssId++);
 209     StyleSheet.register(node.yuiSSID,this);
 210
 211     // Register the instance by name if provided or defaulted from seed
 212     if (name) {
 213         StyleSheet.register(name,this);
 214     }
 215
 216     // Public API
 217     lang.augmentObject(this,{
 218         /**
 219          * Get the unique yuiSSID for this StyleSheet instance
 220          *
 221          * @method getId
 222          * @return {Number} the static id
 223          */
 224         getId : function () { return node.yuiSSID; },
 225
 226         /**
 227          * The HTMLElement that this instance encapsulates
 228          *
 229          * @property node
 230          * @type HTMLElement
 231          */
 232         node : node,
 233
 234         /**
 235          * Enable all the rules in the sheet
 236          *
 237          * @method enable
 238          * @return {StyleSheet} the instance
 239          * @chainable
 240          */
 241         // Enabling/disabling the stylesheet.  Changes may be made to rules
 242         // while disabled.
 243         enable : function () { sheet.disabled = false; return this; },
 244
 245         /**
 246          * Disable all the rules in the sheet.  Rules may be changed while the
 247          * StyleSheet is disabled.
 248          *
 249          * @method disable
 250          * @return {StyleSheet} the instance
 251          * @chainable
 252          */
 253         disable : function () { sheet.disabled = true; return this; },
 254
 255         /**
 256          * Returns boolean indicating whether the StyleSheet is enabled
 257          *
 258          * @method isEnabled
 259          * @return {Boolean} is it enabled?
 260          */
 261         isEnabled : function () { return !sheet.disabled; },
 262
 263         /**
 264          * <p>Set style properties for a provided selector string.
 265          * If the selector includes commas, it will be split into individual
 266          * selectors and applied accordingly.  If the selector string does not
 267          * have a corresponding rule in the sheet, it will be added.</p>
 268          *
 269          * <p>The second parameter can be either a string of CSS text,
 270          * formatted as CSS ("font-size: 10px;"), or an object collection of
 271          * properties and their new values.  Object properties must be in
 272          * JavaScript format ({ fontSize: "10px" }).</p>
 273          *
 274          * <p>The float style property will be set by any of &quot;float&quot;,
 275          * &quot;styleFloat&quot;, or &quot;cssFloat&quot; if passed in the
 276          * object map.  Use "float: left;" format when passing a CSS text
 277          * string.</p>
 278          *
 279          * @method set
 280          * @param sel {String} the selector string to apply the changes to
 281          * @param css {Object|String} Object literal of style properties and
 282          *                      new values, or a string of cssText
 283          * @return {StyleSheet} the StyleSheet instance
 284          * @chainable
 285          */
 286         set : function (sel,css) {
 287             var rule = cssRules[sel],
 288                 multi = sel.split(/\s*,\s*/),i,
 289                 idx;
 290
 291             // IE's addRule doesn't support multiple comma delimited selectors
 292             if (multi.length > 1) {
 293                 for (i = multi.length - 1; i >= 0; --i) {
 294                     this.set(multi[i], css);
 295                 }
 296                 return this;
 297             }
 298
 299             // Some selector values can cause IE to hang
 300             if (!StyleSheet.isValidSelector(sel)) {
 301                 return this;
 302             }
 303
 304             // Opera throws an error if there's a syntax error in assigned
 305             // cssText. Avoid this using a worker style collection, then
 306             // assigning the resulting cssText.
 307             if (rule) {
 308                 rule.style.cssText = StyleSheet.toCssText(css,rule.style.cssText);
 309             } else {
 310                 idx = sheet[_rules].length;
 311                 css = StyleSheet.toCssText(css);
 312
 313                 // IE throws an error when attempting to addRule(sel,'',n)
 314                 // which would crop up if no, or only invalid values are used
 315                 if (css) {
 316                     _insertRule(sel, css, idx);
 317
 318                     // Safari replaces the rules collection, but maintains the
 319                     // rule instances in the new collection when rules are
 320                     // added/removed
 321                     cssRules[sel] = sheet[_rules][idx];
 322                 }
 323             }
 324             return this;
 325         },
 326
 327         /**
 328          * <p>Unset style properties for a provided selector string, removing
 329          * their effect from the style cascade.</p>
 330          *
 331          * <p>If the selector includes commas, it will be split into individual
 332          * selectors and applied accordingly.  If there are no properties
 333          * remaining in the rule after unsetting, the rule is removed.</p>
 334          *
 335          * <p>The style property or properties in the second parameter must be the
 336          * <p>JavaScript style property names. E.g. fontSize rather than font-size.</p>
 337          *
 338          * <p>The float style property will be unset by any of &quot;float&quot;,
 339          * &quot;styleFloat&quot;, or &quot;cssFloat&quot;.</p>
 340          *
 341          * @method unset
 342          * @param sel {String} the selector string to apply the changes to
 343          * @param css {String|Array} style property name or Array of names
 344          * @return {StyleSheet} the StyleSheet instance
 345          * @chainable
 346          */
 347         unset : function (sel,css) {
 348             var rule = cssRules[sel],
 349                 multi = sel.split(/\s*,\s*/),
 350                 remove = !css,
 351                 rules, i;
 352
 353             // IE's addRule doesn't support multiple comma delimited selectors
 354             // so rules are mapped internally by atomic selectors
 355             if (multi.length > 1) {
 356                 for (i = multi.length - 1; i >= 0; --i) {
 357                     this.unset(multi[i], css);
 358                 }
 359                 return this;
 360             }
 361
 362             if (rule) {
 363                 if (!remove) {
 364                     if (!lang.isArray(css)) {
 365                         css = [css];
 366                     }
 367
 368                     workerStyle.cssText = rule.style.cssText;
 369                     for (i = css.length - 1; i >= 0; --i) {
 370                         _unsetProperty(workerStyle,css[i]);
 371                     }
 372
 373                     if (workerStyle.cssText) {
 374                         rule.style.cssText = workerStyle.cssText;
 375                     } else {
 376                         remove = true;
 377                     }
 378                 }
 379
 380                 if (remove) { // remove the rule altogether
 381                     rules = sheet[_rules];
 382                     for (i = rules.length - 1; i >= 0; --i) {
 383                         if (rules[i] === rule) {
 384                             delete cssRules[sel];
 385                             _deleteRule(i);
 386                             break;
 387                         }
 388                     }
 389                 }
 390             }
 391             return this;
 392         },
 393
 394         /**
 395          * Get the current cssText for a rule or the entire sheet.  If the
 396          * selector param is supplied, only the cssText for that rule will be
 397          * returned, if found.  If the selector string targets multiple
 398          * selectors separated by commas, the cssText of the first rule only
 399          * will be returned.  If no selector string, the stylesheet's full
 400          * cssText will be returned.
 401          *
 402          * @method getCssText
 403          * @param sel {String} Selector string
 404          * @return {String}
 405          */
 406         getCssText : function (sel) {
 407             var rule,css;
 408
 409             if (lang.isString(sel)) {
 410                 // IE's addRule doesn't support multiple comma delimited
 411                 // selectors so rules are mapped internally by atomic selectors
 412                 rule = cssRules[sel.split(/\s*,\s*/)[0]];
 413
 414                 return rule ? rule.style.cssText : null;
 415             } else {
 416                 css = [];
 417                 for (sel in cssRules) {
 418                     if (cssRules.hasOwnProperty(sel)) {
 419                         rule = cssRules[sel];
 420                         css.push(rule.selectorText+" {"+rule.style.cssText+"}");
 421                     }
 422                 }
 423                 return css.join("\n");
 424             }
 425         }
 426     },true);
 427
 428 }
 429
 430 _toCssText = function (css,base) {
 431     var f = css.styleFloat || css.cssFloat || css['float'],
 432         prop;
 433
 434     workerStyle.cssText = base || '';
 435
 436     if (lang.isString(css)) {
 437         // There is a danger here of incremental memory consumption in Opera
 438         workerStyle.cssText += ';' + css;
 439     } else {
 440         if (f && !css[floatAttr]) {
 441             css = lang.merge(css);
 442             delete css.styleFloat; delete css.cssFloat; delete css['float'];
 443             css[floatAttr] = f;
 444         }
 445
 446         for (prop in css) {
 447             if (css.hasOwnProperty(prop)) {
 448                 try {
 449                     // IE throws Invalid Value errors and doesn't like whitespace
 450                     // in values ala ' red' or 'red '
 451                     workerStyle[prop] = lang.trim(css[prop]);
 452                 }
 453                 catch (e) {
 454                 }
 455             }
 456         }
 457     }
 458
 459     return workerStyle.cssText;
 460 };
 461
 462 lang.augmentObject(StyleSheet, {
 463     /**
 464      * <p>Converts an object literal of style properties and values into a string
 465      * of css text.  This can then be assigned to el.style.cssText.</p>
 466      *
 467      * <p>The optional second parameter is a cssText string representing the
 468      * starting state of the style prior to alterations.  This is most often
 469      * extracted from the eventual target's current el.style.cssText.</p>
 470      *
 471      * @method StyleSheet.toCssText
 472      * @param css {Object} object literal of style properties and values
 473      * @param cssText {String} OPTIONAL starting cssText value
 474      * @return {String} the resulting cssText string
 475      * @static
 476      */
 477     toCssText : (('opacity' in workerStyle) ? _toCssText :
 478         // Wrap IE's toCssText to catch opacity.  The copy/merge is to preserve
 479         // the input object's integrity, but if float and opacity are set, the
 480         // input will be copied twice in IE.  Is there a way to avoid this
 481         // without increasing the byte count?
 482         function (css, cssText) {
 483             if (lang.isObject(css) && 'opacity' in css) {
 484                 css = lang.merge(css,{
 485                         filter: 'alpha(opacity='+(css.opacity*100)+')'
 486                       });
 487                 delete css.opacity;
 488             }
 489             return _toCssText(css,cssText);
 490         }),
 491
 492     /**
 493      * Registers a StyleSheet instance in the static registry by the given name
 494      *
 495      * @method StyleSheet.register
 496      * @param name {String} the name to assign the StyleSheet in the registry
 497      * @param sheet {StyleSheet} The StyleSheet instance
 498      * @return {Boolean} false if no name or sheet is not a StyleSheet
 499      *              instance. true otherwise.
 500      * @static
 501      */
 502     register : function (name,sheet) {
 503         return !!(name && sheet instanceof StyleSheet &&
 504                   !sheets[name] && (sheets[name] = sheet));
 505     },
 506
 507     /**
 508      * <p>Determines if a selector string is safe to use.  Used internally
 509      * in set to prevent IE from locking up when attempting to add a rule for a
 510      * &quot;bad selector&quot;.</p>
 511      *
 512      * <p>Bad selectors are considered to be any string containing unescaped
 513      * `~!@$%^&()+=|{}[];'"?< or space. Also forbidden are . or # followed by
 514      * anything other than an alphanumeric.  Additionally -abc or .-abc or
 515      * #_abc or '# ' all fail.  There are likely more failure cases, so
 516      * please file a bug if you encounter one.</p>
 517      *
 518      * @method StyleSheet.isValidSelector
 519      * @param sel {String} the selector string
 520      * @return {Boolean}
 521      * @static
 522      */
 523     isValidSelector : function (sel) {
 524         var valid = false;
 525
 526         if (sel && lang.isString(sel)) {
 527
 528             if (!selectors.hasOwnProperty(sel)) {
 529                 // TEST: there should be nothing but white-space left after
 530                 // these destructive regexs
 531                 selectors[sel] = !/\S/.test(
 532                     // combinators
 533                     sel.replace(/\s+|\s*[+~>]\s*/g,' ').
 534                     // attribute selectors (contents not validated)
 535                     replace(/([^ ])\[.*?\]/g,'$1').
 536                     // pseudo-class|element selectors (contents of parens
 537                     // such as :nth-of-type(2) or :not(...) not validated)
 538                     replace(/([^ ])::?[a-z][a-z\-]+[a-z](?:\(.*?\))?/ig,'$1').
 539                     // element tags
 540                     replace(/(?:^| )[a-z0-6]+/ig,' ').
 541                     // escaped characters
 542                     replace(/\\./g,'').
 543                     // class and id identifiers
 544                     replace(/[.#]\w[\w\-]*/g,''));
 545             }
 546
 547             valid = selectors[sel];
 548         }
 549
 550         return valid;
 551     }
 552 },true);
 553
 554 YAHOO.util.StyleSheet = StyleSheet;
 555
 556 })();
 557
 558 /*
 559
 560 NOTES
 561  * Style node must be added to the head element.  Safari does not honor styles
 562    applied to StyleSheet objects on style nodes in the body.
 563  * StyleSheet object is created on the style node when the style node is added
 564    to the head element in Firefox 2 (and maybe 3?)
 565  * The cssRules collection is replaced after insertRule/deleteRule calls in
 566    Safari 3.1.  Existing Rules are used in the new collection, so the collection
 567    cannot be cached, but the rules can be.
 568  * Opera requires that the index be passed with insertRule.
 569  * Same-domain restrictions prevent modifying StyleSheet objects attached to
 570    link elements with remote href (or "about:blank" or "javascript:false")
 571  * Same-domain restrictions prevent reading StyleSheet cssRules/rules
 572    collection of link elements with remote href (or "about:blank" or
 573    "javascript:false")
 574  * Same-domain restrictions result in Safari not populating node.sheet property
 575    for link elements with remote href (et.al)
 576  * IE names StyleSheet related properties and methods differently (see code)
 577  * IE converts tag names to upper case in the Rule's selectorText
 578  * IE converts empty string assignment to complex properties to value settings
 579    for all child properties.  E.g. style.background = '' sets non-'' values on
 580    style.backgroundPosition, style.backgroundColor, etc.  All else clear
 581    style.background and all child properties.
 582  * IE assignment style.filter = '' will result in style.cssText == 'FILTER:'
 583  * All browsers support Rule.style.cssText as a read/write property, leaving
 584    only opacity needing to be accounted for.
 585  * Benchmarks of style.property = value vs style.cssText += 'property: value'
 586    indicate cssText is slightly slower for single property assignment.  For
 587    multiple property assignment, cssText speed stays relatively the same where
 588    style.property speed decreases linearly by the number of properties set.
 589    Exception being Opera 9.27, where style.property is always faster than
 590    style.cssText.
 591  * Opera 9.5b throws a syntax error when assigning cssText with a syntax error.
 592  * Opera 9.5 doesn't honor rule.style.cssText = ''.  Previous style persists.
 593    You have to remove the rule altogether.
 594  * Stylesheet properties set with !important will trump inline style set on an
 595    element or in el.style.property.
 596  * Creating a worker style collection like document.createElement('p').style;
 597    will fail after a time in FF (~5secs of inactivity).  Property assignments
 598    will not alter the property or cssText.  It may be the generated node is
 599    garbage collected and the style collection becomes inert (speculation).
 600  * IE locks up when attempting to add a rule with a selector including at least
 601    characters {[]}~`!@%^&*()+=|? (unescaped) and leading _ or -
 602    such as addRule('-foo','{ color: red }') or addRule('._abc','{...}')
 603  * IE's addRule doesn't support comma separated selectors such as
 604    addRule('.foo, .bar','{..}')
 605  * IE throws an error on valid values with leading/trailing white space.
 606  * When creating an entire sheet at once, only FF2/3 & Opera allow creating a
 607    style node, setting its innerHTML and appending to head.
 608  * When creating an entire sheet at once, Safari requires the style node to be
 609    created with content in innerHTML of another element.
 610  * When creating an entire sheet at once, IE requires the style node content to
 611    be set via node.styleSheet.cssText
 612  * When creating an entire sheet at once in IE, styleSheet.cssText can't be
 613    written until node.type = 'text/css'; is performed.
 614  * When creating an entire sheet at once in IE, load-time fork on
 615    var styleNode = d.createElement('style'); _method = styleNode.styleSheet ?..
 616    fails (falsey).  During run-time, the test for .styleSheet works fine
 617  * Setting complex properties in cssText will SOMETIMES allow child properties
 618    to be unset
 619    set         unset              FF2  FF3  S3.1  IE6  IE7  Op9.27  Op9.5
 620    ----------  -----------------  ---  ---  ----  ---  ---  ------  -----
 621    border      -top               NO   NO   YES   YES  YES  YES     YES
 622                -top-color         NO   NO   YES             YES     YES
 623                -color             NO   NO   NO              NO      NO
 624    background  -color             NO   NO   YES             YES     YES
 625                -position          NO   NO   YES             YES     YES
 626                -position-x        NO   NO   NO              NO      NO
 627    font        line-height        YES  YES  NO    NO   NO   NO      YES
 628                -style             YES  YES  NO              YES     YES
 629                -size              YES  YES  NO              YES     YES
 630                -size-adjust       ???  ???  n/a   n/a  n/a  ???     ???
 631    padding     -top               NO   NO   YES             YES     YES
 632    margin      -top               NO   NO   YES             YES     YES
 633    list-style  -type              YES  YES  YES             YES     YES
 634                -position          YES  YES  YES             YES     YES
 635    overflow    -x                 NO   NO   YES             n/a     YES
 636
 637    ??? - unsetting font-size-adjust has the same effect as unsetting font-size
 638  * FireFox and WebKit populate rule.cssText as "SELECTOR { CSSTEXT }", but
 639    Opera and IE do not.
 640  * IE6 and IE7 silently ignore the { and } if passed into addRule('.foo','{
 641    color:#000}',0).  IE8 does not and creates an empty rule.
 642  * IE6-8 addRule('.foo','',n) throws an error.  Must supply *some* cssText
 643 */
 644
 645 YAHOO.register("stylesheet", YAHOO.util.StyleSheet, {version: "2.8.0r4", build: "2449"});