질문 정정. 자바스크립트로 만들 수 있는 한계...

/*!
 * jQuery JavaScript Library v1.8.3
 * <a href="http://jquery.com/
" rel="nofollow">http://jquery.com/
</a> *
 * Includes Sizzle.js
 * <a href="http://sizzlejs.com/
" rel="nofollow">http://sizzlejs.com/
</a> *
 * Copyright 2012 jQuery Foundation and other contributors
 * Released under the MIT license
 * <a href="http://jquery.org/license
" rel="nofollow">http://jquery.org/license
</a> *
 * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time)
 */
jQuery.fn = jQuery.prototype = {
	constructor: jQuery,
	init: function( selector, context, rootjQuery ) {
		var match, elem, ret, doc;
 
		// Handle $(""), $(null), $(undefined), $(false)
		if ( !selector ) {
			return this;
		}
 
		// Handle $(DOMElement)
		if ( selector.nodeType ) {
			this.context = this[0] = selector;
			this.length = 1;
			return this;
		}
 
		// Handle HTML strings
		if ( typeof selector === "string" ) {
			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
				// Assume that strings that start and end with <> are HTML and skip the regex check
				match = [ null, selector, null ];
 
			} else {
				match = rquickExpr.exec( selector );
			}
 
			// Match html or make sure no context is specified for #id
			if ( match && (match[1] || !context) ) {
 
				// HANDLE: $(html) -> $(array)
				if ( match[1] ) {
					context = context instanceof jQuery ? context[0] : context;
					doc = ( context && context.nodeType ? context.ownerDocument || context : document );
 
					// scripts is true for back-compat
					selector = jQuery.parseHTML( match[1], doc, true );
					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
						this.attr.call( selector, context, true );
					}
 
					return jQuery.merge( this, selector );
 
				// HANDLE: $(#id)
				} else {
					elem = document.getElementById( match[2] );
 
					// Check parentNode to catch when Blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentNode ) {
						// Handle the case where IE and Opera return items
						// by name instead of ID
						if ( elem.id !== match[2] ) {
							return rootjQuery.find( selector );
						}
 
						// Otherwise, we inject the element directly into the jQuery object
						this.length = 1;
						this[0] = elem;
					}
 
					this.context = document;
					this.selector = selector;
					return this;
				}
 
			// HANDLE: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return ( context || rootjQuery ).find( selector );
 
			// HANDLE: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}
 
		// HANDLE: $(function)
		// Shortcut for document ready
		} else if ( jQuery.isFunction( selector ) ) {
			return rootjQuery.ready( selector );
		}
 
		if ( selector.selector !== undefined ) {
			this.selector = selector.selector;
			this.context = selector.context;
		}
 
		return jQuery.makeArray( selector, this );
	},
 
	// Start with an empty selector
	selector: "",
 
	// The current version of jQuery being used
	jquery: "1.8.3",
 
	// The default length of a jQuery object is 0
	length: 0,
 
	// The number of elements contained in the matched element set
	size: function() {
		return this.length;
	},
 
	toArray: function() {
		return core_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 a 'clean' array
			this.toArray() :
 
			// Return just the object
			( num < 0 ? this[ this.length + num ] : this[ num ] );
	},
 
	// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems, name, selector ) {
 
		// 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;
 
		if ( name === "find" ) {
			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
		} else if ( name ) {
			ret.selector = this.selector + "." + name + "(" + selector + ")";
		}
 
		// Return the newly-formed element set
		return ret;
	},
 
	// Execute a callback for every element in the matched set.
	// (You can seed the arguments with an array of args, but this is
	// only used internally.)
	each: function( callback, args ) {
		return jQuery.each( this, callback, args );
	},
 
	ready: function( fn ) {
		// Add the callback
		jQuery.ready.promise().done( fn );
 
		return this;
	},
 
	eq: function( i ) {
		i = +i;
		return i === -1 ?
			this.slice( i ) :
			this.slice( i, i + 1 );
	},
 
	first: function() {
		return this.eq( 0 );
	},
 
	last: function() {
		return this.eq( -1 );
	},
 
	slice: function() {
		return this.pushStack( core_slice.apply( this, arguments ),
			"slice", core_slice.call(arguments).join(",") );
	},
 
	map: function( callback ) {
		return this.pushStack( jQuery.map(this, function( elem, i ) {
			return callback.call( elem, i, elem );
		}));
	},
 
	end: function() {
		return this.prevObject || this.constructor(null);
	},
 
	// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: core_push,
	sort: [].sort,
	splice: [].splice
};
 
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;