text: define( [
      './var/deletedIds',
      './var/document',
      './var/slice',
      './var/concat',
      './var/push',
      './var/indexOf',
      './var/class2type',
      './var/toString',
      './var/hasOwn',
      './var/support'
  ], function( deletedIds, document, slice, concat, push, indexOf,
  	class2type, toString, hasOwn, support ) {
  
      var
          version = '@VERSION',
  
  	// Define a local copy of jQuery
          jQuery = function( selector, context ) {
  
  		// The jQuery object is actually just the init constructor 'enhanced'
  		// Need init if jQuery is called (just allow error to be thrown if not included)
              return new jQuery.fn.init( selector, context );
          },
  
  	// Support: Android<4.1, IE<9
  	// Make sure we trim BOM and NBSP
          rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
  
  	// Matches dashed string for camelizing
          rmsPrefix = /^-ms-/,
          rdashAlpha = /-([\da-z])/gi,
  
  	// Used by jQuery.camelCase as callback to replace()
          fcamelCase = function( all, letter ) {
              return letter.toUpperCase();
          };
  
      jQuery.fn = jQuery.prototype = {
  
  	// The current version of jQuery being used
          jquery: version,
  
          constructor: jQuery,
  
  	// Start with an empty selector
          selector: '',
  
  	// The default length of a jQuery object is 0
          length: 0,
  
          toArray: function() {
              return slice.call( this );
          },
  
  	// Get the Nth element in the matched element set OR
  	// Get the whole matched element set as a clean array
          get: function( num ) {
              return num != null ?
  
  			// Return just the one element from the set
  			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
  
  			// Return all the elements in a clean array
  			slice.call( this );
          },
  
  	// Take an array of elements and push it onto the stack
  	// (returning the new matched element set)
          pushStack: function( elems ) {
  
  		// Build a new jQuery matched element set
              var ret = jQuery.merge( this.constructor(), elems );
  
  		// Add the old object onto the stack (as a reference)
              ret.prevObject = this;
              ret.context = this.context;
  
  		// Return the newly-formed element set
              return ret;
          },
  
  	// Execute a callback for every element in the matched set.
          each: function( callback ) {
              return jQuery.each( this, callback );
          },
  
          map: function( callback ) {
              return this.pushStack( jQuery.map( this, function( elem, i ) {
                  return callback.call( elem, i, elem );
              } ) );
          },
  
          slice: function() {
              return this.pushStack( slice.apply( this, arguments ) );
          },
  
          first: function() {
              return this.eq( 0 );
          },
  
          last: function() {
              return this.eq( -1 );
          },
  
          eq: function( i ) {
              var len = this.length,
                  j = +i + ( i < 0 ? len : 0 );
              return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
          },
  
          end: function() {
              return this.prevObject || this.constructor();
          },
  
  	// For internal use only.
  	// Behaves like an Array's method, not like a jQuery method.
          push: push,
          sort: deletedIds.sort,
          splice: deletedIds.splice
      };
  
      jQuery.extend = jQuery.fn.extend = function() {
          var src, copyIsArray, copy, name, options, clone,
              target = arguments[ 0 ] || {},
              i = 1,
              length = arguments.length,
              deep = false;
  
  	// Handle a deep copy situation
          if ( typeof target === 'boolean' ) {
              deep = target;
  
  		// skip the boolean and the target
              target = arguments[ i ] || {};
              i++;
          }
  
  	// Handle case when target is a string or something (possible in deep copy)
          if ( typeof target !== 'object' && !jQuery.isFunction( target ) ) {
              target = {};
          }
  
  	// extend jQuery itself if only one argument is passed
          if ( i === length ) {
              target = this;
              i--;
          }
  
          for ( ; i < length; i++ ) {
  
  		// Only deal with non-null/undefined values
              if ( ( options = arguments[ i ] ) != null ) {
  
  			// Extend the base object
                  for ( name in options ) {
                      src = target[ name ];
                      copy = options[ name ];
  
  				// Prevent never-ending loop
                      if ( target === copy ) {
                          continue;
                      }
  
  				// Recurse if we're merging plain objects or arrays
                      if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
  					( copyIsArray = jQuery.isArray( copy ) ) ) ) {
  
                          if ( copyIsArray ) {
                              copyIsArray = false;
                              clone = src && jQuery.isArray( src ) ? src : [];
  
                          } else {
                              clone = src && jQuery.isPlainObject( src ) ? src : {};
                          }
  
  					// Never move original objects, clone them
                          target[ name ] = jQuery.extend( deep, clone, copy );
  
  				// Don't bring in undefined values
                      } else if ( copy !== undefined ) {
                          target[ name ] = copy;
                      }
                  }
              }
          }
  
  	// Return the modified object
          return target;
      };
  
      jQuery.extend( {
  
  	// Unique for each copy of jQuery on the page
          expando: 'jQuery' + ( version + Math.random() ).replace( /\D/g, '' ),
  
  	// Assume jQuery is ready without the ready module
          isReady: true,
  
          error: function( msg ) {
              throw new Error( msg );
          },
  
          noop: function() {},
  
  	// See test/unit/core.js for details concerning isFunction.
  	// Since version 1.3, DOM methods and functions like alert
  	// aren't supported. They return false on IE (#2968).
          isFunction: function( obj ) {
              return jQuery.type( obj ) === 'function';
          },
  
          isArray: Array.isArray || function( obj ) {
              return jQuery.type( obj ) === 'array';
          },
  
          isWindow: function( obj ) {
  		/* jshint eqeqeq: false */
              return obj != null && obj == obj.window;
          },
  
          isNumeric: function( obj ) {
  
  		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
  		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  		// subtraction forces infinities to NaN
  		// adding 1 corrects loss of precision from parseFloat (#15100)
              var realStringObj = obj && obj.toString();
              return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
          },
  
          isEmptyObject: function( obj ) {
              var name;
              for ( name in obj ) {
                  return false;
              }
              return true;
          },
  
          isPlainObject: function( obj ) {
              var key;
  
  		// Must be an Object.
  		// Because of IE, we also have to check the presence of the constructor property.
  		// Make sure that DOM nodes and window objects don't pass through, as well
              if ( !obj || jQuery.type( obj ) !== 'object' || obj.nodeType || jQuery.isWindow( obj ) ) {
                  return false;
              }
  
              try {
  
  			// Not own constructor property must be Object
                  if ( obj.constructor &&
  				!hasOwn.call( obj, 'constructor' ) &&
  				!hasOwn.call( obj.constructor.prototype, 'isPrototypeOf' ) ) {
                      return false;
                  }
              } catch ( e ) {
  
  			// IE8,9 Will throw exceptions on certain host objects #9897
                  return false;
              }
  
  		// Support: IE<9
  		// Handle iteration over inherited properties before own properties.
              if ( !support.ownFirst ) {
                  for ( key in obj ) {
                      return hasOwn.call( obj, key );
                  }
              }
  
  		// Own properties are enumerated firstly, so to speed up,
  		// if last one is own, then all properties are own.
              for ( key in obj ) {}
  
              return key === undefined || hasOwn.call( obj, key );
          },
  
          type: function( obj ) {
              if ( obj == null ) {
                  return obj + '';
              }
              return typeof obj === 'object' || typeof obj === 'function' ?
  			class2type[ toString.call( obj ) ] || 'object' :
  			typeof obj;
          },
  
  	// Workarounds based on findings by Jim Driscoll
  	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
          globalEval: function( data ) {
              if ( data && jQuery.trim( data ) ) {
  
  			// We use execScript on Internet Explorer
  			// We use an anonymous function so that context is window
  			// rather than jQuery in Firefox
                  ( window.execScript || function( data ) {
                      window[ 'eval' ].call( window, data ); // jscs:ignore requireDotNotation
                  } )( data );
              }
          },
  
  	// Convert dashed to camelCase; used by the css and data modules
  	// Microsoft forgot to hump their vendor prefix (#9572)
          camelCase: function( string ) {
              return string.replace( rmsPrefix, 'ms-' ).replace( rdashAlpha, fcamelCase );
          },
  
          nodeName: function( elem, name ) {
              return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
          },
  
          each: function( obj, callback ) {
              var length, i = 0;
  
              if ( isArrayLike( obj ) ) {
                  length = obj.length;
                  for ( ; i < length; i++ ) {
                      if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
                          break;
                      }
                  }
              } else {
                  for ( i in obj ) {
                      if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
                          break;
                      }
                  }
              }
  
              return obj;
          },
  
  	// Support: Android<4.1, IE<9
          trim: function( text ) {
              return text == null ?
  			'' :
  			( text + '' ).replace( rtrim, '' );
          },
  
  	// results is for internal usage only
          makeArray: function( arr, results ) {
              var ret = results || [];
  
              if ( arr != null ) {
                  if ( isArrayLike( Object( arr ) ) ) {
                      jQuery.merge( ret,
  					typeof arr === 'string' ?
  					[ arr ] : arr
  				);
                  } else {
                      push.call( ret, arr );
                  }
              }
  
              return ret;
          },
  
          inArray: function( elem, arr, i ) {
              var len;
  
              if ( arr ) {
                  if ( indexOf ) {
                      return indexOf.call( arr, elem, i );
                  }
  
                  len = arr.length;
                  i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
  
                  for ( ; i < len; i++ ) {
  
  				// Skip accessing in sparse arrays
                      if ( i in arr && arr[ i ] === elem ) {
                          return i;
                      }
                  }
              }
  
              return -1;
          },
  
          merge: function( first, second ) {
              var len = +second.length,
                  j = 0,
                  i = first.length;
  
              while ( j < len ) {
                  first[ i++ ] = second[ j++ ];
              }
  
  		// Support: IE<9
  		// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
              if ( len !== len ) {
                  while ( second[ j ] !== undefined ) {
                      first[ i++ ] = second[ j++ ];
                  }
              }
  
              first.length = i;
  
              return first;
          },
  
          grep: function( elems, callback, invert ) {
              var callbackInverse,
                  matches = [],
                  i = 0,
                  length = elems.length,
                  callbackExpect = !invert;
  
  		// Go through the array, only saving the items
  		// that pass the validator function
              for ( ; i < length; i++ ) {
                  callbackInverse = !callback( elems[ i ], i );
                  if ( callbackInverse !== callbackExpect ) {
                      matches.push( elems[ i ] );
                  }
              }
  
              return matches;
          },
  
  	// arg is for internal usage only
          map: function( elems, callback, arg ) {
              var length, value,
                  i = 0,
                  ret = [];
  
  		// Go through the array, translating each of the items to their new values
              if ( isArrayLike( elems ) ) {
                  length = elems.length;
                  for ( ; i < length; i++ ) {
                      value = callback( elems[ i ], i, arg );
  
                      if ( value != null ) {
                          ret.push( value );
                      }
                  }
  
  		// Go through every key on the object,
              } else {
                  for ( i in elems ) {
                      value = callback( elems[ i ], i, arg );
  
                      if ( value != null ) {
                          ret.push( value );
                      }
                  }
              }
  
  		// Flatten any nested arrays
              return concat.apply( [], ret );
          },
  
  	// A global GUID counter for objects
          guid: 1,
  
  	// Bind a function to a context, optionally partially applying any
  	// arguments.
          proxy: function( fn, context ) {
              var args, proxy, tmp;
  
              if ( typeof context === 'string' ) {
                  tmp = fn[ context ];
                  context = fn;
                  fn = tmp;
              }
  
  		// Quick check to determine if target is callable, in the spec
  		// this throws a TypeError, but we will just return undefined.
              if ( !jQuery.isFunction( fn ) ) {
                  return undefined;
              }
  
  		// Simulated bind
              args = slice.call( arguments, 2 );
              proxy = function() {
                  return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
              };
  
  		// Set the guid of unique handler to the same of original handler, so it can be removed
              proxy.guid = fn.guid = fn.guid || jQuery.guid++;
  
              return proxy;
          },
  
          now: function() {
              return +( new Date() );
          },
  
  	// jQuery.support is not used in Core but other projects attach their
  	// properties to it so it needs to exist.
          support: support
      } );
  
  // JSHint would error on this code due to the Symbol not being defined in ES5.
  // Defining this global in .jshintrc would create a danger of using the global
  // unguarded in another place, it seems safer to just disable JSHint for these
  // three lines.
  /* jshint ignore: start */
      if ( typeof Symbol === 'function' ) {
          jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ];
      }
  /* jshint ignore: end */
  
  // Populate the class2type map
      jQuery.each( 'Boolean Number String Function Array Date RegExp Object Error Symbol'.split( ' ' ),
  function( i, name ) {
      class2type[ '[object ' + name + ']' ] = name.toLowerCase();
  } );
  
      function isArrayLike( obj ) {
  
  	// Support: iOS 8.2 (not reproducible in simulator)
  	// `in` check used to prevent JIT error (gh-2145)
  	// hasOwn isn't used here due to false negatives
  	// regarding Nodelist length in IE
          var length = !!obj && 'length' in obj && obj.length,
              type = jQuery.type( obj );
  
          if ( type === 'function' || jQuery.isWindow( obj ) ) {
              return false;
          }
  
          return type === 'array' || length === 0 ||
  		typeof length === 'number' && length > 0 && ( length - 1 ) in obj;
      }
  
      return jQuery;
  } );
  