")
+
+ // inject the contents of the document in, removing the scripts
+ // to avoid any 'Permission Denied' errors in IE
+ .append( responseText.replace( rscript, "" ) )
+
+ // Locate the specified elements
+ .find( selector ) :
+
+ // If not, just inject the full result
+ responseText );
+
+ });
+
+ return this;
+};
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
+ jQuery.fn[ o ] = function( f ){
+ return this.on( o, f );
+ };
+});
+
+jQuery.each( [ "get", "post" ], function( i, method ) {
+ jQuery[ method ] = function( url, data, callback, type ) {
+ // shift arguments if data argument was omitted
+ if ( jQuery.isFunction( data ) ) {
+ type = type || callback;
+ callback = data;
+ data = undefined;
+ }
+
+ return jQuery.ajax({
+ type: method,
+ url: url,
+ data: data,
+ success: callback,
+ dataType: type
+ });
+ };
+});
+
+jQuery.extend({
+
+ getScript: function( url, callback ) {
+ return jQuery.get( url, undefined, callback, "script" );
+ },
+
+ getJSON: function( url, data, callback ) {
+ return jQuery.get( url, data, callback, "json" );
+ },
+
+ // Creates a full fledged settings object into target
+ // with both ajaxSettings and settings fields.
+ // If target is omitted, writes into ajaxSettings.
+ ajaxSetup: function( target, settings ) {
+ if ( settings ) {
+ // Building a settings object
+ ajaxExtend( target, jQuery.ajaxSettings );
+ } else {
+ // Extending ajaxSettings
+ settings = target;
+ target = jQuery.ajaxSettings;
+ }
+ ajaxExtend( target, settings );
+ return target;
+ },
+
+ ajaxSettings: {
+ url: ajaxLocation,
+ isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
+ global: true,
+ type: "GET",
+ contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+ processData: true,
+ async: true,
+ /*
+ timeout: 0,
+ data: null,
+ dataType: null,
+ username: null,
+ password: null,
+ cache: null,
+ throws: false,
+ traditional: false,
+ headers: {},
+ */
+
+ accepts: {
+ xml: "application/xml, text/xml",
+ html: "text/html",
+ text: "text/plain",
+ json: "application/json, text/javascript",
+ "*": allTypes
+ },
+
+ contents: {
+ xml: /xml/,
+ html: /html/,
+ json: /json/
+ },
+
+ responseFields: {
+ xml: "responseXML",
+ text: "responseText"
+ },
+
+ // List of data converters
+ // 1) key format is "source_type destination_type" (a single space in-between)
+ // 2) the catchall symbol "*" can be used for source_type
+ converters: {
+
+ // Convert anything to text
+ "* text": window.String,
+
+ // Text to html (true = no transformation)
+ "text html": true,
+
+ // Evaluate text as a json expression
+ "text json": jQuery.parseJSON,
+
+ // Parse text as xml
+ "text xml": jQuery.parseXML
+ },
+
+ // For options that shouldn't be deep extended:
+ // you can add your own custom options here if
+ // and when you create one that shouldn't be
+ // deep extended (see ajaxExtend)
+ flatOptions: {
+ context: true,
+ url: true
+ }
+ },
+
+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+ ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+ // Main method
+ ajax: function( url, options ) {
+
+ // If url is an object, simulate pre-1.5 signature
+ if ( typeof url === "object" ) {
+ options = url;
+ url = undefined;
+ }
+
+ // Force options to be an object
+ options = options || {};
+
+ var // ifModified key
+ ifModifiedKey,
+ // Response headers
+ responseHeadersString,
+ responseHeaders,
+ // transport
+ transport,
+ // timeout handle
+ timeoutTimer,
+ // Cross-domain detection vars
+ parts,
+ // To know if global events are to be dispatched
+ fireGlobals,
+ // Loop variable
+ i,
+ // Create the final options object
+ s = jQuery.ajaxSetup( {}, options ),
+ // Callbacks context
+ callbackContext = s.context || s,
+ // Context for global events
+ // It's the callbackContext if one was provided in the options
+ // and if it's a DOM node or a jQuery collection
+ globalEventContext = callbackContext !== s &&
+ ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
+ jQuery( callbackContext ) : jQuery.event,
+ // Deferreds
+ deferred = jQuery.Deferred(),
+ completeDeferred = jQuery.Callbacks( "once memory" ),
+ // Status-dependent callbacks
+ statusCode = s.statusCode || {},
+ // Headers (they are sent all at once)
+ requestHeaders = {},
+ requestHeadersNames = {},
+ // The jqXHR state
+ state = 0,
+ // Default abort message
+ strAbort = "canceled",
+ // Fake xhr
+ jqXHR = {
+
+ readyState: 0,
+
+ // Caches the header
+ setRequestHeader: function( name, value ) {
+ if ( !state ) {
+ var lname = name.toLowerCase();
+ name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
+ requestHeaders[ name ] = value;
+ }
+ return this;
+ },
+
+ // Raw string
+ getAllResponseHeaders: function() {
+ return state === 2 ? responseHeadersString : null;
+ },
+
+ // Builds headers hashtable if needed
+ getResponseHeader: function( key ) {
+ var match;
+ if ( state === 2 ) {
+ if ( !responseHeaders ) {
+ responseHeaders = {};
+ while( ( match = rheaders.exec( responseHeadersString ) ) ) {
+ responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
+ }
+ }
+ match = responseHeaders[ key.toLowerCase() ];
+ }
+ return match === undefined ? null : match;
+ },
+
+ // Overrides response content-type header
+ overrideMimeType: function( type ) {
+ if ( !state ) {
+ s.mimeType = type;
+ }
+ return this;
+ },
+
+ // Cancel the request
+ abort: function( statusText ) {
+ statusText = statusText || strAbort;
+ if ( transport ) {
+ transport.abort( statusText );
+ }
+ done( 0, statusText );
+ return this;
+ }
+ };
+
+ // Callback for when everything is done
+ // It is defined here because jslint complains if it is declared
+ // at the end of the function (which would be more logical and readable)
+ function done( status, nativeStatusText, responses, headers ) {
+ var isSuccess, success, error, response, modified,
+ statusText = nativeStatusText;
+
+ // Called once
+ if ( state === 2 ) {
+ return;
+ }
+
+ // State is "done" now
+ state = 2;
+
+ // Clear timeout if it exists
+ if ( timeoutTimer ) {
+ clearTimeout( timeoutTimer );
+ }
+
+ // Dereference transport for early garbage collection
+ // (no matter how long the jqXHR object will be used)
+ transport = undefined;
+
+ // Cache response headers
+ responseHeadersString = headers || "";
+
+ // Set readyState
+ jqXHR.readyState = status > 0 ? 4 : 0;
+
+ // Get response data
+ if ( responses ) {
+ response = ajaxHandleResponses( s, jqXHR, responses );
+ }
+
+ // If successful, handle type chaining
+ if ( status >= 200 && status < 300 || status === 304 ) {
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+
+ modified = jqXHR.getResponseHeader("Last-Modified");
+ if ( modified ) {
+ jQuery.lastModified[ ifModifiedKey ] = modified;
+ }
+ modified = jqXHR.getResponseHeader("Etag");
+ if ( modified ) {
+ jQuery.etag[ ifModifiedKey ] = modified;
+ }
+ }
+
+ // If not modified
+ if ( status === 304 ) {
+
+ statusText = "notmodified";
+ isSuccess = true;
+
+ // If we have data
+ } else {
+
+ isSuccess = ajaxConvert( s, response );
+ statusText = isSuccess.state;
+ success = isSuccess.data;
+ error = isSuccess.error;
+ isSuccess = !error;
+ }
+ } else {
+ // We extract error from statusText
+ // then normalize statusText and status for non-aborts
+ error = statusText;
+ if ( !statusText || status ) {
+ statusText = "error";
+ if ( status < 0 ) {
+ status = 0;
+ }
+ }
+ }
+
+ // Set data for the fake xhr object
+ jqXHR.status = status;
+ jqXHR.statusText = "" + ( nativeStatusText || statusText );
+
+ // Success/Error
+ if ( isSuccess ) {
+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+ } else {
+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+ }
+
+ // Status-dependent callbacks
+ jqXHR.statusCode( statusCode );
+ statusCode = undefined;
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
+ [ jqXHR, s, isSuccess ? success : error ] );
+ }
+
+ // Complete
+ completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+ // Handle the global AJAX counter
+ if ( !( --jQuery.active ) ) {
+ jQuery.event.trigger( "ajaxStop" );
+ }
+ }
+ }
+
+ // Attach deferreds
+ deferred.promise( jqXHR );
+ jqXHR.success = jqXHR.done;
+ jqXHR.error = jqXHR.fail;
+ jqXHR.complete = completeDeferred.add;
+
+ // Status-dependent callbacks
+ jqXHR.statusCode = function( map ) {
+ if ( map ) {
+ var tmp;
+ if ( state < 2 ) {
+ for ( tmp in map ) {
+ statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
+ }
+ } else {
+ tmp = map[ jqXHR.status ];
+ jqXHR.always( tmp );
+ }
+ }
+ return this;
+ };
+
+ // Remove hash character (#7531: and string promotion)
+ // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
+ // We also use the url parameter if available
+ s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
+
+ // Extract dataTypes list
+ s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( core_rspace );
+
+ // Determine if a cross-domain request is in order
+ if ( s.crossDomain == null ) {
+ parts = rurl.exec( s.url.toLowerCase() );
+ s.crossDomain = !!( parts &&
+ ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
+ ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
+ ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
+ );
+ }
+
+ // Convert data if not already a string
+ if ( s.data && s.processData && typeof s.data !== "string" ) {
+ s.data = jQuery.param( s.data, s.traditional );
+ }
+
+ // Apply prefilters
+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+ // If request was aborted inside a prefilter, stop there
+ if ( state === 2 ) {
+ return jqXHR;
+ }
+
+ // We can fire global events as of now if asked to
+ fireGlobals = s.global;
+
+ // Uppercase the type
+ s.type = s.type.toUpperCase();
+
+ // Determine if request has content
+ s.hasContent = !rnoContent.test( s.type );
+
+ // Watch for a new set of requests
+ if ( fireGlobals && jQuery.active++ === 0 ) {
+ jQuery.event.trigger( "ajaxStart" );
+ }
+
+ // More options handling for requests with no content
+ if ( !s.hasContent ) {
+
+ // If data is available, append data to url
+ if ( s.data ) {
+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
+ // #9682: remove data so that it's not used in an eventual retry
+ delete s.data;
+ }
+
+ // Get ifModifiedKey before adding the anti-cache parameter
+ ifModifiedKey = s.url;
+
+ // Add anti-cache in url if needed
+ if ( s.cache === false ) {
+
+ var ts = jQuery.now(),
+ // try replacing _= if it is there
+ ret = s.url.replace( rts, "$1_=" + ts );
+
+ // if nothing was replaced, add timestamp to the end
+ s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
+ }
+ }
+
+ // Set the correct header, if data is being sent
+ if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
+ }
+
+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+ if ( s.ifModified ) {
+ ifModifiedKey = ifModifiedKey || s.url;
+ if ( jQuery.lastModified[ ifModifiedKey ] ) {
+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
+ }
+ if ( jQuery.etag[ ifModifiedKey ] ) {
+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
+ }
+ }
+
+ // Set the Accepts header for the server, depending on the dataType
+ jqXHR.setRequestHeader(
+ "Accept",
+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
+ s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+ s.accepts[ "*" ]
+ );
+
+ // Check for headers option
+ for ( i in s.headers ) {
+ jqXHR.setRequestHeader( i, s.headers[ i ] );
+ }
+
+ // Allow custom headers/mimetypes and early abort
+ if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
+ // Abort if not done already and return
+ return jqXHR.abort();
+
+ }
+
+ // aborting is no longer a cancellation
+ strAbort = "abort";
+
+ // Install callbacks on deferreds
+ for ( i in { success: 1, error: 1, complete: 1 } ) {
+ jqXHR[ i ]( s[ i ] );
+ }
+
+ // Get transport
+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+ // If no transport, we auto-abort
+ if ( !transport ) {
+ done( -1, "No Transport" );
+ } else {
+ jqXHR.readyState = 1;
+ // Send global event
+ if ( fireGlobals ) {
+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+ }
+ // Timeout
+ if ( s.async && s.timeout > 0 ) {
+ timeoutTimer = setTimeout( function(){
+ jqXHR.abort( "timeout" );
+ }, s.timeout );
+ }
+
+ try {
+ state = 1;
+ transport.send( requestHeaders, done );
+ } catch (e) {
+ // Propagate exception as error if not done
+ if ( state < 2 ) {
+ done( -1, e );
+ // Simply rethrow otherwise
+ } else {
+ throw e;
+ }
+ }
+ }
+
+ return jqXHR;
+ },
+
+ // Counter for holding the number of active queries
+ active: 0,
+
+ // Last-Modified header cache for next request
+ lastModified: {},
+ etag: {}
+
+});
+
+/* Handles responses to an ajax request:
+ * - sets all responseXXX fields accordingly
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+ var ct, type, finalDataType, firstDataType,
+ contents = s.contents,
+ dataTypes = s.dataTypes,
+ responseFields = s.responseFields;
+
+ // Fill responseXXX fields
+ for ( type in responseFields ) {
+ if ( type in responses ) {
+ jqXHR[ responseFields[type] ] = responses[ type ];
+ }
+ }
+
+ // Remove auto dataType and get content-type in the process
+ while( dataTypes[ 0 ] === "*" ) {
+ dataTypes.shift();
+ if ( ct === undefined ) {
+ ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
+ }
+ }
+
+ // Check if we're dealing with a known content-type
+ if ( ct ) {
+ for ( type in contents ) {
+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
+ dataTypes.unshift( type );
+ break;
+ }
+ }
+ }
+
+ // Check to see if we have a response for the expected dataType
+ if ( dataTypes[ 0 ] in responses ) {
+ finalDataType = dataTypes[ 0 ];
+ } else {
+ // Try convertible dataTypes
+ for ( type in responses ) {
+ if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
+ finalDataType = type;
+ break;
+ }
+ if ( !firstDataType ) {
+ firstDataType = type;
+ }
+ }
+ // Or just use first one
+ finalDataType = finalDataType || firstDataType;
+ }
+
+ // If we found a dataType
+ // We add the dataType to the list if needed
+ // and return the corresponding response
+ if ( finalDataType ) {
+ if ( finalDataType !== dataTypes[ 0 ] ) {
+ dataTypes.unshift( finalDataType );
+ }
+ return responses[ finalDataType ];
+ }
+}
+
+// Chain conversions given the request and the original response
+function ajaxConvert( s, response ) {
+
+ var conv, conv2, current, tmp,
+ // Work with a copy of dataTypes in case we need to modify it for conversion
+ dataTypes = s.dataTypes.slice(),
+ prev = dataTypes[ 0 ],
+ converters = {},
+ i = 0;
+
+ // Apply the dataFilter if provided
+ if ( s.dataFilter ) {
+ response = s.dataFilter( response, s.dataType );
+ }
+
+ // Create converters map with lowercased keys
+ if ( dataTypes[ 1 ] ) {
+ for ( conv in s.converters ) {
+ converters[ conv.toLowerCase() ] = s.converters[ conv ];
+ }
+ }
+
+ // Convert to each sequential dataType, tolerating list modification
+ for ( ; (current = dataTypes[++i]); ) {
+
+ // There's only work to do if current dataType is non-auto
+ if ( current !== "*" ) {
+
+ // Convert response if prev dataType is non-auto and differs from current
+ if ( prev !== "*" && prev !== current ) {
+
+ // Seek a direct converter
+ conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+ // If none found, seek a pair
+ if ( !conv ) {
+ for ( conv2 in converters ) {
+
+ // If conv2 outputs current
+ tmp = conv2.split(" ");
+ if ( tmp[ 1 ] === current ) {
+
+ // If prev can be converted to accepted input
+ conv = converters[ prev + " " + tmp[ 0 ] ] ||
+ converters[ "* " + tmp[ 0 ] ];
+ if ( conv ) {
+ // Condense equivalence converters
+ if ( conv === true ) {
+ conv = converters[ conv2 ];
+
+ // Otherwise, insert the intermediate dataType
+ } else if ( converters[ conv2 ] !== true ) {
+ current = tmp[ 0 ];
+ dataTypes.splice( i--, 0, current );
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ // Apply converter (if not an equivalence)
+ if ( conv !== true ) {
+
+ // Unless errors are allowed to bubble, catch and return them
+ if ( conv && s["throws"] ) {
+ response = conv( response );
+ } else {
+ try {
+ response = conv( response );
+ } catch ( e ) {
+ return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
+ }
+ }
+ }
+ }
+
+ // Update prev for next iteration
+ prev = current;
+ }
+ }
+
+ return { state: "success", data: response };
+}
+var oldCallbacks = [],
+ rquestion = /\?/,
+ rjsonp = /(=)\?(?=&|$)|\?\?/,
+ nonce = jQuery.now();
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+ jsonp: "callback",
+ jsonpCallback: function() {
+ var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
+ this[ callback ] = true;
+ return callback;
+ }
+});
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+ var callbackName, overwritten, responseContainer,
+ data = s.data,
+ url = s.url,
+ hasCallback = s.jsonp !== false,
+ replaceInUrl = hasCallback && rjsonp.test( url ),
+ replaceInData = hasCallback && !replaceInUrl && typeof data === "string" &&
+ !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") &&
+ rjsonp.test( data );
+
+ // Handle iff the expected data type is "jsonp" or we have a parameter to set
+ if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) {
+
+ // Get callback name, remembering preexisting value associated with it
+ callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+ s.jsonpCallback() :
+ s.jsonpCallback;
+ overwritten = window[ callbackName ];
+
+ // Insert callback into url or form data
+ if ( replaceInUrl ) {
+ s.url = url.replace( rjsonp, "$1" + callbackName );
+ } else if ( replaceInData ) {
+ s.data = data.replace( rjsonp, "$1" + callbackName );
+ } else if ( hasCallback ) {
+ s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+ }
+
+ // Use data converter to retrieve json after script execution
+ s.converters["script json"] = function() {
+ if ( !responseContainer ) {
+ jQuery.error( callbackName + " was not called" );
+ }
+ return responseContainer[ 0 ];
+ };
+
+ // force json dataType
+ s.dataTypes[ 0 ] = "json";
+
+ // Install callback
+ window[ callbackName ] = function() {
+ responseContainer = arguments;
+ };
+
+ // Clean-up function (fires after converters)
+ jqXHR.always(function() {
+ // Restore preexisting value
+ window[ callbackName ] = overwritten;
+
+ // Save back as free
+ if ( s[ callbackName ] ) {
+ // make sure that re-using the options doesn't screw things around
+ s.jsonpCallback = originalSettings.jsonpCallback;
+
+ // save the callback name for future use
+ oldCallbacks.push( callbackName );
+ }
+
+ // Call if it was a function and we have a response
+ if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+ overwritten( responseContainer[ 0 ] );
+ }
+
+ responseContainer = overwritten = undefined;
+ });
+
+ // Delegate to script
+ return "script";
+ }
+});
+// Install script dataType
+jQuery.ajaxSetup({
+ accepts: {
+ script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+ },
+ contents: {
+ script: /javascript|ecmascript/
+ },
+ converters: {
+ "text script": function( text ) {
+ jQuery.globalEval( text );
+ return text;
+ }
+ }
+});
+
+// Handle cache's special case and global
+jQuery.ajaxPrefilter( "script", function( s ) {
+ if ( s.cache === undefined ) {
+ s.cache = false;
+ }
+ if ( s.crossDomain ) {
+ s.type = "GET";
+ s.global = false;
+ }
+});
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function(s) {
+
+ // This transport only deals with cross domain requests
+ if ( s.crossDomain ) {
+
+ var script,
+ head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
+
+ return {
+
+ send: function( _, callback ) {
+
+ script = document.createElement( "script" );
+
+ script.async = "async";
+
+ if ( s.scriptCharset ) {
+ script.charset = s.scriptCharset;
+ }
+
+ script.src = s.url;
+
+ // Attach handlers for all browsers
+ script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+ if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+ // Handle memory leak in IE
+ script.onload = script.onreadystatechange = null;
+
+ // Remove the script
+ if ( head && script.parentNode ) {
+ head.removeChild( script );
+ }
+
+ // Dereference the script
+ script = undefined;
+
+ // Callback if not abort
+ if ( !isAbort ) {
+ callback( 200, "success" );
+ }
+ }
+ };
+ // Use insertBefore instead of appendChild to circumvent an IE6 bug.
+ // This arises when a base node is used (#2709 and #4378).
+ head.insertBefore( script, head.firstChild );
+ },
+
+ abort: function() {
+ if ( script ) {
+ script.onload( 0, 1 );
+ }
+ }
+ };
+ }
+});
+var xhrCallbacks,
+ // #5280: Internet Explorer will keep connections alive if we don't abort on unload
+ xhrOnUnloadAbort = window.ActiveXObject ? function() {
+ // Abort all pending requests
+ for ( var key in xhrCallbacks ) {
+ xhrCallbacks[ key ]( 0, 1 );
+ }
+ } : false,
+ xhrId = 0;
+
+// Functions to create xhrs
+function createStandardXHR() {
+ try {
+ return new window.XMLHttpRequest();
+ } catch( e ) {}
+}
+
+function createActiveXHR() {
+ try {
+ return new window.ActiveXObject( "Microsoft.XMLHTTP" );
+ } catch( e ) {}
+}
+
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+jQuery.ajaxSettings.xhr = window.ActiveXObject ?
+ /* Microsoft failed to properly
+ * implement the XMLHttpRequest in IE7 (can't request local files),
+ * so we use the ActiveXObject when it is available
+ * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
+ * we need a fallback.
+ */
+ function() {
+ return !this.isLocal && createStandardXHR() || createActiveXHR();
+ } :
+ // For all other browsers, use the standard XMLHttpRequest object
+ createStandardXHR;
+
+// Determine support properties
+(function( xhr ) {
+ jQuery.extend( jQuery.support, {
+ ajax: !!xhr,
+ cors: !!xhr && ( "withCredentials" in xhr )
+ });
+})( jQuery.ajaxSettings.xhr() );
+
+// Create transport if the browser can provide an xhr
+if ( jQuery.support.ajax ) {
+
+ jQuery.ajaxTransport(function( s ) {
+ // Cross domain only allowed if supported through XMLHttpRequest
+ if ( !s.crossDomain || jQuery.support.cors ) {
+
+ var callback;
+
+ return {
+ send: function( headers, complete ) {
+
+ // Get a new xhr
+ var handle, i,
+ xhr = s.xhr();
+
+ // Open the socket
+ // Passing null username, generates a login popup on Opera (#2865)
+ if ( s.username ) {
+ xhr.open( s.type, s.url, s.async, s.username, s.password );
+ } else {
+ xhr.open( s.type, s.url, s.async );
+ }
+
+ // Apply custom fields if provided
+ if ( s.xhrFields ) {
+ for ( i in s.xhrFields ) {
+ xhr[ i ] = s.xhrFields[ i ];
+ }
+ }
+
+ // Override mime type if needed
+ if ( s.mimeType && xhr.overrideMimeType ) {
+ xhr.overrideMimeType( s.mimeType );
+ }
+
+ // X-Requested-With header
+ // For cross-domain requests, seeing as conditions for a preflight are
+ // akin to a jigsaw puzzle, we simply never set it to be sure.
+ // (it can always be set on a per-request basis or even using ajaxSetup)
+ // For same-domain requests, won't change header if already provided.
+ if ( !s.crossDomain && !headers["X-Requested-With"] ) {
+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
+ }
+
+ // Need an extra try/catch for cross domain requests in Firefox 3
+ try {
+ for ( i in headers ) {
+ xhr.setRequestHeader( i, headers[ i ] );
+ }
+ } catch( _ ) {}
+
+ // Do send the request
+ // This may raise an exception which is actually
+ // handled in jQuery.ajax (so no try/catch here)
+ xhr.send( ( s.hasContent && s.data ) || null );
+
+ // Listener
+ callback = function( _, isAbort ) {
+
+ var status,
+ statusText,
+ responseHeaders,
+ responses,
+ xml;
+
+ // Firefox throws exceptions when accessing properties
+ // of an xhr when a network error occurred
+ // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
+ try {
+
+ // Was never called and is aborted or complete
+ if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+ // Only called once
+ callback = undefined;
+
+ // Do not keep as active anymore
+ if ( handle ) {
+ xhr.onreadystatechange = jQuery.noop;
+ if ( xhrOnUnloadAbort ) {
+ delete xhrCallbacks[ handle ];
+ }
+ }
+
+ // If it's an abort
+ if ( isAbort ) {
+ // Abort it manually if needed
+ if ( xhr.readyState !== 4 ) {
+ xhr.abort();
+ }
+ } else {
+ status = xhr.status;
+ responseHeaders = xhr.getAllResponseHeaders();
+ responses = {};
+ xml = xhr.responseXML;
+
+ // Construct response list
+ if ( xml && xml.documentElement /* #4958 */ ) {
+ responses.xml = xml;
+ }
+
+ // When requesting binary data, IE6-9 will throw an exception
+ // on any attempt to access responseText (#11426)
+ try {
+ responses.text = xhr.responseText;
+ } catch( _ ) {
+ }
+
+ // Firefox throws an exception when accessing
+ // statusText for faulty cross-domain requests
+ try {
+ statusText = xhr.statusText;
+ } catch( e ) {
+ // We normalize with Webkit giving an empty statusText
+ statusText = "";
+ }
+
+ // Filter status for non standard behaviors
+
+ // If the request is local and we have data: assume a success
+ // (success with no data won't get notified, that's the best we
+ // can do given current implementations)
+ if ( !status && s.isLocal && !s.crossDomain ) {
+ status = responses.text ? 200 : 404;
+ // IE - #1450: sometimes returns 1223 when it should be 204
+ } else if ( status === 1223 ) {
+ status = 204;
+ }
+ }
+ }
+ } catch( firefoxAccessException ) {
+ if ( !isAbort ) {
+ complete( -1, firefoxAccessException );
+ }
+ }
+
+ // Call complete if needed
+ if ( responses ) {
+ complete( status, statusText, responses, responseHeaders );
+ }
+ };
+
+ if ( !s.async ) {
+ // if we're in sync mode we fire the callback
+ callback();
+ } else if ( xhr.readyState === 4 ) {
+ // (IE6 & IE7) if it's in cache and has been
+ // retrieved directly we need to fire the callback
+ setTimeout( callback, 0 );
+ } else {
+ handle = ++xhrId;
+ if ( xhrOnUnloadAbort ) {
+ // Create the active xhrs callbacks list if needed
+ // and attach the unload handler
+ if ( !xhrCallbacks ) {
+ xhrCallbacks = {};
+ jQuery( window ).unload( xhrOnUnloadAbort );
+ }
+ // Add to list of active xhrs callbacks
+ xhrCallbacks[ handle ] = callback;
+ }
+ xhr.onreadystatechange = callback;
+ }
+ },
+
+ abort: function() {
+ if ( callback ) {
+ callback(0,1);
+ }
+ }
+ };
+ }
+ });
+}
+var fxNow, timerId,
+ rfxtypes = /^(?:toggle|show|hide)$/,
+ rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
+ rrun = /queueHooks$/,
+ animationPrefilters = [ defaultPrefilter ],
+ tweeners = {
+ "*": [function( prop, value ) {
+ var end, unit, prevScale,
+ tween = this.createTween( prop, value ),
+ parts = rfxnum.exec( value ),
+ target = tween.cur(),
+ start = +target || 0,
+ scale = 1;
+
+ if ( parts ) {
+ end = +parts[2];
+ unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+
+ // We need to compute starting value
+ if ( unit !== "px" && start ) {
+ // Iteratively approximate from a nonzero starting point
+ // Prefer the current property, because this process will be trivial if it uses the same units
+ // Fallback to end or a simple constant
+ start = jQuery.css( tween.elem, prop, true ) || end || 1;
+
+ do {
+ // If previous iteration zeroed out, double until we get *something*
+ // Use a string for doubling factor so we don't accidentally see scale as unchanged below
+ prevScale = scale = scale || ".5";
+
+ // Adjust and apply
+ start = start / scale;
+ jQuery.style( tween.elem, prop, start + unit );
+
+ // Update scale, tolerating zeroes from tween.cur()
+ scale = tween.cur() / target;
+
+ // Stop looping if we've hit the mark or scale is unchanged
+ } while ( scale !== 1 && scale !== prevScale );
+ }
+
+ tween.unit = unit;
+ tween.start = start;
+ // If a +=/-= token was provided, we're doing a relative animation
+ tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
+ }
+ return tween;
+ }]
+ };
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+ setTimeout(function() {
+ fxNow = undefined;
+ }, 0 );
+ return ( fxNow = jQuery.now() );
+}
+
+function createTweens( animation, props ) {
+ jQuery.each( props, function( prop, value ) {
+ var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
+ index = 0,
+ length = collection.length;
+ for ( ; index < length; index++ ) {
+ if ( collection[ index ].call( animation, prop, value ) ) {
+
+ // we're done with this property
+ return;
+ }
+ }
+ });
+}
+
+function Animation( elem, properties, options ) {
+ var result,
+ index = 0,
+ tweenerIndex = 0,
+ length = animationPrefilters.length,
+ deferred = jQuery.Deferred().always( function() {
+ // don't match elem in the :animated selector
+ delete tick.elem;
+ }),
+ tick = function() {
+ var currentTime = fxNow || createFxNow(),
+ remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+ percent = 1 - ( remaining / animation.duration || 0 ),
+ index = 0,
+ length = animation.tweens.length;
+
+ for ( ; index < length ; index++ ) {
+ animation.tweens[ index ].run( percent );
+ }
+
+ deferred.notifyWith( elem, [ animation, percent, remaining ]);
+
+ if ( percent < 1 && length ) {
+ return remaining;
+ } else {
+ deferred.resolveWith( elem, [ animation ] );
+ return false;
+ }
+ },
+ animation = deferred.promise({
+ elem: elem,
+ props: jQuery.extend( {}, properties ),
+ opts: jQuery.extend( true, { specialEasing: {} }, options ),
+ originalProperties: properties,
+ originalOptions: options,
+ startTime: fxNow || createFxNow(),
+ duration: options.duration,
+ tweens: [],
+ createTween: function( prop, end, easing ) {
+ var tween = jQuery.Tween( elem, animation.opts, prop, end,
+ animation.opts.specialEasing[ prop ] || animation.opts.easing );
+ animation.tweens.push( tween );
+ return tween;
+ },
+ stop: function( gotoEnd ) {
+ var index = 0,
+ // if we are going to the end, we want to run all the tweens
+ // otherwise we skip this part
+ length = gotoEnd ? animation.tweens.length : 0;
+
+ for ( ; index < length ; index++ ) {
+ animation.tweens[ index ].run( 1 );
+ }
+
+ // resolve when we played the last frame
+ // otherwise, reject
+ if ( gotoEnd ) {
+ deferred.resolveWith( elem, [ animation, gotoEnd ] );
+ } else {
+ deferred.rejectWith( elem, [ animation, gotoEnd ] );
+ }
+ return this;
+ }
+ }),
+ props = animation.props;
+
+ propFilter( props, animation.opts.specialEasing );
+
+ for ( ; index < length ; index++ ) {
+ result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
+ if ( result ) {
+ return result;
+ }
+ }
+
+ createTweens( animation, props );
+
+ if ( jQuery.isFunction( animation.opts.start ) ) {
+ animation.opts.start.call( elem, animation );
+ }
+
+ jQuery.fx.timer(
+ jQuery.extend( tick, {
+ anim: animation,
+ queue: animation.opts.queue,
+ elem: elem
+ })
+ );
+
+ // attach callbacks from options
+ return animation.progress( animation.opts.progress )
+ .done( animation.opts.done, animation.opts.complete )
+ .fail( animation.opts.fail )
+ .always( animation.opts.always );
+}
+
+function propFilter( props, specialEasing ) {
+ var index, name, easing, value, hooks;
+
+ // camelCase, specialEasing and expand cssHook pass
+ for ( index in props ) {
+ name = jQuery.camelCase( index );
+ easing = specialEasing[ name ];
+ value = props[ index ];
+ if ( jQuery.isArray( value ) ) {
+ easing = value[ 1 ];
+ value = props[ index ] = value[ 0 ];
+ }
+
+ if ( index !== name ) {
+ props[ name ] = value;
+ delete props[ index ];
+ }
+
+ hooks = jQuery.cssHooks[ name ];
+ if ( hooks && "expand" in hooks ) {
+ value = hooks.expand( value );
+ delete props[ name ];
+
+ // not quite $.extend, this wont overwrite keys already present.
+ // also - reusing 'index' from above because we have the correct "name"
+ for ( index in value ) {
+ if ( !( index in props ) ) {
+ props[ index ] = value[ index ];
+ specialEasing[ index ] = easing;
+ }
+ }
+ } else {
+ specialEasing[ name ] = easing;
+ }
+ }
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+ tweener: function( props, callback ) {
+ if ( jQuery.isFunction( props ) ) {
+ callback = props;
+ props = [ "*" ];
+ } else {
+ props = props.split(" ");
+ }
+
+ var prop,
+ index = 0,
+ length = props.length;
+
+ for ( ; index < length ; index++ ) {
+ prop = props[ index ];
+ tweeners[ prop ] = tweeners[ prop ] || [];
+ tweeners[ prop ].unshift( callback );
+ }
+ },
+
+ prefilter: function( callback, prepend ) {
+ if ( prepend ) {
+ animationPrefilters.unshift( callback );
+ } else {
+ animationPrefilters.push( callback );
+ }
+ }
+});
+
+function defaultPrefilter( elem, props, opts ) {
+ var index, prop, value, length, dataShow, tween, hooks, oldfire,
+ anim = this,
+ style = elem.style,
+ orig = {},
+ handled = [],
+ hidden = elem.nodeType && isHidden( elem );
+
+ // handle queue: false promises
+ if ( !opts.queue ) {
+ hooks = jQuery._queueHooks( elem, "fx" );
+ if ( hooks.unqueued == null ) {
+ hooks.unqueued = 0;
+ oldfire = hooks.empty.fire;
+ hooks.empty.fire = function() {
+ if ( !hooks.unqueued ) {
+ oldfire();
+ }
+ };
+ }
+ hooks.unqueued++;
+
+ anim.always(function() {
+ // doing this makes sure that the complete handler will be called
+ // before this completes
+ anim.always(function() {
+ hooks.unqueued--;
+ if ( !jQuery.queue( elem, "fx" ).length ) {
+ hooks.empty.fire();
+ }
+ });
+ });
+ }
+
+ // height/width overflow pass
+ if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
+ // Make sure that nothing sneaks out
+ // Record all 3 overflow attributes because IE does not
+ // change the overflow attribute when overflowX and
+ // overflowY are set to the same value
+ opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+ // Set display property to inline-block for height/width
+ // animations on inline elements that are having width/height animated
+ if ( jQuery.css( elem, "display" ) === "inline" &&
+ jQuery.css( elem, "float" ) === "none" ) {
+
+ // inline-level elements accept inline-block;
+ // block-level elements need to be inline with layout
+ if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
+ style.display = "inline-block";
+
+ } else {
+ style.zoom = 1;
+ }
+ }
+ }
+
+ if ( opts.overflow ) {
+ style.overflow = "hidden";
+ if ( !jQuery.support.shrinkWrapBlocks ) {
+ anim.done(function() {
+ style.overflow = opts.overflow[ 0 ];
+ style.overflowX = opts.overflow[ 1 ];
+ style.overflowY = opts.overflow[ 2 ];
+ });
+ }
+ }
+
+
+ // show/hide pass
+ for ( index in props ) {
+ value = props[ index ];
+ if ( rfxtypes.exec( value ) ) {
+ delete props[ index ];
+ if ( value === ( hidden ? "hide" : "show" ) ) {
+ continue;
+ }
+ handled.push( index );
+ }
+ }
+
+ length = handled.length;
+ if ( length ) {
+ dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
+ if ( hidden ) {
+ jQuery( elem ).show();
+ } else {
+ anim.done(function() {
+ jQuery( elem ).hide();
+ });
+ }
+ anim.done(function() {
+ var prop;
+ jQuery.removeData( elem, "fxshow", true );
+ for ( prop in orig ) {
+ jQuery.style( elem, prop, orig[ prop ] );
+ }
+ });
+ for ( index = 0 ; index < length ; index++ ) {
+ prop = handled[ index ];
+ tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
+ orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
+
+ if ( !( prop in dataShow ) ) {
+ dataShow[ prop ] = tween.start;
+ if ( hidden ) {
+ tween.end = tween.start;
+ tween.start = prop === "width" || prop === "height" ? 1 : 0;
+ }
+ }
+ }
+ }
+}
+
+function Tween( elem, options, prop, end, easing ) {
+ return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+ constructor: Tween,
+ init: function( elem, options, prop, end, easing, unit ) {
+ this.elem = elem;
+ this.prop = prop;
+ this.easing = easing || "swing";
+ this.options = options;
+ this.start = this.now = this.cur();
+ this.end = end;
+ this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+ },
+ cur: function() {
+ var hooks = Tween.propHooks[ this.prop ];
+
+ return hooks && hooks.get ?
+ hooks.get( this ) :
+ Tween.propHooks._default.get( this );
+ },
+ run: function( percent ) {
+ var eased,
+ hooks = Tween.propHooks[ this.prop ];
+
+ if ( this.options.duration ) {
+ this.pos = eased = jQuery.easing[ this.easing ](
+ percent, this.options.duration * percent, 0, 1, this.options.duration
+ );
+ } else {
+ this.pos = eased = percent;
+ }
+ this.now = ( this.end - this.start ) * eased + this.start;
+
+ if ( this.options.step ) {
+ this.options.step.call( this.elem, this.now, this );
+ }
+
+ if ( hooks && hooks.set ) {
+ hooks.set( this );
+ } else {
+ Tween.propHooks._default.set( this );
+ }
+ return this;
+ }
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+ _default: {
+ get: function( tween ) {
+ var result;
+
+ if ( tween.elem[ tween.prop ] != null &&
+ (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
+ return tween.elem[ tween.prop ];
+ }
+
+ // passing any value as a 4th parameter to .css will automatically
+ // attempt a parseFloat and fallback to a string if the parse fails
+ // so, simple values such as "10px" are parsed to Float.
+ // complex values such as "rotate(1rad)" are returned as is.
+ result = jQuery.css( tween.elem, tween.prop, false, "" );
+ // Empty strings, null, undefined and "auto" are converted to 0.
+ return !result || result === "auto" ? 0 : result;
+ },
+ set: function( tween ) {
+ // use step hook for back compat - use cssHook if its there - use .style if its
+ // available and use plain properties where available
+ if ( jQuery.fx.step[ tween.prop ] ) {
+ jQuery.fx.step[ tween.prop ]( tween );
+ } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
+ jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+ } else {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+ }
+};
+
+// Remove in 2.0 - this supports IE8's panic based approach
+// to setting things on disconnected nodes
+
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+ set: function( tween ) {
+ if ( tween.elem.nodeType && tween.elem.parentNode ) {
+ tween.elem[ tween.prop ] = tween.now;
+ }
+ }
+};
+
+jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
+ var cssFn = jQuery.fn[ name ];
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return speed == null || typeof speed === "boolean" ||
+ // special check for .toggle( handler, handler, ... )
+ ( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ?
+ cssFn.apply( this, arguments ) :
+ this.animate( genFx( name, true ), speed, easing, callback );
+ };
+});
+
+jQuery.fn.extend({
+ fadeTo: function( speed, to, easing, callback ) {
+
+ // show any hidden elements after setting opacity to 0
+ return this.filter( isHidden ).css( "opacity", 0 ).show()
+
+ // animate to the value specified
+ .end().animate({ opacity: to }, speed, easing, callback );
+ },
+ animate: function( prop, speed, easing, callback ) {
+ var empty = jQuery.isEmptyObject( prop ),
+ optall = jQuery.speed( speed, easing, callback ),
+ doAnimation = function() {
+ // Operate on a copy of prop so per-property easing won't be lost
+ var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+ // Empty animations resolve immediately
+ if ( empty ) {
+ anim.stop( true );
+ }
+ };
+
+ return empty || optall.queue === false ?
+ this.each( doAnimation ) :
+ this.queue( optall.queue, doAnimation );
+ },
+ stop: function( type, clearQueue, gotoEnd ) {
+ var stopQueue = function( hooks ) {
+ var stop = hooks.stop;
+ delete hooks.stop;
+ stop( gotoEnd );
+ };
+
+ if ( typeof type !== "string" ) {
+ gotoEnd = clearQueue;
+ clearQueue = type;
+ type = undefined;
+ }
+ if ( clearQueue && type !== false ) {
+ this.queue( type || "fx", [] );
+ }
+
+ return this.each(function() {
+ var dequeue = true,
+ index = type != null && type + "queueHooks",
+ timers = jQuery.timers,
+ data = jQuery._data( this );
+
+ if ( index ) {
+ if ( data[ index ] && data[ index ].stop ) {
+ stopQueue( data[ index ] );
+ }
+ } else {
+ for ( index in data ) {
+ if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+ stopQueue( data[ index ] );
+ }
+ }
+ }
+
+ for ( index = timers.length; index--; ) {
+ if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
+ timers[ index ].anim.stop( gotoEnd );
+ dequeue = false;
+ timers.splice( index, 1 );
+ }
+ }
+
+ // start the next in the queue if the last step wasn't forced
+ // timers currently will call their complete callbacks, which will dequeue
+ // but only if they were gotoEnd
+ if ( dequeue || !gotoEnd ) {
+ jQuery.dequeue( this, type );
+ }
+ });
+ }
+});
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+ var which,
+ attrs = { height: type },
+ i = 0;
+
+ // if we include width, step value is 1 to do all cssExpand values,
+ // if we don't include width, step value is 2 to skip over Left and Right
+ includeWidth = includeWidth? 1 : 0;
+ for( ; i < 4 ; i += 2 - includeWidth ) {
+ which = cssExpand[ i ];
+ attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+ }
+
+ if ( includeWidth ) {
+ attrs.opacity = attrs.width = type;
+ }
+
+ return attrs;
+}
+
+// Generate shortcuts for custom animations
+jQuery.each({
+ slideDown: genFx("show"),
+ slideUp: genFx("hide"),
+ slideToggle: genFx("toggle"),
+ fadeIn: { opacity: "show" },
+ fadeOut: { opacity: "hide" },
+ fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+ jQuery.fn[ name ] = function( speed, easing, callback ) {
+ return this.animate( props, speed, easing, callback );
+ };
+});
+
+jQuery.speed = function( speed, easing, fn ) {
+ var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+ complete: fn || !fn && easing ||
+ jQuery.isFunction( speed ) && speed,
+ duration: speed,
+ easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+ };
+
+ opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
+ opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
+
+ // normalize opt.queue - true/undefined/null -> "fx"
+ if ( opt.queue == null || opt.queue === true ) {
+ opt.queue = "fx";
+ }
+
+ // Queueing
+ opt.old = opt.complete;
+
+ opt.complete = function() {
+ if ( jQuery.isFunction( opt.old ) ) {
+ opt.old.call( this );
+ }
+
+ if ( opt.queue ) {
+ jQuery.dequeue( this, opt.queue );
+ }
+ };
+
+ return opt;
+};
+
+jQuery.easing = {
+ linear: function( p ) {
+ return p;
+ },
+ swing: function( p ) {
+ return 0.5 - Math.cos( p*Math.PI ) / 2;
+ }
+};
+
+jQuery.timers = [];
+jQuery.fx = Tween.prototype.init;
+jQuery.fx.tick = function() {
+ var timer,
+ timers = jQuery.timers,
+ i = 0;
+
+ for ( ; i < timers.length; i++ ) {
+ timer = timers[ i ];
+ // Checks the timer has not already been removed
+ if ( !timer() && timers[ i ] === timer ) {
+ timers.splice( i--, 1 );
+ }
+ }
+
+ if ( !timers.length ) {
+ jQuery.fx.stop();
+ }
+};
+
+jQuery.fx.timer = function( timer ) {
+ if ( timer() && jQuery.timers.push( timer ) && !timerId ) {
+ timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
+ }
+};
+
+jQuery.fx.interval = 13;
+
+jQuery.fx.stop = function() {
+ clearInterval( timerId );
+ timerId = null;
+};
+
+jQuery.fx.speeds = {
+ slow: 600,
+ fast: 200,
+ // Default speed
+ _default: 400
+};
+
+// Back Compat <1.8 extension point
+jQuery.fx.step = {};
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+ jQuery.expr.filters.animated = function( elem ) {
+ return jQuery.grep(jQuery.timers, function( fn ) {
+ return elem === fn.elem;
+ }).length;
+ };
+}
+var rroot = /^(?:body|html)$/i;
+
+jQuery.fn.offset = function( options ) {
+ if ( arguments.length ) {
+ return options === undefined ?
+ this :
+ this.each(function( i ) {
+ jQuery.offset.setOffset( this, options, i );
+ });
+ }
+
+ var box, docElem, body, win, clientTop, clientLeft, scrollTop, scrollLeft, top, left,
+ elem = this[ 0 ],
+ doc = elem && elem.ownerDocument;
+
+ if ( !doc ) {
+ return;
+ }
+
+ if ( (body = doc.body) === elem ) {
+ return jQuery.offset.bodyOffset( elem );
+ }
+
+ docElem = doc.documentElement;
+
+ // Make sure we're not dealing with a disconnected DOM node
+ if ( !jQuery.contains( docElem, elem ) ) {
+ return { top: 0, left: 0 };
+ }
+
+ box = elem.getBoundingClientRect();
+ win = getWindow( doc );
+ clientTop = docElem.clientTop || body.clientTop || 0;
+ clientLeft = docElem.clientLeft || body.clientLeft || 0;
+ scrollTop = win.pageYOffset || docElem.scrollTop;
+ scrollLeft = win.pageXOffset || docElem.scrollLeft;
+ top = box.top + scrollTop - clientTop;
+ left = box.left + scrollLeft - clientLeft;
+
+ return { top: top, left: left };
+};
+
+jQuery.offset = {
+
+ bodyOffset: function( body ) {
+ var top = body.offsetTop,
+ left = body.offsetLeft;
+
+ if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
+ top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
+ left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
+ }
+
+ return { top: top, left: left };
+ },
+
+ setOffset: function( elem, options, i ) {
+ var position = jQuery.css( elem, "position" );
+
+ // set position first, in-case top/left are set even on static elem
+ if ( position === "static" ) {
+ elem.style.position = "relative";
+ }
+
+ var curElem = jQuery( elem ),
+ curOffset = curElem.offset(),
+ curCSSTop = jQuery.css( elem, "top" ),
+ curCSSLeft = jQuery.css( elem, "left" ),
+ calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
+ props = {}, curPosition = {}, curTop, curLeft;
+
+ // 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 ) ) {
+ options = options.call( elem, i, 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({
+
+ position: function() {
+ if ( !this[0] ) {
+ return;
+ }
+
+ var elem = this[0],
+
+ // Get *real* offsetParent
+ offsetParent = this.offsetParent(),
+
+ // Get correct offsets
+ offset = this.offset(),
+ parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
+
+ // Subtract element margins
+ // note: when an element has margin: auto the offsetLeft and marginLeft
+ // are the same in Safari causing offset.left to incorrectly be 0
+ offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
+ offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
+
+ // Add offsetParent borders
+ parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
+ parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
+
+ // Subtract the two offsets
+ return {
+ top: offset.top - parentOffset.top,
+ left: offset.left - parentOffset.left
+ };
+ },
+
+ offsetParent: function() {
+ return this.map(function() {
+ var offsetParent = this.offsetParent || document.body;
+ while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
+ offsetParent = offsetParent.offsetParent;
+ }
+ return offsetParent || document.body;
+ });
+ }
+});
+
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
+ var top = /Y/.test( prop );
+
+ jQuery.fn[ method ] = function( val ) {
+ return jQuery.access( this, function( elem, method, val ) {
+ var win = getWindow( elem );
+
+ if ( val === undefined ) {
+ return win ? (prop in win) ? win[ prop ] :
+ win.document.documentElement[ method ] :
+ elem[ method ];
+ }
+
+ if ( win ) {
+ win.scrollTo(
+ !top ? val : jQuery( win ).scrollLeft(),
+ top ? val : jQuery( win ).scrollTop()
+ );
+
+ } else {
+ elem[ method ] = val;
+ }
+ }, method, val, arguments.length, null );
+ };
+});
+
+function getWindow( elem ) {
+ return jQuery.isWindow( elem ) ?
+ elem :
+ elem.nodeType === 9 ?
+ elem.defaultView || elem.parentWindow :
+ false;
+}
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+ jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
+ // margin is only for outerHeight, outerWidth
+ jQuery.fn[ funcName ] = function( margin, value ) {
+ var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+ extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+ return jQuery.access( this, function( elem, type, value ) {
+ var doc;
+
+ if ( jQuery.isWindow( elem ) ) {
+ // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
+ // isn't a whole lot we can do. See pull request at this URL for discussion:
+ // https://github.com/jquery/jquery/pull/764
+ return elem.document.documentElement[ "client" + name ];
+ }
+
+ // Get document width or height
+ if ( elem.nodeType === 9 ) {
+ doc = elem.documentElement;
+
+ // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
+ // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
+ return Math.max(
+ elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+ elem.body[ "offset" + name ], doc[ "offset" + name ],
+ doc[ "client" + name ]
+ );
+ }
+
+ return value === undefined ?
+ // Get width or height on the element, requesting but not forcing parseFloat
+ jQuery.css( elem, type, value, extra ) :
+
+ // Set width or height on the element
+ jQuery.style( elem, type, value, extra );
+ }, type, chainable ? margin : undefined, chainable, null );
+ };
+ });
+});
+// Expose jQuery to the global object
+window.jQuery = window.$ = jQuery;
+
+// Expose jQuery as an AMD module, but only for AMD loaders that
+// understand the issues with loading multiple versions of jQuery
+// in a page that all might call define(). The loader will indicate
+// they have special allowances for multiple jQuery versions by
+// specifying define.amd.jQuery = true. Register as a named module,
+// since jQuery can be concatenated with other files that may use define,
+// but not use a proper concatenation script that understands anonymous
+// AMD modules. A named AMD is safest and most robust way to register.
+// Lowercase jquery is used because AMD module names are derived from
+// file names, and jQuery is normally delivered in a lowercase file name.
+// Do this after creating the global so that if an AMD module wants to call
+// noConflict to hide this version of jQuery, it will work.
+if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
+ define( "jquery", [], function () { return jQuery; } );
+}
+
+})( window );
+
+// keymaster.js
+// (c) 2011 Thomas Fuchs
+// keymaster.js may be freely distributed under the MIT license.
+
+;(function(global){
+ var k,
+ _handlers = {},
+ _mods = { 16: false, 18: false, 17: false, 91: false },
+ _scope = 'all',
+ // modifier keys
+ _MODIFIERS = {
+ '⇧': 16, shift: 16,
+ '⌥': 18, alt: 18, option: 18,
+ '⌃': 17, ctrl: 17, control: 17,
+ '⌘': 91, command: 91
+ },
+ // special keys
+ _MAP = {
+ backspace: 8, tab: 9, clear: 12,
+ enter: 13, 'return': 13,
+ esc: 27, escape: 27, space: 32,
+ left: 37, up: 38,
+ right: 39, down: 40,
+ del: 46, 'delete': 46,
+ home: 36, end: 35,
+ pageup: 33, pagedown: 34,
+ ',': 188, '.': 190, '/': 191,
+ '`': 192, '-': 189, '=': 187,
+ ';': 186, '\'': 222,
+ '[': 219, ']': 221, '\\': 220
+ };
+
+ for(k=1;k<20;k++) _MODIFIERS['f'+k] = 111+k;
+
+ // IE doesn't support Array#indexOf, so have a simple replacement
+ function index(array, item){
+ var i = array.length;
+ while(i--) if(array[i]===item) return i;
+ return -1;
+ }
+
+ // handle keydown event
+ function dispatch(event, scope){
+ var key, handler, k, i, modifiersMatch;
+ key = event.keyCode;
+
+ // if a modifier key, set the key.
property to true and return
+ if(key == 93 || key == 224) key = 91; // right command on webkit, command on Gecko
+ if(key in _mods) {
+ _mods[key] = true;
+ // 'assignKey' from inside this closure is exported to window.key
+ for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = true;
+ return;
+ }
+
+ // see if we need to ignore the keypress (ftiler() can can be overridden)
+ // by default ignore key presses if a select, textarea, or input is focused
+ if(!assignKey.filter.call(this, event)) return;
+
+ // abort if no potentially matching shortcuts found
+ if (!(key in _handlers)) return;
+
+ // for each potential shortcut
+ for (i = 0; i < _handlers[key].length; i++) {
+ handler = _handlers[key][i];
+
+ // see if it's in the current scope
+ if(handler.scope == scope || handler.scope == 'all'){
+ // check if modifiers match if any
+ modifiersMatch = handler.mods.length > 0;
+ for(k in _mods)
+ if((!_mods[k] && index(handler.mods, +k) > -1) ||
+ (_mods[k] && index(handler.mods, +k) == -1)) modifiersMatch = false;
+ // call the handler and stop the event if neccessary
+ if((handler.mods.length == 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91]) || modifiersMatch){
+ if(handler.method(event, handler)===false){
+ if(event.preventDefault) event.preventDefault();
+ else event.returnValue = false;
+ if(event.stopPropagation) event.stopPropagation();
+ if(event.cancelBubble) event.cancelBubble = true;
+ }
+ }
+ }
+ }
+ };
+
+ // unset modifier keys on keyup
+ function clearModifier(event){
+ var key = event.keyCode, k;
+ if(key == 93 || key == 224) key = 91;
+ if(key in _mods) {
+ _mods[key] = false;
+ for(k in _MODIFIERS) if(_MODIFIERS[k] == key) assignKey[k] = false;
+ }
+ };
+
+ function resetModifiers() {
+ for(k in _mods) _mods[k] = false;
+ for(k in _MODIFIERS) assignKey[k] = false;
+ }
+
+ // parse and assign shortcut
+ function assignKey(key, scope, method){
+ var keys, mods, i, mi;
+ if (method === undefined) {
+ method = scope;
+ scope = 'all';
+ }
+ key = key.replace(/\s/g,'');
+ keys = key.split(',');
+
+ if((keys[keys.length-1])=='')
+ keys[keys.length-2] += ',';
+ // for each shortcut
+ for (i = 0; i < keys.length; i++) {
+ // set modifier keys if any
+ mods = [];
+ key = keys[i].split('+');
+ if(key.length > 1){
+ mods = key.slice(0,key.length-1);
+ for (mi = 0; mi < mods.length; mi++)
+ mods[mi] = _MODIFIERS[mods[mi]];
+ key = [key[key.length-1]];
+ }
+ // convert to keycode and...
+ key = key[0]
+ key = _MAP[key] || key.toUpperCase().charCodeAt(0);
+ // ...store handler
+ if (!(key in _handlers)) _handlers[key] = [];
+ _handlers[key].push({ shortcut: keys[i], scope: scope, method: method, key: keys[i], mods: mods });
+ }
+ };
+
+ function filter(event){
+ var tagName = (event.target || event.srcElement).tagName;
+ // ignore keypressed in any elements that support keyboard data input
+ return !(tagName == 'INPUT' || tagName == 'SELECT' || tagName == 'TEXTAREA');
+ }
+
+ // initialize key. to false
+ for(k in _MODIFIERS) assignKey[k] = false;
+
+ // set current scope (default 'all')
+ function setScope(scope){ _scope = scope || 'all' };
+ function getScope(){ return _scope || 'all' };
+
+ // delete all handlers for a given scope
+ function deleteScope(scope){
+ var key, handlers, i;
+
+ for (key in _handlers) {
+ handlers = _handlers[key];
+ for (i = 0; i < handlers.length; ) {
+ if (handlers[i].scope === scope) handlers.splice(i, 1);
+ else i++;
+ }
+ }
+ };
+
+ // cross-browser events
+ function addEvent(object, event, method) {
+ if (object.addEventListener)
+ object.addEventListener(event, method, false);
+ else if(object.attachEvent)
+ object.attachEvent('on'+event, function(){ method(window.event) });
+ };
+
+ // set the handlers globally on document
+ addEvent(document, 'keydown', function(event) { dispatch(event, _scope) }); // Passing _scope to a callback to ensure it remains the same by execution. Fixes #48
+ addEvent(document, 'keyup', clearModifier);
+
+ // reset modifiers to false whenever the window is (re)focused.
+ addEvent(window, 'focus', resetModifiers);
+
+ // set window.key and window.key.set/get/deleteScope, and the default filter
+ global.key = assignKey;
+ global.key.setScope = setScope;
+ global.key.getScope = getScope;
+ global.key.deleteScope = deleteScope;
+ global.key.filter = filter;
+
+ if(typeof module !== 'undefined') module.exports = key;
+
+})(this);
+
+// Underscore.js 1.3.3
+// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `global` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Establish the object that gets returned to break out of a loop iteration.
+ var breaker = {};
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var slice = ArrayProto.slice,
+ unshift = ArrayProto.unshift,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeForEach = ArrayProto.forEach,
+ nativeMap = ArrayProto.map,
+ nativeReduce = ArrayProto.reduce,
+ nativeReduceRight = ArrayProto.reduceRight,
+ nativeFilter = ArrayProto.filter,
+ nativeEvery = ArrayProto.every,
+ nativeSome = ArrayProto.some,
+ nativeIndexOf = ArrayProto.indexOf,
+ nativeLastIndexOf = ArrayProto.lastIndexOf,
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) { return new wrapper(obj); };
+
+ // Export the Underscore object for **Node.js**, with
+ // backwards-compatibility for the old `require()` API. If we're in
+ // the browser, add `_` as a global object via a string identifier,
+ // for Closure Compiler "advanced" mode.
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports) {
+ exports = module.exports = _;
+ }
+ exports._ = _;
+ } else {
+ root['_'] = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.3.3';
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles objects with the built-in `forEach`, arrays, and raw objects.
+ // Delegates to **ECMAScript 5**'s native `forEach` if available.
+ var each = _.each = _.forEach = function(obj, iterator, context) {
+ if (obj == null) return;
+ if (nativeForEach && obj.forEach === nativeForEach) {
+ obj.forEach(iterator, context);
+ } else if (obj.length === +obj.length) {
+ for (var i = 0, l = obj.length; i < l; i++) {
+ if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ for (var key in obj) {
+ if (_.has(obj, key)) {
+ if (iterator.call(context, obj[key], key, obj) === breaker) return;
+ }
+ }
+ }
+ };
+
+ // Return the results of applying the iterator to each element.
+ // Delegates to **ECMAScript 5**'s native `map` if available.
+ _.map = _.collect = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+ each(obj, function(value, index, list) {
+ results[results.length] = iterator.call(context, value, index, list);
+ });
+ if (obj.length === +obj.length) results.length = obj.length;
+ return results;
+ };
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+ _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduce && obj.reduce === nativeReduce) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+ }
+ each(obj, function(value, index, list) {
+ if (!initial) {
+ memo = value;
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, value, index, list);
+ }
+ });
+ if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+ _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+ var initial = arguments.length > 2;
+ if (obj == null) obj = [];
+ if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+ }
+ var reversed = _.toArray(obj).reverse();
+ if (context && !initial) iterator = _.bind(iterator, context);
+ return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, iterator, context) {
+ var result;
+ any(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Delegates to **ECMAScript 5**'s native `filter` if available.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+ each(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ each(obj, function(value, index, list) {
+ if (!iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Delegates to **ECMAScript 5**'s native `every` if available.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, iterator, context) {
+ var result = true;
+ if (obj == null) return result;
+ if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+ each(obj, function(value, index, list) {
+ if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Delegates to **ECMAScript 5**'s native `some` if available.
+ // Aliased as `any`.
+ var any = _.some = _.any = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = false;
+ if (obj == null) return result;
+ if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+ each(obj, function(value, index, list) {
+ if (result || (result = iterator.call(context, value, index, list))) return breaker;
+ });
+ return !!result;
+ };
+
+ // Determine if a given value is included in the array or object using `===`.
+ // Aliased as `contains`.
+ _.include = _.contains = function(obj, target) {
+ var found = false;
+ if (obj == null) return found;
+ if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+ found = any(obj, function(value) {
+ return value === target;
+ });
+ return found;
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ return _.map(obj, function(value) {
+ return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, function(value){ return value[key]; });
+ };
+
+ // Return the maximum element or (element-based computation).
+ _.max = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.max.apply(Math, obj);
+ if (!iterator && _.isEmpty(obj)) return -Infinity;
+ var result = {computed : -Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed >= result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj) && obj[0] === +obj[0]) return Math.min.apply(Math, obj);
+ if (!iterator && _.isEmpty(obj)) return Infinity;
+ var result = {computed : Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed < result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Shuffle an array.
+ _.shuffle = function(obj) {
+ var shuffled = [], rand;
+ each(obj, function(value, index, list) {
+ rand = Math.floor(Math.random() * (index + 1));
+ shuffled[index] = shuffled[rand];
+ shuffled[rand] = value;
+ });
+ return shuffled;
+ };
+
+ // Sort the object's values by a criterion produced by an iterator.
+ _.sortBy = function(obj, val, context) {
+ var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value : value,
+ criteria : iterator.call(context, value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria, b = right.criteria;
+ if (a === void 0) return 1;
+ if (b === void 0) return -1;
+ return a < b ? -1 : a > b ? 1 : 0;
+ }), 'value');
+ };
+
+ // Groups the object's values by a criterion. Pass either a string attribute
+ // to group by, or a function that returns the criterion.
+ _.groupBy = function(obj, val) {
+ var result = {};
+ var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+ each(obj, function(value, index) {
+ var key = iterator(value, index);
+ (result[key] || (result[key] = [])).push(value);
+ });
+ return result;
+ };
+
+ // Use a comparator function to figure out at what index an object should
+ // be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iterator) {
+ iterator || (iterator = _.identity);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = (low + high) >> 1;
+ iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
+ }
+ return low;
+ };
+
+ // Safely convert anything iterable into a real, live array.
+ _.toArray = function(obj) {
+ if (!obj) return [];
+ if (_.isArray(obj)) return slice.call(obj);
+ if (_.isArguments(obj)) return slice.call(obj);
+ if (obj.toArray && _.isFunction(obj.toArray)) return obj.toArray();
+ return _.values(obj);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ return _.isArray(obj) ? obj.length : _.keys(obj).length;
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head` and `take`. The **guard** check
+ // allows it to work with `_.map`.
+ _.first = _.head = _.take = function(array, n, guard) {
+ return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+ };
+
+ // Returns everything but the last entry of the array. Especcialy useful on
+ // the arguments object. Passing **n** will return all the values in
+ // the array, excluding the last N. The **guard** check allows it to work with
+ // `_.map`.
+ _.initial = function(array, n, guard) {
+ return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+ };
+
+ // Get the last element of an array. Passing **n** will return the last N
+ // values in the array. The **guard** check allows it to work with `_.map`.
+ _.last = function(array, n, guard) {
+ if ((n != null) && !guard) {
+ return slice.call(array, Math.max(array.length - n, 0));
+ } else {
+ return array[array.length - 1];
+ }
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail`.
+ // Especially useful on the arguments object. Passing an **index** will return
+ // the rest of the values in the array from that index onward. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = function(array, index, guard) {
+ return slice.call(array, (index == null) || guard ? 1 : index);
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, function(value){ return !!value; });
+ };
+
+ // Return a completely flattened version of an array.
+ _.flatten = function(array, shallow) {
+ return _.reduce(array, function(memo, value) {
+ if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
+ memo[memo.length] = value;
+ return memo;
+ }, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ return _.difference(array, slice.call(arguments, 1));
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted, iterator) {
+ var initial = iterator ? _.map(array, iterator) : array;
+ var results = [];
+ // The `isSorted` flag is irrelevant if the array only contains two elements.
+ if (array.length < 3) isSorted = true;
+ _.reduce(initial, function (memo, value, index) {
+ if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
+ memo.push(value);
+ results.push(array[index]);
+ }
+ return memo;
+ }, []);
+ return results;
+ };
+
+ // Produce an array that contains the union: each distinct element from all of
+ // the passed-in arrays.
+ _.union = function() {
+ return _.uniq(_.flatten(arguments, true));
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays. (Aliased as "intersect" for back-compat.)
+ _.intersection = _.intersect = function(array) {
+ var rest = slice.call(arguments, 1);
+ return _.filter(_.uniq(array), function(item) {
+ return _.every(rest, function(other) {
+ return _.indexOf(other, item) >= 0;
+ });
+ });
+ };
+
+ // Take the difference between one array and a number of other arrays.
+ // Only the elements present in just the first array will remain.
+ _.difference = function(array) {
+ var rest = _.flatten(slice.call(arguments, 1), true);
+ return _.filter(array, function(value){ return !_.include(rest, value); });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function() {
+ var args = slice.call(arguments);
+ var length = _.max(_.pluck(args, 'length'));
+ var results = new Array(length);
+ for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
+ return results;
+ };
+
+ // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+ // we need this function. Return the position of the first occurrence of an
+ // item in an array, or -1 if the item is not included in the array.
+ // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i, l;
+ if (isSorted) {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
+ for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
+ return -1;
+ };
+
+ // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+ _.lastIndexOf = function(array, item) {
+ if (array == null) return -1;
+ if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
+ var i = array.length;
+ while (i--) if (i in array && array[i] === item) return i;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = arguments[2] || 1;
+
+ var len = Math.max(Math.ceil((stop - start) / step), 0);
+ var idx = 0;
+ var range = new Array(len);
+
+ while(idx < len) {
+ range[idx++] = start;
+ start += step;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Reusable constructor function for prototype setting.
+ var ctor = function(){};
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Binding with arguments is also known as `curry`.
+ // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
+ // We check for `func.bind` first, to fail fast when `func` is undefined.
+ _.bind = function bind(func, context) {
+ var bound, args;
+ if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ if (!_.isFunction(func)) throw new TypeError;
+ args = slice.call(arguments, 2);
+ return bound = function() {
+ if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
+ ctor.prototype = func.prototype;
+ var self = new ctor;
+ var result = func.apply(self, args.concat(slice.call(arguments)));
+ if (Object(result) === result) return result;
+ return self;
+ };
+ };
+
+ // Bind all of an object's methods to that object. Useful for ensuring that
+ // all callbacks defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var funcs = slice.call(arguments, 1);
+ if (funcs.length == 0) funcs = _.functions(obj);
+ each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memo = {};
+ hasher || (hasher = _.identity);
+ return function() {
+ var key = hasher.apply(this, arguments);
+ return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+ };
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){ return func.apply(null, args); }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time.
+ _.throttle = function(func, wait) {
+ var context, args, timeout, throttling, more, result;
+ var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
+ return function() {
+ context = this; args = arguments;
+ var later = function() {
+ timeout = null;
+ if (more) func.apply(context, args);
+ whenDone();
+ };
+ if (!timeout) timeout = setTimeout(later, wait);
+ if (throttling) {
+ more = true;
+ } else {
+ result = func.apply(context, args);
+ }
+ whenDone();
+ throttling = true;
+ return result;
+ };
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds. If `immediate` is passed, trigger the function on the
+ // leading edge, instead of the trailing.
+ _.debounce = function(func, wait, immediate) {
+ var timeout;
+ return function() {
+ var context = this, args = arguments;
+ var later = function() {
+ timeout = null;
+ if (!immediate) func.apply(context, args);
+ };
+ if (immediate && !timeout) func.apply(context, args);
+ clearTimeout(timeout);
+ timeout = setTimeout(later, wait);
+ };
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = function(func) {
+ var ran = false, memo;
+ return function() {
+ if (ran) return memo;
+ ran = true;
+ return memo = func.apply(this, arguments);
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return function() {
+ var args = [func].concat(slice.call(arguments, 0));
+ return wrapper.apply(this, args);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var funcs = arguments;
+ return function() {
+ var args = arguments;
+ for (var i = funcs.length - 1; i >= 0; i--) {
+ args = [funcs[i].apply(this, args)];
+ }
+ return args[0];
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ if (times <= 0) return func();
+ return function() {
+ if (--times < 1) { return func.apply(this, arguments); }
+ };
+ };
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = nativeKeys || function(obj) {
+ if (obj !== Object(obj)) throw new TypeError('Invalid object');
+ var keys = [];
+ for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ return _.map(obj, _.identity);
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ var names = [];
+ for (var key in obj) {
+ if (_.isFunction(obj[key])) names.push(key);
+ }
+ return names.sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Return a copy of the object only containing the whitelisted properties.
+ _.pick = function(obj) {
+ var result = {};
+ each(_.flatten(slice.call(arguments, 1)), function(key) {
+ if (key in obj) result[key] = obj[key];
+ });
+ return result;
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ if (obj[prop] == null) obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ if (!_.isObject(obj)) return obj;
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Internal recursive comparison function.
+ function eq(a, b, stack) {
+ // Identical objects are equal. `0 === -0`, but they aren't identical.
+ // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
+ if (a === b) return a !== 0 || 1 / a == 1 / b;
+ // A strict comparison is necessary because `null == undefined`.
+ if (a == null || b == null) return a === b;
+ // Unwrap any wrapped objects.
+ if (a._chain) a = a._wrapped;
+ if (b._chain) b = b._wrapped;
+ // Invoke a custom `isEqual` method if one is provided.
+ if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
+ if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
+ // Compare `[[Class]]` names.
+ var className = toString.call(a);
+ if (className != toString.call(b)) return false;
+ switch (className) {
+ // Strings, numbers, dates, and booleans are compared by value.
+ case '[object String]':
+ // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+ // equivalent to `new String("5")`.
+ return a == String(b);
+ case '[object Number]':
+ // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+ // other numeric values.
+ return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+ case '[object Date]':
+ case '[object Boolean]':
+ // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+ // millisecond representations. Note that invalid dates with millisecond representations
+ // of `NaN` are not equivalent.
+ return +a == +b;
+ // RegExps are compared by their source patterns and flags.
+ case '[object RegExp]':
+ return a.source == b.source &&
+ a.global == b.global &&
+ a.multiline == b.multiline &&
+ a.ignoreCase == b.ignoreCase;
+ }
+ if (typeof a != 'object' || typeof b != 'object') return false;
+ // Assume equality for cyclic structures. The algorithm for detecting cyclic
+ // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+ var length = stack.length;
+ while (length--) {
+ // Linear search. Performance is inversely proportional to the number of
+ // unique nested structures.
+ if (stack[length] == a) return true;
+ }
+ // Add the first object to the stack of traversed objects.
+ stack.push(a);
+ var size = 0, result = true;
+ // Recursively compare objects and arrays.
+ if (className == '[object Array]') {
+ // Compare array lengths to determine if a deep comparison is necessary.
+ size = a.length;
+ result = size == b.length;
+ if (result) {
+ // Deep compare the contents, ignoring non-numeric properties.
+ while (size--) {
+ // Ensure commutative equality for sparse arrays.
+ if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
+ }
+ }
+ } else {
+ // Objects with different constructors are not equivalent.
+ if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
+ // Deep compare objects.
+ for (var key in a) {
+ if (_.has(a, key)) {
+ // Count the expected number of properties.
+ size++;
+ // Deep compare each member.
+ if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
+ }
+ }
+ // Ensure that both objects contain the same number of properties.
+ if (result) {
+ for (key in b) {
+ if (_.has(b, key) && !(size--)) break;
+ }
+ result = !size;
+ }
+ }
+ // Remove the first object from the stack of traversed objects.
+ stack.pop();
+ return result;
+ }
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ return eq(a, b, []);
+ };
+
+ // Is a given array, string, or object empty?
+ // An "empty" object has no enumerable own-properties.
+ _.isEmpty = function(obj) {
+ if (obj == null) return true;
+ if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+ for (var key in obj) if (_.has(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType == 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) == '[object Array]';
+ };
+
+ // Is a given variable an object?
+ _.isObject = function(obj) {
+ return obj === Object(obj);
+ };
+
+ // Is a given variable an arguments object?
+ _.isArguments = function(obj) {
+ return toString.call(obj) == '[object Arguments]';
+ };
+ if (!_.isArguments(arguments)) {
+ _.isArguments = function(obj) {
+ return !!(obj && _.has(obj, 'callee'));
+ };
+ }
+
+ // Is a given value a function?
+ _.isFunction = function(obj) {
+ return toString.call(obj) == '[object Function]';
+ };
+
+ // Is a given value a string?
+ _.isString = function(obj) {
+ return toString.call(obj) == '[object String]';
+ };
+
+ // Is a given value a number?
+ _.isNumber = function(obj) {
+ return toString.call(obj) == '[object Number]';
+ };
+
+ // Is a given object a finite number?
+ _.isFinite = function(obj) {
+ return _.isNumber(obj) && isFinite(obj);
+ };
+
+ // Is the given value `NaN`?
+ _.isNaN = function(obj) {
+ // `NaN` is the only value for which `===` is not reflexive.
+ return obj !== obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+ };
+
+ // Is a given value a date?
+ _.isDate = function(obj) {
+ return toString.call(obj) == '[object Date]';
+ };
+
+ // Is the given value a regular expression?
+ _.isRegExp = function(obj) {
+ return toString.call(obj) == '[object RegExp]';
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Has own property?
+ _.has = function(obj, key) {
+ return hasOwnProperty.call(obj, key);
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iterators.
+ _.identity = function(value) {
+ return value;
+ };
+
+ // Run a function **n** times.
+ _.times = function (n, iterator, context) {
+ for (var i = 0; i < n; i++) iterator.call(context, i);
+ };
+
+ // Escape a string for HTML interpolation.
+ _.escape = function(string) {
+ return (''+string).replace(/&/g, '&').replace(//g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g,'/');
+ };
+
+ // If the value of the named property is a function then invoke it;
+ // otherwise, return it.
+ _.result = function(object, property) {
+ if (object == null) return null;
+ var value = object[property];
+ return _.isFunction(value) ? value.call(object) : value;
+ };
+
+ // Add your own custom functions to the Underscore object, ensuring that
+ // they're correctly added to the OOP wrapper as well.
+ _.mixin = function(obj) {
+ each(_.functions(obj), function(name){
+ addToWrapper(name, _[name] = obj[name]);
+ });
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = idCounter++;
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g,
+ escape : /<%-([\s\S]+?)%>/g
+ };
+
+ // When customizing `templateSettings`, if you don't want to define an
+ // interpolation, evaluation or escaping regex, we need one that is
+ // guaranteed not to match.
+ var noMatch = /.^/;
+
+ // Certain characters need to be escaped so that they can be put into a
+ // string literal.
+ var escapes = {
+ '\\': '\\',
+ "'": "'",
+ 'r': '\r',
+ 'n': '\n',
+ 't': '\t',
+ 'u2028': '\u2028',
+ 'u2029': '\u2029'
+ };
+
+ for (var p in escapes) escapes[escapes[p]] = p;
+ var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+ var unescaper = /\\(\\|'|r|n|t|u2028|u2029)/g;
+
+ // Within an interpolation, evaluation, or escaping, remove HTML escaping
+ // that had been previously added.
+ var unescape = function(code) {
+ return code.replace(unescaper, function(match, escape) {
+ return escapes[escape];
+ });
+ };
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ _.template = function(text, data, settings) {
+ settings = _.defaults(settings || {}, _.templateSettings);
+
+ // Compile the template source, taking care to escape characters that
+ // cannot be included in a string literal and then unescape them in code
+ // blocks.
+ var source = "__p+='" + text
+ .replace(escaper, function(match) {
+ return '\\' + escapes[match];
+ })
+ .replace(settings.escape || noMatch, function(match, code) {
+ return "'+\n_.escape(" + unescape(code) + ")+\n'";
+ })
+ .replace(settings.interpolate || noMatch, function(match, code) {
+ return "'+\n(" + unescape(code) + ")+\n'";
+ })
+ .replace(settings.evaluate || noMatch, function(match, code) {
+ return "';\n" + unescape(code) + "\n;__p+='";
+ }) + "';\n";
+
+ // If a variable is not specified, place data values in local scope.
+ if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+ source = "var __p='';" +
+ "var print=function(){__p+=Array.prototype.join.call(arguments, '')};\n" +
+ source + "return __p;\n";
+
+ var render = new Function(settings.variable || 'obj', '_', source);
+ if (data) return render(data, _);
+ var template = function(data) {
+ return render.call(this, data, _);
+ };
+
+ // Provide the compiled function source as a convenience for build time
+ // precompilation.
+ template.source = 'function(' + (settings.variable || 'obj') + '){\n' +
+ source + '}';
+
+ return template;
+ };
+
+ // Add a "chain" function, which will delegate to the wrapper.
+ _.chain = function(obj) {
+ return _(obj).chain();
+ };
+
+ // The OOP Wrapper
+ // ---------------
+
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+ var wrapper = function(obj) { this._wrapped = obj; };
+
+ // Expose `wrapper.prototype` as `_.prototype`
+ _.prototype = wrapper.prototype;
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj, chain) {
+ return chain ? _(obj).chain() : obj;
+ };
+
+ // A method to easily add functions to the OOP wrapper.
+ var addToWrapper = function(name, func) {
+ wrapper.prototype[name] = function() {
+ var args = slice.call(arguments);
+ unshift.call(args, this._wrapped);
+ return result(func.apply(_, args), this._chain);
+ };
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ var wrapped = this._wrapped;
+ method.apply(wrapped, arguments);
+ var length = wrapped.length;
+ if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
+ return result(wrapped, this._chain);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ return result(method.apply(this._wrapped, arguments), this._chain);
+ };
+ });
+
+ // Start chaining a wrapped Underscore object.
+ wrapper.prototype.chain = function() {
+ this._chain = true;
+ return this;
+ };
+
+ // Extracts the result from a wrapped and chained object.
+ wrapper.prototype.value = function() {
+ return this._wrapped;
+ };
+
+}).call(this);
+
+(function() {
+ $(function() {
+ $('pre code').each(function(i, e) {
+ return hljs.highlightBlock(e, ' ');
+ });
+ return $('#content a').each(function() {
+ if (/^https?:\/\//i.test($(this).attr('href'))) {
+ return $(this).attr('target', '_top');
+ }
+ });
+ });
+
+}).call(this);
+(function() {
+ $(function() {
+ window.createStripes = function() {
+ return $('#content.list li:visible').each(function(i, el) {
+ if (i % 2 === 0) {
+ return $(el).addClass('stripe');
+ } else {
+ return $(el).removeClass('stripe');
+ }
+ });
+ };
+ window.indentTree = function(el, width) {
+ return $(el).find('> ul').each(function() {
+ $(this).find('> li').css('padding-left', "" + width + "px");
+ return window.indentTree($(this), width + 20);
+ });
+ };
+ $('#content.tree ul > ul').each(function() {
+ return $(this).prev().prepend($('" + (heading.text()) + " ',
+ post: ' ',
+ limit: 25
+ });
+ for (index = _i = 0, _len = matches.length; _i < _len; index = ++_i) {
+ match = matches[index];
+ data = _.find(searchData, function(d) {
+ return d.t === match;
+ });
+ resultList.append($("" + highlights[index] + " " + (data.h ? "(" + data.h + ") " : '') + "scroll-proxy's Documentation
+
+
+ scroll-proxy's Documentation
+
+
+ scroll-proxy by mkautzmann
+
+
+
+
+This package is designed to help dealing with the scroll event in the browser in the smoothest way possible.
+
+Yes, web browsers already deliver ways to listen for the scroll event and they work really well. What scroll-proxy does is proxy the calls from you to the native scroll event and the other way around, doing some transformations in the process.
+
+It applies some techniques already frequently used by web developers such as function throttling , animation toggling and a few others on scroll -related events. Delivering a small library one can just download and use.
+
+The project's main focus is to help developers achieve great scroll performance in their apps while still being able to implement stuff like scroll-based animations , sticky headers and infinite scrolling .
+
+In fact, the sticky header on this page is made in a few lines of code using scroll-proxy. Check your inspector!
+
+
+
+
+The installation process is pretty straight-forward.
+
+You can get it on npm:
+
+npm install scroll-proxy --save
+
+Or bower:
+
+bower install scroll-proxy --save
+
+If you are not into package management there is also the option of direct download , after unzipping the JS file will be in the dist folder.
+
+Don't want to download at all? No problem. Just get it from one of the CDN providers .
+
+
+
+
+
+
+
+One of the biggest concerns when developing scroll-proxy is its interoperability with other libs and frameworks.
+
+So we decided not to change the native scroll handling. Instead, we create a wrapper that can handle everything the native can do and more.
+
+This way we avoid breaking any other lib that may rely on the native scroll event.
+
+The coolest part of the lib is the event handling, you can attach as many events you like but it will only attach one listener to the native scroll event in the browser. This practice is often called event delegation .
+
+Please setup the lib and check for yourself.
+
+
+
+
+Setting up the library is simple and easy.
+
+Once you've installed it and properly added it to your document via a script tag you just have to instantiate a new ScrollProxy object.
+
+var myScroll = new ScrollProxy ();You just did it!
+
+Notice that you didn't pass any arguments to the ScrollProxy constructor. By default, ScrollProxy will always attach to document.body. It means it will report actions when the user scrolls the page .
+
+If you want to get updates when the user scrolls inside some specific HTMLElement you must pass it to the constructor:
+
+var myDiv = document .querySelector(' .scrollable' var myDivScroll = new ScrollProxy (myDiv);
+
+
+The CommonJS module version needs you to require ScrollProxy before using it like above.
+
+var ScrollProxy = require (" scroll-proxy"
+
+
+OK, ScrollProxy's set up. Now let's make some cool stuff.
+
+The first thing you might want to do is to get updates whenever the user scrolls the page.
+
+Usually, using just browsers APIs and vanilla JS, you could do that like this:
+
+window .addEventListener(' scroll' function () {
+ console .log (" YAY, I'm scrolling!" false );And that would work great.
+
+But note that it bombs your console with a lot of logs. That's because each movement on the scroll area causes one scroll event to fire.
+
+That could be fine for logging as it's pretty fast but imagine doing complex calculations or animating stuff based on scroll position. That would be really slow and certainly laggy.
+
+
+scroll-proxy to the rescue!
+
+In scroll-proxy registering an event is as easy as calling the on function passing the name of the event and the callback function.
+
+var s = new ScrollProxy () // It defaults to document.body, just as we want it
+s.on(' scroll' function () {
+ console .log (" YAY, I'm scrolling!" Now your scroll event belongs to ScrollProxy, it will automatically throttle the event calls with a 250ms delay by default.
+
+That's great for most use cases but you can actually change it on the fly! Take a look:
+
+
+
+Now subsequent events are respecting a 100ms delay. Easy, huh?
+
+You could also just opt to get just a ping when the scroll event happened instead of keep monitoring, the function you are looking for is once. It is like on but, as the name implies, only fires once.
+
+s.once(' scroll' function () {
+ console .log (" I have just scrolled" Take your time to compare both vanilla and ScrollProxy implementations and see the difference. It certainly helps tame the frenzy scroll event calls.
+
+Fell free to the behavior using your browser inspector right here in this page. We already have a ScrollProxy instance setup in window.myScroll.
+
+
+
+
+Registering the scroll event is not the only thing ScrollProxy can do, actually it has a bunch of other cool events you can listen with the built in on and once functions.
+
+The full list of events you can rely on:
+
+
+scrolloffsetXoffsetYtopbottomleftrightvisibleinvisible
+
+
+
+
+Some events accept a third argument in the on and once functions. The presence of this third argument and it's value modify the event handling.
+
+The offset events
+
+Offset events are great when you want to check scroll in a specific direction, the next example shows that in a simple way. The circle starts in red and changes to green if you scroll vertically and blue if you scroll horizontally
+
+Try it out! Scroll the area below.
+
+
+
+Code:
+
+var s = new ScrollProxy (document .getElementById (' offset-example1' ' offsetX' function (){
+ changeColor(' blue' ' offsetY' function (){
+ changeColor(' green' The offsetX and offsetY accept a third argument indicating a offset for scroll-proxy it to consider when firing the event. Take a look as the red bar becomes green when it fills the entire scroll area.
+
+
+
+That happened because we are passing the third argument with value 300, so ScrollProxy will emit the offset event when scroll past 300 pixels.
+
+Code:
+
+var s = new ScrollProxy (document .getElementById (' offset-example2' ' offsetY' function (){
+ changeColor(' green' 300 );Note the presence of the optional third argument on the second example. It indicates an offset to respect. The same logic applies to the offsetX event as well.
+
+The top, bottom, left and right events
+
+These kind of events are usually used to determine if the user reached some of the borders of the scroll area. The third argument is useful here when you want to tell scroll-proxy to fire the event earlier than normal.
+
+Let's say you want to implement infinite scrolling. You could just load new stuff when the user reaches the bottom of the scroll area, right? Yes, this would work, but wouldn't it be nicer if you could actually load the content before the user notices any loading?
+
+For these types of use case the third argument comes handy.
+
+Sometimes you want to actually get notified when the scroll area reaches the bottom.
+
+See the text color turn green when you reach the bottom of the scroll area below in the next example:
+
+
+
+Code:
+
+var s = new ScrollProxy (document .getElementById (' bound-example1' ' bottom' function (){
+ changeColor(' green' And on other times you may want to get notified earlier. You can do that by passing the third argument.
+
+The next example looks like the previous one but this time the text turns yellow when approaching the end. Then, when finally hitting it, it turns green:
+
+
+
+Code:
+
+var s = new ScrollProxy (document .getElementById (' bound-example2' ' bottom' function (){
+ changeColor(' yellow' 250 );
+s.once(' bottom' function (){
+ changeColor(' green' The visible and invisible events
+
+These are very special events that have limited use cases but sometimes are very welcome.
+
+Both events will only work if the third argument is given. Yes, the third argument is not optional when using either visible or invisible events.
+
+That's because the events need to check if the element passed in the third argument is visible in the scroll area.
+
+There's another catch: the element to be checked must be a direct child of the scroll area scroll-proxy is attached to.
+
+Example of detecting changes in objects visibility:
+
+
+
#visibility-example
+
+
+
+
Code:
+
+var s = new ScrollProxy (document .getElementById (' visibility-example' ' visible' function (){
+ report(' SQUARE VISIBLE :-)' ' invisible' function (){
+ report(' SQUARE NOT VISIBLE :-('
+
+
+scroll-proxy also delivers current information about the scroll area.
+
+You can fetch info about the x and positions, the width and height of the scroll element and also the width and height of the scroll area.
+
+// Consider a window of 800x600 with a 2000x2000 div inside
+var s = new ScrollProxy ();
+console .log (s.x ); // Will log 0
+console .log (s.y ); // Will log 0
+console .log (s.width ); // Will log 800
+console .log (s.height ); // Will log 600
+console .log (s.scrollWidth); // Will log 2000
+console .log (s.scrollHeight); // Will log 2000 All the info you see above is updated realtime if you registered at least one event with on. In fact if you want to use these kind of info inside the event callback you could do like this:
+
+Example:
+
+
+
#metadata-example
+
+
+ Output Log:
+
+
Code:
+
+var s = new ScrollProxy (document .getElementById (' metadata-example' ' scroll' function (){
+ var output = ' X: ' + this .x + ' <br>' += ' Y: ' + this .y + ' <br>' += ' Element Width: ' + this .width + ' <br>' += ' Element Height: ' + this .height + ' <br>' += ' Scroll Width: ' + this .scrollWidth + ' <br>' += ' Scroll Height: ' + this .scrollHeight;
+ report(output);
+});
+
+
+If you want to remove a event listener created with on or cancel an once event before it is even fired you can just use off.
+
+var s = new ScrollProxy ();
+s.on(' scroll' function () {
+ console .log (' YAY!' ' scroll' // No more YAY! logging
+scroll-proxy instances
+
+When you don't want an instance of scroll-proxy around anymore you should call unregister before losing the variable pointer. That way you assure the memory is clean and the events are released.
+
+var s = new ScrollProxy ();
+s.on(' scroll' function () {
+ console .log (' Scrolling' // Unregistering. Stop event reports and clean stuff
+s.unregister(); // Stopped logging
+
+delete s; // Clear pointer, everything OK The register function can recover unregistered instances and restore all the event handlers.
+
+var s = new ScrollProxy ();
+s.on(' scroll' function () {
+ console .log (' Scrolling' // Unregistering stop event reports
+s.unregister(); // Stopped logging
+
+s.register(); // Logging again on scroll Tip! If you already lost the variable pointing to the scroll-proxy instance you can just call ScrollProxy.clean() and get rid of all the attachments.
+
+var s = new ScrollProxy (); // Attaching ScrollProxy to document.body
+
+// Getting scroll events
+s.on(' scroll' function () {
+ console .log (' Scrolling...' delete s; // Remove s reference
+
+// Still getting 'Scrolling...' on scroll, because s.unregister() wasn't called
+
+// Can't s.unregister() now because it's undefined :(
+
+// So clean everything with ScrollProxy.clean()! :)
+ScrollProxy.clean();
+
+// Now it will stop logging and everything is fine again
+
+
+scroll-proxy can be a great partner in your quest for 60FPS animations!
+
+The first thing you need to know is that by using the custom scroll event you are already helping your websites performance. As you read earlier it throttles the event firing and all you need to do is select a proper delay using setScrollDelay.
+
+But, that's not all! There is another trick we built in the library: animation toggling . Yes, if you have a long page with a lot of hover animations you should be aware that scrolling that page may result in a janky experience.
+
+To solve that you'll want to use the disableHoverOnScroll method. It will disable all hover animations inside the scroll area when the user is scrolling, resulting in a much better experience.
+
+var s = new ScrollProxy ();
+s.disableHoverOnScroll();That's it! Don't worry, all the animations will come back to life once the user stops scrolling. It's all possible thanks to the pointer-events spec.
+
+If you need to enable animations on scroll again for some reason you can do that:
+
+
+
+Notice that it applies a little delay between the scroll stop and the animation enabling, if you want to change that delay use the setHoverDelay method.
+
+// From now on, animations will resume after a 100ms delay after the scroll stop
+s.setHoverDelay(100 );
+
+
+Try pressing the following button, it will toggle the hover animations on this very page. Then try scrolling over buttons to see if they react or not.
+
+Disable hover animations
+
+
+
+
+There are some other great features in the lib, check the full documentation for more information.
+
+
+
+
+This library works with most modern browsers. Some features like the animation toggling require support for the css pointer-events spec.
+
+Theoretical support should include the following browsers:
+
+
+
+
+Android
+iOS
+
+
+
+
+40+
+11+
+40+
+29+
+8+
+12+
+4.0+
+8+
+
+
+
+
+You may get it to work on older browsers as well but some features may not function properly. The table above only states fully supported browsers.
+
+
+
+
+MIT License © Matheus Kautzmann
+
+
+
+
+
+
+
+
+
+
diff --git a/javascript/demos.js b/javascript/demos.js
new file mode 100644
index 0000000..b5af2e0
--- /dev/null
+++ b/javascript/demos.js
@@ -0,0 +1,97 @@
+(function(window, document){
+ //SETUP THE COOL STICKY HEADER
+ var stickyHeader = document.getElementById("sticky-header");
+ if (window.myScroll.y >= 400) {
+ stickyHeader.style.display = 'block';
+ }
+
+ function toggleHeader() {
+ window.myScroll.once('offsetY', function(){
+ stickyHeader.style.display = 'block';
+ this.once('offsetY', function() {
+ stickyHeader.style.display = 'none';
+ toggleHeader();
+ }, -350);
+ }, 350);
+ }
+
+ // Tweaking detection speed
+ window.myScroll.setScrollDelay(100);
+
+ toggleHeader();
+
+ //BUTTON DEMO - TOGGLING HOVER ANIMATIONS
+ var btn = document.getElementById("toggleAnimationBtn");
+ var disabled = false;
+ btn.addEventListener("click", function(){
+ if (disabled) {
+ btn.innerHTML = 'Disable hover animations';
+ window.myScroll.enableHoverOnScroll();
+ disabled = false;
+ }
+ else {
+ btn.innerHTML = 'Enable hover animations';
+ window.myScroll.disableHoverOnScroll();
+ disabled = true;
+ }
+ }, false);
+
+ //EXAMPLE 1
+ var circle1 = document.getElementById('offset-example1-circle');
+ new ScrollProxy(document.getElementById('offset-example1'))
+ .on('offsetX', function(){
+ circle1.className = 'circle blue';
+ })
+ .on('offsetY', function(){
+ circle1.className = 'circle green';
+ });
+
+ //EXAMPLE 2
+ var box = document.getElementById('offset-example2-box');
+ new ScrollProxy(document.getElementById('offset-example2'))
+ .once('offsetY', function(){
+ box.className = 'bigDiv green';
+ }, 300);
+
+ //EXAMPLE 3
+ var box2 = document.getElementById('bound-example1-box');
+ new ScrollProxy(document.getElementById('bound-example1'))
+ .once('bottom', function(){
+ box2.style.color = 'green';
+ });
+
+ //EXAMPLE 4
+ var box3 = document.getElementById('bound-example2-box');
+ new ScrollProxy(document.getElementById('bound-example2'))
+ .once('bottom', function(){
+ box3.style.color = 'yellow';
+ }, 250)
+ .once('bottom', function(){
+ box3.style.color = 'green';
+ });
+
+ //EXAMPLE 5
+ var square = document.getElementById('visibility-example-square');
+ var outputLog = document.getElementById('visibility-example-log');
+ new ScrollProxy(document.getElementById('visibility-example'))
+ .on('visible', function(){
+ outputLog.innerHTML = 'SQUARE VISIBLE :-)';
+ }, square)
+ .on('invisible', function(){
+ outputLog.innerHTML = 'SQUARE NOT VISIBLE :-(';
+ }, square);
+
+ //EXAMPLE 6
+ var outputLog2 = document.getElementById('metadata-example-log');
+ new ScrollProxy(document.getElementById('metadata-example'))
+ .on('scroll', function(){
+ var output = 'X: ' + this.x + '=0},t.isNegativeNumber=function(e){return t.isNumber(e)&&0>e},t}();
@@ -6,4 +6,4 @@ var SUtil,slice=[].slice;module.exports=SUtil=function(){function t(){}return t.
var SUtil,ScrollProxy,indexOf=[].indexOf||function(t){for(var e=0,r=this.length;r>e;e++)if(e in this&&this[e]===t)return e;return-1};SUtil=require("./SUtil"),module.exports=ScrollProxy=function(){function t(t){if(null==t&&(t=document),t===document&&(t=t.body),t===window&&(t=t.document.body),!(t instanceof HTMLElement))throw new Error("Could not attach to a valid anchor");return this._target=t,this._events=[],this.register(),this._updateViewportInfo(),this}return t.active=!1,t._targetList=[],t.SCROLL="scroll",t.OFFSET_X="offsetX",t.OFFSET_Y="offsetY",t.TOP="top",t.BOTTOM="bottom",t.LEFT="left",t.RIGHT="right",t.VISIBLE="visible",t.INVISIBLE="invisible",t.DISABLE_HOVER="disable-hover",t.prototype._targetX="scrollLeft",t.prototype._targetY="scrollTop",t.prototype._target=null,t.prototype._events=[],t.prototype._scrollDelay=250,t.prototype._hoverDelay=250,t.prototype._hoverTimeout=null,t.prototype.x=0,t.prototype.y=0,t.prototype.width=0,t.prototype.height=0,t.prototype.scrollWidth=0,t.prototype.scrollHeight=0,t.prototype.scrollData={},t._handleScroll=function(e){var r,n,i;return r=t._targetList.length,0===r?null:(i=e.target.body||e.target,null!=(n=t._getElement(i))?n.proxy._performScroll(e):void 0)},t._getElement=function(e){var r,n,i,o;for(o=t._targetList,n=0,i=o.length;i>n;n++)if(r=o[n],null!=r&&r.target===e)return r;return null},t.activate=function(){return t.active||(window.addEventListener(t.SCROLL,t._handleScroll,!0),t.active=!0),t.active},t.deactivate=function(){return window.removeEventListener(t.SCROLL,t._handleScroll,!0),t.active=!1},t.clean=function(){return t.deactivate(),t._targetList=[]},t.prototype._updateViewportInfo=function(){return this.x=this._target[this._targetX],this.y=this._target[this._targetY],this.width=this._target.offsetWidth,this.height=this._target.offsetHeight,this.scrollWidth=this._target.scrollWidth,this.scrollHeight=this._target.scrollHeight,null},t.prototype._checkElement=function(t){if(indexOf.call(this._target.children,t)<0)throw new Error("Element must be child of the scroll element");return null},t.prototype._removeEvent=function(t){var e,r,n,i,o,l,s,a,u;for(a=this._events,r=i=0,l=a.length;l>i;r=++i)if(n=a[r],t===n){window.clearTimeout(t.timeout),delete t.fn,delete this._events[r];break}for(e=[],u=this._events,o=0,s=u.length;s>o;o++)n=u[o],null!=n&&e.push(n);return this._events=e},t.prototype._isRectVisible=function(t){var e,r;return this._updateViewportInfo(),e=this.xt.x-this.width,r=this.yt.y-this.height,e&&r},t.prototype._performScroll=function(t){var e,r,n,i,o;if(n=this._events.length,0===n)return null;for(this.scrollData=t,o=this._events,r=0,i=o.length;i>r;r++)e=o[r],e.fn.call(this,e);return this._target},t.prototype._throttleScroll=function(t,e){var r;return r=!1,function(n){return function(i){return r?void 0:(r=!0,i.timeout=window.setTimeout(function(){return r=!1,SUtil.reportChange(t,n,n.scrollData)},null!=e?e:n.getScrollDelay()))}}(this)},t.prototype._createEvent=function(t,e,r,n){var i;return i=this._throttleScroll(e,n),this._events.push({type:t,fn:i,origin:r,timeout:null})},t.prototype._createScrollEvent=function(t,e,r,n){return null==r&&(r=e),this._createEvent(t,function(t){return function(){return t._updateViewportInfo(),SUtil.reportChange(e,t,t.scrollData)}}(this),r,n)},t.prototype._createOffsetEvent=function(e,r,n){return null==n&&(n=0),e===t.OFFSET_X?this._createEvent(e,function(t){return function(){return t.x===t._target[t._targetX]||(t._updateViewportInfo(),SUtil.isPositiveNumber(n)&&t.xMath.abs(n))?void 0:SUtil.reportChange(r,t,t.scrollData)}}(this),r):this._createEvent(e,function(t){return function(){return t.y===t._target[t._targetY]?t._updateViewportInfo():(t._updateViewportInfo(),SUtil.isPositiveNumber(n)&&t.yMath.abs(n)?void 0:SUtil.reportChange(r,t,t.scrollData))}}(this),r)},t.prototype._createHorizontalBoundScrollEvent=function(e,r,n){return null==n&&(n=0),e===t.LEFT?this._createScrollEvent(e,function(t){return function(){return t.x<=Math.abs(n)?SUtil.reportChange(r,t,t.scrollData):void 0}}(this),r,0):this._createScrollEvent(e,function(t){return function(){return t.scrollWidth-t.x-t.width<=Math.abs(n)?SUtil.reportChange(r,t,t.scrollData):void 0}}(this),r,0)},t.prototype._createVerticalBoundScrollEvent=function(e,r,n){return null==n&&(n=0),e===t.TOP?this._createScrollEvent(e,function(t){return function(){return t.y<=Math.abs(n)?SUtil.reportChange(r,t,t.scrollData):void 0}}(this),r,0):this._createScrollEvent(e,function(t){return function(){return t.scrollHeight-t.y-t.height<=Math.abs(n)?SUtil.reportChange(r,t,t.scrollData):void 0}}(this),r,0)},t.prototype._createVisibilityScrollEvent=function(e,r,n){return this._checkElement(n),e===t.VISIBLE?this._createScrollEvent(e,function(t){return function(){return t.isElementVisible(n)?SUtil.reportChange(r,t,t.scrollData):void 0}}(this),r):this._createScrollEvent(e,function(t){return function(){return t.isElementVisible(n)?void 0:SUtil.reportChange(r,t,t.scrollData)}}(this),r)},t.prototype.setScrollDelay=function(t){return SUtil.isPositiveNumber(t)&&(this._scrollDelay=Math.round(t)),this},t.prototype.getScrollDelay=function(){return this._scrollDelay},t.prototype.setHoverDelay=function(t){return SUtil.isPositiveNumber(t)&&(this._hoverDelay=Math.round(t)),this},t.prototype.getHoverDelay=function(){return this._hoverDelay},t.prototype.getTarget=function(){return this._target},t.prototype.getRect=function(t){return{x:t.offsetLeft,y:t.offsetTop,w:t.getBoundingClientRect().width,h:t.getBoundingClientRect().height}},t.prototype.on=function(e,r,n){if(!SUtil.isValidEventName(e))return this;if(!SUtil.isFunction(r))return this;switch(e){case t.SCROLL:this._createScrollEvent(e,r);break;case t.OFFSET_X:case t.OFFSET_Y:this._createOffsetEvent(e,r,n);break;case t.TOP:case t.BOTTOM:this._createVerticalBoundScrollEvent(e,r,n);break;case t.LEFT:case t.RIGHT:this._createHorizontalBoundScrollEvent(e,r,n);break;case t.VISIBLE:case t.INVISIBLE:this._createVisibilityScrollEvent(e,r,n)}return this},t.prototype.once=function(t,e,r){var n;return n=function(r){return function(){return SUtil.reportChange(e,r,r.scrollData),r.off(t,n)}}(this),this.on(t,n,r)},t.prototype.off=function(t,e){var r,n,i,o,l;if(!SUtil.isValidEventName(t))return this;for(l=this._events,n=i=0,o=l.length;o>i;n=++i)r=l[n],null==e&&null!=r&&t===r.type?this._removeEvent(r):null!=e&&null!=r&&r.origin===e&&this._removeEvent(r);return this},t.prototype.register=function(){var e;if(e=t._getElement(this._target),null!=e)throw new Error("Assign one proxy per target");return t._targetList.push({target:this._target,proxy:this}),t.activate(),this},t.prototype.unregister=function(){var e;if(e=t._targetList.length,e>0)for(;e--;)if(t._targetList[e].proxy===this){SUtil.removeItemFromArray(t._targetList,e);break}return 0===t._targetList.length&&t.deactivate(),this},t.prototype.isElementVisible=function(t){return this._checkElement(t),this._isRectVisible(this.getRect(t))},t.prototype.disableHoverOnScroll=function(){return this._createScrollEvent(t.DISABLE_HOVER,function(t){return function(){return window.clearTimeout(t._hoverTimeout),t._target.style.pointerEvents="none",t._hoverTimeout=window.setTimeout(function(){return t._target.style.pointerEvents="auto"},t.getHoverDelay())}}(this),null,0),this},t.prototype.enableHoverOnScroll=function(){return this.off(t.DISABLE_HOVER),this._target.style.pointerEvents="auto",this},t}();
},{"./SUtil":1}]},{},[1,2])(2)
-});
\ No newline at end of file
+});
diff --git a/package.json b/package.json
deleted file mode 100644
index a0ad635..0000000
--- a/package.json
+++ /dev/null
@@ -1,53 +0,0 @@
-{
- "name": "scroll-proxy",
- "version": "0.2.1",
- "description": "Easy scroll handling in the browser. Zero dependencies. ~2kb gzipped",
- "main": "dist/scroll-proxy.js",
- "scripts": {
- "test": "grunt test",
- "coverage": "node_modules/mocha-phantomjs/bin/mocha-phantomjs -R node_modules/mocha-lcov-reporter/lib/lcov.js test/index.html | sed -n '1!p' | sed 's,SF:,SF:src/,' | node_modules/coveralls/bin/coveralls.js"
- },
- "repository": {
- "type": "git",
- "url": "https://github.com/mkautzmann/scroll-proxy.git"
- },
- "keywords": [
- "scroll",
- "proxy",
- "performance",
- "perf",
- "browser",
- "browserify"
- ],
- "author": "Matheus Kautzmann ",
- "license": "MIT",
- "bugs": {
- "url": "https://github.com/mkautzmann/scroll-proxy/issues"
- },
- "homepage": "https://github.com/mkautzmann/scroll-proxy",
- "devDependencies": {
- "browserify": "~11.2.0",
- "browserify-coffee-coverage": "~1.0.2",
- "chai": "~3.3.0",
- "coffeeify": "~1.1.0",
- "coffeelint": "~1.13.0",
- "coveralls": "~2.11.4",
- "function-bind": "~1.0.2",
- "grunt": "~0.4.5",
- "grunt-browserify": "~4.0.1",
- "grunt-codo": "~0.2.0",
- "grunt-coffeelint": "~0.0.13",
- "grunt-contrib-clean": "~0.6.0",
- "grunt-contrib-coffee": "~0.13.0",
- "grunt-contrib-connect": "~0.11.2",
- "grunt-contrib-watch": "~0.6.1",
- "grunt-http-server": "~1.13.0",
- "grunt-mochify": "~0.3.0",
- "grunt-saucelabs": "~8.6.1",
- "mocha-phantomjs": "~4.0.1",
- "sauce-connect-launcher": "~0.13.0",
- "sinon": "~1.17.1",
- "uglifyify": "~3.0.1",
- "wallabify": "~0.0.10"
- }
-}
diff --git a/params.json b/params.json
new file mode 100644
index 0000000..22cfad6
--- /dev/null
+++ b/params.json
@@ -0,0 +1 @@
+{"name":"scroll-proxy","tagline":"Easy scroll handling. Zero dependencies. Just 2kb.","body":"## Goal\r\n\r\nThis package is designed to help dealing with the scroll event in the **browser** in the most smoothly way possible.\r\n\r\nYes, web browsers already deliver ways to listen for the scroll event and they work really well. What `scroll-proxy` does is proxy the calls from you to the native scroll event and the other way around, doing some transformations in the process.\r\n\r\nIt applies some techniques already frequently used by web developers such as **function throttling**, **animation toggling** and a few others on **scroll**-related events. Delivering a small library one can just download and use.\r\n\r\nThe project's main focus is to help developers achieve great scroll performance in their apps while still being able to implement stuff like **scroll-based animations**, **sticky headers** and **infinite scrolling**.\r\n\r\n## Install\r\n\r\nThe installation process is pretty straight-forward.\r\n\r\nYou can get it on npm:\r\n\r\n`npm install scroll-proxy --save`\r\n\r\nOr bower:\r\n\r\n`bower install scroll-proxy --save`\r\n\r\nIf you are not into package management there is also the option of [direct download](), after unzipping the JS file will be in the `dist` folder.\r\n\r\nDon't want to download at all? No problem. Just get it from one of the [CDN providers]().\r\n\r\n## Usage\r\n\r\n### How it works\r\n\r\nOne of the biggest concerns when developing `scroll-proxy` is its interoperability with other libs and frameworks.\r\n\r\nSo we decided not to change the native scroll handling. Instead, we create a wrapper that can handle everything the native can do and more.\r\n\r\nThis way we avoid breaking any other lib that may rely on the native scroll event.\r\n\r\nThe coolest part of the lib is the event handling, you can attach as many events you like but it will only attach one listener to the native `scroll` event in the browser. This practice is often called [event delegation](https://davidwalsh.name/event-delegate).\r\n\r\nPlease setup the lib and check for yourself.\r\n\r\n### Setup\r\n\r\nSetting up the library is simple and easy.\r\n\r\nOnce you've installed it and properly added it to your document via a `script` tag you just have to instantiate a new `ScrollProxy` object.\r\n\r\n```javascript\r\nvar myScroll = new ScrollProxy();\r\n```\r\n\r\nYou just did it!\r\n\r\nNotice that you didn't pass any arguments to the `ScrollProxy` constructor. By default, ScrollProxy will always **attach** to `document.body`. It means it will report actions when the user scrolls the **page**.\r\n\r\nIf you want to get updates when the user scrolls inside some specific `HTMLElement` you must pass it to the constructor:\r\n\r\n```javascript\r\nvar myDiv = document.querySelector('.scrollable');\r\nvar myDivScroll = new ScrollProxy(myDiv);\r\n```\r\n\r\n#### Note for CommonJS/browserify users\r\n\r\nThe CommonJS module version needs you to `require` ScrollProxy before using it like above.\r\n\r\n```javascript\r\nvar ScrollProxy = require(\"scroll-proxy\");\r\n```\r\n\r\n###
-###
-module.exports = class SUtil
-
- ###
- Function that calls the callback with the given args and context
- @param [Function] callback function that will be called back
- @param [Object] context `this` context that will be applied to callback
- @param [Array] args (Optional )A splat with the arguments that will be
- passed along
- @return [Null] it will return null if can't call the callback, undefined
- otherwise
- @example Calling func with ctx as this and no arguments:
- SUtil.reportChange(func, ctx)
- @example Calling the func with ctx as this and two arguments:
- SUtil.reportChange(func, ctx, 1, 2)
- @since 0.1.0
- ###
- @reportChange: (callback, context, args...) ->
- if SUtil.isFunction(callback)
- return callback.apply(context, args)
- return null
-
- ###
- Reliably gets the JS type of the given variable
- @see http://bonsaiden.github.io/JavaScript-Garden/#types.typeof
- @example Checking a string will return [object String]
- SUtil.getType('hello')
- @example Checking a number will return [object Number]
- SUtil.getType(1)
- @param [Object] target variable to be type tested
- @return [String] The type of the given variable
- @since 0.1.0
- ###
- @getType: (target) -> Object::toString.call(target)
-
- ###
- Removes an item from an array, changing the array involved and returning
- the element removed
- @example Removing the first element of the array
- SUtil.removeItemFromArray([1, 2], 0)
- @param [Array] arr Array to remove the element from
- @param [Number] idx Index of the element to be removed
- @return [Any] the element removed
- @since 0.1.0
- ###
- @removeItemFromArray: (arr, idx) -> arr.splice(idx, 1)[0]
-
- ###
- Checks if the suplied variable is a valid JS Function
- @example Checking a valid function will return true
- SUtil.isFunction(-> null)
- @example Checking a number will return false
- SUtil.isFunction(1)
- @param [Function] func Variable to be tested as function
- @return [Boolean] true if function and false if not
- @since 0.1.0
- ###
- @isFunction: (func) -> SUtil.getType(func) is '[object Function]'
-
- ###
- Checks if the suplied variable is a valid JS Number
- @example Checking a number will return true
- SUtil.isNumber(1)
- @example Checking a bool will return false
- SUtil.isNumber(true)
- @param [Number] number Variable to be tested as number
- @return [Boolean] true if number and false if not
- @since 0.1.0
- ###
- @isNumber: (number) -> SUtil.getType(number) is '[object Number]'
-
- ###
- Checks if the suplied variable is a valid JS String
- @example Checking a string will return true
- SUtil.isString('hello')
- @example Checking a number will return false
- SUtil.isString(1)
- @param [Number] number Variable to be tested as string
- @return [Boolean] true if string and false if not
- @since 0.1.0
- ###
- @isString: (string) -> SUtil.getType(string) is '[object String]'
-
- ###
- Checks if the suplied variable can be used as event name for ScrollProxy
- @example Empty strings will return false
- SUtil.isValidEventName('')
- @example Non-string object will return false
- SUtil.isValidEventName(1)
- @example String with one or more chars will return true
- SUtil.isValidEventName('myEvent')
- @param [String name Variable to be tested as valid event name
- @return [Boolean] true if valid name and false if not
- @since 0.1.0
- ###
- @isValidEventName: (name) -> SUtil.isString(name) and name isnt ''
-
- ###
- Checks if the suplied variable is a positive number, it also considers 0
- a positive number
- @example Checking for numbers greater than zero will return true
- SUtil.isPositiveNumber(1)
- @example Checking for 0 itself will return true
- SUtil.isPositiveNumber(0)
- @example Checking for number lower than 0 will return false
- SUtil.isPositiveNumber(-1)
- @param [String name Variable to be tested as positive number
- @return [Boolean] true if positive number and false if not
- @since 0.1.0
- ###
- @isPositiveNumber: (number) -> SUtil.isNumber(number) and number >= 0
-
- ###
- Checks if the suplied variable is a negative number, it does not
- considers 0 a negative number
- @example Checking for anything larger than zero will return false
- SUtil.isNegativeNumber(1)
- @example Checking for 0 itself will return false since it is considered
- positive
- SUtil.isNegativeNumber(0)
- @example Numbers lower than zero will return true
- SUtil.isNegativeNumber(-1)
- @param [String name Variable to be tested as negative number
- @return [Boolean] true if negative number and false if not
- @since 0.1.0
- ###
- @isNegativeNumber: (number) -> SUtil.isNumber(number) and number < 0
diff --git a/src/ScrollProxy.coffee b/src/ScrollProxy.coffee
deleted file mode 100644
index 902e098..0000000
--- a/src/ScrollProxy.coffee
+++ /dev/null
@@ -1,795 +0,0 @@
-# Require SUtil
-SUtil = require('./SUtil')
-
-###
- Main class, containing the scrolling related events and API
-
- @option _targetList [HTMLElement] target The anchor of the ScrollProxy
- instance
- @option _targetList [ScrollProxy] proxy The instance of ScrollProxy
-
- @option _events [String] type The event name of the event
- @option _events [Function] fn The function that will handle the callback
- @option _events [Number] timeout The timeout id of the throttled **fn**
-
- @since 0.1.0
- @author Matheus Kautzmann -
-###
-module.exports = class ScrollProxy
- ###
- @property [Boolean] Class variable that indicates if ScrollProxy is
- currently enabled
- ###
- @active: no
-
- ###
- @property [Array] Private Class variable that holds
- all the elements currently tracked by ScrollProxy
- ###
- @_targetList: []
-
- ###
- @property [String] Class constant that maps to the **scroll** event
- name
- ###
- @SCROLL: 'scroll'
-
- ###
- @property [String] Class constant that maps to the **offsetX**
- event name
- ###
- @OFFSET_X: 'offsetX'
-
- ###
- @property [String] Class constant that maps to the **offsetY**
- event name
- ###
- @OFFSET_Y: 'offsetY'
-
- ###
- @property [String] Class constant that maps to the **top**
- event name
- ###
- @TOP: 'top'
-
- ###
- @property [String] Class constant that maps to the **bottom**
- event name
- ###
- @BOTTOM: 'bottom'
-
- ###
- @property [String] Class constant that maps to the **left**
- event name
- ###
- @LEFT: 'left'
-
- ###
- @property [String] Class constant that maps to the **right**
- event name
- ###
- @RIGHT: 'right'
-
- ###
- @property [String] Class constant that maps to the **visible**
- event name
- ###
- @VISIBLE: 'visible'
-
- ###
- @property [String] Class constant that maps to the **invisible**
- event name
- ###
- @INVISIBLE: 'invisible'
-
- ###
- @property [String] Class constant that maps to the **disable-hover**
- event name
- ###
- @DISABLE_HOVER: 'disable-hover'
-
- ###
- @property [String] Private instance variable that maps to the
- target's **x** position property
- ###
- _targetX: 'scrollLeft'
-
- ###
- @property [String] Private instance variable that maps to the
- target's **y** position property
- ###
- _targetY: 'scrollTop'
-
- ###
- @property [HTMLElement] Private instance variable that indicates the target
- this ScrollProxy's instance is attached to
- ###
- _target: null
-
- ###
- @property [Array] Private instance variable that holds the events
- this instance responds to
- ###
- _events: []
-
- ###
- @property [Number] Private instance variable that holds the
- current delay for scroll throttling
- ###
- _scrollDelay: 250
-
- ###
- @property [Number] Private instance variable that holds the
- current delay for enabling/disabling hover elements on scroll
- ###
- _hoverDelay: 250
-
- ###
- @property [Number] Private instance variable that holds the
- current timeout used when blocking hover animations
- ###
- _hoverTimeout: null
-
- ###
- @property [Number] Instance variable that holds the current x position of
- the scroll target
- ###
- x: 0
-
- ###
- @property [Number] Instance variable that holds the current y position of
- the scroll target
- ###
- y: 0
-
- ###
- @property [Number] Instance variable that holds the current width of
- the scroll target box
- ###
- width: 0
-
- ###
- @property [Number] Instance variable that holds the current height of
- the scroll target box
- ###
- height: 0
-
- ###
- @property [Number] scrollWidth Instance variable that holds the current
- width of the scroll target scroll area
- ###
- scrollWidth: 0
-
- ###
- @property [Number] Instance variable that holds the current
- height of the scroll target scroll area
- ###
- scrollHeight: 0
-
- ###
- @property [Object] Instance variable that holds the current
- scroll data (from last scroll action)
- ###
- scrollData: {}
-
- ###
- Handles the scroll event when it fires
- @example Simulating the window firing an event passing the metadata:
- window.addEventListener('scroll', ScrollProxy.handleScroll, true)
- @param [Object] e scroll event data
- @return [Object] Null or the element that catched the event
- @since 0.1.0
- @private
- ###
- @_handleScroll: (e) ->
- len = ScrollProxy._targetList.length
- if len is 0 then return null
- # Get the correct target anchor (HTML element)
- target = e.target.body or e.target
- return ScrollProxy._getElement(target)?.proxy._performScroll(e)
-
- ###
- Retrieves the current target and proxy for the given HTMLElement
- @example Checking if the body tag is on _targetList:
- ScrollProxy._getElement(document.body)
- @param [HTMLElement] el The element to search for in **_targetList**
- @return [Object] Null or the target that matched the argument
- @since 0.1.0
- @private
- ###
- @_getElement: (el) ->
- for item in ScrollProxy._targetList
- if item? and item.target is el
- return item
- return null
-
- ###
- Activates the ScrollProxy's functionality, registering the event listener
- that will listen for scroll events and proxy it to
- **ScrollProxy.handleScroll**
- @example Activating ScrollProxy manually, it's done automatically with new:
- ScrollProxy.activate()
- @return [Boolean] The current status of ScrollProxy
- @since 0.1.0
- ###
- @activate: ->
- if not ScrollProxy.active
- window.addEventListener(
- ScrollProxy.SCROLL,
- ScrollProxy._handleScroll,
- true
- )
- ScrollProxy.active = yes
- return ScrollProxy.active
-
- ###
- Deactivates the ScrollProxy's functionality, removing the event listener and
- stopping any functionality
- @example Deactivating manually, it's done automatically when unregistering:
- ScrollProxy.deactivate()
- @return [Boolean] The current status of ScrollProxy
- @since 0.1.0
- ###
- @deactivate: ->
- window.removeEventListener(
- ScrollProxy.SCROLL,
- ScrollProxy._handleScroll,
- true
- )
- return ScrollProxy.active = no
-
- ###
- Cleans the **_targetList**, removing all targets
- @example To assure ScrollProxy is shut down you could run **clean**:
- ScrollProxy.clean()
- @return [Array] Targets removed
- @since 0.1.0
- ###
- @clean: ->
- ScrollProxy.deactivate()
- return ScrollProxy._targetList = []
-
- ###
- Update this instance rect information, updating x and y positions as well as
- width, height, scrollWidth and scrollHeight
- @example Most methods run this function when up-to-date data is required:
- s = new ScrollProxy()
- document.body.scrollTop = 20 # s.y continues 0
- s.updateViewportInfo() # s.y is 20 now
- @return [Null] Nothing useful is returned
- @since 0.1.0
- @private
- ###
- _updateViewportInfo: ->
- @x = @_target[@_targetX]
- @y = @_target[@_targetY]
- @width = @_target.offsetWidth
- @height = @_target.offsetHeight
- @scrollWidth = @_target.scrollWidth
- @scrollHeight = @_target.scrollHeight
- return null
-
- ###
- Utility method that Throws error if element given is not child of the
- **_target**
- @example Checking a list item inside a ul:
- s = new ScrollProxy(ul)
- s._checkElement(li) # does not throw anything, so OK
- @param [HTMLElement] el The element to check
- @return [Null] Nothing useful is returned
- @since 0.1.0
- @private
- ###
- _checkElement: (el) ->
- if el not in @_target.children
- throw new Error('Element must be child of the scroll element')
- return null
-
- ###
- Remove an event from the list of events
- @example Don't want to receive scroll feedback anymore:
- s = new ScrollProxy()
- evt = s._createEvent('scroll', -> null)
- s._removeEvent(evt) # OK, event gone
- @param [Object] The event to remove
- @return [Array] The new array of events (**_events**)
- @since 0.1.0
- @private
- ###
- _removeEvent: (event) ->
- for item, i in @_events
- if event is item
- window.clearTimeout(event.timeout)
- delete event.fn
- delete @_events[i]
- break
- arr = []
- arr.push(item) for item in @_events when item?
- return @_events = arr
-
- ###
- Checks if the given virtual rect is visible on **_target** viewport
- @example Check if the rect (0, 0, 50, 50) is visible:
- s = new ScrollProxy()
- rect = {x: 0, y:0, w: 50, h: 50}
- s._isRectVisible(rect) # Visible?
- @param [Object] rect The rect object to check
- @option rect [Number] x The top-left x position
- @option rect [Number] y The top-left y position
- @option rect [Number] w The width of the rect
- @option rect [Number] h The height of the rect
- @return [Boolean] Indicates if visible or not
- @since 0.1.0
- @private
- ###
- _isRectVisible: (rect) ->
- @_updateViewportInfo()
- xVisible = @x < (rect.x + rect.w) and @x > (rect.x - @width)
- yVisible = @y < (rect.y + rect.h) and @y > (rect.y - @height)
- return xVisible and yVisible
-
- ###
- Performs the scroll actions, firing the needed events internally
- @example The **_handleScroll** usually calls this method:
- s = new ScrollProxy()
- s._performScroll(scrollEvt) # OK, related events will be fired
- @param [Object] The scroll data passed with the event
- @return [HTMLElement] The current target
- @since 0.1.0
- @private
- ###
- _performScroll: (e) ->
- len = @_events.length
- if len is 0 then return null
- @scrollData = e
- event.fn.call(this, event) for event in @_events
- return @_target
-
- ###
- Function that performs the scroll throttling to achieve better performance
- @example One must pass a function to be throttled and a delay:
- s = new ScrollProxy()
- func = -> this
- newFunc = s._throttleScroll(func, 250)
- newFunc() # func will be called after 250ms, the scrollData will be passed
- newFunc() # func will not be called, because other call is waiting
- @param [Function] The function to throttle
- @param [Number] delay The time function should wait to fire
- @return [Function] The new throttled function
- @since 0.1.0
- @private
- ###
- _throttleScroll: (func, delay) ->
- running = no
- return (data) =>
- if running then return
- running = yes
- data.timeout = window.setTimeout(=>
- running = no
- return SUtil.reportChange(func, this, @scrollData)
- , (if delay? then delay else @getScrollDelay()))
-
- ###
- Creates a generic event and pushes it in the **_events** array
- @example Create event with name, callback and optional throttle delay:
- s = new ScrollProxy()
- s._createEvent('scroll', -> null, 250) # setting delay of 250ms
- @param [String] evt The event name to register
- @param [Function] callback the function to be called when event is fired
- @param [Function] origin the original function passed, `off` searches for it
- @param [Number] delay Time to wait in milliseconds
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createEvent: (evt, callback, origin, delay) ->
- fn = @_throttleScroll(callback, delay)
- return @_events.push({type: evt, fn: fn, origin: origin, timeout: null})
-
- ###
- Creates a scroll event
- @example Create scroll event with callback and optional throttle delay:
- s = new ScrollProxy()
- s._createScrollEvent('scroll', -> null, 250) # setting delay of 250ms
- @param [String] evt The event name to register (**scroll**)
- @param [Function] callback the function to be called when event is fired
- @param [Function] origin the original function passed, `off` searches for it
- @param [Number] delay Time to wait in milliseconds
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createScrollEvent: (evt, callback, origin = callback, delay) ->
- return @_createEvent(evt, =>
- @_updateViewportInfo()
- return SUtil.reportChange(callback, this, @scrollData)
- , origin, delay)
-
- ###
- Creates a offset event
- @example Create offset event with callback and optional offset:
- s = new ScrollProxy()
- s._createOffsetEvent('offsetX', -> null, 250) # setting offset of 250px
- @param [String] evt The event name to register, **offsetX** or **offsetY**
- @param [Function] callback the function to be called when event is fired
- @param [Number] offset Offset to check for (0 is default)
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createOffsetEvent: (evt, callback, offset = 0) ->
- if evt is ScrollProxy.OFFSET_X
- return @_createEvent(evt, =>
- if @x is @_target[@_targetX]
- return
- else
- @_updateViewportInfo()
- if SUtil.isPositiveNumber(offset) and @x < offset then return
- if SUtil.isNegativeNumber(offset) and @x > Math.abs(offset) then return
- return SUtil.reportChange(callback, this, @scrollData)
- , callback)
- else
- return @_createEvent(evt, =>
- if @y is @_target[@_targetY]
- return @_updateViewportInfo()
- else
- @_updateViewportInfo()
- if SUtil.isPositiveNumber(offset) and @y < offset then return
- if SUtil.isNegativeNumber(offset) and @y > Math.abs(offset) then return
- return SUtil.reportChange(callback, this, @scrollData)
- , callback)
-
- ###
- Creates a event to check for horizontal bound collision
- @example Create horizontal bound event with callback and optional offset:
- s = new ScrollProxy()
- s._createHorizontalBoundEvent('left', -> null)
- # One can also check with a offset inwards, useful for infinite scrolling
- s._createHorizontalBoundEvent('left', -> null, 250) # fire 250px to left
- @param [String] evt The event name to register, **left** or **right**
- @param [Function] callback the function to be called when event is fired
- @param [Number] offset Offset to check for (0 is defaut)
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createHorizontalBoundScrollEvent: (evt, callback, offset = 0) ->
- if evt is ScrollProxy.LEFT
- return @_createScrollEvent(evt, =>
- if @x <= Math.abs(offset)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback, 0)
- else
- return @_createScrollEvent(evt, =>
- if (@scrollWidth - @x) - @width <= Math.abs(offset)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback, 0)
-
- ###
- Creates a event to check for vertical bound collision
- @example Create vertical bound event with callback and optional offset:
- s = new ScrollProxy()
- s._createVerticalBoundEvent('top', -> null)
- # One can also check with a offset inwards, useful for infinite scrolling
- s._createVerticalBoundEvent('top', -> null, 250) # fire 250px to top
- @param [String] evt The event name to register, **top** or **bottom**
- @param [Function] callback the function to be called when event is fired
- @param [Number] offset Offset to check for
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createVerticalBoundScrollEvent: (evt, callback, offset = 0) ->
- if evt is ScrollProxy.TOP
- return @_createScrollEvent(evt, =>
- if @y <= Math.abs(offset)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback, 0)
- else
- return @_createScrollEvent(evt, =>
- if (@scrollHeight - @y) - @height <= Math.abs(offset)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback, 0)
-
- ###
- Creates a event to check for element visibility as one scrolls
- @example Create visibility scroll event with callback and optional offset:
- s = new ScrollProxy()
- ul = document.querySelector('.myBeautifulList')
- s._createVisibilityScrollEvent('visible', -> null, ul)
- @param [String] evt The event name to register, **visible** or **invisible**
- @param [Function] callback the function to be called when event is fired
- @param [Number] offset Offset to check for
- @return [Object] The event just registered
- @since 0.2.0
- @private
- ###
- _createVisibilityScrollEvent: (evt, callback, el) ->
- @_checkElement(el)
- if evt is ScrollProxy.VISIBLE
- return @_createScrollEvent(evt, =>
- if @isElementVisible(el)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback)
- else
- return @_createScrollEvent(evt, =>
- if not @isElementVisible(el)
- return SUtil.reportChange(callback, this, @scrollData)
- , callback)
-
- ###
- The ScrollProxy constructor, use it to create new instances
- @example Create a new ScrollProxy instance:
- # Creating a instance in the document.body
- s = new ScrollProxy() # it defaults to document.body
- # Creating on a div
- s = new ScrollProxy(myDiv) # or any HTMLEment
- # Creating on window
- s = new ScrollProxy(window) # Remaps to window.document.body
- @param [HTMLElement] target The element to attach ScrollProxy
- @return [ScrollProxy] This instance
- @since 0.2.0
- ###
- constructor: (target = document) ->
- if target is document
- target = target.body
- if target is window
- target = target.document.body
- if target instanceof HTMLElement
- @_target = target
- else
- throw new Error('Could not attach to a valid anchor')
- @_events = []
- @register()
- @_updateViewportInfo()
- return this
-
- ###
- Sets the scroll delay, any event registered will respect the new value
- @example Changing the scroll delay mid-flight:
- s = new ScrollProxy()
- # Any call will the throttled with 250ms
- s.on('scroll', -> null) # defaults to 250ms delay
- s.setScrollDelay(300) # any call now throttles with 300ms
- @param [Number] ms The delay in milliseconds
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- setScrollDelay: (ms) ->
- if SUtil.isPositiveNumber(ms)
- @_scrollDelay = Math.round(ms)
- return this
-
- ###
- Returns the current scroll delay
- @example Getting the current delay:
- s = new ScrollProxy()
- s.setScrollDelay(300) # any call now throttles with 300ms
- s.getScrollDelay() # will be 300
- @return [Number] The current value of _scrollDelay
- @since 0.1.0
- ###
- getScrollDelay: -> @_scrollDelay
-
- ###
- Sets the hover delay. The disable hover function will respect it
- @example Changing the hover delay mid-flight:
- s = new ScrollProxy()
- # Hover animations have 250ms delay on scroll end by default
- s.disableHoverOnScroll()
- s.setHoverDelay(300) # now hover delay is 300ms
- @param [Number] ms The delay in milliseconds
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- setHoverDelay: (ms) ->
- if SUtil.isPositiveNumber(ms)
- @_hoverDelay = Math.round(ms)
- return this
-
- ###
- Returns the current hover delay
- @example Getting the current delay:
- s = new ScrollProxy()
- s.setHoverDelay(300) # hover animations now have 300ms delay on scroll end
- s.getHoverDelay() # will be 300
- @return [Number] The current value of _hoverDelay
- @since 0.1.0
- ###
- getHoverDelay: -> @_hoverDelay
-
- ###
- Returns the current target
- @example Getting the current target:
- s = new ScrollProxy(myDiv)
- s.getTarget() # will equal myDiv
- @return [HTMLElement] The current target
- @since 0.1.0
- ###
- getTarget: -> @_target
-
- ###
- Returns the rect for an HTMLElement
- @example Getting body dimensions and position:
- s = new ScrollProxy(myDiv)
- s.getRect(document.body)
- @param [HTMLElement] el The element to get the rect from
- @return [Object] The rect
- @since 0.1.0
- ###
- getRect: (el) ->
- return {
- x: el.offsetLeft
- y: el.offsetTop
- w: el.getBoundingClientRect().width
- h: el.getBoundingClientRect().height
- }
-
- ###
- Register events in ScrollProxy
- @example Registering a new scroll event on body:
- s = new ScrollProxy()
- s.on('scroll', -> 'Awesome scrolling!')
- @param [String] evt The event name to Register
- @param [Function] func The function to callback once event is fired
- @param [Object] option A wildcard argument that is passed to the event
- @event scroll The scroll event that is fired whenever one scrolls
- @event offsetX The offset event on the X axis that fires once one scrolls
- past the given horizontal offset
- @event offsetY The offset event on the Y axis that fires once one scrolls
- past the given vertical offset
- @event top The event that fires once one reaches the top of the scroll area
- or the given offset top
- @event bottom The event that fires once one reaches the bottom of the scroll
- area or the given offset bottom
- @event left The event that fires once one reaches the left bound of the
- scroll area of the given offset left
- @event right The event that fires once one reaches the right bound of the
- scroll area of the given offset right
- @event visible The event that fires once the given element is visible on the
- scroll area
- @event invisible The event that fires once the given element is not visible
- on the scroll area
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- on: (evt, func, option) ->
- if not SUtil.isValidEventName(evt)
- return this
- if not SUtil.isFunction(func)
- return this
- switch evt
- when ScrollProxy.SCROLL
- @_createScrollEvent(evt, func)
- when ScrollProxy.OFFSET_X, ScrollProxy.OFFSET_Y
- @_createOffsetEvent(evt, func, option)
- when ScrollProxy.TOP, ScrollProxy.BOTTOM
- @_createVerticalBoundScrollEvent(evt, func, option)
- when ScrollProxy.LEFT, ScrollProxy.RIGHT
- @_createHorizontalBoundScrollEvent(evt, func, option)
- when ScrollProxy.VISIBLE, ScrollProxy.INVISIBLE
- @_createVisibilityScrollEvent(evt, func, option)
- return this
-
- ###
- Registers events with **on** but just fire the callback the first time
- @example Register an one time event:
- s = new ScrollProxy()
- s.once('top', -> 'I AM ON TOP!') # fires just one time
- @param [String] evt The event name to register
- @param [Function] func The function to callback
- @param [Object] option The wildcard argument that goes with events
- @return [ScrollProxy] This instance
- @since 0.2.0
- ###
- once: (evt, func, option) ->
- oneTimeFunction = =>
- SUtil.reportChange(func, this, @scrollData)
- @off(evt, oneTimeFunction)
- return @on(evt, oneTimeFunction, option)
-
- ###
- Removes all events with the specified event name or name and function
- @example Removing all handlers for one event:
- s = new ScrollProxy()
- s.on('scroll', -> 'Free scrolling')
- s.off('scroll') # no more free scrolling
- @example Removing just the specific function handler for the event
- s = new ScrollProxy()
- func = -> 'Free scrolling'
- s.on('scroll', func)
- s.off('scroll', func)
- @param [String] evt The event name to register
- @return [ScrollProxy] This instance
- @since 0.2.0
- ###
- off: (evt, func) ->
- if not SUtil.isValidEventName(evt) then return this
- for event, i in @_events
- if not func? and event? and evt is event.type
- @_removeEvent(event)
- else if func? and event? and event.origin is func
- @_removeEvent(event)
- return this
-
- ###
- Register this target on ScrollProxy's **_targetList**
- @example Registering a target (constructor does it automatically):
- s = new ScrollProxy()
- s.register() # Throws error because constructor already registered it
- @example Unregistering first will work:
- s = new ScrollProxy()
- s.unregister() # Removing the target
- s.register() # OK. Target already removed, adding it again
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- register: ->
- matchingTarget = ScrollProxy._getElement(@_target)
- if matchingTarget? then throw new Error('Assign one proxy per target')
- ScrollProxy._targetList.push({target: @_target, proxy: this})
- ScrollProxy.activate()
- return this
-
- ###
- Unregister this target and remove it from ScrollProxy's **_targetList**
- @example Unregistering target created automatically by the constructor:
- s = new ScrollProxy()
- s.unregister() # ScrollProxy now has no targets, so it deactivates
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- unregister: ->
- idx = ScrollProxy._targetList.length
- if idx > 0
- # Reverse loop here to avoid messing with the length cache
- while idx--
- if ScrollProxy._targetList[idx].proxy is this
- SUtil.removeItemFromArray(ScrollProxy._targetList, idx)
- break
- if ScrollProxy._targetList.length is 0 then ScrollProxy.deactivate()
- return this
-
- ###
- Checks if the element given is visible in the scroll area of the target
- @example Checking if li is visible within parent ul's scroll area:
- s = new ScrollProxy(ul)
- s.isElementVisible(li) # Visible? May be true or false
- @return [Boolean] Whether it's visible or not
- @since 0.1.0
- ###
- isElementVisible: (el) ->
- @_checkElement(el)
- return @_isRectVisible(@getRect(el))
-
- ###
- Disables hover animations on scrolling to improve scroll performance
- @example It must be activated manually to avoid unexpected behavior:
- s = new ScrollProxy() # defaults to document.body
- s.disableHoverOnScroll() # Hover animations are now disabled on body
- @return [ScrollProxy] This instance
- @since 0.2.0
- ###
- disableHoverOnScroll: ->
- @_createScrollEvent(ScrollProxy.DISABLE_HOVER, =>
- window.clearTimeout(@_hoverTimeout)
- @_target.style.pointerEvents = 'none'
- @_hoverTimeout = window.setTimeout(=>
- @_target.style.pointerEvents = 'auto'
- , @getHoverDelay())
- , null, 0)
- return this
-
- ###
- Re-enables hover animations on scrolling
- @example Once hover animations are disabled, you can re-enable with:
- s = new ScrollProxy() # defaults to document.body
- s.disableHoverOnScroll() # Hover animations on scrolling are now disabled
- s.enableHoverOnScroll() # Hover animations on scrolling are now restored
- @return [ScrollProxy] This instance
- @since 0.1.0
- ###
- enableHoverOnScroll: ->
- @off(ScrollProxy.DISABLE_HOVER)
- @_target.style.pointerEvents = 'auto'
- return this
diff --git a/stylesheets/github-light.css b/stylesheets/github-light.css
new file mode 100644
index 0000000..872a6f4
--- /dev/null
+++ b/stylesheets/github-light.css
@@ -0,0 +1,116 @@
+/*
+ Copyright 2014 GitHub Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+*/
+
+.pl-c /* comment */ {
+ color: #969896;
+}
+
+.pl-c1 /* constant, markup.raw, meta.diff.header, meta.module-reference, meta.property-name, support, support.constant, support.variable, variable.other.constant */,
+.pl-s .pl-v /* string variable */ {
+ color: #0086b3;
+}
+
+.pl-e /* entity */,
+.pl-en /* entity.name */ {
+ color: #795da3;
+}
+
+.pl-s .pl-s1 /* string source */,
+.pl-smi /* storage.modifier.import, storage.modifier.package, storage.type.java, variable.other, variable.parameter.function */ {
+ color: #333;
+}
+
+.pl-ent /* entity.name.tag */ {
+ color: #63a35c;
+}
+
+.pl-k /* keyword, storage, storage.type */ {
+ color: #a71d5d;
+}
+
+.pl-pds /* punctuation.definition.string, string.regexp.character-class */,
+.pl-s /* string */,
+.pl-s .pl-pse .pl-s1 /* string punctuation.section.embedded source */,
+.pl-sr /* string.regexp */,
+.pl-sr .pl-cce /* string.regexp constant.character.escape */,
+.pl-sr .pl-sra /* string.regexp string.regexp.arbitrary-repitition */,
+.pl-sr .pl-sre /* string.regexp source.ruby.embedded */ {
+ color: #183691;
+}
+
+.pl-v /* variable */ {
+ color: #ed6a43;
+}
+
+.pl-id /* invalid.deprecated */ {
+ color: #b52a1d;
+}
+
+.pl-ii /* invalid.illegal */ {
+ background-color: #b52a1d;
+ color: #f8f8f8;
+}
+
+.pl-sr .pl-cce /* string.regexp constant.character.escape */ {
+ color: #63a35c;
+ font-weight: bold;
+}
+
+.pl-ml /* markup.list */ {
+ color: #693a17;
+}
+
+.pl-mh /* markup.heading */,
+.pl-mh .pl-en /* markup.heading entity.name */,
+.pl-ms /* meta.separator */ {
+ color: #1d3e81;
+ font-weight: bold;
+}
+
+.pl-mq /* markup.quote */ {
+ color: #008080;
+}
+
+.pl-mi /* markup.italic */ {
+ color: #333;
+ font-style: italic;
+}
+
+.pl-mb /* markup.bold */ {
+ color: #333;
+ font-weight: bold;
+}
+
+.pl-md /* markup.deleted, meta.diff.header.from-file */ {
+ background-color: #ffecec;
+ color: #bd2c00;
+}
+
+.pl-mi1 /* markup.inserted, meta.diff.header.to-file */ {
+ background-color: #eaffea;
+ color: #55a532;
+}
+
+.pl-mdr /* meta.diff.range */ {
+ color: #795da3;
+ font-weight: bold;
+}
+
+.pl-mo /* meta.output */ {
+ color: #1d3e81;
+}
+
diff --git a/stylesheets/normalize.css b/stylesheets/normalize.css
new file mode 100644
index 0000000..30366a6
--- /dev/null
+++ b/stylesheets/normalize.css
@@ -0,0 +1,424 @@
+/*! normalize.css v3.0.2 | MIT License | git.io/normalize */
+
+/**
+ * 1. Set default font family to sans-serif.
+ * 2. Prevent iOS text size adjust after orientation change, without disabling
+ * user zoom.
+ */
+
+html {
+ font-family: sans-serif; /* 1 */
+ -ms-text-size-adjust: 100%; /* 2 */
+ -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/**
+ * Remove default margin.
+ */
+
+body {
+ margin: 0;
+}
+
+/* HTML5 display definitions
+ ========================================================================== */
+
+/**
+ * Correct `block` display not defined for any HTML5 element in IE 8/9.
+ * Correct `block` display not defined for `details` or `summary` in IE 10/11
+ * and Firefox.
+ * Correct `block` display not defined for `main` in IE 11.
+ */
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+main,
+menu,
+nav,
+section,
+summary {
+ display: block;
+}
+
+/**
+ * 1. Correct `inline-block` display not defined in IE 8/9.
+ * 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
+ */
+
+audio,
+canvas,
+progress,
+video {
+ display: inline-block; /* 1 */
+ vertical-align: baseline; /* 2 */
+}
+
+/**
+ * Prevent modern browsers from displaying `audio` without controls.
+ * Remove excess height in iOS 5 devices.
+ */
+
+audio:not([controls]) {
+ display: none;
+ height: 0;
+}
+
+/**
+ * Address `[hidden]` styling not present in IE 8/9/10.
+ * Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
+ */
+
+[hidden],
+template {
+ display: none;
+}
+
+/* Links
+ ========================================================================== */
+
+/**
+ * Remove the gray background color from active links in IE 10.
+ */
+
+a {
+ background-color: transparent;
+}
+
+/**
+ * Improve readability when focused and also mouse hovered in all browsers.
+ */
+
+a:active,
+a:hover {
+ outline: 0;
+}
+
+/* Text-level semantics
+ ========================================================================== */
+
+/**
+ * Address styling not present in IE 8/9/10/11, Safari, and Chrome.
+ */
+
+abbr[title] {
+ border-bottom: 1px dotted;
+}
+
+/**
+ * Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
+ */
+
+b,
+strong {
+ font-weight: bold;
+}
+
+/**
+ * Address styling not present in Safari and Chrome.
+ */
+
+dfn {
+ font-style: italic;
+}
+
+/**
+ * Address variable `h1` font-size and margin within `section` and `article`
+ * contexts in Firefox 4+, Safari, and Chrome.
+ */
+
+h1 {
+ font-size: 2em;
+ margin: 0.67em 0;
+}
+
+/**
+ * Address styling not present in IE 8/9.
+ */
+
+mark {
+ background: #ff0;
+ color: #000;
+}
+
+/**
+ * Address inconsistent and variable font size in all browsers.
+ */
+
+small {
+ font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` affecting `line-height` in all browsers.
+ */
+
+sub,
+sup {
+ font-size: 75%;
+ line-height: 0;
+ position: relative;
+ vertical-align: baseline;
+}
+
+sup {
+ top: -0.5em;
+}
+
+sub {
+ bottom: -0.25em;
+}
+
+/* Embedded content
+ ========================================================================== */
+
+/**
+ * Remove border when inside `a` element in IE 8/9/10.
+ */
+
+img {
+ border: 0;
+}
+
+/**
+ * Correct overflow not hidden in IE 9/10/11.
+ */
+
+svg:not(:root) {
+ overflow: hidden;
+}
+
+/* Grouping content
+ ========================================================================== */
+
+/**
+ * Address margin not present in IE 8/9 and Safari.
+ */
+
+figure {
+ margin: 1em 40px;
+}
+
+/**
+ * Address differences between Firefox and other browsers.
+ */
+
+hr {
+ box-sizing: content-box;
+ height: 0;
+}
+
+/**
+ * Contain overflow in all browsers.
+ */
+
+pre {
+ overflow: auto;
+}
+
+/**
+ * Address odd `em`-unit font size rendering in all browsers.
+ */
+
+code,
+kbd,
+pre,
+samp {
+ font-family: monospace, monospace;
+ font-size: 1em;
+}
+
+/* Forms
+ ========================================================================== */
+
+/**
+ * Known limitation: by default, Chrome and Safari on OS X allow very limited
+ * styling of `select`, unless a `border` property is set.
+ */
+
+/**
+ * 1. Correct color not being inherited.
+ * Known issue: affects color of disabled elements.
+ * 2. Correct font properties not being inherited.
+ * 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
+ */
+
+button,
+input,
+optgroup,
+select,
+textarea {
+ color: inherit; /* 1 */
+ font: inherit; /* 2 */
+ margin: 0; /* 3 */
+}
+
+/**
+ * Address `overflow` set to `hidden` in IE 8/9/10/11.
+ */
+
+button {
+ overflow: visible;
+}
+
+/**
+ * Address inconsistent `text-transform` inheritance for `button` and `select`.
+ * All other form control elements do not inherit `text-transform` values.
+ * Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
+ * Correct `select` style inheritance in Firefox.
+ */
+
+button,
+select {
+ text-transform: none;
+}
+
+/**
+ * 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
+ * and `video` controls.
+ * 2. Correct inability to style clickable `input` types in iOS.
+ * 3. Improve usability and consistency of cursor style between image-type
+ * `input` and others.
+ */
+
+button,
+html input[type="button"], /* 1 */
+input[type="reset"],
+input[type="submit"] {
+ -webkit-appearance: button; /* 2 */
+ cursor: pointer; /* 3 */
+}
+
+/**
+ * Re-set default cursor for disabled elements.
+ */
+
+button[disabled],
+html input[disabled] {
+ cursor: default;
+}
+
+/**
+ * Remove inner padding and border in Firefox 4+.
+ */
+
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+ border: 0;
+ padding: 0;
+}
+
+/**
+ * Address Firefox 4+ setting `line-height` on `input` using `!important` in
+ * the UA stylesheet.
+ */
+
+input {
+ line-height: normal;
+}
+
+/**
+ * It's recommended that you don't attempt to style these elements.
+ * Firefox's implementation doesn't respect box-sizing, padding, or width.
+ *
+ * 1. Address box sizing set to `content-box` in IE 8/9/10.
+ * 2. Remove excess padding in IE 8/9/10.
+ */
+
+input[type="checkbox"],
+input[type="radio"] {
+ box-sizing: border-box; /* 1 */
+ padding: 0; /* 2 */
+}
+
+/**
+ * Fix the cursor style for Chrome's increment/decrement buttons. For certain
+ * `font-size` values of the `input`, it causes the cursor style of the
+ * decrement button to change from `default` to `text`.
+ */
+
+input[type="number"]::-webkit-inner-spin-button,
+input[type="number"]::-webkit-outer-spin-button {
+ height: auto;
+}
+
+/**
+ * 1. Address `appearance` set to `searchfield` in Safari and Chrome.
+ * 2. Address `box-sizing` set to `border-box` in Safari and Chrome
+ * (include `-moz` to future-proof).
+ */
+
+input[type="search"] {
+ -webkit-appearance: textfield; /* 1 */ /* 2 */
+ box-sizing: content-box;
+}
+
+/**
+ * Remove inner padding and search cancel button in Safari and Chrome on OS X.
+ * Safari (but not Chrome) clips the cancel button when the search input has
+ * padding (and `textfield` appearance).
+ */
+
+input[type="search"]::-webkit-search-cancel-button,
+input[type="search"]::-webkit-search-decoration {
+ -webkit-appearance: none;
+}
+
+/**
+ * Define consistent border, margin, and padding.
+ */
+
+fieldset {
+ border: 1px solid #c0c0c0;
+ margin: 0 2px;
+ padding: 0.35em 0.625em 0.75em;
+}
+
+/**
+ * 1. Correct `color` not being inherited in IE 8/9/10/11.
+ * 2. Remove padding so people aren't caught out if they zero out fieldsets.
+ */
+
+legend {
+ border: 0; /* 1 */
+ padding: 0; /* 2 */
+}
+
+/**
+ * Remove default vertical scrollbar in IE 8/9/10/11.
+ */
+
+textarea {
+ overflow: auto;
+}
+
+/**
+ * Don't inherit the `font-weight` (applied by a rule above).
+ * NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
+ */
+
+optgroup {
+ font-weight: bold;
+}
+
+/* Tables
+ ========================================================================== */
+
+/**
+ * Remove most spacing between table cells.
+ */
+
+table {
+ border-collapse: collapse;
+ border-spacing: 0;
+}
+
+td,
+th {
+ padding: 0;
+}
diff --git a/stylesheets/stylesheet.css b/stylesheets/stylesheet.css
new file mode 100644
index 0000000..7178b20
--- /dev/null
+++ b/stylesheets/stylesheet.css
@@ -0,0 +1,332 @@
+* {
+ box-sizing: border-box; }
+
+body {
+ padding: 0;
+ margin: 0;
+ font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+ font-size: 16px;
+ line-height: 1.5;
+ color: #606c71; }
+
+a {
+ color: #1e6bb8;
+ text-decoration: none; }
+ a:hover {
+ text-decoration: underline; }
+
+.btn {
+ display: inline-block;
+ margin-bottom: 1rem;
+ color: rgba(255, 255, 255, 0.7);
+ background-color: rgba(255, 255, 255, 0.08);
+ border-color: rgba(255, 255, 255, 0.2);
+ border-style: solid;
+ border-width: 1px;
+ border-radius: 0.3rem;
+ transition: color 0.2s, background-color 0.2s, border-color 0.2s; }
+ .btn + .btn {
+ margin-left: 1rem; }
+
+.btn:hover {
+ color: rgba(255, 255, 255, 0.8);
+ text-decoration: none;
+ background-color: rgba(255, 255, 255, 0.2);
+ border-color: rgba(255, 255, 255, 0.3); }
+
+@media screen and (min-width: 64em) {
+ .btn {
+ padding: 0.75rem 1rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .btn {
+ padding: 0.6rem 0.9rem;
+ font-size: 0.9rem; } }
+
+@media screen and (max-width: 42em) {
+ .btn {
+ display: block;
+ width: 100%;
+ padding: 0.75rem;
+ font-size: 0.9rem; }
+ .btn + .btn {
+ margin-top: 1rem;
+ margin-left: 0; } }
+
+.page-header {
+ color: #fff;
+ text-align: center;
+ background-color: #159957;
+ background-image: linear-gradient(120deg, #155799, #159957); }
+
+@media screen and (min-width: 64em) {
+ .page-header {
+ padding: 5rem 6rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .page-header {
+ padding: 3rem 4rem; } }
+
+@media screen and (max-width: 42em) {
+ .page-header {
+ padding: 2rem 1rem; } }
+
+.project-name {
+ margin-top: 0;
+ margin-bottom: 0.1rem; }
+
+@media screen and (min-width: 64em) {
+ .project-name {
+ font-size: 3.25rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .project-name {
+ font-size: 2.25rem; } }
+
+@media screen and (max-width: 42em) {
+ .project-name {
+ font-size: 1.75rem; } }
+
+.project-tagline {
+ margin-bottom: 2rem;
+ font-weight: normal;
+ opacity: 0.7; }
+
+@media screen and (min-width: 64em) {
+ .project-tagline {
+ font-size: 1.25rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .project-tagline {
+ font-size: 1.15rem; } }
+
+@media screen and (max-width: 42em) {
+ .project-tagline {
+ font-size: 1rem; } }
+
+.main-content :first-child {
+ margin-top: 0; }
+.main-content img {
+ max-width: 100%; }
+.main-content h1, .main-content h2, .main-content h3, .main-content h4, .main-content h5, .main-content h6 {
+ margin-top: 2rem;
+ margin-bottom: 1rem;
+ font-weight: normal;
+ color: #159957; }
+.main-content p {
+ margin-bottom: 1em; }
+.main-content code {
+ padding: 2px 4px;
+ font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
+ font-size: 0.9rem;
+ color: #383e41;
+ background-color: #f3f6fa;
+ border-radius: 0.3rem; }
+.main-content pre {
+ padding: 0.8rem;
+ margin-top: 0;
+ margin-bottom: 1rem;
+ font: 1rem Consolas, "Liberation Mono", Menlo, Courier, monospace;
+ color: #567482;
+ word-wrap: normal;
+ background-color: #f3f6fa;
+ border: solid 1px #dce6f0;
+ border-radius: 0.3rem; }
+ .main-content pre > code {
+ padding: 0;
+ margin: 0;
+ font-size: 0.9rem;
+ color: #567482;
+ word-break: normal;
+ white-space: pre;
+ background: transparent;
+ border: 0; }
+.main-content .highlight {
+ margin-bottom: 1rem; }
+ .main-content .highlight pre {
+ margin-bottom: 0;
+ word-break: normal; }
+.main-content .highlight pre, .main-content pre {
+ padding: 0.8rem;
+ overflow: auto;
+ font-size: 0.9rem;
+ line-height: 1.45;
+ border-radius: 0.3rem; }
+.main-content pre code, .main-content pre tt {
+ display: inline;
+ max-width: initial;
+ padding: 0;
+ margin: 0;
+ overflow: initial;
+ line-height: inherit;
+ word-wrap: normal;
+ background-color: transparent;
+ border: 0; }
+ .main-content pre code:before, .main-content pre code:after, .main-content pre tt:before, .main-content pre tt:after {
+ content: normal; }
+.main-content ul, .main-content ol {
+ margin-top: 0; }
+.main-content blockquote {
+ padding: 0 1rem;
+ margin-left: 0;
+ color: #819198;
+ border-left: 0.3rem solid #dce6f0; }
+ .main-content blockquote > :first-child {
+ margin-top: 0; }
+ .main-content blockquote > :last-child {
+ margin-bottom: 0; }
+.main-content table {
+ display: block;
+ width: 100%;
+ overflow: auto;
+ word-break: normal;
+ word-break: keep-all; }
+ .main-content table th {
+ font-weight: bold; }
+ .main-content table th, .main-content table td {
+ padding: 0.5rem 1rem;
+ border: 1px solid #e9ebec; }
+.main-content dl {
+ padding: 0; }
+ .main-content dl dt {
+ padding: 0;
+ margin-top: 1rem;
+ font-size: 1rem;
+ font-weight: bold; }
+ .main-content dl dd {
+ padding: 0;
+ margin-bottom: 1rem; }
+.main-content hr {
+ height: 2px;
+ padding: 0;
+ margin: 1rem 0;
+ background-color: #eff0f1;
+ border: 0; }
+
+@media screen and (min-width: 64em) {
+ .main-content {
+ max-width: 64rem;
+ padding: 2rem 6rem;
+ margin: 0 auto;
+ font-size: 1.1rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .main-content {
+ padding: 2rem 4rem;
+ font-size: 1.1rem; } }
+
+@media screen and (max-width: 42em) {
+ .main-content {
+ padding: 2rem 1rem;
+ font-size: 1rem; } }
+
+.example {
+ width: 100%;
+ max-width: 25rem;
+ border: 1px solid #bbb;
+ border-radius: .3rem;
+ background: #eff0f1;
+ overflow: hidden;
+}
+
+.example .label {
+ width: inherit;
+ height: 2.5rem;
+ padding: .5rem;
+ font-weight: bold;
+ border-bottom: inherit;
+}
+
+.example .scrollable {
+ position: relative;
+ width: 100%;
+ height: 20rem;
+ background: white;
+ box-shadow: inset 0 1px 2px rgba(0,0,0,0.075);
+ overflow-y: scroll;
+}
+
+.xscroll {
+ overflow-x: scroll;
+}
+
+.example .output {
+ width: inherit;
+ padding: .5rem;
+ border-top: inherit;
+}
+
+.example .title {
+ display: block;
+ font-weight: bold;
+}
+
+.example .log {
+ margin-top: 1rem;
+}
+
+.bigDiv {
+ width: 1000px;
+ height: 1000px;
+ padding: 8rem;
+}
+
+.square {
+ position: absolute;
+ top: 100px;
+ left: 100px;
+ width: 5rem;
+ height: 5rem;
+}
+
+.circle {
+ width: 5rem;
+ height: 5rem;
+ border-radius: 100%;
+}
+
+.blue {
+ background: blue;
+}
+
+.red {
+ background: red;
+}
+
+.green {
+ background: #159957;
+ color: white;
+}
+
+.green-btn {
+ background: #159957;
+}
+
+.green-btn:hover {
+ opacity: .5;
+ background: #159957;
+}
+
+.site-footer {
+ padding-top: 2rem;
+ margin-top: 2rem;
+ border-top: solid 1px #eff0f1; }
+
+.site-footer-owner {
+ display: block;
+ font-weight: bold; }
+
+.site-footer-credits {
+ color: #819198; }
+
+@media screen and (min-width: 64em) {
+ .site-footer {
+ font-size: 1rem; } }
+
+@media screen and (min-width: 42em) and (max-width: 64em) {
+ .site-footer {
+ font-size: 1rem; } }
+
+@media screen and (max-width: 42em) {
+ .site-footer {
+ font-size: 0.9rem; } }
diff --git a/test/SUtilSpec.coffee b/test/SUtilSpec.coffee
deleted file mode 100644
index 205a0f3..0000000
--- a/test/SUtilSpec.coffee
+++ /dev/null
@@ -1,95 +0,0 @@
-SUtil = require('../src/SUtil')
-expect = require('chai').expect
-sinon = require('sinon')
-
-describe('SUtil', ->
- describe('when calling back', ->
- it('it should call the functions passed to it', ->
- callback = sinon.spy()
- SUtil.reportChange(callback, this)
- expect(callback.called).to.be.true
- )
-
- it('it return null if it does not receive a function', ->
- result = SUtil.reportChange(1, this)
- expect(result).to.be.null
- )
- )
-
- describe('when testing for valid event names', ->
- it('should assert when asking for "test"', ->
- result = SUtil.isValidEventName('test')
- expect(result).to.be.true
- )
-
- it('should refuse when asking for 1', ->
- result = SUtil.isValidEventName(1)
- expect(result).to.be.false
- )
-
- it('should refuse when asking for empty strings', ->
- result = SUtil.isValidEventName('')
- expect(result).to.be.false
- )
- )
-
- describe('when testing for numbers', ->
- it('should assert when asking for 1', ->
- result = SUtil.isNumber(1)
- expect(result).to.be.true
- )
-
- it('should refuse when asking for "1"', ->
- result = SUtil.isNumber('1')
- expect(result).to.be.false
- )
- )
-
- describe('when testing for positive numbers', ->
- it('should assert when asking for 1', ->
- result = SUtil.isPositiveNumber(1)
- expect(result).to.be.true
- )
-
- it('should assert when asking for 0', ->
- result = SUtil.isPositiveNumber(0)
- expect(result).to.be.true
- )
-
- it('should refuse when asking for -1', ->
- result = SUtil.isPositiveNumber(-1)
- expect(result).to.be.false
- )
- )
-
- describe('when testing for negative numbers', ->
- it('should assert when asking for -1', ->
- result = SUtil.isNegativeNumber(-1)
- expect(result).to.be.true
- )
-
- it('should refuse when asking for 0', ->
- result = SUtil.isNegativeNumber(0)
- expect(result).to.be.false
- )
-
- it('should refuse when asking for 1', ->
- result = SUtil.isNegativeNumber(1)
- expect(result).to.be.false
- )
- )
-
- describe('when removing an item from an array', ->
- it('should remove be able to remove items', ->
- arr = [1, 2, 3]
- SUtil.removeItemFromArray(arr, 0)
- expect(arr).to.eql([2, 3])
- )
-
- it('should return the item removed', ->
- arr = [1, 2, 3]
- result = SUtil.removeItemFromArray(arr, 0)
- expect(result).to.eql(1)
- )
- )
-)
diff --git a/test/ScrollProxySpec.coffee b/test/ScrollProxySpec.coffee
deleted file mode 100644
index 401fc25..0000000
--- a/test/ScrollProxySpec.coffee
+++ /dev/null
@@ -1,990 +0,0 @@
-ScrollProxy = require('../src/ScrollProxy')
-sp = null
-el = null
-square = null
-inner = null
-expect = require('chai').expect
-sinon = require('sinon')
-
-# Temporary shiming PhantomJS lack of the bind function
-Function.prototype.bind = require('function-bind')
-
-describe('ScrollProxy', ->
- @timeout(1000)
- beforeEach(->
- ScrollProxy.clean()
- el = document.createElement('div')
- inner = document.createElement('div')
- square = document.createElement('div')
- square.style.position = 'absolute'
- square.style.width = '50px'
- square.style.height = '50px'
- square.style.top = '0'
- square.style.left = '0'
- inner.style.width = '2000px'
- inner.style.height = '2000px'
- inner.style.margin = '0'
- inner.style.position = 'absolute'
- inner.style.top = '0'
- inner.style.left = '0'
- el.style.width = '200px'
- el.style.height = '200px'
- el.style.margin = '0'
- el.style.padding = '0'
- el.style.position = 'absolute'
- inner.style.margin = '0'
- inner.style.padding = '0'
- el.style.overflow = 'scroll'
- el.appendChild(square)
- el.appendChild(inner)
- document.body.appendChild(el)
- )
- afterEach(->
- document.body.removeChild(el)
- )
- describe('when instantiating', ->
- it('should accept no argument calls and default to document.body', ->
- sp = new ScrollProxy()
- expect(sp.getTarget()).to.eql(document.body)
- )
-
- it('should accept attaching to the window object and remap to body', ->
- sp = new ScrollProxy(window)
- expect(sp.getTarget()).to.eql(document.body)
- )
-
- it('should accept attaching to the document and remap to document.body', ->
- sp = new ScrollProxy(document)
- expect(sp.getTarget()).to.eql(document.body)
- )
-
- it('should accept attaching to an HTMLElement', ->
- myElement = document.createElement('ul')
- sp = new ScrollProxy(myElement)
- expect(sp.getTarget()).to.eql(myElement)
- )
-
- it('should refuse garbage anchors and throw error', ->
- func = -> new ScrollProxy(1)
- expect(func).to.throw(Error)
- )
- )
-
- describe('when cleaning the ScrollProxy object', ->
- it('should clean all targets', ->
- myElement = document.createElement('ul')
- sp = new ScrollProxy(myElement)
- ScrollProxy.clean()
- expect(ScrollProxy._targetList.length).to.eql(0)
- )
- )
-
- describe('when returning information about the scroll element', ->
-
- it('should return 0 for both x and y in the initial state', ->
- sp = new ScrollProxy(el)
- expect(sp.x).to.eql(0)
- expect(sp.y).to.eql(0)
- )
-
- it('it should return the correct values after updating scroll position', ->
- sp = new ScrollProxy(el)
- el.scrollLeft = 20
- el.scrollTop = 20
- sp._updateViewportInfo()
- expect(sp.x).to.eql(20)
- expect(sp.y).to.eql(20)
- )
-
- it('should return the correct initial width and height', ->
- sp = new ScrollProxy(el)
- expect(sp.width).to.eql(200)
- expect(sp.height).to.eql(200)
- )
-
- it('should return the updated value of width and height if resized', ->
- sp = new ScrollProxy(el)
- el.style.width = '3000px'
- el.style.height = '3000px'
- sp._updateViewportInfo()
- expect(sp.width).to.eql(3000)
- expect(sp.height).to.eql(3000)
- )
-
- it('should return the correct initial scrollWidth and scrollHeight', ->
- sp = new ScrollProxy(el)
- expect(sp.scrollWidth).to.eql(2000)
- expect(sp.scrollHeight).to.eql(2000)
- )
-
- it('should return new scrollWidth and scrollHeight when resized', ->
- sp = new ScrollProxy(el)
- inner.style.width = '3000px'
- inner.style.height = '3000px'
- sp._updateViewportInfo()
- expect(sp.scrollWidth).to.eql(3000)
- expect(sp.scrollHeight).to.eql(3000)
- )
- )
-
- describe('when registering', ->
- beforeEach(->
- sp = new ScrollProxy()
- sp.unregister()
- )
- it('should be able to register when it is unregistered', ->
- expect(ScrollProxy._targetList.length).to.eql(0)
- sp.register()
- expect(ScrollProxy._targetList.length).to.eql(1)
- )
-
- it('should activate the ScrollProxy after registering', ->
- expect(ScrollProxy.active).to.be.false
- sp.register()
- expect(ScrollProxy.active).to.be.true
- )
-
- it('should refuse to register more than once', ->
- sp.register()
- func = -> sp.register()
- expect(func).to.throw(Error)
- expect(ScrollProxy.active).to.be.true
- )
-
- it('should not deactivate ScrollProxy when removing one target from two', ->
- sp.register()
- fixture = document.createElement('div')
- sp2 = new ScrollProxy(fixture)
- sp.unregister()
- expect(ScrollProxy._targetList.length).to.eql(1)
- expect(ScrollProxy.active).to.be.true
- )
-
- it('should deactivate ScrollProxy when removing the last target', ->
- sp.register()
- expect(ScrollProxy._targetList.length).to.eql(1)
- sp.unregister()
- expect(ScrollProxy._targetList.length).to.eql(0)
- expect(ScrollProxy.active).to.be.false
- )
- )
-
- describe('when checking for visibility', ->
- it('should throw error if element is not child of the target', ->
- sp = new ScrollProxy(el)
- anotherElement = document.createElement('div')
- func = -> sp.isElementVisible(anotherElement)
- expect(func).to.throw(Error)
- )
-
- it('should return true if the element is visible on view', ->
- sp = new ScrollProxy(el)
- result = sp.isElementVisible(square)
- expect(result).to.be.true
- )
-
- it('should return false if the element is invisible on view', ->
- sp = new ScrollProxy(el)
- el.scrollTop = 100
- el.scollLeft = 100
- result = sp.isElementVisible(square)
- expect(result).to.be.false
- )
- )
-
- describe('when handling scroll', ->
- it('should register a scroll event on window after instantiating', ->
- spy = sinon.spy(ScrollProxy, 'activate')
- sp = new ScrollProxy()
- expect(spy.calledOnce).to.be.true
- )
-
- it('should return immediately when no target is available', ->
- expect(ScrollProxy._handleScroll()).to.be.null
- )
-
- it('should return null when target is available but no events', ->
- sp = new ScrollProxy()
- e = {
- target: document
- }
- item = ScrollProxy._handleScroll(e)
- expect(ScrollProxy._targetList.length).to.eql(1)
- expect(item).to.be.null
- )
-
- it('should return undefined when trying a unregistered target', ->
- sp = new ScrollProxy()
- e = {
- target: document.createElement('div')
- }
- item = ScrollProxy._handleScroll(e)
- expect(ScrollProxy._targetList.length).to.eql(1)
- expect(item).to.eql(undefined)
- )
-
- it('should return the target when it is available and with events', ->
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- e = {
- target: el
- }
- sp.on('scroll', spy)
- item = ScrollProxy._handleScroll(e)
- expect(item).to.eql(el)
- )
- )
-
- describe('when dealing with the scroll delay', ->
- it('should be 250ms by default', ->
- sp = new ScrollProxy()
- expect(sp.getScrollDelay()).to.eql(250)
- )
-
- it('should accept a valid positive number', ->
- sp = new ScrollProxy()
- sp.setScrollDelay(300)
- newDelay = sp.getScrollDelay()
- expect(newDelay).to.eql(300)
- )
-
- it('should round decimal values', ->
- sp = new ScrollProxy()
- sp.setScrollDelay(255.3)
- newDelay = sp.getScrollDelay()
- expect(newDelay).to.eql(255)
- )
-
- it('should ignore wrong changes', ->
- sp = new ScrollProxy()
- sp.setScrollDelay(-1)
- sp.setScrollDelay([])
- sp.setScrollDelay(null)
- sp.setScrollDelay('junk')
- expect(sp.getScrollDelay()).to.eql(250)
- )
- )
-
- describe('when handling events', ->
- it('should not register events with invalid names', ->
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.on(1, spy)
- expect(sp._events.length).to.eql(0)
- )
-
- it('should not register events without callbacks', ->
- junk = 1
- sp = new ScrollProxy(el)
- sp.on('scroll', junk)
- expect(sp._events.length).to.eql(0)
- )
- )
-
- describe('when dealing with the scroll event', ->
- it('should attempt to throttle scroll', (done) ->
- @slow(300)
- spy = sinon.spy(ScrollProxy, '_handleScroll')
- # Waiting for the event to fire
- window.addEventListener('scroll', ->
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 50)
- , true)
- sp = new ScrollProxy(el)
- el.scrollTop = 20
- )
-
- it('should throttle the scrolling', (done) ->
- @slow(500)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 300)
- el.scrollTop = 40
- # Waiting for the event to fire
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollTop = 20
- )
-
- it('should respond to changes on the scroll delay on the fly', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(50)
- func2 = ->
- window.removeEventListener('scroll', func2, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledTwice
- done()
- , 100)
- func = ->
- window.removeEventListener('scroll', func, true)
- window.setTimeout(->
- sp.setScrollDelay(10)
- window.addEventListener('scroll', func2, true)
- el.scrollTop = 40
- , 50)
- # Waiting for the event to fire
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollTop = 20
- )
-
- it('should report just once if registered with once', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(50)
- func2 = ->
- window.removeEventListener('scroll', func2, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce
- done()
- , 100)
- func = ->
- window.removeEventListener('scroll', func, true)
- window.setTimeout(->
- sp.setScrollDelay(10)
- window.addEventListener('scroll', func2, true)
- el.scrollTop = 40
- , 50)
- # Waiting for the event to fire
- window.addEventListener('scroll', func, true)
- sp.once('scroll', spy)
- el.scrollTop = 20
- )
-
- it('should stop reporting if off is called', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(50)
- func2 = ->
- window.removeEventListener('scroll', func2, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce
- done()
- , 100)
- func = ->
- window.removeEventListener('scroll', func, true)
- window.setTimeout(->
- sp.setScrollDelay(10)
- window.addEventListener('scroll', func2, true)
- sp.off('scroll')
- el.scrollTop = 40
- , 50)
- # Waiting for the event to fire
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollTop = 20
- )
-
- it('should remove all the events related if off is called', ->
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.on('scroll', spy)
- sp.on('scroll', spy)
- sp.off('scroll')
- expect(sp._events.length).to.eql(0)
- )
-
- it('should ignore offing an unexistent event', ->
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- expect(sp._events.length).to.eql(0)
- sp.on('scroll', spy)
- expect(sp._events.length).to.eql(1)
- sp.off(1)
- expect(sp._events.length).to.eql(1)
- )
-
- it('should be able to remove a hand picked event', ->
- spy = sinon.spy()
- spy2 = sinon.spy()
- sp = new ScrollProxy(el)
- sp.on('scroll', spy)
- sp.on('scroll', spy2)
- sp._removeEvent(sp._events[0])
- expect(sp._events.length).to.eql(1)
- )
-
- it('should deliver the origin scroll data in callback args', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.args[0][0].target? then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollTop = 20
- )
- )
-
- describe('when dealing with offsetX events', ->
- it('should fire offsetX when scrolling sideways with offset 0', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy)
- el.scrollLeft = 20
- )
-
- it('should not fire offsetX if scrolling vertically', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy)
- el.scrollTop = 20
- )
-
- it('should not fire offsetX before reaching the left offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy, 200)
- el.scrollLeft = 199
- )
-
- it('should fire offsetX when reaching the left offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy, 200)
- el.scrollLeft = 200
- )
-
- it('should fire offsetX for any value past the left offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy, 200)
- el.scrollLeft = 1000
- )
- )
-
- it('should fire offsetX when reaching the right offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy, -200)
- el.scrollLeft = 200
- )
-
- it('should not fire offsetX for any value past the right offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetX', spy, -200)
- el.scrollLeft = 300
- )
-
- describe('when dealing with offsetY events', ->
- it('should fire offsetY when scrolling vertically with offset 0', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy)
- el.scrollTop = 20
- )
-
- it('should not fire offsetY if scrolling sideways', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy)
- el.scrollLeft = 20
- )
-
- it('should not fire offsetY before reaching the bottom offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy, 200)
- el.scrollTop = 199
- )
-
- it('should fire offsetY when reaching the bottom offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy, 200)
- el.scrollTop = 200
- )
-
- it('should fire offsetY for any value past the bottom offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy, 200)
- el.scrollTop = 1000
- )
-
- it('should fire offsetY when reaching the top offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy, -200)
- el.scrollTop = 200
- )
-
- it('should not fire offsetY for any value past the top offset', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if not spy.called then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('offsetY', spy, -200)
- el.scrollTop = 300
- )
- )
-
- describe('when dealing with bound scroll events', ->
- it('should ignore the normal scroll delay', (done) ->
- @slow(300)
- spy = sinon.spy()
- el.scrollTop = 30
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.called then done()
- , 50)
- window.addEventListener('scroll', func, true)
- sp.on('top', spy)
- el.scrollTop = 0
- )
-
- it('should fire top by reaching the top of the viewport', (done) ->
- @slow(300)
- spy = sinon.spy()
- el.scrollTop = 30
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('top', spy)
- el.scrollTop = 0
- )
-
- it('should fire bottom by reaching the bottom of the viewport', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('bottom', spy)
- el.scrollTop = 10000
- )
-
- it('should fire left by reaching the left end of the viewport', (done) ->
- @slow(300)
- spy = sinon.spy()
- el.scrollLeft = 30
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('left', spy)
- el.scrollLeft = 0
- )
-
- it('should fire right by reaching the right end of the viewport', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('right', spy)
- el.scrollLeft = 10000
- )
-
- it('should respect possible top offsets', (done) ->
- @slow(300)
- spy = sinon.spy()
- el.scrollTop = 400
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('top', spy, 200)
- el.scrollTop = 200
- )
-
- it('should respect possible bottom offsets', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('bottom', spy, 200)
- el.scrollTop = 1600
- )
-
- it('should respect possible left offsets', (done) ->
- @slow(300)
- spy = sinon.spy()
- el.scrollLeft = 300
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('left', spy, 100)
- el.scrollLeft = 100
- )
-
- it('should respect possible right offsets', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(250)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 250)
- window.addEventListener('scroll', func, true)
- sp.on('right', spy, 200)
- el.scrollLeft = 1600
- )
- )
-
- describe('when dealing with visibility events', ->
- it('should fire visible once element is on view', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('visible', spy, square)
- el.scrollLeft = 10
- )
-
- it('should fire invisible once element goes out of view', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if spy.calledOnce then done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('invisible', spy, square)
- el.scrollLeft = 500
- )
- )
-
- describe('when setting the hover delay', ->
- it('should be 250ms by default', ->
- sp = new ScrollProxy()
- expect(sp.getHoverDelay()).to.eql(250)
- )
-
- it('should accept a valid positive number', ->
- sp = new ScrollProxy()
- sp.setHoverDelay(300)
- newDelay = sp.getHoverDelay()
- expect(newDelay).to.eql(300)
- )
-
- it('should round decimal values', ->
- sp = new ScrollProxy()
- sp.setHoverDelay(255.3)
- newDelay = sp.getHoverDelay()
- expect(newDelay).to.eql(255)
- )
-
- it('should ignore wrong changes', ->
- sp = new ScrollProxy()
- sp.setHoverDelay(-1)
- sp.setHoverDelay([])
- sp.setHoverDelay(null)
- sp.setHoverDelay('junk')
- expect(sp.getHoverDelay()).to.eql(250)
- )
- )
-
- describe('when dealing with hover scroll', ->
- it('should disable hover on elements when enabled', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- sp.disableHoverOnScroll()
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if el.style.pointerEvents is 'none' then done()
- , 100)
- window.addEventListener('scroll', func, true)
- el.scrollLeft = 500
- )
-
- it('should re-enable after the scroll is done', (done) ->
- @slow(1000)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- sp.setHoverDelay(10)
- sp.disableHoverOnScroll()
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- if el.style.pointerEvents is 'auto' then done()
- , 500)
- window.addEventListener('scroll', func, true)
- el.scrollLeft = 500
- )
-
- it('enableHoverOnScroll should re-enable the hover on scrolling', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- sp.disableHoverOnScroll()
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- sp.enableHoverOnScroll()
- if el.style.pointerEvents is 'auto' then done()
- , 100)
- window.addEventListener('scroll', func, true)
- el.scrollLeft = 500
- )
- )
-
- describe('when receiving events', ->
- it('should set `this` context to the ScrollProxy instance', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- expect(spy.thisValues[0]).to.eql(sp)
- done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollLeft = 500
- )
-
- it('should return up to date values about the view', (done) ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- sp.setScrollDelay(10)
- func = ->
- window.removeEventListener('scroll', func, true)
- # Making sure it's second in order
- window.setTimeout(->
- expect(sp.x).to.eql(el.scrollLeft)
- expect(sp.y).to.eql(el.scrollTop)
- expect(sp.width).to.eql(el.offsetWidth)
- expect(sp.height).to.eql(el.offsetHeight)
- expect(sp.scrollWidth).to.eql(el.scrollWidth)
- expect(sp.scrollHeight).to.eql(el.scrollHeight)
- done()
- , 100)
- window.addEventListener('scroll', func, true)
- sp.on('scroll', spy)
- el.scrollLeft = 500
- )
-
- it('should support method chaining on the API', ->
- @slow(300)
- spy = sinon.spy()
- sp = new ScrollProxy(el)
- chain = sp.setScrollDelay(250)
- .unregister()
- .register()
- .on('scroll', spy)
- .off('scroll')
- .once('scroll', spy)
- .disableHoverOnScroll()
- .enableHoverOnScroll()
- .setScrollDelay(250)
- .setHoverDelay(250)
- expect(sp).to.eql(chain)
- )
- )
-)
diff --git a/test/index.html b/test/index.html
deleted file mode 100644
index 141bf0d..0000000
--- a/test/index.html
+++ /dev/null
@@ -1,41 +0,0 @@
-
-
-
- ScrollProxy Browser Tests
-
-
-
-
-
-
-
-
-[![Build]](https://circleci.com/gh/mkautzmann/scroll-proxy/tree/master) [![SemVer]](http://semver.org/) [![Coverage]](https://coveralls.io/github/mkautzmann/scroll-proxy?branch=master) [![License]](LICENSE)
-
-[](https://saucelabs.com/u/scrollproxy)
-
-## Table of contents
-
- - [Goal](#goal)
- - [Install](#install)
- - [A) I'm using NPM and browserify](#optionA)
- - [B) I love Bower!](#optionB)
- - [C) I'm not into package management...](#optionC)
- - [D) I don't even want to download it, haha](#optionD)
- - [Usage](#usage)
- - [How it works](#how)
- - [Setup](#setup)
- - [Registering scroll events](#on)
- - [Getting metadata](#metadata)
- - [Getting rid of unused events](#off)
- - [Unregistering the `scroll-proxy` instances](#unregistering)
- - [Dealing with animations](#animations)
- - [Other great functionality](#other)
- - [Browser support](#support)
- - [License](#license)
-
-## :scroll: Goal
-
-This package is designed to help dealing with the scroll event in the **browser** in the smoothest way possible.
-
-Yes, web browsers already deliver ways to listen for the scroll event and they work really well. What `scroll-proxy` does is proxy the calls from you to the native scroll event and the other way around, doing some transformations in the process.
-
-It applies some techniques already frequently used by web developers such as **function throttling**, **animation toggling** and a few others on **scroll**-related events. Delivering a small library one can just download and use.
-
-The project's main focus is to help developers achieve great scroll performance in their apps while still being able to implement stuff like **scroll-based animations**, **sticky headers** and **infinite scrolling**.
-
-## :zap: Install
-
-The installation process is pretty straight-forward. Just go to the root folder of your project and follow **one** of the 4 following options:
-
-##### A) I'm using NPM and browserify :sunglasses:
-
-If you use `browserify` and NPM you may install with this command:
-
-`npm install scroll-proxy --save`
-
-##### B) I love Bower! :kissing_closed_eyes:
-
-Bower is another package manager supported. To install, just run:
-
-`bower install scroll-proxy --save`
-
-##### C) I'm not into package management... :worried:
-
-No problem. Just [download the ZIP](https://github.com/mkautzmann/scroll-proxy/archive/master.zip), unzip it and use it! The JS file is inside the `dist` folder.
-
-##### D) I don't even want to download it, haha. :smirk:
-
-You don't have to. You may use it directly via one of the [CDN providers]().
-
-## :beginner: Usage
-
-### How it works
-
-One of the biggest concerns when developing `scroll-proxy` is its interoperability with other libs and frameworks.
-
-So we decided not to change the native scroll handling. Instead, we create a wrapper that can handle everything the native can do and more.
-
-This way we avoid breaking any other lib that may rely on the native scroll event.
-
-The coolest part of the lib is the event handling, you can attach as many events you like but it will only attach one listener to the native `scroll` event in the browser. This practice is often called [event delegation](https://davidwalsh.name/event-delegate).
-
-Please setup the lib and check for yourself.
-
-### Setup
-
-Setting up the library is simple and easy.
-
-Once you've installed it and properly added it to your document via a `script` tag you just have to instantiate a new `ScrollProxy` object.
-
-```javascript
-var myScroll = new ScrollProxy();
-```
-
-You just did it!
-
-Notice that you didn't pass any arguments to the `ScrollProxy` constructor. By default, ScrollProxy will always **attach** to `document.body`. It means it will report actions when the user scrolls the **page**.
-
-If you want to get updates when the user scrolls inside some specific `HTMLElement` you must pass it to the constructor:
-
-```javascript
-var myDiv = document.querySelector('.scrollable');
-var myDivScroll = new ScrollProxy(myDiv);
-```
-
-#### Note for CommonJS/browserify users
-
-The CommonJS module version needs you to `require` ScrollProxy before using it like above.
-
-```javascript
-var ScrollProxy = require("scroll-proxy");
-```
-
-### Registering scroll events
-
-OK, ScrollProxy's set up. Now let's make some cool stuff.
-
-The first thing you might want to do is to get updates whenever the user scrolls the page.
-
-Usually, using just browsers APIs and vanilla JS, you could do that like this:
-
-```javascript
-window.addEventListener('scroll', function() {
- console.log("YAY, I'm scrolling!");
-}, false);
-```
-
-And that would work great.
-
-But note that it bombs your console with a lot of logs. That's because each movement on the scroll area causes one `scroll` event to fire.
-
-That could be fine for logging as it's pretty fast but imagine doing complex calculations or animating stuff based on scroll position. That would be really slow and certainly laggy.
-
-#### Here comes `scroll-proxy` to the rescue!
-
-In `scroll-proxy` registering an event is as easy as calling the `on` function passing the name of the event and the callback function.
-
-```javascript
-var s = new ScrollProxy() // It defaults to document.body, just as we want it
-s.on('scroll', function() {
- console.log("YAY, I'm scrolling!");
-});
-```
-
-Now your `scroll` event belongs to ScrollProxy, it will automatically throttle the event calls with a 250ms delay by default.
-
-That's great for most use cases but you can actually change it on the fly! Take a look:
-
-```javascript
-s.setScrollDelay(100);
-```
-
-Now subsequent events are respecting a 100ms delay. Easy, huh?
-
-You could also just opt to get just a ping when the scroll event happened instead of keep monitoring, the function you are looking for is `once`. It is like `on` but, as the name implies, only fires once.
-
-```javascript
-s.once('scroll', function() {
- console.log("I have just scrolled");
-})
-```
-
-Take your time to compare both vanilla and ScrollProxy implementations and see the difference. It certainly helps tame the frenzy `scroll` event calls.
-
-#### ScrollProxy's custom events
-
-Registering the `scroll` event is not the only thing ScrollProxy can do, actually it has a bunch of other cool events you can listen with the built in `on` and `once` functions.
-
-The full list of events you can rely on:
-
- - `scroll`
- - `offsetX`
- - `offsetY`
- - `top`
- - `bottom`
- - `left`
- - `right`
- - `visible`
- - `invisible`
-
-#### Special events
-
-Some events accept a third argument in the `on` and `once` functions. The presence of this third argument and it's value modify the event handling.
-
-**The offset events**
-
-The `offsetX` and `offsetY` accept a third argument indicating a offset for `scroll-proxy` it to consider when firing the event. Take a look:
-
-```javascript
-var s = new ScrollProxy();
-
-// The following event will fire whenever one scroll the X axis
-s.on('offsetX', function() {
- console.log("It looks like someone scrolled the X axis");
-});
-
-// The next one will only fire when one scrolls past 300px from the left
-s.on('offsetX', function() {
- console.log("I scrolled 300px or more from the left");
-}, 300);
-```
-
-Note the presence of the optional third argument on the second `on` function call. It indicates an **offset** to respect. The same logic applies to the `offsetY` event as well.
-
-**The top, bottom, left and right events**
-
-These kind of events are usually used to determine if the user reached some of the borders of the scroll area. The third argument is useful here when you want to tell `scroll-proxy` to fire the event earlier than normal.
-
-Let's say you want to implement infinite scrolling. You could just load new stuff when the user reaches the bottom of the scroll area, right? Yes, this would work, but wouldn't it be nicer if you could actually load the content **before** the user notices any loading?
-
-For these types of use case the third argument comes handy.
-
-```javascript
-var s = new ScrollProxy();
-
-// Loading new content when user reaches bottom
-s.on('bottom', function() {
- loadMyAwesomeContent();
-});
-
-// Loading new content 200px from bottom, trying to avoid noticeable loading
-s.on('bottom', function() {
- loadMyAwesomeContent();
-}, 200);
-```
-
-**The visible and invisible events**
-
-These are very special events that have limited use cases but sometimes are very welcome.
-
-Both events will only work if the third argument is given. Yes, the third argument is not optional when using either `visible` or `invisible` events.
-
-That's because the events need to check if the element passed in the third argument is visible in the scroll area.
-
-There's another catch: **the element to be checked must be a direct child** of the scroll area `scroll-proxy` is attached to.
-
-You may test this behavior by yourself in the [scroll-proxy website]().
-
-```javascript
-var scrollable = document.querySelector('.scrollable'); // My scroll area
-var square = document.querySelector('.square'); // Direct child of scrollable
-var s = new ScrollProxy(scrollable); // My ScrollProxy instance
-
-// Ping me when square is visible
-s.on('visible', function() {
- console.log("Square is visible");
-}, square);
-```
-
-### Getting metadata
-
-`scroll-proxy` also delivers current information about the scroll area.
-
-You can fetch info about the x and positions, the width and height of the scroll element and also the width and height of the scroll area.
-
-```javascript
-// Consider a window of 800x600 with a 2000x2000 div inside
-var s = new ScrollProxy();
-console.log(s.x); // Will log 0
-console.log(s.y); // Will log 0
-console.log(s.width); // Will log 800
-console.log(s.height); // Will log 600
-console.log(s.scrollWidth); // Will log 2000
-console.log(s.scrollHeight); // Will log 2000
-```
-
-All the info you see above is updated realtime if you registered at least one event with `on`. In fact if you want to use these kind of info inside the event callback you could do like this:
-
-```javascript
-var s = new ScrollProxy();
-s.on('scroll', function() {
- console.log(this.x); // Will log the current x position
- console.log(this.y); // Will log the current y position
-});
-```
-
-### Getting rid of unused events
-
-If you want to remove a event listener created with `on` or cancel an `once` event before it is even fired you can just use `off`.
-
-```javascript
-var s = new ScrollProxy();
-s.on('scroll', function() {
- console.log('YAY!');
-});
-
-s.off('scroll'); // No more YAY! logging
-```
-
-### Unregistering the `scroll-proxy` instances
-
-When you don't want an instance of `scroll-proxy` around anymore you should call `unregister` before losing the variable pointer. That way you assure the memory is clean and the events are released.
-
-```javascript
-var s = new ScrollProxy();
-s.on('scroll', function() {
- console.log('Scrolling');
-});
-
-// Unregistering. Stop event reports and clean stuff
-s.unregister(); // Stopped logging
-
-delete s; // Clear pointer, everything OK
-```
-
-The `register` function can recover unregistered instances and restore all the event handlers.
-
-```javascript
-var s = new ScrollProxy();
-s.on('scroll', function() {
- console.log('Scrolling');
-});
-
-// Unregistering stop event reports
-s.unregister(); // Stopped logging
-
-s.register(); // Logging again on scroll
-```
-
-**Tip!** If you already lost the variable pointing to the `scroll-proxy` instance you can just call `ScrollProxy.clean()` and get rid of all the attachments.
-
-```javascript
-var s = new ScrollProxy(); // Attaching ScrollProxy to document.body
-
-// Getting scroll events
-s.on('scroll', function() {
- console.log('Scrolling...');
-});
-
-delete s; // Remove s reference
-
-// Still getting 'Scrolling...' on scroll, because s.unregister() wasn't called
-
-// Can't s.unregister() now because it's undefined :(
-
-// So clean everything with ScrollProxy.clean()! :)
-ScrollProxy.clean();
-
-// Now it will stop logging and everything is fine again
-```
-
-### Dealing with animations
-
-`scroll-proxy` can be a great partner in your quest for 60FPS animations!
-
-The first thing you need to know is that by using the custom `scroll` event you are already helping your websites performance. As you read earlier it throttles the event firing and all you need to do is select a proper **delay** using `setScrollDelay`.
-
-But, that's not all! There is another trick we built in the library: **animation toggling**. Yes, if you have a long page with a lot of hover animations you should be aware that scrolling that page may result in a janky experience.
-
-To solve that you'll want to use the `disableHoverOnScroll` method. It will disable all hover animations inside the scroll area when the user is scrolling, resulting in a much better experience.
-
-```javascript
-var s = new ScrollProxy();
-s.disableHoverOnScroll();
-```
-
-That's it! Don't worry, all the animations will come back to life once the user stops scrolling. It's all possible thanks to the [pointer-events](https://developer.mozilla.org/pt-BR/docs/Web/CSS/pointer-events) spec.
-
-If you need to enable animations on scroll again for some reason you can do that:
-
-```javascript
-s.enableHoverOnScroll();
-```
-
-Notice that it applies a little delay between the scroll stop and the animation enabling, if you want to change that delay use the `setHoverDelay` method.
-
-```javascript
-// From now on, animations will resume after a 100ms delay after the scroll stop
-s.setHoverDelay(100);
-```
-
-### Other great functionality
-
-There are some other great features in the lib, check the [wiki](https://github.com/mkautzmann/scroll-proxy/wiki) for more information.
-
-## Browser support
-
-This library works with most modern browsers. Some features like the animation toggling require support for the css [pointer-events](https://developer.mozilla.org/pt-BR/docs/Web/CSS/pointer-events) spec.
-
-We test practical support in a handful of browsers over SauceLabs, the support matrix in on the [top of this file](#top).
-
-Theoretical support should include the following browsers:
-
-| 
| 
| 
| 
| 
| 
| Android | iOS |
-| :---: |:---:| :---: | :---: | :---: | :---:| :---: |:---:|
-| 40+ | 11+ | 40+ | 29+ | 8+ | 12+ | 4.0+ | 8+ |
-
-You may get it to work on older browsers as well but some features may not function properly. The table above only states fully supported browsers.
-
-## License
-
-[MIT License](LICENSE) © Matheus Kautzmann
-
-[Build]: https://img.shields.io/circleci/project/mkautzmann/scroll-proxy/master.svg
-[SemVer]: https://img.shields.io/:semver-%E2%9C%93-brightgreen.svg
-[Coverage]: https://img.shields.io/coveralls/mkautzmann/scroll-proxy/master.svg
-[License]: https://img.shields.io/npm/l/scroll-proxy.svg
diff --git a/bower.json b/bower.json
deleted file mode 100644
index 97bf544..0000000
--- a/bower.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
- "name": "scroll-proxy",
- "version": "0.2.1",
- "authors": [
- "Matheus Kautzmann