Synnefo

/*!

 * jQuery JavaScript Library v1.9.1

 * http://jquery.com/

 *

 * Includes Sizzle.js

 * http://sizzlejs.com/

 *

 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors

 * Released under the MIT license

 * http://jquery.org/license

 *

 * Date: 2013-2-4

 */

(function( window, undefined ) {

// Can't do this because several apps including ASP.NET trace

// the stack via arguments.caller.callee and Firefox dies if

// you try to trace through "use strict" call chains. (#13335)

// Support: Firefox 18+

//"use strict";

var

  // The deferred used on DOM ready

  readyList,

  // A central reference to the root jQuery(document)

  rootjQuery,

  // Support: IE<9

  // For `typeof node.method` instead of `node.method !== undefined`

  core_strundefined = typeof undefined,

  // Use the correct document accordingly with window argument (sandbox)

  document = window.document,

  location = window.location,

  // Map over jQuery in case of overwrite

  _jQuery = window.jQuery,

  // Map over the $ in case of overwrite

  _$ = window.$,

  // [[Class]] -> type pairs

  class2type = {},

  // List of deleted data cache ids, so we can reuse them

  core_deletedIds = [],

  core_version = "1.9.1",

  // Save a reference to some core methods

  core_concat = core_deletedIds.concat,

  core_push = core_deletedIds.push,

  core_slice = core_deletedIds.slice,

  core_indexOf = core_deletedIds.indexOf,

  core_toString = class2type.toString,

  core_hasOwn = class2type.hasOwnProperty,

  core_trim = core_version.trim,

  // Define a local copy of jQuery

  jQuery = function( selector, context ) {

    // The jQuery object is actually just the init constructor 'enhanced'

    return new jQuery.fn.init( selector, context, rootjQuery );

  },

  // Used for matching numbers

  core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,

  // Used for splitting on whitespace

  core_rnotwhite = /\S+/g,

  // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)

  rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

  // A simple way to check for HTML strings

  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)

  // Strict HTML recognition (#11290: must start with <)

  rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,

  // Match a standalone tag

  rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,

  // JSON RegExp

  rvalidchars = /^[\],:{}\s]*$/,

  rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

  rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,

  rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,

  // Matches dashed string for camelizing

  rmsPrefix = /^-ms-/,

  rdashAlpha = /-([\da-z])/gi,

  // Used by jQuery.camelCase as callback to replace()

  fcamelCase = function( all, letter ) {

    return letter.toUpperCase();

  },

  // The ready event handler

  completed = function( event ) {

    // readyState === "complete" is good enough for us to call the dom ready in oldIE

    if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {

      detach();

      jQuery.ready();

    }

  },

  // Clean-up method for dom ready events

  detach = function() {

    if ( document.addEventListener ) {

      document.removeEventListener( "DOMContentLoaded", completed, false );

      window.removeEventListener( "load", completed, false );

    } else {

      document.detachEvent( "onreadystatechange", completed );

      window.detachEvent( "onload", completed );

    }

  };

jQuery.fn = jQuery.prototype = {

  // The current version of jQuery being used

  jquery: core_version,

  constructor: jQuery,

  init: function( selector, context, rootjQuery ) {

    var match, elem;

    // HANDLE: $(""), $(null), $(undefined), $(false)

    if ( !selector ) {

      return this;

    }

    // Handle HTML strings

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

      if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {

        // Assume that strings that start and end with <> are HTML and skip the regex check

        match = [ null, selector, null ];

      } else {

        match = rquickExpr.exec( selector );

      }

      // Match html or make sure no context is specified for #id

      if ( match && (match[1] || !context) ) {

        // HANDLE: $(html) -> $(array)

        if ( match[1] ) {

          context = context instanceof jQuery ? context[0] : context;

          // scripts is true for back-compat

          jQuery.merge( this, jQuery.parseHTML(

            match[1],

            context && context.nodeType ? context.ownerDocument || context : document,

            true

          ) );

          // HANDLE: $(html, props)

          if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {

            for ( match in context ) {

              // Properties of context are called as methods if possible

              if ( jQuery.isFunction( this[ match ] ) ) {

                this[ match ]( context[ match ] );

              // ...and otherwise set as attributes

              } else {

                this.attr( match, context[ match ] );

              }

            }

          }

          return this;

        // HANDLE: $(#id)

        } else {

          elem = document.getElementById( match[2] );

          // Check parentNode to catch when Blackberry 4.6 returns

          // nodes that are no longer in the document #6963

          if ( elem && elem.parentNode ) {

            // Handle the case where IE and Opera return items

            // by name instead of ID

            if ( elem.id !== match[2] ) {

              return rootjQuery.find( selector );

            }

            // Otherwise, we inject the element directly into the jQuery object

            this.length = 1;

            this[0] = elem;

          }

          this.context = document;

          this.selector = selector;

          return this;

        }

      // HANDLE: $(expr, $(...))

      } else if ( !context || context.jquery ) {

        return ( context || rootjQuery ).find( selector );

      // HANDLE: $(expr, context)

      // (which is just equivalent to: $(context).find(expr)

      } else {

        return this.constructor( context ).find( selector );

      }

    // HANDLE: $(DOMElement)

    } else if ( selector.nodeType ) {

      this.context = this[0] = selector;

      this.length = 1;

      return this;

    // HANDLE: $(function)

    // Shortcut for document ready

    } else if ( jQuery.isFunction( selector ) ) {

      return rootjQuery.ready( selector );

    }

    if ( selector.selector !== undefined ) {

      this.selector = selector.selector;

      this.context = selector.context;

    }

    return jQuery.makeArray( selector, this );

  },

  // Start with an empty selector

  selector: "",

  // The default length of a jQuery object is 0

  length: 0,

  // The number of elements contained in the matched element set

  size: function() {

    return this.length;

  },

  toArray: function() {

    return core_slice.call( this );

  },

  // Get the Nth element in the matched element set OR

  // Get the whole matched element set as a clean array

  get: function( num ) {

    return num == null ?

      // Return a 'clean' array

      this.toArray() :

      // Return just the object

      ( num < 0 ? this[ this.length + num ] : this[ num ] );

  },

  // Take an array of elements and push it onto the stack

  // (returning the new matched element set)

  pushStack: function( elems ) {

    // Build a new jQuery matched element set

    var ret = jQuery.merge( this.constructor(), elems );

    // Add the old object onto the stack (as a reference)

    ret.prevObject = this;

    ret.context = this.context;

    // Return the newly-formed element set

    return ret;

  },

  // Execute a callback for every element in the matched set.

  // (You can seed the arguments with an array of args, but this is

  // only used internally.)

  each: function( callback, args ) {

    return jQuery.each( this, callback, args );

  },

  ready: function( fn ) {

    // Add the callback

    jQuery.ready.promise().done( fn );

    return this;

  },

  slice: function() {

    return this.pushStack( core_slice.apply( this, arguments ) );

  },

  first: function() {

    return this.eq( 0 );

  },

  last: function() {

    return this.eq( -1 );

  },

  eq: function( i ) {

    var len = this.length,

      j = +i + ( i < 0 ? len : 0 );

    return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );

  },

  map: function( callback ) {

    return this.pushStack( jQuery.map(this, function( elem, i ) {

      return callback.call( elem, i, elem );

    }));

  },

  end: function() {

    return this.prevObject || this.constructor(null);

  },

  // For internal use only.

  // Behaves like an Array's method, not like a jQuery method.

  push: core_push,

  sort: [].sort,

  splice: [].splice

};

// Give the init function the jQuery prototype for later instantiation

jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {

  var src, copyIsArray, copy, name, options, clone,

    target = arguments[0] || {},

    i = 1,

    length = arguments.length,

    deep = false;

  // Handle a deep copy situation

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

    deep = target;

    target = arguments[1] || {};

    // skip the boolean and the target

    i = 2;

  }

  // Handle case when target is a string or something (possible in deep copy)

  if ( typeof target !== "object" && !jQuery.isFunction(target) ) {

    target = {};

  }

  // extend jQuery itself if only one argument is passed

  if ( length === i ) {

    target = this;

    --i;

  }

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

    // Only deal with non-null/undefined values

    if ( (options = arguments[ i ]) != null ) {

      // Extend the base object

      for ( name in options ) {

        src = target[ name ];

        copy = options[ name ];

        // Prevent never-ending loop

        if ( target === copy ) {

          continue;

        }

        // Recurse if we're merging plain objects or arrays

        if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {

          if ( copyIsArray ) {

            copyIsArray = false;

            clone = src && jQuery.isArray(src) ? src : [];

          } else {

            clone = src && jQuery.isPlainObject(src) ? src : {};

          }

          // Never move original objects, clone them

          target[ name ] = jQuery.extend( deep, clone, copy );

        // Don't bring in undefined values

        } else if ( copy !== undefined ) {

          target[ name ] = copy;

        }

      }

    }

  }

  // Return the modified object

  return target;

};

jQuery.extend({

  noConflict: function( deep ) {

    if ( window.$ === jQuery ) {

      window.$ = _$;

    }

    if ( deep && window.jQuery === jQuery ) {

      window.jQuery = _jQuery;

    }

    return jQuery;

  },

  // Is the DOM ready to be used? Set to true once it occurs.

  isReady: false,

  // A counter to track how many items to wait for before

  // the ready event fires. See #6781

  readyWait: 1,

  // Hold (or release) the ready event

  holdReady: function( hold ) {

    if ( hold ) {

      jQuery.readyWait++;

    } else {

      jQuery.ready( true );

    }

  },

  // Handle when the DOM is ready

  ready: function( wait ) {

    // Abort if there are pending holds or we're already ready

    if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {

      return;

    }

    // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

    if ( !document.body ) {

      return setTimeout( jQuery.ready );

    }

    // Remember that the DOM is ready

    jQuery.isReady = true;

    // If a normal DOM Ready event fired, decrement, and wait if need be

    if ( wait !== true && --jQuery.readyWait > 0 ) {

      return;

    }

    // If there are functions bound, to execute

    readyList.resolveWith( document, [ jQuery ] );

    // Trigger any bound ready events

    if ( jQuery.fn.trigger ) {

      jQuery( document ).trigger("ready").off("ready");

    }

  },

  // See test/unit/core.js for details concerning isFunction.

  // Since version 1.3, DOM methods and functions like alert

  // aren't supported. They return false on IE (#2968).

  isFunction: function( obj ) {

    return jQuery.type(obj) === "function";

  },

  isArray: Array.isArray || function( obj ) {

    return jQuery.type(obj) === "array";

  },

  isWindow: function( obj ) {

    return obj != null && obj == obj.window;

  },

  isNumeric: function( obj ) {

    return !isNaN( parseFloat(obj) ) && isFinite( obj );

  },

  type: function( obj ) {

    if ( obj == null ) {

      return String( obj );

    }

    return typeof obj === "object" || typeof obj === "function" ?

      class2type[ core_toString.call(obj) ] || "object" :

      typeof obj;

  },

  isPlainObject: function( obj ) {

    // Must be an Object.

    // Because of IE, we also have to check the presence of the constructor property.

    // Make sure that DOM nodes and window objects don't pass through, as well

    if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {

      return false;

    }

    try {

      // Not own constructor property must be Object

      if ( obj.constructor &&

        !core_hasOwn.call(obj, "constructor") &&

        !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {

        return false;

      }

    } catch ( e ) {

      // IE8,9 Will throw exceptions on certain host objects #9897

      return false;

    }

    // Own properties are enumerated firstly, so to speed up,

    // if last one is own, then all properties are own.

    var key;

    for ( key in obj ) {}

    return key === undefined || core_hasOwn.call( obj, key );

  },

  isEmptyObject: function( obj ) {

    var name;

    for ( name in obj ) {

      return false;

    }

    return true;

  },

  error: function( msg ) {

    throw new Error( msg );

  },

  // data: string of html

  // context (optional): If specified, the fragment will be created in this context, defaults to document

  // keepScripts (optional): If true, will include scripts passed in the html string

  parseHTML: function( data, context, keepScripts ) {

    if ( !data || typeof data !== "string" ) {

      return null;

    }

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

      keepScripts = context;

      context = false;

    }

    context = context || document;

    var parsed = rsingleTag.exec( data ),

      scripts = !keepScripts && [];

    // Single tag

    if ( parsed ) {

      return [ context.createElement( parsed[1] ) ];

    }

    parsed = jQuery.buildFragment( [ data ], context, scripts );

    if ( scripts ) {

      jQuery( scripts ).remove();

    }

    return jQuery.merge( [], parsed.childNodes );

  },

  parseJSON: function( data ) {

    // Attempt to parse using the native JSON parser first

    if ( window.JSON && window.JSON.parse ) {

      return window.JSON.parse( data );

    }

    if ( data === null ) {

      return data;

    }

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

      // Make sure leading/trailing whitespace is removed (IE can't handle it)

      data = jQuery.trim( data );

      if ( data ) {

        // Make sure the incoming data is actual JSON

        // Logic borrowed from http://json.org/json2.js

        if ( rvalidchars.test( data.replace( rvalidescape, "@" )

          .replace( rvalidtokens, "]" )

          .replace( rvalidbraces, "")) ) {

          return ( new Function( "return " + data ) )();

        }

      }

    }

    jQuery.error( "Invalid JSON: " + data );

  },

  // Cross-browser xml parsing

  parseXML: function( data ) {

    var xml, tmp;

    if ( !data || typeof data !== "string" ) {

      return null;

    }

    try {

      if ( window.DOMParser ) { // Standard

        tmp = new DOMParser();

        xml = tmp.parseFromString( data , "text/xml" );

      } else { // IE

        xml = new ActiveXObject( "Microsoft.XMLDOM" );

        xml.async = "false";

        xml.loadXML( data );

      }

    } catch( e ) {

      xml = undefined;

    }

    if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {

      jQuery.error( "Invalid XML: " + data );

    }

    return xml;

  },

  noop: function() {},

  // Evaluates a script in a global context

  // Workarounds based on findings by Jim Driscoll

  // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context

  globalEval: function( data ) {

    if ( data && jQuery.trim( data ) ) {

      // We use execScript on Internet Explorer

      // We use an anonymous function so that context is window

      // rather than jQuery in Firefox

      ( window.execScript || function( data ) {

        window[ "eval" ].call( window, data );

      } )( data );

    }

  },

  // Convert dashed to camelCase; used by the css and data modules

  // Microsoft forgot to hump their vendor prefix (#9572)

  camelCase: function( string ) {

    return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );

  },

  nodeName: function( elem, name ) {

    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();

  },

  // args is for internal usage only

  each: function( obj, callback, args ) {

    var value,

      i = 0,

      length = obj.length,

      isArray = isArraylike( obj );

    if ( args ) {

      if ( isArray ) {

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

          value = callback.apply( obj[ i ], args );

          if ( value === false ) {

            break;

          }

        }

      } else {

        for ( i in obj ) {

          value = callback.apply( obj[ i ], args );

          if ( value === false ) {

            break;

          }

        }

      }

    // A special, fast, case for the most common use of each

    } else {

      if ( isArray ) {

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

          value = callback.call( obj[ i ], i, obj[ i ] );

          if ( value === false ) {

            break;

          }

        }

      } else {

        for ( i in obj ) {

          value = callback.call( obj[ i ], i, obj[ i ] );

          if ( value === false ) {

            break;

          }

        }

      }

    }

    return obj;

  },

  // Use native String.trim function wherever possible

  trim: core_trim && !core_trim.call("\uFEFF\xA0") ?

    function( text ) {

      return text == null ?

        "" :

        core_trim.call( text );

    } :

    // Otherwise use our own trimming functionality

    function( text ) {

      return text == null ?

        "" :

        ( text + "" ).replace( rtrim, "" );

    },

  // results is for internal usage only

  makeArray: function( arr, results ) {

    var ret = results || [];

    if ( arr != null ) {

      if ( isArraylike( Object(arr) ) ) {

        jQuery.merge( ret,

          typeof arr === "string" ?

          [ arr ] : arr

        );

      } else {

        core_push.call( ret, arr );

      }

    }

    return ret;

  },

  inArray: function( elem, arr, i ) {

    var len;

    if ( arr ) {

      if ( core_indexOf ) {

        return core_indexOf.call( arr, elem, i );

      }

      len = arr.length;

      i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

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

        // Skip accessing in sparse arrays

        if ( i in arr && arr[ i ] === elem ) {

          return i;

        }

      }

    }

    return -1;

  },

  merge: function( first, second ) {

    var l = second.length,

      i = first.length,

      j = 0;

    if ( typeof l === "number" ) {

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

        first[ i++ ] = second[ j ];

      }

    } else {

      while ( second[j] !== undefined ) {

        first[ i++ ] = second[ j++ ];

      }

    }

    first.length = i;

    return first;

  },

  grep: function( elems, callback, inv ) {

    var retVal,

      ret = [],

      i = 0,

      length = elems.length;

    inv = !!inv;

    // Go through the array, only saving the items

    // that pass the validator function

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

      retVal = !!callback( elems[ i ], i );

      if ( inv !== retVal ) {

        ret.push( elems[ i ] );

      }

    }

    return ret;

  },

  // arg is for internal usage only

  map: function( elems, callback, arg ) {

    var value,

      i = 0,

      length = elems.length,

      isArray = isArraylike( elems ),

      ret = [];

    // Go through the array, translating each of the items to their

    if ( isArray ) {

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

        value = callback( elems[ i ], i, arg );

        if ( value != null ) {

          ret[ ret.length ] = value;

        }

      }

    // Go through every key on the object,

    } else {

      for ( i in elems ) {

        value = callback( elems[ i ], i, arg );

        if ( value != null ) {

          ret[ ret.length ] = value;

        }

      }

    }

    // Flatten any nested arrays

    return core_concat.apply( [], ret );

  },

  // A global GUID counter for objects

  guid: 1,

  // Bind a function to a context, optionally partially applying any

  // arguments.

  proxy: function( fn, context ) {

    var args, proxy, tmp;

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

      tmp = fn[ context ];

      context = fn;

      fn = tmp;

    }

    // Quick check to determine if target is callable, in the spec

    // this throws a TypeError, but we will just return undefined.

    if ( !jQuery.isFunction( fn ) ) {

      return undefined;

    }

    // Simulated bind

    args = core_slice.call( arguments, 2 );

    proxy = function() {

      return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );

    };

    // Set the guid of unique handler to the same of original handler, so it can be removed

    proxy.guid = fn.guid = fn.guid || jQuery.guid++;

    return proxy;

  },

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

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

  access: function( elems, fn, key, value, chainable, emptyGet, raw ) {

    var i = 0,

      length = 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