diff --git a/lib/client/console.js b/lib/client/console.js index 95eddfb4..1539b54c 100644 --- a/lib/client/console.js +++ b/lib/client/console.js @@ -132,13 +132,15 @@ var CloudCmd, Util, DOM, CloudFunc, $; Util.time(Name + ' load'); var lDir = CloudCmd.LIBDIRCLIENT + 'console/', + cssPath = lDir + 'css/', + jsPath = lDir + 'lib/', lCSS = [ - lDir + 'jqconsole.css', - lDir + 'ansi.css' + cssPath + 'jqconsole.css', + cssPath + 'ansi.css' ], lAllCSS = CloudFunc.getJoinURL(lCSS), lFiles = [ - lDir + 'jqconsole.js', + jsPath + 'jqconsole.js', lAllCSS ]; diff --git a/lib/client/console/Cakefile b/lib/client/console/Cakefile index af53e80d..8c3a3300 100644 --- a/lib/client/console/Cakefile +++ b/lib/client/console/Cakefile @@ -9,7 +9,7 @@ task 'watch', 'Build and watch the CoffeeScript source files', -> task 'build', 'Build minified file with uglify', -> console.log 'building...' - exec 'uglifyjs -o jqconsole.min.js lib/jqconsole.js', (err, res)-> + exec 'uglifyjs -m -o jqconsole.min.js lib/jqconsole.js', (err, res)-> if err console.error 'failed with', err else diff --git a/lib/client/console/ChangeLog b/lib/client/console/ChangeLog index 85ae8052..d566ccc0 100644 --- a/lib/client/console/ChangeLog +++ b/lib/client/console/ChangeLog @@ -66,3 +66,11 @@ info. 2013.1.26 Version 2.7.7 * Support for middle click paste on linux. #47. + +2013.8.5 Version 2.7.8 +* Fix issue #51. + +2014.2.3 Version 2.8.0 +* Remove browser sniffing. Fix #37 #42 #53 +* Update android support. Fix #41 +* Add wrapper div for padding/styling of console. Fix #40 diff --git a/lib/client/console/README.md b/lib/client/console/README.md index 7eada46b..7b668e94 100644 --- a/lib/client/console/README.md +++ b/lib/client/console/README.md @@ -134,8 +134,7 @@ Takes two arguments: Sets the number of spaces inserted when indenting and removed when unindenting. Takes one argument: - * __int__ *width*: The code of the key pressing which (when Ctrl is held) will - trigger this shortcut. + * __int__ *width*: The number of spaces in each indentation level. Example: @@ -720,4 +719,8 @@ further customization. ##Contributors [Max Shawabkeh](http://max99x.com/) -[Amjad Masad](http://twitter.com/amjad_masad) +[Amjad Masad](http://twitter.com/amasad) + +## License + +[MIT](http://opensource.org/licenses/MIT) \ No newline at end of file diff --git a/lib/client/console/ansi.css b/lib/client/console/css/ansi.css similarity index 97% rename from lib/client/console/ansi.css rename to lib/client/console/css/ansi.css index e84d4794..281dcf34 100644 --- a/lib/client/console/ansi.css +++ b/lib/client/console/css/ansi.css @@ -1,4 +1,3 @@ - .jqconsole-ansi-bold { /* font-weight: bold; */ } @@ -121,10 +120,10 @@ color: red; } .jqconsole-ansi-color-green { - color: #65b04b; + color: green; } .jqconsole-ansi-color-yellow { - color: #fed563; + color: yellow; } .jqconsole-ansi-color-blue { color: rgb(49,123,249); @@ -146,10 +145,10 @@ background-color: red; } .jqconsole-ansi-background-color-green { - background-color: #65b04b; + background-color: green; } .jqconsole-ansi-background-color-yellow { - background-color: #fed563; + background-color: yellow; } .jqconsole-ansi-background-color-blue { background-color: blue; diff --git a/lib/client/console/jqconsole.css b/lib/client/console/css/jqconsole.css similarity index 100% rename from lib/client/console/jqconsole.css rename to lib/client/console/css/jqconsole.css diff --git a/lib/client/console/demos/echo.html b/lib/client/console/demos/echo.html new file mode 100644 index 00000000..264e3f02 --- /dev/null +++ b/lib/client/console/demos/echo.html @@ -0,0 +1,78 @@ + + + + + + +
+ + + + + diff --git a/lib/client/console/demos/index.html b/lib/client/console/demos/index.html new file mode 100644 index 00000000..6f57b493 --- /dev/null +++ b/lib/client/console/demos/index.html @@ -0,0 +1,120 @@ + + + + + + + +
+ + + + + diff --git a/lib/client/console/jqconsole.jquery.json b/lib/client/console/jqconsole.jquery.json index a42d1945..ad1331df 100644 --- a/lib/client/console/jqconsole.jquery.json +++ b/lib/client/console/jqconsole.jquery.json @@ -1,6 +1,6 @@ { "name": "jqconsole", - "version": "2.7.7", + "version": "2.8.0", "title": "Feature complete web terminal.", "author": { "name": "Amjad Masad", diff --git a/lib/client/console/karma.conf.js b/lib/client/console/karma.conf.js new file mode 100644 index 00000000..df3028a8 --- /dev/null +++ b/lib/client/console/karma.conf.js @@ -0,0 +1,23 @@ +module.exports = function(config) { + config.set({ + frameworks: ["mocha"], + files: [ + 'test/vendor/*.js', + 'lib/*.js', + 'test/setup.coffee', + 'test/ansi-test.coffee', + 'test/jqconsole-test.coffee', + 'test/prompt-test.coffee', + 'test/shortcuts-test.coffee', + 'test/history-test.coffee', + ], + browsers: ['Chrome'], + reporters: ['dots'], + coffeePreprocessor: { + // options passed to the coffee compiler + options: { + bare: false, + } + }, + }); +}; diff --git a/lib/client/console/jqconsole.js b/lib/client/console/lib/jqconsole.js similarity index 89% rename from lib/client/console/jqconsole.js rename to lib/client/console/lib/jqconsole.js index 0561b911..80836fd9 100644 --- a/lib/client/console/jqconsole.js +++ b/lib/client/console/lib/jqconsole.js @@ -1,72 +1,9 @@ -// Generated by CoffeeScript 1.3.3 - +// Generated by CoffeeScript 1.6.3 /* Copyrights 2011, the repl.it project. Licensed under the MIT license */ -// Limit scope pollution from any deprecated API -(function() { - var matched, browser; - -// Use of jQuery.browser is frowned upon. -// More details: http://api.jquery.com/jQuery.browser -// jQuery.uaMatch maintained for back-compat - jQuery.uaMatch = function( ua ) { - ua = ua.toLowerCase(); - - var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) || - /(webkit)[ \/]([\w.]+)/.exec( ua ) || - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) || - /(msie) ([\w.]+)/.exec( ua ) || - ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || - []; - - return { - browser: match[ 1 ] || "", - version: match[ 2 ] || "0" - }; - }; - - matched = jQuery.uaMatch( navigator.userAgent ); - browser = {}; - - if ( matched.browser ) { - browser[ matched.browser ] = true; - browser.version = matched.version; - } - -// Chrome is Webkit, but Webkit is also Safari. - if ( browser.chrome ) { - browser.webkit = true; - } else if ( browser.webkit ) { - browser.safari = true; - } - - jQuery.browser = browser; - - jQuery.sub = function() { - function jQuerySub( selector, context ) { - return new jQuerySub.fn.init( selector, context ); - } - jQuery.extend( true, jQuerySub, this ); - jQuerySub.superclass = this; - jQuerySub.fn = jQuerySub.prototype = this(); - jQuerySub.fn.constructor = jQuerySub; - jQuerySub.sub = this.sub; - jQuerySub.fn.init = function init( selector, context ) { - if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) { - context = jQuerySub( context ); - } - - return jQuery.fn.init.call( this, selector, context, rootjQuerySub ); - }; - jQuerySub.fn.init.prototype = jQuerySub.fn; - var rootjQuerySub = jQuerySub(document); - return jQuerySub; - }; - -})(); (function() { var $, Ansi, CLASS_ANSI, CLASS_BLURRED, CLASS_CURSOR, CLASS_HEADER, CLASS_INPUT, CLASS_OLD_PROMPT, CLASS_PREFIX, CLASS_PROMPT, DEFAULT_INDENT_WIDTH, DEFAULT_PROMPT_CONINUE_LABEL, DEFAULT_PROMPT_LABEL, EMPTY_DIV, EMPTY_SELECTOR, EMPTY_SPAN, ESCAPE_CHAR, ESCAPE_SYNTAX, E_KEYPRESS, JQConsole, KEY_BACKSPACE, KEY_DELETE, KEY_DOWN, KEY_END, KEY_ENTER, KEY_HOME, KEY_LEFT, KEY_PAGE_DOWN, KEY_PAGE_UP, KEY_RIGHT, KEY_TAB, KEY_UP, NEWLINE, STATE_INPUT, STATE_OUTPUT, STATE_PROMPT, spanHtml, @@ -142,24 +79,16 @@ Licensed under the MIT license ESCAPE_SYNTAX = /\[(\d*)(?:;(\d*))*m/; Ansi = (function() { - Ansi.prototype.COLORS = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white']; function Ansi() { this.stylize = __bind(this.stylize, this); - this._closeSpan = __bind(this._closeSpan, this); - this._openSpan = __bind(this._openSpan, this); - this.getClasses = __bind(this.getClasses, this); - this._style = __bind(this._style, this); - this._color = __bind(this._color, this); - this._remove = __bind(this._remove, this); - this._append = __bind(this._append, this); this.klasses = []; } @@ -344,27 +273,16 @@ Licensed under the MIT license }; JQConsole = (function() { - - function JQConsole(container, header, prompt_label, prompt_continue_label) { - this.container = container; + function JQConsole(outer_container, header, prompt_label, prompt_continue_label) { this._HideComposition = __bind(this._HideComposition, this); - this._ShowComposition = __bind(this._ShowComposition, this); - this._UpdateComposition = __bind(this._UpdateComposition, this); - this._EndComposition = __bind(this._EndComposition, this); - this._StartComposition = __bind(this._StartComposition, this); - this._CheckComposition = __bind(this._CheckComposition, this); - this._ProcessMatch = __bind(this._ProcessMatch, this); - this._HandleKey = __bind(this._HandleKey, this); - this._HandleChar = __bind(this._HandleChar, this); - this.isMobile = !!navigator.userAgent.match(/iPhone|iPad|iPod|Android/i); this.isIos = !!navigator.userAgent.match(/iPhone|iPad|iPod/i); this.isAndroid = !!navigator.userAgent.match(/Android/i); @@ -382,26 +300,41 @@ Licensed under the MIT license this.history_new = ''; this.history_active = false; this.shortcuts = {}; - this.$console = $('
').appendTo(this.container);
+      this.$container = $('
').appendTo(outer_container);
+      this.$container.css({
+        'top': 0,
+        'left': 0,
+        'right': 0,
+        'bottom': 0,
+        'position': 'absolute',
+        'overflow': 'auto'
+      });
+      this.$console = $('
').appendTo(this.$container);
       this.$console.css({
-        position: 'absolute',
-        top: 0,
-        bottom: 0,
-        right: 0,
-        left: 0,
-        margin: 0,
-        overflow: 'auto'
+        'margin': 0,
+        'position': 'relative',
+        'min-height': '100%',
+        'box-sizing': 'border-box',
+        '-moz-box-sizing': 'border-box',
+        '-webkit-box-sizing': 'border-box'
       });
       this.$console_focused = true;
-      this.$input_container = $(EMPTY_DIV).appendTo(this.container);
+      this.$input_container = $(EMPTY_DIV).appendTo(this.$container);
       this.$input_container.css({
-        position: 'relative',
+        position: 'absolute',
         width: 1,
         height: 0,
         overflow: 'hidden'
       });
-      this.$input_source = $('";
+  support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
+})();
+var strundefined = typeof undefined;
+
+
+
+support.focusinBubbles = "onfocusin" in window;
+
+
+var
+  rkeyEvent = /^key/,
+  rmouseEvent = /^(?:mouse|contextmenu)|click/,
+  rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+  rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
+
+function returnTrue() {
+  return true;
+}
+
+function returnFalse() {
+  return false;
+}
+
+function safeActiveElement() {
+  try {
+    return document.activeElement;
+  } catch ( err ) { }
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+  global: {},
+
+  add: function( elem, types, handler, data, selector ) {
+
+    var handleObjIn, eventHandle, tmp,
+      events, t, handleObj,
+      special, handlers, type, namespaces, origType,
+      elemData = data_priv.get( elem );
+
+    // Don't attach events to noData or text/comment nodes (but allow plain objects)
+    if ( !elemData ) {
+      return;
+    }
+
+    // Caller can pass in an object of custom data in lieu of the handler
+    if ( handler.handler ) {
+      handleObjIn = handler;
+      handler = handleObjIn.handler;
+      selector = handleObjIn.selector;
+    }
+
+    // Make sure that the handler has a unique ID, used to find/remove it later
+    if ( !handler.guid ) {
+      handler.guid = jQuery.guid++;
+    }
+
+    // Init the element's event structure and main handler, if this is the first
+    if ( !(events = elemData.events) ) {
+      events = elemData.events = {};
+    }
+    if ( !(eventHandle = elemData.handle) ) {
+      eventHandle = elemData.handle = function( e ) {
+        // Discard the second event of a jQuery.event.trigger() and
+        // when an event is called after a page has unloaded
+        return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ?
+          jQuery.event.dispatch.apply( elem, arguments ) : undefined;
+      };
+    }
+
+    // Handle multiple events separated by a space
+    types = ( types || "" ).match( rnotwhite ) || [ "" ];
+    t = types.length;
+    while ( t-- ) {
+      tmp = rtypenamespace.exec( types[t] ) || [];
+      type = origType = tmp[1];
+      namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+      // There *must* be a type, no attaching namespace-only handlers
+      if ( !type ) {
+        continue;
+      }
+
+      // If event changes its type, use the special event handlers for the changed type
+      special = jQuery.event.special[ type ] || {};
+
+      // If selector defined, determine special event api type, otherwise given type
+      type = ( selector ? special.delegateType : special.bindType ) || type;
+
+      // Update special based on newly reset type
+      special = jQuery.event.special[ type ] || {};
+
+      // handleObj is passed to all event handlers
+      handleObj = jQuery.extend({
+        type: type,
+        origType: origType,
+        data: data,
+        handler: handler,
+        guid: handler.guid,
+        selector: selector,
+        needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+        namespace: namespaces.join(".")
+      }, handleObjIn );
+
+      // Init the event handler queue if we're the first
+      if ( !(handlers = events[ type ]) ) {
+        handlers = events[ type ] = [];
+        handlers.delegateCount = 0;
+
+        // Only use addEventListener if the special events handler returns false
+        if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+          if ( elem.addEventListener ) {
+            elem.addEventListener( type, eventHandle, false );
+          }
+        }
+      }
+
+      if ( special.add ) {
+        special.add.call( elem, handleObj );
+
+        if ( !handleObj.handler.guid ) {
+          handleObj.handler.guid = handler.guid;
+        }
+      }
+
+      // Add to the element's handler list, delegates in front
+      if ( selector ) {
+        handlers.splice( handlers.delegateCount++, 0, handleObj );
+      } else {
+        handlers.push( handleObj );
+      }
+
+      // Keep track of which events have ever been used, for event optimization
+      jQuery.event.global[ type ] = true;
+    }
+
+  },
+
+  // Detach an event or set of events from an element
+  remove: function( elem, types, handler, selector, mappedTypes ) {
+
+    var j, origCount, tmp,
+      events, t, handleObj,
+      special, handlers, type, namespaces, origType,
+      elemData = data_priv.hasData( elem ) && data_priv.get( elem );
+
+    if ( !elemData || !(events = elemData.events) ) {
+      return;
+    }
+
+    // Once for each type.namespace in types; type may be omitted
+    types = ( types || "" ).match( rnotwhite ) || [ "" ];
+    t = types.length;
+    while ( t-- ) {
+      tmp = rtypenamespace.exec( types[t] ) || [];
+      type = origType = tmp[1];
+      namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+      // Unbind all events (on this namespace, if provided) for the element
+      if ( !type ) {
+        for ( type in events ) {
+          jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+        }
+        continue;
+      }
+
+      special = jQuery.event.special[ type ] || {};
+      type = ( selector ? special.delegateType : special.bindType ) || type;
+      handlers = events[ type ] || [];
+      tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
+
+      // Remove matching events
+      origCount = j = handlers.length;
+      while ( j-- ) {
+        handleObj = handlers[ j ];
+
+        if ( ( mappedTypes || origType === handleObj.origType ) &&
+          ( !handler || handler.guid === handleObj.guid ) &&
+          ( !tmp || tmp.test( handleObj.namespace ) ) &&
+          ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
+          handlers.splice( j, 1 );
+
+          if ( handleObj.selector ) {
+            handlers.delegateCount--;
+          }
+          if ( special.remove ) {
+            special.remove.call( elem, handleObj );
+          }
+        }
+      }
+
+      // Remove generic event handler if we removed something and no more handlers exist
+      // (avoids potential for endless recursion during removal of special event handlers)
+      if ( origCount && !handlers.length ) {
+        if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+          jQuery.removeEvent( elem, type, elemData.handle );
+        }
+
+        delete events[ type ];
+      }
+    }
+
+    // Remove the expando if it's no longer used
+    if ( jQuery.isEmptyObject( events ) ) {
+      delete elemData.handle;
+      data_priv.remove( elem, "events" );
+    }
+  },
+
+  trigger: function( event, data, elem, onlyHandlers ) {
+
+    var i, cur, tmp, bubbleType, ontype, handle, special,
+      eventPath = [ elem || document ],
+      type = hasOwn.call( event, "type" ) ? event.type : event,
+      namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
+
+    cur = tmp = elem = elem || document;
+
+    // Don't do events on text and comment nodes
+    if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+      return;
+    }
+
+    // focus/blur morphs to focusin/out; ensure we're not firing them right now
+    if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+      return;
+    }
+
+    if ( type.indexOf(".") >= 0 ) {
+      // Namespaced trigger; create a regexp to match event type in handle()
+      namespaces = type.split(".");
+      type = namespaces.shift();
+      namespaces.sort();
+    }
+    ontype = type.indexOf(":") < 0 && "on" + type;
+
+    // Caller can pass in a jQuery.Event object, Object, or just an event type string
+    event = event[ jQuery.expando ] ?
+      event :
+      new jQuery.Event( type, typeof event === "object" && event );
+
+    // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+    event.isTrigger = onlyHandlers ? 2 : 3;
+    event.namespace = namespaces.join(".");
+    event.namespace_re = event.namespace ?
+      new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
+      null;
+
+    // Clean up the event in case it is being reused
+    event.result = undefined;
+    if ( !event.target ) {
+      event.target = elem;
+    }
+
+    // Clone any incoming data and prepend the event, creating the handler arg list
+    data = data == null ?
+      [ event ] :
+      jQuery.makeArray( data, [ event ] );
+
+    // Allow special events to draw outside the lines
+    special = jQuery.event.special[ type ] || {};
+    if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+      return;
+    }
+
+    // Determine event propagation path in advance, per W3C events spec (#9951)
+    // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+    if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+
+      bubbleType = special.delegateType || type;
+      if ( !rfocusMorph.test( bubbleType + type ) ) {
+        cur = cur.parentNode;
+      }
+      for ( ; cur; cur = cur.parentNode ) {
+        eventPath.push( cur );
+        tmp = cur;
+      }
+
+      // Only add window if we got to document (e.g., not plain obj or detached DOM)
+      if ( tmp === (elem.ownerDocument || document) ) {
+        eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+      }
+    }
+
+    // Fire handlers on the event path
+    i = 0;
+    while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
+
+      event.type = i > 1 ?
+        bubbleType :
+        special.bindType || type;
+
+      // jQuery handler
+      handle = ( data_priv.get( cur, "events" ) || {} )[ event.type ] && data_priv.get( cur, "handle" );
+      if ( handle ) {
+        handle.apply( cur, data );
+      }
+
+      // Native handler
+      handle = ontype && cur[ ontype ];
+      if ( handle && handle.apply && jQuery.acceptData( cur ) ) {
+        event.result = handle.apply( cur, data );
+        if ( event.result === false ) {
+          event.preventDefault();
+        }
+      }
+    }
+    event.type = type;
+
+    // If nobody prevented the default action, do it now
+    if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+      if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) &&
+        jQuery.acceptData( elem ) ) {
+
+        // Call a native DOM method on the target with the same name name as the event.
+        // Don't do default actions on window, that's where global variables be (#6170)
+        if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
+
+          // Don't re-trigger an onFOO event when we call its FOO() method
+          tmp = elem[ ontype ];
+
+          if ( tmp ) {
+            elem[ ontype ] = null;
+          }
+
+          // Prevent re-triggering of the same event, since we already bubbled it above
+          jQuery.event.triggered = type;
+          elem[ type ]();
+          jQuery.event.triggered = undefined;
+
+          if ( tmp ) {
+            elem[ ontype ] = tmp;
+          }
+        }
+      }
+    }
+
+    return event.result;
+  },
+
+  dispatch: function( event ) {
+
+    // Make a writable jQuery.Event from the native event object
+    event = jQuery.event.fix( event );
+
+    var i, j, ret, matched, handleObj,
+      handlerQueue = [],
+      args = slice.call( arguments ),
+      handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [],
+      special = jQuery.event.special[ event.type ] || {};
+
+    // Use the fix-ed jQuery.Event rather than the (read-only) native event
+    args[0] = event;
+    event.delegateTarget = this;
+
+    // Call the preDispatch hook for the mapped type, and let it bail if desired
+    if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+      return;
+    }
+
+    // Determine handlers
+    handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+    // Run delegates first; they may want to stop propagation beneath us
+    i = 0;
+    while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
+      event.currentTarget = matched.elem;
+
+      j = 0;
+      while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
+
+        // Triggered event must either 1) have no namespace, or
+        // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+        if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
+
+          event.handleObj = handleObj;
+          event.data = handleObj.data;
+
+          ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
+              .apply( matched.elem, args );
+
+          if ( ret !== undefined ) {
+            if ( (event.result = ret) === false ) {
+              event.preventDefault();
+              event.stopPropagation();
+            }
+          }
+        }
+      }
+    }
+
+    // Call the postDispatch hook for the mapped type
+    if ( special.postDispatch ) {
+      special.postDispatch.call( this, event );
+    }
+
+    return event.result;
+  },
+
+  handlers: function( event, handlers ) {
+    var i, matches, sel, handleObj,
+      handlerQueue = [],
+      delegateCount = handlers.delegateCount,
+      cur = event.target;
+
+    // Find delegate handlers
+    // Black-hole SVG  instance trees (#13180)
+    // Avoid non-left-click bubbling in Firefox (#3861)
+    if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
+
+      for ( ; cur !== this; cur = cur.parentNode || this ) {
+
+        // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+        if ( cur.disabled !== true || event.type !== "click" ) {
+          matches = [];
+          for ( i = 0; i < delegateCount; i++ ) {
+            handleObj = handlers[ i ];
+
+            // Don't conflict with Object.prototype properties (#13203)
+            sel = handleObj.selector + " ";
+
+            if ( matches[ sel ] === undefined ) {
+              matches[ sel ] = handleObj.needsContext ?
+                jQuery( sel, this ).index( cur ) >= 0 :
+                jQuery.find( sel, this, null, [ cur ] ).length;
+            }
+            if ( matches[ sel ] ) {
+              matches.push( handleObj );
+            }
+          }
+          if ( matches.length ) {
+            handlerQueue.push({ elem: cur, handlers: matches });
+          }
+        }
+      }
+    }
+
+    // Add the remaining (directly-bound) handlers
+    if ( delegateCount < handlers.length ) {
+      handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
+    }
+
+    return handlerQueue;
+  },
+
+  // Includes some event props shared by KeyEvent and MouseEvent
+  props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
+
+  fixHooks: {},
+
+  keyHooks: {
+    props: "char charCode key keyCode".split(" "),
+    filter: function( event, original ) {
+
+      // Add which for key events
+      if ( event.which == null ) {
+        event.which = original.charCode != null ? original.charCode : original.keyCode;
+      }
+
+      return event;
+    }
+  },
+
+  mouseHooks: {
+    props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
+    filter: function( event, original ) {
+      var eventDoc, doc, body,
+        button = original.button;
+
+      // Calculate pageX/Y if missing and clientX/Y available
+      if ( event.pageX == null && original.clientX != null ) {
+        eventDoc = event.target.ownerDocument || document;
+        doc = eventDoc.documentElement;
+        body = eventDoc.body;
+
+        event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+        event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
+      }
+
+      // Add which for click: 1 === left; 2 === middle; 3 === right
+      // Note: button is not normalized, so don't use it
+      if ( !event.which && button !== undefined ) {
+        event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
+      }
+
+      return event;
+    }
+  },
+
+  fix: function( event ) {
+    if ( event[ jQuery.expando ] ) {
+      return event;
+    }
+
+    // Create a writable copy of the event object and normalize some properties
+    var i, prop, copy,
+      type = event.type,
+      originalEvent = event,
+      fixHook = this.fixHooks[ type ];
+
+    if ( !fixHook ) {
+      this.fixHooks[ type ] = fixHook =
+        rmouseEvent.test( type ) ? this.mouseHooks :
+        rkeyEvent.test( type ) ? this.keyHooks :
+        {};
+    }
+    copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
+
+    event = new jQuery.Event( originalEvent );
+
+    i = copy.length;
+    while ( i-- ) {
+      prop = copy[ i ];
+      event[ prop ] = originalEvent[ prop ];
+    }
+
+    // Support: Cordova 2.5 (WebKit) (#13255)
+    // All events should have a target; Cordova deviceready doesn't
+    if ( !event.target ) {
+      event.target = document;
+    }
+
+    // Support: Safari 6.0+, Chrome < 28
+    // Target should not be a text node (#504, #13143)
+    if ( event.target.nodeType === 3 ) {
+      event.target = event.target.parentNode;
+    }
+
+    return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
+  },
+
+  special: {
+    load: {
+      // Prevent triggered image.load events from bubbling to window.load
+      noBubble: true
+    },
+    focus: {
+      // Fire native event if possible so blur/focus sequence is correct
+      trigger: function() {
+        if ( this !== safeActiveElement() && this.focus ) {
+          this.focus();
+          return false;
+        }
+      },
+      delegateType: "focusin"
+    },
+    blur: {
+      trigger: function() {
+        if ( this === safeActiveElement() && this.blur ) {
+          this.blur();
+          return false;
+        }
+      },
+      delegateType: "focusout"
+    },
+    click: {
+      // For checkbox, fire native event so checked state will be right
+      trigger: function() {
+        if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
+          this.click();
+          return false;
+        }
+      },
+
+      // For cross-browser consistency, don't fire native .click() on links
+      _default: function( event ) {
+        return jQuery.nodeName( event.target, "a" );
+      }
+    },
+
+    beforeunload: {
+      postDispatch: function( event ) {
+
+        // Support: Firefox 20+
+        // Firefox doesn't alert if the returnValue field is not set.
+        if ( event.result !== undefined ) {
+          event.originalEvent.returnValue = event.result;
+        }
+      }
+    }
+  },
+
+  simulate: function( type, elem, event, bubble ) {
+    // Piggyback on a donor event to simulate a different one.
+    // Fake originalEvent to avoid donor's stopPropagation, but if the
+    // simulated event prevents default then we do the same on the donor.
+    var e = jQuery.extend(
+      new jQuery.Event(),
+      event,
+      {
+        type: type,
+        isSimulated: true,
+        originalEvent: {}
+      }
+    );
+    if ( bubble ) {
+      jQuery.event.trigger( e, null, elem );
+    } else {
+      jQuery.event.dispatch.call( elem, e );
+    }
+    if ( e.isDefaultPrevented() ) {
+      event.preventDefault();
+    }
+  }
+};
+
+jQuery.removeEvent = function( elem, type, handle ) {
+  if ( elem.removeEventListener ) {
+    elem.removeEventListener( type, handle, false );
+  }
+};
+
+jQuery.Event = function( src, props ) {
+  // Allow instantiation without the 'new' keyword
+  if ( !(this instanceof jQuery.Event) ) {
+    return new jQuery.Event( src, props );
+  }
+
+  // Event object
+  if ( src && src.type ) {
+    this.originalEvent = src;
+    this.type = src.type;
+
+    // Events bubbling up the document may have been marked as prevented
+    // by a handler lower down the tree; reflect the correct value.
+    this.isDefaultPrevented = src.defaultPrevented ||
+        // Support: Android < 4.0
+        src.defaultPrevented === undefined &&
+        src.getPreventDefault && src.getPreventDefault() ?
+      returnTrue :
+      returnFalse;
+
+  // Event type
+  } else {
+    this.type = src;
+  }
+
+  // Put explicitly provided properties onto the event object
+  if ( props ) {
+    jQuery.extend( this, props );
+  }
+
+  // Create a timestamp if incoming event doesn't have one
+  this.timeStamp = src && src.timeStamp || jQuery.now();
+
+  // Mark it as fixed
+  this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+  isDefaultPrevented: returnFalse,
+  isPropagationStopped: returnFalse,
+  isImmediatePropagationStopped: returnFalse,
+
+  preventDefault: function() {
+    var e = this.originalEvent;
+
+    this.isDefaultPrevented = returnTrue;
+
+    if ( e && e.preventDefault ) {
+      e.preventDefault();
+    }
+  },
+  stopPropagation: function() {
+    var e = this.originalEvent;
+
+    this.isPropagationStopped = returnTrue;
+
+    if ( e && e.stopPropagation ) {
+      e.stopPropagation();
+    }
+  },
+  stopImmediatePropagation: function() {
+    this.isImmediatePropagationStopped = returnTrue;
+    this.stopPropagation();
+  }
+};
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+// Support: Chrome 15+
+jQuery.each({
+  mouseenter: "mouseover",
+  mouseleave: "mouseout"
+}, function( orig, fix ) {
+  jQuery.event.special[ orig ] = {
+    delegateType: fix,
+    bindType: fix,
+
+    handle: function( event ) {
+      var ret,
+        target = this,
+        related = event.relatedTarget,
+        handleObj = event.handleObj;
+
+      // For mousenter/leave call the handler if related is outside the target.
+      // NB: No relatedTarget if the mouse left/entered the browser window
+      if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
+        event.type = handleObj.origType;
+        ret = handleObj.handler.apply( this, arguments );
+        event.type = fix;
+      }
+      return ret;
+    }
+  };
+});
+
+// Create "bubbling" focus and blur events
+// Support: Firefox, Chrome, Safari
+if ( !support.focusinBubbles ) {
+  jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+    // Attach a single capturing handler on the document while someone wants focusin/focusout
+    var handler = function( event ) {
+        jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
+      };
+
+    jQuery.event.special[ fix ] = {
+      setup: function() {
+        var doc = this.ownerDocument || this,
+          attaches = data_priv.access( doc, fix );
+
+        if ( !attaches ) {
+          doc.addEventListener( orig, handler, true );
+        }
+        data_priv.access( doc, fix, ( attaches || 0 ) + 1 );
+      },
+      teardown: function() {
+        var doc = this.ownerDocument || this,
+          attaches = data_priv.access( doc, fix ) - 1;
+
+        if ( !attaches ) {
+          doc.removeEventListener( orig, handler, true );
+          data_priv.remove( doc, fix );
+
+        } else {
+          data_priv.access( doc, fix, attaches );
+        }
+      }
+    };
+  });
+}
+
+jQuery.fn.extend({
+
+  on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
+    var origFn, type;
+
+    // Types can be a map of types/handlers
+    if ( typeof types === "object" ) {
+      // ( types-Object, selector, data )
+      if ( typeof selector !== "string" ) {
+        // ( types-Object, data )
+        data = data || selector;
+        selector = undefined;
+      }
+      for ( type in types ) {
+        this.on( type, selector, data, types[ type ], one );
+      }
+      return this;
+    }
+
+    if ( data == null && fn == null ) {
+      // ( types, fn )
+      fn = selector;
+      data = selector = undefined;
+    } else if ( fn == null ) {
+      if ( typeof selector === "string" ) {
+        // ( types, selector, fn )
+        fn = data;
+        data = undefined;
+      } else {
+        // ( types, data, fn )
+        fn = data;
+        data = selector;
+        selector = undefined;
+      }
+    }
+    if ( fn === false ) {
+      fn = returnFalse;
+    } else if ( !fn ) {
+      return this;
+    }
+
+    if ( one === 1 ) {
+      origFn = fn;
+      fn = function( event ) {
+        // Can use an empty set, since event contains the info
+        jQuery().off( event );
+        return origFn.apply( this, arguments );
+      };
+      // Use same guid so caller can remove using origFn
+      fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+    }
+    return this.each( function() {
+      jQuery.event.add( this, types, fn, data, selector );
+    });
+  },
+  one: function( types, selector, data, fn ) {
+    return this.on( types, selector, data, fn, 1 );
+  },
+  off: function( types, selector, fn ) {
+    var handleObj, type;
+    if ( types && types.preventDefault && types.handleObj ) {
+      // ( event )  dispatched jQuery.Event
+      handleObj = types.handleObj;
+      jQuery( types.delegateTarget ).off(
+        handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
+        handleObj.selector,
+        handleObj.handler
+      );
+      return this;
+    }
+    if ( typeof types === "object" ) {
+      // ( types-object [, selector] )
+      for ( type in types ) {
+        this.off( type, selector, types[ type ] );
+      }
+      return this;
+    }
+    if ( selector === false || typeof selector === "function" ) {
+      // ( types [, fn] )
+      fn = selector;
+      selector = undefined;
+    }
+    if ( fn === false ) {
+      fn = returnFalse;
+    }
+    return this.each(function() {
+      jQuery.event.remove( this, types, fn, selector );
+    });
+  },
+
+  trigger: function( type, data ) {
+    return this.each(function() {
+      jQuery.event.trigger( type, data, this );
+    });
+  },
+  triggerHandler: function( type, data ) {
+    var elem = this[0];
+    if ( elem ) {
+      return jQuery.event.trigger( type, data, elem, true );
+    }
+  }
+});
+
+
+var
+  rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
+  rtagName = /<([\w:]+)/,
+  rhtml = /<|&#?\w+;/,
+  rnoInnerhtml = /<(?:script|style|link)/i,
+  // checked="checked" or checked
+  rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+  rscriptType = /^$|\/(?:java|ecma)script/i,
+  rscriptTypeMasked = /^true\/(.*)/,
+  rcleanScript = /^\s*\s*$/g,
+
+  // We have to close these tags to support XHTML (#13200)
+  wrapMap = {
+
+    // Support: IE 9
+    option: [ 1, "" ],
+
+    thead: [ 1, "", "
" ],
+    col: [ 2, "", "
" ],
+    tr: [ 2, "", "
" ],
+    td: [ 3, "", "
" ],
+
+    _default: [ 0, "", "" ]
+  };
+
+// Support: IE 9
+wrapMap.optgroup = wrapMap.option;
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// Support: 1.x compatibility
+// Manipulating tables requires a tbody
+function manipulationTarget( elem, content ) {
+  return jQuery.nodeName( elem, "table" ) &&
+    jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
+
+    elem.getElementsByTagName("tbody")[0] ||
+      elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
+    elem;
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+  elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
+  return elem;
+}
+function restoreScript( elem ) {
+  var match = rscriptTypeMasked.exec( elem.type );
+
+  if ( match ) {
+    elem.type = match[ 1 ];
+  } else {
+    elem.removeAttribute("type");
+  }
+
+  return elem;
+}
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+  var i = 0,
+    l = elems.length;
+
+  for ( ; i < l; i++ ) {
+    data_priv.set(
+      elems[ i ], "globalEval", !refElements || data_priv.get( refElements[ i ], "globalEval" )
+    );
+  }
+}
+
+function cloneCopyEvent( src, dest ) {
+  var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
+
+  if ( dest.nodeType !== 1 ) {
+    return;
+  }
+
+  // 1. Copy private data: events, handlers, etc.
+  if ( data_priv.hasData( src ) ) {
+    pdataOld = data_priv.access( src );
+    pdataCur = data_priv.set( dest, pdataOld );
+    events = pdataOld.events;
+
+    if ( events ) {
+      delete pdataCur.handle;
+      pdataCur.events = {};
+
+      for ( type in events ) {
+        for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+          jQuery.event.add( dest, type, events[ type ][ i ] );
+        }
+      }
+    }
+  }
+
+  // 2. Copy user data
+  if ( data_user.hasData( src ) ) {
+    udataOld = data_user.access( src );
+    udataCur = jQuery.extend( {}, udataOld );
+
+    data_user.set( dest, udataCur );
+  }
+}
+
+function getAll( context, tag ) {
+  var ret = context.getElementsByTagName ? context.getElementsByTagName( tag || "*" ) :
+      context.querySelectorAll ? context.querySelectorAll( tag || "*" ) :
+      [];
+
+  return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
+    jQuery.merge( [ context ], ret ) :
+    ret;
+}
+
+// Support: IE >= 9
+function fixInput( src, dest ) {
+  var nodeName = dest.nodeName.toLowerCase();
+
+  // Fails to persist the checked state of a cloned checkbox or radio button.
+  if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+    dest.checked = src.checked;
+
+  // Fails to return the selected option to the default selected state when cloning options
+  } else if ( nodeName === "input" || nodeName === "textarea" ) {
+    dest.defaultValue = src.defaultValue;
+  }
+}
+
+jQuery.extend({
+  clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+    var i, l, srcElements, destElements,
+      clone = elem.cloneNode( true ),
+      inPage = jQuery.contains( elem.ownerDocument, elem );
+
+    // Support: IE >= 9
+    // Fix Cloning issues
+    if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
+        !jQuery.isXMLDoc( elem ) ) {
+
+      // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
+      destElements = getAll( clone );
+      srcElements = getAll( elem );
+
+      for ( i = 0, l = srcElements.length; i < l; i++ ) {
+        fixInput( srcElements[ i ], destElements[ i ] );
+      }
+    }
+
+    // Copy the events from the original to the clone
+    if ( dataAndEvents ) {
+      if ( deepDataAndEvents ) {
+        srcElements = srcElements || getAll( elem );
+        destElements = destElements || getAll( clone );
+
+        for ( i = 0, l = srcElements.length; i < l; i++ ) {
+          cloneCopyEvent( srcElements[ i ], destElements[ i ] );
+        }
+      } else {
+        cloneCopyEvent( elem, clone );
+      }
+    }
+
+    // Preserve script evaluation history
+    destElements = getAll( clone, "script" );
+    if ( destElements.length > 0 ) {
+      setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+    }
+
+    // Return the cloned set
+    return clone;
+  },
+
+  buildFragment: function( elems, context, scripts, selection ) {
+    var elem, tmp, tag, wrap, contains, j,
+      fragment = context.createDocumentFragment(),
+      nodes = [],
+      i = 0,
+      l = elems.length;
+
+    for ( ; i < l; i++ ) {
+      elem = elems[ i ];
+
+      if ( elem || elem === 0 ) {
+
+        // Add nodes directly
+        if ( jQuery.type( elem ) === "object" ) {
+          // Support: QtWebKit
+          // jQuery.merge because push.apply(_, arraylike) throws
+          jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
+
+        // Convert non-html into a text node
+        } else if ( !rhtml.test( elem ) ) {
+          nodes.push( context.createTextNode( elem ) );
+
+        // Convert html into DOM nodes
+        } else {
+          tmp = tmp || fragment.appendChild( context.createElement("div") );
+
+          // Deserialize a standard representation
+          tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
+          wrap = wrapMap[ tag ] || wrapMap._default;
+          tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1>" ) + wrap[ 2 ];
+
+          // Descend through wrappers to the right content
+          j = wrap[ 0 ];
+          while ( j-- ) {
+            tmp = tmp.lastChild;
+          }
+
+          // Support: QtWebKit
+          // jQuery.merge because push.apply(_, arraylike) throws
+          jQuery.merge( nodes, tmp.childNodes );
+
+          // Remember the top-level container
+          tmp = fragment.firstChild;
+
+          // Fixes #12346
+          // Support: Webkit, IE
+          tmp.textContent = "";
+        }
+      }
+    }
+
+    // Remove wrapper from fragment
+    fragment.textContent = "";
+
+    i = 0;
+    while ( (elem = nodes[ i++ ]) ) {
+
+      // #4087 - If origin and destination elements are the same, and this is
+      // that element, do not do anything
+      if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
+        continue;
+      }
+
+      contains = jQuery.contains( elem.ownerDocument, elem );
+
+      // Append to fragment
+      tmp = getAll( fragment.appendChild( elem ), "script" );
+
+      // Preserve script evaluation history
+      if ( contains ) {
+        setGlobalEval( tmp );
+      }
+
+      // Capture executables
+      if ( scripts ) {
+        j = 0;
+        while ( (elem = tmp[ j++ ]) ) {
+          if ( rscriptType.test( elem.type || "" ) ) {
+            scripts.push( elem );
+          }
+        }
+      }
+    }
+
+    return fragment;
+  },
+
+  cleanData: function( elems ) {
+    var data, elem, events, type, key, j,
+      special = jQuery.event.special,
+      i = 0;
+
+    for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
+      if ( jQuery.acceptData( elem ) ) {
+        key = elem[ data_priv.expando ];
+
+        if ( key && (data = data_priv.cache[ key ]) ) {
+          events = Object.keys( data.events || {} );
+          if ( events.length ) {
+            for ( j = 0; (type = events[j]) !== undefined; j++ ) {
+              if ( special[ type ] ) {
+                jQuery.event.remove( elem, type );
+
+              // This is a shortcut to avoid jQuery.event.remove's overhead
+              } else {
+                jQuery.removeEvent( elem, type, data.handle );
+              }
+            }
+          }
+          if ( data_priv.cache[ key ] ) {
+            // Discard any remaining `private` data
+            delete data_priv.cache[ key ];
+          }
+        }
+      }
+      // Discard any remaining `user` data
+      delete data_user.cache[ elem[ data_user.expando ] ];
+    }
+  }
+});
+
+jQuery.fn.extend({
+  text: function( value ) {
+    return access( this, function( value ) {
+      return value === undefined ?
+        jQuery.text( this ) :
+        this.empty().each(function() {
+          if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+            this.textContent = value;
+          }
+        });
+    }, null, value, arguments.length );
+  },
+
+  append: function() {
+    return this.domManip( arguments, function( elem ) {
+      if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+        var target = manipulationTarget( this, elem );
+        target.appendChild( elem );
+      }
+    });
+  },
+
+  prepend: function() {
+    return this.domManip( arguments, function( elem ) {
+      if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+        var target = manipulationTarget( this, elem );
+        target.insertBefore( elem, target.firstChild );
+      }
+    });
+  },
+
+  before: function() {
+    return this.domManip( arguments, function( elem ) {
+      if ( this.parentNode ) {
+        this.parentNode.insertBefore( elem, this );
+      }
+    });
+  },
+
+  after: function() {
+    return this.domManip( arguments, function( elem ) {
+      if ( this.parentNode ) {
+        this.parentNode.insertBefore( elem, this.nextSibling );
+      }
+    });
+  },
+
+  remove: function( selector, keepData /* Internal Use Only */ ) {
+    var elem,
+      elems = selector ? jQuery.filter( selector, this ) : this,
+      i = 0;
+
+    for ( ; (elem = elems[i]) != null; i++ ) {
+      if ( !keepData && elem.nodeType === 1 ) {
+        jQuery.cleanData( getAll( elem ) );
+      }
+
+      if ( elem.parentNode ) {
+        if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
+          setGlobalEval( getAll( elem, "script" ) );
+        }
+        elem.parentNode.removeChild( elem );
+      }
+    }
+
+    return this;
+  },
+
+  empty: function() {
+    var elem,
+      i = 0;
+
+    for ( ; (elem = this[i]) != null; i++ ) {
+      if ( elem.nodeType === 1 ) {
+
+        // Prevent memory leaks
+        jQuery.cleanData( getAll( elem, false ) );
+
+        // Remove any remaining nodes
+        elem.textContent = "";
+      }
+    }
+
+    return this;
+  },
+
+  clone: function( dataAndEvents, deepDataAndEvents ) {
+    dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+    deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+    return this.map(function() {
+      return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+    });
+  },
+
+  html: function( value ) {
+    return access( this, function( value ) {
+      var elem = this[ 0 ] || {},
+        i = 0,
+        l = this.length;
+
+      if ( value === undefined && elem.nodeType === 1 ) {
+        return elem.innerHTML;
+      }
+
+      // See if we can take a shortcut and just use innerHTML
+      if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+        !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
+
+        value = value.replace( rxhtmlTag, "<$1>" );
+
+        try {
+          for ( ; i < l; i++ ) {
+            elem = this[ i ] || {};
+
+            // Remove element nodes and prevent memory leaks
+            if ( elem.nodeType === 1 ) {
+              jQuery.cleanData( getAll( elem, false ) );
+              elem.innerHTML = value;
+            }
+          }
+
+          elem = 0;
+
+        // If using innerHTML throws an exception, use the fallback method
+        } catch( e ) {}
+      }
+
+      if ( elem ) {
+        this.empty().append( value );
+      }
+    }, null, value, arguments.length );
+  },
+
+  replaceWith: function() {
+    var arg = arguments[ 0 ];
+
+    // Make the changes, replacing each context element with the new content
+    this.domManip( arguments, function( elem ) {
+      arg = this.parentNode;
+
+      jQuery.cleanData( getAll( this ) );
+
+      if ( arg ) {
+        arg.replaceChild( elem, this );
+      }
+    });
+
+    // Force removal if there was no new content (e.g., from empty arguments)
+    return arg && (arg.length || arg.nodeType) ? this : this.remove();
+  },
+
+  detach: function( selector ) {
+    return this.remove( selector, true );
+  },
+
+  domManip: function( args, callback ) {
+
+    // Flatten any nested arrays
+    args = concat.apply( [], args );
+
+    var fragment, first, scripts, hasScripts, node, doc,
+      i = 0,
+      l = this.length,
+      set = this,
+      iNoClone = l - 1,
+      value = args[ 0 ],
+      isFunction = jQuery.isFunction( value );
+
+    // We can't cloneNode fragments that contain checked, in WebKit
+    if ( isFunction ||
+        ( l > 1 && typeof value === "string" &&
+          !support.checkClone && rchecked.test( value ) ) ) {
+      return this.each(function( index ) {
+        var self = set.eq( index );
+        if ( isFunction ) {
+          args[ 0 ] = value.call( this, index, self.html() );
+        }
+        self.domManip( args, callback );
+      });
+    }
+
+    if ( l ) {
+      fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
+      first = fragment.firstChild;
+
+      if ( fragment.childNodes.length === 1 ) {
+        fragment = first;
+      }
+
+      if ( first ) {
+        scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
+        hasScripts = scripts.length;
+
+        // Use the original fragment for the last item instead of the first because it can end up
+        // being emptied incorrectly in certain situations (#8070).
+        for ( ; i < l; i++ ) {
+          node = fragment;
+
+          if ( i !== iNoClone ) {
+            node = jQuery.clone( node, true, true );
+
+            // Keep references to cloned scripts for later restoration
+            if ( hasScripts ) {
+              // Support: QtWebKit
+              // jQuery.merge because push.apply(_, arraylike) throws
+              jQuery.merge( scripts, getAll( node, "script" ) );
+            }
+          }
+
+          callback.call( this[ i ], node, i );
+        }
+
+        if ( hasScripts ) {
+          doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+          // Reenable scripts
+          jQuery.map( scripts, restoreScript );
+
+          // Evaluate executable scripts on first document insertion
+          for ( i = 0; i < hasScripts; i++ ) {
+            node = scripts[ i ];
+            if ( rscriptType.test( node.type || "" ) &&
+              !data_priv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
+
+              if ( node.src ) {
+                // Optional AJAX dependency, but won't run scripts if not present
+                if ( jQuery._evalUrl ) {
+                  jQuery._evalUrl( node.src );
+                }
+              } else {
+                jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return this;
+  }
+});
+
+jQuery.each({
+  appendTo: "append",
+  prependTo: "prepend",
+  insertBefore: "before",
+  insertAfter: "after",
+  replaceAll: "replaceWith"
+}, function( name, original ) {
+  jQuery.fn[ name ] = function( selector ) {
+    var elems,
+      ret = [],
+      insert = jQuery( selector ),
+      last = insert.length - 1,
+      i = 0;
+
+    for ( ; i <= last; i++ ) {
+      elems = i === last ? this : this.clone( true );
+      jQuery( insert[ i ] )[ original ]( elems );
+
+      // Support: QtWebKit
+      // .get() because push.apply(_, arraylike) throws
+      push.apply( ret, elems.get() );
+    }
+
+    return this.pushStack( ret );
+  };
+});
+
+
+var iframe,
+  elemdisplay = {};
+
+/**
+ * Retrieve the actual display of a element
+ * @param {String} name nodeName of the element
+ * @param {Object} doc Document object
+ */
+// Called only from within defaultDisplay
+function actualDisplay( name, doc ) {
+  var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
+
+    // getDefaultComputedStyle might be reliably used only on attached element
+    display = window.getDefaultComputedStyle ?
+
+      // Use of this method is a temporary fix (more like optmization) until something better comes along,
+      // since it was removed from specification and supported only in FF
+      window.getDefaultComputedStyle( elem[ 0 ] ).display : jQuery.css( elem[ 0 ], "display" );
+
+  // We don't have any data stored on the element,
+  // so use "detach" method as fast way to get rid of the element
+  elem.detach();
+
+  return display;
+}
+
+/**
+ * Try to determine the default display value of an element
+ * @param {String} nodeName
+ */
+function defaultDisplay( nodeName ) {
+  var doc = document,
+    display = elemdisplay[ nodeName ];
+
+  if ( !display ) {
+    display = actualDisplay( nodeName, doc );
+
+    // If the simple way fails, read from inside an iframe
+    if ( display === "none" || !display ) {
+
+      // Use the already-created iframe if possible
+      iframe = (iframe || jQuery( "