git.r.bdr.sh - rbdr/dotfiles/blob - atom/packages/ex-mode/node_modules/space-pen/node_modules/jquery/src/css.js

   1 define([
   2         "./core",
   3         "./var/pnum",
   4         "./core/access",
   5         "./css/var/rmargin",
   6         "./css/var/rnumnonpx",
   7         "./css/var/cssExpand",
   8         "./css/var/isHidden",
   9         "./css/var/getStyles",
  10         "./css/curCSS",
  11         "./css/defaultDisplay",
  12         "./css/addGetHookIf",
  13         "./css/support",
  14         "./data/var/data_priv",
  15
  16         "./core/init",
  17         "./css/swap",
  18         "./core/ready",
  19         "./selector" // contains
  20 ], function( jQuery, pnum, access, rmargin, rnumnonpx, cssExpand, isHidden,
  21         getStyles, curCSS, defaultDisplay, addGetHookIf, support, data_priv ) {
  22
  23 var
  24         // Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
  25         // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  26         rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  27         rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
  28         rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
  29
  30         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  31         cssNormalTransform = {
  32                 letterSpacing: "0",
  33                 fontWeight: "400"
  34         },
  35
  36         cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
  37
  38 // Return a css property mapped to a potentially vendor prefixed property
  39 function vendorPropName( style, name ) {
  40
  41         // Shortcut for names that are not vendor prefixed
  42         if ( name in style ) {
  43                 return name;
  44         }
  45
  46         // Check for vendor prefixed names
  47         var capName = name[0].toUpperCase() + name.slice(1),
  48                 origName = name,
  49                 i = cssPrefixes.length;
  50
  51         while ( i-- ) {
  52                 name = cssPrefixes[ i ] + capName;
  53                 if ( name in style ) {
  54                         return name;
  55                 }
  56         }
  57
  58         return origName;
  59 }
  60
  61 function setPositiveNumber( elem, value, subtract ) {
  62         var matches = rnumsplit.exec( value );
  63         return matches ?
  64                 // Guard against undefined "subtract", e.g., when used as in cssHooks
  65                 Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
  66                 value;
  67 }
  68
  69 function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
  70         var i = extra === ( isBorderBox ? "border" : "content" ) ?
  71                 // If we already have the right measurement, avoid augmentation
  72                 4 :
  73                 // Otherwise initialize for horizontal or vertical properties
  74                 name === "width" ? 1 : 0,
  75
  76                 val = 0;
  77
  78         for ( ; i < 4; i += 2 ) {
  79                 // Both box models exclude margin, so add it if we want it
  80                 if ( extra === "margin" ) {
  81                         val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
  82                 }
  83
  84                 if ( isBorderBox ) {
  85                         // border-box includes padding, so remove it if we want content
  86                         if ( extra === "content" ) {
  87                                 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  88                         }
  89
  90                         // At this point, extra isn't border nor margin, so remove border
  91                         if ( extra !== "margin" ) {
  92                                 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  93                         }
  94                 } else {
  95                         // At this point, extra isn't content, so add padding
  96                         val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  97
  98                         // At this point, extra isn't content nor padding, so add border
  99                         if ( extra !== "padding" ) {
 100                                 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 101                         }
 102                 }
 103         }
 104
 105         return val;
 106 }
 107
 108 function getWidthOrHeight( elem, name, extra ) {
 109
 110         // Start with offset property, which is equivalent to the border-box value
 111         var valueIsBorderBox = true,
 112                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
 113                 styles = getStyles( elem ),
 114                 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
 115
 116         // Some non-html elements return undefined for offsetWidth, so check for null/undefined
 117         // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
 118         // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
 119         if ( val <= 0 || val == null ) {
 120                 // Fall back to computed then uncomputed css if necessary
 121                 val = curCSS( elem, name, styles );
 122                 if ( val < 0 || val == null ) {
 123                         val = elem.style[ name ];
 124                 }
 125
 126                 // Computed unit is not pixels. Stop here and return.
 127                 if ( rnumnonpx.test(val) ) {
 128                         return val;
 129                 }
 130
 131                 // Check for style in case a browser which returns unreliable values
 132                 // for getComputedStyle silently falls back to the reliable elem.style
 133                 valueIsBorderBox = isBorderBox &&
 134                         ( support.boxSizingReliable() || val === elem.style[ name ] );
 135
 136                 // Normalize "", auto, and prepare for extra
 137                 val = parseFloat( val ) || 0;
 138         }
 139
 140         // Use the active box-sizing model to add/subtract irrelevant styles
 141         return ( val +
 142                 augmentWidthOrHeight(
 143                         elem,
 144                         name,
 145                         extra || ( isBorderBox ? "border" : "content" ),
 146                         valueIsBorderBox,
 147                         styles
 148                 )
 149         ) + "px";
 150 }
 151
 152 function showHide( elements, show ) {
 153         var display, elem, hidden,
 154                 values = [],
 155                 index = 0,
 156                 length = elements.length;
 157
 158         for ( ; index < length; index++ ) {
 159                 elem = elements[ index ];
 160                 if ( !elem.style ) {
 161                         continue;
 162                 }
 163
 164                 values[ index ] = data_priv.get( elem, "olddisplay" );
 165                 display = elem.style.display;
 166                 if ( show ) {
 167                         // Reset the inline display of this element to learn if it is
 168                         // being hidden by cascaded rules or not
 169                         if ( !values[ index ] && display === "none" ) {
 170                                 elem.style.display = "";
 171                         }
 172
 173                         // Set elements which have been overridden with display: none
 174                         // in a stylesheet to whatever the default browser style is
 175                         // for such an element
 176                         if ( elem.style.display === "" && isHidden( elem ) ) {
 177                                 values[ index ] = data_priv.access( elem, "olddisplay", defaultDisplay(elem.nodeName) );
 178                         }
 179                 } else {
 180                         hidden = isHidden( elem );
 181
 182                         if ( display !== "none" || !hidden ) {
 183                                 data_priv.set( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
 184                         }
 185                 }
 186         }
 187
 188         // Set the display of most of the elements in a second loop
 189         // to avoid the constant reflow
 190         for ( index = 0; index < length; index++ ) {
 191                 elem = elements[ index ];
 192                 if ( !elem.style ) {
 193                         continue;
 194                 }
 195                 if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
 196                         elem.style.display = show ? values[ index ] || "" : "none";
 197                 }
 198         }
 199
 200         return elements;
 201 }
 202
 203 jQuery.extend({
 204
 205         // Add in style property hooks for overriding the default
 206         // behavior of getting and setting a style property
 207         cssHooks: {
 208                 opacity: {
 209                         get: function( elem, computed ) {
 210                                 if ( computed ) {
 211
 212                                         // We should always get a number back from opacity
 213                                         var ret = curCSS( elem, "opacity" );
 214                                         return ret === "" ? "1" : ret;
 215                                 }
 216                         }
 217                 }
 218         },
 219
 220         // Don't automatically add "px" to these possibly-unitless properties
 221         cssNumber: {
 222                 "columnCount": true,
 223                 "fillOpacity": true,
 224                 "flexGrow": true,
 225                 "flexShrink": true,
 226                 "fontWeight": true,
 227                 "lineHeight": true,
 228                 "opacity": true,
 229                 "order": true,
 230                 "orphans": true,
 231                 "widows": true,
 232                 "zIndex": true,
 233                 "zoom": true
 234         },
 235
 236         // Add in properties whose names you wish to fix before
 237         // setting or getting the value
 238         cssProps: {
 239                 "float": "cssFloat"
 240         },
 241
 242         // Get and set the style property on a DOM Node
 243         style: function( elem, name, value, extra ) {
 244
 245                 // Don't set styles on text and comment nodes
 246                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
 247                         return;
 248                 }
 249
 250                 // Make sure that we're working with the right name
 251                 var ret, type, hooks,
 252                         origName = jQuery.camelCase( name ),
 253                         style = elem.style;
 254
 255                 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
 256
 257                 // Gets hook for the prefixed version, then unprefixed version
 258                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 259
 260                 // Check if we're setting a value
 261                 if ( value !== undefined ) {
 262                         type = typeof value;
 263
 264                         // Convert "+=" or "-=" to relative numbers (#7345)
 265                         if ( type === "string" && (ret = rrelNum.exec( value )) ) {
 266                                 value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
 267                                 // Fixes bug #9237
 268                                 type = "number";
 269                         }
 270
 271                         // Make sure that null and NaN values aren't set (#7116)
 272                         if ( value == null || value !== value ) {
 273                                 return;
 274                         }
 275
 276                         // If a number, add 'px' to the (except for certain CSS properties)
 277                         if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
 278                                 value += "px";
 279                         }
 280
 281                         // Support: IE9-11+
 282                         // background-* props affect original clone's values
 283                         if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
 284                                 style[ name ] = "inherit";
 285                         }
 286
 287                         // If a hook was provided, use that value, otherwise just set the specified value
 288                         if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
 289                                 style[ name ] = value;
 290                         }
 291
 292                 } else {
 293                         // If a hook was provided get the non-computed value from there
 294                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
 295                                 return ret;
 296                         }
 297
 298                         // Otherwise just get the value from the style object
 299                         return style[ name ];
 300                 }
 301         },
 302
 303         css: function( elem, name, extra, styles ) {
 304                 var val, num, hooks,
 305                         origName = jQuery.camelCase( name );
 306
 307                 // Make sure that we're working with the right name
 308                 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
 309
 310                 // Try prefixed name followed by the unprefixed name
 311                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 312
 313                 // If a hook was provided get the computed value from there
 314                 if ( hooks && "get" in hooks ) {
 315                         val = hooks.get( elem, true, extra );
 316                 }
 317
 318                 // Otherwise, if a way to get the computed value exists, use that
 319                 if ( val === undefined ) {
 320                         val = curCSS( elem, name, styles );
 321                 }
 322
 323                 // Convert "normal" to computed value
 324                 if ( val === "normal" && name in cssNormalTransform ) {
 325                         val = cssNormalTransform[ name ];
 326                 }
 327
 328                 // Make numeric if forced or a qualifier was provided and val looks numeric
 329                 if ( extra === "" || extra ) {
 330                         num = parseFloat( val );
 331                         return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
 332                 }
 333                 return val;
 334         }
 335 });
 336
 337 jQuery.each([ "height", "width" ], function( i, name ) {
 338         jQuery.cssHooks[ name ] = {
 339                 get: function( elem, computed, extra ) {
 340                         if ( computed ) {
 341
 342                                 // Certain elements can have dimension info if we invisibly show them
 343                                 // but it must have a current display style that would benefit
 344                                 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
 345                                         jQuery.swap( elem, cssShow, function() {
 346                                                 return getWidthOrHeight( elem, name, extra );
 347                                         }) :
 348                                         getWidthOrHeight( elem, name, extra );
 349                         }
 350                 },
 351
 352                 set: function( elem, value, extra ) {
 353                         var styles = extra && getStyles( elem );
 354                         return setPositiveNumber( elem, value, extra ?
 355                                 augmentWidthOrHeight(
 356                                         elem,
 357                                         name,
 358                                         extra,
 359                                         jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
 360                                         styles
 361                                 ) : 0
 362                         );
 363                 }
 364         };
 365 });
 366
 367 // Support: Android 2.3
 368 jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
 369         function( elem, computed ) {
 370                 if ( computed ) {
 371                         return jQuery.swap( elem, { "display": "inline-block" },
 372                                 curCSS, [ elem, "marginRight" ] );
 373                 }
 374         }
 375 );
 376
 377 // These hooks are used by animate to expand properties
 378 jQuery.each({
 379         margin: "",
 380         padding: "",
 381         border: "Width"
 382 }, function( prefix, suffix ) {
 383         jQuery.cssHooks[ prefix + suffix ] = {
 384                 expand: function( value ) {
 385                         var i = 0,
 386                                 expanded = {},
 387
 388                                 // Assumes a single number if not a string
 389                                 parts = typeof value === "string" ? value.split(" ") : [ value ];
 390
 391                         for ( ; i < 4; i++ ) {
 392                                 expanded[ prefix + cssExpand[ i ] + suffix ] =
 393                                         parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
 394                         }
 395
 396                         return expanded;
 397                 }
 398         };
 399
 400         if ( !rmargin.test( prefix ) ) {
 401                 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
 402         }
 403 });
 404
 405 jQuery.fn.extend({
 406         css: function( name, value ) {
 407                 return access( this, function( elem, name, value ) {
 408                         var styles, len,
 409                                 map = {},
 410                                 i = 0;
 411
 412                         if ( jQuery.isArray( name ) ) {
 413                                 styles = getStyles( elem );
 414                                 len = name.length;
 415
 416                                 for ( ; i < len; i++ ) {
 417                                         map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
 418                                 }
 419
 420                                 return map;
 421                         }
 422
 423                         return value !== undefined ?
 424                                 jQuery.style( elem, name, value ) :
 425                                 jQuery.css( elem, name );
 426                 }, name, value, arguments.length > 1 );
 427         },
 428         show: function() {
 429                 return showHide( this, true );
 430         },
 431         hide: function() {
 432                 return showHide( this );
 433         },
 434         toggle: function( state ) {
 435                 if ( typeof state === "boolean" ) {
 436                         return state ? this.show() : this.hide();
 437                 }
 438
 439                 return this.each(function() {
 440                         if ( isHidden( this ) ) {
 441                                 jQuery( this ).show();
 442                         } else {
 443                                 jQuery( this ).hide();
 444                         }
 445                 });
 446         }
 447 });
 448
 449 return jQuery;
 450 });