https://www.losnotrequired.com/static/content_page-6d0843f94c45121…fcd3cd2bd60bee768bed6760422145af4ecd3bff.js

1189// $.ui might exist from components with no dependencies, e.g., $.ui.position
1190$.ui = $.ui || {};
1191
1192$.extend( $.ui, {
1193  version: "1.10.4",
1194
1195  keyCode: {
1196    BACKSPACE: 8,
1197    COMMA: 188,
1198    DELETE: 46,
1199    DOWN: 40,
1200    END: 35,
1201    ENTER: 13,
1202    ESCAPE: 27,
1203    HOME: 36,
1204    LEFT: 37,
1205    NUMPAD_ADD: 107,
1206    NUMPAD_DECIMAL: 110,
1207    NUMPAD_DIVIDE: 111,
1208    NUMPAD_ENTER: 108,
1209    NUMPAD_MULTIPLY: 106,
1210    NUMPAD_SUBTRACT: 109,
1211    PAGE_DOWN: 34,
1212    PAGE_UP: 33,
1213    PERIOD: 190,
1214    RIGHT: 39,
1215    SPACE: 32,
1216    TAB: 9,
1217    UP: 38
1218  }
1219});
1220
1221// plugins
1222$.fn.extend({
1223  focus: (function( orig ) {
1224    return function( delay, fn ) {
1225      return typeof delay === "number" ?
1226        this.each(function() {
1227          var elem = this;
1228          setTimeout(function() {
1229            $( elem ).focus();
1230            if ( fn ) {
1231              fn.call( elem );
1232            }
1233          }, delay );
1234        }) :
1235        orig.apply( this, arguments );
1236    };
1237  })( $.fn.focus ),
1238
1239  scrollParent: function() {
1240    var scrollParent;
1241    if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
1242      scrollParent = this.parents().filter(function() {
1243        return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
1244      }).eq(0);
1245    } else {
1246      scrollParent = this.parents().filter(function() {
1247        return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
1248      }).eq(0);
1249    }
1250
1251    return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
1252  },
1253
1254  zIndex: function( zIndex ) {
1255    if ( zIndex !== undefined ) {
1256      return this.css( "zIndex", zIndex );
1257    }
1258
1259    if ( this.length ) {
1260      var elem = $( this[ 0 ] ), position, value;
1261      while ( elem.length && elem[ 0 ] !== document ) {
1262        // Ignore z-index if position is set to a value where z-index is ignored by the browser
1263        // This makes behavior of this function consistent across browsers
1264        // WebKit always returns auto if the element is positioned
1265        position = elem.css( "position" );
1266        if ( position === "absolute" || position === "relative" || position === "fixed" ) {
1267          // IE returns 0 when zIndex is not specified
1268          // other browsers return a string
1269          // we ignore the case of nested elements with an explicit value of 0
1270          // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
1271          value = parseInt( elem.css( "zIndex" ), 10 );
1272          if ( !isNaN( value ) && value !== 0 ) {
1273            return value;
1274          }
1275        }
1276        elem = elem.parent();
1277      }
1278    }
1279
1280    return 0;
1281  },
1282
1283  uniqueId: function() {
1284    return this.each(function() {
1285      if ( !this.id ) {
1286        this.id = "ui-id-" + (++uuid);
1287      }
1288    });
1289  },
1290
1291  removeUniqueId: function() {
1292    return this.each(function() {
1293      if ( runiqueId.test( this.id ) ) {
1294        $( this ).removeAttr( "id" );
1295      }
1296    });
1297  }
1298});
1299
1300// selectors
1301function focusable( element, isTabIndexNotNaN ) {
1302  var map, mapName, img,
1303    nodeName = element.nodeName.toLowerCase();
1304  if ( "area" === nodeName ) {
1305    map = element.parentNode;
1306    mapName = map.name;
1307    if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
1308      return false;
1309    }
1310    img = $( "img[usemap=#" + mapName + "]" )[0];
1311    return !!img && visible( img );
1312  }
1313  return ( /input|select|textarea|button|object/.test( nodeName ) ?
1314    !element.disabled :
1315    "a" === nodeName ?
1316      element.href || isTabIndexNotNaN :
1317      isTabIndexNotNaN) &&
1318    // the element and all of its ancestors must be visible
1319    visible( element );
1320}
1321
1322function visible( element ) {
1323  return $.expr.filters.visible( element ) &&
1324    !$( element ).parents().addBack().filter(function() {
1325      return $.css( this, "visibility" ) === "hidden";
1326    }).length;
1327}
1328
1329$.extend( $.expr[ ":" ], {
1330  data: $.expr.createPseudo ?
1331    $.expr.createPseudo(function( dataName ) {
1332      return function( elem ) {
1333        return !!$.data( elem, dataName );
1334      };
1335    }) :
1336    // support: jQuery <1.8
1337    function( elem, i, match ) {
1338      return !!$.data( elem, match[ 3 ] );
1339    },
1340
1341  focusable: function( element ) {
1342    return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
1343  },
1344
1345  tabbable: function( element ) {
1346    var tabIndex = $.attr( element, "tabindex" ),
1347      isTabIndexNaN = isNaN( tabIndex );
1348    return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
1349  }
1350});
1351
1352// support: jQuery <1.8
1353if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
1354  $.each( [ "Width", "Height" ], function( i, name ) {
1355    var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
1356      type = name.toLowerCase(),
1357      orig = {
1358        innerWidth: $.fn.innerWidth,
1359        innerHeight: $.fn.innerHeight,
1360        outerWidth: $.fn.outerWidth,
1361        outerHeight: $.fn.outerHeight
1362      };
1363
1364    function reduce( elem, size, border, margin ) {
1365      $.each( side, function() {
1366        size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
1367        if ( border ) {
1368          size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
1369        }
1370        if ( margin ) {
1371          size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
1372        }
1373      });
1374      return size;
1375    }
1376

1579        returnValue = value.apply( this, arguments );
1580
1581        this._super = __super;
1582        this._superApply = __superApply;
1583
1584        return returnValue;
1585      };
1586    })();
1587  });
1588  constructor.prototype = $.widget.extend( basePrototype, {
1589    // TODO: remove support for widgetEventPrefix
1590    // always use the name + a colon as the prefix, e.g., draggable:start
1591    // don't prefix for widgets that aren't DOM-based
1592    widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
1593  }, proxiedPrototype, {
1594    constructor: constructor,
1595    namespace: namespace,
1596    widgetName: name,
1597    widgetFullName: fullName
1598  });
1599
1600  // If this widget is being redefined then we need to find all widgets that
1601  // are inheriting from it and redefine all of them so that they inherit from
1602  // the new version of this widget. We're essentially trying to replace one
1603  // level in the prototype chain.
1604  if ( existingConstructor ) {
1605    $.each( existingConstructor._childConstructors, function( i, child ) {
1606      var childPrototype = child.prototype;
1607
1608      // redefine the child widget using the same prototype that was
1609      // originally used, but inherit from the new version of the base
1610      $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
1611    });
1612    // remove the list of existing child constructors from the old constructor
1613    // so the old child constructors can be garbage collected
1614    delete existingConstructor._childConstructors;
1615  } else {
1616    base._childConstructors.push( constructor );
1617  }
1618
1619  $.widget.bridge( name, constructor );
1620};
1621
1622$.widget.extend = function( target ) {
1623  var input = slice.call( arguments, 1 ),
1624    inputIndex = 0,
1625    inputLength = input.length,
1626    key,
1627    value;
1628  for ( ; inputIndex < inputLength; inputIndex++ ) {
1629    for ( key in input[ inputIndex ] ) {
1630      value = input[ inputIndex ][ key ];
1631      if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
1632        // Clone objects
1633        if ( $.isPlainObject( value ) ) {
1634          target[ key ] = $.isPlainObject( target[ key ] ) ?
1635            $.widget.extend( {}, target[ key ], value ) :
1636            // Don't extend strings, arrays, etc. with objects
1637            $.widget.extend( {}, value );
1638        // Copy everything else by reference
1639        } else {
1640          target[ key ] = value;
1641        }
1642      }
1643    }
1644  }
1645  return target;
1646};
1647
1648$.widget.bridge = function( name, object ) {
1649  var fullName = object.prototype.widgetFullName || name;
1650  $.fn[ name ] = function( options ) {
1651    var isMethodCall = typeof options === "string",
1652      args = slice.call( arguments, 1 ),
1653      returnValue = this;
1654
1655    // allow multiple hashes to be passed on init
1656    options = !isMethodCall && args.length ?
1657      $.widget.extend.apply( null, [ options ].concat(args) ) :
1658      options;
1659
1660    if ( isMethodCall ) {
1661      this.each(function() {
1662        var methodValue,
1663          instance = $.data( this, fullName );
1664        if ( !instance ) {
1665          return $.error( "cannot call methods on " + name + " prior to initialization; " +
1666            "attempted to call method '" + options + "'" );
1667        }
1668        if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
1669          return $.error( "no such method '" + options + "' for " + name + " widget instance" );
1670        }
1671        methodValue = instance[ options ].apply( instance, args );
1672        if ( methodValue !== instance && methodValue !== undefined ) {
1673          returnValue = methodValue && methodValue.jquery ?
1674            returnValue.pushStack( methodValue.get() ) :
1675            methodValue;
1676          return false;
1677        }
1678      });
1679    } else {
1680      this.each(function() {
1681        var instance = $.data( this, fullName );
1682        if ( instance ) {
1683          instance.option( options || {} )._init();
1684        } else {
1685          $.data( this, fullName, new object( options, this ) );
1686        }
1687      });
1688    }
1689
1690    return returnValue;
1691  };
1692};
1693
1694$.Widget = function( /* options, element */ ) {};
1695$.Widget._childConstructors = [];
1696
1697$.Widget.prototype = {
1698  widgetName: "widget",
1699  widgetEventPrefix: "",
1700  defaultElement: "<div>",
1701  options: {
1702    disabled: false,
1703
1704    // callbacks
1705    create: null
1706  },
1707  _createWidget: function( options, element ) {
1708    element = $( element || this.defaultElement || this )[ 0 ];
1709    this.element = $( element );
1710    this.uuid = uuid++;
1711    this.eventNamespace = "." + this.widgetName + this.uuid;
1712    this.options = $.widget.extend( {},
1713      this.options,
1714      this._getCreateOptions(),
1715      options );
1716
1717    this.bindings = $();
1718    this.hoverable = $();
1719    this.focusable = $();
1720
1721    if ( element !== this ) {
1722      $.data( element, this.widgetFullName, this );
1723      this._on( true, this.element, {
1724        remove: function( event ) {
1725          if ( event.target === element ) {
1726            this.destroy();
1727          }
1728        }
1729      });
1730      this.document = $( element.style ?
1731        // element within the document
1732        element.ownerDocument :
1733        // element is window or document
1734        element.document || element );
1735      this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
1736    }
1737
1738    this._create();
1739    this._trigger( "create", null, this._getCreateEventData() );
1740    this._init();
1741  },
1742  _getCreateOptions: $.noop,
1743  _getCreateEventData: $.noop,
1744  _create: $.noop,
1745  _init: $.noop,
1746
1747  destroy: function() {
1748    this._destroy();
1749    // we can probably remove the unbind calls in 2.0
1750    // all event bindings should go through this._on()
1751    this.element
1752      .unbind( this.eventNamespace )
1753      // 1.9 BC for #7810
1754      // TODO remove dual storage
1755      .removeData( this.widgetName )
1756      .removeData( this.widgetFullName )
1757      // support: jquery <1.6.3
1758      // http://bugs.jquery.com/ticket/9413
1759      .removeData( $.camelCase( this.widgetFullName ) );
1760    this.widget()
1761      .unbind( this.eventNamespace )
1762      .removeAttr( "aria-disabled" )
1763      .removeClass(
1764        this.widgetFullName + "-disabled " +
1765        "ui-state-disabled" );
1766
1767    // clean up events and states
1768    this.bindings.unbind( this.eventNamespace );
1769    this.hoverable.removeClass( "ui-state-hover" );
1770    this.focusable.removeClass( "ui-state-focus" );
1771  },
1772  _destroy: $.noop,
1773
1774  widget: function() {
1775    return this.element;
1776  },
1777
1778  option: function( key, value ) {
1779    var options = key,
1780      parts,
1781      curOption,
1782      i;
1783
1784    if ( arguments.length === 0 ) {
1785      // don't return a reference to the internal hash
1786      return $.widget.extend( {}, this.options );
1787    }
1788
1789    if ( typeof key === "string" ) {
1790      // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
1791      options = {};
1792      parts = key.split( "." );
1793      key = parts.shift();
1794      if ( parts.length ) {
1795        curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
1796        for ( i = 0; i < parts.length - 1; i++ ) {
1797          curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
1798          curOption = curOption[ parts[ i ] ];
1799        }
1800        key = parts.pop();
1801        if ( arguments.length === 1 ) {
1802          return curOption[ key ] === undefined ? null : curOption[ key ];
1803        }
1804        curOption[ key ] = value;
1805      } else {
1806        if ( arguments.length === 1 ) {
1807          return this.options[ key ] === undefined ? null : this.options[ key ];
1808        }
1809        options[ key ] = value;
1810      }
1811    }
1812
1813    this._setOptions( options );
1814
1815    return this;
1816  },
1817  _setOptions: function( options ) {
1818    var key;
1819
1820    for ( key in options ) {
1821      this._setOption( key, options[ key ] );
1822    }
1823
1824    return this;
1825  },
1826  _setOption: function( key, value ) {
1827    this.options[ key ] = value;
1828
1829    if ( key === "disabled" ) {
1830      this.widget()
1831        .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
1832        .attr( "aria-disabled", value );
1833      this.hoverable.removeClass( "ui-state-hover" );
1834      this.focusable.removeClass( "ui-state-focus" );
1835    }
1836
1837    return this;
1838  },
1839
1840  enable: function() {
1841    return this._setOption( "disabled", false );
1842  },
1843  disable: function() {
1844    return this._setOption( "disabled", true );
1845  },
1846
1847  _on: function( suppressDisabledCheck, element, handlers ) {
1848    var delegateElement,
1849      instance = this;
1850
1851    // no suppressDisabledCheck flag, shuffle arguments
1852    if ( typeof suppressDisabledCheck !== "boolean" ) {
1853      handlers = element;
1854      element = suppressDisabledCheck;
1855      suppressDisabledCheck = false;
1856    }
1857
1858    // no element argument, shuffle and use this.element
1859    if ( !handlers ) {
1860      handlers = element;
1861      element = this.element;
1862      delegateElement = this.widget();
1863    } else {
1864      // accept selectors, DOM elements
1865      element = delegateElement = $( element );
1866      this.bindings = this.bindings.add( element );
1867    }
1868
1869    $.each( handlers, function( event, handler ) {
1870      function handlerProxy() {
1871        // allow widgets to customize the disabled handling
1872        // - disabled as an array instead of boolean
1873        // - disabled class as method for disabling individual parts
1874        if ( !suppressDisabledCheck &&
1875            ( instance.options.disabled === true ||
1876              $( this ).hasClass( "ui-state-disabled" ) ) ) {
1877          return;
1878        }
1879        return ( typeof handler === "string" ? instance[ handler ] : handler )
1880          .apply( instance, arguments );
1881      }
1882
1883      // copy the guid so direct unbinding works
1884      if ( typeof handler !== "string" ) {
1885        handlerProxy.guid = handler.guid =
1886          handler.guid || handlerProxy.guid || $.guid++;
1887      }
1888
1889      var match = event.match( /^(\w+)\s*(.*)$/ ),
1890        eventName = match[1] + instance.eventNamespace,
1891        selector = match[2];
1892      if ( selector ) {
1893        delegateElement.delegate( selector, eventName, handlerProxy );
1894      } else {
1895        element.bind( eventName, handlerProxy );
1896      }
1897    });
1898  },
1899
1900  _off: function( element, eventName ) {
1901    eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
1902    element.unbind( eventName ).undelegate( eventName );
1903  },
1904
1905  _delay: function( handler, delay ) {
1906    function handlerProxy() {
1907      return ( typeof handler === "string" ? instance[ handler ] : handler )
1908        .apply( instance, arguments );
1909    }
1910    var instance = this;
1911    return setTimeout( handlerProxy, delay || 0 );
1912  },
1913
1914  _hoverable: function( element ) {
1915    this.hoverable = this.hoverable.add( element );
1916    this._on( element, {
1917      mouseenter: function( event ) {
1918        $( event.currentTarget ).addClass( "ui-state-hover" );
1919      },
1920      mouseleave: function( event ) {
1921        $( event.currentTarget ).removeClass( "ui-state-hover" );
1922      }
1923    });
1924  },
1925
1926  _focusable: function( element ) {
1927    this.focusable = this.focusable.add( element );
1928    this._on( element, {
1929      focusin: function( event ) {
1930        $( event.currentTarget ).addClass( "ui-state-focus" );
1931      },
1932      focusout: function( event ) {
1933        $( event.currentTarget ).removeClass( "ui-state-focus" );
1934      }
1935    });
1936  },
1937
1938  _trigger: function( type, event, data ) {
1939    var prop, orig,
1940      callback = this.options[ type ];
1941
1942    data = data || {};
1943    event = $.Event( event );
1944    event.type = ( type === this.widgetEventPrefix ?
1945      type :
1946      this.widgetEventPrefix + type ).toLowerCase();
1947    // the original event may come from any element
1948    // so we need to reset the target on the new event
1949    event.target = this.element[ 0 ];
1950
1951    // copy original event properties over to the new event
1952    orig = event.originalEvent;
1953    if ( orig ) {
1954      for ( prop in orig ) {
1955        if ( !( prop in event ) ) {
1956          event[ prop ] = orig[ prop ];
1957        }
1958      }
1959    }
1960
1961    this.element.trigger( event, data );
1962    return !( $.isFunction( callback ) &&
1963      callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
1964      event.isDefaultPrevented() );
1965  }
1966};
1967
1968$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
1969  $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
1970    if ( typeof options === "string" ) {
1971      options = { effect: options };
1972    }
1973    var hasOptions,
1974      effectName = !options ?
1975        method :
1976        options === true || typeof options === "number" ?
1977          defaultEffect :
1978          options.effect || defaultEffect;
1979    options = options || {};
1980    if ( typeof options === "number" ) {
1981      options = { duration: options };
1982    }
1983    hasOptions = !$.isEmptyObject( options );
1984    options.complete = callback;
1985    if ( options.delay ) {
1986      element.delay( options.delay );
1987    }
1988    if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
1989      element[ method ]( options );
1990    } else if ( effectName !== method && element[ effectName ] ) {

1991      element[ effectName ]( options.duration, options.easing, callback );
1992    } else {
1993      element.queue(function( next ) {
1994        $( this )[ method ]();
1995        if ( callback ) {
1996          callback.call( element[ 0 ] );
1997        }
1998        next();
1999      });
2000    }
2001  };
2002});
2003
2004})( _4ORMAT.$ );
2005(function( $, undefined ) {
2006
2007var mouseHandled = false;
2008$( document ).mouseup( function() {
2009  mouseHandled = false;
2010});
2011
2012$.widget("ui.mouse", {
2013  version: "1.10.4",
2014  options: {
2015    cancel: "input,textarea,button,select,option",
2016    distance: 1,
2017    delay: 0
2018  },
2019  _mouseInit: function() {
2020    var that = this;
2021
2022    this.element
2023      .bind("mousedown."+this.widgetName, function(event) {
2024        return that._mouseDown(event);
2025      })
2026      .bind("click."+this.widgetName, function(event) {
2027        if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
2028          $.removeData(event.target, that.widgetName + ".preventClickEvent");
2029          event.stopImmediatePropagation();
2030          return false;
2031        }
2032      });
2033
2034    this.started = false;
2035  },
2036
2037  // TODO: make sure destroying one instance of mouse doesn't mess with
2038  // other instances of mouse
2039  _mouseDestroy: function() {
2040    this.element.unbind("."+this.widgetName);
2041    if ( this._mouseMoveDelegate ) {
2042      $(document)
2043        .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
2044        .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
2045    }
2046  },
2047
2048  _mouseDown: function(event) {
2049    // don't let more than one widget handle mouseStart
2050    if( mouseHandled ) { return; }
2051
2052    // we may have missed mouseup (out of window)
2053    (this._mouseStarted && this._mouseUp(event));
2054
2055    this._mouseDownEvent = event;
2056
2057    var that = this,
2058      btnIsLeft = (event.which === 1),
2059      // event.target.nodeName works around a bug in IE 8 with
2060      // disabled inputs (#7620)
2061      elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
2062    if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
2063      return true;
2064    }
2065
2066    this.mouseDelayMet = !this.options.delay;
2067    if (!this.mouseDelayMet) {
2068      this._mouseDelayTimer = setTimeout(function() {
2069        that.mouseDelayMet = true;
2070      }, this.options.delay);
2071    }
2072
2073    if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
2074      this._mouseStarted = (this._mouseStart(event) !== false);
2075      if (!this._mouseStarted) {
2076        event.preventDefault();
2077        return true;
2078      }
2079    }
2080
2081    // Click event may never have fired (Gecko & Opera)
2082    if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
2083      $.removeData(event.target, this.widgetName + ".preventClickEvent");
2084    }
2085
2086    // these delegates are required to keep context
2087    this._mouseMoveDelegate = function(event) {
2088      return that._mouseMove(event);
2089    };
2090    this._mouseUpDelegate = function(event) {
2091      return that._mouseUp(event);
2092    };
2093    $(document)
2094      .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
2095      .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
2096
2097    event.preventDefault();
2098
2099    mouseHandled = true;
2100    return true;
2101  },
2102
2103  _mouseMove: function(event) {
2104    // IE mouseup check - mouseup happened when mouse was out of window
2105    if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
2106      return this._mouseUp(event);
2107    }
2108
2109    if (this._mouseStarted) {
2110      this._mouseDrag(event);
2111      return event.preventDefault();
2112    }
2113
2114    if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
2115      this._mouseStarted =
2116        (this._mouseStart(this._mouseDownEvent, event) !== false);
2117      (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
2118    }
2119
2120    return !this._mouseStarted;
2121  },
2122
2123  _mouseUp: function(event) {
2124    $(document)
2125      .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
2126      .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
2127
2128    if (this._mouseStarted) {
2129      this._mouseStarted = false;
2130
2131      if (event.target === this._mouseDownEvent.target) {
2132        $.data(event.target, this.widgetName + ".preventClickEvent", true);
2133      }
2134
2135      this._mouseStop(event);
2136    }
2137
2138    return false;
2139  },
2140
2141  _mouseDistanceMet: function(event) {
2142    return (Math.max(
2143        Math.abs(this._mouseDownEvent.pageX - event.pageX),
2144        Math.abs(this._mouseDownEvent.pageY - event.pageY)
2145      ) >= this.options.distance
2146    );
2147  },
2148
2149  _mouseDelayMet: function(/* event */) {
2150    return this.mouseDelayMet;
2151  },
2152
2153  // These are placeholder methods, to be overriden by extending plugin
2154  _mouseStart: function(/* event */) {},
2155  _mouseDrag: function(/* event */) {},
2156  _mouseStop: function(/* event */) {},
2157  _mouseCapture: function(/* event */) { return true; }
2158});
2159
2160})( _4ORMAT.$ );
2161(function( $, undefined ) {
2162
2163$.ui = $.ui || {};
2164
2165var cachedScrollbarWidth,
2166  max = Math.max,
2167  abs = Math.abs,
2168  round = Math.round,
2169  rhorizontal = /left|center|right/,
2170  rvertical = /top|center|bottom/,
2171  roffset = /[\+\-]\d+(\.[\d]+)?%?/,
2172  rposition = /^\w+/,
2173  rpercent = /%$/,
2174  _position = $.fn.position;
2175
2176function getOffsets( offsets, width, height ) {
2177  return [
2178    parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
2179    parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
2180  ];
2181}
2182
2183function parseCss( element, property ) {
2184  return parseInt( $.css( element, property ), 10 ) || 0;
2185}
2186
2187function getDimensions( elem ) {
2188  var raw = elem[0];
2189  if ( raw.nodeType === 9 ) {
2190    return {
2191      width: elem.width(),
2192      height: elem.height(),
2193      offset: { top: 0, left: 0 }
2194    };
2195  }
2196  if ( $.isWindow( raw ) ) {
2197    return {
2198      width: elem.width(),
2199      height: elem.height(),
2200      offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
2201    };
2202  }
2203  if ( raw.preventDefault ) {
2204    return {
2205      width: 0,
2206      height: 0,
2207      offset: { top: raw.pageY, left: raw.pageX }
2208    };
2209  }
2210  return {
2211    width: elem.outerWidth(),
2212    height: elem.outerHeight(),
2213    offset: elem.offset()
2214  };
2215}
2216
2217$.position = {
2218  scrollbarWidth: function() {
2219    if ( cachedScrollbarWidth !== undefined ) {
2220      return cachedScrollbarWidth;
2221    }
2222    var w1, w2,
2223      div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
2224      innerDiv = div.children()[0];
2225
2226    $( "body" ).append( div );
2227    w1 = innerDiv.offsetWidth;
2228    div.css( "overflow", "scroll" );
2229
2230    w2 = innerDiv.offsetWidth;
2231
2232    if ( w1 === w2 ) {
2233      w2 = div[0].clientWidth;
2234    }
2235
2236    div.remove();
2237
2238    return (cachedScrollbarWidth = w1 - w2);
2239  },
2240  getScrollInfo: function( within ) {
2241    var overflowX = within.isWindow || within.isDocument ? "" :
2242        within.element.css( "overflow-x" ),
2243      overflowY = within.isWindow || within.isDocument ? "" :
2244        within.element.css( "overflow-y" ),
2245      hasOverflowX = overflowX === "scroll" ||
2246        ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
2247      hasOverflowY = overflowY === "scroll" ||
2248        ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
2249    return {
2250      width: hasOverflowY ? $.position.scrollbarWidth() : 0,
2251      height: hasOverflowX ? $.position.scrollbarWidth() : 0
2252    };
2253  },
2254  getWithinInfo: function( element ) {
2255    var withinElement = $( element || window ),
2256      isWindow = $.isWindow( withinElement[0] ),
2257      isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
2258    return {
2259      element: withinElement,
2260      isWindow: isWindow,
2261      isDocument: isDocument,
2262      offset: withinElement.offset() || { left: 0, top: 0 },
2263      scrollLeft: withinElement.scrollLeft(),
2264      scrollTop: withinElement.scrollTop(),
2265      width: isWindow ? withinElement.width() : withinElement.outerWidth(),
2266      height: isWindow ? withinElement.height() : withinElement.outerHeight()
2267    };
2268  }
2269};
2270
2271$.fn.position = function( options ) {
2272  if ( !options || !options.of ) {
2273    return _position.apply( this, arguments );
2274  }
2275
2276  // make a copy, we don't want to modify arguments
2277  options = $.extend( {}, options );
2278
2279  var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
2280    target = $( options.of ),
2281    within = $.position.getWithinInfo( options.within ),
2282    scrollInfo = $.position.getScrollInfo( within ),
2283    collision = ( options.collision || "flip" ).split( " " ),
2284    offsets = {};
2285
2286  dimensions = getDimensions( target );
2287  if ( target[0].preventDefault ) {
2288    // force left top to allow flipping
2289    options.at = "left top";
2290  }
2291  targetWidth = dimensions.width;
2292  targetHeight = dimensions.height;
2293  targetOffset = dimensions.offset;
2294  // clone to reuse original targetOffset later
2295  basePosition = $.extend( {}, targetOffset );
2296
2297  // force my and at to have valid horizontal and vertical positions
2298  // if a value is missing or invalid, it will be converted to center
2299  $.each( [ "my", "at" ], function() {
2300    var pos = ( options[ this ] || "" ).split( " " ),
2301      horizontalOffset,
2302      verticalOffset;
2303
2304    if ( pos.length === 1) {
2305      pos = rhorizontal.test( pos[ 0 ] ) ?
2306        pos.concat( [ "center" ] ) :
2307        rvertical.test( pos[ 0 ] ) ?
2308          [ "center" ].concat( pos ) :
2309          [ "center", "center" ];
2310    }
2311    pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
2312    pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
2313
2314    // calculate offsets
2315    horizontalOffset = roffset.exec( pos[ 0 ] );
2316    verticalOffset = roffset.exec( pos[ 1 ] );
2317    offsets[ this ] = [
2318      horizontalOffset ? horizontalOffset[ 0 ] : 0,
2319      verticalOffset ? verticalOffset[ 0 ] : 0
2320    ];
2321
2322    // reduce to just the positions without the offsets
2323    options[ this ] = [
2324      rposition.exec( pos[ 0 ] )[ 0 ],
2325      rposition.exec( pos[ 1 ] )[ 0 ]
2326    ];
2327  });
2328
2329  // normalize collision option
2330  if ( collision.length === 1 ) {
2331    collision[ 1 ] = collision[ 0 ];
2332  }
2333
2334  if ( options.at[ 0 ] === "right" ) {
2335    basePosition.left += targetWidth;
2336  } else if ( options.at[ 0 ] === "center" ) {
2337    basePosition.left += targetWidth / 2;
2338  }
2339
2340  if ( options.at[ 1 ] === "bottom" ) {
2341    basePosition.top += targetHeight;
2342  } else if ( options.at[ 1 ] === "center" ) {
2343    basePosition.top += targetHeight / 2;
2344  }
2345
2346  atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
2347  basePosition.left += atOffset[ 0 ];
2348  basePosition.top += atOffset[ 1 ];
2349
2350  return this.each(function() {
2351    var collisionPosition, using,
2352      elem = $( this ),
2353      elemWidth = elem.outerWidth(),
2354      elemHeight = elem.outerHeight(),
2355      marginLeft = parseCss( this, "marginLeft" ),
2356      marginTop = parseCss( this, "marginTop" ),
2357      collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
2358      collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
2359      position = $.extend( {}, basePosition ),
2360      myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
2361
2362    if ( options.my[ 0 ] === "right" ) {
2363      position.left -= elemWidth;
2364    } else if ( options.my[ 0 ] === "center" ) {
2365      position.left -= elemWidth / 2;
2366    }
2367
2368    if ( options.my[ 1 ] === "bottom" ) {
2369      position.top -= elemHeight;
2370    } else if ( options.my[ 1 ] === "center" ) {
2371      position.top -= elemHeight / 2;
2372    }
2373
2374    position.left += myOffset[ 0 ];
2375    position.top += myOffset[ 1 ];
2376
2377    // if the browser doesn't support fractions, then round for consistent results
2378    if ( !$.support.offsetFractions ) {
2379      position.left = round( position.left );
2380      position.top = round( position.top );
2381    }
2382
2383    collisionPosition = {
2384      marginLeft: marginLeft,
2385      marginTop: marginTop
2386    };
2387
2388    $.each( [ "left", "top" ], function( i, dir ) {
2389      if ( $.ui.position[ collision[ i ] ] ) {
2390        $.ui.position[ collision[ i ] ][ dir ]( position, {
2391          targetWidth: targetWidth,
2392          targetHeight: targetHeight,
2393          elemWidth: elemWidth,
2394          elemHeight: elemHeight,
2395          collisionPosition: collisionPosition,
2396          collisionWidth: collisionWidth,
2397          collisionHeight: collisionHeight,
2398          offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
2399          my: options.my,
2400          at: options.at,
2401          within: within,
2402          elem : elem
2403        });
2404      }
2405    });
2406
2407    if ( options.using ) {
2408      // adds feedback as second argument to using callback, if present
2409      using = function( props ) {
2410        var left = targetOffset.left - position.left,
2411          right = left + targetWidth - elemWidth,
2412          top = targetOffset.top - position.top,
2413          bottom = top + targetHeight - elemHeight,
2414          feedback = {
2415            target: {
2416              element: target,
2417              left: targetOffset.left,
2418              top: targetOffset.top,
2419              width: targetWidth,
2420              height: targetHeight
2421            },
2422            element: {
2423              element: elem,
2424              left: position.left,
2425              top: position.top,
2426              width: elemWidth,
2427              height: elemHeight
2428            },
2429            horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
2430            vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
2431          };
2432        if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
2433          feedback.horizontal = "center";
2434        }
2435        if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
2436          feedback.vertical = "middle";
2437        }
2438        if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
2439          feedback.important = "horizontal";
2440        } else {
2441          feedback.important = "vertical";
2442        }
2443        options.using.call( this, props, feedback );
2444      };
2445    }
2446
2447    elem.offset( $.extend( position, { using: using } ) );
2448  });
2449};
2450
2451$.ui.position = {
2452  fit: {
2453    left: function( position, data ) {
2454      var within = data.within,
2455        withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
2456        outerWidth = within.width,
2457        collisionPosLeft = position.left - data.collisionPosition.marginLeft,
2458        overLeft = withinOffset - collisionPosLeft,
2459        overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
2460        newOverRight;
2461
2462      // element is wider than within
2463      if ( data.collisionWidth > outerWidth ) {
2464        // element is initially over the left side of within
2465        if ( overLeft > 0 && overRight <= 0 ) {
2466          newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
2467          position.left += overLeft - newOverRight;
2468        // element is initially over right side of within
2469        } else if ( overRight > 0 && overLeft <= 0 ) {
2470          position.left = withinOffset;
2471        // element is initially over both left and right sides of within
2472        } else {
2473          if ( overLeft > overRight ) {
2474            position.left = withinOffset + outerWidth - data.collisionWidth;
2475          } else {
2476            position.left = withinOffset;
2477          }
2478        }
2479      // too far left -> align with left edge
2480      } else if ( overLeft > 0 ) {
2481        position.left += overLeft;
2482      // too far right -> align with right edge
2483      } else if ( overRight > 0 ) {
2484        position.left -= overRight;
2485      // adjust based on position and margin
2486      } else {
2487        position.left = max( position.left - collisionPosLeft, position.left );
2488      }
2489    },
2490    top: function( position, data ) {
2491      var within = data.within,
2492        withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
2493        outerHeight = data.within.height,
2494        collisionPosTop = position.top - data.collisionPosition.marginTop,
2495        overTop = withinOffset - collisionPosTop,
2496        overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
2497        newOverBottom;
2498
2499      // element is taller than within
2500      if ( data.collisionHeight > outerHeight ) {
2501        // element is initially over the top of within
2502        if ( overTop > 0 && overBottom <= 0 ) {
2503          newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
2504          position.top += overTop - newOverBottom;
2505        // element is initially over bottom of within
2506        } else if ( overBottom > 0 && overTop <= 0 ) {
2507          position.top = withinOffset;
2508        // element is initially over both top and bottom of within
2509        } else {
2510          if ( overTop > overBottom ) {
2511            position.top = withinOffset + outerHeight - data.collisionHeight;
2512          } else {
2513            position.top = withinOffset;
2514          }
2515        }
2516      // too far up -> align with top
2517      } else if ( overTop > 0 ) {
2518        position.top += overTop;
2519      // too far down -> align with bottom edge
2520      } else if ( overBottom > 0 ) {
2521        position.top -= overBottom;
2522      // adjust based on position and margin
2523      } else {
2524        position.top = max( position.top - collisionPosTop, position.top );
2525      }
2526    }
2527  },
2528  flip: {
2529    left: function( position, data ) {
2530      var within = data.within,
2531        withinOffset = within.offset.left + within.scrollLeft,
2532        outerWidth = within.width,
2533        offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
2534        collisionPosLeft = position.left - data.collisionPosition.marginLeft,
2535        overLeft = collisionPosLeft - offsetLeft,
2536        overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
2537        myOffset = data.my[ 0 ] === "left" ?
2538          -data.elemWidth :
2539          data.my[ 0 ] === "right" ?
2540            data.elemWidth :
2541            0,
2542        atOffset = data.at[ 0 ] === "left" ?
2543          data.targetWidth :
2544          data.at[ 0 ] === "right" ?
2545            -data.targetWidth :
2546            0,
2547        offset = -2 * data.offset[ 0 ],
2548        newOverRight,
2549        newOverLeft;
2550
2551      if ( overLeft < 0 ) {
2552        newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
2553        if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
2554          position.left += myOffset + atOffset + offset;
2555        }
2556      }
2557      else if ( overRight > 0 ) {
2558        newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
2559        if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
2560          position.left += myOffset + atOffset + offset;
2561        }
2562      }
2563    },
2564    top: function( position, data ) {
2565      var within = data.within,
2566        withinOffset = within.offset.top + within.scrollTop,
2567        outerHeight = within.height,
2568        offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
2569        collisionPosTop = position.top - data.collisionPosition.marginTop,
2570        overTop = collisionPosTop - offsetTop,
2571        overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
2572        top = data.my[ 1 ] === "top",
2573        myOffset = top ?
2574          -data.elemHeight :
2575          data.my[ 1 ] === "bottom" ?
2576            data.elemHeight :
2577            0,
2578        atOffset = data.at[ 1 ] === "top" ?
2579          data.targetHeight :
2580          data.at[ 1 ] === "bottom" ?
2581            -data.targetHeight :
2582            0,
2583        offset = -2 * data.offset[ 1 ],
2584        newOverTop,
2585        newOverBottom;
2586      if ( overTop < 0 ) {
2587        newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
2588        if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
2589          position.top += myOffset + atOffset + offset;
2590        }
2591      }
2592      else if ( overBottom > 0 ) {
2593        newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
2594        if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
2595          position.top += myOffset + atOffset + offset;
2596        }
2597      }
2598    }
2599  },
2600  flipfit: {
2601    left: function() {
2602      $.ui.position.flip.left.apply( this, arguments );
2603      $.ui.position.fit.left.apply( this, arguments );
2604    },
2605    top: function() {
2606      $.ui.position.flip.top.apply( this, arguments );
2607      $.ui.position.fit.top.apply( this, arguments );
2608    }
2609  }
2610};
2611
2612// fraction support test
2613(function () {
2614  var testElement, testElementParent, testElementStyle, offsetLeft, i,
2615    body = document.getElementsByTagName( "body" )[ 0 ],
2616    div = document.createElement( "div" );
2617
2618  //Create a "fake body" for testing based on method used in jQuery.support
2619  testElement = document.createElement( body ? "div" : "body" );
2620  testElementStyle = {
2621    visibility: "hidden",
2622    width: 0,
2623    height: 0,
2624    border: 0,
2625    margin: 0,
2626    background: "none"
2627  };
2628  if ( body ) {
2629    $.extend( testElementStyle, {
2630      position: "absolute",
2631      left: "-1000px",
2632      top: "-1000px"
2633    });
2634  }
2635  for ( i in testElementStyle ) {
2636    testElement.style[ i ] = testElementStyle[ i ];
2637  }
2638  testElement.appendChild( div );
2639  testElementParent = body || document.documentElement;
2640  testElementParent.insertBefore( testElement, testElementParent.firstChild );
2641
2642  div.style.cssText = "position: absolute; left: 10.7432222px;";
2643
2644  offsetLeft = $( div ).offset().left;
2645  $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
2646
2647  testElement.innerHTML = "";
2648  testElementParent.removeChild( testElement );
2649})();
2650
2651}( _4ORMAT.$ ) );
2652(function( $, undefined ) {
2653
2654var uid = 0,
2655  hideProps = {},
2656  showProps = {};
2657
2658hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
2659  hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
2660showProps.height = showProps.paddingTop = showProps.paddingBottom =
2661  showProps.borderTopWidth = showProps.borderBottomWidth = "show";
2662
2663$.widget( "ui.accordion", {
2664  version: "1.10.4",
2665  options: {
2666    active: 0,
2667    animate: {},
2668    collapsible: false,
2669    event: "click",
2670    header: "> li > :first-child,> :not(li):even",
2671    heightStyle: "auto",
2672    icons: {
2673      activeHeader: "ui-icon-triangle-1-s",
2674      header: "ui-icon-triangle-1-e"
2675    },
2676
2677    // callbacks
2678    activate: null,
2679    beforeActivate: null
2680  },
2681
2682  _create: function() {
2683    var options = this.options;
2684    this.prevShow = this.prevHide = $();
2685    this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
2686      // ARIA
2687      .attr( "role", "tablist" );
2688
2689    // don't allow collapsible: false and active: false / null
2690    if ( !options.collapsible && (options.active === false || options.active == null) ) {
2691      options.active = 0;
2692    }
2693
2694    this._processPanels();
2695    // handle negative values
2696    if ( options.active < 0 ) {
2697      options.active += this.headers.length;
2698    }
2699    this._refresh();
2700  },
2701
2702  _getCreateEventData: function() {
2703    return {
2704      header: this.active,
2705      panel: !this.active.length ? $() : this.active.next(),
2706      content: !this.active.length ? $() : this.active.next()
2707    };
2708  },
2709
2710  _createIcons: function() {
2711    var icons = this.options.icons;
2712    if ( icons ) {
2713      $( "<span>" )
2714        .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
2715        .prependTo( this.headers );
2716      this.active.children( ".ui-accordion-header-icon" )
2717        .removeClass( icons.header )
2718        .addClass( icons.activeHeader );
2719      this.headers.addClass( "ui-accordion-icons" );
2720    }
2721  },
2722
2723  _destroyIcons: function() {
2724    this.headers
2725      .removeClass( "ui-accordion-icons" )
2726      .children( ".ui-accordion-header-icon" )
2727        .remove();
2728  },
2729
2730  _destroy: function() {
2731    var contents;
2732
2733    // clean up main element
2734    this.element
2735      .removeClass( "ui-accordion ui-widget ui-helper-reset" )
2736      .removeAttr( "role" );
2737
2738    // clean up headers
2739    this.headers
2740      .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
2741      .removeAttr( "role" )
2742      .removeAttr( "aria-expanded" )
2743      .removeAttr( "aria-selected" )
2744      .removeAttr( "aria-controls" )
2745      .removeAttr( "tabIndex" )
2746      .each(function() {
2747        if ( /^ui-accordion/.test( this.id ) ) {
2748          this.removeAttribute( "id" );
2749        }
2750      });
2751    this._destroyIcons();
2752
2753    // clean up content panels
2754    contents = this.headers.next()
2755      .css( "display", "" )
2756      .removeAttr( "role" )
2757      .removeAttr( "aria-hidden" )
2758      .removeAttr( "aria-labelledby" )
2759      .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
2760      .each(function() {
2761        if ( /^ui-accordion/.test( this.id ) ) {
2762          this.removeAttribute( "id" );
2763        }
2764      });
2765    if ( this.options.heightStyle !== "content" ) {
2766      contents.css( "height", "" );
2767    }
2768  },
2769
2770  _setOption: function( key, value ) {
2771    if ( key === "active" ) {
2772      // _activate() will handle invalid values and update this.options
2773      this._activate( value );
2774      return;
2775    }
2776
2777    if ( key === "event" ) {
2778      if ( this.options.event ) {
2779        this._off( this.headers, this.options.event );
2780      }
2781      this._setupEvents( value );
2782    }
2783
2784    this._super( key, value );
2785
2786    // setting collapsible: false while collapsed; open first panel
2787    if ( key === "collapsible" && !value && this.options.active === false ) {
2788      this._activate( 0 );
2789    }
2790
2791    if ( key === "icons" ) {
2792      this._destroyIcons();
2793      if ( value ) {
2794        this._createIcons();
2795      }
2796    }
2797
2798    // #5332 - opacity doesn't cascade to positioned elements in IE
2799    // so we need to add the disabled class to the headers and panels
2800    if ( key === "disabled" ) {
2801      this.headers.add( this.headers.next() )
2802        .toggleClass( "ui-state-disabled", !!value );
2803    }
2804  },
2805
2806  _keydown: function( event ) {
2807    if ( event.altKey || event.ctrlKey ) {
2808      return;
2809    }
2810
2811    var keyCode = $.ui.keyCode,
2812      length = this.headers.length,
2813      currentIndex = this.headers.index( event.target ),
2814      toFocus = false;
2815
2816    switch ( event.keyCode ) {
2817      case keyCode.RIGHT:
2818      case keyCode.DOWN:
2819        toFocus = this.headers[ ( currentIndex + 1 ) % length ];
2820        break;
2821      case keyCode.LEFT:
2822      case keyCode.UP:
2823        toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
2824        break;
2825      case keyCode.SPACE:
2826      case keyCode.ENTER:
2827        this._eventHandler( event );
2828        break;
2829      case keyCode.HOME:
2830        toFocus = this.headers[ 0 ];
2831        break;
2832      case keyCode.END:
2833        toFocus = this.headers[ length - 1 ];
2834        break;
2835    }
2836
2837    if ( toFocus ) {
2838      $( event.target ).attr( "tabIndex", -1 );
2839      $( toFocus ).attr( "tabIndex", 0 );
2840      toFocus.focus();
2841      event.preventDefault();
2842    }
2843  },
2844
2845  _panelKeyDown : function( event ) {
2846    if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
2847      $( event.currentTarget ).prev().focus();
2848    }
2849  },
2850
2851  refresh: function() {
2852    var options = this.options;
2853    this._processPanels();
2854
2855    // was collapsed or no panel
2856    if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
2857      options.active = false;
2858      this.active = $();
2859    // active false only when collapsible is true
2860    } else if ( options.active === false ) {
2861      this._activate( 0 );
2862    // was active, but active panel is gone
2863    } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2864      // all remaining panel are disabled
2865      if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
2866        options.active = false;
2867        this.active = $();
2868      // activate previous panel
2869      } else {
2870        this._activate( Math.max( 0, options.active - 1 ) );
2871      }
2872    // was active, active panel still exists
2873    } else {
2874      // make sure active index is correct
2875      options.active = this.headers.index( this.active );
2876    }
2877
2878    this._destroyIcons();
2879
2880    this._refresh();
2881  },
2882
2883  _processPanels: function() {
2884    this.headers = this.element.find( this.options.header )
2885      .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
2886
2887    this.headers.next()
2888      .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
2889      .filter(":not(.ui-accordion-content-active)")
2890      .hide();
2891  },
2892
2893  _refresh: function() {
2894    var maxHeight,
2895      options = this.options,
2896      heightStyle = options.heightStyle,
2897      parent = this.element.parent(),
2898      accordionId = this.accordionId = "ui-accordion-" +
2899        (this.element.attr( "id" ) || ++uid);
2900
2901    this.active = this._findActive( options.active )
2902      .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
2903      .removeClass( "ui-corner-all" );
2904    this.active.next()
2905      .addClass( "ui-accordion-content-active" )
2906      .show();
2907
2908    this.headers
2909      .attr( "role", "tab" )
2910      .each(function( i ) {
2911        var header = $( this ),
2912          headerId = header.attr( "id" ),
2913          panel = header.next(),
2914          panelId = panel.attr( "id" );
2915        if ( !headerId ) {
2916          headerId = accordionId + "-header-" + i;
2917          header.attr( "id", headerId );
2918        }
2919        if ( !panelId ) {
2920          panelId = accordionId + "-panel-" + i;
2921          panel.attr( "id", panelId );
2922        }
2923        header.attr( "aria-controls", panelId );
2924        panel.attr( "aria-labelledby", headerId );
2925      })
2926      .next()
2927        .attr( "role", "tabpanel" );
2928
2929    this.headers
2930      .not( this.active )
2931      .attr({
2932        "aria-selected": "false",
2933        "aria-expanded": "false",
2934        tabIndex: -1
2935      })
2936      .next()
2937        .attr({
2938          "aria-hidden": "true"
2939        })
2940        .hide();
2941
2942    // make sure at least one header is in the tab order
2943    if ( !this.active.length ) {
2944      this.headers.eq( 0 ).attr( "tabIndex", 0 );
2945    } else {
2946      this.active.attr({
2947        "aria-selected": "true",
2948        "aria-expanded": "true",
2949        tabIndex: 0
2950      })
2951      .next()
2952        .attr({
2953          "aria-hidden": "false"
2954        });
2955    }
2956
2957    this._createIcons();
2958
2959    this._setupEvents( options.event );
2960
2961    if ( heightStyle === "fill" ) {
2962      maxHeight = parent.height();
2963      this.element.siblings( ":visible" ).each(function() {
2964        var elem = $( this ),
2965          position = elem.css( "position" );
2966
2967        if ( position === "absolute" || position === "fixed" ) {
2968          return;
2969        }
2970        maxHeight -= elem.outerHeight( true );
2971      });
2972
2973      this.headers.each(function() {
2974        maxHeight -= $( this ).outerHeight( true );
2975      });
2976
2977      this.headers.next()
2978        .each(function() {
2979          $( this ).height( Math.max( 0, maxHeight -
2980            $( this ).innerHeight() + $( this ).height() ) );
2981        })
2982        .css( "overflow", "auto" );
2983    } else if ( heightStyle === "auto" ) {
2984      maxHeight = 0;
2985      this.headers.next()
2986        .each(function() {
2987          maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
2988        })
2989        .height( maxHeight );
2990    }
2991  },
2992
2993  _activate: function( index ) {
2994    var active = this._findActive( index )[ 0 ];
2995
2996    // trying to activate the already active panel
2997    if ( active === this.active[ 0 ] ) {
2998      return;
2999    }
3000
3001    // trying to collapse, simulate a click on the currently active header
3002    active = active || this.active[ 0 ];
3003
3004    this._eventHandler({
3005      target: active,
3006      currentTarget: active,
3007      preventDefault: $.noop
3008    });
3009  },
3010
3011  _findActive: function( selector ) {
3012    return typeof selector === "number" ? this.headers.eq( selector ) : $();
3013  },
3014
3015  _setupEvents: function( event ) {
3016    var events = {
3017      keydown: "_keydown"
3018    };
3019    if ( event ) {
3020      $.each( event.split(" "), function( index, eventName ) {
3021        events[ eventName ] = "_eventHandler";
3022      });
3023    }
3024
3025    this._off( this.headers.add( this.headers.next() ) );
3026    this._on( this.headers, events );
3027    this._on( this.headers.next(), { keydown: "_panelKeyDown" });
3028    this._hoverable( this.headers );
3029    this._focusable( this.headers );
3030  },
3031
3032  _eventHandler: function( event ) {
3033    var options = this.options,
3034      active = this.active,
3035      clicked = $( event.currentTarget ),
3036      clickedIsActive = clicked[ 0 ] === active[ 0 ],
3037      collapsing = clickedIsActive && options.collapsible,
3038      toShow = collapsing ? $() : clicked.next(),
3039      toHide = active.next(),
3040      eventData = {
3041        oldHeader: active,
3042        oldPanel: toHide,
3043        newHeader: collapsing ? $() : clicked,
3044        newPanel: toShow
3045      };
3046
3047    event.preventDefault();
3048
3049    if (
3050        // click on active header, but not collapsible
3051        ( clickedIsActive && !options.collapsible ) ||
3052        // allow canceling activation
3053        ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
3054      return;
3055    }
3056
3057    options.active = collapsing ? false : this.headers.index( clicked );
3058
3059    // when the call to ._toggle() comes after the class changes
3060    // it causes a very odd bug in IE 8 (see #6720)
3061    this.active = clickedIsActive ? $() : clicked;
3062    this._toggle( eventData );
3063
3064    // switch classes
3065    // corner classes on the previously active header stay after the animation
3066    active.removeClass( "ui-accordion-header-active ui-state-active" );
3067    if ( options.icons ) {
3068      active.children( ".ui-accordion-header-icon" )
3069        .removeClass( options.icons.activeHeader )
3070        .addClass( options.icons.header );
3071    }
3072
3073    if ( !clickedIsActive ) {
3074      clicked
3075        .removeClass( "ui-corner-all" )
3076        .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
3077      if ( options.icons ) {
3078        clicked.children( ".ui-accordion-header-icon" )
3079          .removeClass( options.icons.header )
3080          .addClass( options.icons.activeHeader );
3081      }
3082
3083      clicked
3084        .next()
3085        .addClass( "ui-accordion-content-active" );
3086    }
3087  },
3088
3089  _toggle: function( data ) {
3090    var toShow = data.newPanel,
3091      toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
3092
3093    // handle activating a panel during the animation for another activation
3094    this.prevShow.add( this.prevHide ).stop( true, true );
3095    this.prevShow = toShow;
3096    this.prevHide = toHide;
3097
3098    if ( this.options.animate ) {
3099      this._animate( toShow, toHide, data );
3100    } else {
3101      toHide.hide();
3102      toShow.show();
3103      this._toggleComplete( data );
3104    }
3105
3106    toHide.attr({
3107      "aria-hidden": "true"
3108    });
3109    toHide.prev().attr( "aria-selected", "false" );
3110    // if we're switching panels, remove the old header from the tab order
3111    // if we're opening from collapsed state, remove the previous header from the tab order
3112    // if we're collapsing, then keep the collapsing header in the tab order
3113    if ( toShow.length && toHide.length ) {
3114      toHide.prev().attr({
3115        "tabIndex": -1,
3116        "aria-expanded": "false"
3117      });
3118    } else if ( toShow.length ) {
3119      this.headers.filter(function() {
3120        return $( this ).attr( "tabIndex" ) === 0;
3121      })
3122      .attr( "tabIndex", -1 );
3123    }
3124
3125    toShow
3126      .attr( "aria-hidden", "false" )
3127      .prev()
3128        .attr({
3129          "aria-selected": "true",
3130          tabIndex: 0,
3131          "aria-expanded": "true"
3132        });
3133  },
3134
3135  _animate: function( toShow, toHide, data ) {
3136    var total, easing, duration,
3137      that = this,
3138      adjust = 0,
3139      down = toShow.length &&
3140        ( !toHide.length || ( toShow.index() < toHide.index() ) ),
3141      animate = this.options.animate || {},
3142      options = down && animate.down || animate,
3143      complete = function() {
3144        that._toggleComplete( data );
3145      };
3146
3147    if ( typeof options === "number" ) {
3148      duration = options;
3149    }
3150    if ( typeof options === "string" ) {
3151      easing = options;
3152    }
3153    // fall back from options to animation in case of partial down settings
3154    easing = easing || options.easing || animate.easing;
3155    duration = duration || options.duration || animate.duration;
3156
3157    if ( !toHide.length ) {
3158      return toShow.animate( showProps, duration, easing, complete );
3159    }
3160    if ( !toShow.length ) {
3161      return toHide.animate( hideProps, duration, easing, complete );
3162    }
3163
3164    total = toShow.show().outerHeight();
3165    toHide.animate( hideProps, {
3166      duration: duration,
3167      easing: easing,
3168      step: function( now, fx ) {
3169        fx.now = Math.round( now );
3170      }
3171    });
3172    toShow
3173      .hide()
3174      .animate( showProps, {
3175        duration: duration,
3176        easing: easing,
3177        complete: complete,
3178        step: function( now, fx ) {
3179          fx.now = Math.round( now );
3180          if ( fx.prop !== "height" ) {
3181            adjust += fx.now;
3182          } else if ( that.options.heightStyle !== "content" ) {
3183            fx.now = Math.round( total - toHide.outerHeight() - adjust );
3184            adjust = 0;
3185          }
3186        }
3187      });
3188  },
3189
3190  _toggleComplete: function( data ) {
3191    var toHide = data.oldPanel;
3192
3193    toHide
3194      .removeClass( "ui-accordion-content-active" )
3195      .prev()
3196        .removeClass( "ui-corner-top" )
3197        .addClass( "ui-corner-all" );
3198
3199    // Work around for rendering bug in IE (#5421)
3200    if ( toHide.length ) {
3201      toHide.parent()[0].className = toHide.parent()[0].className;
3202    }
3203    this._trigger( "activate", null, data );
3204  }
3205});
3206
3207})( _4ORMAT.$ );
3208(function( $, undefined ) {
3209
3210$.widget( "ui.autocomplete", {
3211  version: "1.10.4",
3212  defaultElement: "<input>",
3213  options: {
3214    appendTo: null,
3215    autoFocus: false,
3216    delay: 300,
3217    minLength: 1,
3218    position: {
3219      my: "left top",
3220      at: "left bottom",
3221      collision: "none"
3222    },
3223    source: null,
3224
3225    // callbacks
3226    change: null,
3227    close: null,
3228    focus: null,
3229    open: null,
3230    response: null,
3231    search: null,
3232    select: null
3233  },
3234
3235  requestIndex: 0,
3236  pending: 0,
3237
3238  _create: function() {
3239    // Some browsers only repeat keydown events, not keypress events,
3240    // so we use the suppressKeyPress flag to determine if we've already
3241    // handled the keydown event. #7269
3242    // Unfortunately the code for & in keypress is the same as the up arrow,
3243    // so we use the suppressKeyPressRepeat flag to avoid handling keypress
3244    // events when we know the keydown event was used to modify the
3245    // search term. #7799
3246    var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
3247      nodeName = this.element[0].nodeName.toLowerCase(),
3248      isTextarea = nodeName === "textarea",
3249      isInput = nodeName === "input";
3250
3251    this.isMultiLine =
3252      // Textareas are always multi-line
3253      isTextarea ? true :
3254      // Inputs are always single-line, even if inside a contentEditable element
3255      // IE also treats inputs as contentEditable
3256      isInput ? false :
3257      // All other element types are determined by whether or not they're contentEditable
3258      this.element.prop( "isContentEditable" );
3259
3260    this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
3261    this.isNewMenu = true;
3262
3263    this.element
3264      .addClass( "ui-autocomplete-input" )
3265      .attr( "autocomplete", "off" );
3266
3267    this._on( this.element, {
3268      keydown: function( event ) {
3269        if ( this.element.prop( "readOnly" ) ) {
3270          suppressKeyPress = true;
3271          suppressInput = true;
3272          suppressKeyPressRepeat = true;
3273          return;
3274        }
3275
3276        suppressKeyPress = false;
3277        suppressInput = false;
3278        suppressKeyPressRepeat = false;
3279        var keyCode = $.ui.keyCode;
3280        switch( event.keyCode ) {
3281        case keyCode.PAGE_UP:
3282          suppressKeyPress = true;
3283          this._move( "previousPage", event );
3284          break;
3285        case keyCode.PAGE_DOWN:
3286          suppressKeyPress = true;
3287          this._move( "nextPage", event );
3288          break;
3289        case keyCode.UP:
3290          suppressKeyPress = true;
3291          this._keyEvent( "previous", event );
3292          break;
3293        case keyCode.DOWN:
3294          suppressKeyPress = true;
3295          this._keyEvent( "next", event );
3296          break;
3297        case keyCode.ENTER:
3298        case keyCode.NUMPAD_ENTER:
3299          // when menu is open and has focus
3300          if ( this.menu.active ) {
3301            // #6055 - Opera still allows the keypress to occur
3302            // which causes forms to submit
3303            suppressKeyPress = true;
3304            event.preventDefault();
3305            this.menu.select( event );
3306          }
3307          break;
3308        case keyCode.TAB:
3309          if ( this.menu.active ) {
3310            this.menu.select( event );
3311          }
3312          break;
3313        case keyCode.ESCAPE:
3314          if ( this.menu.element.is( ":visible" ) ) {
3315            this._value( this.term );
3316            this.close( event );
3317            // Different browsers have different default behavior for escape
3318            // Single press can mean undo or clear
3319            // Double press in IE means clear the whole form
3320            event.preventDefault();
3321          }
3322          break;
3323        default:
3324          suppressKeyPressRepeat = true;
3325          // search timeout should be triggered before the input value is changed
3326          this._searchTimeout( event );
3327          break;
3328        }
3329      },
3330      keypress: function( event ) {
3331        if ( suppressKeyPress ) {
3332          suppressKeyPress = false;
3333          if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3334            event.preventDefault();
3335          }
3336          return;
3337        }
3338        if ( suppressKeyPressRepeat ) {
3339          return;
3340        }
3341
3342        // replicate some key handlers to allow them to repeat in Firefox and Opera
3343        var keyCode = $.ui.keyCode;
3344        switch( event.keyCode ) {
3345        case keyCode.PAGE_UP:
3346          this._move( "previousPage", event );
3347          break;
3348        case keyCode.PAGE_DOWN:
3349          this._move( "nextPage", event );
3350          break;
3351        case keyCode.UP:
3352          this._keyEvent( "previous", event );
3353          break;
3354        case keyCode.DOWN:
3355          this._keyEvent( "next", event );
3356          break;
3357        }
3358      },
3359      input: function( event ) {
3360        if ( suppressInput ) {
3361          suppressInput = false;
3362          event.preventDefault();
3363          return;
3364        }
3365        this._searchTimeout( event );
3366      },
3367      focus: function() {
3368        this.selectedItem = null;
3369        this.previous = this._value();
3370      },
3371      blur: function( event ) {
3372        if ( this.cancelBlur ) {
3373          delete this.cancelBlur;
3374          return;
3375        }
3376
3377        clearTimeout( this.searching );
3378        this.close( event );
3379        this._change( event );
3380      }
3381    });
3382
3383    this._initSource();
3384    this.menu = $( "<ul>" )
3385      .addClass( "ui-autocomplete ui-front" )
3386      .appendTo( this._appendTo() )
3387      .menu({
3388        // disable ARIA support, the live region takes care of that
3389        role: null
3390      })
3391      .hide()
3392      .data( "ui-menu" );
3393
3394    this._on( this.menu.element, {
3395      mousedown: function( event ) {
3396        // prevent moving focus out of the text field
3397        event.preventDefault();
3398
3399        // IE doesn't prevent moving focus even with event.preventDefault()
3400        // so we set a flag to know when we should ignore the blur event
3401        this.cancelBlur = true;
3402        this._delay(function() {
3403          delete this.cancelBlur;
3404        });
3405
3406        // clicking on the scrollbar causes focus to shift to the body
3407        // but we can't detect a mouseup or a click immediately afterward
3408        // so we have to track the next mousedown and close the menu if
3409        // the user clicks somewhere outside of the autocomplete
3410        var menuElement = this.menu.element[ 0 ];
3411        if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
3412          this._delay(function() {
3413            var that = this;
3414            this.document.one( "mousedown", function( event ) {
3415              if ( event.target !== that.element[ 0 ] &&
3416                  event.target !== menuElement &&
3417                  !$.contains( menuElement, event.target ) ) {
3418                that.close();
3419              }
3420            });
3421          });
3422        }
3423      },
3424      menufocus: function( event, ui ) {
3425        // support: Firefox
3426        // Prevent accidental activation of menu items in Firefox (#7024 #9118)
3427        if ( this.isNewMenu ) {
3428          this.isNewMenu = false;
3429          if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
3430            this.menu.blur();
3431
3432            this.document.one( "mousemove", function() {
3433              $( event.target ).trigger( event.originalEvent );
3434            });
3435
3436            return;
3437          }
3438        }
3439
3440        var item = ui.item.data( "ui-autocomplete-item" );
3441        if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3442          // use value to match what will end up in the input, if it was a key event
3443          if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3444            this._value( item.value );
3445          }
3446        } else {
3447          // Normally the input is populated with the item's value as the
3448          // menu is navigated, causing screen readers to notice a change and
3449          // announce the item. Since the focus event was canceled, this doesn't
3450          // happen, so we update the live region so that screen readers can
3451          // still notice the change and announce it.
3452          this.liveRegion.text( item.value );
3453        }
3454      },
3455      menuselect: function( event, ui ) {
3456        var item = ui.item.data( "ui-autocomplete-item" ),
3457          previous = this.previous;
3458
3459        // only trigger when focus was lost (click on menu)
3460        if ( this.element[0] !== this.document[0].activeElement ) {
3461          this.element.focus();
3462          this.previous = previous;
3463          // #6109 - IE triggers two focus events and the second
3464          // is asynchronous, so we need to reset the previous
3465          // term synchronously and asynchronously :-(
3466          this._delay(function() {
3467            this.previous = previous;
3468            this.selectedItem = item;
3469          });
3470        }
3471
3472        if ( false !== this._trigger( "select", event, { item: item } ) ) {
3473          this._value( item.value );
3474        }
3475        // reset the term after the select event
3476        // this allows custom select handling to work properly
3477        this.term = this._value();
3478
3479        this.close( event );
3480        this.selectedItem = item;
3481      }
3482    });
3483
3484    this.liveRegion = $( "<span>", {
3485        role: "status",
3486        "aria-live": "polite"
3487      })
3488      .addClass( "ui-helper-hidden-accessible" )
3489      .insertBefore( this.element );
3490
3491    // turning off autocomplete prevents the browser from remembering the
3492    // value when navigating through history, so we re-enable autocomplete
3493    // if the page is unloaded before the widget is destroyed. #7790
3494    this._on( this.window, {
3495      beforeunload: function() {
3496        this.element.removeAttr( "autocomplete" );
3497      }
3498    });
3499  },
3500
3501  _destroy: function() {
3502    clearTimeout( this.searching );
3503    this.element
3504      .removeClass( "ui-autocomplete-input" )
3505      .removeAttr( "autocomplete" );
3506    this.menu.element.remove();
3507    this.liveRegion.remove();
3508  },
3509
3510  _setOption: function( key, value ) {
3511    this._super( key, value );
3512    if ( key === "source" ) {
3513      this._initSource();
3514    }
3515    if ( key === "appendTo" ) {
3516      this.menu.element.appendTo( this._appendTo() );
3517    }
3518    if ( key === "disabled" && value && this.xhr ) {
3519      this.xhr.abort();
3520    }
3521  },
3522
3523  _appendTo: function() {
3524    var element = this.options.appendTo;
3525
3526    if ( element ) {
3527      element = element.jquery || element.nodeType ?
3528        $( element ) :
3529        this.document.find( element ).eq( 0 );
3530    }
3531
3532    if ( !element ) {
3533      element = this.element.closest( ".ui-front" );
3534    }
3535
3536    if ( !element.length ) {
3537      element = this.document[0].body;
3538    }
3539
3540    return element;
3541  },
3542
3543  _initSource: function() {
3544    var array, url,
3545      that = this;
3546    if ( $.isArray(this.options.source) ) {
3547      array = this.options.source;
3548      this.source = function( request, response ) {
3549        response( $.ui.autocomplete.filter( array, request.term ) );
3550      };
3551    } else if ( typeof this.options.source === "string" ) {
3552      url = this.options.source;
3553      this.source = function( request, response ) {
3554        if ( that.xhr ) {
3555          that.xhr.abort();
3556        }
3557        that.xhr = $.ajax({
3558          url: url,
3559          data: request,
3560          dataType: "json",
3561          success: function( data ) {
3562            response( data );
3563          },
3564          error: function() {
3565            response( [] );
3566          }
3567        });
3568      };
3569    } else {
3570      this.source = this.options.source;
3571    }
3572  },
3573
3574  _searchTimeout: function( event ) {
3575    clearTimeout( this.searching );
3576    this.searching = this._delay(function() {
3577      // only search if the value has changed
3578      if ( this.term !== this._value() ) {
3579        this.selectedItem = null;
3580        this.search( null, event );
3581      }
3582    }, this.options.delay );
3583  },
3584
3585  search: function( value, event ) {
3586    value = value != null ? value : this._value();
3587
3588    // always save the actual value, not the one passed as an argument
3589    this.term = this._value();
3590
3591    if ( value.length < this.options.minLength ) {
3592      return this.close( event );
3593    }
3594
3595    if ( this._trigger( "search", event ) === false ) {
3596      return;
3597    }
3598
3599    return this._search( value );
3600  },
3601
3602  _search: function( value ) {
3603    this.pending++;
3604    this.element.addClass( "ui-autocomplete-loading" );
3605    this.cancelSearch = false;
3606
3607    this.source( { term: value }, this._response() );
3608  },
3609
3610  _response: function() {
3611    var index = ++this.requestIndex;
3612
3613    return $.proxy(function( content ) {
3614      if ( index === this.requestIndex ) {
3615        this.__response( content );
3616      }
3617
3618      this.pending--;
3619      if ( !this.pending ) {
3620        this.element.removeClass( "ui-autocomplete-loading" );
3621      }
3622    }, this );
3623  },
3624
3625  __response: function( content ) {
3626    if ( content ) {
3627      content = this._normalize( content );
3628    }
3629    this._trigger( "response", null, { content: content } );
3630    if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3631      this._suggest( content );
3632      this._trigger( "open" );
3633    } else {
3634      // use ._close() instead of .close() so we don't cancel future searches
3635      this._close();
3636    }
3637  },
3638
3639  close: function( event ) {
3640    this.cancelSearch = true;
3641    this._close( event );
3642  },
3643
3644  _close: function( event ) {
3645    if ( this.menu.element.is( ":visible" ) ) {
3646      this.menu.element.hide();
3647      this.menu.blur();
3648      this.isNewMenu = true;
3649      this._trigger( "close", event );
3650    }
3651  },
3652
3653  _change: function( event ) {
3654    if ( this.previous !== this._value() ) {
3655      this._trigger( "change", event, { item: this.selectedItem } );
3656    }
3657  },
3658
3659  _normalize: function( items ) {
3660    // assume all items have the right format when the first item is complete
3661    if ( items.length && items[0].label && items[0].value ) {
3662      return items;
3663    }
3664    return $.map( items, function( item ) {
3665      if ( typeof item === "string" ) {
3666        return {
3667          label: item,
3668          value: item
3669        };
3670      }
3671      return $.extend({
3672        label: item.label || item.value,
3673        value: item.value || item.label
3674      }, item );
3675    });
3676  },
3677
3678  _suggest: function( items ) {
3679    var ul = this.menu.element.empty();
3680    this._renderMenu( ul, items );
3681    this.isNewMenu = true;
3682    this.menu.refresh();
3683
3684    // size and position menu
3685    ul.show();
3686    this._resizeMenu();
3687    ul.position( $.extend({
3688      of: this.element
3689    }, this.options.position ));
3690
3691    if ( this.options.autoFocus ) {
3692      this.menu.next();
3693    }
3694  },
3695
3696  _resizeMenu: function() {
3697    var ul = this.menu.element;
3698    ul.outerWidth( Math.max(
3699      // Firefox wraps long text (possibly a rounding bug)
3700      // so we add 1px to avoid the wrapping (#7513)
3701      ul.width( "" ).outerWidth() + 1,
3702      this.element.outerWidth()
3703    ) );
3704  },
3705
3706  _renderMenu: function( ul, items ) {
3707    var that = this;
3708    $.each( items, function( index, item ) {
3709      that._renderItemData( ul, item );
3710    });
3711  },
3712
3713  _renderItemData: function( ul, item ) {
3714    return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3715  },
3716
3717  _renderItem: function( ul, item ) {
3718    return $( "<li>" )
3719      .append( $( "<a>" ).text( item.label ) )
3720      .appendTo( ul );
3721  },
3722
3723  _move: function( direction, event ) {
3724    if ( !this.menu.element.is( ":visible" ) ) {
3725      this.search( null, event );
3726      return;
3727    }
3728    if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3729        this.menu.isLastItem() && /^next/.test( direction ) ) {
3730      this._value( this.term );
3731      this.menu.blur();
3732      return;
3733    }
3734    this.menu[ direction ]( event );
3735  },
3736
3737  widget: function() {
3738    return this.menu.element;
3739  },
3740
3741  _value: function() {
3742    return this.valueMethod.apply( this.element, arguments );
3743  },
3744
3745  _keyEvent: function( keyEvent, event ) {
3746    if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3747      this._move( keyEvent, event );
3748
3749      // prevents moving cursor to beginning/end of the text field in some browsers
3750      event.preventDefault();
3751    }
3752  }
3753});
3754
3755$.extend( $.ui.autocomplete, {
3756  escapeRegex: function( value ) {
3757    return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
3758  },
3759  filter: function(array, term) {
3760    var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
3761    return $.grep( array, function(value) {
3762      return matcher.test( value.label || value.value || value );
3763    });
3764  }
3765});
3766
3767
3768// live region extension, adding a `messages` option
3769// NOTE: This is an experimental API. We are still investigating
3770// a full solution for string manipulation and internationalization.
3771$.widget( "ui.autocomplete", $.ui.autocomplete, {
3772  options: {
3773    messages: {
3774      noResults: "No search results.",
3775      results: function( amount ) {
3776        return amount + ( amount > 1 ? " results are" : " result is" ) +
3777          " available, use up and down arrow keys to navigate.";
3778      }
3779    }
3780  },
3781
3782  __response: function( content ) {
3783    var message;
3784    this._superApply( arguments );
3785    if ( this.options.disabled || this.cancelSearch ) {
3786      return;
3787    }
3788    if ( content && content.length ) {
3789      message = this.options.messages.results( content.length );
3790    } else {
3791      message = this.options.messages.noResults;
3792    }
3793    this.liveRegion.text( message );
3794  }
3795});
3796
3797}( _4ORMAT.$ ));
3798(function( $, undefined ) {
3799
3800var lastActive,
3801  baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3802  typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
3803  formResetHandler = function() {
3804    var form = $( this );
3805    setTimeout(function() {
3806      form.find( ":ui-button" ).button( "refresh" );
3807    }, 1 );
3808  },
3809  radioGroup = function( radio ) {
3810    var name = radio.name,
3811      form = radio.form,
3812      radios = $( [] );
3813    if ( name ) {
3814      name = name.replace( /'/g, "\\'" );
3815      if ( form ) {
3816        radios = $( form ).find( "[name='" + name + "']" );
3817      } else {
3818        radios = $( "[name='" + name + "']", radio.ownerDocument )
3819          .filter(function() {
3820            return !this.form;
3821          });
3822      }
3823    }
3824    return radios;
3825  };
3826
3827$.widget( "ui.button", {
3828  version: "1.10.4",
3829  defaultElement: "<button>",
3830  options: {
3831    disabled: null,
3832    text: true,
3833    label: null,
3834    icons: {
3835      primary: null,
3836      secondary: null
3837    }
3838  },
3839  _create: function() {
3840    this.element.closest( "form" )
3841      .unbind( "reset" + this.eventNamespace )
3842      .bind( "reset" + this.eventNamespace, formResetHandler );
3843
3844    if ( typeof this.options.disabled !== "boolean" ) {
3845      this.options.disabled = !!this.element.prop( "disabled" );
3846    } else {
3847      this.element.prop( "disabled", this.options.disabled );
3848    }
3849
3850    this._determineButtonType();
3851    this.hasTitle = !!this.buttonElement.attr( "title" );
3852
3853    var that = this,
3854      options = this.options,
3855      toggleButton = this.type === "checkbox" || this.type === "radio",
3856      activeClass = !toggleButton ? "ui-state-active" : "";
3857
3858    if ( options.label === null ) {
3859      options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3860    }
3861
3862    this._hoverable( this.buttonElement );
3863
3864    this.buttonElement
3865      .addClass( baseClasses )
3866      .attr( "role", "button" )
3867      .bind( "mouseenter" + this.eventNamespace, function() {
3868        if ( options.disabled ) {
3869          return;
3870        }
3871        if ( this === lastActive ) {
3872          $( this ).addClass( "ui-state-active" );
3873        }
3874      })
3875      .bind( "mouseleave" + this.eventNamespace, function() {
3876        if ( options.disabled ) {
3877          return;
3878        }
3879        $( this ).removeClass( activeClass );
3880      })
3881      .bind( "click" + this.eventNamespace, function( event ) {
3882        if ( options.disabled ) {
3883          event.preventDefault();
3884          event.stopImmediatePropagation();
3885        }
3886      });
3887
3888    // Can't use _focusable() because the element that receives focus
3889    // and the element that gets the ui-state-focus class are different
3890    this._on({
3891      focus: function() {
3892        this.buttonElement.addClass( "ui-state-focus" );
3893      },
3894      blur: function() {
3895        this.buttonElement.removeClass( "ui-state-focus" );
3896      }
3897    });
3898
3899    if ( toggleButton ) {
3900      this.element.bind( "change" + this.eventNamespace, function() {
3901        that.refresh();
3902      });
3903    }
3904
3905    if ( this.type === "checkbox" ) {
3906      this.buttonElement.bind( "click" + this.eventNamespace, function() {
3907        if ( options.disabled ) {
3908          return false;
3909        }
3910      });
3911    } else if ( this.type === "radio" ) {
3912      this.buttonElement.bind( "click" + this.eventNamespace, function() {
3913        if ( options.disabled ) {
3914          return false;
3915        }
3916        $( this ).addClass( "ui-state-active" );
3917        that.buttonElement.attr( "aria-pressed", "true" );
3918
3919        var radio = that.element[ 0 ];
3920        radioGroup( radio )
3921          .not( radio )
3922          .map(function() {
3923            return $( this ).button( "widget" )[ 0 ];
3924          })
3925          .removeClass( "ui-state-active" )
3926          .attr( "aria-pressed", "false" );
3927      });
3928    } else {
3929      this.buttonElement
3930        .bind( "mousedown" + this.eventNamespace, function() {
3931          if ( options.disabled ) {
3932            return false;
3933          }
3934          $( this ).addClass( "ui-state-active" );
3935          lastActive = this;
3936          that.document.one( "mouseup", function() {
3937            lastActive = null;
3938          });
3939        })
3940        .bind( "mouseup" + this.eventNamespace, function() {
3941          if ( options.disabled ) {
3942            return false;
3943          }
3944          $( this ).removeClass( "ui-state-active" );
3945        })
3946        .bind( "keydown" + this.eventNamespace, function(event) {
3947          if ( options.disabled ) {
3948            return false;
3949          }
3950          if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3951            $( this ).addClass( "ui-state-active" );
3952          }
3953        })
3954        // see #8559, we bind to blur here in case the button element loses
3955        // focus between keydown and keyup, it would be left in an "active" state
3956        .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3957          $( this ).removeClass( "ui-state-active" );
3958        });
3959
3960      if ( this.buttonElement.is("a") ) {
3961        this.buttonElement.keyup(function(event) {
3962          if ( event.keyCode === $.ui.keyCode.SPACE ) {
3963            // TODO pass through original event correctly (just as 2nd argument doesn't work)
3964            $( this ).click();
3965          }
3966        });
3967      }
3968    }
3969
3970    // TODO: pull out $.Widget's handling for the disabled option into
3971    // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
3972    // be overridden by individual plugins
3973    this._setOption( "disabled", options.disabled );
3974    this._resetButton();
3975  },
3976
3977  _determineButtonType: function() {
3978    var ancestor, labelSelector, checked;
3979
3980    if ( this.element.is("[type=checkbox]") ) {
3981      this.type = "checkbox";
3982    } else if ( this.element.is("[type=radio]") ) {
3983      this.type = "radio";
3984    } else if ( this.element.is("input") ) {
3985      this.type = "input";
3986    } else {
3987      this.type = "button";
3988    }
3989
3990    if ( this.type === "checkbox" || this.type === "radio" ) {
3991      // we don't search against the document in case the element
3992      // is disconnected from the DOM