Gecko [ rhythmmedical.in ]

Name	Size	Permission
ajax	[ DIR ]	drwxrwxrwx
attributes	[ DIR ]	drwxrwxrwx
core	[ DIR ]	drwxrwxrwx
css	[ DIR ]	drwxrwxrwx
data	[ DIR ]	drwxrwxrwx
deferred	[ DIR ]	drwxrwxrwx
effects	[ DIR ]	drwxrwxrwx
event	[ DIR ]	drwxrwxrwx
exports	[ DIR ]	drwxrwxrwx
manipulation	[ DIR ]	drwxrwxrwx
queue	[ DIR ]	drwxrwxrwx
traversing	[ DIR ]	drwxrwxrwx
var	[ DIR ]	drwxrwxrwx
.eslintrc.json	60 B	-rw-rw-rw-
ajax.js	21.73 KB	-rw-rw-rw-
attributes.js	217 B	-rw-rw-rw-
callbacks.js	5.38 KB	-rw-rw-rw-
core.js	10.93 KB	-rw-rw-rw-
css.js	11.41 KB	-rw-rw-rw-
data.js	4.2 KB	-rw-rw-rw-
deferred.js	10.61 KB	-rw-rw-rw-
deprecated.js	801 B	-rw-rw-rw-
dimensions.js	1.69 KB	-rw-rw-rw-
effects.js	16.99 KB	-rw-rw-rw-
event.js	18.96 KB	-rw-rw-rw-
jquery.js	640 B	-rw-rw-rw-
manipulation.js	12.21 KB	-rw-rw-rw-
offset.js	6.12 KB	-rw-rw-rw-
queue.js	3.02 KB	-rw-rw-rw-
selector-native.js	6.24 KB	-rw-rw-rw-
selector-sizzle.js	411 B	-rw-rw-rw-
selector.js	66 B	-rw-rw-rw-
serialize.js	3.1 KB	-rw-rw-rw-
traversing.js	4.44 KB	-rw-rw-rw-
wrap.js	1.42 KB	-rw-rw-rw-

Code Editor : offset.js

define( [
	"./core",
	"./core/access",
	"./var/document",
	"./var/documentElement",
	"./css/var/rnumnonpx",
	"./css/curCSS",
	"./css/addGetHookIf",
	"./css/support",
	"./core/nodeName",

"./core/init",
	"./css",
	"./selector" // contains
], function( jQuery, access, document, documentElement, rnumnonpx,
             curCSS, addGetHookIf, support, nodeName ) {

"use strict";

jQuery.offset = {
	setOffset: function( elem, options, i ) {
		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
			position = jQuery.css( elem, "position" ),
			curElem = jQuery( elem ),
			props = {};

// Set position first, in-case top/left are set even on static elem
		if ( position === "static" ) {
			elem.style.position = "relative";
		}

curOffset = curElem.offset();
		curCSSTop = jQuery.css( elem, "top" );
		curCSSLeft = jQuery.css( elem, "left" );
		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;

// Need to be able to calculate position if either
		// top or left is auto and position is either absolute or fixed
		if ( calculatePosition ) {
			curPosition = curElem.position();
			curTop = curPosition.top;
			curLeft = curPosition.left;

} else {
			curTop = parseFloat( curCSSTop ) || 0;
			curLeft = parseFloat( curCSSLeft ) || 0;
		}

if ( jQuery.isFunction( options ) ) {

// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
		}

if ( options.top != null ) {
			props.top = ( options.top - curOffset.top ) + curTop;
		}
		if ( options.left != null ) {
			props.left = ( options.left - curOffset.left ) + curLeft;
		}

if ( "using" in options ) {
			options.using.call( elem, props );

} else {
			curElem.css( props );
		}
	}
};

jQuery.fn.extend( {
	offset: function( options ) {

// Preserve chaining for setter
		if ( arguments.length ) {
			return options === undefined ?
				this :
				this.each( function( i ) {
					jQuery.offset.setOffset( this, options, i );
				} );
		}

var doc, docElem, rect, win,
			elem = this[ 0 ];

if ( !elem ) {
			return;
		}

// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
		// Support: IE <=11 only
		// Running getBoundingClientRect on a
		// disconnected node in IE throws an error
		if ( !elem.getClientRects().length ) {
			return { top: 0, left: 0 };
		}

rect = elem.getBoundingClientRect();

doc = elem.ownerDocument;
		docElem = doc.documentElement;
		win = doc.defaultView;

return {
			top: rect.top + win.pageYOffset - docElem.clientTop,
			left: rect.left + win.pageXOffset - docElem.clientLeft
		};
	},

position: function() {
		if ( !this[ 0 ] ) {
			return;
		}

var offsetParent, offset,
			elem = this[ 0 ],
			parentOffset = { top: 0, left: 0 };

// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
		// because it is its only offset parent
		if ( jQuery.css( elem, "position" ) === "fixed" ) {

// Assume getBoundingClientRect is there when computed position is fixed
			offset = elem.getBoundingClientRect();

} else {

// Get *real* offsetParent
			offsetParent = this.offsetParent();

// Get correct offsets
			offset = this.offset();
			if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
				parentOffset = offsetParent.offset();
			}

// Add offsetParent borders
			parentOffset = {
				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
			};
		}

// Subtract parent offsets and element margins
		return {
			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
		};
	},

// This method will return documentElement in the following cases:
	// 1) For the element inside the iframe without offsetParent, this method will return
	//    documentElement of the parent window
	// 2) For the hidden or detached element
	// 3) For body or html element, i.e. in case of the html node - it will return itself
	//
	// but those exceptions were never presented as a real life use-cases
	// and might be considered as more preferable results.
	//
	// This logic, however, is not guaranteed and can change at any point in the future
	offsetParent: function() {
		return this.map( function() {
			var offsetParent = this.offsetParent;

while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
				offsetParent = offsetParent.offsetParent;
			}

return offsetParent || documentElement;
		} );
	}
} );

// Create scrollLeft and scrollTop methods
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
	var top = "pageYOffset" === prop;

jQuery.fn[ method ] = function( val ) {
		return access( this, function( elem, method, val ) {

// Coalesce documents and windows
			var win;
			if ( jQuery.isWindow( elem ) ) {
				win = elem;
			} else if ( elem.nodeType === 9 ) {
				win = elem.defaultView;
			}

if ( val === undefined ) {
				return win ? win[ prop ] : elem[ method ];
			}

if ( win ) {
				win.scrollTo(
					!top ? val : win.pageXOffset,
					top ? val : win.pageYOffset
				);

} else {
				elem[ method ] = val;
			}
		}, method, val, arguments.length );
	};
} );

// Support: Safari <=7 - 9.1, Chrome <=37 - 49
// Add the top/left cssHooks using jQuery.fn.position
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
// getComputedStyle returns percent when specified for top/left/bottom/right;
// rather than make the css module depend on the offset module, just check for it here
jQuery.each( [ "top", "left" ], function( i, prop ) {
	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
		function( elem, computed ) {
			if ( computed ) {
				computed = curCSS( elem, prop );

// If curCSS returns percentage, fallback to offset
				return rnumnonpx.test( computed ) ?
					jQuery( elem ).position()[ prop ] + "px" :
					computed;
			}
		}
	);
} );

return jQuery;
} );

${this.title}

Code Editor : offset.js