corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
Rev Author Line No. Line
20 office 1 define( [
2 "./core",
3 "./var/document",
4 "./var/documentElement",
5 "./var/rnothtmlwhite",
6 "./var/slice",
7 "./data/var/dataPriv",
8 "./core/nodeName",
9  
10 "./core/init",
11 "./selector"
12 ], function( jQuery, document, documentElement, rnothtmlwhite, slice, dataPriv, nodeName ) {
13  
14 "use strict";
15  
16 var
17 rkeyEvent = /^key/,
18 rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
19 rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
20  
21 function returnTrue() {
22 return true;
23 }
24  
25 function returnFalse() {
26 return false;
27 }
28  
29 // Support: IE <=9 only
30 // See #13393 for more info
31 function safeActiveElement() {
32 try {
33 return document.activeElement;
34 } catch ( err ) { }
35 }
36  
37 function on( elem, types, selector, data, fn, one ) {
38 var origFn, type;
39  
40 // Types can be a map of types/handlers
41 if ( typeof types === "object" ) {
42  
43 // ( types-Object, selector, data )
44 if ( typeof selector !== "string" ) {
45  
46 // ( types-Object, data )
47 data = data || selector;
48 selector = undefined;
49 }
50 for ( type in types ) {
51 on( elem, type, selector, data, types[ type ], one );
52 }
53 return elem;
54 }
55  
56 if ( data == null && fn == null ) {
57  
58 // ( types, fn )
59 fn = selector;
60 data = selector = undefined;
61 } else if ( fn == null ) {
62 if ( typeof selector === "string" ) {
63  
64 // ( types, selector, fn )
65 fn = data;
66 data = undefined;
67 } else {
68  
69 // ( types, data, fn )
70 fn = data;
71 data = selector;
72 selector = undefined;
73 }
74 }
75 if ( fn === false ) {
76 fn = returnFalse;
77 } else if ( !fn ) {
78 return elem;
79 }
80  
81 if ( one === 1 ) {
82 origFn = fn;
83 fn = function( event ) {
84  
85 // Can use an empty set, since event contains the info
86 jQuery().off( event );
87 return origFn.apply( this, arguments );
88 };
89  
90 // Use same guid so caller can remove using origFn
91 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
92 }
93 return elem.each( function() {
94 jQuery.event.add( this, types, fn, data, selector );
95 } );
96 }
97  
98 /*
99 * Helper functions for managing events -- not part of the public interface.
100 * Props to Dean Edwards' addEvent library for many of the ideas.
101 */
102 jQuery.event = {
103  
104 global: {},
105  
106 add: function( elem, types, handler, data, selector ) {
107  
108 var handleObjIn, eventHandle, tmp,
109 events, t, handleObj,
110 special, handlers, type, namespaces, origType,
111 elemData = dataPriv.get( elem );
112  
113 // Don't attach events to noData or text/comment nodes (but allow plain objects)
114 if ( !elemData ) {
115 return;
116 }
117  
118 // Caller can pass in an object of custom data in lieu of the handler
119 if ( handler.handler ) {
120 handleObjIn = handler;
121 handler = handleObjIn.handler;
122 selector = handleObjIn.selector;
123 }
124  
125 // Ensure that invalid selectors throw exceptions at attach time
126 // Evaluate against documentElement in case elem is a non-element node (e.g., document)
127 if ( selector ) {
128 jQuery.find.matchesSelector( documentElement, selector );
129 }
130  
131 // Make sure that the handler has a unique ID, used to find/remove it later
132 if ( !handler.guid ) {
133 handler.guid = jQuery.guid++;
134 }
135  
136 // Init the element's event structure and main handler, if this is the first
137 if ( !( events = elemData.events ) ) {
138 events = elemData.events = {};
139 }
140 if ( !( eventHandle = elemData.handle ) ) {
141 eventHandle = elemData.handle = function( e ) {
142  
143 // Discard the second event of a jQuery.event.trigger() and
144 // when an event is called after a page has unloaded
145 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
146 jQuery.event.dispatch.apply( elem, arguments ) : undefined;
147 };
148 }
149  
150 // Handle multiple events separated by a space
151 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
152 t = types.length;
153 while ( t-- ) {
154 tmp = rtypenamespace.exec( types[ t ] ) || [];
155 type = origType = tmp[ 1 ];
156 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
157  
158 // There *must* be a type, no attaching namespace-only handlers
159 if ( !type ) {
160 continue;
161 }
162  
163 // If event changes its type, use the special event handlers for the changed type
164 special = jQuery.event.special[ type ] || {};
165  
166 // If selector defined, determine special event api type, otherwise given type
167 type = ( selector ? special.delegateType : special.bindType ) || type;
168  
169 // Update special based on newly reset type
170 special = jQuery.event.special[ type ] || {};
171  
172 // handleObj is passed to all event handlers
173 handleObj = jQuery.extend( {
174 type: type,
175 origType: origType,
176 data: data,
177 handler: handler,
178 guid: handler.guid,
179 selector: selector,
180 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
181 namespace: namespaces.join( "." )
182 }, handleObjIn );
183  
184 // Init the event handler queue if we're the first
185 if ( !( handlers = events[ type ] ) ) {
186 handlers = events[ type ] = [];
187 handlers.delegateCount = 0;
188  
189 // Only use addEventListener if the special events handler returns false
190 if ( !special.setup ||
191 special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
192  
193 if ( elem.addEventListener ) {
194 elem.addEventListener( type, eventHandle );
195 }
196 }
197 }
198  
199 if ( special.add ) {
200 special.add.call( elem, handleObj );
201  
202 if ( !handleObj.handler.guid ) {
203 handleObj.handler.guid = handler.guid;
204 }
205 }
206  
207 // Add to the element's handler list, delegates in front
208 if ( selector ) {
209 handlers.splice( handlers.delegateCount++, 0, handleObj );
210 } else {
211 handlers.push( handleObj );
212 }
213  
214 // Keep track of which events have ever been used, for event optimization
215 jQuery.event.global[ type ] = true;
216 }
217  
218 },
219  
220 // Detach an event or set of events from an element
221 remove: function( elem, types, handler, selector, mappedTypes ) {
222  
223 var j, origCount, tmp,
224 events, t, handleObj,
225 special, handlers, type, namespaces, origType,
226 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
227  
228 if ( !elemData || !( events = elemData.events ) ) {
229 return;
230 }
231  
232 // Once for each type.namespace in types; type may be omitted
233 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
234 t = types.length;
235 while ( t-- ) {
236 tmp = rtypenamespace.exec( types[ t ] ) || [];
237 type = origType = tmp[ 1 ];
238 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
239  
240 // Unbind all events (on this namespace, if provided) for the element
241 if ( !type ) {
242 for ( type in events ) {
243 jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
244 }
245 continue;
246 }
247  
248 special = jQuery.event.special[ type ] || {};
249 type = ( selector ? special.delegateType : special.bindType ) || type;
250 handlers = events[ type ] || [];
251 tmp = tmp[ 2 ] &&
252 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
253  
254 // Remove matching events
255 origCount = j = handlers.length;
256 while ( j-- ) {
257 handleObj = handlers[ j ];
258  
259 if ( ( mappedTypes || origType === handleObj.origType ) &&
260 ( !handler || handler.guid === handleObj.guid ) &&
261 ( !tmp || tmp.test( handleObj.namespace ) ) &&
262 ( !selector || selector === handleObj.selector ||
263 selector === "**" && handleObj.selector ) ) {
264 handlers.splice( j, 1 );
265  
266 if ( handleObj.selector ) {
267 handlers.delegateCount--;
268 }
269 if ( special.remove ) {
270 special.remove.call( elem, handleObj );
271 }
272 }
273 }
274  
275 // Remove generic event handler if we removed something and no more handlers exist
276 // (avoids potential for endless recursion during removal of special event handlers)
277 if ( origCount && !handlers.length ) {
278 if ( !special.teardown ||
279 special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
280  
281 jQuery.removeEvent( elem, type, elemData.handle );
282 }
283  
284 delete events[ type ];
285 }
286 }
287  
288 // Remove data and the expando if it's no longer used
289 if ( jQuery.isEmptyObject( events ) ) {
290 dataPriv.remove( elem, "handle events" );
291 }
292 },
293  
294 dispatch: function( nativeEvent ) {
295  
296 // Make a writable jQuery.Event from the native event object
297 var event = jQuery.event.fix( nativeEvent );
298  
299 var i, j, ret, matched, handleObj, handlerQueue,
300 args = new Array( arguments.length ),
301 handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
302 special = jQuery.event.special[ event.type ] || {};
303  
304 // Use the fix-ed jQuery.Event rather than the (read-only) native event
305 args[ 0 ] = event;
306  
307 for ( i = 1; i < arguments.length; i++ ) {
308 args[ i ] = arguments[ i ];
309 }
310  
311 event.delegateTarget = this;
312  
313 // Call the preDispatch hook for the mapped type, and let it bail if desired
314 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
315 return;
316 }
317  
318 // Determine handlers
319 handlerQueue = jQuery.event.handlers.call( this, event, handlers );
320  
321 // Run delegates first; they may want to stop propagation beneath us
322 i = 0;
323 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
324 event.currentTarget = matched.elem;
325  
326 j = 0;
327 while ( ( handleObj = matched.handlers[ j++ ] ) &&
328 !event.isImmediatePropagationStopped() ) {
329  
330 // Triggered event must either 1) have no namespace, or 2) have namespace(s)
331 // a subset or equal to those in the bound event (both can have no namespace).
332 if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
333  
334 event.handleObj = handleObj;
335 event.data = handleObj.data;
336  
337 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
338 handleObj.handler ).apply( matched.elem, args );
339  
340 if ( ret !== undefined ) {
341 if ( ( event.result = ret ) === false ) {
342 event.preventDefault();
343 event.stopPropagation();
344 }
345 }
346 }
347 }
348 }
349  
350 // Call the postDispatch hook for the mapped type
351 if ( special.postDispatch ) {
352 special.postDispatch.call( this, event );
353 }
354  
355 return event.result;
356 },
357  
358 handlers: function( event, handlers ) {
359 var i, handleObj, sel, matchedHandlers, matchedSelectors,
360 handlerQueue = [],
361 delegateCount = handlers.delegateCount,
362 cur = event.target;
363  
364 // Find delegate handlers
365 if ( delegateCount &&
366  
367 // Support: IE <=9
368 // Black-hole SVG <use> instance trees (trac-13180)
369 cur.nodeType &&
370  
371 // Support: Firefox <=42
372 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
373 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
374 // Support: IE 11 only
375 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
376 !( event.type === "click" && event.button >= 1 ) ) {
377  
378 for ( ; cur !== this; cur = cur.parentNode || this ) {
379  
380 // Don't check non-elements (#13208)
381 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
382 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
383 matchedHandlers = [];
384 matchedSelectors = {};
385 for ( i = 0; i < delegateCount; i++ ) {
386 handleObj = handlers[ i ];
387  
388 // Don't conflict with Object.prototype properties (#13203)
389 sel = handleObj.selector + " ";
390  
391 if ( matchedSelectors[ sel ] === undefined ) {
392 matchedSelectors[ sel ] = handleObj.needsContext ?
393 jQuery( sel, this ).index( cur ) > -1 :
394 jQuery.find( sel, this, null, [ cur ] ).length;
395 }
396 if ( matchedSelectors[ sel ] ) {
397 matchedHandlers.push( handleObj );
398 }
399 }
400 if ( matchedHandlers.length ) {
401 handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
402 }
403 }
404 }
405 }
406  
407 // Add the remaining (directly-bound) handlers
408 cur = this;
409 if ( delegateCount < handlers.length ) {
410 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
411 }
412  
413 return handlerQueue;
414 },
415  
416 addProp: function( name, hook ) {
417 Object.defineProperty( jQuery.Event.prototype, name, {
418 enumerable: true,
419 configurable: true,
420  
421 get: jQuery.isFunction( hook ) ?
422 function() {
423 if ( this.originalEvent ) {
424 return hook( this.originalEvent );
425 }
426 } :
427 function() {
428 if ( this.originalEvent ) {
429 return this.originalEvent[ name ];
430 }
431 },
432  
433 set: function( value ) {
434 Object.defineProperty( this, name, {
435 enumerable: true,
436 configurable: true,
437 writable: true,
438 value: value
439 } );
440 }
441 } );
442 },
443  
444 fix: function( originalEvent ) {
445 return originalEvent[ jQuery.expando ] ?
446 originalEvent :
447 new jQuery.Event( originalEvent );
448 },
449  
450 special: {
451 load: {
452  
453 // Prevent triggered image.load events from bubbling to window.load
454 noBubble: true
455 },
456 focus: {
457  
458 // Fire native event if possible so blur/focus sequence is correct
459 trigger: function() {
460 if ( this !== safeActiveElement() && this.focus ) {
461 this.focus();
462 return false;
463 }
464 },
465 delegateType: "focusin"
466 },
467 blur: {
468 trigger: function() {
469 if ( this === safeActiveElement() && this.blur ) {
470 this.blur();
471 return false;
472 }
473 },
474 delegateType: "focusout"
475 },
476 click: {
477  
478 // For checkbox, fire native event so checked state will be right
479 trigger: function() {
480 if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
481 this.click();
482 return false;
483 }
484 },
485  
486 // For cross-browser consistency, don't fire native .click() on links
487 _default: function( event ) {
488 return nodeName( event.target, "a" );
489 }
490 },
491  
492 beforeunload: {
493 postDispatch: function( event ) {
494  
495 // Support: Firefox 20+
496 // Firefox doesn't alert if the returnValue field is not set.
497 if ( event.result !== undefined && event.originalEvent ) {
498 event.originalEvent.returnValue = event.result;
499 }
500 }
501 }
502 }
503 };
504  
505 jQuery.removeEvent = function( elem, type, handle ) {
506  
507 // This "if" is needed for plain objects
508 if ( elem.removeEventListener ) {
509 elem.removeEventListener( type, handle );
510 }
511 };
512  
513 jQuery.Event = function( src, props ) {
514  
515 // Allow instantiation without the 'new' keyword
516 if ( !( this instanceof jQuery.Event ) ) {
517 return new jQuery.Event( src, props );
518 }
519  
520 // Event object
521 if ( src && src.type ) {
522 this.originalEvent = src;
523 this.type = src.type;
524  
525 // Events bubbling up the document may have been marked as prevented
526 // by a handler lower down the tree; reflect the correct value.
527 this.isDefaultPrevented = src.defaultPrevented ||
528 src.defaultPrevented === undefined &&
529  
530 // Support: Android <=2.3 only
531 src.returnValue === false ?
532 returnTrue :
533 returnFalse;
534  
535 // Create target properties
536 // Support: Safari <=6 - 7 only
537 // Target should not be a text node (#504, #13143)
538 this.target = ( src.target && src.target.nodeType === 3 ) ?
539 src.target.parentNode :
540 src.target;
541  
542 this.currentTarget = src.currentTarget;
543 this.relatedTarget = src.relatedTarget;
544  
545 // Event type
546 } else {
547 this.type = src;
548 }
549  
550 // Put explicitly provided properties onto the event object
551 if ( props ) {
552 jQuery.extend( this, props );
553 }
554  
555 // Create a timestamp if incoming event doesn't have one
556 this.timeStamp = src && src.timeStamp || jQuery.now();
557  
558 // Mark it as fixed
559 this[ jQuery.expando ] = true;
560 };
561  
562 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
563 // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
564 jQuery.Event.prototype = {
565 constructor: jQuery.Event,
566 isDefaultPrevented: returnFalse,
567 isPropagationStopped: returnFalse,
568 isImmediatePropagationStopped: returnFalse,
569 isSimulated: false,
570  
571 preventDefault: function() {
572 var e = this.originalEvent;
573  
574 this.isDefaultPrevented = returnTrue;
575  
576 if ( e && !this.isSimulated ) {
577 e.preventDefault();
578 }
579 },
580 stopPropagation: function() {
581 var e = this.originalEvent;
582  
583 this.isPropagationStopped = returnTrue;
584  
585 if ( e && !this.isSimulated ) {
586 e.stopPropagation();
587 }
588 },
589 stopImmediatePropagation: function() {
590 var e = this.originalEvent;
591  
592 this.isImmediatePropagationStopped = returnTrue;
593  
594 if ( e && !this.isSimulated ) {
595 e.stopImmediatePropagation();
596 }
597  
598 this.stopPropagation();
599 }
600 };
601  
602 // Includes all common event props including KeyEvent and MouseEvent specific props
603 jQuery.each( {
604 altKey: true,
605 bubbles: true,
606 cancelable: true,
607 changedTouches: true,
608 ctrlKey: true,
609 detail: true,
610 eventPhase: true,
611 metaKey: true,
612 pageX: true,
613 pageY: true,
614 shiftKey: true,
615 view: true,
616 "char": true,
617 charCode: true,
618 key: true,
619 keyCode: true,
620 button: true,
621 buttons: true,
622 clientX: true,
623 clientY: true,
624 offsetX: true,
625 offsetY: true,
626 pointerId: true,
627 pointerType: true,
628 screenX: true,
629 screenY: true,
630 targetTouches: true,
631 toElement: true,
632 touches: true,
633  
634 which: function( event ) {
635 var button = event.button;
636  
637 // Add which for key events
638 if ( event.which == null && rkeyEvent.test( event.type ) ) {
639 return event.charCode != null ? event.charCode : event.keyCode;
640 }
641  
642 // Add which for click: 1 === left; 2 === middle; 3 === right
643 if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
644 if ( button & 1 ) {
645 return 1;
646 }
647  
648 if ( button & 2 ) {
649 return 3;
650 }
651  
652 if ( button & 4 ) {
653 return 2;
654 }
655  
656 return 0;
657 }
658  
659 return event.which;
660 }
661 }, jQuery.event.addProp );
662  
663 // Create mouseenter/leave events using mouseover/out and event-time checks
664 // so that event delegation works in jQuery.
665 // Do the same for pointerenter/pointerleave and pointerover/pointerout
666 //
667 // Support: Safari 7 only
668 // Safari sends mouseenter too often; see:
669 // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
670 // for the description of the bug (it existed in older Chrome versions as well).
671 jQuery.each( {
672 mouseenter: "mouseover",
673 mouseleave: "mouseout",
674 pointerenter: "pointerover",
675 pointerleave: "pointerout"
676 }, function( orig, fix ) {
677 jQuery.event.special[ orig ] = {
678 delegateType: fix,
679 bindType: fix,
680  
681 handle: function( event ) {
682 var ret,
683 target = this,
684 related = event.relatedTarget,
685 handleObj = event.handleObj;
686  
687 // For mouseenter/leave call the handler if related is outside the target.
688 // NB: No relatedTarget if the mouse left/entered the browser window
689 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
690 event.type = handleObj.origType;
691 ret = handleObj.handler.apply( this, arguments );
692 event.type = fix;
693 }
694 return ret;
695 }
696 };
697 } );
698  
699 jQuery.fn.extend( {
700  
701 on: function( types, selector, data, fn ) {
702 return on( this, types, selector, data, fn );
703 },
704 one: function( types, selector, data, fn ) {
705 return on( this, types, selector, data, fn, 1 );
706 },
707 off: function( types, selector, fn ) {
708 var handleObj, type;
709 if ( types && types.preventDefault && types.handleObj ) {
710  
711 // ( event ) dispatched jQuery.Event
712 handleObj = types.handleObj;
713 jQuery( types.delegateTarget ).off(
714 handleObj.namespace ?
715 handleObj.origType + "." + handleObj.namespace :
716 handleObj.origType,
717 handleObj.selector,
718 handleObj.handler
719 );
720 return this;
721 }
722 if ( typeof types === "object" ) {
723  
724 // ( types-object [, selector] )
725 for ( type in types ) {
726 this.off( type, selector, types[ type ] );
727 }
728 return this;
729 }
730 if ( selector === false || typeof selector === "function" ) {
731  
732 // ( types [, fn] )
733 fn = selector;
734 selector = undefined;
735 }
736 if ( fn === false ) {
737 fn = returnFalse;
738 }
739 return this.each( function() {
740 jQuery.event.remove( this, types, fn, selector );
741 } );
742 }
743 } );
744  
745 return jQuery;
746 } );