tools/side_chain_tool/web/node_modules/jquery/src/css.js

   1 define( [
   2         "./core",
   3         "./var/pnum",
   4         "./core/access",
   5         "./core/camelCase",
   6         "./var/document",
   7         "./var/rcssNum",
   8         "./css/var/rnumnonpx",
   9         "./css/var/cssExpand",
  10         "./css/var/getStyles",
  11         "./css/var/swap",
  12         "./css/curCSS",
  13         "./css/adjustCSS",
  14         "./css/addGetHookIf",
  15         "./css/support",
  16
  17         "./core/init",
  18         "./core/ready",
  19         "./selector" // contains
  20 ], function( jQuery, pnum, access, camelCase, document, rcssNum, rnumnonpx, cssExpand,
  21         getStyles, swap, curCSS, adjustCSS, addGetHookIf, support ) {
  22
  23 "use strict";
  24
  25 var
  26
  27         // Swappable if display is none or starts with table
  28         // except "table", "table-cell", or "table-caption"
  29         // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  30         rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  31         rcustomProp = /^--/,
  32         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  33         cssNormalTransform = {
  34                 letterSpacing: "0",
  35                 fontWeight: "400"
  36         },
  37
  38         cssPrefixes = [ "Webkit", "Moz", "ms" ],
  39         emptyStyle = document.createElement( "div" ).style;
  40
  41 // Return a css property mapped to a potentially vendor prefixed property
  42 function vendorPropName( name ) {
  43
  44         // Shortcut for names that are not vendor prefixed
  45         if ( name in emptyStyle ) {
  46                 return name;
  47         }
  48
  49         // Check for vendor prefixed names
  50         var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
  51                 i = cssPrefixes.length;
  52
  53         while ( i-- ) {
  54                 name = cssPrefixes[ i ] + capName;
  55                 if ( name in emptyStyle ) {
  56                         return name;
  57                 }
  58         }
  59 }
  60
  61 // Return a property mapped along what jQuery.cssProps suggests or to
  62 // a vendor prefixed property.
  63 function finalPropName( name ) {
  64         var ret = jQuery.cssProps[ name ];
  65         if ( !ret ) {
  66                 ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
  67         }
  68         return ret;
  69 }
  70
  71 function setPositiveNumber( elem, value, subtract ) {
  72
  73         // Any relative (+/-) values have already been
  74         // normalized at this point
  75         var matches = rcssNum.exec( value );
  76         return matches ?
  77
  78                 // Guard against undefined "subtract", e.g., when used as in cssHooks
  79                 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
  80                 value;
  81 }
  82
  83 function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
  84         var i = dimension === "width" ? 1 : 0,
  85                 extra = 0,
  86                 delta = 0;
  87
  88         // Adjustment may not be necessary
  89         if ( box === ( isBorderBox ? "border" : "content" ) ) {
  90                 return 0;
  91         }
  92
  93         for ( ; i < 4; i += 2 ) {
  94
  95                 // Both box models exclude margin
  96                 if ( box === "margin" ) {
  97                         delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
  98                 }
  99
 100                 // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
 101                 if ( !isBorderBox ) {
 102
 103                         // Add padding
 104                         delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 105
 106                         // For "border" or "margin", add border
 107                         if ( box !== "padding" ) {
 108                                 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 109
 110                         // But still keep track of it otherwise
 111                         } else {
 112                                 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 113                         }
 114
 115                 // If we get here with a border-box (content + padding + border), we're seeking "content" or
 116                 // "padding" or "margin"
 117                 } else {
 118
 119                         // For "content", subtract padding
 120                         if ( box === "content" ) {
 121                                 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 122                         }
 123
 124                         // For "content" or "padding", subtract border
 125                         if ( box !== "margin" ) {
 126                                 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 127                         }
 128                 }
 129         }
 130
 131         // Account for positive content-box scroll gutter when requested by providing computedVal
 132         if ( !isBorderBox && computedVal >= 0 ) {
 133
 134                 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
 135                 // Assuming integer scroll gutter, subtract the rest and round down
 136                 delta += Math.max( 0, Math.ceil(
 137                         elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
 138                         computedVal -
 139                         delta -
 140                         extra -
 141                         0.5
 142                 ) );
 143         }
 144
 145         return delta;
 146 }
 147
 148 function getWidthOrHeight( elem, dimension, extra ) {
 149
 150         // Start with computed style
 151         var styles = getStyles( elem ),
 152                 val = curCSS( elem, dimension, styles ),
 153                 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
 154                 valueIsBorderBox = isBorderBox;
 155
 156         // Support: Firefox <=54
 157         // Return a confounding non-pixel value or feign ignorance, as appropriate.
 158         if ( rnumnonpx.test( val ) ) {
 159                 if ( !extra ) {
 160                         return val;
 161                 }
 162                 val = "auto";
 163         }
 164
 165         // Check for style in case a browser which returns unreliable values
 166         // for getComputedStyle silently falls back to the reliable elem.style
 167         valueIsBorderBox = valueIsBorderBox &&
 168                 ( support.boxSizingReliable() || val === elem.style[ dimension ] );
 169
 170         // Fall back to offsetWidth/offsetHeight when value is "auto"
 171         // This happens for inline elements with no explicit setting (gh-3571)
 172         // Support: Android <=4.1 - 4.3 only
 173         // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
 174         if ( val === "auto" ||
 175                 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) {
 176
 177                 val = elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ];
 178
 179                 // offsetWidth/offsetHeight provide border-box values
 180                 valueIsBorderBox = true;
 181         }
 182
 183         // Normalize "" and auto
 184         val = parseFloat( val ) || 0;
 185
 186         // Adjust for the element's box model
 187         return ( val +
 188                 boxModelAdjustment(
 189                         elem,
 190                         dimension,
 191                         extra || ( isBorderBox ? "border" : "content" ),
 192                         valueIsBorderBox,
 193                         styles,
 194
 195                         // Provide the current computed size to request scroll gutter calculation (gh-3589)
 196                         val
 197                 )
 198         ) + "px";
 199 }
 200
 201 jQuery.extend( {
 202
 203         // Add in style property hooks for overriding the default
 204         // behavior of getting and setting a style property
 205         cssHooks: {
 206                 opacity: {
 207                         get: function( elem, computed ) {
 208                                 if ( computed ) {
 209
 210                                         // We should always get a number back from opacity
 211                                         var ret = curCSS( elem, "opacity" );
 212                                         return ret === "" ? "1" : ret;
 213                                 }
 214                         }
 215                 }
 216         },
 217
 218         // Don't automatically add "px" to these possibly-unitless properties
 219         cssNumber: {
 220                 "animationIterationCount": true,
 221                 "columnCount": true,
 222                 "fillOpacity": true,
 223                 "flexGrow": true,
 224                 "flexShrink": true,
 225                 "fontWeight": true,
 226                 "lineHeight": true,
 227                 "opacity": true,
 228                 "order": true,
 229                 "orphans": true,
 230                 "widows": true,
 231                 "zIndex": true,
 232                 "zoom": true
 233         },
 234
 235         // Add in properties whose names you wish to fix before
 236         // setting or getting the value
 237         cssProps: {},
 238
 239         // Get and set the style property on a DOM Node
 240         style: function( elem, name, value, extra ) {
 241
 242                 // Don't set styles on text and comment nodes
 243                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
 244                         return;
 245                 }
 246
 247                 // Make sure that we're working with the right name
 248                 var ret, type, hooks,
 249                         origName = camelCase( name ),
 250                         isCustomProp = rcustomProp.test( name ),
 251                         style = elem.style;
 252
 253                 // Make sure that we're working with the right name. We don't
 254                 // want to query the value if it is a CSS custom property
 255                 // since they are user-defined.
 256                 if ( !isCustomProp ) {
 257                         name = finalPropName( origName );
 258                 }
 259
 260                 // Gets hook for the prefixed version, then unprefixed version
 261                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 262
 263                 // Check if we're setting a value
 264                 if ( value !== undefined ) {
 265                         type = typeof value;
 266
 267                         // Convert "+=" or "-=" to relative numbers (#7345)
 268                         if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
 269                                 value = adjustCSS( elem, name, ret );
 270
 271                                 // Fixes bug #9237
 272                                 type = "number";
 273                         }
 274
 275                         // Make sure that null and NaN values aren't set (#7116)
 276                         if ( value == null || value !== value ) {
 277                                 return;
 278                         }
 279
 280                         // If a number was passed in, add the unit (except for certain CSS properties)
 281                         if ( type === "number" ) {
 282                                 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
 283                         }
 284
 285                         // background-* props affect original clone's values
 286                         if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
 287                                 style[ name ] = "inherit";
 288                         }
 289
 290                         // If a hook was provided, use that value, otherwise just set the specified value
 291                         if ( !hooks || !( "set" in hooks ) ||
 292                                 ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
 293
 294                                 if ( isCustomProp ) {
 295                                         style.setProperty( name, value );
 296                                 } else {
 297                                         style[ name ] = value;
 298                                 }
 299                         }
 300
 301                 } else {
 302
 303                         // If a hook was provided get the non-computed value from there
 304                         if ( hooks && "get" in hooks &&
 305                                 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
 306
 307                                 return ret;
 308                         }
 309
 310                         // Otherwise just get the value from the style object
 311                         return style[ name ];
 312                 }
 313         },
 314
 315         css: function( elem, name, extra, styles ) {
 316                 var val, num, hooks,
 317                         origName = camelCase( name ),
 318                         isCustomProp = rcustomProp.test( name );
 319
 320                 // Make sure that we're working with the right name. We don't
 321                 // want to modify the value if it is a CSS custom property
 322                 // since they are user-defined.
 323                 if ( !isCustomProp ) {
 324                         name = finalPropName( origName );
 325                 }
 326
 327                 // Try prefixed name followed by the unprefixed name
 328                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 329
 330                 // If a hook was provided get the computed value from there
 331                 if ( hooks && "get" in hooks ) {
 332                         val = hooks.get( elem, true, extra );
 333                 }
 334
 335                 // Otherwise, if a way to get the computed value exists, use that
 336                 if ( val === undefined ) {
 337                         val = curCSS( elem, name, styles );
 338                 }
 339
 340                 // Convert "normal" to computed value
 341                 if ( val === "normal" && name in cssNormalTransform ) {
 342                         val = cssNormalTransform[ name ];
 343                 }
 344
 345                 // Make numeric if forced or a qualifier was provided and val looks numeric
 346                 if ( extra === "" || extra ) {
 347                         num = parseFloat( val );
 348                         return extra === true || isFinite( num ) ? num || 0 : val;
 349                 }
 350
 351                 return val;
 352         }
 353 } );
 354
 355 jQuery.each( [ "height", "width" ], function( i, dimension ) {
 356         jQuery.cssHooks[ dimension ] = {
 357                 get: function( elem, computed, extra ) {
 358                         if ( computed ) {
 359
 360                                 // Certain elements can have dimension info if we invisibly show them
 361                                 // but it must have a current display style that would benefit
 362                                 return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
 363
 364                                         // Support: Safari 8+
 365                                         // Table columns in Safari have non-zero offsetWidth & zero
 366                                         // getBoundingClientRect().width unless display is changed.
 367                                         // Support: IE <=11 only
 368                                         // Running getBoundingClientRect on a disconnected node
 369                                         // in IE throws an error.
 370                                         ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
 371                                                 swap( elem, cssShow, function() {
 372                                                         return getWidthOrHeight( elem, dimension, extra );
 373                                                 } ) :
 374                                                 getWidthOrHeight( elem, dimension, extra );
 375                         }
 376                 },
 377
 378                 set: function( elem, value, extra ) {
 379                         var matches,
 380                                 styles = getStyles( elem ),
 381                                 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
 382                                 subtract = extra && boxModelAdjustment(
 383                                         elem,
 384                                         dimension,
 385                                         extra,
 386                                         isBorderBox,
 387                                         styles
 388                                 );
 389
 390                         // Account for unreliable border-box dimensions by comparing offset* to computed and
 391                         // faking a content-box to get border and padding (gh-3699)
 392                         if ( isBorderBox && support.scrollboxSize() === styles.position ) {
 393                                 subtract -= Math.ceil(
 394                                         elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
 395                                         parseFloat( styles[ dimension ] ) -
 396                                         boxModelAdjustment( elem, dimension, "border", false, styles ) -
 397                                         0.5
 398                                 );
 399                         }
 400
 401                         // Convert to pixels if value adjustment is needed
 402                         if ( subtract && ( matches = rcssNum.exec( value ) ) &&
 403                                 ( matches[ 3 ] || "px" ) !== "px" ) {
 404
 405                                 elem.style[ dimension ] = value;
 406                                 value = jQuery.css( elem, dimension );
 407                         }
 408
 409                         return setPositiveNumber( elem, value, subtract );
 410                 }
 411         };
 412 } );
 413
 414 jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
 415         function( elem, computed ) {
 416                 if ( computed ) {
 417                         return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
 418                                 elem.getBoundingClientRect().left -
 419                                         swap( elem, { marginLeft: 0 }, function() {
 420                                                 return elem.getBoundingClientRect().left;
 421                                         } )
 422                                 ) + "px";
 423                 }
 424         }
 425 );
 426
 427 // These hooks are used by animate to expand properties
 428 jQuery.each( {
 429         margin: "",
 430         padding: "",
 431         border: "Width"
 432 }, function( prefix, suffix ) {
 433         jQuery.cssHooks[ prefix + suffix ] = {
 434                 expand: function( value ) {
 435                         var i = 0,
 436                                 expanded = {},
 437
 438                                 // Assumes a single number if not a string
 439                                 parts = typeof value === "string" ? value.split( " " ) : [ value ];
 440
 441                         for ( ; i < 4; i++ ) {
 442                                 expanded[ prefix + cssExpand[ i ] + suffix ] =
 443                                         parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
 444                         }
 445
 446                         return expanded;
 447                 }
 448         };
 449
 450         if ( prefix !== "margin" ) {
 451                 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
 452         }
 453 } );
 454
 455 jQuery.fn.extend( {
 456         css: function( name, value ) {
 457                 return access( this, function( elem, name, value ) {
 458                         var styles, len,
 459                                 map = {},
 460                                 i = 0;
 461
 462                         if ( Array.isArray( name ) ) {
 463                                 styles = getStyles( elem );
 464                                 len = name.length;
 465
 466                                 for ( ; i < len; i++ ) {
 467                                         map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
 468                                 }
 469
 470                                 return map;
 471                         }
 472
 473                         return value !== undefined ?
 474                                 jQuery.style( elem, name, value ) :
 475                                 jQuery.css( elem, name );
 476                 }, name, value, arguments.length > 1 );
 477         }
 478 } );
 479
 480 return jQuery;
 481 } );