D-Net

define([

	"./core",

	"./var/rnotwhite"

], function( jQuery, rnotwhite ) {

// String to Object options format cache

var optionsCache = {};

// Convert String-formatted options into Object-formatted ones and store in cache

function createOptions( options ) {

	var object = optionsCache[ options ] = {};

	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {

		object[ flag ] = true;

	});

	return object;

}

/*

 * Create a callback list using the following parameters:

 *

 *	options: an optional list of space-separated options that will change how

 *			the callback list behaves or a more traditional option object

 *

 * By default a callback list will act like an event callback list and can be

 * "fired" multiple times.

 *

 * Possible options:

 *

 *	once:			will ensure the callback list can only be fired once (like a Deferred)

 *

 *	memory:			will keep track of previous values and will call any callback added

 *					after the list has been fired right away with the latest "memorized"

 *					values (like a Deferred)

 *

 *	unique:			will ensure a callback can only be added once (no duplicate in the list)

 *

 *	stopOnFalse:	interrupt callings when a callback returns false

 *

 */

jQuery.Callbacks = function( options ) {

	// Convert options from String-formatted to Object-formatted if needed

	// (we check in cache first)

	options = typeof options === "string" ?

		( optionsCache[ options ] || createOptions( options ) ) :

		jQuery.extend( {}, options );

	var // Last fire value (for non-forgettable lists)

		memory,

		// Flag to know if list was already fired

		fired,

		// Flag to know if list is currently firing

		firing,

		// First callback to fire (used internally by add and fireWith)

		firingStart,

		// End of the loop when firing

		firingLength,

		// Index of currently firing callback (modified by remove if needed)

		firingIndex,

		// Actual callback list

		list = [],

		// Stack of fire calls for repeatable lists

		stack = !options.once && [],

		// Fire callbacks

		fire = function( data ) {

			memory = options.memory && data;

			fired = true;

			firingIndex = firingStart || 0;

			firingStart = 0;

			firingLength = list.length;

			firing = true;

			for ( ; list && firingIndex < firingLength; firingIndex++ ) {

				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {

					memory = false; // To prevent further calls using add

					break;

				}

			}

			firing = false;

			if ( list ) {

				if ( stack ) {

					if ( stack.length ) {

						fire( stack.shift() );

					}

				} else if ( memory ) {

					list = [];

				} else {

					self.disable();

				}

			}

		},

		// Actual Callbacks object

		self = {

			// Add a callback or a collection of callbacks to the list

			add: function() {

				if ( list ) {

					// First, we save the current length

					var start = list.length;

					(function add( args ) {

						jQuery.each( args, function( _, arg ) {

							var type = jQuery.type( arg );

							if ( type === "function" ) {

								if ( !options.unique || !self.has( arg ) ) {

									list.push( arg );

								}

							} else if ( arg && arg.length && type !== "string" ) {

								// Inspect recursively

								add( arg );

							}

						});

					})( arguments );

					// Do we need to add the callbacks to the

					// current firing batch?

					if ( firing ) {

						firingLength = list.length;

					// With memory, if we're not firing then

					// we should call right away

					} else if ( memory ) {

						firingStart = start;

						fire( memory );

					}

				}

				return this;

			},

			// Remove a callback from the list

			remove: function() {

				if ( list ) {

					jQuery.each( arguments, function( _, arg ) {

						var index;

						while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {

							list.splice( index, 1 );

							// Handle firing indexes

							if ( firing ) {

								if ( index <= firingLength ) {

									firingLength--;

								}

								if ( index <= firingIndex ) {

									firingIndex--;

								}

							}

						}

					});

				}

				return this;

			},

			// Check if a given callback is in the list.

			// If no argument is given, return whether or not list has callbacks attached.

			has: function( fn ) {

				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );

			},

			// Remove all callbacks from the list

			empty: function() {

				list = [];

				firingLength = 0;

				return this;

			},

			// Have the list do nothing anymore

			disable: function() {

				list = stack = memory = undefined;

				return this;

			},

			// Is it disabled?

			disabled: function() {

				return !list;

			},

			// Lock the list in its current state

			lock: function() {

				stack = undefined;

				if ( !memory ) {

					self.disable();

				}

				return this;

			},

			// Is it locked?

			locked: function() {

				return !stack;

			},

			// Call all callbacks with the given context and arguments

			fireWith: function( context, args ) {

				if ( list && ( !fired || stack ) ) {

					args = args || [];

					args = [ context, args.slice ? args.slice() : args ];

					if ( firing ) {

						stack.push( args );

					} else {

						fire( args );

					}

				}

				return this;

			},

			// Call all the callbacks with the given arguments

			fire: function() {

				self.fireWith( this, arguments );

				return this;

			},

			// To know if the callbacks have already been called at least once

			fired: function() {

				return !!fired;

			}

		};

	return self;

};

return jQuery;

});

define([

	"../core",

	"../var/rnotwhite",

	"../var/strundefined",

	"../data/var/data_priv",

	"../core/init"

], function( jQuery, rnotwhite, strundefined, data_priv ) {

var rclass = /[\t\r\n\f]/g;

jQuery.fn.extend({

	addClass: function( value ) {

		var classes, elem, cur, clazz, j, finalValue,

			proceed = typeof value === "string" && value,

			i = 0,

			len = this.length;

		if ( jQuery.isFunction( value ) ) {

			return this.each(function( j ) {

				jQuery( this ).addClass( value.call( this, j, this.className ) );

			});

		}

		if ( proceed ) {

			// The disjunction here is for better compressibility (see removeClass)

			classes = ( value || "" ).match( rnotwhite ) || [];

			for ( ; i < len; i++ ) {

				elem = this[ i ];

				cur = elem.nodeType === 1 && ( elem.className ?

					( " " + elem.className + " " ).replace( rclass, " " ) :

					" "

				);

				if ( cur ) {

					j = 0;

					while ( (clazz = classes[j++]) ) {

						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {

							cur += clazz + " ";

						}

					}

					// only assign if different to avoid unneeded rendering.

					finalValue = jQuery.trim( cur );

					if ( elem.className !== finalValue ) {

						elem.className = finalValue;

					}

				}

			}

		}

		return this;

	},

	removeClass: function( value ) {

		var classes, elem, cur, clazz, j, finalValue,

			proceed = arguments.length === 0 || typeof value === "string" && value,

			i = 0,

			len = this.length;

		if ( jQuery.isFunction( value ) ) {

			return this.each(function( j ) {

				jQuery( this ).removeClass( value.call( this, j, this.className ) );

			});

		}

		if ( proceed ) {

			classes = ( value || "" ).match( rnotwhite ) || [];

			for ( ; i < len; i++ ) {

				elem = this[ i ];

				// This expression is here for better compressibility (see addClass)

				cur = elem.nodeType === 1 && ( elem.className ?

					( " " + elem.className + " " ).replace( rclass, " " ) :

					""

				);

				if ( cur ) {

					j = 0;

					while ( (clazz = classes[j++]) ) {

						// Remove *all* instances

						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {

							cur = cur.replace( " " + clazz + " ", " " );

						}

					}

					// Only assign if different to avoid unneeded rendering.

					finalValue = value ? jQuery.trim( cur ) : "";

					if ( elem.className !== finalValue ) {

						elem.className = finalValue;

					}

				}

			}

		}

		return this;

	},

	toggleClass: function( value, stateVal ) {

		var type = typeof value;

		if ( typeof stateVal === "boolean" && type === "string" ) {

			return stateVal ? this.addClass( value ) : this.removeClass( value );

		}

		if ( jQuery.isFunction( value ) ) {

			return this.each(function( i ) {

				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );

			});

		}

		return this.each(function() {

			if ( type === "string" ) {

				// Toggle individual class names

				var className,

					i = 0,

					self = jQuery( this ),

					classNames = value.match( rnotwhite ) || [];

				while ( (className = classNames[ i++ ]) ) {

					// Check each className given, space separated list

					if ( self.hasClass( className ) ) {

						self.removeClass( className );

					} else {

						self.addClass( className );

					}

				}

			// Toggle whole class name

			} else if ( type === strundefined || type === "boolean" ) {

				if ( this.className ) {

					// store className if set

					data_priv.set( this, "__className__", this.className );

				}

				// If the element has a class name or if we're passed `false`,

				// then remove the whole classname (if there was one, the above saved it).

				// Otherwise bring back whatever was previously saved (if anything),

				// falling back to the empty string if nothing was stored.

				this.className = this.className || value === false ? "" : data_priv.get( this, "__className__" ) || "";

			}

		});

	},

	hasClass: function( selector ) {

		var className = " " + selector + " ",

			i = 0,

			l = this.length;

		for ( ; i < l; i++ ) {

			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {

				return true;

			}

		}

		return false;

	}

});

});

define([

	"./core",

	"./var/indexOf",

	"./traversing/var/rneedsContext",

	"./core/init",

	"./traversing/findFilter",

	"./selector"

], function( jQuery, indexOf, rneedsContext ) {

var rparentsprev = /^(?:parents|prev(?:Until|All))/,

	// Methods guaranteed to produce a unique set when starting from a unique set

	guaranteedUnique = {

		children: true,

		contents: true,

		next: true,

		prev: true

	};

jQuery.extend({

	dir: function( elem, dir, until ) {

		var matched = [],

			truncate = until !== undefined;

		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {

			if ( elem.nodeType === 1 ) {

				if ( truncate && jQuery( elem ).is( until ) ) {

					break;

				}

				matched.push( elem );

			}

		}

		return matched;

	},

	sibling: function( n, elem ) {

		var matched = [];

		for ( ; n; n = n.nextSibling ) {

			if ( n.nodeType === 1 && n !== elem ) {

				matched.push( n );

			}

		}

		return matched;

	}

});

jQuery.fn.extend({

	has: function( target ) {

		var targets = jQuery( target, this ),

			l = targets.length;

		return this.filter(function() {

			var i = 0;

			for ( ; i < l; i++ ) {

				if ( jQuery.contains( this, targets[i] ) ) {

					return true;

				}

			}

		});

	},

	closest: function( selectors, context ) {

		var cur,

			i = 0,

			l = this.length,

			matched = [],

			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?

				jQuery( selectors, context || this.context ) :

				0;

		for ( ; i < l; i++ ) {

			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {

				// Always skip document fragments

				if ( cur.nodeType < 11 && (pos ?

					pos.index(cur) > -1 :

					// Don't pass non-elements to Sizzle

					cur.nodeType === 1 &&

						jQuery.find.matchesSelector(cur, selectors)) ) {

					matched.push( cur );

					break;

				}

			}

		}

		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );

	},

	// Determine the position of an element within the set

	index: function( elem ) {

		// No argument, return index in parent

		if ( !elem ) {

			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;

		}

		// Index in selector

		if ( typeof elem === "string" ) {

			return indexOf.call( jQuery( elem ), this[ 0 ] );

		}

		// Locate the position of the desired element

		return indexOf.call( this,

			// If it receives a jQuery object, the first element is used

			elem.jquery ? elem[ 0 ] : elem

		);

	},

	add: function( selector, context ) {

		return this.pushStack(

			jQuery.unique(

				jQuery.merge( this.get(), jQuery( selector, context ) )

			)

		);

	},

	addBack: function( selector ) {

		return this.add( selector == null ?

			this.prevObject : this.prevObject.filter(selector)

		);

	}

});

function sibling( cur, dir ) {

	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}

	return cur;

}

jQuery.each({

	parent: function( elem ) {

		var parent = elem.parentNode;

		return parent && parent.nodeType !== 11 ? parent : null;

	},

	parents: function( elem ) {

		return jQuery.dir( elem, "parentNode" );

	},

	parentsUntil: function( elem, i, until ) {

		return jQuery.dir( elem, "parentNode", until );

	},

	next: function( elem ) {

		return sibling( elem, "nextSibling" );

	},

	prev: function( elem ) {

		return sibling( elem, "previousSibling" );

	},

	nextAll: function( elem ) {

		return jQuery.dir( elem, "nextSibling" );

	},

	prevAll: function( elem ) {

		return jQuery.dir( elem, "previousSibling" );

	},

	nextUntil: function( elem, i, until ) {

		return jQuery.dir( elem, "nextSibling", until );

	},

	prevUntil: function( elem, i, until ) {

		return jQuery.dir( elem, "previousSibling", until );

	},

	siblings: function( elem ) {

		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );

	},

	children: function( elem ) {

		return jQuery.sibling( elem.firstChild );

	},

	contents: function( elem ) {

		return elem.contentDocument || jQuery.merge( [], elem.childNodes );

	}

}, function( name, fn ) {

	jQuery.fn[ name ] = function( until, selector ) {

		var matched = jQuery.map( this, fn, until );

		if ( name.slice( -5 ) !== "Until" ) {

			selector = until;

		}

		if ( selector && typeof selector === "string" ) {

			matched = jQuery.filter( selector, matched );

		}

		if ( this.length > 1 ) {

			// Remove duplicates

			if ( !guaranteedUnique[ name ] ) {

				jQuery.unique( matched );

			}

			// Reverse order for parents* and prev-derivatives

			if ( rparentsprev.test( name ) ) {

				matched.reverse();

			}

		}

		return this.pushStack( matched );

	};

});

return jQuery;

});

define([

	"../var/support"

], function( support ) {

(function() {

	var fragment = document.createDocumentFragment(),

		div = fragment.appendChild( document.createElement( "div" ) ),

		input = document.createElement( "input" );

	// Support: Safari<=5.1

	// Check state lost if the name is set (#11217)

	// Support: Windows Web Apps (WWA)

	// `name` and `type` must use .setAttribute for WWA (#14901)

	input.setAttribute( "type", "radio" );

	input.setAttribute( "checked", "checked" );

	input.setAttribute( "name", "t" );

	div.appendChild( input );

	// Support: Safari<=5.1, Android<4.2

	// Older WebKit doesn't clone checked state correctly in fragments

	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;

	// Support: IE<=11+

	// Make sure textarea (and checkbox) defaultValue is properly cloned

	div.innerHTML = "<textarea>x</textarea>";

	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;

})();

return support;

});

define([

	"../core",

	"./support",

	"../core/init"

], function( jQuery, support ) {

var rreturn = /\r/g;

jQuery.fn.extend({

	val: function( value ) {

		var hooks, ret, isFunction,

			elem = this[0];

		if ( !arguments.length ) {

			if ( elem ) {

				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];

				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {

					return ret;

				}

				ret = elem.value;

				return typeof ret === "string" ?

					// Handle most common string cases

					ret.replace(rreturn, "") :

					// Handle cases where value is null/undef or number

					ret == null ? "" : ret;

			}

			return;

		}

		isFunction = jQuery.isFunction( value );

		return this.each(function( i ) {

			var val;

			if ( this.nodeType !== 1 ) {

				return;

			}

			if ( isFunction ) {

				val = value.call( this, i, jQuery( this ).val() );

			} else {

				val = value;

			}

			// Treat null/undefined as ""; convert numbers to string

			if ( val == null ) {

				val = "";

			} else if ( typeof val === "number" ) {

				val += "";

			} else if ( jQuery.isArray( val ) ) {

				val = jQuery.map( val, function( value ) {

					return value == null ? "" : value + "";

				});

			}

			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

			// If set returns undefined, fall back to normal setting

			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {

				this.value = val;

			}

		});

	}

});

jQuery.extend({

	valHooks: {

		option: {

			get: function( elem ) {

				var val = jQuery.find.attr( elem, "value" );

				return val != null ?

					val :

					// Support: IE10-11+

					// option.text throws exceptions (#14686, #14858)

					jQuery.trim( jQuery.text( elem ) );

			}

		},

		select: {

			get: function( elem ) {

				var value, option,

					options = elem.options,

					index = elem.selectedIndex,

					one = elem.type === "select-one" || index < 0,

					values = one ? null : [],

					max = one ? index + 1 : options.length,

					i = index < 0 ?

						max :

						one ? index : 0;

				// Loop through all the selected options

				for ( ; i < max; i++ ) {

					option = options[ i ];

					// IE6-9 doesn't update selected after form reset (#2551)

					if ( ( option.selected || i === index ) &&

							// Don't return options that are disabled or in a disabled optgroup

							( support.optDisabled ? !option.disabled : option.getAttribute( "disabled" ) === null ) &&

							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {

						// Get the specific value for the option

						value = jQuery( option ).val();

						// We don't need an array for one selects

						if ( one ) {

							return value;

						}

						// Multi-Selects return an array

						values.push( value );

					}

				}

				return values;

			},

			set: function( elem, value ) {

				var optionSet, option,

					options = elem.options,

					values = jQuery.makeArray( value ),

					i = options.length;

				while ( i-- ) {

					option = options[ i ];

					if ( (option.selected = jQuery.inArray( option.value, values ) >= 0) ) {

						optionSet = true;

					}

				}

				// Force browsers to behave consistently when non-matching value is set

				if ( !optionSet ) {

					elem.selectedIndex = -1;

				}

				return values;

			}

		}

	}

});

// Radios and checkboxes getter/setter

jQuery.each([ "radio", "checkbox" ], function() {

	jQuery.valHooks[ this ] = {

		set: function( elem, value ) {

			if ( jQuery.isArray( value ) ) {

				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );

			}

		}

	};

	if ( !support.checkOn ) {

		jQuery.valHooks[ this ].get = function( elem ) {

			return elem.getAttribute("value") === null ? "on" : elem.value;

		};

	}

});

});

define([

	"./core",

	"./var/pnum",

	"./core/access",

	"./css/var/rmargin",

	"./css/var/rnumnonpx",

	"./css/var/cssExpand",

	"./css/var/isHidden",

	"./css/var/getStyles",

	"./css/curCSS",

	"./css/defaultDisplay",

	"./css/addGetHookIf",

	"./css/support",

	"./data/var/data_priv",

	"./core/init",

	"./css/swap",

	"./core/ready",

	"./selector" // contains

], function( jQuery, pnum, access, rmargin, rnumnonpx, cssExpand, isHidden,

	getStyles, curCSS, defaultDisplay, addGetHookIf, support, data_priv ) {

var

	// Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"

	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display

	rdisplayswap = /^(none|table(?!-c[ea]).+)/,

	rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),

	rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),

	cssShow = { position: "absolute", visibility: "hidden", display: "block" },

	cssNormalTransform = {

		letterSpacing: "0",

		fontWeight: "400"

	},

	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];

// Return a css property mapped to a potentially vendor prefixed property

function vendorPropName( style, name ) {

	// Shortcut for names that are not vendor prefixed

	if ( name in style ) {

		return name;

	}

	// Check for vendor prefixed names

	var capName = name[0].toUpperCase() + name.slice(1),

		origName = name,

		i = cssPrefixes.length;

	while ( i-- ) {

		name = cssPrefixes[ i ] + capName;

		if ( name in style ) {

			return name;

		}

	}

	return origName;

}

function setPositiveNumber( elem, value, subtract ) {

	var matches = rnumsplit.exec( value );

	return matches ?

		// Guard against undefined "subtract", e.g., when used as in cssHooks

		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :

		value;

}

function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {

	var i = extra === ( isBorderBox ? "border" : "content" ) ?

		// If we already have the right measurement, avoid augmentation

		4 :

		// Otherwise initialize for horizontal or vertical properties

		name === "width" ? 1 : 0,

		val = 0;

	for ( ; i < 4; i += 2 ) {

		// Both box models exclude margin, so add it if we want it

		if ( extra === "margin" ) {

			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );

		}

		if ( isBorderBox ) {

			// border-box includes padding, so remove it if we want content

			if ( extra === "content" ) {

				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

			}

			// At this point, extra isn't border nor margin, so remove border

			if ( extra !== "margin" ) {

				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );

			}

		} else {

			// At this point, extra isn't content, so add padding

			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

			// At this point, extra isn't content nor padding, so add border

			if ( extra !== "padding" ) {

				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );

			}

		}

	}

	return val;

}

function getWidthOrHeight( elem, name, extra ) {

	// Start with offset property, which is equivalent to the border-box value

	var valueIsBorderBox = true,

		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,

		styles = getStyles( elem ),

		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

	// Some non-html elements return undefined for offsetWidth, so check for null/undefined

	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285

	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668

	if ( val <= 0 || val == null ) {

		// Fall back to computed then uncomputed css if necessary

		val = curCSS( elem, name, styles );

		if ( val < 0 || val == null ) {

			val = elem.style[ name ];

		}

		// Computed unit is not pixels. Stop here and return.

		if ( rnumnonpx.test(val) ) {

			return val;

		}

		// Check for style in case a browser which returns unreliable values

		// for getComputedStyle silently falls back to the reliable elem.style

		valueIsBorderBox = isBorderBox &&

			( support.boxSizingReliable() || val === elem.style[ name ] );

		// Normalize "", auto, and prepare for extra

		val = parseFloat( val ) || 0;

	}

	// Use the active box-sizing model to add/subtract irrelevant styles

	return ( val +

		augmentWidthOrHeight(

			elem,

			name,

			extra || ( isBorderBox ? "border" : "content" ),

			valueIsBorderBox,

			styles

		)

	) + "px";

}

function showHide( elements, show ) {

	var display, elem, hidden,

		values = [],

		index = 0,

		length = elements.length;

	for ( ; index < length; index++ ) {

		elem = elements[ index ];

		if ( !elem.style ) {

			continue;

		}

		values[ index ] = data_priv.get( elem, "olddisplay" );

		display = elem.style.display;

		if ( show ) {

			// Reset the inline display of this element to learn if it is

			// being hidden by cascaded rules or not

			if ( !values[ index ] && display === "none" ) {

				elem.style.display = "";

			}

			// Set elements which have been overridden with display: none

			// in a stylesheet to whatever the default browser style is

			// for such an element

			if ( elem.style.display === "" && isHidden( elem ) ) {

				values[ index ] = data_priv.access( elem, "olddisplay", defaultDisplay(elem.nodeName) );

			}

		} else {

			hidden = isHidden( elem );

			if ( display !== "none" || !hidden ) {

				data_priv.set( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );

			}

		}

	}

	// Set the display of most of the elements in a second loop

	// to avoid the constant reflow

	for ( index = 0; index < length; index++ ) {

		elem = elements[ index ];

		if ( !elem.style ) {

			continue;

		}

		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {

			elem.style.display = show ? values[ index ] || "" : "none";

		}

	}

	return elements;

}

jQuery.extend({

	// Add in style property hooks for overriding the default

	// behavior of getting and setting a style property

	cssHooks: {

		opacity: {

			get: function( elem, computed ) {

				if ( computed ) {

					// We should always get a number back from opacity

					var ret = curCSS( elem, "opacity" );

					return ret === "" ? "1" : ret;

				}

			}

		}

	},

	// Don't automatically add "px" to these possibly-unitless properties

	cssNumber: {

		"columnCount": true,

		"fillOpacity": true,

		"flexGrow": true,

		"flexShrink": true,

		"fontWeight": true,

		"lineHeight": true,

		"opacity": true,

		"order": true,

		"orphans": true,

		"widows": true,

		"zIndex": true,

		"zoom": true

	},

	// Add in properties whose names you wish to fix before

	// setting or getting the value

	cssProps: {

		"float": "cssFloat"

	},

	// Get and set the style property on a DOM Node

	style: function( elem, name, value, extra ) {

		// Don't set styles on text and comment nodes

		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {

			return;

		}

		// Make sure that we're working with the right name

		var ret, type, hooks,

			origName = jQuery.camelCase( name ),

			style = elem.style;

		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );

		// Gets hook for the prefixed version, then unprefixed version

		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

		// Check if we're setting a value

		if ( value !== undefined ) {

			type = typeof value;

			// Convert "+=" or "-=" to relative numbers (#7345)

			if ( type === "string" && (ret = rrelNum.exec( value )) ) {

				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );

				// Fixes bug #9237

				type = "number";

			}

			// Make sure that null and NaN values aren't set (#7116)

			if ( value == null || value !== value ) {

				return;

			}

			// If a number, add 'px' to the (except for certain CSS properties)

			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {

				value += "px";

			}

			// Support: IE9-11+

			// background-* props affect original clone's values

			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {

				style[ name ] = "inherit";

			}

			// If a hook was provided, use that value, otherwise just set the specified value

			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {

				style[ name ] = value;

			}

		} else {

			// If a hook was provided get the non-computed value from there

			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {

				return ret;

			}

			// Otherwise just get the value from the style object

			return style[ name ];

		}

	},

	css: function( elem, name, extra, styles ) {

		var val, num, hooks,

			origName = jQuery.camelCase( name );

		// Make sure that we're working with the right name

		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );

		// Try prefixed name followed by the unprefixed name

		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

		// If a hook was provided get the computed value from there

		if ( hooks && "get" in hooks ) {

			val = hooks.get( elem, true, extra );

		}

		// Otherwise, if a way to get the computed value exists, use that

		if ( val === undefined ) {

			val = curCSS( elem, name, styles );

		}

		// Convert "normal" to computed value

		if ( val === "normal" && name in cssNormalTransform ) {

			val = cssNormalTransform[ name ];

		}

		// Make numeric if forced or a qualifier was provided and val looks numeric

		if ( extra === "" || extra ) {

			num = parseFloat( val );

			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;

		}

		return val;

	}

});

jQuery.each([ "height", "width" ], function( i, name ) {

	jQuery.cssHooks[ name ] = {

		get: function( elem, computed, extra ) {

			if ( computed ) {

				// Certain elements can have dimension info if we invisibly show them

				// but it must have a current display style that would benefit

				return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?

					jQuery.swap( elem, cssShow, function() {

						return getWidthOrHeight( elem, name, extra );

					}) :

					getWidthOrHeight( elem, name, extra );

			}

		},

		set: function( elem, value, extra ) {

			var styles = extra && getStyles( elem );

			return setPositiveNumber( elem, value, extra ?

				augmentWidthOrHeight(

					elem,

					name,

					extra,

					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",

					styles

				) : 0

			);

		}

	};

});

// Support: Android 2.3

jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,

	function( elem, computed ) {

		if ( computed ) {

			return jQuery.swap( elem, { "display": "inline-block" },

				curCSS, [ elem, "marginRight" ] );

		}

	}

);

// These hooks are used by animate to expand properties

jQuery.each({

	margin: "",

	padding: "",

	border: "Width"

}, function( prefix, suffix ) {

	jQuery.cssHooks[ prefix + suffix ] = {

		expand: function( value ) {

			var i = 0,

				expanded = {},

				// Assumes a single number if not a string

				parts = typeof value === "string" ? value.split(" ") : [ value ];

			for ( ; i < 4; i++ ) {

				expanded[ prefix + cssExpand[ i ] + suffix ] =

					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];

			}

			return expanded;

		}

	};

	if ( !rmargin.test( prefix ) ) {

		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;

	}

});

jQuery.fn.extend({

	css: function( name, value ) {

		return access( this, function( elem, name, value ) {

			var styles, len,

				map = {},

				i = 0;

			if ( jQuery.isArray( name ) ) {

				styles = getStyles( elem );

				len = name.length;

				for ( ; i < len; i++ ) {

					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );

				}

				return map;

			}

			return value !== undefined ?

				jQuery.style( elem, name, value ) :

				jQuery.css( elem, name );

		}, name, value, arguments.length > 1 );

	},

	show: function() {

		return showHide( this, true );

	},

	hide: function() {

		return showHide( this );

	},

	toggle: function( state ) {

		if ( typeof state === "boolean" ) {

			return state ? this.show() : this.hide();

		}

		return this.each(function() {

			if ( isHidden( this ) ) {

				jQuery( this ).show();

			} else {

				jQuery( this ).hide();

			}

		});

	}

});

return jQuery;

});

define(function() {

	// Match a standalone tag

	return (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);

});

define([

	"../core"

], function( jQuery ) {

// Multifunctional method to get and set values of a collection

// The value/s can optionally be executed if it's a function

var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {

	var i = 0,

		len = elems.length,

		bulk = key == null;

	// Sets many values

	if ( jQuery.type( key ) === "object" ) {

		chainable = true;

		for ( i in key ) {

			jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );

		}

	// Sets one value

	} else if ( value !== undefined ) {

		chainable = true;

		if ( !jQuery.isFunction( value ) ) {

			raw = true;

		}

		if ( bulk ) {

			// Bulk operations run against the entire set

			if ( raw ) {

				fn.call( elems, value );

				fn = null;

			// ...except when executing function values

			} else {

				bulk = fn;

				fn = function( elem, key, value ) {

					return bulk.call( jQuery( elem ), value );

				};

			}

		}

		if ( fn ) {

			for ( ; i < len; i++ ) {

				fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );

			}

		}

	}

	return chainable ?

		elems :

		// Gets

		bulk ?

			fn.call( elems ) :

			len ? fn( elems[0], key ) : emptyGet;

};

return access;

});

#!/usr/bin/python

#

# Flask server, woo!

#

import json

from flask import Flask, jsonify, request

from flask.json import JSONEncoder

from DLIObject import DLIObject, DLIRelation

import logging

from DLIQueryResolver import QueryResolver

class MyJSONEncoder(JSONEncoder):

    def default(self, obj):

        if isinstance(obj, DLIObject):

            return obj.__dict__

        if isinstance(obj, DLIRelation):

            return obj.__dict__

        return super(MyJSONEncoder, self).default(obj)

app = Flask(__name__)

app.debug = True

app.json_encoder = MyJSONEncoder

host = "http://node0.d.dli.research-infrastructures.eu:8983/solr/DLIF-index-cleaned_shard1_replica1"

# q = QueryResolver("http://localhost:8983/solr/DLIF-index-cleaned_shard1_replica1")

class InvalidUsage(Exception):

    status_code = 400

    def __init__(self, message, status_code=None, payload=None):

        Exception.__init__(self)

        self.message = message

        if status_code is not None:

            self.status_code = status_code

        self.payload = payload

    def to_dict(self):

        rv = dict(self.payload or ())

        rv['message'] = self.message

        return rv

# Routes

@app.route('/')

def root():

    return app.send_static_file('index.html')

@app.route('/<path:path>')

def static_proxy(path):

    # send_static_file will guess the correct MIME type

    return app.send_static_file(path)

@app.route('/api/item/<path:identifier>', methods=['post', 'get'])

def getItem(identifier):

    if identifier:

        q = QueryResolver(host)

        return jsonify(result=q.get_item(identifier))

    else:

        raise InvalidUsage('This view is gone', status_code=410)

@app.route('/api/stats/', methods=['post', 'get'])

def stats():

    q = QueryResolver(host)

    return jsonify(stats=q.get_stats())

@app.route('/api/stats_detail/', methods=['post', 'get'])

def stats_detail():

    q = QueryResolver(host)

    return jsonify(stats=q.get_stats_detail())

@app.route('/api/post/', methods=['post', 'get'])

def query_post():

    action = None

    query = None

    only_result = False

    filter_query = None

    start = 0

    if 'action' in request.form:

        action = request.form['action']

    if 'query' in request.form:

        query = request.form['query']

    if 'only_result' in request.form:

        only_result = True

    if 'browse_field' in request.form:

        try:

            filter_query = json.loads(request.form['browse_field'])

            print filter_query

        except:

            logging.error("Unable to parse browse_field, current value %s" % request.form['browse_field'])

    print type(filter_query)

    if 'start' in request.form:

        start = int(request.form['start'])

    if action == 'query' and query is not None:

        q = QueryResolver(host)

        result = q.query(q=query, browse_fields=["entitytype", "provenance"], start=start, only_result=only_result,

                         filter_query=filter_query)

        return jsonify(result=result)

    else:

        return jsonify(error={'error_code': 'an error occur during query on server'})

if __name__ == '__main__':

    app.run(debug=True, host='0.0.0.0', processes=5)

define([

	"../Data"

], function( Data ) {

	return new Data();

});

define([

	"../var/support"

], function( support ) {

support.focusinBubbles = "onfocusin" in window;

return support;

});

from xml.dom.minidom import  parseString

import logging

import re

p = re.compile("((https?):((//)|(\\\\))+([\w\d:#@%/;$()~_?\+-=\\\.&](#!)?)*)")

def get_single_node(node, nodeName, nodeNamespace):

    results = node.getElementsByTagNameNS(nodeNamespace, nodeName)

    if len(results) > 0:

        return results[0]

    return None

def get_children_nodes(node, nodeName, nodeNamespace):

    results = node.getElementsByTagNameNS(nodeNamespace, nodeName)

    if len(results) > 0:

        return results

    return None

def get_text_value(node):

    children = node.childNodes

    if len(children)>0:

        return children[0].data

    return ""

class DLIRelation(object):

    def __init__(self, rel_node=None, dli_namespace=None):

        if dli_namespace is None:

            self.namespace = "http://www.dli.eu"

        else:

            self.namespace = dli_namespace

        if rel_node is not None:

            self._initialize_with_rel_node(rel_node)

    def _associate_identifier(self, rel_node):

        dnet_id_node = get_single_node(rel_node, "dnetIdentifier", self.namespace)