define( [

"./core",
"./var/pnum",
"./core/access",
"./css/var/rmargin",
"./var/document",
"./var/rcssNum",
"./css/var/rnumnonpx",
"./css/var/cssExpand",
"./css/var/getStyles",
"./css/var/swap",
"./css/curCSS",
"./css/adjustCSS",
"./css/addGetHookIf",
"./css/support",

"./core/init",
"./core/ready",
"./selector" // contains

], function( jQuery, pnum, access, rmargin, document, rcssNum, rnumnonpx, cssExpand,

getStyles, swap, curCSS, adjustCSS, addGetHookIf, support ) {

“use strict”;

var

// Swappable if display is none or starts with table
// except "table", "table-cell", or "table-caption"
// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
rcustomProp = /^--/,
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
cssNormalTransform = {
        letterSpacing: "0",
        fontWeight: "400"
},

cssPrefixes = [ "Webkit", "Moz", "ms" ],
emptyStyle = document.createElement( "div" ).style;

// Return a css property mapped to a potentially vendor prefixed property function vendorPropName( name ) {

// Shortcut for names that are not vendor prefixed
if ( name in emptyStyle ) {
        return name;
}

// Check for vendor prefixed names
var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
        i = cssPrefixes.length;

while ( i-- ) {
        name = cssPrefixes[ i ] + capName;
        if ( name in emptyStyle ) {
                return name;
        }
}

}

// Return a property mapped along what jQuery.cssProps suggests or to // a vendor prefixed property. function finalPropName( name ) {

var ret = jQuery.cssProps[ name ];
if ( !ret ) {
        ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
}
return ret;

}

function setPositiveNumber( elem, value, subtract ) {

// Any relative (+/-) values have already been
// normalized at this point
var matches = rcssNum.exec( value );
return matches ?

        // Guard against undefined "subtract", e.g., when used as in cssHooks
        Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
        value;

}

function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {

var i,
        val = 0;

// If we already have the right measurement, avoid augmentation
if ( extra === ( isBorderBox ? "border" : "content" ) ) {
        i = 4;

// Otherwise initialize for horizontal or vertical properties
} else {
        i = name === "width" ? 1 : 0;
}

for ( ; i < 4; i += 2 ) {

        // Both box models exclude margin, so add it if we want it
        if ( extra === "margin" ) {
                val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
        }

        if ( isBorderBox ) {

                // border-box includes padding, so remove it if we want content
                if ( extra === "content" ) {
                        val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
                }

                // At this point, extra isn't border nor margin, so remove border
                if ( extra !== "margin" ) {
                        val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
                }
        } else {

                // At this point, extra isn't content, so add padding
                val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

                // At this point, extra isn't content nor padding, so add border
                if ( extra !== "padding" ) {
                        val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
                }
        }
}

return val;

}

function getWidthOrHeight( elem, name, extra ) {

// Start with computed style
var valueIsBorderBox,
        styles = getStyles( elem ),
        val = curCSS( elem, name, styles ),
        isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

// Computed unit is not pixels. Stop here and return.
if ( rnumnonpx.test( val ) ) {
        return val;
}

// Check for style in case a browser which returns unreliable values
// for getComputedStyle silently falls back to the reliable elem.style
valueIsBorderBox = isBorderBox &&
        ( support.boxSizingReliable() || val === elem.style[ name ] );

// Fall back to offsetWidth/Height when value is "auto"
// This happens for inline elements with no explicit setting (gh-3571)
if ( val === "auto" ) {
        val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
}

// Normalize "", auto, and prepare for extra
val = parseFloat( val ) || 0;

// Use the active box-sizing model to add/subtract irrelevant styles
return ( val +
        augmentWidthOrHeight(
                elem,
                name,
                extra || ( isBorderBox ? "border" : "content" ),
                valueIsBorderBox,
                styles
        )
) + "px";

}

jQuery.extend( {

// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
        opacity: {
                get: function( elem, computed ) {
                        if ( computed ) {

                                // We should always get a number back from opacity
                                var ret = curCSS( elem, "opacity" );
                                return ret === "" ? "1" : ret;
                        }
                }
        }
},

// Don't automatically add "px" to these possibly-unitless properties
cssNumber: {
        "animationIterationCount": true,
        "columnCount": true,
        "fillOpacity": true,
        "flexGrow": true,
        "flexShrink": true,
        "fontWeight": true,
        "lineHeight": true,
        "opacity": true,
        "order": true,
        "orphans": true,
        "widows": true,
        "zIndex": true,
        "zoom": true
},

// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {
        "float": "cssFloat"
},

// Get and set the style property on a DOM Node
style: function( elem, name, value, extra ) {

        // Don't set styles on text and comment nodes
        if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
                return;
        }

        // Make sure that we're working with the right name
        var ret, type, hooks,
                origName = jQuery.camelCase( name ),
                isCustomProp = rcustomProp.test( name ),
                style = elem.style;

        // Make sure that we're working with the right name. We don't
        // want to query the value if it is a CSS custom property
        // since they are user-defined.
        if ( !isCustomProp ) {
                name = finalPropName( origName );
        }

        // Gets hook for the prefixed version, then unprefixed version
        hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

        // Check if we're setting a value
        if ( value !== undefined ) {
                type = typeof value;

                // Convert "+=" or "-=" to relative numbers (#7345)
                if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
                        value = adjustCSS( elem, name, ret );

                        // Fixes bug #9237
                        type = "number";
                }

                // Make sure that null and NaN values aren't set (#7116)
                if ( value == null || value !== value ) {
                        return;
                }

                // If a number was passed in, add the unit (except for certain CSS properties)
                if ( type === "number" ) {
                        value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
                }

                // background-* props affect original clone's values
                if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
                        style[ name ] = "inherit";
                }

                // If a hook was provided, use that value, otherwise just set the specified value
                if ( !hooks || !( "set" in hooks ) ||
                        ( value = hooks.set( elem, value, extra ) ) !== undefined ) {

                        if ( isCustomProp ) {
                                style.setProperty( name, value );
                        } else {
                                style[ name ] = value;
                        }
                }

        } else {

                // If a hook was provided get the non-computed value from there
                if ( hooks && "get" in hooks &&
                        ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {

                        return ret;
                }

                // Otherwise just get the value from the style object
                return style[ name ];
        }
},

css: function( elem, name, extra, styles ) {
        var val, num, hooks,
                origName = jQuery.camelCase( name ),
                isCustomProp = rcustomProp.test( name );

        // Make sure that we're working with the right name. We don't
        // want to modify the value if it is a CSS custom property
        // since they are user-defined.
        if ( !isCustomProp ) {
                name = finalPropName( origName );
        }

        // Try prefixed name followed by the unprefixed name
        hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

        // If a hook was provided get the computed value from there
        if ( hooks && "get" in hooks ) {
                val = hooks.get( elem, true, extra );
        }

        // Otherwise, if a way to get the computed value exists, use that
        if ( val === undefined ) {
                val = curCSS( elem, name, styles );
        }

        // Convert "normal" to computed value
        if ( val === "normal" && name in cssNormalTransform ) {
                val = cssNormalTransform[ name ];
        }

        // Make numeric if forced or a qualifier was provided and val looks numeric
        if ( extra === "" || extra ) {
                num = parseFloat( val );
                return extra === true || isFinite( num ) ? num || 0 : val;
        }

        return val;
}

} );

jQuery.each( [ “height”, “width” ], function( i, name ) {

jQuery.cssHooks[ name ] = {
        get: function( elem, computed, extra ) {
                if ( computed ) {

                        // Certain elements can have dimension info if we invisibly show them
                        // but it must have a current display style that would benefit
                        return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&

                                // Support: Safari 8+
                                // Table columns in Safari have non-zero offsetWidth & zero
                                // getBoundingClientRect().width unless display is changed.
                                // Support: IE <=11 only
                                // Running getBoundingClientRect on a disconnected node
                                // in IE throws an error.
                                ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
                                        swap( elem, cssShow, function() {
                                                return getWidthOrHeight( elem, name, extra );
                                        } ) :
                                        getWidthOrHeight( elem, name, extra );
                }
        },

        set: function( elem, value, extra ) {
                var matches,
                        styles = extra && getStyles( elem ),
                        subtract = extra && augmentWidthOrHeight(
                                elem,
                                name,
                                extra,
                                jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
                                styles
                        );

                // Convert to pixels if value adjustment is needed
                if ( subtract && ( matches = rcssNum.exec( value ) ) &&
                        ( matches[ 3 ] || "px" ) !== "px" ) {

                        elem.style[ name ] = value;
                        value = jQuery.css( elem, name );
                }

                return setPositiveNumber( elem, value, subtract );
        }
};

} );

jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,

function( elem, computed ) {
        if ( computed ) {
                return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
                        elem.getBoundingClientRect().left -
                                swap( elem, { marginLeft: 0 }, function() {
                                        return elem.getBoundingClientRect().left;
                                } )
                        ) + "px";
        }
}

);

// These hooks are used by animate to expand properties jQuery.each( {

margin: "",
padding: "",
border: "Width"

}, function( prefix, suffix ) {

jQuery.cssHooks[ prefix + suffix ] = {
        expand: function( value ) {
                var i = 0,
                        expanded = {},

                        // Assumes a single number if not a string
                        parts = typeof value === "string" ? value.split( " " ) : [ value ];

                for ( ; i < 4; i++ ) {
                        expanded[ prefix + cssExpand[ i ] + suffix ] =
                                parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
                }

                return expanded;
        }
};

if ( !rmargin.test( prefix ) ) {
        jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
}

} );

jQuery.fn.extend( {

css: function( name, value ) {
        return access( this, function( elem, name, value ) {
                var styles, len,
                        map = {},
                        i = 0;

                if ( Array.isArray( name ) ) {
                        styles = getStyles( elem );
                        len = name.length;

                        for ( ; i < len; i++ ) {
                                map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
                        }

                        return map;
                }

                return value !== undefined ?
                        jQuery.style( elem, name, value ) :
                        jQuery.css( elem, name );
        }, name, value, arguments.length > 1 );
}

} );

return jQuery; } );