Etatvasoft_Dynamic_Image_Slider

Version Notes

All features are configurable from admin like width, height, auto slideshow, display next previous arrow, show caption, show navigation images, max number of slides to display, display slide content, time between two slides.

Download this release

Release Info

Developer	Etatvasoft
Extension	Etatvasoft_Dynamic_Image_Slider
Version	1.5.1
Comparing to
See all releases

Version 1.5.1

Files changed (42) hide show

app/code/local/Tatva/Slider/Block/Adminhtml/Slider.php +12 -0
app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit.php +45 -0
app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Form.php +19 -0
app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Tab/Form.php +114 -0
app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Tabs.php +30 -0
app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Grid.php +139 -0
app/code/local/Tatva/Slider/Block/Slider.php +23 -0
app/code/local/Tatva/Slider/Helper/Data.php +6 -0
app/code/local/Tatva/Slider/Model/Mysql4/Slider.php +80 -0
app/code/local/Tatva/Slider/Model/Mysql4/Slider/Collection.php +80 -0
app/code/local/Tatva/Slider/Model/Slider.php +24 -0
app/code/local/Tatva/Slider/controllers/Adminhtml/SliderController.php +268 -0
app/code/local/Tatva/Slider/controllers/IndexController.php +9 -0
app/code/local/Tatva/Slider/etc/adminhtml.xml +51 -0
app/code/local/Tatva/Slider/etc/config.xml +154 -0
app/code/local/Tatva/Slider/etc/system.xml +142 -0
app/code/local/Tatva/Slider/sql/slider_setup/mysql4-install-0.1.0.php +35 -0
app/design/adminhtml/default/default/layout/slider/slider.xml +11 -0
app/design/frontend/default/default/layout/slider/slider.xml +15 -0
app/design/frontend/default/default/template/slider/slider.phtml +147 -0
app/etc/modules/Tatva_Slider.xml +9 -0
package.xml +22 -0
skin/frontend/default/default/css/slider/slider.css +105 -0
skin/frontend/default/default/images/slider/Thumbs.db +0 -0
skin/frontend/default/default/images/slider/b_next.png +0 -0
skin/frontend/default/default/images/slider/b_prev.png +0 -0
skin/frontend/default/default/images/slider/bannerscrollbg.gif +0 -0
skin/frontend/default/default/images/slider/bluehbg.gif +0 -0
skin/frontend/default/default/images/slider/carousel_next.png +0 -0
skin/frontend/default/default/images/slider/carousel_prev.png +0 -0
skin/frontend/default/default/images/slider/content_bg.jpg +0 -0
skin/frontend/default/default/images/slider/next.png +0 -0
skin/frontend/default/default/images/slider/next_arrow.png +0 -0
skin/frontend/default/default/images/slider/num-act.png +0 -0
skin/frontend/default/default/images/slider/num.png +0 -0
skin/frontend/default/default/images/slider/prev.png +0 -0
skin/frontend/default/default/images/slider/prev_arrow.png +0 -0
skin/frontend/default/default/images/slider/primopiano_menu.gif +0 -0
skin/frontend/default/default/images/slider/primopiano_menu2.gif +0 -0
skin/frontend/default/default/images/slider/scroolbg.gif +0 -0
skin/frontend/default/default/js/slider/jquery-1.6.4.min.js +9049 -0
skin/frontend/default/default/js/slider/jquery.jcarousel.js +487 -0

app/code/local/Tatva/Slider/Block/Adminhtml/Slider.php ADDED Viewed

	@@ -0,0 +1,12 @@


1	+ <?php
2	+ class Tatva_Slider_Block_Adminhtml_Slider extends Mage_Adminhtml_Block_Widget_Grid_Container
3	+ {
4	+ public function __construct()
5	+ {
6	+ $this->_controller = 'adminhtml_slider';
7	+ $this->_blockGroup = 'slider';
8	+ $this->_headerText = Mage::helper('slider')->__('Slider Manager');
9	+ $this->_addButtonLabel = Mage::helper('slider')->__('Add Slide');
10	+ parent::__construct();
11	+ }
12	+ }

app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit.php ADDED Viewed

	@@ -0,0 +1,45 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Block_Adminhtml_Slider_Edit extends Mage_Adminhtml_Block_Widget_Form_Container
4	+ {
5	+ public function __construct()
6	+ {
7	+ parent::__construct();
8	+
9	+ $this->_objectId = 'id';
10	+ $this->_blockGroup = 'slider';
11	+ $this->_controller = 'adminhtml_slider';
12	+
13	+ $this->_updateButton('save', 'label', Mage::helper('slider')->__('Save Slide'));
14	+ $this->_updateButton('delete', 'label', Mage::helper('slider')->__('Delete Slide'));
15	+
16	+ $this->_addButton('saveandcontinue', array(
17	+ 'label' => Mage::helper('adminhtml')->__('Save And Continue Edit'),
18	+ 'onclick' => 'saveAndContinueEdit()',
19	+ 'class' => 'save',
20	+ ), -100);
21	+
22	+ $this->_formScripts[] = "
23	+ function toggleEditor() {
24	+ if (tinyMCE.getInstanceById('slider_content') == null) {
25	+ tinyMCE.execCommand('mceAddControl', false, 'slider_content');
26	+ } else {
27	+ tinyMCE.execCommand('mceRemoveControl', false, 'slider_content');
28	+ }
29	+ }
30	+
31	+ function saveAndContinueEdit(){
32	+ editForm.submit($('edit_form').action+'back/edit/');
33	+ }
34	+ ";
35	+ }
36	+
37	+ public function getHeaderText()
38	+ {
39	+ if( Mage::registry('slider_data') && Mage::registry('slider_data')->getId() ) {
40	+ return Mage::helper('slider')->__("Edit Slide '%s'", $this->htmlEscape(Mage::registry('slider_data')->getTitle()));
41	+ } else {
42	+ return Mage::helper('slider')->__('Add Slide');
43	+ }
44	+ }
45	+ }

app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Form.php ADDED Viewed

	@@ -0,0 +1,19 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Block_Adminhtml_Slider_Edit_Form extends Mage_Adminhtml_Block_Widget_Form
4	+ {
5	+ protected function _prepareForm()
6	+ {
7	+ $form = new Varien_Data_Form(array(
8	+ 'id' => 'edit_form',
9	+ 'action' => $this->getUrl('//save', array('id' => $this->getRequest()->getParam('id'))),
10	+ 'method' => 'post',
11	+ 'enctype' => 'multipart/form-data'
12	+ )
13	+ );
14	+
15	+ $form->setUseContainer(true);
16	+ $this->setForm($form);
17	+ return parent::_prepareForm();
18	+ }
19	+ }

app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Tab/Form.php ADDED Viewed

	@@ -0,0 +1,114 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Block_Adminhtml_Slider_Edit_Tab_Form extends Mage_Adminhtml_Block_Widget_Form
4	+ {
5	+ protected function _prepareLayout()
6	+ {
7	+ parent::_prepareLayout();
8	+ if(Mage::getSingleton('cms/wysiwyg_config')->isEnabled())
9	+ {
10	+ $this->getLayout()->getBlock('head')->setCanLoadTinyMce(true);
11	+ }
12	+ }
13	+
14	+ protected function _prepareForm()
15	+ {
16	+ $form = new Varien_Data_Form();
17	+ $form->setHtmlIdPrefix('slider_');
18	+ $this->setForm($form);
19	+ $fieldset = $form->addFieldset('slider_form', array('legend'=>Mage::helper('slider')->__('Slide information')));
20	+
21	+ $slider = Mage::getModel('slider/slider')->load( $this->getRequest()->getParam('id') );
22	+ $after_html = '';
23	+ if( $slider->getFilename() )
24	+ {
25	+ $path = Mage::getBaseUrl('media')."customerslider/".$slider->getFilename();
26	+ $after_html = '<a onclick="imagePreview(slider); return false;" href="'.$path.'">
27	+ <img height="22" width="22" class="small-image-preview v-middle" alt="'.$slider->getFilename().'" title="'.$slider->getFilename().'" id="slider" src="'.$path.'"/>
28	+ </a>';
29	+ }
30	+
31	+ $fieldset->addField('title', 'text', array(
32	+ 'label' => Mage::helper('slider')->__('Title'),
33	+ 'class' => 'required-entry',
34	+ 'required' => true,
35	+ 'name' => 'title',
36	+ ));
37	+
38	+ $fieldset->addField('slider_url', 'text', array(
39	+ 'label' => Mage::helper('slider')->__('Url'),
40	+ 'name' => 'slider_url',
41	+ 'note' => Mage::helper('slider')->__('Example: http://www.google.com'),
42	+ ));
43	+
44	+ $fieldset->addField('filename', 'file', array(
45	+ 'label' => Mage::helper('slider')->__('File'),
46	+ 'name' => 'filename',
47	+ 'after_element_html' => $after_html,
48	+ 'class' => (($slider->getfilename()) ? '' : 'required-entry'),
49	+ 'required' => (($slider->getfilename()) ? false : true),
50	+ ));
51	+
52	+ /**
53	+ * Check is single store mode
54	+ */
55	+ if (!Mage::app()->isSingleStoreMode()) {
56	+ $fieldset->addField('store_id', 'multiselect',
57	+ array (
58	+ 'name' => 'stores[]',
59	+ 'label' => Mage::helper('cms')->__('Store view'),
60	+ 'title' => Mage::helper('cms')->__('Store view'),
61	+ 'required' => true,
62	+ 'values' => Mage::getSingleton('adminhtml/system_store')->getStoreValuesForForm(false, true) ));
63	+ }
64	+ else {
65	+ $fieldset->addField('store_id', 'hidden', array (
66	+ 'name' => 'stores[]',
67	+ 'value' => Mage::app()->getStore(true)->getId() ));
68	+ $model->setStoreId(Mage::app()->getStore(true)->getId());
69	+ }
70	+
71	+ $fieldset->addField('status', 'select', array(
72	+ 'label' => Mage::helper('slider')->__('Status'),
73	+ 'name' => 'status',
74	+ 'values' => array(
75	+ array(
76	+ 'value' => 1,
77	+ 'label' => Mage::helper('slider')->__('Enabled'),
78	+ ),
79	+
80	+ array(
81	+ 'value' => 2,
82	+ 'label' => Mage::helper('slider')->__('Disabled'),
83	+ ),
84	+ ),
85	+ ));
86	+
87	+ $fieldset->addField('sortorder', 'text', array(
88	+ 'label' => Mage::helper('slider')->__('Sort Order'),
89	+ 'class' => 'required-entry validate-digits',
90	+ 'required' => true,
91	+ 'name' => 'sortorder',
92	+ ));
93	+
94	+ $fieldset->addField('content', 'editor', array(
95	+ 'name' => 'content',
96	+ 'label' => Mage::helper('slider')->__('Content'),
97	+ 'title' => Mage::helper('slider')->__('Content'),
98	+ 'style' => 'height:25em;width:600px',
99	+ //'config' => Mage::getSingleton('cms/wysiwyg_config')->getConfig(),
100	+ 'wysiwyg' => true,
101	+ 'required' => false,
102	+ ));
103	+
104	+ if ( Mage::getSingleton('adminhtml/session')->getsliderData() )
105	+ {
106	+ $form->setValues(Mage::getSingleton('adminhtml/session')->getsliderData());
107	+ Mage::getSingleton('adminhtml/session')->setsliderData(null);
108	+ } elseif ( Mage::registry('slider_data') ) {
109	+ $form->setValues(Mage::registry('slider_data')->getData());
110	+ }
111	+
112	+ return parent::_prepareForm();
113	+ }
114	+ }

app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Edit/Tabs.php ADDED Viewed

	@@ -0,0 +1,30 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Block_Adminhtml_Slider_Edit_Tabs extends Mage_Adminhtml_Block_Widget_Tabs
4	+ {
5	+
6	+ public function __construct()
7	+ {
8	+ parent::__construct();
9	+ $this->setId('slider_tabs');
10	+ $this->setDestElementId('edit_form');
11	+ $this->setTitle(Mage::helper('slider')->__('Slide Information'));
12	+ }
13	+
14	+ protected function _prepareLayout()
15	+ {
16	+ $return = parent::_prepareLayout();
17	+
18	+ $this->addTab(
19	+ 'main_section',
20	+ array(
21	+ 'label' => Mage::helper('slider')->__('Slide Information'),
22	+ 'title' => Mage::helper('slider')->__('Slide Information'),
23	+ 'content' => $this->getLayout()->createBlock('slider/adminhtml_slider_edit_tab_form')->toHtml(),
24	+ 'active' => true,
25	+ )
26	+ );
27	+
28	+ return $return;
29	+ }
30	+ }

app/code/local/Tatva/Slider/Block/Adminhtml/Slider/Grid.php ADDED Viewed

	@@ -0,0 +1,139 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Block_Adminhtml_Slider_Grid extends Mage_Adminhtml_Block_Widget_Grid
4	+ {
5	+ public function __construct()
6	+ {
7	+ parent::__construct();
8	+ $this->setId('sliderGrid');
9	+ $this->setDefaultSort('slider_id');
10	+ $this->setDefaultDir('ASC');
11	+ $this->setSaveParametersInSession(true);
12	+ }
13	+
14	+ protected function _prepareCollection()
15	+ {
16	+ $collection = Mage::getModel('slider/slider')->getCollection();
17	+ $this->setCollection($collection);
18	+ return parent::_prepareCollection();
19	+ }
20	+
21	+ protected function _prepareColumns()
22	+ {
23	+ $this->addColumn('slider_id', array(
24	+ 'header' => Mage::helper('slider')->__('ID'),
25	+ 'align' =>'right',
26	+ 'width' => '80px',
27	+ 'index' => 'slider_id',
28	+ 'type' => 'number',
29	+ ));
30	+
31	+ $this->addColumn('title', array(
32	+ 'header' => Mage::helper('slider')->__('Title'),
33	+ 'align' =>'left',
34	+ 'index' => 'title',
35	+ ));
36	+
37	+ if (!Mage::app()->isSingleStoreMode())
38	+ {
39	+ $this->addColumn('store_id',
40	+ array (
41	+ 'header' => Mage::helper('cms')->__('Store view'),
42	+ 'index' => 'store_id',
43	+ 'type' => 'store',
44	+ 'store_all' => true,
45	+ 'store_view' => true,
46	+ 'sortable' => false,
47	+ 'filter_condition_callback' => array (
48	+ $this,
49	+ '_filterStoreCondition' ) ));
50	+ }
51	+
52	+ $this->addColumn('content', array(
53	+ 'header' => Mage::helper('slider')->__('Slide Content'),
54	+ 'width' => '550px',
55	+ 'index' => 'content',
56	+ ));
57	+
58	+ $this->addColumn('status', array(
59	+ 'header' => Mage::helper('slider')->__('Status'),
60	+ 'align' => 'left',
61	+ 'width' => '120px',
62	+ 'index' => 'status',
63	+ 'type' => 'options',
64	+ 'options' => array(
65	+ 1 => 'Enabled',
66	+ 2 => 'Disabled',
67	+ ),
68	+ ));
69	+
70	+ $this->addColumn('action',
71	+ array(
72	+ 'header' => Mage::helper('slider')->__('Action'),
73	+ 'width' => '100',
74	+ 'type' => 'action',
75	+ 'getter' => 'getId',
76	+ 'actions' => array(
77	+ array(
78	+ 'caption' => Mage::helper('slider')->__('Edit'),
79	+ 'url' => array('base'=> '//edit'),
80	+ 'field' => 'id'
81	+ )
82	+ ),
83	+ 'filter' => false,
84	+ 'sortable' => false,
85	+ 'index' => 'stores',
86	+ 'is_system' => true,
87	+ ));
88	+
89	+ $this->addExportType('//exportCsv', Mage::helper('slider')->__('CSV'));
90	+ $this->addExportType('//exportXml', Mage::helper('slider')->__('XML'));
91	+
92	+ return parent::_prepareColumns();
93	+ }
94	+
95	+ protected function _prepareMassaction()
96	+ {
97	+ $this->setMassactionIdField('slider_id');
98	+ $this->getMassactionBlock()->setFormFieldName('slider');
99	+
100	+ $this->getMassactionBlock()->addItem('delete', array(
101	+ 'label' => Mage::helper('slider')->__('Delete'),
102	+ 'url' => $this->getUrl('//massDelete'),
103	+ 'confirm' => Mage::helper('slider')->__('Are you sure?')
104	+ ));
105	+
106	+ return $this;
107	+ }
108	+
109	+ public function getRowUrl($row)
110	+ {
111	+ return $this->getUrl('//edit', array('id' => $row->getId()));
112	+ }
113	+
114	+ /**
115	+ * Helper function to do after load modifications
116	+ *
117	+ */
118	+ protected function _afterLoadCollection()
119	+ {
120	+ $this->getCollection()->walk('afterLoad');
121	+ parent::_afterLoadCollection();
122	+ }
123	+
124	+ /**
125	+ * Helper function to add store filter condition
126	+ *
127	+ * @param Mage_Core_Model_Mysql4_Collection_Abstract $collection Data collection
128	+ * @param Mage_Adminhtml_Block_Widget_Grid_Column $column Column information to be filtered
129	+ */
130	+ protected function _filterStoreCondition($collection, $column)
131	+ {
132	+ if (!$value = $column->getFilter()->getValue()) {
133	+ return;
134	+ }
135	+
136	+ $this->getCollection()->addStoreFilter($value);
137	+ }
138	+
139	+ }

app/code/local/Tatva/Slider/Block/Slider.php ADDED Viewed

	@@ -0,0 +1,23 @@


1	+ <?php
2	+ class Tatva_Slider_Block_Slider extends Mage_Core_Block_Template
3	+ {
4	+ public function _prepareLayout()
5	+ {
6	+ return parent::_prepareLayout();
7	+ }
8	+
9	+ public function getSlider()
10	+ {
11	+ if (!$this->hasData('slider'))
12	+ {
13	+ $this->setData('slider', Mage::registry('slider'));
14	+ }
15	+ return $this->getData('slider');
16	+ }
17	+
18	+ public function getcustomerslider()
19	+ {
20	+ $collection = Mage::getModel('slider/slider')->getcustomersliderdata();
21	+ return $collection;
22	+ }
23	+ }

app/code/local/Tatva/Slider/Helper/Data.php ADDED Viewed

	@@ -0,0 +1,6 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Helper_Data extends Mage_Core_Helper_Abstract
4	+ {
5	+
6	+ }

app/code/local/Tatva/Slider/Model/Mysql4/Slider.php ADDED Viewed

	@@ -0,0 +1,80 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Model_Mysql4_Slider extends Mage_Core_Model_Mysql4_Abstract
4	+ {
5	+ public function _construct()
6	+ {
7	+ // Note that the slider_id refers to the key field in your database table.
8	+ $this->_init('slider/slider', 'slider_id');
9	+ }
10	+
11	+ /**
12	+ * Retrieve select object for load object data
13	+ *
14	+ * @param string $field
15	+ * @param mixed $value
16	+ * @return Zend_Db_Select
17	+ */
18	+ protected function _getLoadSelect($field, $value, $object) {
19	+
20	+ $select = parent::_getLoadSelect($field, $value, $object);
21	+
22	+ if ($object->getStoreId()) {
23	+ $select->join(
24	+ array('nns' => $this->getTable('slider_store')),
25	+ $this->getMainTable() . '.item_id = `nns`.slider_id'
26	+ )->where('status=1 AND `nns`.store_id in (0, ?) ',
27	+ $object->getStoreId())->order('created_time DESC')->limit(1);
28	+ }
29	+
30	+ return $select;
31	+ }
32	+
33	+ /**
34	+ * Assign page to store views
35	+ *
36	+ * @param Mage_Core_Model_Abstract $object
37	+ */
38	+ protected function _afterSave(Mage_Core_Model_Abstract $object)
39	+ {
40	+ $condition = $this->_getWriteAdapter()->quoteInto('slider_id = ?', $object->getId());
41	+
42	+ // process slider item to store relation
43	+ $this->_getWriteAdapter()->delete($this->getTable('slider_store'), $condition);
44	+ foreach ((array) $object->getData('stores') as $store) {
45	+ $storeArray = array ();
46	+ $storeArray['slider_id'] = $object->getId();
47	+ $storeArray['store_id'] = $store;
48	+ $this->_getWriteAdapter()->insert(
49	+ $this->getTable('slider_store'), $storeArray
50	+ );
51	+ }
52	+
53	+ return parent::_afterSave($object);
54	+ }
55	+
56	+ /**
57	+ * Do store and category processing after loading
58	+ *
59	+ * @param Mage_Core_Model_Abstract $object Current slider item
60	+ */
61	+ protected function _afterLoad(Mage_Core_Model_Abstract $object)
62	+ {
63	+ // process slider item to store relation
64	+ $select = $this->_getReadAdapter()->select()->from(
65	+ $this->getTable('slider_store')
66	+ )->where('slider_id = ?', $object->getId());
67	+
68	+ if ($data = $this->_getReadAdapter()->fetchAll($select)) {
69	+ $storesArray = array ();
70	+ foreach ($data as $row) {
71	+ $storesArray[] = $row['store_id'];
72	+ }
73	+ $object->setData('store_id', $storesArray);
74	+ }
75	+
76	+ return parent::_afterLoad($object);
77	+ }
78	+
79	+
80	+ }

app/code/local/Tatva/Slider/Model/Mysql4/Slider/Collection.php ADDED Viewed

	@@ -0,0 +1,80 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Model_Mysql4_Slider_Collection extends Mage_Core_Model_Mysql4_Collection_Abstract
4	+ {
5	+ public function _construct()
6	+ {
7	+ parent::_construct();
8	+ $this->_init('slider/slider');
9	+ }
10	+
11	+ public function orderBySort(){
12	+ $this->getSelect()->order('sortorder');
13	+ return $this;
14	+ }
15	+
16	+ /**
17	+ * Add Filter by store
18	+ *
19	+ * @param int\|Mage_Core_Model_Store $store Store to be filtered
20	+ * @return Tatva_Slider_Model_Mysql4_Slider_Collection Self
21	+ */
22	+ public function addStoreFilter($store)
23	+ {
24	+ if ($store instanceof Mage_Core_Model_Store) {
25	+ $store = array (
26	+ $store->getId()
27	+ );
28	+ }
29	+
30	+ $this->getSelect()->join(
31	+ array('store_table' => $this->getTable('slider_store')),
32	+ 'main_table.slider_id = store_table.slider_id',
33	+ array ()
34	+ )->where('store_table.store_id in (?)', array (
35	+ 0,
36	+ $store
37	+ ))->group('main_table.slider_id');
38	+
39	+ return $this;
40	+ }
41	+
42	+ /**
43	+ * After load processing - adds store information to the datasets
44	+ *
45	+ */
46	+ protected function _afterLoad()
47	+ {
48	+ if ($this->_previewFlag) {
49	+ $items = $this->getColumnValues('slider_id');
50	+ if (count($items)) {
51	+ $select = $this->getConnection()->select()->from(
52	+ $this->getTable('slider_store')
53	+ )->where(
54	+ $this->getTable('slider_store') . '.slider_id IN (?)',
55	+ $items
56	+ );
57	+ if ($result = $this->getConnection()->fetchPairs($select)) {
58	+ foreach ($this as $item) {
59	+ if (!isset($result[$item->getData('slider_id')])) {
60	+ continue;
61	+ }
62	+ if ($result[$item->getData('slider_id')] == 0) {
63	+ $stores = Mage::app()->getStores(false, true);
64	+ $storeId = current($stores)->getId();
65	+ $storeCode = key($stores);
66	+ }
67	+ else {
68	+ $storeId = $result[$item->getData('slider_id')];
69	+ $storeCode = Mage::app()->getStore($storeId)->getCode();
70	+ }
71	+ $item->setData('_first_store_id', $storeId);
72	+ $item->setData('store_code', $storeCode);
73	+ }
74	+ }
75	+ }
76	+ }
77	+
78	+ parent::_afterLoad();
79	+ }
80	+ }

app/code/local/Tatva/Slider/Model/Slider.php ADDED Viewed

	@@ -0,0 +1,24 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Model_Slider extends Mage_Core_Model_Abstract
4	+ {
5	+ public function _construct()
6	+ {
7	+ parent::_construct();
8	+ $this->_init('slider/slider');
9	+ }
10	+
11	+ public function getcustomersliderdata()
12	+ {
13	+ $collection = $this->getCollection()
14	+ ->addFieldToFilter('status',1)
15	+ ->orderBySort()
16	+ ->addStoreFilter(Mage :: app()->getStore());
17	+ if(Mage::getStoreConfig('slider/slider/maxlimit'))
18	+ {
19	+ $collection->setPageSize(Mage::getStoreConfig('slider/slider/maxlimit'));
20	+ }
21	+
22	+ return $collection;
23	+ }
24	+ }

app/code/local/Tatva/Slider/controllers/Adminhtml/SliderController.php ADDED Viewed

	@@ -0,0 +1,268 @@


1	+ <?php
2	+
3	+ class Tatva_Slider_Adminhtml_SliderController extends Mage_Adminhtml_Controller_action
4	+ {
5	+
6	+ protected function _initAction() {
7	+ $this->loadLayout()
8	+ ->_setActiveMenu('slider/items')
9	+ ->_addBreadcrumb(Mage::helper('adminhtml')->__('Slider Manager'), Mage::helper('adminhtml')->__('Slider Manager'));
10	+
11	+ return $this;
12	+ }
13	+
14	+ public function indexAction() {
15	+ $this->_initAction()
16	+ ->renderLayout();
17	+ }
18	+
19	+ public function editAction() {
20	+ $id = $this->getRequest()->getParam('id');
21	+ $model = Mage::getModel('slider/slider')->load($id);
22	+
23	+ if ($model->getId() \|\| $id == 0) {
24	+ $data = Mage::getSingleton('adminhtml/session')->getFormData(true);
25	+ if (!empty($data)) {
26	+ $model->setData($data);
27	+ }
28	+
29	+ Mage::register('slider_data', $model);
30	+
31	+ $this->loadLayout();
32	+ $this->_setActiveMenu('slider/items');
33	+
34	+ $this->_addBreadcrumb(Mage::helper('adminhtml')->__('Slider Manager'), Mage::helper('adminhtml')->__('Slider Manager'));
35	+ $this->_addBreadcrumb(Mage::helper('adminhtml')->__('Slider News'), Mage::helper('adminhtml')->__('Slider News'));
36	+
37	+ $this->getLayout()->getBlock('head')->setCanLoadExtJs(true);
38	+
39	+ $this->_addContent($this->getLayout()->createBlock('slider/adminhtml_slider_edit'))
40	+ ->_addLeft($this->getLayout()->createBlock('slider/adminhtml_slider_edit_tabs'));
41	+
42	+ $this->renderLayout();
43	+ } else {
44	+ Mage::getSingleton('adminhtml/session')->addError(Mage::helper('slider')->__('Slide does not exist'));
45	+ $this->_redirect('//');
46	+ }
47	+ }
48	+
49	+ public function newAction() {
50	+ $this->_forward('edit');
51	+ }
52	+
53	+ public function saveAction()
54	+ {
55	+ if ($data = $this->getRequest()->getPost())
56	+ {
57	+ $collection = Mage::getModel('slider/slider')->getCollection();
58	+ $collection->addFieldToFilter('title',$data['title']);
59	+ if($this->getRequest()->getParam('id'))
60	+ {
61	+ $collection->addFieldToFilter('slider_id',array('neq' => $this->getRequest()->getParam('id')));
62	+ }
63	+
64	+ if($collection->getData())
65	+ {
66	+ Mage::getSingleton('adminhtml/session')->addError(Mage::helper('slider')->__('Slider with same title "%s" already exist.', $data['title']));
67	+ Mage::getSingleton('adminhtml/session')->setFormData($data);
68	+ $this->_redirect('//edit', array('id' => $this->getRequest()->getParam('id')));
69	+ return;
70	+ }
71	+
72	+ if(isset($_FILES['filename']['name']) && $_FILES['filename']['name'] != '')
73	+ {
74	+ if( $this->getRequest()->getParam('id') > 0 )
75	+ {
76	+ $model = Mage::getModel('slider/slider')->load($this->getRequest()->getParam('id'));
77	+ if($model->getfilename() != "")
78	+ {
79	+ // path of the resized image to be saved
80	+ // remove file if it already exist
81	+ $imageUrl = Mage::getBaseDir('media').DS."customerslider".DS.$model->getfilename();
82	+ $imageResized = Mage::getBaseDir('media').DS."customerslider".DS."thumbnail".DS.$model->getfilename();
83	+
84	+ if(file_exists($imageUrl))
85	+ {
86	+ unlink($imageUrl);
87	+ unlink($imageResized);
88	+ }
89	+ }
90	+ }
91	+ try
92	+ {
93	+ $date = date('Ymdhis');
94	+ /* Starting upload */
95	+ $uploader = new Varien_File_Uploader('filename');
96	+
97	+ // Any extention would work
98	+ $uploader->setAllowedExtensions(array('jpg','jpeg','gif','png'));
99	+ $uploader->setAllowRenameFiles(false);
100	+
101	+ // Set the file upload mode
102	+ // false -> get the file directly in the specified folder
103	+ // true -> get the file in the product like folders (file.jpg will go in something like /media/f/i/file.jpg)
104	+ $uploader->setFilesDispersion(false);
105	+
106	+ $filedet = pathinfo($_FILES['filename']['name']);
107	+
108	+ // We set media as the upload dir
109	+ $path = Mage::getBaseDir('media').DS.'customerslider'.DS;
110	+ $uploader->save($path, $filedet['filename'].$date.'.'.$filedet['extension'] );
111	+
112	+ // actual path of image
113	+ $imageUrl = Mage::getBaseDir('media').DS."customerslider".DS.$filedet['filename'].$date.'.'.$filedet['extension'];
114	+
115	+ // path of the resized image to be saved
116	+ // here, the resized image is saved in media/resized folder
117	+ $imageResized = Mage::getBaseDir('media').DS."customerslider".DS."thumbnail".DS.$filedet['filename'].$date.'.'.$filedet['extension'];
118	+
119	+ // resize image only if the image file exists and the resized image file doesn't exist
120	+ // the image is resized proportionally with the width/height 135px
121	+ if (!file_exists($imageResized)&&file_exists($imageUrl))
122	+ {
123	+ $imageObj = new Varien_Image($imageUrl);
124	+ $imageObj->constrainOnly(TRUE);
125	+ $imageObj->keepAspectRatio(TRUE);
126	+ $imageObj->keepFrame(FALSE);
127	+ $imageObj->resize(100, 100);
128	+ $imageObj->save($imageResized);
129	+ }
130	+
131	+ }
132	+ catch (Exception $e){
133	+ }
134	+
135	+ //this way the name is saved in DB
136	+ $data['filename'] = $filedet['filename'].$date.'.'.$filedet['extension'];
137	+ }
138	+
139	+ $model = Mage::getModel('slider/slider');
140	+ $model->setData($data)
141	+ ->setId($this->getRequest()->getParam('id'));
142	+
143	+ try
144	+ {
145	+ if ($model->getCreatedTime == NULL \|\| $model->getUpdateTime() == NULL) {
146	+ $model->setCreatedTime(now())
147	+ ->setUpdateTime(now());
148	+ } else {
149	+ $model->setUpdateTime(now());
150	+ }
151	+
152	+ $model->save();
153	+ Mage::getSingleton('adminhtml/session')->addSuccess(Mage::helper('slider')->__('Slide was successfully saved'));
154	+ Mage::getSingleton('adminhtml/session')->setFormData(false);
155	+
156	+ if ($this->getRequest()->getParam('back')) {
157	+ $this->_redirect('//edit', array('id' => $model->getId()));
158	+ return;
159	+ }
160	+ $this->_redirect('//');
161	+ return;
162	+ }
163	+ catch (Exception $e)
164	+ {
165	+ Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
166	+ Mage::getSingleton('adminhtml/session')->setFormData($data);
167	+ $this->_redirect('//edit', array('id' => $this->getRequest()->getParam('id')));
168	+ return;
169	+ }
170	+ }
171	+ Mage::getSingleton('adminhtml/session')->addError(Mage::helper('slider')->__('Unable to find item to save'));
172	+ $this->_redirect('//');
173	+ }
174	+
175	+ public function deleteAction()
176	+ {
177	+ if( $this->getRequest()->getParam('id') > 0 )
178	+ {
179	+ try
180	+ {
181	+ $model = Mage::getModel('slider/slider')->load($this->getRequest()->getParam('id'));
182	+ if($model->getfilename() != "")
183	+ {
184	+ $imageUrl = Mage::getBaseDir('media').DS."customerslider".DS.$model->getfilename();
185	+
186	+ // path of the resized image to be saved
187	+ // here, the resized image is saved in media/resized folder
188	+ $imageResized = Mage::getBaseDir('media').DS."customerslider".DS."thumbnail".DS.$model->getfilename();
189	+
190	+ if(file_exists($imageUrl))
191	+ {
192	+ unlink($imageUrl);
193	+ unlink($imageResized);
194	+ }
195	+ }
196	+
197	+ $model->setId($this->getRequest()->getParam('id'))
198	+ ->delete();
199	+
200	+ Mage::getSingleton('adminhtml/session')->addSuccess(Mage::helper('adminhtml')->__('Slide was successfully deleted'));
201	+ $this->_redirect('//');
202	+ }
203	+ catch (Exception $e)
204	+ {
205	+ Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
206	+ $this->_redirect('//edit', array('id' => $this->getRequest()->getParam('id')));
207	+ }
208	+ }
209	+ $this->_redirect('//');
210	+ }
211	+
212	+ public function massDeleteAction()
213	+ {
214	+ $sliderIds = $this->getRequest()->getParam('slider');
215	+ if(!is_array($sliderIds)) {
216	+ Mage::getSingleton('adminhtml/session')->addError(Mage::helper('adminhtml')->__('Please select item(s)'));
217	+ } else {
218	+ try {
219	+ foreach ($sliderIds as $sliderId) {
220	+ $slider = Mage::getModel('slider/slider')->load($sliderId);
221	+ $slider->delete();
222	+ }
223	+ Mage::getSingleton('adminhtml/session')->addSuccess(
224	+ Mage::helper('adminhtml')->__(
225	+ 'Total of %d record(s) were successfully deleted', count($sliderIds)
226	+ )
227	+ );
228	+ } catch (Exception $e) {
229	+ Mage::getSingleton('adminhtml/session')->addError($e->getMessage());
230	+ }
231	+ }
232	+ $this->_redirect('//index');
233	+ }
234	+
235	+ public function exportCsvAction()
236	+ {
237	+ $fileName = 'slider.csv';
238	+ $content = $this->getLayout()->createBlock('slider/adminhtml_slider_grid')
239	+ ->getCsv();
240	+
241	+ $this->_sendUploadResponse($fileName, $content);
242	+ }
243	+
244	+ public function exportXmlAction()
245	+ {
246	+ $fileName = 'slider.xml';
247	+ $content = $this->getLayout()->createBlock('slider/adminhtml_slider_grid')
248	+ ->getXml();
249	+
250	+ $this->_sendUploadResponse($fileName, $content);
251	+ }
252	+
253	+ protected function _sendUploadResponse($fileName, $content, $contentType='application/octet-stream')
254	+ {
255	+ $response = $this->getResponse();
256	+ $response->setHeader('HTTP/1.1 200 OK','');
257	+ $response->setHeader('Pragma', 'public', true);
258	+ $response->setHeader('Cache-Control', 'must-revalidate, post-check=0, pre-check=0', true);
259	+ $response->setHeader('Content-Disposition', 'attachment; filename='.$fileName);
260	+ $response->setHeader('Last-Modified', date('r'));
261	+ $response->setHeader('Accept-Ranges', 'bytes');
262	+ $response->setHeader('Content-Length', strlen($content));
263	+ $response->setHeader('Content-type', $contentType);
264	+ $response->setBody($content);
265	+ $response->sendResponse();
266	+ die;
267	+ }
268	+ }

app/code/local/Tatva/Slider/controllers/IndexController.php ADDED Viewed

	@@ -0,0 +1,9 @@


1	+ <?php
2	+ class Tatva_Slider_IndexController extends Mage_Core_Controller_Front_Action
3	+ {
4	+ public function indexAction()
5	+ {
6	+ $this->loadLayout();
7	+ $this->renderLayout();
8	+ }
9	+ }

app/code/local/Tatva/Slider/etc/adminhtml.xml ADDED Viewed

	@@ -0,0 +1,51 @@


1	+ <?xml version="1.0"?>
2	+ <adminhtml>
3	+ <menu>
4	+ <slider module="slider">
5	+ <title>Slider</title>
6	+ <sort_order>101</sort_order>
7	+ <children>
8	+ <items module="slider">
9	+ <title>Manage Slides</title>
10	+ <sort_order>0</sort_order>
11	+ <action>slider/adminhtml_slider</action>
12	+ </items>
13	+ </children>
14	+ </slider>
15	+ </menu>
16	+ <acl>
17	+ <resources>
18	+ <all>
19	+ <title>Allow Everything</title>
20	+ </all>
21	+ <admin>
22	+ <children>
23	+ <children>
24	+ <Tatva_Slider>
25	+ <title>Tatva Slider</title>
26	+ <sort_order>11</sort_order>
27	+ </Tatva_Slider>
28	+ </children>
29	+ <system>
30	+ <children>
31	+ <config>
32	+ <children>
33	+ <slider translate="title" module="slider">
34	+ <title>Slider</title>
35	+ </slider>
36	+ </children>
37	+ </config>
38	+ </children>
39	+ </system>
40	+ </children>
41	+ </admin>
42	+ </resources>
43	+ </acl>
44	+ <layout>
45	+ <updates>
46	+ <slider>
47	+ <file>slider/slider.xml</file>
48	+ </slider>
49	+ </updates>
50	+ </layout>
51	+ </adminhtml>

app/code/local/Tatva/Slider/etc/config.xml ADDED Viewed

	@@ -0,0 +1,154 @@


1	+ <?xml version="1.0"?>
2	+ <config>
3	+ <modules>
4	+ <Tatva_Slider>
5	+ <version>0.1.0</version>
6	+ </Tatva_Slider>
7	+ </modules>
8	+ <frontend>
9	+ <routers>
10	+ <slider>
11	+ <use>standard</use>
12	+ <args>
13	+ <module>Tatva_Slider</module>
14	+ <frontName>slider</frontName>
15	+ </args>
16	+ </slider>
17	+ </routers>
18	+ <layout>
19	+ <updates>
20	+ <slider>
21	+ <file>slider/slider.xml</file>
22	+ </slider>
23	+ </updates>
24	+ </layout>
25	+ </frontend>
26	+ <admin>
27	+ <routers>
28	+ <slider>
29	+ <use>admin</use>
30	+ <args>
31	+ <module>Tatva_Slider</module>
32	+ <frontName>slider</frontName>
33	+ </args>
34	+ </slider>
35	+ </routers>
36	+ </admin>
37	+ <adminhtml>
38	+ <menu>
39	+ <slider module="slider">
40	+ <title>Slider</title>
41	+ <sort_order>101</sort_order>
42	+ <children>
43	+ <items module="slider">
44	+ <title>Manage Slides</title>
45	+ <sort_order>0</sort_order>
46	+ <action>slider/adminhtml_slider</action>
47	+ </items>
48	+ </children>
49	+ </slider>
50	+ </menu>
51	+ <acl>
52	+ <resources>
53	+ <all>
54	+ <title>Allow Everything</title>
55	+ </all>
56	+ <admin>
57	+ <children>
58	+ <children>
59	+ <Tatva_Slider>
60	+ <title>Tatva Slider</title>
61	+ <sort_order>11</sort_order>
62	+ </Tatva_Slider>
63	+ </children>
64	+ <system>
65	+ <children>
66	+ <config>
67	+ <children>
68	+ <slider translate="title" module="slider">
69	+ <title>Slider</title>
70	+ </slider>
71	+ </children>
72	+ </config>
73	+ </children>
74	+ </system>
75	+ </children>
76	+ </admin>
77	+ </resources>
78	+ </acl>
79	+ <layout>
80	+ <updates>
81	+ <slider>
82	+ <file>slider/slider.xml</file>
83	+ </slider>
84	+ </updates>
85	+ </layout>
86	+ </adminhtml>
87	+ <global>
88	+ <models>
89	+ <slider>
90	+ <class>Tatva_Slider_Model</class>
91	+ <resourceModel>slider_mysql4</resourceModel>
92	+ </slider>
93	+ <slider_mysql4>
94	+ <class>Tatva_Slider_Model_Mysql4</class>
95	+ <entities>
96	+ <slider>
97	+ <table>slider</table>
98	+ </slider>
99	+ <slider_store>
100	+ <table>slider_store</table>
101	+ </slider_store>
102	+ </entities>
103	+ </slider_mysql4>
104	+ </models>
105	+ <resources>
106	+ <slider_setup>
107	+ <setup>
108	+ <module>Tatva_Slider</module>
109	+ </setup>
110	+ <connection>
111	+ <use>core_setup</use>
112	+ </connection>
113	+ </slider_setup>
114	+ <slider_write>
115	+ <connection>
116	+ <use>core_write</use>
117	+ </connection>
118	+ </slider_write>
119	+ <slider_read>
120	+ <connection>
121	+ <use>core_read</use>
122	+ </connection>
123	+ </slider_read>
124	+ </resources>
125	+ <blocks>
126	+ <slider>
127	+ <class>Tatva_Slider_Block</class>
128	+ </slider>
129	+ </blocks>
130	+ <helpers>
131	+ <slider>
132	+ <class>Tatva_Slider_Helper</class>
133	+ </slider>
134	+ </helpers>
135	+ </global>
136	+ <default>
137	+ <slider>
138	+ <slider>
139	+ <title>1</title>
140	+ <square>1</square>
141	+ <button>0</button>
142	+ <auto>1</auto>
143	+ <time>7</time>
144	+ <content>0</content>
145	+ <maxlimit>5</maxlimit>
146	+ <width>900</width>
147	+ <height>450</height>
148	+ <imagewidth>900</imagewidth>
149	+ <imageheight>450</imageheight>
150	+ <left>740</left>
151	+ </slider>
152	+ </slider>
153	+ </default>
154	+ </config>

app/code/local/Tatva/Slider/etc/system.xml ADDED Viewed

	@@ -0,0 +1,142 @@


1	+ <?xml version="1.0"?>
2	+ <config>
3	+ <tabs>
4	+ <slider translate="label" module="slider">
5	+ <label>Slider</label>
6	+ <sort_order>101</sort_order>
7	+ </slider>
8	+ </tabs>
9	+ <sections>
10	+ <slider translate="label" module="slider">
11	+ <label>Slider Configuration</label>
12	+ <class>separator-top</class>
13	+ <tab>slider</tab>
14	+ <frontend_type>text</frontend_type>
15	+ <sort_order>10001</sort_order>
16	+ <show_in_default>1</show_in_default>
17	+ <show_in_website>1</show_in_website>
18	+ <show_in_store>1</show_in_store>
19	+ <groups>
20	+ <slider translate="label" module="slider">
21	+ <label>Slider Configuration</label>
22	+ <frontend_type>text</frontend_type>
23	+ <sort_order>50</sort_order>
24	+ <show_in_default>1</show_in_default>
25	+ <show_in_website>1</show_in_website>
26	+ <show_in_store>1</show_in_store>
27	+ <fields>
28	+ <title translate="label" module="slider">
29	+ <label>Display Titles</label>
30	+ <frontend_type>select</frontend_type>
31	+ <source_model>adminhtml/system_config_source_yesno</source_model>
32	+ <sort_order>1</sort_order>
33	+ <show_in_default>1</show_in_default>
34	+ <show_in_website>1</show_in_website>
35	+ <show_in_store>1</show_in_store>
36	+ </title>
37	+ <square translate="label" module="slider">
38	+ <label>Display Squares</label>
39	+ <frontend_type>select</frontend_type>
40	+ <source_model>adminhtml/system_config_source_yesno</source_model>
41	+ <sort_order>2</sort_order>
42	+ <show_in_default>1</show_in_default>
43	+ <show_in_website>1</show_in_website>
44	+ <show_in_store>1</show_in_store>
45	+ </square>
46	+ <button translate="label" module="slider">
47	+ <label>Display Next-Previous Buttons</label>
48	+ <frontend_type>select</frontend_type>
49	+ <source_model>adminhtml/system_config_source_yesno</source_model>
50	+ <sort_order>3</sort_order>
51	+ <show_in_default>1</show_in_default>
52	+ <show_in_website>1</show_in_website>
53	+ <show_in_store>1</show_in_store>
54	+ </button>
55	+ <auto translate="label" module="slider">
56	+ <label>Auto Slide</label>
57	+ <frontend_type>select</frontend_type>
58	+ <source_model>adminhtml/system_config_source_yesno</source_model>
59	+ <sort_order>4</sort_order>
60	+ <show_in_default>1</show_in_default>
61	+ <show_in_website>1</show_in_website>
62	+ <show_in_store>1</show_in_store>
63	+ </auto>
64	+ <time translate="label" module="slider">
65	+ <label>Delay Between Two Slides</label>
66	+ <comment>In Seconds</comment>
67	+ <frontend_type>text</frontend_type>
68	+ <validate>validate-digits validate-greater-than-zero</validate>
69	+ <sort_order>5</sort_order>
70	+ <show_in_default>1</show_in_default>
71	+ <show_in_website>1</show_in_website>
72	+ <show_in_store>1</show_in_store>
73	+ </time>
74	+ <content translate="label" module="slider">
75	+ <label>Display Content Of Slide</label>
76	+ <frontend_type>select</frontend_type>
77	+ <source_model>adminhtml/system_config_source_yesno</source_model>
78	+ <sort_order>6</sort_order>
79	+ <show_in_default>1</show_in_default>
80	+ <show_in_website>1</show_in_website>
81	+ <show_in_store>1</show_in_store>
82	+ </content>
83	+ <maxlimit translate="label" module="slider">
84	+ <label>Maximum No Of Slides To Display</label>
85	+ <frontend_type>text</frontend_type>
86	+ <validate>validate-digits validate-greater-than-zero</validate>
87	+ <sort_order>7</sort_order>
88	+ <show_in_default>1</show_in_default>
89	+ <show_in_website>1</show_in_website>
90	+ <show_in_store>1</show_in_store>
91	+ </maxlimit>
92	+ <width translate="label" module="slider">
93	+ <label>Slider Width</label>
94	+ <frontend_type>text</frontend_type>
95	+ <validate>validate-digits validate-greater-than-zero</validate>
96	+ <sort_order>8</sort_order>
97	+ <show_in_default>1</show_in_default>
98	+ <show_in_website>1</show_in_website>
99	+ <show_in_store>1</show_in_store>
100	+ </width>
101	+ <height translate="label" module="slider">
102	+ <label>Slider Height</label>
103	+ <frontend_type>text</frontend_type>
104	+ <validate>validate-digits validate-greater-than-zero</validate>
105	+ <sort_order>9</sort_order>
106	+ <show_in_default>1</show_in_default>
107	+ <show_in_website>1</show_in_website>
108	+ <show_in_store>1</show_in_store>
109	+ </height>
110	+ <imagewidth translate="label" module="slider">
111	+ <label>Image Width</label>
112	+ <frontend_type>text</frontend_type>
113	+ <validate>validate-digits validate-greater-than-zero</validate>
114	+ <sort_order>10</sort_order>
115	+ <show_in_default>1</show_in_default>
116	+ <show_in_website>1</show_in_website>
117	+ <show_in_store>1</show_in_store>
118	+ </imagewidth>
119	+ <imageheight translate="label" module="slider">
120	+ <label>Image Height</label>
121	+ <frontend_type>text</frontend_type>
122	+ <validate>validate-digits validate-greater-than-zero</validate>
123	+ <sort_order>11</sort_order>
124	+ <show_in_default>1</show_in_default>
125	+ <show_in_website>1</show_in_website>
126	+ <show_in_store>1</show_in_store>
127	+ </imageheight>
128	+ <left translate="label" module="slider">
129	+ <label>Left Position For Squares</label>
130	+ <frontend_type>text</frontend_type>
131	+ <validate>validate-digits validate-greater-than-zero</validate>
132	+ <sort_order>12</sort_order>
133	+ <show_in_default>1</show_in_default>
134	+ <show_in_website>1</show_in_website>
135	+ <show_in_store>1</show_in_store>
136	+ </left>
137	+ </fields>
138	+ </slider>
139	+ </groups>
140	+ </slider>
141	+ </sections>
142	+ </config>

app/code/local/Tatva/Slider/sql/slider_setup/mysql4-install-0.1.0.php ADDED Viewed

	@@ -0,0 +1,35 @@


1	+ <?php
2	+
3	+ $installer = $this;
4	+
5	+ $installer->startSetup();
6	+
7	+ $installer->run("
8	+
9	+ -- DROP TABLE IF EXISTS {$this->getTable('slider')};
10	+ CREATE TABLE IF NOT EXISTS {$this->getTable('slider')} (
11	+ `slider_id` int(11) unsigned NOT NULL auto_increment,
12	+ `title` varchar(255) NOT NULL default '',
13	+ `slider_url` varchar(255) NOT NULL default '',
14	+ `filename` varchar(255) NOT NULL default '',
15	+ `sortorder` int(11) NOT NULL default '0',
16	+ `status` smallint(6) NOT NULL default '0',
17	+ `content` text NULL default '',
18	+ `created_time` datetime NULL,
19	+ `update_time` datetime NULL,
20	+ PRIMARY KEY (`slider_id`)
21	+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
22	+
23	+ -- DROP TABLE IF EXISTS `{$this->getTable('slider_store')}`;
24	+ CREATE TABLE `{$this->getTable('slider_store')}` (
25	+ `slider_id` int(10) unsigned NOT NULL,
26	+ `store_id` smallint(5) unsigned NOT NULL,
27	+ PRIMARY KEY (`slider_id`,`store_id`),
28	+ CONSTRAINT `FK_SLIDER_SLIDER_STORE_SLIDER` FOREIGN KEY (`slider_id`) REFERENCES `{$this->getTable('slider')}` (`slider_id`) ON UPDATE CASCADE ON DELETE CASCADE,
29	+ CONSTRAINT `FK_SLIDER_SLIDER_STORE_STORE` FOREIGN KEY (`store_id`) REFERENCES `{$this->getTable('core/store')}` (`store_id`) ON UPDATE CASCADE ON DELETE CASCADE
30	+ ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='SLIDER items to Stores';
31	+
32	+
33	+ ");
34	+
35	+ $installer->endSetup();

app/design/adminhtml/default/default/layout/slider/slider.xml ADDED Viewed

	@@ -0,0 +1,11 @@


1	+ <?xml version="1.0"?>
2	+ <layout version="0.1.0">
3	+ <slider_adminhtml_slider_index>
4	+ <reference name="content">
5	+ <block type="slider/adminhtml_slider" name="slider" />
6	+ </reference>
7	+ </slider_adminhtml_slider_index>
8	+ <slider_adminhtml_slider_edit>
9	+ <update handle="editor"/>
10	+ </slider_adminhtml_slider_edit>
11	+ </layout>

app/design/frontend/default/default/layout/slider/slider.xml ADDED Viewed

	@@ -0,0 +1,15 @@


1	+ <?xml version="1.0"?>
2	+ <layout version="0.1.0">
3	+ <default translate="label" module="page">
4	+ <reference name="head">
5	+ <action method="addCss"><stylesheet>css/slider/slider.css</stylesheet></action>
6	+ <action method="addItem"><type>skin_js</type><name>js/slider/jquery-1.6.4.min.js</name></action>
7	+ <action method="addItem"><type>skin_js</type><name>js/slider/jquery.jcarousel.js</name></action>
8	+ </reference>
9	+ </default>
10	+ <slider_index_index>
11	+ <reference name="content">
12	+ <block type="slider/slider" name="slider" template="slider/slider.phtml" />
13	+ </reference>
14	+ </slider_index_index>
15	+ </layout>

app/design/frontend/default/default/template/slider/slider.phtml ADDED Viewed

	@@ -0,0 +1,147 @@


1	+ <?php
2	+ $slider = $this->getcustomerslider();
3	+
4	+ if($slider->getData())
5	+ {
6	+ $width = Mage::getStoreConfig('slider/slider/width') ? Mage::getStoreConfig('slider/slider/width') : 900;
7	+ $height = Mage::getStoreConfig('slider/slider/height') ? Mage::getStoreConfig('slider/slider/height') : 450;
8	+ $imagewidth = Mage::getStoreConfig('slider/slider/imagewidth') ? Mage::getStoreConfig('slider/slider/imagewidth') : 900;
9	+ $imageheight = Mage::getStoreConfig('slider/slider/imageheight') ? Mage::getStoreConfig('slider/slider/imageheight') : 450;
10	+ $title = Mage::getStoreConfig('slider/slider/title') ? Mage::getStoreConfig('slider/slider/title') : false;
11	+ $square = Mage::getStoreConfig('slider/slider/square') ? Mage::getStoreConfig('slider/slider/square') : false;
12	+ $button = Mage::getStoreConfig('slider/slider/button') ? Mage::getStoreConfig('slider/slider/button') : 2;
13	+ $content = Mage::getStoreConfig('slider/slider/content') ? Mage::getStoreConfig('slider/slider/content') : false;
14	+ $auto = Mage::getStoreConfig('slider/slider/auto') ? Mage::getStoreConfig('slider/slider/time') : 0;
15	+ $left = Mage::getStoreConfig('slider/slider/left') ? Mage::getStoreConfig('slider/slider/left') : 590;
16	+ $left = ($left > $width) ? 590 : $left;
17	+ if(!$content)
18	+ {
19	+ $imagewidth = $width;
20	+ $imageheight = $height;
21	+ }
22	+ else
23	+ {
24	+ $imagewidth = ($imagewidth >= $width) ? $width - 200 : $imagewidth;
25	+ $imageheight = ($imageheight >= $height) ? $height : $imageheight;
26	+ $contentwidth = $width - $imagewidth - 50;
27	+ $contentheight = $height - 100;
28	+ }
29	+ ?>
30	+
31	+ <script type="text/javascript" language="javascript">
32	+
33	+ function mycarousel_initCallback(carousel) {
34	+ carousel.buttonNext.bind('click', function() {
35	+ carousel.startAuto(0);
36	+ });
37	+ carousel.buttonPrev.bind('click', function() {
38	+ carousel.startAuto(0);
39	+ });
40	+ carousel.clip.hover(function() {
41	+ carousel.stopAuto();
42	+ }, function() {
43	+ carousel.startAuto();
44	+ });
45	+ };
46	+
47	+ jQuery(document).ready(function()
48	+ {
49	+ function primopiano_itemLastInCallback(carousel, item, idx, state) {
50	+ jQuery("#gooeymenu li a").removeClass("active");
51	+ jQuery("#gooeymenu li#link_primopiano_"+idx+" a").addClass("active");
52	+ jQuery("#primopiano_menu li").removeClass("active");
53	+ jQuery("#primopiano_menu li#link_primopiano_"+idx).addClass("active");
54	+ };
55	+
56	+ function primopiano_initCallback(carousel) {
57	+ jQuery('#gooeymenu a').bind('click', function() {
58	+ carousel.scroll(jQuery.jcarousel.intval(jQuery(this).attr("rel")));
59	+ carousel.stopAuto();
60	+ return false;
61	+ });
62	+ carousel.clip.hover(function() {
63	+ carousel.stopAuto();
64	+ }, function() {
65	+ carousel.startAuto();
66	+ });
67	+
68	+ jQuery('#primopiano_menu a').bind('click', function() {
69	+ carousel.scroll(jQuery.jcarousel.intval(jQuery(this).attr("rel")));
70	+ carousel.stopAuto();
71	+ return false;
72	+ });
73	+ carousel.clip.hover(function() {
74	+ carousel.stopAuto();
75	+ }, function() {
76	+ carousel.startAuto();
77	+ });
78	+ };
79	+
80	+ var button = <?php echo $button?>;
81	+
82	+ jQuery('#primopiano_slide').jcarousel({
83	+ auto: <?php echo $auto?>,
84	+ scroll:1,
85	+ wrap: 'both',
86	+ animation: 500,
87	+ buttonNextHTML: (button == 1) ? '<div></div>' : '',
88	+ buttonPrevHTML: (button == 1) ? '<div></div>' : '',
89	+ initCallback: primopiano_initCallback,
90	+ itemLastInCallback: {
91	+ onBeforeAnimation: primopiano_itemLastInCallback
92	+ }
93	+ });
94	+ });
95	+ </script>
96	+
97	+ <div id="primopiano_big" style="width:<?php echo $width?>px; height:<?php echo $height?>px;">
98	+ <?php if($square) { ?>
99	+ <ul id="primopiano_menu" style="left: <?php echo $left?>px;">
100	+ <?php $i=1;foreach($slider as $item):?>
101	+ <li id="link_primopiano_<?php echo $i?>">
102	+ <a rel="<?php echo $i?>" href="#"> </a>
103	+ </li>
104	+ <?php $i++;endforeach;?>
105	+ </ul>
106	+ <?php } ?>
107	+ <div class="jcarousel-container jcarousel-container-horizontal" style="display: block;">
108	+ <?php if($button == 1) { ?>
109	+ <div class="jcarousel-prev jcarousel-prev-horizontal" style="display: block;" disabled="false"></div>
110	+ <div class="jcarousel-next jcarousel-next-horizontal" style="display: block;" disabled="false"></div>
111	+ <?php } ?>
112	+ <div class="jcarousel-clip jcarousel-clip-horizontal">
113	+ <ul id="primopiano_slide" class="jcarousel-list jcarousel-list-horizontal" >
114	+ <?php $i=1;foreach($slider as $item):?>
115	+ <li id="primopiano_<?php echo $i?>" jcarouselindex="<?php echo $i?>">
116	+ <a href="<?php echo $item->getSliderUrl() ?>" target="_blank"><img src="<?php echo Mage::getBaseUrl('media') . 'customerslider/' . $item->getFilename(); ?>" height="<?php echo $imageheight?>" width="<?php echo $imagewidth?>"/></a>
117	+ <?php if($content) { ?>
118	+ <div class="text" style="width:<?php echo $contentwidth?>px; height:<?php echo ($height-15) ?>px;">
119	+ <h2><?php echo $item->getTitle();?></h2>
120	+ <div style="height:<?php echo $contentheight?>px;">
121	+ <?php echo $item->getContent();?>
122	+ </div>
123	+ </div>
124	+ <?php } ?>
125	+ </li>
126	+ <?php $i++;endforeach;?>
127	+ </ul>
128	+ </div>
129	+ </div>
130	+ </div>
131	+ <?php if($title) { ?>
132	+ <div class="paging banscrollbg" id="mygaltop" style="width: <?php echo ($width-12) ;?>px;">
133	+ <ul id="gooeymenu" class="solidblockmenu">
134	+ <?php $i=1;foreach($slider as $item):?>
135	+ <li id="link_primopiano_<?php echo $i?>">
136	+ <a href="#" rel="<?php echo $i; ?>"><?php echo $item->getTitle(); ?></a>
137	+ </li>
138	+ <?php if($i%5 == 0 && $i < count($slider) ) { ?>
139	+ </ul>
140	+ </div>
141	+ <div class="paging banscrollbg" id="mygaltop" style="width: <?php echo ($width-12) ;?>px; margin-top: -11px">
142	+ <ul id="gooeymenu" class="solidblockmenu">
143	+ <?php } $i++; endforeach; ?>
144	+ </ul>
145	+ </div>
146	+ <?php } ?>
147	+ <?php } ?>

app/etc/modules/Tatva_Slider.xml ADDED Viewed

	@@ -0,0 +1,9 @@


1	+ <?xml version="1.0"?>
2	+ <config>
3	+ <modules>
4	+ <Tatva_Slider>
5	+ <active>true</active>
6	+ <codePool>local</codePool>
7	+ </Tatva_Slider>
8	+ </modules>
9	+ </config>

package.xml ADDED Viewed

	@@ -0,0 +1,22 @@


1	+ <?xml version="1.0"?>
2	+ <package>
3	+ <name>Etatvasoft_Dynamic_Image_Slider</name>
4	+ <version>1.5.1</version>
5	+ <stability>stable</stability>
6	+ <license uri="http://opensource.org/licenses/osl-3.0.php">Open Software License (OSL)</license>
7	+ <channel>community</channel>
8	+ <extends/>
9	+ <summary>This Extension is very simple and easy to install and have lots of dynamic feature that helps shop owner to show their shop feature on innovative ways.</summary>
10	+ <description>Magento Slider is a very powerful and useful feature. if you are running an online business then you need to highlight your featured areas.
11	+ This Extension is very simple and easy to install and have lots of dynamic feature that helps shop owner to show their shop feature on innovative ways.
12	+ Its multistore supported so shop owner can display different slides for different stores
13	+ All features are configurable from admin like width, height, auto slideshow, display next previous arrow, show caption, show navigation images, max number of slides to display, display slide content, time between two slides.
14	+ </description>
15	+ <notes>All features are configurable from admin like width, height, auto slideshow, display next previous arrow, show caption, show navigation images, max number of slides to display, display slide content, time between two slides.</notes>
16	+ <authors><author><name>Etatvasoft</name><user>Etatvasoft</user><email>etatvasoft.magentodevelopment@gmail.com</email></author></authors>
17	+ <date>2012-12-26</date>
18	+ <time>07:36:10</time>
19	+ <contents><target name="magelocal"><dir name="Tatva"><dir name="Slider"><dir name="Block"><dir name="Adminhtml"><dir name="Slider"><dir name="Edit"><file name="Form.php" hash="ca930481c7735510714bc08f3ed54388"/><dir name="Tab"><file name="Form.php" hash="ecbc323463fcab88693d4c59fecd4a0c"/></dir><file name="Tabs.php" hash="caad7f9056c9c07c392980656c356871"/></dir><file name="Edit.php" hash="8a3a0fef10e2e61350a5b96d42919fc3"/><file name="Grid.php" hash="f514362d14115b3723e936728a856ce0"/></dir><file name="Slider.php" hash="d1c6599add8772e4b564fa24d0706742"/></dir><file name="Slider.php" hash="206931d8e27c6917f7a2644006780348"/></dir><dir name="Helper"><file name="Data.php" hash="1040dcdf8a42eed3e0010fed0d6128a3"/></dir><dir name="Model"><dir name="Mysql4"><dir name="Slider"><file name="Collection.php" hash="2ae22e2c3320dd3a22c853d443cc914f"/></dir><file name="Slider.php" hash="f58a717ab3b4bd59ba605649129ca9d1"/></dir><file name="Slider.php" hash="0d75c8352f467422a324d68e4e8f1ccb"/></dir><dir name="controllers"><dir name="Adminhtml"><file name="SliderController.php" hash="cea85ed88e7daefc237ba9554f78ec30"/></dir><file name="IndexController.php" hash="c1fc4c20c94f5c3076b1be1370add42a"/></dir><dir name="etc"><file name="adminhtml.xml" hash="bebfdfea65ef756de4153f0dba4a2b10"/><file name="config.xml" hash="a2800ac31a36329fc7740b00ceee1070"/><file name="system.xml" hash="0ce62b0e65d5096ddc8564169705cb92"/></dir><dir name="sql"><dir name="slider_setup"><file name="mysql4-install-0.1.0.php" hash="efd60f0f0fd9351c16c15aca41bdfb48"/></dir></dir></dir></dir></target><target name="magedesign"><dir name="adminhtml"><dir name="default"><dir name="default"><dir name="layout"><dir name="slider"><file name="slider.xml" hash="a110923b7eeb351204c9e43f6ca8e0dd"/></dir></dir></dir></dir></dir><dir name="frontend"><dir name="default"><dir name="default"><dir name="layout"><dir name="slider"><file name="slider.xml" hash="9651b1f4114b5f8ff1229886b4607fca"/></dir></dir><dir name="template"><dir name="slider"><file name="slider.phtml" hash="54bebb898706ad8a076829b9acf477df"/></dir></dir></dir></dir></dir></target><target name="mageetc"><dir name="modules"><file name="Tatva_Slider.xml" hash="248fedac6d3c4175a2564765fde3b4a9"/></dir></target><target name="mageskin"><dir name="frontend"><dir name="default"><dir name="default"><dir name="css"><dir name="slider"><file name="slider.css" hash="dab445ad3a99959812c5af9d2865a780"/></dir></dir><dir name="images"><dir name="slider"><file name="Thumbs.db" hash="a4e466bbbb29524e0d89c23c19829437"/><file name="b_next.png" hash="d72dde0609aded61a24fa18cdca4bf7f"/><file name="b_prev.png" hash="86e333b7023d493e8024ccc6b32cd690"/><file name="bannerscrollbg.gif" hash="bd8c7ef3273a6219fd1bb56bc24cbf6d"/><file name="bluehbg.gif" hash="bdd4f53932bd952684d5d87a69c261c3"/><file name="carousel_next.png" hash="8a6d7719accc317e0dbd4a831677598c"/><file name="carousel_prev.png" hash="849d28e8873e8104c232348348c5e5b8"/><file name="content_bg.jpg" hash="e32654532856667842f9002208341e15"/><file name="next.png" hash="1b2ee17462251a2bd374a8a8a49d6ede"/><file name="next_arrow.png" hash="f395949692f96b812d41521dc8418e37"/><file name="num-act.png" hash="bead24653e91070840cec1153577ba24"/><file name="num.png" hash="4847ee03d68096c72339117db3ce981d"/><file name="prev.png" hash="e0b379b1a7db33c59cc90c4068b2ae3f"/><file name="prev_arrow.png" hash="3ba0da3255d4aac51f8bddf814abd480"/><file name="primopiano_menu.gif" hash="157cf32c6c9a103000441d1cf13768bf"/><file name="primopiano_menu2.gif" hash="2e08aa45e6ad2bd460832bf2c0c20069"/><file name="scroolbg.gif" hash="39d89710b27da072e63bbbdc474ab090"/></dir></dir><dir name="js"><dir name="slider"><file name="jquery-1.6.4.min.js" hash="fdcd59e694043785ddaebb2c688cfa64"/><file name="jquery.jcarousel.js" hash="c12b6393fdd5aa32fc572ce1594d4184"/></dir></dir></dir></dir></dir></target></contents>
20	+ <compatible/>
21	+ <dependencies><required><php><min>5.1.0</min><max>6.0.0</max></php></required></dependencies>
22	+ </package>

skin/frontend/default/default/css/slider/slider.css ADDED Viewed

	@@ -0,0 +1,105 @@


1	+ ul.solidblockmenu{
2	+ margin: 0;
3	+ padding:1px 0px 9px 40px;
4	+ list-style: none;
5	+ position:relative;
6	+ text-align: left;
7	+ background:url(../../images/slider/scroolbg.gif);
8	+ height:18px;
9	+ z-index:4;
10	+ }
11	+
12	+ ul.solidblockmenu li{
13	+ display: inline;
14	+ }
15	+
16	+ ul.solidblockmenu li a{
17	+ font-size:14px;
18	+ color: #5a5a5a;
19	+ padding:0px 25px 0px 25px;
20	+ margin-right:40px; /spacing between each menu link/
21	+ text-decoration: none;
22	+ text-align: center;
23	+ line-height: 26px;
24	+ display: block;
25	+ float: left;
26	+ }
27	+
28	+ ul.solidblockmenu li.active{ /style of LI that gets dynamically added to menu to create background effect/
29	+ position:absolute;
30	+ background:url(../../images/slider/bluehbg.gif) repeat-x top;
31	+ padding:1px 0px 1px 0px;
32	+ height:24px;
33	+ color:#FFF;
34	+ }
35	+
36	+ /--Paging Styles--/
37	+
38	+ .paging a:hover, a.current, a.active{
39	+ background:url(../../images/slider/bluehbg.gif) repeat-x top;
40	+ }
41	+
42	+ .banscrollbg {background:url(../../images/slider/bannerscrollbg.gif) repeat-x top; float:left; height:28px;
43	+ padding:6px;}
44	+
45	+
46	+ #primopiano_big {
47	+ position: relative; float:left; overflow: hidden;
48	+ }
49	+ ul#primopiano_menu {
50	+ position: absolute; bottom:5px; height:18px; z-index:100000;
51	+ }
52	+ ul#primopiano_menu li {
53	+ width:18px; height:18px; display:inline-block; background:url(../../images/slider/num.png) no-repeat left top;
54	+ z-index:1000; margin-right:2px;float:left;
55	+ }
56	+ ul#primopiano_menu li.active,ul#primopiano_menu li a:hover {
57	+ /background-position: left bottom;/ /for square button enable it/
58	+ background:url(../../images/slider/num-act.png) no-repeat left top;
59	+ }
60	+ ul#primopiano_menu li a {
61	+ display: block;
62	+ text-decoration: none;
63	+ }
64	+
65	+ ul#primopiano_slide li {
66	+ position: relative; float: left; overflow: hidden;
67	+ }
68	+
69	+ ul#primopiano_slide li a {
70	+ float: left;
71	+ }
72	+
73	+ ul#primopiano_slide li .text {
74	+ float: right; background:url(../../images/slider/content_bg.jpg) top; font-size:14px; color:#cccccc;
75	+ padding:15px 25px 0px 25px; margin:0px; overflow: hidden; background-repeat: repeat;
76	+ }
77	+
78	+ ul#primopiano_slide li .text div {
79	+ overflow: hidden;
80	+ clear: both;
81	+ line-height: 22px;
82	+ }
83	+
84	+ ul#primopiano_slide li img {
85	+ border: 0;
86	+ }
87	+
88	+ ul#primopiano_slide li h2 {
89	+ line-height: normal; padding:0px 0px 10px 0px; margin:0px; color: #58554e; font-size: 25px; font-weight: normal;
90	+ font-family: 'TradeGothicLTStdBold', Arial; font-size:33px; color:#ffffff; line-height:38px
91	+ }
92	+
93	+ #primopiano_big .jcarousel-clip {
94	+ z-index: 2; position: relative; padding-bottom: 2px; margin: 0px; padding-left: 0px; padding-right: 0px; overflow: hidden; padding-top: 0px
95	+ }
96	+ #primopiano_big .jcarousel-list {
97	+ z-index: 1; position: relative; padding-bottom: 0px; margin: 0px; padding-left: 0px; padding-right: 0px; overflow: hidden; top: 0px; padding-top: 0px; left: 0px
98	+ }
99	+
100	+ #primopiano_big .jcarousel-next {
101	+ z-index: 3; position: absolute; width:22px; bottom:180px; display: block; background: url(../../images/slider/next.png) no-repeat; height:66px; cursor: pointer; right:0px
102	+ }
103	+ #primopiano_big .jcarousel-prev {
104	+ z-index: 3; position: absolute; width:21px; bottom:180px; display: block; background:url(../../images/slider/prev.png) no-repeat; height:66px; cursor: pointer; left:0px
105	+ }

skin/frontend/default/default/images/slider/Thumbs.db ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/b_next.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/b_prev.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/bannerscrollbg.gif ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/bluehbg.gif ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/carousel_next.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/carousel_prev.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/content_bg.jpg ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/next.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/next_arrow.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/num-act.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/num.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/prev.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/prev_arrow.png ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/primopiano_menu.gif ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/primopiano_menu2.gif ADDED Viewed

Binary file

skin/frontend/default/default/images/slider/scroolbg.gif ADDED Viewed

Binary file

skin/frontend/default/default/js/slider/jquery-1.6.4.min.js ADDED Viewed

	@@ -0,0 +1,9049 @@


1	+ /*!
2	+ * jQuery JavaScript Library v1.6.4
3	+ * http://jquery.com/
4	+ *
5	+ * Copyright 2011, John Resig
6	+ * Dual licensed under the MIT or GPL Version 2 licenses.
7	+ * http://jquery.org/license
8	+ *
9	+ * Includes Sizzle.js
10	+ * http://sizzlejs.com/
11	+ * Copyright 2011, The Dojo Foundation
12	+ * Released under the MIT, BSD, and GPL Licenses.
13	+ *
14	+ * Date: Mon Sep 12 18:54:48 2011 -0400
15	+ */
16	+ (function( window, undefined ) {
17	+
18	+ // Use the correct document accordingly with window argument (sandbox)
19	+ var document = window.document,
20	+ navigator = window.navigator,
21	+ location = window.location;
22	+ var jQuery = (function() {
23	+
24	+ // Define a local copy of jQuery
25	+ var jQuery = function( selector, context ) {
26	+ // The jQuery object is actually just the init constructor 'enhanced'
27	+ return new jQuery.fn.init( selector, context, rootjQuery );
28	+ },
29	+
30	+ // Map over jQuery in case of overwrite
31	+ _jQuery = window.jQuery,
32	+
33	+ // Map over the $ in case of overwrite
34	+ _$ = window.$,
35	+
36	+ // A central reference to the root jQuery(document)
37	+ rootjQuery,
38	+
39	+ // A simple way to check for HTML strings or ID strings
40	+ // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
41	+ quickExpr = /^(?:[^#<](<[\w\W]+>)[^>]$\|#([\w\-]*)$)/,
42	+
43	+ // Check if a string has a non-whitespace character in it
44	+ rnotwhite = /\S/,
45	+
46	+ // Used for trimming whitespace
47	+ trimLeft = /^\s+/,
48	+ trimRight = /\s+$/,
49	+
50	+ // Check for digits
51	+ rdigit = /\d/,
52	+
53	+ // Match a standalone tag
54	+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
55	+
56	+ // JSON RegExp
57	+ rvalidchars = /^[\],:{}\s]*$/,
58	+ rvalidescape = /\\(?:["\\\/bfnrt]\|u[0-9a-fA-F]{4})/g,
59	+ rvalidtokens = /"[^"\\\n\r]"\|true\|false\|null\|-?\d+(?:\.\d)?(?:[eE][+\-]?\d+)?/g,
60	+ rvalidbraces = /(?:^\|:\|,)(?:\s*\[)+/g,
61	+
62	+ // Useragent RegExp
63	+ rwebkit = /(webkit)[ \/]([\w.]+)/,
64	+ ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
65	+ rmsie = /(msie) ([\w.]+)/,
66	+ rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
67	+
68	+ // Matches dashed string for camelizing
69	+ rdashAlpha = /-([a-z]\|[0-9])/ig,
70	+ rmsPrefix = /^-ms-/,
71	+
72	+ // Used by jQuery.camelCase as callback to replace()
73	+ fcamelCase = function( all, letter ) {
74	+ return ( letter + "" ).toUpperCase();
75	+ },
76	+
77	+ // Keep a UserAgent string for use with jQuery.browser
78	+ userAgent = navigator.userAgent,
79	+
80	+ // For matching the engine and version of the browser
81	+ browserMatch,
82	+
83	+ // The deferred used on DOM ready
84	+ readyList,
85	+
86	+ // The ready event handler
87	+ DOMContentLoaded,
88	+
89	+ // Save a reference to some core methods
90	+ toString = Object.prototype.toString,
91	+ hasOwn = Object.prototype.hasOwnProperty,
92	+ push = Array.prototype.push,
93	+ slice = Array.prototype.slice,
94	+ trim = String.prototype.trim,
95	+ indexOf = Array.prototype.indexOf,
96	+
97	+ // [[Class]] -> type pairs
98	+ class2type = {};
99	+
100	+ jQuery.fn = jQuery.prototype = {
101	+ constructor: jQuery,
102	+ init: function( selector, context, rootjQuery ) {
103	+ var match, elem, ret, doc;
104	+
105	+ // Handle $(""), $(null), or $(undefined)
106	+ if ( !selector ) {
107	+ return this;
108	+ }
109	+
110	+ // Handle $(DOMElement)
111	+ if ( selector.nodeType ) {
112	+ this.context = this[0] = selector;
113	+ this.length = 1;
114	+ return this;
115	+ }
116	+
117	+ // The body element only exists once, optimize finding it
118	+ if ( selector === "body" && !context && document.body ) {
119	+ this.context = document;
120	+ this[0] = document.body;
121	+ this.selector = selector;
122	+ this.length = 1;
123	+ return this;
124	+ }
125	+
126	+ // Handle HTML strings
127	+ if ( typeof selector === "string" ) {
128	+ // Are we dealing with HTML string or an ID?
129	+ if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
130	+ // Assume that strings that start and end with <> are HTML and skip the regex check
131	+ match = [ null, selector, null ];
132	+
133	+ } else {
134	+ match = quickExpr.exec( selector );
135	+ }
136	+
137	+ // Verify a match, and that no context was specified for #id
138	+ if ( match && (match[1] \|\| !context) ) {
139	+
140	+ // HANDLE: $(html) -> $(array)
141	+ if ( match[1] ) {
142	+ context = context instanceof jQuery ? context[0] : context;
143	+ doc = (context ? context.ownerDocument \|\| context : document);
144	+
145	+ // If a single string is passed in and it's a single tag
146	+ // just do a createElement and skip the rest
147	+ ret = rsingleTag.exec( selector );
148	+
149	+ if ( ret ) {
150	+ if ( jQuery.isPlainObject( context ) ) {
151	+ selector = [ document.createElement( ret[1] ) ];
152	+ jQuery.fn.attr.call( selector, context, true );
153	+
154	+ } else {
155	+ selector = [ doc.createElement( ret[1] ) ];
156	+ }
157	+
158	+ } else {
159	+ ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
160	+ selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
161	+ }
162	+
163	+ return jQuery.merge( this, selector );
164	+
165	+ // HANDLE: $("#id")
166	+ } else {
167	+ elem = document.getElementById( match[2] );
168	+
169	+ // Check parentNode to catch when Blackberry 4.6 returns
170	+ // nodes that are no longer in the document #6963
171	+ if ( elem && elem.parentNode ) {
172	+ // Handle the case where IE and Opera return items
173	+ // by name instead of ID
174	+ if ( elem.id !== match[2] ) {
175	+ return rootjQuery.find( selector );
176	+ }
177	+
178	+ // Otherwise, we inject the element directly into the jQuery object
179	+ this.length = 1;
180	+ this[0] = elem;
181	+ }
182	+
183	+ this.context = document;
184	+ this.selector = selector;
185	+ return this;
186	+ }
187	+
188	+ // HANDLE: $(expr, $(...))
189	+ } else if ( !context \|\| context.jquery ) {
190	+ return (context \|\| rootjQuery).find( selector );
191	+
192	+ // HANDLE: $(expr, context)
193	+ // (which is just equivalent to: $(context).find(expr)
194	+ } else {
195	+ return this.constructor( context ).find( selector );
196	+ }
197	+
198	+ // HANDLE: $(function)
199	+ // Shortcut for document ready
200	+ } else if ( jQuery.isFunction( selector ) ) {
201	+ return rootjQuery.ready( selector );
202	+ }
203	+
204	+ if (selector.selector !== undefined) {
205	+ this.selector = selector.selector;
206	+ this.context = selector.context;
207	+ }
208	+
209	+ return jQuery.makeArray( selector, this );
210	+ },
211	+
212	+ // Start with an empty selector
213	+ selector: "",
214	+
215	+ // The current version of jQuery being used
216	+ jquery: "1.6.4",
217	+
218	+ // The default length of a jQuery object is 0
219	+ length: 0,
220	+
221	+ // The number of elements contained in the matched element set
222	+ size: function() {
223	+ return this.length;
224	+ },
225	+
226	+ toArray: function() {
227	+ return slice.call( this, 0 );
228	+ },
229	+
230	+ // Get the Nth element in the matched element set OR
231	+ // Get the whole matched element set as a clean array
232	+ get: function( num ) {
233	+ return num == null ?
234	+
235	+ // Return a 'clean' array
236	+ this.toArray() :
237	+
238	+ // Return just the object
239	+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
240	+ },
241	+
242	+ // Take an array of elements and push it onto the stack
243	+ // (returning the new matched element set)
244	+ pushStack: function( elems, name, selector ) {
245	+ // Build a new jQuery matched element set
246	+ var ret = this.constructor();
247	+
248	+ if ( jQuery.isArray( elems ) ) {
249	+ push.apply( ret, elems );
250	+
251	+ } else {
252	+ jQuery.merge( ret, elems );
253	+ }
254	+
255	+ // Add the old object onto the stack (as a reference)
256	+ ret.prevObject = this;
257	+
258	+ ret.context = this.context;
259	+
260	+ if ( name === "find" ) {
261	+ ret.selector = this.selector + (this.selector ? " " : "") + selector;
262	+ } else if ( name ) {
263	+ ret.selector = this.selector + "." + name + "(" + selector + ")";
264	+ }
265	+
266	+ // Return the newly-formed element set
267	+ return ret;
268	+ },
269	+
270	+ // Execute a callback for every element in the matched set.
271	+ // (You can seed the arguments with an array of args, but this is
272	+ // only used internally.)
273	+ each: function( callback, args ) {
274	+ return jQuery.each( this, callback, args );
275	+ },
276	+
277	+ ready: function( fn ) {
278	+ // Attach the listeners
279	+ jQuery.bindReady();
280	+
281	+ // Add the callback
282	+ readyList.done( fn );
283	+
284	+ return this;
285	+ },
286	+
287	+ eq: function( i ) {
288	+ return i === -1 ?
289	+ this.slice( i ) :
290	+ this.slice( i, +i + 1 );
291	+ },
292	+
293	+ first: function() {
294	+ return this.eq( 0 );
295	+ },
296	+
297	+ last: function() {
298	+ return this.eq( -1 );
299	+ },
300	+
301	+ slice: function() {
302	+ return this.pushStack( slice.apply( this, arguments ),
303	+ "slice", slice.call(arguments).join(",") );
304	+ },
305	+
306	+ map: function( callback ) {
307	+ return this.pushStack( jQuery.map(this, function( elem, i ) {
308	+ return callback.call( elem, i, elem );
309	+ }));
310	+ },
311	+
312	+ end: function() {
313	+ return this.prevObject \|\| this.constructor(null);
314	+ },
315	+
316	+ // For internal use only.
317	+ // Behaves like an Array's method, not like a jQuery method.
318	+ push: push,
319	+ sort: [].sort,
320	+ splice: [].splice
321	+ };
322	+
323	+ // Give the init function the jQuery prototype for later instantiation
324	+ jQuery.fn.init.prototype = jQuery.fn;
325	+
326	+ jQuery.extend = jQuery.fn.extend = function() {
327	+ var options, name, src, copy, copyIsArray, clone,
328	+ target = arguments[0] \|\| {},
329	+ i = 1,
330	+ length = arguments.length,
331	+ deep = false;
332	+
333	+ // Handle a deep copy situation
334	+ if ( typeof target === "boolean" ) {
335	+ deep = target;
336	+ target = arguments[1] \|\| {};
337	+ // skip the boolean and the target
338	+ i = 2;
339	+ }
340	+
341	+ // Handle case when target is a string or something (possible in deep copy)
342	+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
343	+ target = {};
344	+ }
345	+
346	+ // extend jQuery itself if only one argument is passed
347	+ if ( length === i ) {
348	+ target = this;
349	+ --i;
350	+ }
351	+
352	+ for ( ; i < length; i++ ) {
353	+ // Only deal with non-null/undefined values
354	+ if ( (options = arguments[ i ]) != null ) {
355	+ // Extend the base object
356	+ for ( name in options ) {
357	+ src = target[ name ];
358	+ copy = options[ name ];
359	+
360	+ // Prevent never-ending loop
361	+ if ( target === copy ) {
362	+ continue;
363	+ }
364	+
365	+ // Recurse if we're merging plain objects or arrays
366	+ if ( deep && copy && ( jQuery.isPlainObject(copy) \|\| (copyIsArray = jQuery.isArray(copy)) ) ) {
367	+ if ( copyIsArray ) {
368	+ copyIsArray = false;
369	+ clone = src && jQuery.isArray(src) ? src : [];
370	+
371	+ } else {
372	+ clone = src && jQuery.isPlainObject(src) ? src : {};
373	+ }
374	+
375	+ // Never move original objects, clone them
376	+ target[ name ] = jQuery.extend( deep, clone, copy );
377	+
378	+ // Don't bring in undefined values
379	+ } else if ( copy !== undefined ) {
380	+ target[ name ] = copy;
381	+ }
382	+ }
383	+ }
384	+ }
385	+
386	+ // Return the modified object
387	+ return target;
388	+ };
389	+
390	+ jQuery.extend({
391	+ noConflict: function( deep ) {
392	+ if ( window.$ === jQuery ) {
393	+ window.$ = _$;
394	+ }
395	+
396	+ if ( deep && window.jQuery === jQuery ) {
397	+ window.jQuery = _jQuery;
398	+ }
399	+
400	+ return jQuery;
401	+ },
402	+
403	+ // Is the DOM ready to be used? Set to true once it occurs.
404	+ isReady: false,
405	+
406	+ // A counter to track how many items to wait for before
407	+ // the ready event fires. See #6781
408	+ readyWait: 1,
409	+
410	+ // Hold (or release) the ready event
411	+ holdReady: function( hold ) {
412	+ if ( hold ) {
413	+ jQuery.readyWait++;
414	+ } else {
415	+ jQuery.ready( true );
416	+ }
417	+ },
418	+
419	+ // Handle when the DOM is ready
420	+ ready: function( wait ) {
421	+ // Either a released hold or an DOMready/load event and not yet ready
422	+ if ( (wait === true && !--jQuery.readyWait) \|\| (wait !== true && !jQuery.isReady) ) {
423	+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
424	+ if ( !document.body ) {
425	+ return setTimeout( jQuery.ready, 1 );
426	+ }
427	+
428	+ // Remember that the DOM is ready
429	+ jQuery.isReady = true;
430	+
431	+ // If a normal DOM Ready event fired, decrement, and wait if need be
432	+ if ( wait !== true && --jQuery.readyWait > 0 ) {
433	+ return;
434	+ }
435	+
436	+ // If there are functions bound, to execute
437	+ readyList.resolveWith( document, [ jQuery ] );
438	+
439	+ // Trigger any bound ready events
440	+ if ( jQuery.fn.trigger ) {
441	+ jQuery( document ).trigger( "ready" ).unbind( "ready" );
442	+ }
443	+ }
444	+ },
445	+
446	+ bindReady: function() {
447	+ if ( readyList ) {
448	+ return;
449	+ }
450	+
451	+ readyList = jQuery._Deferred();
452	+
453	+ // Catch cases where $(document).ready() is called after the
454	+ // browser event has already occurred.
455	+ if ( document.readyState === "complete" ) {
456	+ // Handle it asynchronously to allow scripts the opportunity to delay ready
457	+ return setTimeout( jQuery.ready, 1 );
458	+ }
459	+
460	+ // Mozilla, Opera and webkit nightlies currently support this event
461	+ if ( document.addEventListener ) {
462	+ // Use the handy event callback
463	+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
464	+
465	+ // A fallback to window.onload, that will always work
466	+ window.addEventListener( "load", jQuery.ready, false );
467	+
468	+ // If IE event model is used
469	+ } else if ( document.attachEvent ) {
470	+ // ensure firing before onload,
471	+ // maybe late but safe also for iframes
472	+ document.attachEvent( "onreadystatechange", DOMContentLoaded );
473	+
474	+ // A fallback to window.onload, that will always work
475	+ window.attachEvent( "onload", jQuery.ready );
476	+
477	+ // If IE and not a frame
478	+ // continually check to see if the document is ready
479	+ var toplevel = false;
480	+
481	+ try {
482	+ toplevel = window.frameElement == null;
483	+ } catch(e) {}
484	+
485	+ if ( document.documentElement.doScroll && toplevel ) {
486	+ doScrollCheck();
487	+ }
488	+ }
489	+ },
490	+
491	+ // See test/unit/core.js for details concerning isFunction.
492	+ // Since version 1.3, DOM methods and functions like alert
493	+ // aren't supported. They return false on IE (#2968).
494	+ isFunction: function( obj ) {
495	+ return jQuery.type(obj) === "function";
496	+ },
497	+
498	+ isArray: Array.isArray \|\| function( obj ) {
499	+ return jQuery.type(obj) === "array";
500	+ },
501	+
502	+ // A crude way of determining if an object is a window
503	+ isWindow: function( obj ) {
504	+ return obj && typeof obj === "object" && "setInterval" in obj;
505	+ },
506	+
507	+ isNaN: function( obj ) {
508	+ return obj == null \|\| !rdigit.test( obj ) \|\| isNaN( obj );
509	+ },
510	+
511	+ type: function( obj ) {
512	+ return obj == null ?
513	+ String( obj ) :
514	+ class2type[ toString.call(obj) ] \|\| "object";
515	+ },
516	+
517	+ isPlainObject: function( obj ) {
518	+ // Must be an Object.
519	+ // Because of IE, we also have to check the presence of the constructor property.
520	+ // Make sure that DOM nodes and window objects don't pass through, as well
521	+ if ( !obj \|\| jQuery.type(obj) !== "object" \|\| obj.nodeType \|\| jQuery.isWindow( obj ) ) {
522	+ return false;
523	+ }
524	+
525	+ try {
526	+ // Not own constructor property must be Object
527	+ if ( obj.constructor &&
528	+ !hasOwn.call(obj, "constructor") &&
529	+ !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
530	+ return false;
531	+ }
532	+ } catch ( e ) {
533	+ // IE8,9 Will throw exceptions on certain host objects #9897
534	+ return false;
535	+ }
536	+
537	+ // Own properties are enumerated firstly, so to speed up,
538	+ // if last one is own, then all properties are own.
539	+
540	+ var key;
541	+ for ( key in obj ) {}
542	+
543	+ return key === undefined \|\| hasOwn.call( obj, key );
544	+ },
545	+
546	+ isEmptyObject: function( obj ) {
547	+ for ( var name in obj ) {
548	+ return false;
549	+ }
550	+ return true;
551	+ },
552	+
553	+ error: function( msg ) {
554	+ throw msg;
555	+ },
556	+
557	+ parseJSON: function( data ) {
558	+ if ( typeof data !== "string" \|\| !data ) {
559	+ return null;
560	+ }
561	+
562	+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
563	+ data = jQuery.trim( data );
564	+
565	+ // Attempt to parse using the native JSON parser first
566	+ if ( window.JSON && window.JSON.parse ) {
567	+ return window.JSON.parse( data );
568	+ }
569	+
570	+ // Make sure the incoming data is actual JSON
571	+ // Logic borrowed from http://json.org/json2.js
572	+ if ( rvalidchars.test( data.replace( rvalidescape, "@" )
573	+ .replace( rvalidtokens, "]" )
574	+ .replace( rvalidbraces, "")) ) {
575	+
576	+ return (new Function( "return " + data ))();
577	+
578	+ }
579	+ jQuery.error( "Invalid JSON: " + data );
580	+ },
581	+
582	+ // Cross-browser xml parsing
583	+ parseXML: function( data ) {
584	+ var xml, tmp;
585	+ try {
586	+ if ( window.DOMParser ) { // Standard
587	+ tmp = new DOMParser();
588	+ xml = tmp.parseFromString( data , "text/xml" );
589	+ } else { // IE
590	+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
591	+ xml.async = "false";
592	+ xml.loadXML( data );
593	+ }
594	+ } catch( e ) {
595	+ xml = undefined;
596	+ }
597	+ if ( !xml \|\| !xml.documentElement \|\| xml.getElementsByTagName( "parsererror" ).length ) {
598	+ jQuery.error( "Invalid XML: " + data );
599	+ }
600	+ return xml;
601	+ },
602	+
603	+ noop: function() {},
604	+
605	+ // Evaluates a script in a global context
606	+ // Workarounds based on findings by Jim Driscoll
607	+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
608	+ globalEval: function( data ) {
609	+ if ( data && rnotwhite.test( data ) ) {
610	+ // We use execScript on Internet Explorer
611	+ // We use an anonymous function so that context is window
612	+ // rather than jQuery in Firefox
613	+ ( window.execScript \|\| function( data ) {
614	+ window[ "eval" ].call( window, data );
615	+ } )( data );
616	+ }
617	+ },
618	+
619	+ // Convert dashed to camelCase; used by the css and data modules
620	+ // Microsoft forgot to hump their vendor prefix (#9572)
621	+ camelCase: function( string ) {
622	+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
623	+ },
624	+
625	+ nodeName: function( elem, name ) {
626	+ return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
627	+ },
628	+
629	+ // args is for internal usage only
630	+ each: function( object, callback, args ) {
631	+ var name, i = 0,
632	+ length = object.length,
633	+ isObj = length === undefined \|\| jQuery.isFunction( object );
634	+
635	+ if ( args ) {
636	+ if ( isObj ) {
637	+ for ( name in object ) {
638	+ if ( callback.apply( object[ name ], args ) === false ) {
639	+ break;
640	+ }
641	+ }
642	+ } else {
643	+ for ( ; i < length; ) {
644	+ if ( callback.apply( object[ i++ ], args ) === false ) {
645	+ break;
646	+ }
647	+ }
648	+ }
649	+
650	+ // A special, fast, case for the most common use of each
651	+ } else {
652	+ if ( isObj ) {
653	+ for ( name in object ) {
654	+ if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
655	+ break;
656	+ }
657	+ }
658	+ } else {
659	+ for ( ; i < length; ) {
660	+ if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
661	+ break;
662	+ }
663	+ }
664	+ }
665	+ }
666	+
667	+ return object;
668	+ },
669	+
670	+ // Use native String.trim function wherever possible
671	+ trim: trim ?
672	+ function( text ) {
673	+ return text == null ?
674	+ "" :
675	+ trim.call( text );
676	+ } :
677	+
678	+ // Otherwise use our own trimming functionality
679	+ function( text ) {
680	+ return text == null ?
681	+ "" :
682	+ text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
683	+ },
684	+
685	+ // results is for internal usage only
686	+ makeArray: function( array, results ) {
687	+ var ret = results \|\| [];
688	+
689	+ if ( array != null ) {
690	+ // The window, strings (and functions) also have 'length'
691	+ // The extra typeof function check is to prevent crashes
692	+ // in Safari 2 (See: #3039)
693	+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
694	+ var type = jQuery.type( array );
695	+
696	+ if ( array.length == null \|\| type === "string" \|\| type === "function" \|\| type === "regexp" \|\| jQuery.isWindow( array ) ) {
697	+ push.call( ret, array );
698	+ } else {
699	+ jQuery.merge( ret, array );
700	+ }
701	+ }
702	+
703	+ return ret;
704	+ },
705	+
706	+ inArray: function( elem, array ) {
707	+ if ( !array ) {
708	+ return -1;
709	+ }
710	+
711	+ if ( indexOf ) {
712	+ return indexOf.call( array, elem );
713	+ }
714	+
715	+ for ( var i = 0, length = array.length; i < length; i++ ) {
716	+ if ( array[ i ] === elem ) {
717	+ return i;
718	+ }
719	+ }
720	+
721	+ return -1;
722	+ },
723	+
724	+ merge: function( first, second ) {
725	+ var i = first.length,
726	+ j = 0;
727	+
728	+ if ( typeof second.length === "number" ) {
729	+ for ( var l = second.length; j < l; j++ ) {
730	+ first[ i++ ] = second[ j ];
731	+ }
732	+
733	+ } else {
734	+ while ( second[j] !== undefined ) {
735	+ first[ i++ ] = second[ j++ ];
736	+ }
737	+ }
738	+
739	+ first.length = i;
740	+
741	+ return first;
742	+ },
743	+
744	+ grep: function( elems, callback, inv ) {
745	+ var ret = [], retVal;
746	+ inv = !!inv;
747	+
748	+ // Go through the array, only saving the items
749	+ // that pass the validator function
750	+ for ( var i = 0, length = elems.length; i < length; i++ ) {
751	+ retVal = !!callback( elems[ i ], i );
752	+ if ( inv !== retVal ) {
753	+ ret.push( elems[ i ] );
754	+ }
755	+ }
756	+
757	+ return ret;
758	+ },
759	+
760	+ // arg is for internal usage only
761	+ map: function( elems, callback, arg ) {
762	+ var value, key, ret = [],
763	+ i = 0,
764	+ length = elems.length,
765	+ // jquery objects are treated as arrays
766	+ isArray = elems instanceof jQuery \|\| length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) \|\| length === 0 \|\| jQuery.isArray( elems ) ) ;
767	+
768	+ // Go through the array, translating each of the items to their
769	+ if ( isArray ) {
770	+ for ( ; i < length; i++ ) {
771	+ value = callback( elems[ i ], i, arg );
772	+
773	+ if ( value != null ) {
774	+ ret[ ret.length ] = value;
775	+ }
776	+ }
777	+
778	+ // Go through every key on the object,
779	+ } else {
780	+ for ( key in elems ) {
781	+ value = callback( elems[ key ], key, arg );
782	+
783	+ if ( value != null ) {
784	+ ret[ ret.length ] = value;
785	+ }
786	+ }
787	+ }
788	+
789	+ // Flatten any nested arrays
790	+ return ret.concat.apply( [], ret );
791	+ },
792	+
793	+ // A global GUID counter for objects
794	+ guid: 1,
795	+
796	+ // Bind a function to a context, optionally partially applying any
797	+ // arguments.
798	+ proxy: function( fn, context ) {
799	+ if ( typeof context === "string" ) {
800	+ var tmp = fn[ context ];
801	+ context = fn;
802	+ fn = tmp;
803	+ }
804	+
805	+ // Quick check to determine if target is callable, in the spec
806	+ // this throws a TypeError, but we will just return undefined.
807	+ if ( !jQuery.isFunction( fn ) ) {
808	+ return undefined;
809	+ }
810	+
811	+ // Simulated bind
812	+ var args = slice.call( arguments, 2 ),
813	+ proxy = function() {
814	+ return fn.apply( context, args.concat( slice.call( arguments ) ) );
815	+ };
816	+
817	+ // Set the guid of unique handler to the same of original handler, so it can be removed
818	+ proxy.guid = fn.guid = fn.guid \|\| proxy.guid \|\| jQuery.guid++;
819	+
820	+ return proxy;
821	+ },
822	+
823	+ // Mutifunctional method to get and set values to a collection
824	+ // The value/s can optionally be executed if it's a function
825	+ access: function( elems, key, value, exec, fn, pass ) {
826	+ var length = elems.length;
827	+
828	+ // Setting many attributes
829	+ if ( typeof key === "object" ) {
830	+ for ( var k in key ) {
831	+ jQuery.access( elems, k, key[k], exec, fn, value );
832	+ }
833	+ return elems;
834	+ }
835	+
836	+ // Setting one attribute
837	+ if ( value !== undefined ) {
838	+ // Optionally, function values get executed if exec is true
839	+ exec = !pass && exec && jQuery.isFunction(value);
840	+
841	+ for ( var i = 0; i < length; i++ ) {
842	+ fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
843	+ }
844	+
845	+ return elems;
846	+ }
847	+
848	+ // Getting an attribute
849	+ return length ? fn( elems[0], key ) : undefined;
850	+ },
851	+
852	+ now: function() {
853	+ return (new Date()).getTime();
854	+ },
855	+
856	+ // Use of jQuery.browser is frowned upon.
857	+ // More details: http://docs.jquery.com/Utilities/jQuery.browser
858	+ uaMatch: function( ua ) {
859	+ ua = ua.toLowerCase();
860	+
861	+ var match = rwebkit.exec( ua ) \|\|
862	+ ropera.exec( ua ) \|\|
863	+ rmsie.exec( ua ) \|\|
864	+ ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) \|\|
865	+ [];
866	+
867	+ return { browser: match[1] \|\| "", version: match[2] \|\| "0" };
868	+ },
869	+
870	+ sub: function() {
871	+ function jQuerySub( selector, context ) {
872	+ return new jQuerySub.fn.init( selector, context );
873	+ }
874	+ jQuery.extend( true, jQuerySub, this );
875	+ jQuerySub.superclass = this;
876	+ jQuerySub.fn = jQuerySub.prototype = this();
877	+ jQuerySub.fn.constructor = jQuerySub;
878	+ jQuerySub.sub = this.sub;
879	+ jQuerySub.fn.init = function init( selector, context ) {
880	+ if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
881	+ context = jQuerySub( context );
882	+ }
883	+
884	+ return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
885	+ };
886	+ jQuerySub.fn.init.prototype = jQuerySub.fn;
887	+ var rootjQuerySub = jQuerySub(document);
888	+ return jQuerySub;
889	+ },
890	+
891	+ browser: {}
892	+ });
893	+
894	+ // Populate the class2type map
895	+ jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
896	+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
897	+ });
898	+
899	+ browserMatch = jQuery.uaMatch( userAgent );
900	+ if ( browserMatch.browser ) {
901	+ jQuery.browser[ browserMatch.browser ] = true;
902	+ jQuery.browser.version = browserMatch.version;
903	+ }
904	+
905	+ // Deprecated, use jQuery.browser.webkit instead
906	+ if ( jQuery.browser.webkit ) {
907	+ jQuery.browser.safari = true;
908	+ }
909	+
910	+ // IE doesn't match non-breaking spaces with \s
911	+ if ( rnotwhite.test( "\xA0" ) ) {
912	+ trimLeft = /^[\s\xA0]+/;
913	+ trimRight = /[\s\xA0]+$/;
914	+ }
915	+
916	+ // All jQuery objects should point back to these
917	+ rootjQuery = jQuery(document);
918	+
919	+ // Cleanup functions for the document ready method
920	+ if ( document.addEventListener ) {
921	+ DOMContentLoaded = function() {
922	+ document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
923	+ jQuery.ready();
924	+ };
925	+
926	+ } else if ( document.attachEvent ) {
927	+ DOMContentLoaded = function() {
928	+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
929	+ if ( document.readyState === "complete" ) {
930	+ document.detachEvent( "onreadystatechange", DOMContentLoaded );
931	+ jQuery.ready();
932	+ }
933	+ };
934	+ }
935	+
936	+ // The DOM ready check for Internet Explorer
937	+ function doScrollCheck() {
938	+ if ( jQuery.isReady ) {
939	+ return;
940	+ }
941	+
942	+ try {
943	+ // If IE is used, use the trick by Diego Perini
944	+ // http://javascript.nwbox.com/IEContentLoaded/
945	+ document.documentElement.doScroll("left");
946	+ } catch(e) {
947	+ setTimeout( doScrollCheck, 1 );
948	+ return;
949	+ }
950	+
951	+ // and execute any waiting functions
952	+ jQuery.ready();
953	+ }
954	+
955	+ return jQuery;
956	+
957	+ })();
958	+
959	+
960	+ var // Promise methods
961	+ promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
962	+ // Static reference to slice
963	+ sliceDeferred = [].slice;
964	+
965	+ jQuery.extend({
966	+ // Create a simple deferred (one callbacks list)
967	+ _Deferred: function() {
968	+ var // callbacks list
969	+ callbacks = [],
970	+ // stored [ context , args ]
971	+ fired,
972	+ // to avoid firing when already doing so
973	+ firing,
974	+ // flag to know if the deferred has been cancelled
975	+ cancelled,
976	+ // the deferred itself
977	+ deferred = {
978	+
979	+ // done( f1, f2, ...)
980	+ done: function() {
981	+ if ( !cancelled ) {
982	+ var args = arguments,
983	+ i,
984	+ length,
985	+ elem,
986	+ type,
987	+ _fired;
988	+ if ( fired ) {
989	+ _fired = fired;
990	+ fired = 0;
991	+ }
992	+ for ( i = 0, length = args.length; i < length; i++ ) {
993	+ elem = args[ i ];
994	+ type = jQuery.type( elem );
995	+ if ( type === "array" ) {
996	+ deferred.done.apply( deferred, elem );
997	+ } else if ( type === "function" ) {
998	+ callbacks.push( elem );
999	+ }
1000	+ }
1001	+ if ( _fired ) {
1002	+ deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
1003	+ }
1004	+ }
1005	+ return this;
1006	+ },
1007	+
1008	+ // resolve with given context and args
1009	+ resolveWith: function( context, args ) {
1010	+ if ( !cancelled && !fired && !firing ) {
1011	+ // make sure args are available (#8421)
1012	+ args = args \|\| [];
1013	+ firing = 1;
1014	+ try {
1015	+ while( callbacks[ 0 ] ) {
1016	+ callbacks.shift().apply( context, args );
1017	+ }
1018	+ }
1019	+ finally {
1020	+ fired = [ context, args ];
1021	+ firing = 0;
1022	+ }
1023	+ }
1024	+ return this;
1025	+ },
1026	+
1027	+ // resolve with this as context and given arguments
1028	+ resolve: function() {
1029	+ deferred.resolveWith( this, arguments );
1030	+ return this;
1031	+ },
1032	+
1033	+ // Has this deferred been resolved?
1034	+ isResolved: function() {
1035	+ return !!( firing \|\| fired );
1036	+ },
1037	+
1038	+ // Cancel
1039	+ cancel: function() {
1040	+ cancelled = 1;
1041	+ callbacks = [];
1042	+ return this;
1043	+ }
1044	+ };
1045	+
1046	+ return deferred;
1047	+ },
1048	+
1049	+ // Full fledged deferred (two callbacks list)
1050	+ Deferred: function( func ) {
1051	+ var deferred = jQuery._Deferred(),
1052	+ failDeferred = jQuery._Deferred(),
1053	+ promise;
1054	+ // Add errorDeferred methods, then and promise
1055	+ jQuery.extend( deferred, {
1056	+ then: function( doneCallbacks, failCallbacks ) {
1057	+ deferred.done( doneCallbacks ).fail( failCallbacks );
1058	+ return this;
1059	+ },
1060	+ always: function() {
1061	+ return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1062	+ },
1063	+ fail: failDeferred.done,
1064	+ rejectWith: failDeferred.resolveWith,
1065	+ reject: failDeferred.resolve,
1066	+ isRejected: failDeferred.isResolved,
1067	+ pipe: function( fnDone, fnFail ) {
1068	+ return jQuery.Deferred(function( newDefer ) {
1069	+ jQuery.each( {
1070	+ done: [ fnDone, "resolve" ],
1071	+ fail: [ fnFail, "reject" ]
1072	+ }, function( handler, data ) {
1073	+ var fn = data[ 0 ],
1074	+ action = data[ 1 ],
1075	+ returned;
1076	+ if ( jQuery.isFunction( fn ) ) {
1077	+ deferred[ handler ](function() {
1078	+ returned = fn.apply( this, arguments );
1079	+ if ( returned && jQuery.isFunction( returned.promise ) ) {
1080	+ returned.promise().then( newDefer.resolve, newDefer.reject );
1081	+ } else {
1082	+ newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1083	+ }
1084	+ });
1085	+ } else {
1086	+ deferred[ handler ]( newDefer[ action ] );
1087	+ }
1088	+ });
1089	+ }).promise();
1090	+ },
1091	+ // Get a promise for this deferred
1092	+ // If obj is provided, the promise aspect is added to the object
1093	+ promise: function( obj ) {
1094	+ if ( obj == null ) {
1095	+ if ( promise ) {
1096	+ return promise;
1097	+ }
1098	+ promise = obj = {};
1099	+ }
1100	+ var i = promiseMethods.length;
1101	+ while( i-- ) {
1102	+ obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1103	+ }
1104	+ return obj;
1105	+ }
1106	+ });
1107	+ // Make sure only one callback list will be used
1108	+ deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1109	+ // Unexpose cancel
1110	+ delete deferred.cancel;
1111	+ // Call given func if any
1112	+ if ( func ) {
1113	+ func.call( deferred, deferred );
1114	+ }
1115	+ return deferred;
1116	+ },
1117	+
1118	+ // Deferred helper
1119	+ when: function( firstParam ) {
1120	+ var args = arguments,
1121	+ i = 0,
1122	+ length = args.length,
1123	+ count = length,
1124	+ deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1125	+ firstParam :
1126	+ jQuery.Deferred();
1127	+ function resolveFunc( i ) {
1128	+ return function( value ) {
1129	+ args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1130	+ if ( !( --count ) ) {
1131	+ // Strange bug in FF4:
1132	+ // Values changed onto the arguments object sometimes end up as undefined values
1133	+ // outside the $.when method. Cloning the object into a fresh array solves the issue
1134	+ deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1135	+ }
1136	+ };
1137	+ }
1138	+ if ( length > 1 ) {
1139	+ for( ; i < length; i++ ) {
1140	+ if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1141	+ args[ i ].promise().then( resolveFunc(i), deferred.reject );
1142	+ } else {
1143	+ --count;
1144	+ }
1145	+ }
1146	+ if ( !count ) {
1147	+ deferred.resolveWith( deferred, args );
1148	+ }
1149	+ } else if ( deferred !== firstParam ) {
1150	+ deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1151	+ }
1152	+ return deferred.promise();
1153	+ }
1154	+ });
1155	+
1156	+
1157	+
1158	+ jQuery.support = (function() {
1159	+
1160	+ var div = document.createElement( "div" ),
1161	+ documentElement = document.documentElement,
1162	+ all,
1163	+ a,
1164	+ select,
1165	+ opt,
1166	+ input,
1167	+ marginDiv,
1168	+ support,
1169	+ fragment,
1170	+ body,
1171	+ testElementParent,
1172	+ testElement,
1173	+ testElementStyle,
1174	+ tds,
1175	+ events,
1176	+ eventName,
1177	+ i,
1178	+ isSupported;
1179	+
1180	+ // Preliminary tests
1181	+ div.setAttribute("className", "t");
1182	+ div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1183	+
1184	+
1185	+ all = div.getElementsByTagName( "*" );
1186	+ a = div.getElementsByTagName( "a" )[ 0 ];
1187	+
1188	+ // Can't get basic test support
1189	+ if ( !all \|\| !all.length \|\| !a ) {
1190	+ return {};
1191	+ }
1192	+
1193	+ // First batch of supports tests
1194	+ select = document.createElement( "select" );
1195	+ opt = select.appendChild( document.createElement("option") );
1196	+ input = div.getElementsByTagName( "input" )[ 0 ];
1197	+
1198	+ support = {
1199	+ // IE strips leading whitespace when .innerHTML is used
1200	+ leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1201	+
1202	+ // Make sure that tbody elements aren't automatically inserted
1203	+ // IE will insert them into empty tables
1204	+ tbody: !div.getElementsByTagName( "tbody" ).length,
1205	+
1206	+ // Make sure that link elements get serialized correctly by innerHTML
1207	+ // This requires a wrapper element in IE
1208	+ htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1209	+
1210	+ // Get the style information from getAttribute
1211	+ // (IE uses .cssText instead)
1212	+ style: /top/.test( a.getAttribute("style") ),
1213	+
1214	+ // Make sure that URLs aren't manipulated
1215	+ // (IE normalizes it by default)
1216	+ hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1217	+
1218	+ // Make sure that element opacity exists
1219	+ // (IE uses filter instead)
1220	+ // Use a regex to work around a WebKit issue. See #5145
1221	+ opacity: /^0.55$/.test( a.style.opacity ),
1222	+
1223	+ // Verify style float existence
1224	+ // (IE uses styleFloat instead of cssFloat)
1225	+ cssFloat: !!a.style.cssFloat,
1226	+
1227	+ // Make sure that if no value is specified for a checkbox
1228	+ // that it defaults to "on".
1229	+ // (WebKit defaults to "" instead)
1230	+ checkOn: ( input.value === "on" ),
1231	+
1232	+ // Make sure that a selected-by-default option has a working selected property.
1233	+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1234	+ optSelected: opt.selected,
1235	+
1236	+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1237	+ getSetAttribute: div.className !== "t",
1238	+
1239	+ // Will be defined later
1240	+ submitBubbles: true,
1241	+ changeBubbles: true,
1242	+ focusinBubbles: false,
1243	+ deleteExpando: true,
1244	+ noCloneEvent: true,
1245	+ inlineBlockNeedsLayout: false,
1246	+ shrinkWrapBlocks: false,
1247	+ reliableMarginRight: true
1248	+ };
1249	+
1250	+ // Make sure checked status is properly cloned
1251	+ input.checked = true;
1252	+ support.noCloneChecked = input.cloneNode( true ).checked;
1253	+
1254	+ // Make sure that the options inside disabled selects aren't marked as disabled
1255	+ // (WebKit marks them as disabled)
1256	+ select.disabled = true;
1257	+ support.optDisabled = !opt.disabled;
1258	+
1259	+ // Test to see if it's possible to delete an expando from an element
1260	+ // Fails in Internet Explorer
1261	+ try {
1262	+ delete div.test;
1263	+ } catch( e ) {
1264	+ support.deleteExpando = false;
1265	+ }
1266	+
1267	+ if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1268	+ div.attachEvent( "onclick", function() {
1269	+ // Cloning a node shouldn't copy over any
1270	+ // bound event handlers (IE does this)
1271	+ support.noCloneEvent = false;
1272	+ });
1273	+ div.cloneNode( true ).fireEvent( "onclick" );
1274	+ }
1275	+
1276	+ // Check if a radio maintains it's value
1277	+ // after being appended to the DOM
1278	+ input = document.createElement("input");
1279	+ input.value = "t";
1280	+ input.setAttribute("type", "radio");
1281	+ support.radioValue = input.value === "t";
1282	+
1283	+ input.setAttribute("checked", "checked");
1284	+ div.appendChild( input );
1285	+ fragment = document.createDocumentFragment();
1286	+ fragment.appendChild( div.firstChild );
1287	+
1288	+ // WebKit doesn't clone checked state correctly in fragments
1289	+ support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1290	+
1291	+ div.innerHTML = "";
1292	+
1293	+ // Figure out if the W3C box model works as expected
1294	+ div.style.width = div.style.paddingLeft = "1px";
1295	+
1296	+ body = document.getElementsByTagName( "body" )[ 0 ];
1297	+ // We use our own, invisible, body unless the body is already present
1298	+ // in which case we use a div (#9239)
1299	+ testElement = document.createElement( body ? "div" : "body" );
1300	+ testElementStyle = {
1301	+ visibility: "hidden",
1302	+ width: 0,
1303	+ height: 0,
1304	+ border: 0,
1305	+ margin: 0,
1306	+ background: "none"
1307	+ };
1308	+ if ( body ) {
1309	+ jQuery.extend( testElementStyle, {
1310	+ position: "absolute",
1311	+ left: "-1000px",
1312	+ top: "-1000px"
1313	+ });
1314	+ }
1315	+ for ( i in testElementStyle ) {
1316	+ testElement.style[ i ] = testElementStyle[ i ];
1317	+ }
1318	+ testElement.appendChild( div );
1319	+ testElementParent = body \|\| documentElement;
1320	+ testElementParent.insertBefore( testElement, testElementParent.firstChild );
1321	+
1322	+ // Check if a disconnected checkbox will retain its checked
1323	+ // value of true after appended to the DOM (IE6/7)
1324	+ support.appendChecked = input.checked;
1325	+
1326	+ support.boxModel = div.offsetWidth === 2;
1327	+
1328	+ if ( "zoom" in div.style ) {
1329	+ // Check if natively block-level elements act like inline-block
1330	+ // elements when setting their display to 'inline' and giving
1331	+ // them layout
1332	+ // (IE < 8 does this)
1333	+ div.style.display = "inline";
1334	+ div.style.zoom = 1;
1335	+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1336	+
1337	+ // Check if elements with layout shrink-wrap their children
1338	+ // (IE 6 does this)
1339	+ div.style.display = "";
1340	+ div.innerHTML = "<div style='width:4px;'></div>";
1341	+ support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1342	+ }
1343	+
1344	+ div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1345	+ tds = div.getElementsByTagName( "td" );
1346	+
1347	+ // Check if table cells still have offsetWidth/Height when they are set
1348	+ // to display:none and there are still other visible table cells in a
1349	+ // table row; if so, offsetWidth/Height are not reliable for use when
1350	+ // determining if an element has been hidden directly using
1351	+ // display:none (it is still safe to use offsets if a parent element is
1352	+ // hidden; don safety goggles and see bug #4512 for more information).
1353	+ // (only IE 8 fails this test)
1354	+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
1355	+
1356	+ tds[ 0 ].style.display = "";
1357	+ tds[ 1 ].style.display = "none";
1358	+
1359	+ // Check if empty table cells still have offsetWidth/Height
1360	+ // (IE < 8 fail this test)
1361	+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1362	+ div.innerHTML = "";
1363	+
1364	+ // Check if div with explicit width and no margin-right incorrectly
1365	+ // gets computed margin-right based on width of container. For more
1366	+ // info see bug #3333
1367	+ // Fails in WebKit before Feb 2011 nightlies
1368	+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1369	+ if ( document.defaultView && document.defaultView.getComputedStyle ) {
1370	+ marginDiv = document.createElement( "div" );
1371	+ marginDiv.style.width = "0";
1372	+ marginDiv.style.marginRight = "0";
1373	+ div.appendChild( marginDiv );
1374	+ support.reliableMarginRight =
1375	+ ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) \|\| { marginRight: 0 } ).marginRight, 10 ) \|\| 0 ) === 0;
1376	+ }
1377	+
1378	+ // Remove the body element we added
1379	+ testElement.innerHTML = "";
1380	+ testElementParent.removeChild( testElement );
1381	+
1382	+ // Technique from Juriy Zaytsev
1383	+ // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1384	+ // We only care about the case where non-standard event systems
1385	+ // are used, namely in IE. Short-circuiting here helps us to
1386	+ // avoid an eval call (in setAttribute) which can cause CSP
1387	+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1388	+ if ( div.attachEvent ) {
1389	+ for( i in {
1390	+ submit: 1,
1391	+ change: 1,
1392	+ focusin: 1
1393	+ } ) {
1394	+ eventName = "on" + i;
1395	+ isSupported = ( eventName in div );
1396	+ if ( !isSupported ) {
1397	+ div.setAttribute( eventName, "return;" );
1398	+ isSupported = ( typeof div[ eventName ] === "function" );
1399	+ }
1400	+ support[ i + "Bubbles" ] = isSupported;
1401	+ }
1402	+ }
1403	+
1404	+ // Null connected elements to avoid leaks in IE
1405	+ testElement = fragment = select = opt = body = marginDiv = div = input = null;
1406	+
1407	+ return support;
1408	+ })();
1409	+
1410	+ // Keep track of boxModel
1411	+ jQuery.boxModel = jQuery.support.boxModel;
1412	+
1413	+
1414	+
1415	+
1416	+ var rbrace = /^(?:\{.\}\|\[.\])$/,
1417	+ rmultiDash = /([A-Z])/g;
1418	+
1419	+ jQuery.extend({
1420	+ cache: {},
1421	+
1422	+ // Please use with caution
1423	+ uuid: 0,
1424	+
1425	+ // Unique for each copy of jQuery on the page
1426	+ // Non-digits removed to match rinlinejQuery
1427	+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1428	+
1429	+ // The following elements throw uncatchable exceptions if you
1430	+ // attempt to add expando properties to them.
1431	+ noData: {
1432	+ "embed": true,
1433	+ // Ban all objects except for Flash (which handle expandos)
1434	+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1435	+ "applet": true
1436	+ },
1437	+
1438	+ hasData: function( elem ) {
1439	+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1440	+
1441	+ return !!elem && !isEmptyDataObject( elem );
1442	+ },
1443	+
1444	+ data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1445	+ if ( !jQuery.acceptData( elem ) ) {
1446	+ return;
1447	+ }
1448	+
1449	+ var thisCache, ret,
1450	+ internalKey = jQuery.expando,
1451	+ getByName = typeof name === "string",
1452	+
1453	+ // We have to handle DOM nodes and JS objects differently because IE6-7
1454	+ // can't GC object references properly across the DOM-JS boundary
1455	+ isNode = elem.nodeType,
1456	+
1457	+ // Only DOM nodes need the global jQuery cache; JS object data is
1458	+ // attached directly to the object so GC can occur automatically
1459	+ cache = isNode ? jQuery.cache : elem,
1460	+
1461	+ // Only defining an ID for JS objects if its cache already exists allows
1462	+ // the code to shortcut on the same path as a DOM node with no cache
1463	+ id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1464	+
1465	+ // Avoid doing any more work than we need to when trying to get data on an
1466	+ // object that has no data at all
1467	+ if ( (!id \|\| (pvt && id && (cache[ id ] && !cache[ id ][ internalKey ]))) && getByName && data === undefined ) {
1468	+ return;
1469	+ }
1470	+
1471	+ if ( !id ) {
1472	+ // Only DOM nodes need a new unique ID for each element since their data
1473	+ // ends up in the global cache
1474	+ if ( isNode ) {
1475	+ elem[ jQuery.expando ] = id = ++jQuery.uuid;
1476	+ } else {
1477	+ id = jQuery.expando;
1478	+ }
1479	+ }
1480	+
1481	+ if ( !cache[ id ] ) {
1482	+ cache[ id ] = {};
1483	+
1484	+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1485	+ // metadata on plain JS objects when the object is serialized using
1486	+ // JSON.stringify
1487	+ if ( !isNode ) {
1488	+ cache[ id ].toJSON = jQuery.noop;
1489	+ }
1490	+ }
1491	+
1492	+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
1493	+ // shallow copied over onto the existing cache
1494	+ if ( typeof name === "object" \|\| typeof name === "function" ) {
1495	+ if ( pvt ) {
1496	+ cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1497	+ } else {
1498	+ cache[ id ] = jQuery.extend(cache[ id ], name);
1499	+ }
1500	+ }
1501	+
1502	+ thisCache = cache[ id ];
1503	+
1504	+ // Internal jQuery data is stored in a separate object inside the object's data
1505	+ // cache in order to avoid key collisions between internal data and user-defined
1506	+ // data
1507	+ if ( pvt ) {
1508	+ if ( !thisCache[ internalKey ] ) {
1509	+ thisCache[ internalKey ] = {};
1510	+ }
1511	+
1512	+ thisCache = thisCache[ internalKey ];
1513	+ }
1514	+
1515	+ if ( data !== undefined ) {
1516	+ thisCache[ jQuery.camelCase( name ) ] = data;
1517	+ }
1518	+
1519	+ // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1520	+ // not attempt to inspect the internal events object using jQuery.data, as this
1521	+ // internal data object is undocumented and subject to change.
1522	+ if ( name === "events" && !thisCache[name] ) {
1523	+ return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1524	+ }
1525	+
1526	+ // Check for both converted-to-camel and non-converted data property names
1527	+ // If a data property was specified
1528	+ if ( getByName ) {
1529	+
1530	+ // First Try to find as-is property data
1531	+ ret = thisCache[ name ];
1532	+
1533	+ // Test for null\|undefined property data
1534	+ if ( ret == null ) {
1535	+
1536	+ // Try to find the camelCased property
1537	+ ret = thisCache[ jQuery.camelCase( name ) ];
1538	+ }
1539	+ } else {
1540	+ ret = thisCache;
1541	+ }
1542	+
1543	+ return ret;
1544	+ },
1545	+
1546	+ removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1547	+ if ( !jQuery.acceptData( elem ) ) {
1548	+ return;
1549	+ }
1550	+
1551	+ var thisCache,
1552	+
1553	+ // Reference to internal data cache key
1554	+ internalKey = jQuery.expando,
1555	+
1556	+ isNode = elem.nodeType,
1557	+
1558	+ // See jQuery.data for more information
1559	+ cache = isNode ? jQuery.cache : elem,
1560	+
1561	+ // See jQuery.data for more information
1562	+ id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1563	+
1564	+ // If there is already no cache entry for this object, there is no
1565	+ // purpose in continuing
1566	+ if ( !cache[ id ] ) {
1567	+ return;
1568	+ }
1569	+
1570	+ if ( name ) {
1571	+
1572	+ thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1573	+
1574	+ if ( thisCache ) {
1575	+
1576	+ // Support interoperable removal of hyphenated or camelcased keys
1577	+ if ( !thisCache[ name ] ) {
1578	+ name = jQuery.camelCase( name );
1579	+ }
1580	+
1581	+ delete thisCache[ name ];
1582	+
1583	+ // If there is no data left in the cache, we want to continue
1584	+ // and let the cache object itself get destroyed
1585	+ if ( !isEmptyDataObject(thisCache) ) {
1586	+ return;
1587	+ }
1588	+ }
1589	+ }
1590	+
1591	+ // See jQuery.data for more information
1592	+ if ( pvt ) {
1593	+ delete cache[ id ][ internalKey ];
1594	+
1595	+ // Don't destroy the parent cache unless the internal data object
1596	+ // had been the only thing left in it
1597	+ if ( !isEmptyDataObject(cache[ id ]) ) {
1598	+ return;
1599	+ }
1600	+ }
1601	+
1602	+ var internalCache = cache[ id ][ internalKey ];
1603	+
1604	+ // Browsers that fail expando deletion also refuse to delete expandos on
1605	+ // the window, but it will allow it on all other JS objects; other browsers
1606	+ // don't care
1607	+ // Ensure that `cache` is not a window object #10080
1608	+ if ( jQuery.support.deleteExpando \|\| !cache.setInterval ) {
1609	+ delete cache[ id ];
1610	+ } else {
1611	+ cache[ id ] = null;
1612	+ }
1613	+
1614	+ // We destroyed the entire user cache at once because it's faster than
1615	+ // iterating through each key, but we need to continue to persist internal
1616	+ // data if it existed
1617	+ if ( internalCache ) {
1618	+ cache[ id ] = {};
1619	+ // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1620	+ // metadata on plain JS objects when the object is serialized using
1621	+ // JSON.stringify
1622	+ if ( !isNode ) {
1623	+ cache[ id ].toJSON = jQuery.noop;
1624	+ }
1625	+
1626	+ cache[ id ][ internalKey ] = internalCache;
1627	+
1628	+ // Otherwise, we need to eliminate the expando on the node to avoid
1629	+ // false lookups in the cache for entries that no longer exist
1630	+ } else if ( isNode ) {
1631	+ // IE does not allow us to delete expando properties from nodes,
1632	+ // nor does it have a removeAttribute function on Document nodes;
1633	+ // we must handle all of these cases
1634	+ if ( jQuery.support.deleteExpando ) {
1635	+ delete elem[ jQuery.expando ];
1636	+ } else if ( elem.removeAttribute ) {
1637	+ elem.removeAttribute( jQuery.expando );
1638	+ } else {
1639	+ elem[ jQuery.expando ] = null;
1640	+ }
1641	+ }
1642	+ },
1643	+
1644	+ // For internal use only.
1645	+ _data: function( elem, name, data ) {
1646	+ return jQuery.data( elem, name, data, true );
1647	+ },
1648	+
1649	+ // A method for determining if a DOM node can handle the data expando
1650	+ acceptData: function( elem ) {
1651	+ if ( elem.nodeName ) {
1652	+ var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1653	+
1654	+ if ( match ) {
1655	+ return !(match === true \|\| elem.getAttribute("classid") !== match);
1656	+ }
1657	+ }
1658	+
1659	+ return true;
1660	+ }
1661	+ });
1662	+
1663	+ jQuery.fn.extend({
1664	+ data: function( key, value ) {
1665	+ var data = null;
1666	+
1667	+ if ( typeof key === "undefined" ) {
1668	+ if ( this.length ) {
1669	+ data = jQuery.data( this[0] );
1670	+
1671	+ if ( this[0].nodeType === 1 ) {
1672	+ var attr = this[0].attributes, name;
1673	+ for ( var i = 0, l = attr.length; i < l; i++ ) {
1674	+ name = attr[i].name;
1675	+
1676	+ if ( name.indexOf( "data-" ) === 0 ) {
1677	+ name = jQuery.camelCase( name.substring(5) );
1678	+
1679	+ dataAttr( this[0], name, data[ name ] );
1680	+ }
1681	+ }
1682	+ }
1683	+ }
1684	+
1685	+ return data;
1686	+
1687	+ } else if ( typeof key === "object" ) {
1688	+ return this.each(function() {
1689	+ jQuery.data( this, key );
1690	+ });
1691	+ }
1692	+
1693	+ var parts = key.split(".");
1694	+ parts[1] = parts[1] ? "." + parts[1] : "";
1695	+
1696	+ if ( value === undefined ) {
1697	+ data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1698	+
1699	+ // Try to fetch any internally stored data first
1700	+ if ( data === undefined && this.length ) {
1701	+ data = jQuery.data( this[0], key );
1702	+ data = dataAttr( this[0], key, data );
1703	+ }
1704	+
1705	+ return data === undefined && parts[1] ?
1706	+ this.data( parts[0] ) :
1707	+ data;
1708	+
1709	+ } else {
1710	+ return this.each(function() {
1711	+ var $this = jQuery( this ),
1712	+ args = [ parts[0], value ];
1713	+
1714	+ $this.triggerHandler( "setData" + parts[1] + "!", args );
1715	+ jQuery.data( this, key, value );
1716	+ $this.triggerHandler( "changeData" + parts[1] + "!", args );
1717	+ });
1718	+ }
1719	+ },
1720	+
1721	+ removeData: function( key ) {
1722	+ return this.each(function() {
1723	+ jQuery.removeData( this, key );
1724	+ });
1725	+ }
1726	+ });
1727	+
1728	+ function dataAttr( elem, key, data ) {
1729	+ // If nothing was found internally, try to fetch any
1730	+ // data from the HTML5 data-* attribute
1731	+ if ( data === undefined && elem.nodeType === 1 ) {
1732	+
1733	+ var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1734	+
1735	+ data = elem.getAttribute( name );
1736	+
1737	+ if ( typeof data === "string" ) {
1738	+ try {
1739	+ data = data === "true" ? true :
1740	+ data === "false" ? false :
1741	+ data === "null" ? null :
1742	+ !jQuery.isNaN( data ) ? parseFloat( data ) :
1743	+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
1744	+ data;
1745	+ } catch( e ) {}
1746	+
1747	+ // Make sure we set the data so it isn't changed later
1748	+ jQuery.data( elem, key, data );
1749	+
1750	+ } else {
1751	+ data = undefined;
1752	+ }
1753	+ }
1754	+
1755	+ return data;
1756	+ }
1757	+
1758	+ // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1759	+ // property to be considered empty objects; this property always exists in
1760	+ // order to make sure JSON.stringify does not expose internal metadata
1761	+ function isEmptyDataObject( obj ) {
1762	+ for ( var name in obj ) {
1763	+ if ( name !== "toJSON" ) {
1764	+ return false;
1765	+ }
1766	+ }
1767	+
1768	+ return true;
1769	+ }
1770	+
1771	+
1772	+
1773	+
1774	+ function handleQueueMarkDefer( elem, type, src ) {
1775	+ var deferDataKey = type + "defer",
1776	+ queueDataKey = type + "queue",
1777	+ markDataKey = type + "mark",
1778	+ defer = jQuery.data( elem, deferDataKey, undefined, true );
1779	+ if ( defer &&
1780	+ ( src === "queue" \|\| !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1781	+ ( src === "mark" \|\| !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1782	+ // Give room for hard-coded callbacks to fire first
1783	+ // and eventually mark/queue something else on the element
1784	+ setTimeout( function() {
1785	+ if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1786	+ !jQuery.data( elem, markDataKey, undefined, true ) ) {
1787	+ jQuery.removeData( elem, deferDataKey, true );
1788	+ defer.resolve();
1789	+ }
1790	+ }, 0 );
1791	+ }
1792	+ }
1793	+
1794	+ jQuery.extend({
1795	+
1796	+ _mark: function( elem, type ) {
1797	+ if ( elem ) {
1798	+ type = (type \|\| "fx") + "mark";
1799	+ jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) \|\| 0) + 1, true );
1800	+ }
1801	+ },
1802	+
1803	+ _unmark: function( force, elem, type ) {
1804	+ if ( force !== true ) {
1805	+ type = elem;
1806	+ elem = force;
1807	+ force = false;
1808	+ }
1809	+ if ( elem ) {
1810	+ type = type \|\| "fx";
1811	+ var key = type + "mark",
1812	+ count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) \|\| 1 ) - 1 );
1813	+ if ( count ) {
1814	+ jQuery.data( elem, key, count, true );
1815	+ } else {
1816	+ jQuery.removeData( elem, key, true );
1817	+ handleQueueMarkDefer( elem, type, "mark" );
1818	+ }
1819	+ }
1820	+ },
1821	+
1822	+ queue: function( elem, type, data ) {
1823	+ if ( elem ) {
1824	+ type = (type \|\| "fx") + "queue";
1825	+ var q = jQuery.data( elem, type, undefined, true );
1826	+ // Speed up dequeue by getting out quickly if this is just a lookup
1827	+ if ( data ) {
1828	+ if ( !q \|\| jQuery.isArray(data) ) {
1829	+ q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1830	+ } else {
1831	+ q.push( data );
1832	+ }
1833	+ }
1834	+ return q \|\| [];
1835	+ }
1836	+ },
1837	+
1838	+ dequeue: function( elem, type ) {
1839	+ type = type \|\| "fx";
1840	+
1841	+ var queue = jQuery.queue( elem, type ),
1842	+ fn = queue.shift(),
1843	+ defer;
1844	+
1845	+ // If the fx queue is dequeued, always remove the progress sentinel
1846	+ if ( fn === "inprogress" ) {
1847	+ fn = queue.shift();
1848	+ }
1849	+
1850	+ if ( fn ) {
1851	+ // Add a progress sentinel to prevent the fx queue from being
1852	+ // automatically dequeued
1853	+ if ( type === "fx" ) {
1854	+ queue.unshift("inprogress");
1855	+ }
1856	+
1857	+ fn.call(elem, function() {
1858	+ jQuery.dequeue(elem, type);
1859	+ });
1860	+ }
1861	+
1862	+ if ( !queue.length ) {
1863	+ jQuery.removeData( elem, type + "queue", true );
1864	+ handleQueueMarkDefer( elem, type, "queue" );
1865	+ }
1866	+ }
1867	+ });
1868	+
1869	+ jQuery.fn.extend({
1870	+ queue: function( type, data ) {
1871	+ if ( typeof type !== "string" ) {
1872	+ data = type;
1873	+ type = "fx";
1874	+ }
1875	+
1876	+ if ( data === undefined ) {
1877	+ return jQuery.queue( this[0], type );
1878	+ }
1879	+ return this.each(function() {
1880	+ var queue = jQuery.queue( this, type, data );
1881	+
1882	+ if ( type === "fx" && queue[0] !== "inprogress" ) {
1883	+ jQuery.dequeue( this, type );
1884	+ }
1885	+ });
1886	+ },
1887	+ dequeue: function( type ) {
1888	+ return this.each(function() {
1889	+ jQuery.dequeue( this, type );
1890	+ });
1891	+ },
1892	+ // Based off of the plugin by Clint Helfers, with permission.
1893	+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
1894	+ delay: function( time, type ) {
1895	+ time = jQuery.fx ? jQuery.fx.speeds[time] \|\| time : time;
1896	+ type = type \|\| "fx";
1897	+
1898	+ return this.queue( type, function() {
1899	+ var elem = this;
1900	+ setTimeout(function() {
1901	+ jQuery.dequeue( elem, type );
1902	+ }, time );
1903	+ });
1904	+ },
1905	+ clearQueue: function( type ) {
1906	+ return this.queue( type \|\| "fx", [] );
1907	+ },
1908	+ // Get a promise resolved when queues of a certain type
1909	+ // are emptied (fx is the type by default)
1910	+ promise: function( type, object ) {
1911	+ if ( typeof type !== "string" ) {
1912	+ object = type;
1913	+ type = undefined;
1914	+ }
1915	+ type = type \|\| "fx";
1916	+ var defer = jQuery.Deferred(),
1917	+ elements = this,
1918	+ i = elements.length,
1919	+ count = 1,
1920	+ deferDataKey = type + "defer",
1921	+ queueDataKey = type + "queue",
1922	+ markDataKey = type + "mark",
1923	+ tmp;
1924	+ function resolve() {
1925	+ if ( !( --count ) ) {
1926	+ defer.resolveWith( elements, [ elements ] );
1927	+ }
1928	+ }
1929	+ while( i-- ) {
1930	+ if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) \|\|
1931	+ ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) \|\|
1932	+ jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1933	+ jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1934	+ count++;
1935	+ tmp.done( resolve );
1936	+ }
1937	+ }
1938	+ resolve();
1939	+ return defer.promise();
1940	+ }
1941	+ });
1942	+
1943	+
1944	+
1945	+
1946	+ var rclass = /[\n\t\r]/g,
1947	+ rspace = /\s+/,
1948	+ rreturn = /\r/g,
1949	+ rtype = /^(?:button\|input)$/i,
1950	+ rfocusable = /^(?:button\|input\|object\|select\|textarea)$/i,
1951	+ rclickable = /^a(?:rea)?$/i,
1952	+ rboolean = /^(?:autofocus\|autoplay\|async\|checked\|controls\|defer\|disabled\|hidden\|loop\|multiple\|open\|readonly\|required\|scoped\|selected)$/i,
1953	+ nodeHook, boolHook;
1954	+
1955	+ jQuery.fn.extend({
1956	+ attr: function( name, value ) {
1957	+ return jQuery.access( this, name, value, true, jQuery.attr );
1958	+ },
1959	+
1960	+ removeAttr: function( name ) {
1961	+ return this.each(function() {
1962	+ jQuery.removeAttr( this, name );
1963	+ });
1964	+ },
1965	+
1966	+ prop: function( name, value ) {
1967	+ return jQuery.access( this, name, value, true, jQuery.prop );
1968	+ },
1969	+
1970	+ removeProp: function( name ) {
1971	+ name = jQuery.propFix[ name ] \|\| name;
1972	+ return this.each(function() {
1973	+ // try/catch handles cases where IE balks (such as removing a property on window)
1974	+ try {
1975	+ this[ name ] = undefined;
1976	+ delete this[ name ];
1977	+ } catch( e ) {}
1978	+ });
1979	+ },
1980	+
1981	+ addClass: function( value ) {
1982	+ var classNames, i, l, elem,
1983	+ setClass, c, cl;
1984	+
1985	+ if ( jQuery.isFunction( value ) ) {
1986	+ return this.each(function( j ) {
1987	+ jQuery( this ).addClass( value.call(this, j, this.className) );
1988	+ });
1989	+ }
1990	+
1991	+ if ( value && typeof value === "string" ) {
1992	+ classNames = value.split( rspace );
1993	+
1994	+ for ( i = 0, l = this.length; i < l; i++ ) {
1995	+ elem = this[ i ];
1996	+
1997	+ if ( elem.nodeType === 1 ) {
1998	+ if ( !elem.className && classNames.length === 1 ) {
1999	+ elem.className = value;
2000	+
2001	+ } else {
2002	+ setClass = " " + elem.className + " ";
2003	+
2004	+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2005	+ if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2006	+ setClass += classNames[ c ] + " ";
2007	+ }
2008	+ }
2009	+ elem.className = jQuery.trim( setClass );
2010	+ }
2011	+ }
2012	+ }
2013	+ }
2014	+
2015	+ return this;
2016	+ },
2017	+
2018	+ removeClass: function( value ) {
2019	+ var classNames, i, l, elem, className, c, cl;
2020	+
2021	+ if ( jQuery.isFunction( value ) ) {
2022	+ return this.each(function( j ) {
2023	+ jQuery( this ).removeClass( value.call(this, j, this.className) );
2024	+ });
2025	+ }
2026	+
2027	+ if ( (value && typeof value === "string") \|\| value === undefined ) {
2028	+ classNames = (value \|\| "").split( rspace );
2029	+
2030	+ for ( i = 0, l = this.length; i < l; i++ ) {
2031	+ elem = this[ i ];
2032	+
2033	+ if ( elem.nodeType === 1 && elem.className ) {
2034	+ if ( value ) {
2035	+ className = (" " + elem.className + " ").replace( rclass, " " );
2036	+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2037	+ className = className.replace(" " + classNames[ c ] + " ", " ");
2038	+ }
2039	+ elem.className = jQuery.trim( className );
2040	+
2041	+ } else {
2042	+ elem.className = "";
2043	+ }
2044	+ }
2045	+ }
2046	+ }
2047	+
2048	+ return this;
2049	+ },
2050	+
2051	+ toggleClass: function( value, stateVal ) {
2052	+ var type = typeof value,
2053	+ isBool = typeof stateVal === "boolean";
2054	+
2055	+ if ( jQuery.isFunction( value ) ) {
2056	+ return this.each(function( i ) {
2057	+ jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2058	+ });
2059	+ }
2060	+
2061	+ return this.each(function() {
2062	+ if ( type === "string" ) {
2063	+ // toggle individual class names
2064	+ var className,
2065	+ i = 0,
2066	+ self = jQuery( this ),
2067	+ state = stateVal,
2068	+ classNames = value.split( rspace );
2069	+
2070	+ while ( (className = classNames[ i++ ]) ) {
2071	+ // check each className given, space seperated list
2072	+ state = isBool ? state : !self.hasClass( className );
2073	+ self[ state ? "addClass" : "removeClass" ]( className );
2074	+ }
2075	+
2076	+ } else if ( type === "undefined" \|\| type === "boolean" ) {
2077	+ if ( this.className ) {
2078	+ // store className if set
2079	+ jQuery._data( this, "__className__", this.className );
2080	+ }
2081	+
2082	+ // toggle whole className
2083	+ this.className = this.className \|\| value === false ? "" : jQuery._data( this, "__className__" ) \|\| "";
2084	+ }
2085	+ });
2086	+ },
2087	+
2088	+ hasClass: function( selector ) {
2089	+ var className = " " + selector + " ";
2090	+ for ( var i = 0, l = this.length; i < l; i++ ) {
2091	+ if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2092	+ return true;
2093	+ }
2094	+ }
2095	+
2096	+ return false;
2097	+ },
2098	+
2099	+ val: function( value ) {
2100	+ var hooks, ret,
2101	+ elem = this[0];
2102	+
2103	+ if ( !arguments.length ) {
2104	+ if ( elem ) {
2105	+ hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] \|\| jQuery.valHooks[ elem.type ];
2106	+
2107	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2108	+ return ret;
2109	+ }
2110	+
2111	+ ret = elem.value;
2112	+
2113	+ return typeof ret === "string" ?
2114	+ // handle most common string cases
2115	+ ret.replace(rreturn, "") :
2116	+ // handle cases where value is null/undef or number
2117	+ ret == null ? "" : ret;
2118	+ }
2119	+
2120	+ return undefined;
2121	+ }
2122	+
2123	+ var isFunction = jQuery.isFunction( value );
2124	+
2125	+ return this.each(function( i ) {
2126	+ var self = jQuery(this), val;
2127	+
2128	+ if ( this.nodeType !== 1 ) {
2129	+ return;
2130	+ }
2131	+
2132	+ if ( isFunction ) {
2133	+ val = value.call( this, i, self.val() );
2134	+ } else {
2135	+ val = value;
2136	+ }
2137	+
2138	+ // Treat null/undefined as ""; convert numbers to string
2139	+ if ( val == null ) {
2140	+ val = "";
2141	+ } else if ( typeof val === "number" ) {
2142	+ val += "";
2143	+ } else if ( jQuery.isArray( val ) ) {
2144	+ val = jQuery.map(val, function ( value ) {
2145	+ return value == null ? "" : value + "";
2146	+ });
2147	+ }
2148	+
2149	+ hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] \|\| jQuery.valHooks[ this.type ];
2150	+
2151	+ // If set returns undefined, fall back to normal setting
2152	+ if ( !hooks \|\| !("set" in hooks) \|\| hooks.set( this, val, "value" ) === undefined ) {
2153	+ this.value = val;
2154	+ }
2155	+ });
2156	+ }
2157	+ });
2158	+
2159	+ jQuery.extend({
2160	+ valHooks: {
2161	+ option: {
2162	+ get: function( elem ) {
2163	+ // attributes.value is undefined in Blackberry 4.7 but
2164	+ // uses .value. See #6932
2165	+ var val = elem.attributes.value;
2166	+ return !val \|\| val.specified ? elem.value : elem.text;
2167	+ }
2168	+ },
2169	+ select: {
2170	+ get: function( elem ) {
2171	+ var value,
2172	+ index = elem.selectedIndex,
2173	+ values = [],
2174	+ options = elem.options,
2175	+ one = elem.type === "select-one";
2176	+
2177	+ // Nothing was selected
2178	+ if ( index < 0 ) {
2179	+ return null;
2180	+ }
2181	+
2182	+ // Loop through all the selected options
2183	+ for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2184	+ var option = options[ i ];
2185	+
2186	+ // Don't return options that are disabled or in a disabled optgroup
2187	+ if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2188	+ (!option.parentNode.disabled \|\| !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2189	+
2190	+ // Get the specific value for the option
2191	+ value = jQuery( option ).val();
2192	+
2193	+ // We don't need an array for one selects
2194	+ if ( one ) {
2195	+ return value;
2196	+ }
2197	+
2198	+ // Multi-Selects return an array
2199	+ values.push( value );
2200	+ }
2201	+ }
2202	+
2203	+ // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2204	+ if ( one && !values.length && options.length ) {
2205	+ return jQuery( options[ index ] ).val();
2206	+ }
2207	+
2208	+ return values;
2209	+ },
2210	+
2211	+ set: function( elem, value ) {
2212	+ var values = jQuery.makeArray( value );
2213	+
2214	+ jQuery(elem).find("option").each(function() {
2215	+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2216	+ });
2217	+
2218	+ if ( !values.length ) {
2219	+ elem.selectedIndex = -1;
2220	+ }
2221	+ return values;
2222	+ }
2223	+ }
2224	+ },
2225	+
2226	+ attrFn: {
2227	+ val: true,
2228	+ css: true,
2229	+ html: true,
2230	+ text: true,
2231	+ data: true,
2232	+ width: true,
2233	+ height: true,
2234	+ offset: true
2235	+ },
2236	+
2237	+ attrFix: {
2238	+ // Always normalize to ensure hook usage
2239	+ tabindex: "tabIndex"
2240	+ },
2241	+
2242	+ attr: function( elem, name, value, pass ) {
2243	+ var nType = elem.nodeType;
2244	+
2245	+ // don't get/set attributes on text, comment and attribute nodes
2246	+ if ( !elem \|\| nType === 3 \|\| nType === 8 \|\| nType === 2 ) {
2247	+ return undefined;
2248	+ }
2249	+
2250	+ if ( pass && name in jQuery.attrFn ) {
2251	+ return jQuery( elem )[ name ]( value );
2252	+ }
2253	+
2254	+ // Fallback to prop when attributes are not supported
2255	+ if ( !("getAttribute" in elem) ) {
2256	+ return jQuery.prop( elem, name, value );
2257	+ }
2258	+
2259	+ var ret, hooks,
2260	+ notxml = nType !== 1 \|\| !jQuery.isXMLDoc( elem );
2261	+
2262	+ // Normalize the name if needed
2263	+ if ( notxml ) {
2264	+ name = jQuery.attrFix[ name ] \|\| name;
2265	+
2266	+ hooks = jQuery.attrHooks[ name ];
2267	+
2268	+ if ( !hooks ) {
2269	+ // Use boolHook for boolean attributes
2270	+ if ( rboolean.test( name ) ) {
2271	+ hooks = boolHook;
2272	+
2273	+ // Use nodeHook if available( IE6/7 )
2274	+ } else if ( nodeHook ) {
2275	+ hooks = nodeHook;
2276	+ }
2277	+ }
2278	+ }
2279	+
2280	+ if ( value !== undefined ) {
2281	+
2282	+ if ( value === null ) {
2283	+ jQuery.removeAttr( elem, name );
2284	+ return undefined;
2285	+
2286	+ } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2287	+ return ret;
2288	+
2289	+ } else {
2290	+ elem.setAttribute( name, "" + value );
2291	+ return value;
2292	+ }
2293	+
2294	+ } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2295	+ return ret;
2296	+
2297	+ } else {
2298	+
2299	+ ret = elem.getAttribute( name );
2300	+
2301	+ // Non-existent attributes return null, we normalize to undefined
2302	+ return ret === null ?
2303	+ undefined :
2304	+ ret;
2305	+ }
2306	+ },
2307	+
2308	+ removeAttr: function( elem, name ) {
2309	+ var propName;
2310	+ if ( elem.nodeType === 1 ) {
2311	+ name = jQuery.attrFix[ name ] \|\| name;
2312	+
2313	+ jQuery.attr( elem, name, "" );
2314	+ elem.removeAttribute( name );
2315	+
2316	+ // Set corresponding property to false for boolean attributes
2317	+ if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] \|\| name) in elem ) {
2318	+ elem[ propName ] = false;
2319	+ }
2320	+ }
2321	+ },
2322	+
2323	+ attrHooks: {
2324	+ type: {
2325	+ set: function( elem, value ) {
2326	+ // We can't allow the type property to be changed (since it causes problems in IE)
2327	+ if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2328	+ jQuery.error( "type property can't be changed" );
2329	+ } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2330	+ // Setting the type on a radio button after the value resets the value in IE6-9
2331	+ // Reset value to it's default in case type is set after value
2332	+ // This is for element creation
2333	+ var val = elem.value;
2334	+ elem.setAttribute( "type", value );
2335	+ if ( val ) {
2336	+ elem.value = val;
2337	+ }
2338	+ return value;
2339	+ }
2340	+ }
2341	+ },
2342	+ // Use the value property for back compat
2343	+ // Use the nodeHook for button elements in IE6/7 (#1954)
2344	+ value: {
2345	+ get: function( elem, name ) {
2346	+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2347	+ return nodeHook.get( elem, name );
2348	+ }
2349	+ return name in elem ?
2350	+ elem.value :
2351	+ null;
2352	+ },
2353	+ set: function( elem, value, name ) {
2354	+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2355	+ return nodeHook.set( elem, value, name );
2356	+ }
2357	+ // Does not return so that setAttribute is also used
2358	+ elem.value = value;
2359	+ }
2360	+ }
2361	+ },
2362	+
2363	+ propFix: {
2364	+ tabindex: "tabIndex",
2365	+ readonly: "readOnly",
2366	+ "for": "htmlFor",
2367	+ "class": "className",
2368	+ maxlength: "maxLength",
2369	+ cellspacing: "cellSpacing",
2370	+ cellpadding: "cellPadding",
2371	+ rowspan: "rowSpan",
2372	+ colspan: "colSpan",
2373	+ usemap: "useMap",
2374	+ frameborder: "frameBorder",
2375	+ contenteditable: "contentEditable"
2376	+ },
2377	+
2378	+ prop: function( elem, name, value ) {
2379	+ var nType = elem.nodeType;
2380	+
2381	+ // don't get/set properties on text, comment and attribute nodes
2382	+ if ( !elem \|\| nType === 3 \|\| nType === 8 \|\| nType === 2 ) {
2383	+ return undefined;
2384	+ }
2385	+
2386	+ var ret, hooks,
2387	+ notxml = nType !== 1 \|\| !jQuery.isXMLDoc( elem );
2388	+
2389	+ if ( notxml ) {
2390	+ // Fix name and attach hooks
2391	+ name = jQuery.propFix[ name ] \|\| name;
2392	+ hooks = jQuery.propHooks[ name ];
2393	+ }
2394	+
2395	+ if ( value !== undefined ) {
2396	+ if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2397	+ return ret;
2398	+
2399	+ } else {
2400	+ return (elem[ name ] = value);
2401	+ }
2402	+
2403	+ } else {
2404	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2405	+ return ret;
2406	+
2407	+ } else {
2408	+ return elem[ name ];
2409	+ }
2410	+ }
2411	+ },
2412	+
2413	+ propHooks: {
2414	+ tabIndex: {
2415	+ get: function( elem ) {
2416	+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2417	+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2418	+ var attributeNode = elem.getAttributeNode("tabindex");
2419	+
2420	+ return attributeNode && attributeNode.specified ?
2421	+ parseInt( attributeNode.value, 10 ) :
2422	+ rfocusable.test( elem.nodeName ) \|\| rclickable.test( elem.nodeName ) && elem.href ?
2423	+ 0 :
2424	+ undefined;
2425	+ }
2426	+ }
2427	+ }
2428	+ });
2429	+
2430	+ // Add the tabindex propHook to attrHooks for back-compat
2431	+ jQuery.attrHooks.tabIndex = jQuery.propHooks.tabIndex;
2432	+
2433	+ // Hook for boolean attributes
2434	+ boolHook = {
2435	+ get: function( elem, name ) {
2436	+ // Align boolean attributes with corresponding properties
2437	+ // Fall back to attribute presence where some booleans are not supported
2438	+ var attrNode;
2439	+ return jQuery.prop( elem, name ) === true \|\| ( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ?
2440	+ name.toLowerCase() :
2441	+ undefined;
2442	+ },
2443	+ set: function( elem, value, name ) {
2444	+ var propName;
2445	+ if ( value === false ) {
2446	+ // Remove boolean attributes when set to false
2447	+ jQuery.removeAttr( elem, name );
2448	+ } else {
2449	+ // value is true since we know at this point it's type boolean and not false
2450	+ // Set boolean attributes to the same name and set the DOM property
2451	+ propName = jQuery.propFix[ name ] \|\| name;
2452	+ if ( propName in elem ) {
2453	+ // Only set the IDL specifically if it already exists on the element
2454	+ elem[ propName ] = true;
2455	+ }
2456	+
2457	+ elem.setAttribute( name, name.toLowerCase() );
2458	+ }
2459	+ return name;
2460	+ }
2461	+ };
2462	+
2463	+ // IE6/7 do not support getting/setting some attributes with get/setAttribute
2464	+ if ( !jQuery.support.getSetAttribute ) {
2465	+
2466	+ // Use this for any attribute in IE6/7
2467	+ // This fixes almost every IE6/7 issue
2468	+ nodeHook = jQuery.valHooks.button = {
2469	+ get: function( elem, name ) {
2470	+ var ret;
2471	+ ret = elem.getAttributeNode( name );
2472	+ // Return undefined if nodeValue is empty string
2473	+ return ret && ret.nodeValue !== "" ?
2474	+ ret.nodeValue :
2475	+ undefined;
2476	+ },
2477	+ set: function( elem, value, name ) {
2478	+ // Set the existing or create a new attribute node
2479	+ var ret = elem.getAttributeNode( name );
2480	+ if ( !ret ) {
2481	+ ret = document.createAttribute( name );
2482	+ elem.setAttributeNode( ret );
2483	+ }
2484	+ return (ret.nodeValue = value + "");
2485	+ }
2486	+ };
2487	+
2488	+ // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2489	+ // This is for removals
2490	+ jQuery.each([ "width", "height" ], function( i, name ) {
2491	+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2492	+ set: function( elem, value ) {
2493	+ if ( value === "" ) {
2494	+ elem.setAttribute( name, "auto" );
2495	+ return value;
2496	+ }
2497	+ }
2498	+ });
2499	+ });
2500	+ }
2501	+
2502	+
2503	+ // Some attributes require a special call on IE
2504	+ if ( !jQuery.support.hrefNormalized ) {
2505	+ jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2506	+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2507	+ get: function( elem ) {
2508	+ var ret = elem.getAttribute( name, 2 );
2509	+ return ret === null ? undefined : ret;
2510	+ }
2511	+ });
2512	+ });
2513	+ }
2514	+
2515	+ if ( !jQuery.support.style ) {
2516	+ jQuery.attrHooks.style = {
2517	+ get: function( elem ) {
2518	+ // Return undefined in the case of empty string
2519	+ // Normalize to lowercase since IE uppercases css property names
2520	+ return elem.style.cssText.toLowerCase() \|\| undefined;
2521	+ },
2522	+ set: function( elem, value ) {
2523	+ return (elem.style.cssText = "" + value);
2524	+ }
2525	+ };
2526	+ }
2527	+
2528	+ // Safari mis-reports the default selected property of an option
2529	+ // Accessing the parent's selectedIndex property fixes it
2530	+ if ( !jQuery.support.optSelected ) {
2531	+ jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2532	+ get: function( elem ) {
2533	+ var parent = elem.parentNode;
2534	+
2535	+ if ( parent ) {
2536	+ parent.selectedIndex;
2537	+
2538	+ // Make sure that it also works with optgroups, see #5701
2539	+ if ( parent.parentNode ) {
2540	+ parent.parentNode.selectedIndex;
2541	+ }
2542	+ }
2543	+ return null;
2544	+ }
2545	+ });
2546	+ }
2547	+
2548	+ // Radios and checkboxes getter/setter
2549	+ if ( !jQuery.support.checkOn ) {
2550	+ jQuery.each([ "radio", "checkbox" ], function() {
2551	+ jQuery.valHooks[ this ] = {
2552	+ get: function( elem ) {
2553	+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2554	+ return elem.getAttribute("value") === null ? "on" : elem.value;
2555	+ }
2556	+ };
2557	+ });
2558	+ }
2559	+ jQuery.each([ "radio", "checkbox" ], function() {
2560	+ jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2561	+ set: function( elem, value ) {
2562	+ if ( jQuery.isArray( value ) ) {
2563	+ return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2564	+ }
2565	+ }
2566	+ });
2567	+ });
2568	+
2569	+
2570	+
2571	+
2572	+ var rnamespaces = /\.(.*)$/,
2573	+ rformElems = /^(?:textarea\|input\|select)$/i,
2574	+ rperiod = /\./g,
2575	+ rspaces = / /g,
2576	+ rescape = /[^\w\s.\|`]/g,
2577	+ fcleanup = function( nm ) {
2578	+ return nm.replace(rescape, "\\$&");
2579	+ };
2580	+
2581	+ /*
2582	+ * A number of helper functions used for managing events.
2583	+ * Many of the ideas behind this code originated from
2584	+ * Dean Edwards' addEvent library.
2585	+ */
2586	+ jQuery.event = {
2587	+
2588	+ // Bind an event to an element
2589	+ // Original by Dean Edwards
2590	+ add: function( elem, types, handler, data ) {
2591	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2592	+ return;
2593	+ }
2594	+
2595	+ if ( handler === false ) {
2596	+ handler = returnFalse;
2597	+ } else if ( !handler ) {
2598	+ // Fixes bug #7229. Fix recommended by jdalton
2599	+ return;
2600	+ }
2601	+
2602	+ var handleObjIn, handleObj;
2603	+
2604	+ if ( handler.handler ) {
2605	+ handleObjIn = handler;
2606	+ handler = handleObjIn.handler;
2607	+ }
2608	+
2609	+ // Make sure that the function being executed has a unique ID
2610	+ if ( !handler.guid ) {
2611	+ handler.guid = jQuery.guid++;
2612	+ }
2613	+
2614	+ // Init the element's event structure
2615	+ var elemData = jQuery._data( elem );
2616	+
2617	+ // If no elemData is found then we must be trying to bind to one of the
2618	+ // banned noData elements
2619	+ if ( !elemData ) {
2620	+ return;
2621	+ }
2622	+
2623	+ var events = elemData.events,
2624	+ eventHandle = elemData.handle;
2625	+
2626	+ if ( !events ) {
2627	+ elemData.events = events = {};
2628	+ }
2629	+
2630	+ if ( !eventHandle ) {
2631	+ elemData.handle = eventHandle = function( e ) {
2632	+ // Discard the second event of a jQuery.event.trigger() and
2633	+ // when an event is called after a page has unloaded
2634	+ return typeof jQuery !== "undefined" && (!e \|\| jQuery.event.triggered !== e.type) ?
2635	+ jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2636	+ undefined;
2637	+ };
2638	+ }
2639	+
2640	+ // Add elem as a property of the handle function
2641	+ // This is to prevent a memory leak with non-native events in IE.
2642	+ eventHandle.elem = elem;
2643	+
2644	+ // Handle multiple events separated by a space
2645	+ // jQuery(...).bind("mouseover mouseout", fn);
2646	+ types = types.split(" ");
2647	+
2648	+ var type, i = 0, namespaces;
2649	+
2650	+ while ( (type = types[ i++ ]) ) {
2651	+ handleObj = handleObjIn ?
2652	+ jQuery.extend({}, handleObjIn) :
2653	+ { handler: handler, data: data };
2654	+
2655	+ // Namespaced event handlers
2656	+ if ( type.indexOf(".") > -1 ) {
2657	+ namespaces = type.split(".");
2658	+ type = namespaces.shift();
2659	+ handleObj.namespace = namespaces.slice(0).sort().join(".");
2660	+
2661	+ } else {
2662	+ namespaces = [];
2663	+ handleObj.namespace = "";
2664	+ }
2665	+
2666	+ handleObj.type = type;
2667	+ if ( !handleObj.guid ) {
2668	+ handleObj.guid = handler.guid;
2669	+ }
2670	+
2671	+ // Get the current list of functions bound to this event
2672	+ var handlers = events[ type ],
2673	+ special = jQuery.event.special[ type ] \|\| {};
2674	+
2675	+ // Init the event handler queue
2676	+ if ( !handlers ) {
2677	+ handlers = events[ type ] = [];
2678	+
2679	+ // Check for a special event handler
2680	+ // Only use addEventListener/attachEvent if the special
2681	+ // events handler returns false
2682	+ if ( !special.setup \|\| special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2683	+ // Bind the global event handler to the element
2684	+ if ( elem.addEventListener ) {
2685	+ elem.addEventListener( type, eventHandle, false );
2686	+
2687	+ } else if ( elem.attachEvent ) {
2688	+ elem.attachEvent( "on" + type, eventHandle );
2689	+ }
2690	+ }
2691	+ }
2692	+
2693	+ if ( special.add ) {
2694	+ special.add.call( elem, handleObj );
2695	+
2696	+ if ( !handleObj.handler.guid ) {
2697	+ handleObj.handler.guid = handler.guid;
2698	+ }
2699	+ }
2700	+
2701	+ // Add the function to the element's handler list
2702	+ handlers.push( handleObj );
2703	+
2704	+ // Keep track of which events have been used, for event optimization
2705	+ jQuery.event.global[ type ] = true;
2706	+ }
2707	+
2708	+ // Nullify elem to prevent memory leaks in IE
2709	+ elem = null;
2710	+ },
2711	+
2712	+ global: {},
2713	+
2714	+ // Detach an event or set of events from an element
2715	+ remove: function( elem, types, handler, pos ) {
2716	+ // don't do events on text and comment nodes
2717	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2718	+ return;
2719	+ }
2720	+
2721	+ if ( handler === false ) {
2722	+ handler = returnFalse;
2723	+ }
2724	+
2725	+ var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2726	+ elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2727	+ events = elemData && elemData.events;
2728	+
2729	+ if ( !elemData \|\| !events ) {
2730	+ return;
2731	+ }
2732	+
2733	+ // types is actually an event object here
2734	+ if ( types && types.type ) {
2735	+ handler = types.handler;
2736	+ types = types.type;
2737	+ }
2738	+
2739	+ // Unbind all events for the element
2740	+ if ( !types \|\| typeof types === "string" && types.charAt(0) === "." ) {
2741	+ types = types \|\| "";
2742	+
2743	+ for ( type in events ) {
2744	+ jQuery.event.remove( elem, type + types );
2745	+ }
2746	+
2747	+ return;
2748	+ }
2749	+
2750	+ // Handle multiple events separated by a space
2751	+ // jQuery(...).unbind("mouseover mouseout", fn);
2752	+ types = types.split(" ");
2753	+
2754	+ while ( (type = types[ i++ ]) ) {
2755	+ origType = type;
2756	+ handleObj = null;
2757	+ all = type.indexOf(".") < 0;
2758	+ namespaces = [];
2759	+
2760	+ if ( !all ) {
2761	+ // Namespaced event handlers
2762	+ namespaces = type.split(".");
2763	+ type = namespaces.shift();
2764	+
2765	+ namespace = new RegExp("(^\|\\.)" +
2766	+ jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.\|$)");
2767	+ }
2768	+
2769	+ eventType = events[ type ];
2770	+
2771	+ if ( !eventType ) {
2772	+ continue;
2773	+ }
2774	+
2775	+ if ( !handler ) {
2776	+ for ( j = 0; j < eventType.length; j++ ) {
2777	+ handleObj = eventType[ j ];
2778	+
2779	+ if ( all \|\| namespace.test( handleObj.namespace ) ) {
2780	+ jQuery.event.remove( elem, origType, handleObj.handler, j );
2781	+ eventType.splice( j--, 1 );
2782	+ }
2783	+ }
2784	+
2785	+ continue;
2786	+ }
2787	+
2788	+ special = jQuery.event.special[ type ] \|\| {};
2789	+
2790	+ for ( j = pos \|\| 0; j < eventType.length; j++ ) {
2791	+ handleObj = eventType[ j ];
2792	+
2793	+ if ( handler.guid === handleObj.guid ) {
2794	+ // remove the given handler for the given type
2795	+ if ( all \|\| namespace.test( handleObj.namespace ) ) {
2796	+ if ( pos == null ) {
2797	+ eventType.splice( j--, 1 );
2798	+ }
2799	+
2800	+ if ( special.remove ) {
2801	+ special.remove.call( elem, handleObj );
2802	+ }
2803	+ }
2804	+
2805	+ if ( pos != null ) {
2806	+ break;
2807	+ }
2808	+ }
2809	+ }
2810	+
2811	+ // remove generic event handler if no more handlers exist
2812	+ if ( eventType.length === 0 \|\| pos != null && eventType.length === 1 ) {
2813	+ if ( !special.teardown \|\| special.teardown.call( elem, namespaces ) === false ) {
2814	+ jQuery.removeEvent( elem, type, elemData.handle );
2815	+ }
2816	+
2817	+ ret = null;
2818	+ delete events[ type ];
2819	+ }
2820	+ }
2821	+
2822	+ // Remove the expando if it's no longer used
2823	+ if ( jQuery.isEmptyObject( events ) ) {
2824	+ var handle = elemData.handle;
2825	+ if ( handle ) {
2826	+ handle.elem = null;
2827	+ }
2828	+
2829	+ delete elemData.events;
2830	+ delete elemData.handle;
2831	+
2832	+ if ( jQuery.isEmptyObject( elemData ) ) {
2833	+ jQuery.removeData( elem, undefined, true );
2834	+ }
2835	+ }
2836	+ },
2837	+
2838	+ // Events that are safe to short-circuit if no handlers are attached.
2839	+ // Native DOM events should not be added, they may have inline handlers.
2840	+ customEvent: {
2841	+ "getData": true,
2842	+ "setData": true,
2843	+ "changeData": true
2844	+ },
2845	+
2846	+ trigger: function( event, data, elem, onlyHandlers ) {
2847	+ // Event object or event type
2848	+ var type = event.type \|\| event,
2849	+ namespaces = [],
2850	+ exclusive;
2851	+
2852	+ if ( type.indexOf("!") >= 0 ) {
2853	+ // Exclusive events trigger only for the exact event (no namespaces)
2854	+ type = type.slice(0, -1);
2855	+ exclusive = true;
2856	+ }
2857	+
2858	+ if ( type.indexOf(".") >= 0 ) {
2859	+ // Namespaced trigger; create a regexp to match event type in handle()
2860	+ namespaces = type.split(".");
2861	+ type = namespaces.shift();
2862	+ namespaces.sort();
2863	+ }
2864	+
2865	+ if ( (!elem \|\| jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2866	+ // No jQuery handlers for this event type, and it can't have inline handlers
2867	+ return;
2868	+ }
2869	+
2870	+ // Caller can pass in an Event, Object, or just an event type string
2871	+ event = typeof event === "object" ?
2872	+ // jQuery.Event object
2873	+ event[ jQuery.expando ] ? event :
2874	+ // Object literal
2875	+ new jQuery.Event( type, event ) :
2876	+ // Just the event type (string)
2877	+ new jQuery.Event( type );
2878	+
2879	+ event.type = type;
2880	+ event.exclusive = exclusive;
2881	+ event.namespace = namespaces.join(".");
2882	+ event.namespace_re = new RegExp("(^\|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.\|$)");
2883	+
2884	+ // triggerHandler() and global events don't bubble or run the default action
2885	+ if ( onlyHandlers \|\| !elem ) {
2886	+ event.preventDefault();
2887	+ event.stopPropagation();
2888	+ }
2889	+
2890	+ // Handle a global trigger
2891	+ if ( !elem ) {
2892	+ // TODO: Stop taunting the data cache; remove global events and always attach to document
2893	+ jQuery.each( jQuery.cache, function() {
2894	+ // internalKey variable is just used to make it easier to find
2895	+ // and potentially change this stuff later; currently it just
2896	+ // points to jQuery.expando
2897	+ var internalKey = jQuery.expando,
2898	+ internalCache = this[ internalKey ];
2899	+ if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2900	+ jQuery.event.trigger( event, data, internalCache.handle.elem );
2901	+ }
2902	+ });
2903	+ return;
2904	+ }
2905	+
2906	+ // Don't do events on text and comment nodes
2907	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 8 ) {
2908	+ return;
2909	+ }
2910	+
2911	+ // Clean up the event in case it is being reused
2912	+ event.result = undefined;
2913	+ event.target = elem;
2914	+
2915	+ // Clone any incoming data and prepend the event, creating the handler arg list
2916	+ data = data != null ? jQuery.makeArray( data ) : [];
2917	+ data.unshift( event );
2918	+
2919	+ var cur = elem,
2920	+ // IE doesn't like method names with a colon (#3533, #8272)
2921	+ ontype = type.indexOf(":") < 0 ? "on" + type : "";
2922	+
2923	+ // Fire event on the current element, then bubble up the DOM tree
2924	+ do {
2925	+ var handle = jQuery._data( cur, "handle" );
2926	+
2927	+ event.currentTarget = cur;
2928	+ if ( handle ) {
2929	+ handle.apply( cur, data );
2930	+ }
2931	+
2932	+ // Trigger an inline bound script
2933	+ if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2934	+ event.result = false;
2935	+ event.preventDefault();
2936	+ }
2937	+
2938	+ // Bubble up to document, then to window
2939	+ cur = cur.parentNode \|\| cur.ownerDocument \|\| cur === event.target.ownerDocument && window;
2940	+ } while ( cur && !event.isPropagationStopped() );
2941	+
2942	+ // If nobody prevented the default action, do it now
2943	+ if ( !event.isDefaultPrevented() ) {
2944	+ var old,
2945	+ special = jQuery.event.special[ type ] \|\| {};
2946	+
2947	+ if ( (!special._default \|\| special._default.call( elem.ownerDocument, event ) === false) &&
2948	+ !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2949	+
2950	+ // Call a native DOM method on the target with the same name name as the event.
2951	+ // Can't use an .isFunction)() check here because IE6/7 fails that test.
2952	+ // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2953	+ try {
2954	+ if ( ontype && elem[ type ] ) {
2955	+ // Don't re-trigger an onFOO event when we call its FOO() method
2956	+ old = elem[ ontype ];
2957	+
2958	+ if ( old ) {
2959	+ elem[ ontype ] = null;
2960	+ }
2961	+
2962	+ jQuery.event.triggered = type;
2963	+ elem[ type ]();
2964	+ }
2965	+ } catch ( ieError ) {}
2966	+
2967	+ if ( old ) {
2968	+ elem[ ontype ] = old;
2969	+ }
2970	+
2971	+ jQuery.event.triggered = undefined;
2972	+ }
2973	+ }
2974	+
2975	+ return event.result;
2976	+ },
2977	+
2978	+ handle: function( event ) {
2979	+ event = jQuery.event.fix( event \|\| window.event );
2980	+ // Snapshot the handlers list since a called handler may add/remove events.
2981	+ var handlers = ((jQuery._data( this, "events" ) \|\| {})[ event.type ] \|\| []).slice(0),
2982	+ run_all = !event.exclusive && !event.namespace,
2983	+ args = Array.prototype.slice.call( arguments, 0 );
2984	+
2985	+ // Use the fix-ed Event rather than the (read-only) native event
2986	+ args[0] = event;
2987	+ event.currentTarget = this;
2988	+
2989	+ for ( var j = 0, l = handlers.length; j < l; j++ ) {
2990	+ var handleObj = handlers[ j ];
2991	+
2992	+ // Triggered event must 1) be non-exclusive and have no namespace, or
2993	+ // 2) have namespace(s) a subset or equal to those in the bound event.
2994	+ if ( run_all \|\| event.namespace_re.test( handleObj.namespace ) ) {
2995	+ // Pass in a reference to the handler function itself
2996	+ // So that we can later remove it
2997	+ event.handler = handleObj.handler;
2998	+ event.data = handleObj.data;
2999	+ event.handleObj = handleObj;
3000	+
3001	+ var ret = handleObj.handler.apply( this, args );
3002	+
3003	+ if ( ret !== undefined ) {
3004	+ event.result = ret;
3005	+ if ( ret === false ) {
3006	+ event.preventDefault();
3007	+ event.stopPropagation();
3008	+ }
3009	+ }
3010	+
3011	+ if ( event.isImmediatePropagationStopped() ) {
3012	+ break;
3013	+ }
3014	+ }
3015	+ }
3016	+ return event.result;
3017	+ },
3018	+
3019	+ props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
3020	+
3021	+ fix: function( event ) {
3022	+ if ( event[ jQuery.expando ] ) {
3023	+ return event;
3024	+ }
3025	+
3026	+ // store a copy of the original event object
3027	+ // and "clone" to set read-only properties
3028	+ var originalEvent = event;
3029	+ event = jQuery.Event( originalEvent );
3030	+
3031	+ for ( var i = this.props.length, prop; i; ) {
3032	+ prop = this.props[ --i ];
3033	+ event[ prop ] = originalEvent[ prop ];
3034	+ }
3035	+
3036	+ // Fix target property, if necessary
3037	+ if ( !event.target ) {
3038	+ // Fixes #1925 where srcElement might not be defined either
3039	+ event.target = event.srcElement \|\| document;
3040	+ }
3041	+
3042	+ // check if target is a textnode (safari)
3043	+ if ( event.target.nodeType === 3 ) {
3044	+ event.target = event.target.parentNode;
3045	+ }
3046	+
3047	+ // Add relatedTarget, if necessary
3048	+ if ( !event.relatedTarget && event.fromElement ) {
3049	+ event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
3050	+ }
3051	+
3052	+ // Calculate pageX/Y if missing and clientX/Y available
3053	+ if ( event.pageX == null && event.clientX != null ) {
3054	+ var eventDocument = event.target.ownerDocument \|\| document,
3055	+ doc = eventDocument.documentElement,
3056	+ body = eventDocument.body;
3057	+
3058	+ event.pageX = event.clientX + (doc && doc.scrollLeft \|\| body && body.scrollLeft \|\| 0) - (doc && doc.clientLeft \|\| body && body.clientLeft \|\| 0);
3059	+ event.pageY = event.clientY + (doc && doc.scrollTop \|\| body && body.scrollTop \|\| 0) - (doc && doc.clientTop \|\| body && body.clientTop \|\| 0);
3060	+ }
3061	+
3062	+ // Add which for key events
3063	+ if ( event.which == null && (event.charCode != null \|\| event.keyCode != null) ) {
3064	+ event.which = event.charCode != null ? event.charCode : event.keyCode;
3065	+ }
3066	+
3067	+ // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
3068	+ if ( !event.metaKey && event.ctrlKey ) {
3069	+ event.metaKey = event.ctrlKey;
3070	+ }
3071	+
3072	+ // Add which for click: 1 === left; 2 === middle; 3 === right
3073	+ // Note: button is not normalized, so don't use it
3074	+ if ( !event.which && event.button !== undefined ) {
3075	+ event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3076	+ }
3077	+
3078	+ return event;
3079	+ },
3080	+
3081	+ // Deprecated, use jQuery.guid instead
3082	+ guid: 1E8,
3083	+
3084	+ // Deprecated, use jQuery.proxy instead
3085	+ proxy: jQuery.proxy,
3086	+
3087	+ special: {
3088	+ ready: {
3089	+ // Make sure the ready event is setup
3090	+ setup: jQuery.bindReady,
3091	+ teardown: jQuery.noop
3092	+ },
3093	+
3094	+ live: {
3095	+ add: function( handleObj ) {
3096	+ jQuery.event.add( this,
3097	+ liveConvert( handleObj.origType, handleObj.selector ),
3098	+ jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3099	+ },
3100	+
3101	+ remove: function( handleObj ) {
3102	+ jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3103	+ }
3104	+ },
3105	+
3106	+ beforeunload: {
3107	+ setup: function( data, namespaces, eventHandle ) {
3108	+ // We only want to do this special case on windows
3109	+ if ( jQuery.isWindow( this ) ) {
3110	+ this.onbeforeunload = eventHandle;
3111	+ }
3112	+ },
3113	+
3114	+ teardown: function( namespaces, eventHandle ) {
3115	+ if ( this.onbeforeunload === eventHandle ) {
3116	+ this.onbeforeunload = null;
3117	+ }
3118	+ }
3119	+ }
3120	+ }
3121	+ };
3122	+
3123	+ jQuery.removeEvent = document.removeEventListener ?
3124	+ function( elem, type, handle ) {
3125	+ if ( elem.removeEventListener ) {
3126	+ elem.removeEventListener( type, handle, false );
3127	+ }
3128	+ } :
3129	+ function( elem, type, handle ) {
3130	+ if ( elem.detachEvent ) {
3131	+ elem.detachEvent( "on" + type, handle );
3132	+ }
3133	+ };
3134	+
3135	+ jQuery.Event = function( src, props ) {
3136	+ // Allow instantiation without the 'new' keyword
3137	+ if ( !this.preventDefault ) {
3138	+ return new jQuery.Event( src, props );
3139	+ }
3140	+
3141	+ // Event object
3142	+ if ( src && src.type ) {
3143	+ this.originalEvent = src;
3144	+ this.type = src.type;
3145	+
3146	+ // Events bubbling up the document may have been marked as prevented
3147	+ // by a handler lower down the tree; reflect the correct value.
3148	+ this.isDefaultPrevented = (src.defaultPrevented \|\| src.returnValue === false \|\|
3149	+ src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3150	+
3151	+ // Event type
3152	+ } else {
3153	+ this.type = src;
3154	+ }
3155	+
3156	+ // Put explicitly provided properties onto the event object
3157	+ if ( props ) {
3158	+ jQuery.extend( this, props );
3159	+ }
3160	+
3161	+ // timeStamp is buggy for some events on Firefox(#3843)
3162	+ // So we won't rely on the native value
3163	+ this.timeStamp = jQuery.now();
3164	+
3165	+ // Mark it as fixed
3166	+ this[ jQuery.expando ] = true;
3167	+ };
3168	+
3169	+ function returnFalse() {
3170	+ return false;
3171	+ }
3172	+ function returnTrue() {
3173	+ return true;
3174	+ }
3175	+
3176	+ // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3177	+ // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3178	+ jQuery.Event.prototype = {
3179	+ preventDefault: function() {
3180	+ this.isDefaultPrevented = returnTrue;
3181	+
3182	+ var e = this.originalEvent;
3183	+ if ( !e ) {
3184	+ return;
3185	+ }
3186	+
3187	+ // if preventDefault exists run it on the original event
3188	+ if ( e.preventDefault ) {
3189	+ e.preventDefault();
3190	+
3191	+ // otherwise set the returnValue property of the original event to false (IE)
3192	+ } else {
3193	+ e.returnValue = false;
3194	+ }
3195	+ },
3196	+ stopPropagation: function() {
3197	+ this.isPropagationStopped = returnTrue;
3198	+
3199	+ var e = this.originalEvent;
3200	+ if ( !e ) {
3201	+ return;
3202	+ }
3203	+ // if stopPropagation exists run it on the original event
3204	+ if ( e.stopPropagation ) {
3205	+ e.stopPropagation();
3206	+ }
3207	+ // otherwise set the cancelBubble property of the original event to true (IE)
3208	+ e.cancelBubble = true;
3209	+ },
3210	+ stopImmediatePropagation: function() {
3211	+ this.isImmediatePropagationStopped = returnTrue;
3212	+ this.stopPropagation();
3213	+ },
3214	+ isDefaultPrevented: returnFalse,
3215	+ isPropagationStopped: returnFalse,
3216	+ isImmediatePropagationStopped: returnFalse
3217	+ };
3218	+
3219	+ // Checks if an event happened on an element within another element
3220	+ // Used in jQuery.event.special.mouseenter and mouseleave handlers
3221	+ var withinElement = function( event ) {
3222	+
3223	+ // Check if mouse(over\|out) are still within the same parent element
3224	+ var related = event.relatedTarget,
3225	+ inside = false,
3226	+ eventType = event.type;
3227	+
3228	+ event.type = event.data;
3229	+
3230	+ if ( related !== this ) {
3231	+
3232	+ if ( related ) {
3233	+ inside = jQuery.contains( this, related );
3234	+ }
3235	+
3236	+ if ( !inside ) {
3237	+
3238	+ jQuery.event.handle.apply( this, arguments );
3239	+
3240	+ event.type = eventType;
3241	+ }
3242	+ }
3243	+ },
3244	+
3245	+ // In case of event delegation, we only need to rename the event.type,
3246	+ // liveHandler will take care of the rest.
3247	+ delegate = function( event ) {
3248	+ event.type = event.data;
3249	+ jQuery.event.handle.apply( this, arguments );
3250	+ };
3251	+
3252	+ // Create mouseenter and mouseleave events
3253	+ jQuery.each({
3254	+ mouseenter: "mouseover",
3255	+ mouseleave: "mouseout"
3256	+ }, function( orig, fix ) {
3257	+ jQuery.event.special[ orig ] = {
3258	+ setup: function( data ) {
3259	+ jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
3260	+ },
3261	+ teardown: function( data ) {
3262	+ jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
3263	+ }
3264	+ };
3265	+ });
3266	+
3267	+ // submit delegation
3268	+ if ( !jQuery.support.submitBubbles ) {
3269	+
3270	+ jQuery.event.special.submit = {
3271	+ setup: function( data, namespaces ) {
3272	+ if ( !jQuery.nodeName( this, "form" ) ) {
3273	+ jQuery.event.add(this, "click.specialSubmit", function( e ) {
3274	+ // Avoid triggering error on non-existent type attribute in IE VML (#7071)
3275	+ var elem = e.target,
3276	+ type = jQuery.nodeName( elem, "input" ) \|\| jQuery.nodeName( elem, "button" ) ? elem.type : "";
3277	+
3278	+ if ( (type === "submit" \|\| type === "image") && jQuery( elem ).closest("form").length ) {
3279	+ trigger( "submit", this, arguments );
3280	+ }
3281	+ });
3282	+
3283	+ jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
3284	+ var elem = e.target,
3285	+ type = jQuery.nodeName( elem, "input" ) \|\| jQuery.nodeName( elem, "button" ) ? elem.type : "";
3286	+
3287	+ if ( (type === "text" \|\| type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
3288	+ trigger( "submit", this, arguments );
3289	+ }
3290	+ });
3291	+
3292	+ } else {
3293	+ return false;
3294	+ }
3295	+ },
3296	+
3297	+ teardown: function( namespaces ) {
3298	+ jQuery.event.remove( this, ".specialSubmit" );
3299	+ }
3300	+ };
3301	+
3302	+ }
3303	+
3304	+ // change delegation, happens here so we have bind.
3305	+ if ( !jQuery.support.changeBubbles ) {
3306	+
3307	+ var changeFilters,
3308	+
3309	+ getVal = function( elem ) {
3310	+ var type = jQuery.nodeName( elem, "input" ) ? elem.type : "",
3311	+ val = elem.value;
3312	+
3313	+ if ( type === "radio" \|\| type === "checkbox" ) {
3314	+ val = elem.checked;
3315	+
3316	+ } else if ( type === "select-multiple" ) {
3317	+ val = elem.selectedIndex > -1 ?
3318	+ jQuery.map( elem.options, function( elem ) {
3319	+ return elem.selected;
3320	+ }).join("-") :
3321	+ "";
3322	+
3323	+ } else if ( jQuery.nodeName( elem, "select" ) ) {
3324	+ val = elem.selectedIndex;
3325	+ }
3326	+
3327	+ return val;
3328	+ },
3329	+
3330	+ testChange = function testChange( e ) {
3331	+ var elem = e.target, data, val;
3332	+
3333	+ if ( !rformElems.test( elem.nodeName ) \|\| elem.readOnly ) {
3334	+ return;
3335	+ }
3336	+
3337	+ data = jQuery._data( elem, "_change_data" );
3338	+ val = getVal(elem);
3339	+
3340	+ // the current data will be also retrieved by beforeactivate
3341	+ if ( e.type !== "focusout" \|\| elem.type !== "radio" ) {
3342	+ jQuery._data( elem, "_change_data", val );
3343	+ }
3344	+
3345	+ if ( data === undefined \|\| val === data ) {
3346	+ return;
3347	+ }
3348	+
3349	+ if ( data != null \|\| val ) {
3350	+ e.type = "change";
3351	+ e.liveFired = undefined;
3352	+ jQuery.event.trigger( e, arguments[1], elem );
3353	+ }
3354	+ };
3355	+
3356	+ jQuery.event.special.change = {
3357	+ filters: {
3358	+ focusout: testChange,
3359	+
3360	+ beforedeactivate: testChange,
3361	+
3362	+ click: function( e ) {
3363	+ var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3364	+
3365	+ if ( type === "radio" \|\| type === "checkbox" \|\| jQuery.nodeName( elem, "select" ) ) {
3366	+ testChange.call( this, e );
3367	+ }
3368	+ },
3369	+
3370	+ // Change has to be called before submit
3371	+ // Keydown will be called before keypress, which is used in submit-event delegation
3372	+ keydown: function( e ) {
3373	+ var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3374	+
3375	+ if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) \|\|
3376	+ (e.keyCode === 32 && (type === "checkbox" \|\| type === "radio")) \|\|
3377	+ type === "select-multiple" ) {
3378	+ testChange.call( this, e );
3379	+ }
3380	+ },
3381	+
3382	+ // Beforeactivate happens also before the previous element is blurred
3383	+ // with this event you can't trigger a change event, but you can store
3384	+ // information
3385	+ beforeactivate: function( e ) {
3386	+ var elem = e.target;
3387	+ jQuery._data( elem, "_change_data", getVal(elem) );
3388	+ }
3389	+ },
3390	+
3391	+ setup: function( data, namespaces ) {
3392	+ if ( this.type === "file" ) {
3393	+ return false;
3394	+ }
3395	+
3396	+ for ( var type in changeFilters ) {
3397	+ jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
3398	+ }
3399	+
3400	+ return rformElems.test( this.nodeName );
3401	+ },
3402	+
3403	+ teardown: function( namespaces ) {
3404	+ jQuery.event.remove( this, ".specialChange" );
3405	+
3406	+ return rformElems.test( this.nodeName );
3407	+ }
3408	+ };
3409	+
3410	+ changeFilters = jQuery.event.special.change.filters;
3411	+
3412	+ // Handle when the input is .focus()'d
3413	+ changeFilters.focus = changeFilters.beforeactivate;
3414	+ }
3415	+
3416	+ function trigger( type, elem, args ) {
3417	+ // Piggyback on a donor event to simulate a different one.
3418	+ // Fake originalEvent to avoid donor's stopPropagation, but if the
3419	+ // simulated event prevents default then we do the same on the donor.
3420	+ // Don't pass args or remember liveFired; they apply to the donor event.
3421	+ var event = jQuery.extend( {}, args[ 0 ] );
3422	+ event.type = type;
3423	+ event.originalEvent = {};
3424	+ event.liveFired = undefined;
3425	+ jQuery.event.handle.call( elem, event );
3426	+ if ( event.isDefaultPrevented() ) {
3427	+ args[ 0 ].preventDefault();
3428	+ }
3429	+ }
3430	+
3431	+ // Create "bubbling" focus and blur events
3432	+ if ( !jQuery.support.focusinBubbles ) {
3433	+ jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3434	+
3435	+ // Attach a single capturing handler while someone wants focusin/focusout
3436	+ var attaches = 0;
3437	+
3438	+ jQuery.event.special[ fix ] = {
3439	+ setup: function() {
3440	+ if ( attaches++ === 0 ) {
3441	+ document.addEventListener( orig, handler, true );
3442	+ }
3443	+ },
3444	+ teardown: function() {
3445	+ if ( --attaches === 0 ) {
3446	+ document.removeEventListener( orig, handler, true );
3447	+ }
3448	+ }
3449	+ };
3450	+
3451	+ function handler( donor ) {
3452	+ // Donor event is always a native one; fix it and switch its type.
3453	+ // Let focusin/out handler cancel the donor focus/blur event.
3454	+ var e = jQuery.event.fix( donor );
3455	+ e.type = fix;
3456	+ e.originalEvent = {};
3457	+ jQuery.event.trigger( e, null, e.target );
3458	+ if ( e.isDefaultPrevented() ) {
3459	+ donor.preventDefault();
3460	+ }
3461	+ }
3462	+ });
3463	+ }
3464	+
3465	+ jQuery.each(["bind", "one"], function( i, name ) {
3466	+ jQuery.fn[ name ] = function( type, data, fn ) {
3467	+ var handler;
3468	+
3469	+ // Handle object literals
3470	+ if ( typeof type === "object" ) {
3471	+ for ( var key in type ) {
3472	+ this[ name ](key, data, type[key], fn);
3473	+ }
3474	+ return this;
3475	+ }
3476	+
3477	+ if ( arguments.length === 2 \|\| data === false ) {
3478	+ fn = data;
3479	+ data = undefined;
3480	+ }
3481	+
3482	+ if ( name === "one" ) {
3483	+ handler = function( event ) {
3484	+ jQuery( this ).unbind( event, handler );
3485	+ return fn.apply( this, arguments );
3486	+ };
3487	+ handler.guid = fn.guid \|\| jQuery.guid++;
3488	+ } else {
3489	+ handler = fn;
3490	+ }
3491	+
3492	+ if ( type === "unload" && name !== "one" ) {
3493	+ this.one( type, data, fn );
3494	+
3495	+ } else {
3496	+ for ( var i = 0, l = this.length; i < l; i++ ) {
3497	+ jQuery.event.add( this[i], type, handler, data );
3498	+ }
3499	+ }
3500	+
3501	+ return this;
3502	+ };
3503	+ });
3504	+
3505	+ jQuery.fn.extend({
3506	+ unbind: function( type, fn ) {
3507	+ // Handle object literals
3508	+ if ( typeof type === "object" && !type.preventDefault ) {
3509	+ for ( var key in type ) {
3510	+ this.unbind(key, type[key]);
3511	+ }
3512	+
3513	+ } else {
3514	+ for ( var i = 0, l = this.length; i < l; i++ ) {
3515	+ jQuery.event.remove( this[i], type, fn );
3516	+ }
3517	+ }
3518	+
3519	+ return this;
3520	+ },
3521	+
3522	+ delegate: function( selector, types, data, fn ) {
3523	+ return this.live( types, data, fn, selector );
3524	+ },
3525	+
3526	+ undelegate: function( selector, types, fn ) {
3527	+ if ( arguments.length === 0 ) {
3528	+ return this.unbind( "live" );
3529	+
3530	+ } else {
3531	+ return this.die( types, null, fn, selector );
3532	+ }
3533	+ },
3534	+
3535	+ trigger: function( type, data ) {
3536	+ return this.each(function() {
3537	+ jQuery.event.trigger( type, data, this );
3538	+ });
3539	+ },
3540	+
3541	+ triggerHandler: function( type, data ) {
3542	+ if ( this[0] ) {
3543	+ return jQuery.event.trigger( type, data, this[0], true );
3544	+ }
3545	+ },
3546	+
3547	+ toggle: function( fn ) {
3548	+ // Save reference to arguments for access in closure
3549	+ var args = arguments,
3550	+ guid = fn.guid \|\| jQuery.guid++,
3551	+ i = 0,
3552	+ toggler = function( event ) {
3553	+ // Figure out which function to execute
3554	+ var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) \|\| 0 ) % i;
3555	+ jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3556	+
3557	+ // Make sure that clicks stop
3558	+ event.preventDefault();
3559	+
3560	+ // and execute the function
3561	+ return args[ lastToggle ].apply( this, arguments ) \|\| false;
3562	+ };
3563	+
3564	+ // link all the functions, so any of them can unbind this click handler
3565	+ toggler.guid = guid;
3566	+ while ( i < args.length ) {
3567	+ args[ i++ ].guid = guid;
3568	+ }
3569	+
3570	+ return this.click( toggler );
3571	+ },
3572	+
3573	+ hover: function( fnOver, fnOut ) {
3574	+ return this.mouseenter( fnOver ).mouseleave( fnOut \|\| fnOver );
3575	+ }
3576	+ });
3577	+
3578	+ var liveMap = {
3579	+ focus: "focusin",
3580	+ blur: "focusout",
3581	+ mouseenter: "mouseover",
3582	+ mouseleave: "mouseout"
3583	+ };
3584	+
3585	+ jQuery.each(["live", "die"], function( i, name ) {
3586	+ jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3587	+ var type, i = 0, match, namespaces, preType,
3588	+ selector = origSelector \|\| this.selector,
3589	+ context = origSelector ? this : jQuery( this.context );
3590	+
3591	+ if ( typeof types === "object" && !types.preventDefault ) {
3592	+ for ( var key in types ) {
3593	+ context[ name ]( key, data, types[key], selector );
3594	+ }
3595	+
3596	+ return this;
3597	+ }
3598	+
3599	+ if ( name === "die" && !types &&
3600	+ origSelector && origSelector.charAt(0) === "." ) {
3601	+
3602	+ context.unbind( origSelector );
3603	+
3604	+ return this;
3605	+ }
3606	+
3607	+ if ( data === false \|\| jQuery.isFunction( data ) ) {
3608	+ fn = data \|\| returnFalse;
3609	+ data = undefined;
3610	+ }
3611	+
3612	+ types = (types \|\| "").split(" ");
3613	+
3614	+ while ( (type = types[ i++ ]) != null ) {
3615	+ match = rnamespaces.exec( type );
3616	+ namespaces = "";
3617	+
3618	+ if ( match ) {
3619	+ namespaces = match[0];
3620	+ type = type.replace( rnamespaces, "" );
3621	+ }
3622	+
3623	+ if ( type === "hover" ) {
3624	+ types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3625	+ continue;
3626	+ }
3627	+
3628	+ preType = type;
3629	+
3630	+ if ( liveMap[ type ] ) {
3631	+ types.push( liveMap[ type ] + namespaces );
3632	+ type = type + namespaces;
3633	+
3634	+ } else {
3635	+ type = (liveMap[ type ] \|\| type) + namespaces;
3636	+ }
3637	+
3638	+ if ( name === "live" ) {
3639	+ // bind live handler
3640	+ for ( var j = 0, l = context.length; j < l; j++ ) {
3641	+ jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3642	+ { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3643	+ }
3644	+
3645	+ } else {
3646	+ // unbind live handler
3647	+ context.unbind( "live." + liveConvert( type, selector ), fn );
3648	+ }
3649	+ }
3650	+
3651	+ return this;
3652	+ };
3653	+ });
3654	+
3655	+ function liveHandler( event ) {
3656	+ var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3657	+ elems = [],
3658	+ selectors = [],
3659	+ events = jQuery._data( this, "events" );
3660	+
3661	+ // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3662	+ if ( event.liveFired === this \|\| !events \|\| !events.live \|\| event.target.disabled \|\| event.button && event.type === "click" ) {
3663	+ return;
3664	+ }
3665	+
3666	+ if ( event.namespace ) {
3667	+ namespace = new RegExp("(^\|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.\|$)");
3668	+ }
3669	+
3670	+ event.liveFired = this;
3671	+
3672	+ var live = events.live.slice(0);
3673	+
3674	+ for ( j = 0; j < live.length; j++ ) {
3675	+ handleObj = live[j];
3676	+
3677	+ if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3678	+ selectors.push( handleObj.selector );
3679	+
3680	+ } else {
3681	+ live.splice( j--, 1 );
3682	+ }
3683	+ }
3684	+
3685	+ match = jQuery( event.target ).closest( selectors, event.currentTarget );
3686	+
3687	+ for ( i = 0, l = match.length; i < l; i++ ) {
3688	+ close = match[i];
3689	+
3690	+ for ( j = 0; j < live.length; j++ ) {
3691	+ handleObj = live[j];
3692	+
3693	+ if ( close.selector === handleObj.selector && (!namespace \|\| namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
3694	+ elem = close.elem;
3695	+ related = null;
3696	+
3697	+ // Those two events require additional checking
3698	+ if ( handleObj.preType === "mouseenter" \|\| handleObj.preType === "mouseleave" ) {
3699	+ event.type = handleObj.preType;
3700	+ related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3701	+
3702	+ // Make sure not to accidentally match a child element with the same selector
3703	+ if ( related && jQuery.contains( elem, related ) ) {
3704	+ related = elem;
3705	+ }
3706	+ }
3707	+
3708	+ if ( !related \|\| related !== elem ) {
3709	+ elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3710	+ }
3711	+ }
3712	+ }
3713	+ }
3714	+
3715	+ for ( i = 0, l = elems.length; i < l; i++ ) {
3716	+ match = elems[i];
3717	+
3718	+ if ( maxLevel && match.level > maxLevel ) {
3719	+ break;
3720	+ }
3721	+
3722	+ event.currentTarget = match.elem;
3723	+ event.data = match.handleObj.data;
3724	+ event.handleObj = match.handleObj;
3725	+
3726	+ ret = match.handleObj.origHandler.apply( match.elem, arguments );
3727	+
3728	+ if ( ret === false \|\| event.isPropagationStopped() ) {
3729	+ maxLevel = match.level;
3730	+
3731	+ if ( ret === false ) {
3732	+ stop = false;
3733	+ }
3734	+ if ( event.isImmediatePropagationStopped() ) {
3735	+ break;
3736	+ }
3737	+ }
3738	+ }
3739	+
3740	+ return stop;
3741	+ }
3742	+
3743	+ function liveConvert( type, selector ) {
3744	+ return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
3745	+ }
3746	+
3747	+ jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3748	+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3749	+ "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3750	+
3751	+ // Handle event binding
3752	+ jQuery.fn[ name ] = function( data, fn ) {
3753	+ if ( fn == null ) {
3754	+ fn = data;
3755	+ data = null;
3756	+ }
3757	+
3758	+ return arguments.length > 0 ?
3759	+ this.bind( name, data, fn ) :
3760	+ this.trigger( name );
3761	+ };
3762	+
3763	+ if ( jQuery.attrFn ) {
3764	+ jQuery.attrFn[ name ] = true;
3765	+ }
3766	+ });
3767	+
3768	+
3769	+
3770	+ /*!
3771	+ * Sizzle CSS Selector Engine
3772	+ * Copyright 2011, The Dojo Foundation
3773	+ * Released under the MIT, BSD, and GPL Licenses.
3774	+ * More information: http://sizzlejs.com/
3775	+ */
3776	+ (function(){
3777	+
3778	+ var chunker = /((?:$(?:\([^()]+$\|[^()]+)+\)\|\[(?:\[[^\[\]]\]\|['"][^'"]['"]\|[^\[\]'"]+)+\]\|\\.\|[^ >+~,(\[\\]+)+\|[>+~])(\s,\s)?((?:.\|\r\|\n)*)/g,
3779	+ done = 0,
3780	+ toString = Object.prototype.toString,
3781	+ hasDuplicate = false,
3782	+ baseHasDuplicate = true,
3783	+ rBackslash = /\\/g,
3784	+ rNonWord = /\W/;
3785	+
3786	+ // Here we check if the JavaScript engine is using some sort of
3787	+ // optimization where it does not always call our comparision
3788	+ // function. If that is the case, discard the hasDuplicate value.
3789	+ // Thus far that includes Google Chrome.
3790	+ [0, 0].sort(function() {
3791	+ baseHasDuplicate = false;
3792	+ return 0;
3793	+ });
3794	+
3795	+ var Sizzle = function( selector, context, results, seed ) {
3796	+ results = results \|\| [];
3797	+ context = context \|\| document;
3798	+
3799	+ var origContext = context;
3800	+
3801	+ if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3802	+ return [];
3803	+ }
3804	+
3805	+ if ( !selector \|\| typeof selector !== "string" ) {
3806	+ return results;
3807	+ }
3808	+
3809	+ var m, set, checkSet, extra, ret, cur, pop, i,
3810	+ prune = true,
3811	+ contextXML = Sizzle.isXML( context ),
3812	+ parts = [],
3813	+ soFar = selector;
3814	+
3815	+ // Reset the position of the chunker regexp (start from head)
3816	+ do {
3817	+ chunker.exec( "" );
3818	+ m = chunker.exec( soFar );
3819	+
3820	+ if ( m ) {
3821	+ soFar = m[3];
3822	+
3823	+ parts.push( m[1] );
3824	+
3825	+ if ( m[2] ) {
3826	+ extra = m[3];
3827	+ break;
3828	+ }
3829	+ }
3830	+ } while ( m );
3831	+
3832	+ if ( parts.length > 1 && origPOS.exec( selector ) ) {
3833	+
3834	+ if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3835	+ set = posProcess( parts[0] + parts[1], context );
3836	+
3837	+ } else {
3838	+ set = Expr.relative[ parts[0] ] ?
3839	+ [ context ] :
3840	+ Sizzle( parts.shift(), context );
3841	+
3842	+ while ( parts.length ) {
3843	+ selector = parts.shift();
3844	+
3845	+ if ( Expr.relative[ selector ] ) {
3846	+ selector += parts.shift();
3847	+ }
3848	+
3849	+ set = posProcess( selector, set );
3850	+ }
3851	+ }
3852	+
3853	+ } else {
3854	+ // Take a shortcut and set the context if the root selector is an ID
3855	+ // (but not if it'll be faster if the inner selector is an ID)
3856	+ if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3857	+ Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3858	+
3859	+ ret = Sizzle.find( parts.shift(), context, contextXML );
3860	+ context = ret.expr ?
3861	+ Sizzle.filter( ret.expr, ret.set )[0] :
3862	+ ret.set[0];
3863	+ }
3864	+
3865	+ if ( context ) {
3866	+ ret = seed ?
3867	+ { expr: parts.pop(), set: makeArray(seed) } :
3868	+ Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" \|\| parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3869	+
3870	+ set = ret.expr ?
3871	+ Sizzle.filter( ret.expr, ret.set ) :
3872	+ ret.set;
3873	+
3874	+ if ( parts.length > 0 ) {
3875	+ checkSet = makeArray( set );
3876	+
3877	+ } else {
3878	+ prune = false;
3879	+ }
3880	+
3881	+ while ( parts.length ) {
3882	+ cur = parts.pop();
3883	+ pop = cur;
3884	+
3885	+ if ( !Expr.relative[ cur ] ) {
3886	+ cur = "";
3887	+ } else {
3888	+ pop = parts.pop();
3889	+ }
3890	+
3891	+ if ( pop == null ) {
3892	+ pop = context;
3893	+ }
3894	+
3895	+ Expr.relative[ cur ]( checkSet, pop, contextXML );
3896	+ }
3897	+
3898	+ } else {
3899	+ checkSet = parts = [];
3900	+ }
3901	+ }
3902	+
3903	+ if ( !checkSet ) {
3904	+ checkSet = set;
3905	+ }
3906	+
3907	+ if ( !checkSet ) {
3908	+ Sizzle.error( cur \|\| selector );
3909	+ }
3910	+
3911	+ if ( toString.call(checkSet) === "[object Array]" ) {
3912	+ if ( !prune ) {
3913	+ results.push.apply( results, checkSet );
3914	+
3915	+ } else if ( context && context.nodeType === 1 ) {
3916	+ for ( i = 0; checkSet[i] != null; i++ ) {
3917	+ if ( checkSet[i] && (checkSet[i] === true \|\| checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3918	+ results.push( set[i] );
3919	+ }
3920	+ }
3921	+
3922	+ } else {
3923	+ for ( i = 0; checkSet[i] != null; i++ ) {
3924	+ if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3925	+ results.push( set[i] );
3926	+ }
3927	+ }
3928	+ }
3929	+
3930	+ } else {
3931	+ makeArray( checkSet, results );
3932	+ }
3933	+
3934	+ if ( extra ) {
3935	+ Sizzle( extra, origContext, results, seed );
3936	+ Sizzle.uniqueSort( results );
3937	+ }
3938	+
3939	+ return results;
3940	+ };
3941	+
3942	+ Sizzle.uniqueSort = function( results ) {
3943	+ if ( sortOrder ) {
3944	+ hasDuplicate = baseHasDuplicate;
3945	+ results.sort( sortOrder );
3946	+
3947	+ if ( hasDuplicate ) {
3948	+ for ( var i = 1; i < results.length; i++ ) {
3949	+ if ( results[i] === results[ i - 1 ] ) {
3950	+ results.splice( i--, 1 );
3951	+ }
3952	+ }
3953	+ }
3954	+ }
3955	+
3956	+ return results;
3957	+ };
3958	+
3959	+ Sizzle.matches = function( expr, set ) {
3960	+ return Sizzle( expr, null, null, set );
3961	+ };
3962	+
3963	+ Sizzle.matchesSelector = function( node, expr ) {
3964	+ return Sizzle( expr, null, null, [node] ).length > 0;
3965	+ };
3966	+
3967	+ Sizzle.find = function( expr, context, isXML ) {
3968	+ var set;
3969	+
3970	+ if ( !expr ) {
3971	+ return [];
3972	+ }
3973	+
3974	+ for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3975	+ var match,
3976	+ type = Expr.order[i];
3977	+
3978	+ if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3979	+ var left = match[1];
3980	+ match.splice( 1, 1 );
3981	+
3982	+ if ( left.substr( left.length - 1 ) !== "\\" ) {
3983	+ match[1] = (match[1] \|\| "").replace( rBackslash, "" );
3984	+ set = Expr.find[ type ]( match, context, isXML );
3985	+
3986	+ if ( set != null ) {
3987	+ expr = expr.replace( Expr.match[ type ], "" );
3988	+ break;
3989	+ }
3990	+ }
3991	+ }
3992	+ }
3993	+
3994	+ if ( !set ) {
3995	+ set = typeof context.getElementsByTagName !== "undefined" ?
3996	+ context.getElementsByTagName( "*" ) :
3997	+ [];
3998	+ }
3999	+
4000	+ return { set: set, expr: expr };
4001	+ };
4002	+
4003	+ Sizzle.filter = function( expr, set, inplace, not ) {
4004	+ var match, anyFound,
4005	+ old = expr,
4006	+ result = [],
4007	+ curLoop = set,
4008	+ isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
4009	+
4010	+ while ( expr && set.length ) {
4011	+ for ( var type in Expr.filter ) {
4012	+ if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
4013	+ var found, item,
4014	+ filter = Expr.filter[ type ],
4015	+ left = match[1];
4016	+
4017	+ anyFound = false;
4018	+
4019	+ match.splice(1,1);
4020	+
4021	+ if ( left.substr( left.length - 1 ) === "\\" ) {
4022	+ continue;
4023	+ }
4024	+
4025	+ if ( curLoop === result ) {
4026	+ result = [];
4027	+ }
4028	+
4029	+ if ( Expr.preFilter[ type ] ) {
4030	+ match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
4031	+
4032	+ if ( !match ) {
4033	+ anyFound = found = true;
4034	+
4035	+ } else if ( match === true ) {
4036	+ continue;
4037	+ }
4038	+ }
4039	+
4040	+ if ( match ) {
4041	+ for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
4042	+ if ( item ) {
4043	+ found = filter( item, match, i, curLoop );
4044	+ var pass = not ^ !!found;
4045	+
4046	+ if ( inplace && found != null ) {
4047	+ if ( pass ) {
4048	+ anyFound = true;
4049	+
4050	+ } else {
4051	+ curLoop[i] = false;
4052	+ }
4053	+
4054	+ } else if ( pass ) {
4055	+ result.push( item );
4056	+ anyFound = true;
4057	+ }
4058	+ }
4059	+ }
4060	+ }
4061	+
4062	+ if ( found !== undefined ) {
4063	+ if ( !inplace ) {
4064	+ curLoop = result;
4065	+ }
4066	+
4067	+ expr = expr.replace( Expr.match[ type ], "" );
4068	+
4069	+ if ( !anyFound ) {
4070	+ return [];
4071	+ }
4072	+
4073	+ break;
4074	+ }
4075	+ }
4076	+ }
4077	+
4078	+ // Improper expression
4079	+ if ( expr === old ) {
4080	+ if ( anyFound == null ) {
4081	+ Sizzle.error( expr );
4082	+
4083	+ } else {
4084	+ break;
4085	+ }
4086	+ }
4087	+
4088	+ old = expr;
4089	+ }
4090	+
4091	+ return curLoop;
4092	+ };
4093	+
4094	+ Sizzle.error = function( msg ) {
4095	+ throw "Syntax error, unrecognized expression: " + msg;
4096	+ };
4097	+
4098	+ var Expr = Sizzle.selectors = {
4099	+ order: [ "ID", "NAME", "TAG" ],
4100	+
4101	+ match: {
4102	+ ID: /#((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
4103	+ CLASS: /\.((?:[\w\u00c0-\uFFFF\-]\|\\.)+)/,
4104	+ NAME: /\[name=['"]((?:[\w\u00c0-\uFFFF\-]\|\\.)+)['"]\]/,
4105	+ ATTR: /\[\s((?:[\w\u00c0-\uFFFF\-]\|\\.)+)\s(?:(\S?=)\s(?:(['"])(.?)\3\|(#?(?:[\w\u00c0-\uFFFF\-]\|\\.))\|)\|)\s\]/,
4106	+ TAG: /^((?:[\w\u00c0-\uFFFF\*\-]\|\\.)+)/,
4107	+ CHILD: /:(only\|nth\|last\|first)-child(?:$\s(even\|odd\|(?:[+\-]?\d+\|(?:[+\-]?\d)?n\s(?:[+\-]\s\d+)?))\s*$)?/,
4108	+ POS: /:(nth\|eq\|gt\|lt\|first\|last\|even\|odd)(?:$(\d*)$)?(?=[^\-]\|$)/,
4109	+ PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]\|\\.)+)(?:$(['"]?)((?:\([^$]+\)\|[^]*)+)\2\))?/
4110	+ },
4111	+
4112	+ leftMatch: {},
4113	+
4114	+ attrMap: {
4115	+ "class": "className",
4116	+ "for": "htmlFor"
4117	+ },
4118	+
4119	+ attrHandle: {
4120	+ href: function( elem ) {
4121	+ return elem.getAttribute( "href" );
4122	+ },
4123	+ type: function( elem ) {
4124	+ return elem.getAttribute( "type" );
4125	+ }
4126	+ },
4127	+
4128	+ relative: {
4129	+ "+": function(checkSet, part){
4130	+ var isPartStr = typeof part === "string",
4131	+ isTag = isPartStr && !rNonWord.test( part ),
4132	+ isPartStrNotTag = isPartStr && !isTag;
4133	+
4134	+ if ( isTag ) {
4135	+ part = part.toLowerCase();
4136	+ }
4137	+
4138	+ for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4139	+ if ( (elem = checkSet[i]) ) {
4140	+ while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4141	+
4142	+ checkSet[i] = isPartStrNotTag \|\| elem && elem.nodeName.toLowerCase() === part ?
4143	+ elem \|\| false :
4144	+ elem === part;
4145	+ }
4146	+ }
4147	+
4148	+ if ( isPartStrNotTag ) {
4149	+ Sizzle.filter( part, checkSet, true );
4150	+ }
4151	+ },
4152	+
4153	+ ">": function( checkSet, part ) {
4154	+ var elem,
4155	+ isPartStr = typeof part === "string",
4156	+ i = 0,
4157	+ l = checkSet.length;
4158	+
4159	+ if ( isPartStr && !rNonWord.test( part ) ) {
4160	+ part = part.toLowerCase();
4161	+
4162	+ for ( ; i < l; i++ ) {
4163	+ elem = checkSet[i];
4164	+
4165	+ if ( elem ) {
4166	+ var parent = elem.parentNode;
4167	+ checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4168	+ }
4169	+ }
4170	+
4171	+ } else {
4172	+ for ( ; i < l; i++ ) {
4173	+ elem = checkSet[i];
4174	+
4175	+ if ( elem ) {
4176	+ checkSet[i] = isPartStr ?
4177	+ elem.parentNode :
4178	+ elem.parentNode === part;
4179	+ }
4180	+ }
4181	+
4182	+ if ( isPartStr ) {
4183	+ Sizzle.filter( part, checkSet, true );
4184	+ }
4185	+ }
4186	+ },
4187	+
4188	+ "": function(checkSet, part, isXML){
4189	+ var nodeCheck,
4190	+ doneName = done++,
4191	+ checkFn = dirCheck;
4192	+
4193	+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
4194	+ part = part.toLowerCase();
4195	+ nodeCheck = part;
4196	+ checkFn = dirNodeCheck;
4197	+ }
4198	+
4199	+ checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4200	+ },
4201	+
4202	+ "~": function( checkSet, part, isXML ) {
4203	+ var nodeCheck,
4204	+ doneName = done++,
4205	+ checkFn = dirCheck;
4206	+
4207	+ if ( typeof part === "string" && !rNonWord.test( part ) ) {
4208	+ part = part.toLowerCase();
4209	+ nodeCheck = part;
4210	+ checkFn = dirNodeCheck;
4211	+ }
4212	+
4213	+ checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4214	+ }
4215	+ },
4216	+
4217	+ find: {
4218	+ ID: function( match, context, isXML ) {
4219	+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
4220	+ var m = context.getElementById(match[1]);
4221	+ // Check parentNode to catch when Blackberry 4.6 returns
4222	+ // nodes that are no longer in the document #6963
4223	+ return m && m.parentNode ? [m] : [];
4224	+ }
4225	+ },
4226	+
4227	+ NAME: function( match, context ) {
4228	+ if ( typeof context.getElementsByName !== "undefined" ) {
4229	+ var ret = [],
4230	+ results = context.getElementsByName( match[1] );
4231	+
4232	+ for ( var i = 0, l = results.length; i < l; i++ ) {
4233	+ if ( results[i].getAttribute("name") === match[1] ) {
4234	+ ret.push( results[i] );
4235	+ }
4236	+ }
4237	+
4238	+ return ret.length === 0 ? null : ret;
4239	+ }
4240	+ },
4241	+
4242	+ TAG: function( match, context ) {
4243	+ if ( typeof context.getElementsByTagName !== "undefined" ) {
4244	+ return context.getElementsByTagName( match[1] );
4245	+ }
4246	+ }
4247	+ },
4248	+ preFilter: {
4249	+ CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4250	+ match = " " + match[1].replace( rBackslash, "" ) + " ";
4251	+
4252	+ if ( isXML ) {
4253	+ return match;
4254	+ }
4255	+
4256	+ for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4257	+ if ( elem ) {
4258	+ if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4259	+ if ( !inplace ) {
4260	+ result.push( elem );
4261	+ }
4262	+
4263	+ } else if ( inplace ) {
4264	+ curLoop[i] = false;
4265	+ }
4266	+ }
4267	+ }
4268	+
4269	+ return false;
4270	+ },
4271	+
4272	+ ID: function( match ) {
4273	+ return match[1].replace( rBackslash, "" );
4274	+ },
4275	+
4276	+ TAG: function( match, curLoop ) {
4277	+ return match[1].replace( rBackslash, "" ).toLowerCase();
4278	+ },
4279	+
4280	+ CHILD: function( match ) {
4281	+ if ( match[1] === "nth" ) {
4282	+ if ( !match[2] ) {
4283	+ Sizzle.error( match[0] );
4284	+ }
4285	+
4286	+ match[2] = match[2].replace(/^\+\|\s*/g, '');
4287	+
4288	+ // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4289	+ var test = /(-?)(\d)(?:n([+\-]?\d))?/.exec(
4290	+ match[2] === "even" && "2n" \|\| match[2] === "odd" && "2n+1" \|\|
4291	+ !/\D/.test( match[2] ) && "0n+" + match[2] \|\| match[2]);
4292	+
4293	+ // calculate the numbers (first)n+(last) including if they are negative
4294	+ match[2] = (test[1] + (test[2] \|\| 1)) - 0;
4295	+ match[3] = test[3] - 0;
4296	+ }
4297	+ else if ( match[2] ) {
4298	+ Sizzle.error( match[0] );
4299	+ }
4300	+
4301	+ // TODO: Move to normal caching system
4302	+ match[0] = done++;
4303	+
4304	+ return match;
4305	+ },
4306	+
4307	+ ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4308	+ var name = match[1] = match[1].replace( rBackslash, "" );
4309	+
4310	+ if ( !isXML && Expr.attrMap[name] ) {
4311	+ match[1] = Expr.attrMap[name];
4312	+ }
4313	+
4314	+ // Handle if an un-quoted value was used
4315	+ match[4] = ( match[4] \|\| match[5] \|\| "" ).replace( rBackslash, "" );
4316	+
4317	+ if ( match[2] === "~=" ) {
4318	+ match[4] = " " + match[4] + " ";
4319	+ }
4320	+
4321	+ return match;
4322	+ },
4323	+
4324	+ PSEUDO: function( match, curLoop, inplace, result, not ) {
4325	+ if ( match[1] === "not" ) {
4326	+ // If we're dealing with a complex expression, or a simple one
4327	+ if ( ( chunker.exec(match[3]) \|\| "" ).length > 1 \|\| /^\w/.test(match[3]) ) {
4328	+ match[3] = Sizzle(match[3], null, null, curLoop);
4329	+
4330	+ } else {
4331	+ var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4332	+
4333	+ if ( !inplace ) {
4334	+ result.push.apply( result, ret );
4335	+ }
4336	+
4337	+ return false;
4338	+ }
4339	+
4340	+ } else if ( Expr.match.POS.test( match[0] ) \|\| Expr.match.CHILD.test( match[0] ) ) {
4341	+ return true;
4342	+ }
4343	+
4344	+ return match;
4345	+ },
4346	+
4347	+ POS: function( match ) {
4348	+ match.unshift( true );
4349	+
4350	+ return match;
4351	+ }
4352	+ },
4353	+
4354	+ filters: {
4355	+ enabled: function( elem ) {
4356	+ return elem.disabled === false && elem.type !== "hidden";
4357	+ },
4358	+
4359	+ disabled: function( elem ) {
4360	+ return elem.disabled === true;
4361	+ },
4362	+
4363	+ checked: function( elem ) {
4364	+ return elem.checked === true;
4365	+ },
4366	+
4367	+ selected: function( elem ) {
4368	+ // Accessing this property makes selected-by-default
4369	+ // options in Safari work properly
4370	+ if ( elem.parentNode ) {
4371	+ elem.parentNode.selectedIndex;
4372	+ }
4373	+
4374	+ return elem.selected === true;
4375	+ },
4376	+
4377	+ parent: function( elem ) {
4378	+ return !!elem.firstChild;
4379	+ },
4380	+
4381	+ empty: function( elem ) {
4382	+ return !elem.firstChild;
4383	+ },
4384	+
4385	+ has: function( elem, i, match ) {
4386	+ return !!Sizzle( match[3], elem ).length;
4387	+ },
4388	+
4389	+ header: function( elem ) {
4390	+ return (/h\d/i).test( elem.nodeName );
4391	+ },
4392	+
4393	+ text: function( elem ) {
4394	+ var attr = elem.getAttribute( "type" ), type = elem.type;
4395	+ // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4396	+ // use getAttribute instead to test this case
4397	+ return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type \|\| attr === null );
4398	+ },
4399	+
4400	+ radio: function( elem ) {
4401	+ return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4402	+ },
4403	+
4404	+ checkbox: function( elem ) {
4405	+ return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4406	+ },
4407	+
4408	+ file: function( elem ) {
4409	+ return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4410	+ },
4411	+
4412	+ password: function( elem ) {
4413	+ return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4414	+ },
4415	+
4416	+ submit: function( elem ) {
4417	+ var name = elem.nodeName.toLowerCase();
4418	+ return (name === "input" \|\| name === "button") && "submit" === elem.type;
4419	+ },
4420	+
4421	+ image: function( elem ) {
4422	+ return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4423	+ },
4424	+
4425	+ reset: function( elem ) {
4426	+ var name = elem.nodeName.toLowerCase();
4427	+ return (name === "input" \|\| name === "button") && "reset" === elem.type;
4428	+ },
4429	+
4430	+ button: function( elem ) {
4431	+ var name = elem.nodeName.toLowerCase();
4432	+ return name === "input" && "button" === elem.type \|\| name === "button";
4433	+ },
4434	+
4435	+ input: function( elem ) {
4436	+ return (/input\|select\|textarea\|button/i).test( elem.nodeName );
4437	+ },
4438	+
4439	+ focus: function( elem ) {
4440	+ return elem === elem.ownerDocument.activeElement;
4441	+ }
4442	+ },
4443	+ setFilters: {
4444	+ first: function( elem, i ) {
4445	+ return i === 0;
4446	+ },
4447	+
4448	+ last: function( elem, i, match, array ) {
4449	+ return i === array.length - 1;
4450	+ },
4451	+
4452	+ even: function( elem, i ) {
4453	+ return i % 2 === 0;
4454	+ },
4455	+
4456	+ odd: function( elem, i ) {
4457	+ return i % 2 === 1;
4458	+ },
4459	+
4460	+ lt: function( elem, i, match ) {
4461	+ return i < match[3] - 0;
4462	+ },
4463	+
4464	+ gt: function( elem, i, match ) {
4465	+ return i > match[3] - 0;
4466	+ },
4467	+
4468	+ nth: function( elem, i, match ) {
4469	+ return match[3] - 0 === i;
4470	+ },
4471	+
4472	+ eq: function( elem, i, match ) {
4473	+ return match[3] - 0 === i;
4474	+ }
4475	+ },
4476	+ filter: {
4477	+ PSEUDO: function( elem, match, i, array ) {
4478	+ var name = match[1],
4479	+ filter = Expr.filters[ name ];
4480	+
4481	+ if ( filter ) {
4482	+ return filter( elem, i, match, array );
4483	+
4484	+ } else if ( name === "contains" ) {
4485	+ return (elem.textContent \|\| elem.innerText \|\| Sizzle.getText([ elem ]) \|\| "").indexOf(match[3]) >= 0;
4486	+
4487	+ } else if ( name === "not" ) {
4488	+ var not = match[3];
4489	+
4490	+ for ( var j = 0, l = not.length; j < l; j++ ) {
4491	+ if ( not[j] === elem ) {
4492	+ return false;
4493	+ }
4494	+ }
4495	+
4496	+ return true;
4497	+
4498	+ } else {
4499	+ Sizzle.error( name );
4500	+ }
4501	+ },
4502	+
4503	+ CHILD: function( elem, match ) {
4504	+ var type = match[1],
4505	+ node = elem;
4506	+
4507	+ switch ( type ) {
4508	+ case "only":
4509	+ case "first":
4510	+ while ( (node = node.previousSibling) ) {
4511	+ if ( node.nodeType === 1 ) {
4512	+ return false;
4513	+ }
4514	+ }
4515	+
4516	+ if ( type === "first" ) {
4517	+ return true;
4518	+ }
4519	+
4520	+ node = elem;
4521	+
4522	+ case "last":
4523	+ while ( (node = node.nextSibling) ) {
4524	+ if ( node.nodeType === 1 ) {
4525	+ return false;
4526	+ }
4527	+ }
4528	+
4529	+ return true;
4530	+
4531	+ case "nth":
4532	+ var first = match[2],
4533	+ last = match[3];
4534	+
4535	+ if ( first === 1 && last === 0 ) {
4536	+ return true;
4537	+ }
4538	+
4539	+ var doneName = match[0],
4540	+ parent = elem.parentNode;
4541	+
4542	+ if ( parent && (parent.sizcache !== doneName \|\| !elem.nodeIndex) ) {
4543	+ var count = 0;
4544	+
4545	+ for ( node = parent.firstChild; node; node = node.nextSibling ) {
4546	+ if ( node.nodeType === 1 ) {
4547	+ node.nodeIndex = ++count;
4548	+ }
4549	+ }
4550	+
4551	+ parent.sizcache = doneName;
4552	+ }
4553	+
4554	+ var diff = elem.nodeIndex - last;
4555	+
4556	+ if ( first === 0 ) {
4557	+ return diff === 0;
4558	+
4559	+ } else {
4560	+ return ( diff % first === 0 && diff / first >= 0 );
4561	+ }
4562	+ }
4563	+ },
4564	+
4565	+ ID: function( elem, match ) {
4566	+ return elem.nodeType === 1 && elem.getAttribute("id") === match;
4567	+ },
4568	+
4569	+ TAG: function( elem, match ) {
4570	+ return (match === "*" && elem.nodeType === 1) \|\| elem.nodeName.toLowerCase() === match;
4571	+ },
4572	+
4573	+ CLASS: function( elem, match ) {
4574	+ return (" " + (elem.className \|\| elem.getAttribute("class")) + " ")
4575	+ .indexOf( match ) > -1;
4576	+ },
4577	+
4578	+ ATTR: function( elem, match ) {
4579	+ var name = match[1],
4580	+ result = Expr.attrHandle[ name ] ?
4581	+ Expr.attrHandle[ name ]( elem ) :
4582	+ elem[ name ] != null ?
4583	+ elem[ name ] :
4584	+ elem.getAttribute( name ),
4585	+ value = result + "",
4586	+ type = match[2],
4587	+ check = match[4];
4588	+
4589	+ return result == null ?
4590	+ type === "!=" :
4591	+ type === "=" ?
4592	+ value === check :
4593	+ type === "*=" ?
4594	+ value.indexOf(check) >= 0 :
4595	+ type === "~=" ?
4596	+ (" " + value + " ").indexOf(check) >= 0 :
4597	+ !check ?
4598	+ value && result !== false :
4599	+ type === "!=" ?
4600	+ value !== check :
4601	+ type === "^=" ?
4602	+ value.indexOf(check) === 0 :
4603	+ type === "$=" ?
4604	+ value.substr(value.length - check.length) === check :
4605	+ type === "\|=" ?
4606	+ value === check \|\| value.substr(0, check.length + 1) === check + "-" :
4607	+ false;
4608	+ },
4609	+
4610	+ POS: function( elem, match, i, array ) {
4611	+ var name = match[2],
4612	+ filter = Expr.setFilters[ name ];
4613	+
4614	+ if ( filter ) {
4615	+ return filter( elem, i, match, array );
4616	+ }
4617	+ }
4618	+ }
4619	+ };
4620	+
4621	+ var origPOS = Expr.match.POS,
4622	+ fescape = function(all, num){
4623	+ return "\\" + (num - 0 + 1);
4624	+ };
4625	+
4626	+ for ( var type in Expr.match ) {
4627	+ Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]\])(?![^$]$)/.source) );
4628	+ Expr.leftMatch[ type ] = new RegExp( /(^(?:.\|\r\|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4629	+ }
4630	+
4631	+ var makeArray = function( array, results ) {
4632	+ array = Array.prototype.slice.call( array, 0 );
4633	+
4634	+ if ( results ) {
4635	+ results.push.apply( results, array );
4636	+ return results;
4637	+ }
4638	+
4639	+ return array;
4640	+ };
4641	+
4642	+ // Perform a simple check to determine if the browser is capable of
4643	+ // converting a NodeList to an array using builtin methods.
4644	+ // Also verifies that the returned array holds DOM nodes
4645	+ // (which is not the case in the Blackberry browser)
4646	+ try {
4647	+ Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4648	+
4649	+ // Provide a fallback method if it does not work
4650	+ } catch( e ) {
4651	+ makeArray = function( array, results ) {
4652	+ var i = 0,
4653	+ ret = results \|\| [];
4654	+
4655	+ if ( toString.call(array) === "[object Array]" ) {
4656	+ Array.prototype.push.apply( ret, array );
4657	+
4658	+ } else {
4659	+ if ( typeof array.length === "number" ) {
4660	+ for ( var l = array.length; i < l; i++ ) {
4661	+ ret.push( array[i] );
4662	+ }
4663	+
4664	+ } else {
4665	+ for ( ; array[i]; i++ ) {
4666	+ ret.push( array[i] );
4667	+ }
4668	+ }
4669	+ }
4670	+
4671	+ return ret;
4672	+ };
4673	+ }
4674	+
4675	+ var sortOrder, siblingCheck;
4676	+
4677	+ if ( document.documentElement.compareDocumentPosition ) {
4678	+ sortOrder = function( a, b ) {
4679	+ if ( a === b ) {
4680	+ hasDuplicate = true;
4681	+ return 0;
4682	+ }
4683	+
4684	+ if ( !a.compareDocumentPosition \|\| !b.compareDocumentPosition ) {
4685	+ return a.compareDocumentPosition ? -1 : 1;
4686	+ }
4687	+
4688	+ return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4689	+ };
4690	+
4691	+ } else {
4692	+ sortOrder = function( a, b ) {
4693	+ // The nodes are identical, we can exit early
4694	+ if ( a === b ) {
4695	+ hasDuplicate = true;
4696	+ return 0;
4697	+
4698	+ // Fallback to using sourceIndex (in IE) if it's available on both nodes
4699	+ } else if ( a.sourceIndex && b.sourceIndex ) {
4700	+ return a.sourceIndex - b.sourceIndex;
4701	+ }
4702	+
4703	+ var al, bl,
4704	+ ap = [],
4705	+ bp = [],
4706	+ aup = a.parentNode,
4707	+ bup = b.parentNode,
4708	+ cur = aup;
4709	+
4710	+ // If the nodes are siblings (or identical) we can do a quick check
4711	+ if ( aup === bup ) {
4712	+ return siblingCheck( a, b );
4713	+
4714	+ // If no parents were found then the nodes are disconnected
4715	+ } else if ( !aup ) {
4716	+ return -1;
4717	+
4718	+ } else if ( !bup ) {
4719	+ return 1;
4720	+ }
4721	+
4722	+ // Otherwise they're somewhere else in the tree so we need
4723	+ // to build up a full list of the parentNodes for comparison
4724	+ while ( cur ) {
4725	+ ap.unshift( cur );
4726	+ cur = cur.parentNode;
4727	+ }
4728	+
4729	+ cur = bup;
4730	+
4731	+ while ( cur ) {
4732	+ bp.unshift( cur );
4733	+ cur = cur.parentNode;
4734	+ }
4735	+
4736	+ al = ap.length;
4737	+ bl = bp.length;
4738	+
4739	+ // Start walking down the tree looking for a discrepancy
4740	+ for ( var i = 0; i < al && i < bl; i++ ) {
4741	+ if ( ap[i] !== bp[i] ) {
4742	+ return siblingCheck( ap[i], bp[i] );
4743	+ }
4744	+ }
4745	+
4746	+ // We ended someplace up the tree so do a sibling check
4747	+ return i === al ?
4748	+ siblingCheck( a, bp[i], -1 ) :
4749	+ siblingCheck( ap[i], b, 1 );
4750	+ };
4751	+
4752	+ siblingCheck = function( a, b, ret ) {
4753	+ if ( a === b ) {
4754	+ return ret;
4755	+ }
4756	+
4757	+ var cur = a.nextSibling;
4758	+
4759	+ while ( cur ) {
4760	+ if ( cur === b ) {
4761	+ return -1;
4762	+ }
4763	+
4764	+ cur = cur.nextSibling;
4765	+ }
4766	+
4767	+ return 1;
4768	+ };
4769	+ }
4770	+
4771	+ // Utility function for retreiving the text value of an array of DOM nodes
4772	+ Sizzle.getText = function( elems ) {
4773	+ var ret = "", elem;
4774	+
4775	+ for ( var i = 0; elems[i]; i++ ) {
4776	+ elem = elems[i];
4777	+
4778	+ // Get the text from text nodes and CDATA nodes
4779	+ if ( elem.nodeType === 3 \|\| elem.nodeType === 4 ) {
4780	+ ret += elem.nodeValue;
4781	+
4782	+ // Traverse everything else, except comment nodes
4783	+ } else if ( elem.nodeType !== 8 ) {
4784	+ ret += Sizzle.getText( elem.childNodes );
4785	+ }
4786	+ }
4787	+
4788	+ return ret;
4789	+ };
4790	+
4791	+ // Check to see if the browser returns elements by name when
4792	+ // querying by getElementById (and provide a workaround)
4793	+ (function(){
4794	+ // We're going to inject a fake input element with a specified name
4795	+ var form = document.createElement("div"),
4796	+ id = "script" + (new Date()).getTime(),
4797	+ root = document.documentElement;
4798	+
4799	+ form.innerHTML = "<a name='" + id + "'/>";
4800	+
4801	+ // Inject it into the root element, check its status, and remove it quickly
4802	+ root.insertBefore( form, root.firstChild );
4803	+
4804	+ // The workaround has to do additional checks after a getElementById
4805	+ // Which slows things down for other browsers (hence the branching)
4806	+ if ( document.getElementById( id ) ) {
4807	+ Expr.find.ID = function( match, context, isXML ) {
4808	+ if ( typeof context.getElementById !== "undefined" && !isXML ) {
4809	+ var m = context.getElementById(match[1]);
4810	+
4811	+ return m ?
4812	+ m.id === match[1] \|\| typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4813	+ [m] :
4814	+ undefined :
4815	+ [];
4816	+ }
4817	+ };
4818	+
4819	+ Expr.filter.ID = function( elem, match ) {
4820	+ var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4821	+
4822	+ return elem.nodeType === 1 && node && node.nodeValue === match;
4823	+ };
4824	+ }
4825	+
4826	+ root.removeChild( form );
4827	+
4828	+ // release memory in IE
4829	+ root = form = null;
4830	+ })();
4831	+
4832	+ (function(){
4833	+ // Check to see if the browser returns only elements
4834	+ // when doing getElementsByTagName("*")
4835	+
4836	+ // Create a fake element
4837	+ var div = document.createElement("div");
4838	+ div.appendChild( document.createComment("") );
4839	+
4840	+ // Make sure no comments are found
4841	+ if ( div.getElementsByTagName("*").length > 0 ) {
4842	+ Expr.find.TAG = function( match, context ) {
4843	+ var results = context.getElementsByTagName( match[1] );
4844	+
4845	+ // Filter out possible comments
4846	+ if ( match[1] === "*" ) {
4847	+ var tmp = [];
4848	+
4849	+ for ( var i = 0; results[i]; i++ ) {
4850	+ if ( results[i].nodeType === 1 ) {
4851	+ tmp.push( results[i] );
4852	+ }
4853	+ }
4854	+
4855	+ results = tmp;
4856	+ }
4857	+
4858	+ return results;
4859	+ };
4860	+ }
4861	+
4862	+ // Check to see if an attribute returns normalized href attributes
4863	+ div.innerHTML = "<a href='#'></a>";
4864	+
4865	+ if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4866	+ div.firstChild.getAttribute("href") !== "#" ) {
4867	+
4868	+ Expr.attrHandle.href = function( elem ) {
4869	+ return elem.getAttribute( "href", 2 );
4870	+ };
4871	+ }
4872	+
4873	+ // release memory in IE
4874	+ div = null;
4875	+ })();
4876	+
4877	+ if ( document.querySelectorAll ) {
4878	+ (function(){
4879	+ var oldSizzle = Sizzle,
4880	+ div = document.createElement("div"),
4881	+ id = "__sizzle__";
4882	+
4883	+ div.innerHTML = "<p class='TEST'></p>";
4884	+
4885	+ // Safari can't handle uppercase or unicode characters when
4886	+ // in quirks mode.
4887	+ if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4888	+ return;
4889	+ }
4890	+
4891	+ Sizzle = function( query, context, extra, seed ) {
4892	+ context = context \|\| document;
4893	+
4894	+ // Only use querySelectorAll on non-XML documents
4895	+ // (ID selectors don't work in non-HTML documents)
4896	+ if ( !seed && !Sizzle.isXML(context) ) {
4897	+ // See if we find a selector to speed up
4898	+ var match = /^(\w+$)\|^\.([\w\-]+$)\|^#([\w\-]+$)/.exec( query );
4899	+
4900	+ if ( match && (context.nodeType === 1 \|\| context.nodeType === 9) ) {
4901	+ // Speed-up: Sizzle("TAG")
4902	+ if ( match[1] ) {
4903	+ return makeArray( context.getElementsByTagName( query ), extra );
4904	+
4905	+ // Speed-up: Sizzle(".CLASS")
4906	+ } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
4907	+ return makeArray( context.getElementsByClassName( match[2] ), extra );
4908	+ }
4909	+ }
4910	+
4911	+ if ( context.nodeType === 9 ) {
4912	+ // Speed-up: Sizzle("body")
4913	+ // The body element only exists once, optimize finding it
4914	+ if ( query === "body" && context.body ) {
4915	+ return makeArray( [ context.body ], extra );
4916	+
4917	+ // Speed-up: Sizzle("#ID")
4918	+ } else if ( match && match[3] ) {
4919	+ var elem = context.getElementById( match[3] );
4920	+
4921	+ // Check parentNode to catch when Blackberry 4.6 returns
4922	+ // nodes that are no longer in the document #6963
4923	+ if ( elem && elem.parentNode ) {
4924	+ // Handle the case where IE and Opera return items
4925	+ // by name instead of ID
4926	+ if ( elem.id === match[3] ) {
4927	+ return makeArray( [ elem ], extra );
4928	+ }
4929	+
4930	+ } else {
4931	+ return makeArray( [], extra );
4932	+ }
4933	+ }
4934	+
4935	+ try {
4936	+ return makeArray( context.querySelectorAll(query), extra );
4937	+ } catch(qsaError) {}
4938	+
4939	+ // qSA works strangely on Element-rooted queries
4940	+ // We can work around this by specifying an extra ID on the root
4941	+ // and working up from there (Thanks to Andrew Dupont for the technique)
4942	+ // IE 8 doesn't work on object elements
4943	+ } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4944	+ var oldContext = context,
4945	+ old = context.getAttribute( "id" ),
4946	+ nid = old \|\| id,
4947	+ hasParent = context.parentNode,
4948	+ relativeHierarchySelector = /^\s*[+~]/.test( query );
4949	+
4950	+ if ( !old ) {
4951	+ context.setAttribute( "id", nid );
4952	+ } else {
4953	+ nid = nid.replace( /'/g, "\\$&" );
4954	+ }
4955	+ if ( relativeHierarchySelector && hasParent ) {
4956	+ context = context.parentNode;
4957	+ }
4958	+
4959	+ try {
4960	+ if ( !relativeHierarchySelector \|\| hasParent ) {
4961	+ return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
4962	+ }
4963	+
4964	+ } catch(pseudoError) {
4965	+ } finally {
4966	+ if ( !old ) {
4967	+ oldContext.removeAttribute( "id" );
4968	+ }
4969	+ }
4970	+ }
4971	+ }
4972	+
4973	+ return oldSizzle(query, context, extra, seed);
4974	+ };
4975	+
4976	+ for ( var prop in oldSizzle ) {
4977	+ Sizzle[ prop ] = oldSizzle[ prop ];
4978	+ }
4979	+
4980	+ // release memory in IE
4981	+ div = null;
4982	+ })();
4983	+ }
4984	+
4985	+ (function(){
4986	+ var html = document.documentElement,
4987	+ matches = html.matchesSelector \|\| html.mozMatchesSelector \|\| html.webkitMatchesSelector \|\| html.msMatchesSelector;
4988	+
4989	+ if ( matches ) {
4990	+ // Check to see if it's possible to do matchesSelector
4991	+ // on a disconnected node (IE 9 fails this)
4992	+ var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
4993	+ pseudoWorks = false;
4994	+
4995	+ try {
4996	+ // This should fail with an exception
4997	+ // Gecko does not error, returns false instead
4998	+ matches.call( document.documentElement, "[test!='']:sizzle" );
4999	+
5000	+ } catch( pseudoError ) {
5001	+ pseudoWorks = true;
5002	+ }
5003	+
5004	+ Sizzle.matchesSelector = function( node, expr ) {
5005	+ // Make sure that attribute selectors are quoted
5006	+ expr = expr.replace(/\=\s([^'"\]])\s*\]/g, "='$1']");
5007	+
5008	+ if ( !Sizzle.isXML( node ) ) {
5009	+ try {
5010	+ if ( pseudoWorks \|\| !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
5011	+ var ret = matches.call( node, expr );
5012	+
5013	+ // IE 9's matchesSelector returns false on disconnected nodes
5014	+ if ( ret \|\| !disconnectedMatch \|\|
5015	+ // As well, disconnected nodes are said to be in a document
5016	+ // fragment in IE 9, so check for that
5017	+ node.document && node.document.nodeType !== 11 ) {
5018	+ return ret;
5019	+ }
5020	+ }
5021	+ } catch(e) {}
5022	+ }
5023	+
5024	+ return Sizzle(expr, null, null, [node]).length > 0;
5025	+ };
5026	+ }
5027	+ })();
5028	+
5029	+ (function(){
5030	+ var div = document.createElement("div");
5031	+
5032	+ div.innerHTML = "<div class='test e'></div><div class='test'></div>";
5033	+
5034	+ // Opera can't find a second classname (in 9.6)
5035	+ // Also, make sure that getElementsByClassName actually exists
5036	+ if ( !div.getElementsByClassName \|\| div.getElementsByClassName("e").length === 0 ) {
5037	+ return;
5038	+ }
5039	+
5040	+ // Safari caches class attributes, doesn't catch changes (in 3.2)
5041	+ div.lastChild.className = "e";
5042	+
5043	+ if ( div.getElementsByClassName("e").length === 1 ) {
5044	+ return;
5045	+ }
5046	+
5047	+ Expr.order.splice(1, 0, "CLASS");
5048	+ Expr.find.CLASS = function( match, context, isXML ) {
5049	+ if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
5050	+ return context.getElementsByClassName(match[1]);
5051	+ }
5052	+ };
5053	+
5054	+ // release memory in IE
5055	+ div = null;
5056	+ })();
5057	+
5058	+ function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5059	+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5060	+ var elem = checkSet[i];
5061	+
5062	+ if ( elem ) {
5063	+ var match = false;
5064	+
5065	+ elem = elem[dir];
5066	+
5067	+ while ( elem ) {
5068	+ if ( elem.sizcache === doneName ) {
5069	+ match = checkSet[elem.sizset];
5070	+ break;
5071	+ }
5072	+
5073	+ if ( elem.nodeType === 1 && !isXML ){
5074	+ elem.sizcache = doneName;
5075	+ elem.sizset = i;
5076	+ }
5077	+
5078	+ if ( elem.nodeName.toLowerCase() === cur ) {
5079	+ match = elem;
5080	+ break;
5081	+ }
5082	+
5083	+ elem = elem[dir];
5084	+ }
5085	+
5086	+ checkSet[i] = match;
5087	+ }
5088	+ }
5089	+ }
5090	+
5091	+ function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5092	+ for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5093	+ var elem = checkSet[i];
5094	+
5095	+ if ( elem ) {
5096	+ var match = false;
5097	+
5098	+ elem = elem[dir];
5099	+
5100	+ while ( elem ) {
5101	+ if ( elem.sizcache === doneName ) {
5102	+ match = checkSet[elem.sizset];
5103	+ break;
5104	+ }
5105	+
5106	+ if ( elem.nodeType === 1 ) {
5107	+ if ( !isXML ) {
5108	+ elem.sizcache = doneName;
5109	+ elem.sizset = i;
5110	+ }
5111	+
5112	+ if ( typeof cur !== "string" ) {
5113	+ if ( elem === cur ) {
5114	+ match = true;
5115	+ break;
5116	+ }
5117	+
5118	+ } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5119	+ match = elem;
5120	+ break;
5121	+ }
5122	+ }
5123	+
5124	+ elem = elem[dir];
5125	+ }
5126	+
5127	+ checkSet[i] = match;
5128	+ }
5129	+ }
5130	+ }
5131	+
5132	+ if ( document.documentElement.contains ) {
5133	+ Sizzle.contains = function( a, b ) {
5134	+ return a !== b && (a.contains ? a.contains(b) : true);
5135	+ };
5136	+
5137	+ } else if ( document.documentElement.compareDocumentPosition ) {
5138	+ Sizzle.contains = function( a, b ) {
5139	+ return !!(a.compareDocumentPosition(b) & 16);
5140	+ };
5141	+
5142	+ } else {
5143	+ Sizzle.contains = function() {
5144	+ return false;
5145	+ };
5146	+ }
5147	+
5148	+ Sizzle.isXML = function( elem ) {
5149	+ // documentElement is verified for cases where it doesn't yet exist
5150	+ // (such as loading iframes in IE - #4833)
5151	+ var documentElement = (elem ? elem.ownerDocument \|\| elem : 0).documentElement;
5152	+
5153	+ return documentElement ? documentElement.nodeName !== "HTML" : false;
5154	+ };
5155	+
5156	+ var posProcess = function( selector, context ) {
5157	+ var match,
5158	+ tmpSet = [],
5159	+ later = "",
5160	+ root = context.nodeType ? [context] : context;
5161	+
5162	+ // Position selectors must be done after the filter
5163	+ // And so must :not(positional) so we move all PSEUDOs to the end
5164	+ while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5165	+ later += match[0];
5166	+ selector = selector.replace( Expr.match.PSEUDO, "" );
5167	+ }
5168	+
5169	+ selector = Expr.relative[selector] ? selector + "*" : selector;
5170	+
5171	+ for ( var i = 0, l = root.length; i < l; i++ ) {
5172	+ Sizzle( selector, root[i], tmpSet );
5173	+ }
5174	+
5175	+ return Sizzle.filter( later, tmpSet );
5176	+ };
5177	+
5178	+ // EXPOSE
5179	+ jQuery.find = Sizzle;
5180	+ jQuery.expr = Sizzle.selectors;
5181	+ jQuery.expr[":"] = jQuery.expr.filters;
5182	+ jQuery.unique = Sizzle.uniqueSort;
5183	+ jQuery.text = Sizzle.getText;
5184	+ jQuery.isXMLDoc = Sizzle.isXML;
5185	+ jQuery.contains = Sizzle.contains;
5186	+
5187	+
5188	+ })();
5189	+
5190	+
5191	+ var runtil = /Until$/,
5192	+ rparentsprev = /^(?:parents\|prevUntil\|prevAll)/,
5193	+ // Note: This RegExp should be improved, or likely pulled from Sizzle
5194	+ rmultiselector = /,/,
5195	+ isSimple = /^.[^:#\[\.,]*$/,
5196	+ slice = Array.prototype.slice,
5197	+ POS = jQuery.expr.match.POS,
5198	+ // methods guaranteed to produce a unique set when starting from a unique set
5199	+ guaranteedUnique = {
5200	+ children: true,
5201	+ contents: true,
5202	+ next: true,
5203	+ prev: true
5204	+ };
5205	+
5206	+ jQuery.fn.extend({
5207	+ find: function( selector ) {
5208	+ var self = this,
5209	+ i, l;
5210	+
5211	+ if ( typeof selector !== "string" ) {
5212	+ return jQuery( selector ).filter(function() {
5213	+ for ( i = 0, l = self.length; i < l; i++ ) {
5214	+ if ( jQuery.contains( self[ i ], this ) ) {
5215	+ return true;
5216	+ }
5217	+ }
5218	+ });
5219	+ }
5220	+
5221	+ var ret = this.pushStack( "", "find", selector ),
5222	+ length, n, r;
5223	+
5224	+ for ( i = 0, l = this.length; i < l; i++ ) {
5225	+ length = ret.length;
5226	+ jQuery.find( selector, this[i], ret );
5227	+
5228	+ if ( i > 0 ) {
5229	+ // Make sure that the results are unique
5230	+ for ( n = length; n < ret.length; n++ ) {
5231	+ for ( r = 0; r < length; r++ ) {
5232	+ if ( ret[r] === ret[n] ) {
5233	+ ret.splice(n--, 1);
5234	+ break;
5235	+ }
5236	+ }
5237	+ }
5238	+ }
5239	+ }
5240	+
5241	+ return ret;
5242	+ },
5243	+
5244	+ has: function( target ) {
5245	+ var targets = jQuery( target );
5246	+ return this.filter(function() {
5247	+ for ( var i = 0, l = targets.length; i < l; i++ ) {
5248	+ if ( jQuery.contains( this, targets[i] ) ) {
5249	+ return true;
5250	+ }
5251	+ }
5252	+ });
5253	+ },
5254	+
5255	+ not: function( selector ) {
5256	+ return this.pushStack( winnow(this, selector, false), "not", selector);
5257	+ },
5258	+
5259	+ filter: function( selector ) {
5260	+ return this.pushStack( winnow(this, selector, true), "filter", selector );
5261	+ },
5262	+
5263	+ is: function( selector ) {
5264	+ return !!selector && ( typeof selector === "string" ?
5265	+ jQuery.filter( selector, this ).length > 0 :
5266	+ this.filter( selector ).length > 0 );
5267	+ },
5268	+
5269	+ closest: function( selectors, context ) {
5270	+ var ret = [], i, l, cur = this[0];
5271	+
5272	+ // Array
5273	+ if ( jQuery.isArray( selectors ) ) {
5274	+ var match, selector,
5275	+ matches = {},
5276	+ level = 1;
5277	+
5278	+ if ( cur && selectors.length ) {
5279	+ for ( i = 0, l = selectors.length; i < l; i++ ) {
5280	+ selector = selectors[i];
5281	+
5282	+ if ( !matches[ selector ] ) {
5283	+ matches[ selector ] = POS.test( selector ) ?
5284	+ jQuery( selector, context \|\| this.context ) :
5285	+ selector;
5286	+ }
5287	+ }
5288	+
5289	+ while ( cur && cur.ownerDocument && cur !== context ) {
5290	+ for ( selector in matches ) {
5291	+ match = matches[ selector ];
5292	+
5293	+ if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
5294	+ ret.push({ selector: selector, elem: cur, level: level });
5295	+ }
5296	+ }
5297	+
5298	+ cur = cur.parentNode;
5299	+ level++;
5300	+ }
5301	+ }
5302	+
5303	+ return ret;
5304	+ }
5305	+
5306	+ // String
5307	+ var pos = POS.test( selectors ) \|\| typeof selectors !== "string" ?
5308	+ jQuery( selectors, context \|\| this.context ) :
5309	+ 0;
5310	+
5311	+ for ( i = 0, l = this.length; i < l; i++ ) {
5312	+ cur = this[i];
5313	+
5314	+ while ( cur ) {
5315	+ if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5316	+ ret.push( cur );
5317	+ break;
5318	+
5319	+ } else {
5320	+ cur = cur.parentNode;
5321	+ if ( !cur \|\| !cur.ownerDocument \|\| cur === context \|\| cur.nodeType === 11 ) {
5322	+ break;
5323	+ }
5324	+ }
5325	+ }
5326	+ }
5327	+
5328	+ ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5329	+
5330	+ return this.pushStack( ret, "closest", selectors );
5331	+ },
5332	+
5333	+ // Determine the position of an element within
5334	+ // the matched set of elements
5335	+ index: function( elem ) {
5336	+
5337	+ // No argument, return index in parent
5338	+ if ( !elem ) {
5339	+ return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
5340	+ }
5341	+
5342	+ // index in selector
5343	+ if ( typeof elem === "string" ) {
5344	+ return jQuery.inArray( this[0], jQuery( elem ) );
5345	+ }
5346	+
5347	+ // Locate the position of the desired element
5348	+ return jQuery.inArray(
5349	+ // If it receives a jQuery object, the first element is used
5350	+ elem.jquery ? elem[0] : elem, this );
5351	+ },
5352	+
5353	+ add: function( selector, context ) {
5354	+ var set = typeof selector === "string" ?
5355	+ jQuery( selector, context ) :
5356	+ jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5357	+ all = jQuery.merge( this.get(), set );
5358	+
5359	+ return this.pushStack( isDisconnected( set[0] ) \|\| isDisconnected( all[0] ) ?
5360	+ all :
5361	+ jQuery.unique( all ) );
5362	+ },
5363	+
5364	+ andSelf: function() {
5365	+ return this.add( this.prevObject );
5366	+ }
5367	+ });
5368	+
5369	+ // A painfully simple check to see if an element is disconnected
5370	+ // from a document (should be improved, where feasible).
5371	+ function isDisconnected( node ) {
5372	+ return !node \|\| !node.parentNode \|\| node.parentNode.nodeType === 11;
5373	+ }
5374	+
5375	+ jQuery.each({
5376	+ parent: function( elem ) {
5377	+ var parent = elem.parentNode;
5378	+ return parent && parent.nodeType !== 11 ? parent : null;
5379	+ },
5380	+ parents: function( elem ) {
5381	+ return jQuery.dir( elem, "parentNode" );
5382	+ },
5383	+ parentsUntil: function( elem, i, until ) {
5384	+ return jQuery.dir( elem, "parentNode", until );
5385	+ },
5386	+ next: function( elem ) {
5387	+ return jQuery.nth( elem, 2, "nextSibling" );
5388	+ },
5389	+ prev: function( elem ) {
5390	+ return jQuery.nth( elem, 2, "previousSibling" );
5391	+ },
5392	+ nextAll: function( elem ) {
5393	+ return jQuery.dir( elem, "nextSibling" );
5394	+ },
5395	+ prevAll: function( elem ) {
5396	+ return jQuery.dir( elem, "previousSibling" );
5397	+ },
5398	+ nextUntil: function( elem, i, until ) {
5399	+ return jQuery.dir( elem, "nextSibling", until );
5400	+ },
5401	+ prevUntil: function( elem, i, until ) {
5402	+ return jQuery.dir( elem, "previousSibling", until );
5403	+ },
5404	+ siblings: function( elem ) {
5405	+ return jQuery.sibling( elem.parentNode.firstChild, elem );
5406	+ },
5407	+ children: function( elem ) {
5408	+ return jQuery.sibling( elem.firstChild );
5409	+ },
5410	+ contents: function( elem ) {
5411	+ return jQuery.nodeName( elem, "iframe" ) ?
5412	+ elem.contentDocument \|\| elem.contentWindow.document :
5413	+ jQuery.makeArray( elem.childNodes );
5414	+ }
5415	+ }, function( name, fn ) {
5416	+ jQuery.fn[ name ] = function( until, selector ) {
5417	+ var ret = jQuery.map( this, fn, until ),
5418	+ // The variable 'args' was introduced in
5419	+ // https://github.com/jquery/jquery/commit/52a0238
5420	+ // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
5421	+ // http://code.google.com/p/v8/issues/detail?id=1050
5422	+ args = slice.call(arguments);
5423	+
5424	+ if ( !runtil.test( name ) ) {
5425	+ selector = until;
5426	+ }
5427	+
5428	+ if ( selector && typeof selector === "string" ) {
5429	+ ret = jQuery.filter( selector, ret );
5430	+ }
5431	+
5432	+ ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5433	+
5434	+ if ( (this.length > 1 \|\| rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5435	+ ret = ret.reverse();
5436	+ }
5437	+
5438	+ return this.pushStack( ret, name, args.join(",") );
5439	+ };
5440	+ });
5441	+
5442	+ jQuery.extend({
5443	+ filter: function( expr, elems, not ) {
5444	+ if ( not ) {
5445	+ expr = ":not(" + expr + ")";
5446	+ }
5447	+
5448	+ return elems.length === 1 ?
5449	+ jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5450	+ jQuery.find.matches(expr, elems);
5451	+ },
5452	+
5453	+ dir: function( elem, dir, until ) {
5454	+ var matched = [],
5455	+ cur = elem[ dir ];
5456	+
5457	+ while ( cur && cur.nodeType !== 9 && (until === undefined \|\| cur.nodeType !== 1 \|\| !jQuery( cur ).is( until )) ) {
5458	+ if ( cur.nodeType === 1 ) {
5459	+ matched.push( cur );
5460	+ }
5461	+ cur = cur[dir];
5462	+ }
5463	+ return matched;
5464	+ },
5465	+
5466	+ nth: function( cur, result, dir, elem ) {
5467	+ result = result \|\| 1;
5468	+ var num = 0;
5469	+
5470	+ for ( ; cur; cur = cur[dir] ) {
5471	+ if ( cur.nodeType === 1 && ++num === result ) {
5472	+ break;
5473	+ }
5474	+ }
5475	+
5476	+ return cur;
5477	+ },
5478	+
5479	+ sibling: function( n, elem ) {
5480	+ var r = [];
5481	+
5482	+ for ( ; n; n = n.nextSibling ) {
5483	+ if ( n.nodeType === 1 && n !== elem ) {
5484	+ r.push( n );
5485	+ }
5486	+ }
5487	+
5488	+ return r;
5489	+ }
5490	+ });
5491	+
5492	+ // Implement the identical functionality for filter and not
5493	+ function winnow( elements, qualifier, keep ) {
5494	+
5495	+ // Can't pass null or undefined to indexOf in Firefox 4
5496	+ // Set to 0 to skip string check
5497	+ qualifier = qualifier \|\| 0;
5498	+
5499	+ if ( jQuery.isFunction( qualifier ) ) {
5500	+ return jQuery.grep(elements, function( elem, i ) {
5501	+ var retVal = !!qualifier.call( elem, i, elem );
5502	+ return retVal === keep;
5503	+ });
5504	+
5505	+ } else if ( qualifier.nodeType ) {
5506	+ return jQuery.grep(elements, function( elem, i ) {
5507	+ return (elem === qualifier) === keep;
5508	+ });
5509	+
5510	+ } else if ( typeof qualifier === "string" ) {
5511	+ var filtered = jQuery.grep(elements, function( elem ) {
5512	+ return elem.nodeType === 1;
5513	+ });
5514	+
5515	+ if ( isSimple.test( qualifier ) ) {
5516	+ return jQuery.filter(qualifier, filtered, !keep);
5517	+ } else {
5518	+ qualifier = jQuery.filter( qualifier, filtered );
5519	+ }
5520	+ }
5521	+
5522	+ return jQuery.grep(elements, function( elem, i ) {
5523	+ return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
5524	+ });
5525	+ }
5526	+
5527	+
5528	+
5529	+
5530	+ var rinlinejQuery = / jQuery\d+="(?:\d+\|null)"/g,
5531	+ rleadingWhitespace = /^\s+/,
5532	+ rxhtmlTag = /<(?!area\|br\|col\|embed\|hr\|img\|input\|link\|meta\|param)(([\w:]+)[^>]*)\/>/ig,
5533	+ rtagName = /<([\w:]+)/,
5534	+ rtbody = /<tbody/i,
5535	+ rhtml = /<\|&#?\w+;/,
5536	+ rnocache = /<(?:script\|object\|embed\|option\|style)/i,
5537	+ // checked="checked" or checked
5538	+ rchecked = /checked\s(?:[^=]\|=\s.checked.)/i,
5539	+ rscriptType = /\/(java\|ecma)script/i,
5540	+ rcleanScript = /^\s*<!(?:\[CDATA\[\|\-\-)/,
5541	+ wrapMap = {
5542	+ option: [ 1, "<select multiple='multiple'>", "</select>" ],
5543	+ legend: [ 1, "<fieldset>", "</fieldset>" ],
5544	+ thead: [ 1, "<table>", "</table>" ],
5545	+ tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5546	+ td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5547	+ col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5548	+ area: [ 1, "<map>", "</map>" ],
5549	+ _default: [ 0, "", "" ]
5550	+ };
5551	+
5552	+ wrapMap.optgroup = wrapMap.option;
5553	+ wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5554	+ wrapMap.th = wrapMap.td;
5555	+
5556	+ // IE can't serialize <link> and <script> tags normally
5557	+ if ( !jQuery.support.htmlSerialize ) {
5558	+ wrapMap._default = [ 1, "div<div>", "</div>" ];
5559	+ }
5560	+
5561	+ jQuery.fn.extend({
5562	+ text: function( text ) {
5563	+ if ( jQuery.isFunction(text) ) {
5564	+ return this.each(function(i) {
5565	+ var self = jQuery( this );
5566	+
5567	+ self.text( text.call(this, i, self.text()) );
5568	+ });
5569	+ }
5570	+
5571	+ if ( typeof text !== "object" && text !== undefined ) {
5572	+ return this.empty().append( (this[0] && this[0].ownerDocument \|\| document).createTextNode( text ) );
5573	+ }
5574	+
5575	+ return jQuery.text( this );
5576	+ },
5577	+
5578	+ wrapAll: function( html ) {
5579	+ if ( jQuery.isFunction( html ) ) {
5580	+ return this.each(function(i) {
5581	+ jQuery(this).wrapAll( html.call(this, i) );
5582	+ });
5583	+ }
5584	+
5585	+ if ( this[0] ) {
5586	+ // The elements to wrap the target around
5587	+ var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5588	+
5589	+ if ( this[0].parentNode ) {
5590	+ wrap.insertBefore( this[0] );
5591	+ }
5592	+
5593	+ wrap.map(function() {
5594	+ var elem = this;
5595	+
5596	+ while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5597	+ elem = elem.firstChild;
5598	+ }
5599	+
5600	+ return elem;
5601	+ }).append( this );
5602	+ }
5603	+
5604	+ return this;
5605	+ },
5606	+
5607	+ wrapInner: function( html ) {
5608	+ if ( jQuery.isFunction( html ) ) {
5609	+ return this.each(function(i) {
5610	+ jQuery(this).wrapInner( html.call(this, i) );
5611	+ });
5612	+ }
5613	+
5614	+ return this.each(function() {
5615	+ var self = jQuery( this ),
5616	+ contents = self.contents();
5617	+
5618	+ if ( contents.length ) {
5619	+ contents.wrapAll( html );
5620	+
5621	+ } else {
5622	+ self.append( html );
5623	+ }
5624	+ });
5625	+ },
5626	+
5627	+ wrap: function( html ) {
5628	+ return this.each(function() {
5629	+ jQuery( this ).wrapAll( html );
5630	+ });
5631	+ },
5632	+
5633	+ unwrap: function() {
5634	+ return this.parent().each(function() {
5635	+ if ( !jQuery.nodeName( this, "body" ) ) {
5636	+ jQuery( this ).replaceWith( this.childNodes );
5637	+ }
5638	+ }).end();
5639	+ },
5640	+
5641	+ append: function() {
5642	+ return this.domManip(arguments, true, function( elem ) {
5643	+ if ( this.nodeType === 1 ) {
5644	+ this.appendChild( elem );
5645	+ }
5646	+ });
5647	+ },
5648	+
5649	+ prepend: function() {
5650	+ return this.domManip(arguments, true, function( elem ) {
5651	+ if ( this.nodeType === 1 ) {
5652	+ this.insertBefore( elem, this.firstChild );
5653	+ }
5654	+ });
5655	+ },
5656	+
5657	+ before: function() {
5658	+ if ( this[0] && this[0].parentNode ) {
5659	+ return this.domManip(arguments, false, function( elem ) {
5660	+ this.parentNode.insertBefore( elem, this );
5661	+ });
5662	+ } else if ( arguments.length ) {
5663	+ var set = jQuery(arguments[0]);
5664	+ set.push.apply( set, this.toArray() );
5665	+ return this.pushStack( set, "before", arguments );
5666	+ }
5667	+ },
5668	+
5669	+ after: function() {
5670	+ if ( this[0] && this[0].parentNode ) {
5671	+ return this.domManip(arguments, false, function( elem ) {
5672	+ this.parentNode.insertBefore( elem, this.nextSibling );
5673	+ });
5674	+ } else if ( arguments.length ) {
5675	+ var set = this.pushStack( this, "after", arguments );
5676	+ set.push.apply( set, jQuery(arguments[0]).toArray() );
5677	+ return set;
5678	+ }
5679	+ },
5680	+
5681	+ // keepData is for internal use only--do not document
5682	+ remove: function( selector, keepData ) {
5683	+ for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5684	+ if ( !selector \|\| jQuery.filter( selector, [ elem ] ).length ) {
5685	+ if ( !keepData && elem.nodeType === 1 ) {
5686	+ jQuery.cleanData( elem.getElementsByTagName("*") );
5687	+ jQuery.cleanData( [ elem ] );
5688	+ }
5689	+
5690	+ if ( elem.parentNode ) {
5691	+ elem.parentNode.removeChild( elem );
5692	+ }
5693	+ }
5694	+ }
5695	+
5696	+ return this;
5697	+ },
5698	+
5699	+ empty: function() {
5700	+ for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5701	+ // Remove element nodes and prevent memory leaks
5702	+ if ( elem.nodeType === 1 ) {
5703	+ jQuery.cleanData( elem.getElementsByTagName("*") );
5704	+ }
5705	+
5706	+ // Remove any remaining nodes
5707	+ while ( elem.firstChild ) {
5708	+ elem.removeChild( elem.firstChild );
5709	+ }
5710	+ }
5711	+
5712	+ return this;
5713	+ },
5714	+
5715	+ clone: function( dataAndEvents, deepDataAndEvents ) {
5716	+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5717	+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5718	+
5719	+ return this.map( function () {
5720	+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5721	+ });
5722	+ },
5723	+
5724	+ html: function( value ) {
5725	+ if ( value === undefined ) {
5726	+ return this[0] && this[0].nodeType === 1 ?
5727	+ this[0].innerHTML.replace(rinlinejQuery, "") :
5728	+ null;
5729	+
5730	+ // See if we can take a shortcut and just use innerHTML
5731	+ } else if ( typeof value === "string" && !rnocache.test( value ) &&
5732	+ (jQuery.support.leadingWhitespace \|\| !rleadingWhitespace.test( value )) &&
5733	+ !wrapMap[ (rtagName.exec( value ) \|\| ["", ""])[1].toLowerCase() ] ) {
5734	+
5735	+ value = value.replace(rxhtmlTag, "<$1></$2>");
5736	+
5737	+ try {
5738	+ for ( var i = 0, l = this.length; i < l; i++ ) {
5739	+ // Remove element nodes and prevent memory leaks
5740	+ if ( this[i].nodeType === 1 ) {
5741	+ jQuery.cleanData( this[i].getElementsByTagName("*") );
5742	+ this[i].innerHTML = value;
5743	+ }
5744	+ }
5745	+
5746	+ // If using innerHTML throws an exception, use the fallback method
5747	+ } catch(e) {
5748	+ this.empty().append( value );
5749	+ }
5750	+
5751	+ } else if ( jQuery.isFunction( value ) ) {
5752	+ this.each(function(i){
5753	+ var self = jQuery( this );
5754	+
5755	+ self.html( value.call(this, i, self.html()) );
5756	+ });
5757	+
5758	+ } else {
5759	+ this.empty().append( value );
5760	+ }
5761	+
5762	+ return this;
5763	+ },
5764	+
5765	+ replaceWith: function( value ) {
5766	+ if ( this[0] && this[0].parentNode ) {
5767	+ // Make sure that the elements are removed from the DOM before they are inserted
5768	+ // this can help fix replacing a parent with child elements
5769	+ if ( jQuery.isFunction( value ) ) {
5770	+ return this.each(function(i) {
5771	+ var self = jQuery(this), old = self.html();
5772	+ self.replaceWith( value.call( this, i, old ) );
5773	+ });
5774	+ }
5775	+
5776	+ if ( typeof value !== "string" ) {
5777	+ value = jQuery( value ).detach();
5778	+ }
5779	+
5780	+ return this.each(function() {
5781	+ var next = this.nextSibling,
5782	+ parent = this.parentNode;
5783	+
5784	+ jQuery( this ).remove();
5785	+
5786	+ if ( next ) {
5787	+ jQuery(next).before( value );
5788	+ } else {
5789	+ jQuery(parent).append( value );
5790	+ }
5791	+ });
5792	+ } else {
5793	+ return this.length ?
5794	+ this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5795	+ this;
5796	+ }
5797	+ },
5798	+
5799	+ detach: function( selector ) {
5800	+ return this.remove( selector, true );
5801	+ },
5802	+
5803	+ domManip: function( args, table, callback ) {
5804	+ var results, first, fragment, parent,
5805	+ value = args[0],
5806	+ scripts = [];
5807	+
5808	+ // We can't cloneNode fragments that contain checked, in WebKit
5809	+ if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5810	+ return this.each(function() {
5811	+ jQuery(this).domManip( args, table, callback, true );
5812	+ });
5813	+ }
5814	+
5815	+ if ( jQuery.isFunction(value) ) {
5816	+ return this.each(function(i) {
5817	+ var self = jQuery(this);
5818	+ args[0] = value.call(this, i, table ? self.html() : undefined);
5819	+ self.domManip( args, table, callback );
5820	+ });
5821	+ }
5822	+
5823	+ if ( this[0] ) {
5824	+ parent = value && value.parentNode;
5825	+
5826	+ // If we're in a fragment, just use that instead of building a new one
5827	+ if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5828	+ results = { fragment: parent };
5829	+
5830	+ } else {
5831	+ results = jQuery.buildFragment( args, this, scripts );
5832	+ }
5833	+
5834	+ fragment = results.fragment;
5835	+
5836	+ if ( fragment.childNodes.length === 1 ) {
5837	+ first = fragment = fragment.firstChild;
5838	+ } else {
5839	+ first = fragment.firstChild;
5840	+ }
5841	+
5842	+ if ( first ) {
5843	+ table = table && jQuery.nodeName( first, "tr" );
5844	+
5845	+ for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5846	+ callback.call(
5847	+ table ?
5848	+ root(this[i], first) :
5849	+ this[i],
5850	+ // Make sure that we do not leak memory by inadvertently discarding
5851	+ // the original fragment (which might have attached data) instead of
5852	+ // using it; in addition, use the original fragment object for the last
5853	+ // item instead of first because it can end up being emptied incorrectly
5854	+ // in certain situations (Bug #8070).
5855	+ // Fragments from the fragment cache must always be cloned and never used
5856	+ // in place.
5857	+ results.cacheable \|\| (l > 1 && i < lastIndex) ?
5858	+ jQuery.clone( fragment, true, true ) :
5859	+ fragment
5860	+ );
5861	+ }
5862	+ }
5863	+
5864	+ if ( scripts.length ) {
5865	+ jQuery.each( scripts, evalScript );
5866	+ }
5867	+ }
5868	+
5869	+ return this;
5870	+ }
5871	+ });
5872	+
5873	+ function root( elem, cur ) {
5874	+ return jQuery.nodeName(elem, "table") ?
5875	+ (elem.getElementsByTagName("tbody")[0] \|\|
5876	+ elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5877	+ elem;
5878	+ }
5879	+
5880	+ function cloneCopyEvent( src, dest ) {
5881	+
5882	+ if ( dest.nodeType !== 1 \|\| !jQuery.hasData( src ) ) {
5883	+ return;
5884	+ }
5885	+
5886	+ var internalKey = jQuery.expando,
5887	+ oldData = jQuery.data( src ),
5888	+ curData = jQuery.data( dest, oldData );
5889	+
5890	+ // Switch to use the internal data object, if it exists, for the next
5891	+ // stage of data copying
5892	+ if ( (oldData = oldData[ internalKey ]) ) {
5893	+ var events = oldData.events;
5894	+ curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5895	+
5896	+ if ( events ) {
5897	+ delete curData.handle;
5898	+ curData.events = {};
5899	+
5900	+ for ( var type in events ) {
5901	+ for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5902	+ jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5903	+ }
5904	+ }
5905	+ }
5906	+ }
5907	+ }
5908	+
5909	+ function cloneFixAttributes( src, dest ) {
5910	+ var nodeName;
5911	+
5912	+ // We do not need to do anything for non-Elements
5913	+ if ( dest.nodeType !== 1 ) {
5914	+ return;
5915	+ }
5916	+
5917	+ // clearAttributes removes the attributes, which we don't want,
5918	+ // but also removes the attachEvent events, which we do want
5919	+ if ( dest.clearAttributes ) {
5920	+ dest.clearAttributes();
5921	+ }
5922	+
5923	+ // mergeAttributes, in contrast, only merges back on the
5924	+ // original attributes, not the events
5925	+ if ( dest.mergeAttributes ) {
5926	+ dest.mergeAttributes( src );
5927	+ }
5928	+
5929	+ nodeName = dest.nodeName.toLowerCase();
5930	+
5931	+ // IE6-8 fail to clone children inside object elements that use
5932	+ // the proprietary classid attribute value (rather than the type
5933	+ // attribute) to identify the type of content to display
5934	+ if ( nodeName === "object" ) {
5935	+ dest.outerHTML = src.outerHTML;
5936	+
5937	+ } else if ( nodeName === "input" && (src.type === "checkbox" \|\| src.type === "radio") ) {
5938	+ // IE6-8 fails to persist the checked state of a cloned checkbox
5939	+ // or radio button. Worse, IE6-7 fail to give the cloned element
5940	+ // a checked appearance if the defaultChecked value isn't also set
5941	+ if ( src.checked ) {
5942	+ dest.defaultChecked = dest.checked = src.checked;
5943	+ }
5944	+
5945	+ // IE6-7 get confused and end up setting the value of a cloned
5946	+ // checkbox/radio button to an empty string instead of "on"
5947	+ if ( dest.value !== src.value ) {
5948	+ dest.value = src.value;
5949	+ }
5950	+
5951	+ // IE6-8 fails to return the selected option to the default selected
5952	+ // state when cloning options
5953	+ } else if ( nodeName === "option" ) {
5954	+ dest.selected = src.defaultSelected;
5955	+
5956	+ // IE6-8 fails to set the defaultValue to the correct value when
5957	+ // cloning other types of input fields
5958	+ } else if ( nodeName === "input" \|\| nodeName === "textarea" ) {
5959	+ dest.defaultValue = src.defaultValue;
5960	+ }
5961	+
5962	+ // Event data gets referenced instead of copied if the expando
5963	+ // gets copied too
5964	+ dest.removeAttribute( jQuery.expando );
5965	+ }
5966	+
5967	+ jQuery.buildFragment = function( args, nodes, scripts ) {
5968	+ var fragment, cacheable, cacheresults, doc;
5969	+
5970	+ // nodes may contain either an explicit document object,
5971	+ // a jQuery collection or context object.
5972	+ // If nodes[0] contains a valid object to assign to doc
5973	+ if ( nodes && nodes[0] ) {
5974	+ doc = nodes[0].ownerDocument \|\| nodes[0];
5975	+ }
5976	+
5977	+ // Ensure that an attr object doesn't incorrectly stand in as a document object
5978	+ // Chrome and Firefox seem to allow this to occur and will throw exception
5979	+ // Fixes #8950
5980	+ if ( !doc.createDocumentFragment ) {
5981	+ doc = document;
5982	+ }
5983	+
5984	+ // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
5985	+ // Cloning options loses the selected state, so don't cache them
5986	+ // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5987	+ // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5988	+ if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5989	+ args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone \|\| !rchecked.test( args[0] )) ) {
5990	+
5991	+ cacheable = true;
5992	+
5993	+ cacheresults = jQuery.fragments[ args[0] ];
5994	+ if ( cacheresults && cacheresults !== 1 ) {
5995	+ fragment = cacheresults;
5996	+ }
5997	+ }
5998	+
5999	+ if ( !fragment ) {
6000	+ fragment = doc.createDocumentFragment();
6001	+ jQuery.clean( args, doc, fragment, scripts );
6002	+ }
6003	+
6004	+ if ( cacheable ) {
6005	+ jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
6006	+ }
6007	+
6008	+ return { fragment: fragment, cacheable: cacheable };
6009	+ };
6010	+
6011	+ jQuery.fragments = {};
6012	+
6013	+ jQuery.each({
6014	+ appendTo: "append",
6015	+ prependTo: "prepend",
6016	+ insertBefore: "before",
6017	+ insertAfter: "after",
6018	+ replaceAll: "replaceWith"
6019	+ }, function( name, original ) {
6020	+ jQuery.fn[ name ] = function( selector ) {
6021	+ var ret = [],
6022	+ insert = jQuery( selector ),
6023	+ parent = this.length === 1 && this[0].parentNode;
6024	+
6025	+ if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
6026	+ insert[ original ]( this[0] );
6027	+ return this;
6028	+
6029	+ } else {
6030	+ for ( var i = 0, l = insert.length; i < l; i++ ) {
6031	+ var elems = (i > 0 ? this.clone(true) : this).get();
6032	+ jQuery( insert[i] )[ original ]( elems );
6033	+ ret = ret.concat( elems );
6034	+ }
6035	+
6036	+ return this.pushStack( ret, name, insert.selector );
6037	+ }
6038	+ };
6039	+ });
6040	+
6041	+ function getAll( elem ) {
6042	+ if ( "getElementsByTagName" in elem ) {
6043	+ return elem.getElementsByTagName( "*" );
6044	+
6045	+ } else if ( "querySelectorAll" in elem ) {
6046	+ return elem.querySelectorAll( "*" );
6047	+
6048	+ } else {
6049	+ return [];
6050	+ }
6051	+ }
6052	+
6053	+ // Used in clean, fixes the defaultChecked property
6054	+ function fixDefaultChecked( elem ) {
6055	+ if ( elem.type === "checkbox" \|\| elem.type === "radio" ) {
6056	+ elem.defaultChecked = elem.checked;
6057	+ }
6058	+ }
6059	+ // Finds all inputs and passes them to fixDefaultChecked
6060	+ function findInputs( elem ) {
6061	+ if ( jQuery.nodeName( elem, "input" ) ) {
6062	+ fixDefaultChecked( elem );
6063	+ } else if ( "getElementsByTagName" in elem ) {
6064	+ jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6065	+ }
6066	+ }
6067	+
6068	+ jQuery.extend({
6069	+ clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6070	+ var clone = elem.cloneNode(true),
6071	+ srcElements,
6072	+ destElements,
6073	+ i;
6074	+
6075	+ if ( (!jQuery.support.noCloneEvent \|\| !jQuery.support.noCloneChecked) &&
6076	+ (elem.nodeType === 1 \|\| elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6077	+ // IE copies events bound via attachEvent when using cloneNode.
6078	+ // Calling detachEvent on the clone will also remove the events
6079	+ // from the original. In order to get around this, we use some
6080	+ // proprietary methods to clear the events. Thanks to MooTools
6081	+ // guys for this hotness.
6082	+
6083	+ cloneFixAttributes( elem, clone );
6084	+
6085	+ // Using Sizzle here is crazy slow, so we use getElementsByTagName
6086	+ // instead
6087	+ srcElements = getAll( elem );
6088	+ destElements = getAll( clone );
6089	+
6090	+ // Weird iteration because IE will replace the length property
6091	+ // with an element if you are cloning the body and one of the
6092	+ // elements on the page has a name or id of "length"
6093	+ for ( i = 0; srcElements[i]; ++i ) {
6094	+ // Ensure that the destination node is not null; Fixes #9587
6095	+ if ( destElements[i] ) {
6096	+ cloneFixAttributes( srcElements[i], destElements[i] );
6097	+ }
6098	+ }
6099	+ }
6100	+
6101	+ // Copy the events from the original to the clone
6102	+ if ( dataAndEvents ) {
6103	+ cloneCopyEvent( elem, clone );
6104	+
6105	+ if ( deepDataAndEvents ) {
6106	+ srcElements = getAll( elem );
6107	+ destElements = getAll( clone );
6108	+
6109	+ for ( i = 0; srcElements[i]; ++i ) {
6110	+ cloneCopyEvent( srcElements[i], destElements[i] );
6111	+ }
6112	+ }
6113	+ }
6114	+
6115	+ srcElements = destElements = null;
6116	+
6117	+ // Return the cloned set
6118	+ return clone;
6119	+ },
6120	+
6121	+ clean: function( elems, context, fragment, scripts ) {
6122	+ var checkScriptType;
6123	+
6124	+ context = context \|\| document;
6125	+
6126	+ // !context.createElement fails in IE with an error but returns typeof 'object'
6127	+ if ( typeof context.createElement === "undefined" ) {
6128	+ context = context.ownerDocument \|\| context[0] && context[0].ownerDocument \|\| document;
6129	+ }
6130	+
6131	+ var ret = [], j;
6132	+
6133	+ for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6134	+ if ( typeof elem === "number" ) {
6135	+ elem += "";
6136	+ }
6137	+
6138	+ if ( !elem ) {
6139	+ continue;
6140	+ }
6141	+
6142	+ // Convert html string into DOM nodes
6143	+ if ( typeof elem === "string" ) {
6144	+ if ( !rhtml.test( elem ) ) {
6145	+ elem = context.createTextNode( elem );
6146	+ } else {
6147	+ // Fix "XHTML"-style tags in all browsers
6148	+ elem = elem.replace(rxhtmlTag, "<$1></$2>");
6149	+
6150	+ // Trim whitespace, otherwise indexOf won't work as expected
6151	+ var tag = (rtagName.exec( elem ) \|\| ["", ""])[1].toLowerCase(),
6152	+ wrap = wrapMap[ tag ] \|\| wrapMap._default,
6153	+ depth = wrap[0],
6154	+ div = context.createElement("div");
6155	+
6156	+ // Go to html and back, then peel off extra wrappers
6157	+ div.innerHTML = wrap[1] + elem + wrap[2];
6158	+
6159	+ // Move to the right depth
6160	+ while ( depth-- ) {
6161	+ div = div.lastChild;
6162	+ }
6163	+
6164	+ // Remove IE's autoinserted <tbody> from table fragments
6165	+ if ( !jQuery.support.tbody ) {
6166	+
6167	+ // String was a <table>, may have spurious <tbody>
6168	+ var hasBody = rtbody.test(elem),
6169	+ tbody = tag === "table" && !hasBody ?
6170	+ div.firstChild && div.firstChild.childNodes :
6171	+
6172	+ // String was a bare <thead> or <tfoot>
6173	+ wrap[1] === "<table>" && !hasBody ?
6174	+ div.childNodes :
6175	+ [];
6176	+
6177	+ for ( j = tbody.length - 1; j >= 0 ; --j ) {
6178	+ if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6179	+ tbody[ j ].parentNode.removeChild( tbody[ j ] );
6180	+ }
6181	+ }
6182	+ }
6183	+
6184	+ // IE completely kills leading whitespace when innerHTML is used
6185	+ if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6186	+ div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6187	+ }
6188	+
6189	+ elem = div.childNodes;
6190	+ }
6191	+ }
6192	+
6193	+ // Resets defaultChecked for any radios and checkboxes
6194	+ // about to be appended to the DOM in IE 6/7 (#8060)
6195	+ var len;
6196	+ if ( !jQuery.support.appendChecked ) {
6197	+ if ( elem[0] && typeof (len = elem.length) === "number" ) {
6198	+ for ( j = 0; j < len; j++ ) {
6199	+ findInputs( elem[j] );
6200	+ }
6201	+ } else {
6202	+ findInputs( elem );
6203	+ }
6204	+ }
6205	+
6206	+ if ( elem.nodeType ) {
6207	+ ret.push( elem );
6208	+ } else {
6209	+ ret = jQuery.merge( ret, elem );
6210	+ }
6211	+ }
6212	+
6213	+ if ( fragment ) {
6214	+ checkScriptType = function( elem ) {
6215	+ return !elem.type \|\| rscriptType.test( elem.type );
6216	+ };
6217	+ for ( i = 0; ret[i]; i++ ) {
6218	+ if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type \|\| ret[i].type.toLowerCase() === "text/javascript") ) {
6219	+ scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6220	+
6221	+ } else {
6222	+ if ( ret[i].nodeType === 1 ) {
6223	+ var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6224	+
6225	+ ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6226	+ }
6227	+ fragment.appendChild( ret[i] );
6228	+ }
6229	+ }
6230	+ }
6231	+
6232	+ return ret;
6233	+ },
6234	+
6235	+ cleanData: function( elems ) {
6236	+ var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
6237	+ deleteExpando = jQuery.support.deleteExpando;
6238	+
6239	+ for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6240	+ if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6241	+ continue;
6242	+ }
6243	+
6244	+ id = elem[ jQuery.expando ];
6245	+
6246	+ if ( id ) {
6247	+ data = cache[ id ] && cache[ id ][ internalKey ];
6248	+
6249	+ if ( data && data.events ) {
6250	+ for ( var type in data.events ) {
6251	+ if ( special[ type ] ) {
6252	+ jQuery.event.remove( elem, type );
6253	+
6254	+ // This is a shortcut to avoid jQuery.event.remove's overhead
6255	+ } else {
6256	+ jQuery.removeEvent( elem, type, data.handle );
6257	+ }
6258	+ }
6259	+
6260	+ // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6261	+ if ( data.handle ) {
6262	+ data.handle.elem = null;
6263	+ }
6264	+ }
6265	+
6266	+ if ( deleteExpando ) {
6267	+ delete elem[ jQuery.expando ];
6268	+
6269	+ } else if ( elem.removeAttribute ) {
6270	+ elem.removeAttribute( jQuery.expando );
6271	+ }
6272	+
6273	+ delete cache[ id ];
6274	+ }
6275	+ }
6276	+ }
6277	+ });
6278	+
6279	+ function evalScript( i, elem ) {
6280	+ if ( elem.src ) {
6281	+ jQuery.ajax({
6282	+ url: elem.src,
6283	+ async: false,
6284	+ dataType: "script"
6285	+ });
6286	+ } else {
6287	+ jQuery.globalEval( ( elem.text \|\| elem.textContent \|\| elem.innerHTML \|\| "" ).replace( rcleanScript, "/$0/" ) );
6288	+ }
6289	+
6290	+ if ( elem.parentNode ) {
6291	+ elem.parentNode.removeChild( elem );
6292	+ }
6293	+ }
6294	+
6295	+
6296	+
6297	+
6298	+ var ralpha = /alpha$[^)]*$/i,
6299	+ ropacity = /opacity=([^)]*)/,
6300	+ // fixed for IE9, see #8346
6301	+ rupper = /([A-Z]\|^ms)/g,
6302	+ rnumpx = /^-?\d+(?:px)?$/i,
6303	+ rnum = /^-?\d/,
6304	+ rrelNum = /^([\-+])=([\-+.\de]+)/,
6305	+
6306	+ cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6307	+ cssWidth = [ "Left", "Right" ],
6308	+ cssHeight = [ "Top", "Bottom" ],
6309	+ curCSS,
6310	+
6311	+ getComputedStyle,
6312	+ currentStyle;
6313	+
6314	+ jQuery.fn.css = function( name, value ) {
6315	+ // Setting 'undefined' is a no-op
6316	+ if ( arguments.length === 2 && value === undefined ) {
6317	+ return this;
6318	+ }
6319	+
6320	+ return jQuery.access( this, name, value, true, function( elem, name, value ) {
6321	+ return value !== undefined ?
6322	+ jQuery.style( elem, name, value ) :
6323	+ jQuery.css( elem, name );
6324	+ });
6325	+ };
6326	+
6327	+ jQuery.extend({
6328	+ // Add in style property hooks for overriding the default
6329	+ // behavior of getting and setting a style property
6330	+ cssHooks: {
6331	+ opacity: {
6332	+ get: function( elem, computed ) {
6333	+ if ( computed ) {
6334	+ // We should always get a number back from opacity
6335	+ var ret = curCSS( elem, "opacity", "opacity" );
6336	+ return ret === "" ? "1" : ret;
6337	+
6338	+ } else {
6339	+ return elem.style.opacity;
6340	+ }
6341	+ }
6342	+ }
6343	+ },
6344	+
6345	+ // Exclude the following css properties to add px
6346	+ cssNumber: {
6347	+ "fillOpacity": true,
6348	+ "fontWeight": true,
6349	+ "lineHeight": true,
6350	+ "opacity": true,
6351	+ "orphans": true,
6352	+ "widows": true,
6353	+ "zIndex": true,
6354	+ "zoom": true
6355	+ },
6356	+
6357	+ // Add in properties whose names you wish to fix before
6358	+ // setting or getting the value
6359	+ cssProps: {
6360	+ // normalize float css property
6361	+ "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6362	+ },
6363	+
6364	+ // Get and set the style property on a DOM Node
6365	+ style: function( elem, name, value, extra ) {
6366	+ // Don't set styles on text and comment nodes
6367	+ if ( !elem \|\| elem.nodeType === 3 \|\| elem.nodeType === 8 \|\| !elem.style ) {
6368	+ return;
6369	+ }
6370	+
6371	+ // Make sure that we're working with the right name
6372	+ var ret, type, origName = jQuery.camelCase( name ),
6373	+ style = elem.style, hooks = jQuery.cssHooks[ origName ];
6374	+
6375	+ name = jQuery.cssProps[ origName ] \|\| origName;
6376	+
6377	+ // Check if we're setting a value
6378	+ if ( value !== undefined ) {
6379	+ type = typeof value;
6380	+
6381	+ // convert relative number strings (+= or -=) to relative numbers. #7345
6382	+ if ( type === "string" && (ret = rrelNum.exec( value )) ) {
6383	+ value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
6384	+ // Fixes bug #9237
6385	+ type = "number";
6386	+ }
6387	+
6388	+ // Make sure that NaN and null values aren't set. See: #7116
6389	+ if ( value == null \|\| type === "number" && isNaN( value ) ) {
6390	+ return;
6391	+ }
6392	+
6393	+ // If a number was passed in, add 'px' to the (except for certain CSS properties)
6394	+ if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6395	+ value += "px";
6396	+ }
6397	+
6398	+ // If a hook was provided, use that value, otherwise just set the specified value
6399	+ if ( !hooks \|\| !("set" in hooks) \|\| (value = hooks.set( elem, value )) !== undefined ) {
6400	+ // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6401	+ // Fixes bug #5509
6402	+ try {
6403	+ style[ name ] = value;
6404	+ } catch(e) {}
6405	+ }
6406	+
6407	+ } else {
6408	+ // If a hook was provided get the non-computed value from there
6409	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6410	+ return ret;
6411	+ }
6412	+
6413	+ // Otherwise just get the value from the style object
6414	+ return style[ name ];
6415	+ }
6416	+ },
6417	+
6418	+ css: function( elem, name, extra ) {
6419	+ var ret, hooks;
6420	+
6421	+ // Make sure that we're working with the right name
6422	+ name = jQuery.camelCase( name );
6423	+ hooks = jQuery.cssHooks[ name ];
6424	+ name = jQuery.cssProps[ name ] \|\| name;
6425	+
6426	+ // cssFloat needs a special treatment
6427	+ if ( name === "cssFloat" ) {
6428	+ name = "float";
6429	+ }
6430	+
6431	+ // If a hook was provided get the computed value from there
6432	+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6433	+ return ret;
6434	+
6435	+ // Otherwise, if a way to get the computed value exists, use that
6436	+ } else if ( curCSS ) {
6437	+ return curCSS( elem, name );
6438	+ }
6439	+ },
6440	+
6441	+ // A method for quickly swapping in/out CSS properties to get correct calculations
6442	+ swap: function( elem, options, callback ) {
6443	+ var old = {};
6444	+
6445	+ // Remember the old values, and insert the new ones
6446	+ for ( var name in options ) {
6447	+ old[ name ] = elem.style[ name ];
6448	+ elem.style[ name ] = options[ name ];
6449	+ }
6450	+
6451	+ callback.call( elem );
6452	+
6453	+ // Revert the old values
6454	+ for ( name in options ) {
6455	+ elem.style[ name ] = old[ name ];
6456	+ }
6457	+ }
6458	+ });
6459	+
6460	+ // DEPRECATED, Use jQuery.css() instead
6461	+ jQuery.curCSS = jQuery.css;
6462	+
6463	+ jQuery.each(["height", "width"], function( i, name ) {
6464	+ jQuery.cssHooks[ name ] = {
6465	+ get: function( elem, computed, extra ) {
6466	+ var val;
6467	+
6468	+ if ( computed ) {
6469	+ if ( elem.offsetWidth !== 0 ) {
6470	+ return getWH( elem, name, extra );
6471	+ } else {
6472	+ jQuery.swap( elem, cssShow, function() {
6473	+ val = getWH( elem, name, extra );
6474	+ });
6475	+ }
6476	+
6477	+ return val;
6478	+ }
6479	+ },
6480	+
6481	+ set: function( elem, value ) {
6482	+ if ( rnumpx.test( value ) ) {
6483	+ // ignore negative width and height values #1599
6484	+ value = parseFloat( value );
6485	+
6486	+ if ( value >= 0 ) {
6487	+ return value + "px";
6488	+ }
6489	+
6490	+ } else {
6491	+ return value;
6492	+ }
6493	+ }
6494	+ };
6495	+ });
6496	+
6497	+ if ( !jQuery.support.opacity ) {
6498	+ jQuery.cssHooks.opacity = {
6499	+ get: function( elem, computed ) {
6500	+ // IE uses filters for opacity
6501	+ return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) \|\| "" ) ?
6502	+ ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6503	+ computed ? "1" : "";
6504	+ },
6505	+
6506	+ set: function( elem, value ) {
6507	+ var style = elem.style,
6508	+ currentStyle = elem.currentStyle,
6509	+ opacity = jQuery.isNaN( value ) ? "" : "alpha(opacity=" + value * 100 + ")",
6510	+ filter = currentStyle && currentStyle.filter \|\| style.filter \|\| "";
6511	+
6512	+ // IE has trouble with opacity if it does not have layout
6513	+ // Force it by setting the zoom level
6514	+ style.zoom = 1;
6515	+
6516	+ // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
6517	+ if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
6518	+
6519	+ // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
6520	+ // if "filter:" is present at all, clearType is disabled, we want to avoid this
6521	+ // style.removeAttribute is IE Only, but so apparently is this code path...
6522	+ style.removeAttribute( "filter" );
6523	+
6524	+ // if there there is no filter style applied in a css rule, we are done
6525	+ if ( currentStyle && !currentStyle.filter ) {
6526	+ return;
6527	+ }
6528	+ }
6529	+
6530	+ // otherwise, set new filter values
6531	+ style.filter = ralpha.test( filter ) ?
6532	+ filter.replace( ralpha, opacity ) :
6533	+ filter + " " + opacity;
6534	+ }
6535	+ };
6536	+ }
6537	+
6538	+ jQuery(function() {
6539	+ // This hook cannot be added until DOM ready because the support test
6540	+ // for it is not run until after DOM ready
6541	+ if ( !jQuery.support.reliableMarginRight ) {
6542	+ jQuery.cssHooks.marginRight = {
6543	+ get: function( elem, computed ) {
6544	+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6545	+ // Work around by temporarily setting element display to inline-block
6546	+ var ret;
6547	+ jQuery.swap( elem, { "display": "inline-block" }, function() {
6548	+ if ( computed ) {
6549	+ ret = curCSS( elem, "margin-right", "marginRight" );
6550	+ } else {
6551	+ ret = elem.style.marginRight;
6552	+ }
6553	+ });
6554	+ return ret;
6555	+ }
6556	+ };
6557	+ }
6558	+ });
6559	+
6560	+ if ( document.defaultView && document.defaultView.getComputedStyle ) {
6561	+ getComputedStyle = function( elem, name ) {
6562	+ var ret, defaultView, computedStyle;
6563	+
6564	+ name = name.replace( rupper, "-$1" ).toLowerCase();
6565	+
6566	+ if ( !(defaultView = elem.ownerDocument.defaultView) ) {
6567	+ return undefined;
6568	+ }
6569	+
6570	+ if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6571	+ ret = computedStyle.getPropertyValue( name );
6572	+ if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6573	+ ret = jQuery.style( elem, name );
6574	+ }
6575	+ }
6576	+
6577	+ return ret;
6578	+ };
6579	+ }
6580	+
6581	+ if ( document.documentElement.currentStyle ) {
6582	+ currentStyle = function( elem, name ) {
6583	+ var left,
6584	+ ret = elem.currentStyle && elem.currentStyle[ name ],
6585	+ rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
6586	+ style = elem.style;
6587	+
6588	+ // From the awesome hack by Dean Edwards
6589	+ // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6590	+
6591	+ // If we're not dealing with a regular pixel number
6592	+ // but a number that has a weird ending, we need to convert it to pixels
6593	+ if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6594	+ // Remember the original values
6595	+ left = style.left;
6596	+
6597	+ // Put in the new values to get a computed value out
6598	+ if ( rsLeft ) {
6599	+ elem.runtimeStyle.left = elem.currentStyle.left;
6600	+ }
6601	+ style.left = name === "fontSize" ? "1em" : (ret \|\| 0);
6602	+ ret = style.pixelLeft + "px";
6603	+
6604	+ // Revert the changed values
6605	+ style.left = left;
6606	+ if ( rsLeft ) {
6607	+ elem.runtimeStyle.left = rsLeft;
6608	+ }
6609	+ }
6610	+
6611	+ return ret === "" ? "auto" : ret;
6612	+ };
6613	+ }
6614	+
6615	+ curCSS = getComputedStyle \|\| currentStyle;
6616	+
6617	+ function getWH( elem, name, extra ) {
6618	+
6619	+ // Start with offset property
6620	+ var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6621	+ which = name === "width" ? cssWidth : cssHeight;
6622	+
6623	+ if ( val > 0 ) {
6624	+ if ( extra !== "border" ) {
6625	+ jQuery.each( which, function() {
6626	+ if ( !extra ) {
6627	+ val -= parseFloat( jQuery.css( elem, "padding" + this ) ) \|\| 0;
6628	+ }
6629	+ if ( extra === "margin" ) {
6630	+ val += parseFloat( jQuery.css( elem, extra + this ) ) \|\| 0;
6631	+ } else {
6632	+ val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) \|\| 0;
6633	+ }
6634	+ });
6635	+ }
6636	+
6637	+ return val + "px";
6638	+ }
6639	+
6640	+ // Fall back to computed then uncomputed css if necessary
6641	+ val = curCSS( elem, name, name );
6642	+ if ( val < 0 \|\| val == null ) {
6643	+ val = elem.style[ name ] \|\| 0;
6644	+ }
6645	+ // Normalize "", auto, and prepare for extra
6646	+ val = parseFloat( val ) \|\| 0;
6647	+
6648	+ // Add padding, border, margin
6649	+ if ( extra ) {
6650	+ jQuery.each( which, function() {
6651	+ val += parseFloat( jQuery.css( elem, "padding" + this ) ) \|\| 0;
6652	+ if ( extra !== "padding" ) {
6653	+ val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) \|\| 0;
6654	+ }
6655	+ if ( extra === "margin" ) {
6656	+ val += parseFloat( jQuery.css( elem, extra + this ) ) \|\| 0;
6657	+ }
6658	+ });
6659	+ }
6660	+
6661	+ return val + "px";
6662	+ }
6663	+
6664	+ if ( jQuery.expr && jQuery.expr.filters ) {
6665	+ jQuery.expr.filters.hidden = function( elem ) {
6666	+ var width = elem.offsetWidth,
6667	+ height = elem.offsetHeight;
6668	+
6669	+ return (width === 0 && height === 0) \|\| (!jQuery.support.reliableHiddenOffsets && (elem.style.display \|\| jQuery.css( elem, "display" )) === "none");
6670	+ };
6671	+
6672	+ jQuery.expr.filters.visible = function( elem ) {
6673	+ return !jQuery.expr.filters.hidden( elem );
6674	+ };
6675	+ }
6676	+
6677	+
6678	+
6679	+
6680	+ var r20 = /%20/g,
6681	+ rbracket = /\[\]$/,
6682	+ rCRLF = /\r?\n/g,
6683	+ rhash = /#.*$/,
6684	+ rheaders = /^(.?):[ \t]([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6685	+ rinput = /^(?:color\|date\|datetime\|datetime-local\|email\|hidden\|month\|number\|password\|range\|search\|tel\|text\|time\|url\|week)$/i,
6686	+ // #7653, #8125, #8152: local protocol detection
6687	+ rlocalProtocol = /^(?:about\|app\|app\-storage\|.+\-extension\|file\|res\|widget):$/,
6688	+ rnoContent = /^(?:GET\|HEAD)$/,
6689	+ rprotocol = /^\/\//,
6690	+ rquery = /\?/,
6691	+ rscript = /<script\b[^<](?:(?!<\/script>)<[^<])*<\/script>/gi,
6692	+ rselectTextarea = /^(?:select\|textarea)/i,
6693	+ rspacesAjax = /\s+/,
6694	+ rts = /([?&])_=[^&]*/,
6695	+ rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6696	+
6697	+ // Keep a copy of the old load method
6698	+ _load = jQuery.fn.load,
6699	+
6700	+ /* Prefilters
6701	+ * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6702	+ * 2) These are called:
6703	+ * - BEFORE asking for a transport
6704	+ * - AFTER param serialization (s.data is a string if s.processData is true)
6705	+ * 3) key is the dataType
6706	+ * 4) the catchall symbol "*" can be used
6707	+ * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6708	+ */
6709	+ prefilters = {},
6710	+
6711	+ /* Transports bindings
6712	+ * 1) key is the dataType
6713	+ * 2) the catchall symbol "*" can be used
6714	+ * 3) selection will start with transport dataType and THEN go to "*" if needed
6715	+ */
6716	+ transports = {},
6717	+
6718	+ // Document location
6719	+ ajaxLocation,
6720	+
6721	+ // Document location segments
6722	+ ajaxLocParts,
6723	+
6724	+ // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
6725	+ allTypes = ["/"] + [""];
6726	+
6727	+ // #8138, IE may throw an exception when accessing
6728	+ // a field from window.location if document.domain has been set
6729	+ try {
6730	+ ajaxLocation = location.href;
6731	+ } catch( e ) {
6732	+ // Use the href attribute of an A element
6733	+ // since IE will modify it given document.location
6734	+ ajaxLocation = document.createElement( "a" );
6735	+ ajaxLocation.href = "";
6736	+ ajaxLocation = ajaxLocation.href;
6737	+ }
6738	+
6739	+ // Segment location into parts
6740	+ ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) \|\| [];
6741	+
6742	+ // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6743	+ function addToPrefiltersOrTransports( structure ) {
6744	+
6745	+ // dataTypeExpression is optional and defaults to "*"
6746	+ return function( dataTypeExpression, func ) {
6747	+
6748	+ if ( typeof dataTypeExpression !== "string" ) {
6749	+ func = dataTypeExpression;
6750	+ dataTypeExpression = "*";
6751	+ }
6752	+
6753	+ if ( jQuery.isFunction( func ) ) {
6754	+ var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6755	+ i = 0,
6756	+ length = dataTypes.length,
6757	+ dataType,
6758	+ list,
6759	+ placeBefore;
6760	+
6761	+ // For each dataType in the dataTypeExpression
6762	+ for(; i < length; i++ ) {
6763	+ dataType = dataTypes[ i ];
6764	+ // We control if we're asked to add before
6765	+ // any existing element
6766	+ placeBefore = /^\+/.test( dataType );
6767	+ if ( placeBefore ) {
6768	+ dataType = dataType.substr( 1 ) \|\| "*";
6769	+ }
6770	+ list = structure[ dataType ] = structure[ dataType ] \|\| [];
6771	+ // then we add to the structure accordingly
6772	+ list[ placeBefore ? "unshift" : "push" ]( func );
6773	+ }
6774	+ }
6775	+ };
6776	+ }
6777	+
6778	+ // Base inspection function for prefilters and transports
6779	+ function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6780	+ dataType /* internal /, inspected / internal */ ) {
6781	+
6782	+ dataType = dataType \|\| options.dataTypes[ 0 ];
6783	+ inspected = inspected \|\| {};
6784	+
6785	+ inspected[ dataType ] = true;
6786	+
6787	+ var list = structure[ dataType ],
6788	+ i = 0,
6789	+ length = list ? list.length : 0,
6790	+ executeOnly = ( structure === prefilters ),
6791	+ selection;
6792	+
6793	+ for(; i < length && ( executeOnly \|\| !selection ); i++ ) {
6794	+ selection = list[ i ]( options, originalOptions, jqXHR );
6795	+ // If we got redirected to another dataType
6796	+ // we try there if executing only and not done already
6797	+ if ( typeof selection === "string" ) {
6798	+ if ( !executeOnly \|\| inspected[ selection ] ) {
6799	+ selection = undefined;
6800	+ } else {
6801	+ options.dataTypes.unshift( selection );
6802	+ selection = inspectPrefiltersOrTransports(
6803	+ structure, options, originalOptions, jqXHR, selection, inspected );
6804	+ }
6805	+ }
6806	+ }
6807	+ // If we're only executing or nothing was selected
6808	+ // we try the catchall dataType if not done already
6809	+ if ( ( executeOnly \|\| !selection ) && !inspected[ "*" ] ) {
6810	+ selection = inspectPrefiltersOrTransports(
6811	+ structure, options, originalOptions, jqXHR, "*", inspected );
6812	+ }
6813	+ // unnecessary when only executing (prefilters)
6814	+ // but it'll be ignored by the caller in that case
6815	+ return selection;
6816	+ }
6817	+
6818	+ // A special extend for ajax options
6819	+ // that takes "flat" options (not to be deep extended)
6820	+ // Fixes #9887
6821	+ function ajaxExtend( target, src ) {
6822	+ var key, deep,
6823	+ flatOptions = jQuery.ajaxSettings.flatOptions \|\| {};
6824	+ for( key in src ) {
6825	+ if ( src[ key ] !== undefined ) {
6826	+ ( flatOptions[ key ] ? target : ( deep \|\| ( deep = {} ) ) )[ key ] = src[ key ];
6827	+ }
6828	+ }
6829	+ if ( deep ) {
6830	+ jQuery.extend( true, target, deep );
6831	+ }
6832	+ }
6833	+
6834	+ jQuery.fn.extend({
6835	+ load: function( url, params, callback ) {
6836	+ if ( typeof url !== "string" && _load ) {
6837	+ return _load.apply( this, arguments );
6838	+
6839	+ // Don't do a request if no elements are being requested
6840	+ } else if ( !this.length ) {
6841	+ return this;
6842	+ }
6843	+
6844	+ var off = url.indexOf( " " );
6845	+ if ( off >= 0 ) {
6846	+ var selector = url.slice( off, url.length );
6847	+ url = url.slice( 0, off );
6848	+ }
6849	+
6850	+ // Default to a GET request
6851	+ var type = "GET";
6852	+
6853	+ // If the second parameter was provided
6854	+ if ( params ) {
6855	+ // If it's a function
6856	+ if ( jQuery.isFunction( params ) ) {
6857	+ // We assume that it's the callback
6858	+ callback = params;
6859	+ params = undefined;
6860	+
6861	+ // Otherwise, build a param string
6862	+ } else if ( typeof params === "object" ) {
6863	+ params = jQuery.param( params, jQuery.ajaxSettings.traditional );
6864	+ type = "POST";
6865	+ }
6866	+ }
6867	+
6868	+ var self = this;
6869	+
6870	+ // Request the remote document
6871	+ jQuery.ajax({
6872	+ url: url,
6873	+ type: type,
6874	+ dataType: "html",
6875	+ data: params,
6876	+ // Complete callback (responseText is used internally)
6877	+ complete: function( jqXHR, status, responseText ) {
6878	+ // Store the response as specified by the jqXHR object
6879	+ responseText = jqXHR.responseText;
6880	+ // If successful, inject the HTML into all the matched elements
6881	+ if ( jqXHR.isResolved() ) {
6882	+ // #4825: Get the actual response in case
6883	+ // a dataFilter is present in ajaxSettings
6884	+ jqXHR.done(function( r ) {
6885	+ responseText = r;
6886	+ });
6887	+ // See if a selector was specified
6888	+ self.html( selector ?
6889	+ // Create a dummy div to hold the results
6890	+ jQuery("<div>")
6891	+ // inject the contents of the document in, removing the scripts
6892	+ // to avoid any 'Permission Denied' errors in IE
6893	+ .append(responseText.replace(rscript, ""))
6894	+
6895	+ // Locate the specified elements
6896	+ .find(selector) :
6897	+
6898	+ // If not, just inject the full result
6899	+ responseText );
6900	+ }
6901	+
6902	+ if ( callback ) {
6903	+ self.each( callback, [ responseText, status, jqXHR ] );
6904	+ }
6905	+ }
6906	+ });
6907	+
6908	+ return this;
6909	+ },
6910	+
6911	+ serialize: function() {
6912	+ return jQuery.param( this.serializeArray() );
6913	+ },
6914	+
6915	+ serializeArray: function() {
6916	+ return this.map(function(){
6917	+ return this.elements ? jQuery.makeArray( this.elements ) : this;
6918	+ })
6919	+ .filter(function(){
6920	+ return this.name && !this.disabled &&
6921	+ ( this.checked \|\| rselectTextarea.test( this.nodeName ) \|\|
6922	+ rinput.test( this.type ) );
6923	+ })
6924	+ .map(function( i, elem ){
6925	+ var val = jQuery( this ).val();
6926	+
6927	+ return val == null ?
6928	+ null :
6929	+ jQuery.isArray( val ) ?
6930	+ jQuery.map( val, function( val, i ){
6931	+ return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6932	+ }) :
6933	+ { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6934	+ }).get();
6935	+ }
6936	+ });
6937	+
6938	+ // Attach a bunch of functions for handling common AJAX events
6939	+ jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6940	+ jQuery.fn[ o ] = function( f ){
6941	+ return this.bind( o, f );
6942	+ };
6943	+ });
6944	+
6945	+ jQuery.each( [ "get", "post" ], function( i, method ) {
6946	+ jQuery[ method ] = function( url, data, callback, type ) {
6947	+ // shift arguments if data argument was omitted
6948	+ if ( jQuery.isFunction( data ) ) {
6949	+ type = type \|\| callback;
6950	+ callback = data;
6951	+ data = undefined;
6952	+ }
6953	+
6954	+ return jQuery.ajax({
6955	+ type: method,
6956	+ url: url,
6957	+ data: data,
6958	+ success: callback,
6959	+ dataType: type
6960	+ });
6961	+ };
6962	+ });
6963	+
6964	+ jQuery.extend({
6965	+
6966	+ getScript: function( url, callback ) {
6967	+ return jQuery.get( url, undefined, callback, "script" );
6968	+ },
6969	+
6970	+ getJSON: function( url, data, callback ) {
6971	+ return jQuery.get( url, data, callback, "json" );
6972	+ },
6973	+
6974	+ // Creates a full fledged settings object into target
6975	+ // with both ajaxSettings and settings fields.
6976	+ // If target is omitted, writes into ajaxSettings.
6977	+ ajaxSetup: function( target, settings ) {
6978	+ if ( settings ) {
6979	+ // Building a settings object
6980	+ ajaxExtend( target, jQuery.ajaxSettings );
6981	+ } else {
6982	+ // Extending ajaxSettings
6983	+ settings = target;
6984	+ target = jQuery.ajaxSettings;
6985	+ }
6986	+ ajaxExtend( target, settings );
6987	+ return target;
6988	+ },
6989	+
6990	+ ajaxSettings: {
6991	+ url: ajaxLocation,
6992	+ isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
6993	+ global: true,
6994	+ type: "GET",
6995	+ contentType: "application/x-www-form-urlencoded",
6996	+ processData: true,
6997	+ async: true,
6998	+ /*
6999	+ timeout: 0,
7000	+ data: null,
7001	+ dataType: null,
7002	+ username: null,
7003	+ password: null,
7004	+ cache: null,
7005	+ traditional: false,
7006	+ headers: {},
7007	+ */
7008	+
7009	+ accepts: {
7010	+ xml: "application/xml, text/xml",
7011	+ html: "text/html",
7012	+ text: "text/plain",
7013	+ json: "application/json, text/javascript",
7014	+ "*": allTypes
7015	+ },
7016	+
7017	+ contents: {
7018	+ xml: /xml/,
7019	+ html: /html/,
7020	+ json: /json/
7021	+ },
7022	+
7023	+ responseFields: {
7024	+ xml: "responseXML",
7025	+ text: "responseText"
7026	+ },
7027	+
7028	+ // List of data converters
7029	+ // 1) key format is "source_type destination_type" (a single space in-between)
7030	+ // 2) the catchall symbol "*" can be used for source_type
7031	+ converters: {
7032	+
7033	+ // Convert anything to text
7034	+ "* text": window.String,
7035	+
7036	+ // Text to html (true = no transformation)
7037	+ "text html": true,
7038	+
7039	+ // Evaluate text as a json expression
7040	+ "text json": jQuery.parseJSON,
7041	+
7042	+ // Parse text as xml
7043	+ "text xml": jQuery.parseXML
7044	+ },
7045	+
7046	+ // For options that shouldn't be deep extended:
7047	+ // you can add your own custom options here if
7048	+ // and when you create one that shouldn't be
7049	+ // deep extended (see ajaxExtend)
7050	+ flatOptions: {
7051	+ context: true,
7052	+ url: true
7053	+ }
7054	+ },
7055	+
7056	+ ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
7057	+ ajaxTransport: addToPrefiltersOrTransports( transports ),
7058	+
7059	+ // Main method
7060	+ ajax: function( url, options ) {
7061	+
7062	+ // If url is an object, simulate pre-1.5 signature
7063	+ if ( typeof url === "object" ) {
7064	+ options = url;
7065	+ url = undefined;
7066	+ }
7067	+
7068	+ // Force options to be an object
7069	+ options = options \|\| {};
7070	+
7071	+ var // Create the final options object
7072	+ s = jQuery.ajaxSetup( {}, options ),
7073	+ // Callbacks context
7074	+ callbackContext = s.context \|\| s,
7075	+ // Context for global events
7076	+ // It's the callbackContext if one was provided in the options
7077	+ // and if it's a DOM node or a jQuery collection
7078	+ globalEventContext = callbackContext !== s &&
7079	+ ( callbackContext.nodeType \|\| callbackContext instanceof jQuery ) ?
7080	+ jQuery( callbackContext ) : jQuery.event,
7081	+ // Deferreds
7082	+ deferred = jQuery.Deferred(),
7083	+ completeDeferred = jQuery._Deferred(),
7084	+ // Status-dependent callbacks
7085	+ statusCode = s.statusCode \|\| {},
7086	+ // ifModified key
7087	+ ifModifiedKey,
7088	+ // Headers (they are sent all at once)
7089	+ requestHeaders = {},
7090	+ requestHeadersNames = {},
7091	+ // Response headers
7092	+ responseHeadersString,
7093	+ responseHeaders,
7094	+ // transport
7095	+ transport,
7096	+ // timeout handle
7097	+ timeoutTimer,
7098	+ // Cross-domain detection vars
7099	+ parts,
7100	+ // The jqXHR state
7101	+ state = 0,
7102	+ // To know if global events are to be dispatched
7103	+ fireGlobals,
7104	+ // Loop variable
7105	+ i,
7106	+ // Fake xhr
7107	+ jqXHR = {
7108	+
7109	+ readyState: 0,
7110	+
7111	+ // Caches the header
7112	+ setRequestHeader: function( name, value ) {
7113	+ if ( !state ) {
7114	+ var lname = name.toLowerCase();
7115	+ name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] \|\| name;
7116	+ requestHeaders[ name ] = value;
7117	+ }
7118	+ return this;
7119	+ },
7120	+
7121	+ // Raw string
7122	+ getAllResponseHeaders: function() {
7123	+ return state === 2 ? responseHeadersString : null;
7124	+ },
7125	+
7126	+ // Builds headers hashtable if needed
7127	+ getResponseHeader: function( key ) {
7128	+ var match;
7129	+ if ( state === 2 ) {
7130	+ if ( !responseHeaders ) {
7131	+ responseHeaders = {};
7132	+ while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7133	+ responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7134	+ }
7135	+ }
7136	+ match = responseHeaders[ key.toLowerCase() ];
7137	+ }
7138	+ return match === undefined ? null : match;
7139	+ },
7140	+
7141	+ // Overrides response content-type header
7142	+ overrideMimeType: function( type ) {
7143	+ if ( !state ) {
7144	+ s.mimeType = type;
7145	+ }
7146	+ return this;
7147	+ },
7148	+
7149	+ // Cancel the request
7150	+ abort: function( statusText ) {
7151	+ statusText = statusText \|\| "abort";
7152	+ if ( transport ) {
7153	+ transport.abort( statusText );
7154	+ }
7155	+ done( 0, statusText );
7156	+ return this;
7157	+ }
7158	+ };
7159	+
7160	+ // Callback for when everything is done
7161	+ // It is defined here because jslint complains if it is declared
7162	+ // at the end of the function (which would be more logical and readable)
7163	+ function done( status, nativeStatusText, responses, headers ) {
7164	+
7165	+ // Called once
7166	+ if ( state === 2 ) {
7167	+ return;
7168	+ }
7169	+
7170	+ // State is "done" now
7171	+ state = 2;
7172	+
7173	+ // Clear timeout if it exists
7174	+ if ( timeoutTimer ) {
7175	+ clearTimeout( timeoutTimer );
7176	+ }
7177	+
7178	+ // Dereference transport for early garbage collection
7179	+ // (no matter how long the jqXHR object will be used)
7180	+ transport = undefined;
7181	+
7182	+ // Cache response headers
7183	+ responseHeadersString = headers \|\| "";
7184	+
7185	+ // Set readyState
7186	+ jqXHR.readyState = status > 0 ? 4 : 0;
7187	+
7188	+ var isSuccess,
7189	+ success,
7190	+ error,
7191	+ statusText = nativeStatusText,
7192	+ response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7193	+ lastModified,
7194	+ etag;
7195	+
7196	+ // If successful, handle type chaining
7197	+ if ( status >= 200 && status < 300 \|\| status === 304 ) {
7198	+
7199	+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7200	+ if ( s.ifModified ) {
7201	+
7202	+ if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7203	+ jQuery.lastModified[ ifModifiedKey ] = lastModified;
7204	+ }
7205	+ if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7206	+ jQuery.etag[ ifModifiedKey ] = etag;
7207	+ }
7208	+ }
7209	+
7210	+ // If not modified
7211	+ if ( status === 304 ) {
7212	+
7213	+ statusText = "notmodified";
7214	+ isSuccess = true;
7215	+
7216	+ // If we have data
7217	+ } else {
7218	+
7219	+ try {
7220	+ success = ajaxConvert( s, response );
7221	+ statusText = "success";
7222	+ isSuccess = true;
7223	+ } catch(e) {
7224	+ // We have a parsererror
7225	+ statusText = "parsererror";
7226	+ error = e;
7227	+ }
7228	+ }
7229	+ } else {
7230	+ // We extract error from statusText
7231	+ // then normalize statusText and status for non-aborts
7232	+ error = statusText;
7233	+ if( !statusText \|\| status ) {
7234	+ statusText = "error";
7235	+ if ( status < 0 ) {
7236	+ status = 0;
7237	+ }
7238	+ }
7239	+ }
7240	+
7241	+ // Set data for the fake xhr object
7242	+ jqXHR.status = status;
7243	+ jqXHR.statusText = "" + ( nativeStatusText \|\| statusText );
7244	+
7245	+ // Success/Error
7246	+ if ( isSuccess ) {
7247	+ deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7248	+ } else {
7249	+ deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7250	+ }
7251	+
7252	+ // Status-dependent callbacks
7253	+ jqXHR.statusCode( statusCode );
7254	+ statusCode = undefined;
7255	+
7256	+ if ( fireGlobals ) {
7257	+ globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7258	+ [ jqXHR, s, isSuccess ? success : error ] );
7259	+ }
7260	+
7261	+ // Complete
7262	+ completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
7263	+
7264	+ if ( fireGlobals ) {
7265	+ globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
7266	+ // Handle the global AJAX counter
7267	+ if ( !( --jQuery.active ) ) {
7268	+ jQuery.event.trigger( "ajaxStop" );
7269	+ }
7270	+ }
7271	+ }
7272	+
7273	+ // Attach deferreds
7274	+ deferred.promise( jqXHR );
7275	+ jqXHR.success = jqXHR.done;
7276	+ jqXHR.error = jqXHR.fail;
7277	+ jqXHR.complete = completeDeferred.done;
7278	+
7279	+ // Status-dependent callbacks
7280	+ jqXHR.statusCode = function( map ) {
7281	+ if ( map ) {
7282	+ var tmp;
7283	+ if ( state < 2 ) {
7284	+ for( tmp in map ) {
7285	+ statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7286	+ }
7287	+ } else {
7288	+ tmp = map[ jqXHR.status ];
7289	+ jqXHR.then( tmp, tmp );
7290	+ }
7291	+ }
7292	+ return this;
7293	+ };
7294	+
7295	+ // Remove hash character (#7531: and string promotion)
7296	+ // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7297	+ // We also use the url parameter if available
7298	+ s.url = ( ( url \|\| s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7299	+
7300	+ // Extract dataTypes list
7301	+ s.dataTypes = jQuery.trim( s.dataType \|\| "*" ).toLowerCase().split( rspacesAjax );
7302	+
7303	+ // Determine if a cross-domain request is in order
7304	+ if ( s.crossDomain == null ) {
7305	+ parts = rurl.exec( s.url.toLowerCase() );
7306	+ s.crossDomain = !!( parts &&
7307	+ ( parts[ 1 ] != ajaxLocParts[ 1 ] \|\| parts[ 2 ] != ajaxLocParts[ 2 ] \|\|
7308	+ ( parts[ 3 ] \|\| ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7309	+ ( ajaxLocParts[ 3 ] \|\| ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7310	+ );
7311	+ }
7312	+
7313	+ // Convert data if not already a string
7314	+ if ( s.data && s.processData && typeof s.data !== "string" ) {
7315	+ s.data = jQuery.param( s.data, s.traditional );
7316	+ }
7317	+
7318	+ // Apply prefilters
7319	+ inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7320	+
7321	+ // If request was aborted inside a prefiler, stop there
7322	+ if ( state === 2 ) {
7323	+ return false;
7324	+ }
7325	+
7326	+ // We can fire global events as of now if asked to
7327	+ fireGlobals = s.global;
7328	+
7329	+ // Uppercase the type
7330	+ s.type = s.type.toUpperCase();
7331	+
7332	+ // Determine if request has content
7333	+ s.hasContent = !rnoContent.test( s.type );
7334	+
7335	+ // Watch for a new set of requests
7336	+ if ( fireGlobals && jQuery.active++ === 0 ) {
7337	+ jQuery.event.trigger( "ajaxStart" );
7338	+ }
7339	+
7340	+ // More options handling for requests with no content
7341	+ if ( !s.hasContent ) {
7342	+
7343	+ // If data is available, append data to url
7344	+ if ( s.data ) {
7345	+ s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7346	+ // #9682: remove data so that it's not used in an eventual retry
7347	+ delete s.data;
7348	+ }
7349	+
7350	+ // Get ifModifiedKey before adding the anti-cache parameter
7351	+ ifModifiedKey = s.url;
7352	+
7353	+ // Add anti-cache in url if needed
7354	+ if ( s.cache === false ) {
7355	+
7356	+ var ts = jQuery.now(),
7357	+ // try replacing _= if it is there
7358	+ ret = s.url.replace( rts, "$1_=" + ts );
7359	+
7360	+ // if nothing was replaced, add timestamp to the end
7361	+ s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7362	+ }
7363	+ }
7364	+
7365	+ // Set the correct header, if data is being sent
7366	+ if ( s.data && s.hasContent && s.contentType !== false \|\| options.contentType ) {
7367	+ jqXHR.setRequestHeader( "Content-Type", s.contentType );
7368	+ }
7369	+
7370	+ // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7371	+ if ( s.ifModified ) {
7372	+ ifModifiedKey = ifModifiedKey \|\| s.url;
7373	+ if ( jQuery.lastModified[ ifModifiedKey ] ) {
7374	+ jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7375	+ }
7376	+ if ( jQuery.etag[ ifModifiedKey ] ) {
7377	+ jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7378	+ }
7379	+ }
7380	+
7381	+ // Set the Accepts header for the server, depending on the dataType
7382	+ jqXHR.setRequestHeader(
7383	+ "Accept",
7384	+ s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7385	+ s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
7386	+ s.accepts[ "*" ]
7387	+ );
7388	+
7389	+ // Check for headers option
7390	+ for ( i in s.headers ) {
7391	+ jqXHR.setRequestHeader( i, s.headers[ i ] );
7392	+ }
7393	+
7394	+ // Allow custom headers/mimetypes and early abort
7395	+ if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false \|\| state === 2 ) ) {
7396	+ // Abort if not done already
7397	+ jqXHR.abort();
7398	+ return false;
7399	+
7400	+ }
7401	+
7402	+ // Install callbacks on deferreds
7403	+ for ( i in { success: 1, error: 1, complete: 1 } ) {
7404	+ jqXHR[ i ]( s[ i ] );
7405	+ }
7406	+
7407	+ // Get transport
7408	+ transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7409	+
7410	+ // If no transport, we auto-abort
7411	+ if ( !transport ) {
7412	+ done( -1, "No Transport" );
7413	+ } else {
7414	+ jqXHR.readyState = 1;
7415	+ // Send global event
7416	+ if ( fireGlobals ) {
7417	+ globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7418	+ }
7419	+ // Timeout
7420	+ if ( s.async && s.timeout > 0 ) {
7421	+ timeoutTimer = setTimeout( function(){
7422	+ jqXHR.abort( "timeout" );
7423	+ }, s.timeout );
7424	+ }
7425	+
7426	+ try {
7427	+ state = 1;
7428	+ transport.send( requestHeaders, done );
7429	+ } catch (e) {
7430	+ // Propagate exception as error if not done
7431	+ if ( state < 2 ) {
7432	+ done( -1, e );
7433	+ // Simply rethrow otherwise
7434	+ } else {
7435	+ jQuery.error( e );
7436	+ }
7437	+ }
7438	+ }
7439	+
7440	+ return jqXHR;
7441	+ },
7442	+
7443	+ // Serialize an array of form elements or a set of
7444	+ // key/values into a query string
7445	+ param: function( a, traditional ) {
7446	+ var s = [],
7447	+ add = function( key, value ) {
7448	+ // If value is a function, invoke it and return its value
7449	+ value = jQuery.isFunction( value ) ? value() : value;
7450	+ s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7451	+ };
7452	+
7453	+ // Set traditional to true for jQuery <= 1.3.2 behavior.
7454	+ if ( traditional === undefined ) {
7455	+ traditional = jQuery.ajaxSettings.traditional;
7456	+ }
7457	+
7458	+ // If an array was passed in, assume that it is an array of form elements.
7459	+ if ( jQuery.isArray( a ) \|\| ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7460	+ // Serialize the form elements
7461	+ jQuery.each( a, function() {
7462	+ add( this.name, this.value );
7463	+ });
7464	+
7465	+ } else {
7466	+ // If traditional, encode the "old" way (the way 1.3.2 or older
7467	+ // did it), otherwise encode params recursively.
7468	+ for ( var prefix in a ) {
7469	+ buildParams( prefix, a[ prefix ], traditional, add );
7470	+ }
7471	+ }
7472	+
7473	+ // Return the resulting serialization
7474	+ return s.join( "&" ).replace( r20, "+" );
7475	+ }
7476	+ });
7477	+
7478	+ function buildParams( prefix, obj, traditional, add ) {
7479	+ if ( jQuery.isArray( obj ) ) {
7480	+ // Serialize array item.
7481	+ jQuery.each( obj, function( i, v ) {
7482	+ if ( traditional \|\| rbracket.test( prefix ) ) {
7483	+ // Treat each array item as a scalar.
7484	+ add( prefix, v );
7485	+
7486	+ } else {
7487	+ // If array item is non-scalar (array or object), encode its
7488	+ // numeric index to resolve deserialization ambiguity issues.
7489	+ // Note that rack (as of 1.0.0) can't currently deserialize
7490	+ // nested arrays properly, and attempting to do so may cause
7491	+ // a server error. Possible fixes are to modify rack's
7492	+ // deserialization algorithm or to provide an option or flag
7493	+ // to force array serialization to be shallow.
7494	+ buildParams( prefix + "[" + ( typeof v === "object" \|\| jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7495	+ }
7496	+ });
7497	+
7498	+ } else if ( !traditional && obj != null && typeof obj === "object" ) {
7499	+ // Serialize object item.
7500	+ for ( var name in obj ) {
7501	+ buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7502	+ }
7503	+
7504	+ } else {
7505	+ // Serialize scalar item.
7506	+ add( prefix, obj );
7507	+ }
7508	+ }
7509	+
7510	+ // This is still on the jQuery object... for now
7511	+ // Want to move this to jQuery.ajax some day
7512	+ jQuery.extend({
7513	+
7514	+ // Counter for holding the number of active queries
7515	+ active: 0,
7516	+
7517	+ // Last-Modified header cache for next request
7518	+ lastModified: {},
7519	+ etag: {}
7520	+
7521	+ });
7522	+
7523	+ /* Handles responses to an ajax request:
7524	+ * - sets all responseXXX fields accordingly
7525	+ * - finds the right dataType (mediates between content-type and expected dataType)
7526	+ * - returns the corresponding response
7527	+ */
7528	+ function ajaxHandleResponses( s, jqXHR, responses ) {
7529	+
7530	+ var contents = s.contents,
7531	+ dataTypes = s.dataTypes,
7532	+ responseFields = s.responseFields,
7533	+ ct,
7534	+ type,
7535	+ finalDataType,
7536	+ firstDataType;
7537	+
7538	+ // Fill responseXXX fields
7539	+ for( type in responseFields ) {
7540	+ if ( type in responses ) {
7541	+ jqXHR[ responseFields[type] ] = responses[ type ];
7542	+ }
7543	+ }
7544	+
7545	+ // Remove auto dataType and get content-type in the process
7546	+ while( dataTypes[ 0 ] === "*" ) {
7547	+ dataTypes.shift();
7548	+ if ( ct === undefined ) {
7549	+ ct = s.mimeType \|\| jqXHR.getResponseHeader( "content-type" );
7550	+ }
7551	+ }
7552	+
7553	+ // Check if we're dealing with a known content-type
7554	+ if ( ct ) {
7555	+ for ( type in contents ) {
7556	+ if ( contents[ type ] && contents[ type ].test( ct ) ) {
7557	+ dataTypes.unshift( type );
7558	+ break;
7559	+ }
7560	+ }
7561	+ }
7562	+
7563	+ // Check to see if we have a response for the expected dataType
7564	+ if ( dataTypes[ 0 ] in responses ) {
7565	+ finalDataType = dataTypes[ 0 ];
7566	+ } else {
7567	+ // Try convertible dataTypes
7568	+ for ( type in responses ) {
7569	+ if ( !dataTypes[ 0 ] \|\| s.converters[ type + " " + dataTypes[0] ] ) {
7570	+ finalDataType = type;
7571	+ break;
7572	+ }
7573	+ if ( !firstDataType ) {
7574	+ firstDataType = type;
7575	+ }
7576	+ }
7577	+ // Or just use first one
7578	+ finalDataType = finalDataType \|\| firstDataType;
7579	+ }
7580	+
7581	+ // If we found a dataType
7582	+ // We add the dataType to the list if needed
7583	+ // and return the corresponding response
7584	+ if ( finalDataType ) {
7585	+ if ( finalDataType !== dataTypes[ 0 ] ) {
7586	+ dataTypes.unshift( finalDataType );
7587	+ }
7588	+ return responses[ finalDataType ];
7589	+ }
7590	+ }
7591	+
7592	+ // Chain conversions given the request and the original response
7593	+ function ajaxConvert( s, response ) {
7594	+
7595	+ // Apply the dataFilter if provided
7596	+ if ( s.dataFilter ) {
7597	+ response = s.dataFilter( response, s.dataType );
7598	+ }
7599	+
7600	+ var dataTypes = s.dataTypes,
7601	+ converters = {},
7602	+ i,
7603	+ key,
7604	+ length = dataTypes.length,
7605	+ tmp,
7606	+ // Current and previous dataTypes
7607	+ current = dataTypes[ 0 ],
7608	+ prev,
7609	+ // Conversion expression
7610	+ conversion,
7611	+ // Conversion function
7612	+ conv,
7613	+ // Conversion functions (transitive conversion)
7614	+ conv1,
7615	+ conv2;
7616	+
7617	+ // For each dataType in the chain
7618	+ for( i = 1; i < length; i++ ) {
7619	+
7620	+ // Create converters map
7621	+ // with lowercased keys
7622	+ if ( i === 1 ) {
7623	+ for( key in s.converters ) {
7624	+ if( typeof key === "string" ) {
7625	+ converters[ key.toLowerCase() ] = s.converters[ key ];
7626	+ }
7627	+ }
7628	+ }
7629	+
7630	+ // Get the dataTypes
7631	+ prev = current;
7632	+ current = dataTypes[ i ];
7633	+
7634	+ // If current is auto dataType, update it to prev
7635	+ if( current === "*" ) {
7636	+ current = prev;
7637	+ // If no auto and dataTypes are actually different
7638	+ } else if ( prev !== "*" && prev !== current ) {
7639	+
7640	+ // Get the converter
7641	+ conversion = prev + " " + current;
7642	+ conv = converters[ conversion ] \|\| converters[ "* " + current ];
7643	+
7644	+ // If there is no direct converter, search transitively
7645	+ if ( !conv ) {
7646	+ conv2 = undefined;
7647	+ for( conv1 in converters ) {
7648	+ tmp = conv1.split( " " );
7649	+ if ( tmp[ 0 ] === prev \|\| tmp[ 0 ] === "*" ) {
7650	+ conv2 = converters[ tmp[1] + " " + current ];
7651	+ if ( conv2 ) {
7652	+ conv1 = converters[ conv1 ];
7653	+ if ( conv1 === true ) {
7654	+ conv = conv2;
7655	+ } else if ( conv2 === true ) {
7656	+ conv = conv1;
7657	+ }
7658	+ break;
7659	+ }
7660	+ }
7661	+ }
7662	+ }
7663	+ // If we found no converter, dispatch an error
7664	+ if ( !( conv \|\| conv2 ) ) {
7665	+ jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7666	+ }
7667	+ // If found converter is not an equivalence
7668	+ if ( conv !== true ) {
7669	+ // Convert with 1 or 2 converters accordingly
7670	+ response = conv ? conv( response ) : conv2( conv1(response) );
7671	+ }
7672	+ }
7673	+ }
7674	+ return response;
7675	+ }
7676	+
7677	+
7678	+
7679	+
7680	+ var jsc = jQuery.now(),
7681	+ jsre = /(\=)\?(&\|$)\|\?\?/i;
7682	+
7683	+ // Default jsonp settings
7684	+ jQuery.ajaxSetup({
7685	+ jsonp: "callback",
7686	+ jsonpCallback: function() {
7687	+ return jQuery.expando + "_" + ( jsc++ );
7688	+ }
7689	+ });
7690	+
7691	+ // Detect, normalize options and install callbacks for jsonp requests
7692	+ jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7693	+
7694	+ var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7695	+ ( typeof s.data === "string" );
7696	+
7697	+ if ( s.dataTypes[ 0 ] === "jsonp" \|\|
7698	+ s.jsonp !== false && ( jsre.test( s.url ) \|\|
7699	+ inspectData && jsre.test( s.data ) ) ) {
7700	+
7701	+ var responseContainer,
7702	+ jsonpCallback = s.jsonpCallback =
7703	+ jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7704	+ previous = window[ jsonpCallback ],
7705	+ url = s.url,
7706	+ data = s.data,
7707	+ replace = "$1" + jsonpCallback + "$2";
7708	+
7709	+ if ( s.jsonp !== false ) {
7710	+ url = url.replace( jsre, replace );
7711	+ if ( s.url === url ) {
7712	+ if ( inspectData ) {
7713	+ data = data.replace( jsre, replace );
7714	+ }
7715	+ if ( s.data === data ) {
7716	+ // Add callback manually
7717	+ url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7718	+ }
7719	+ }
7720	+ }
7721	+
7722	+ s.url = url;
7723	+ s.data = data;
7724	+
7725	+ // Install callback
7726	+ window[ jsonpCallback ] = function( response ) {
7727	+ responseContainer = [ response ];
7728	+ };
7729	+
7730	+ // Clean-up function
7731	+ jqXHR.always(function() {
7732	+ // Set callback back to previous value
7733	+ window[ jsonpCallback ] = previous;
7734	+ // Call if it was a function and we have a response
7735	+ if ( responseContainer && jQuery.isFunction( previous ) ) {
7736	+ window[ jsonpCallback ]( responseContainer[ 0 ] );
7737	+ }
7738	+ });
7739	+
7740	+ // Use data converter to retrieve json after script execution
7741	+ s.converters["script json"] = function() {
7742	+ if ( !responseContainer ) {
7743	+ jQuery.error( jsonpCallback + " was not called" );
7744	+ }
7745	+ return responseContainer[ 0 ];
7746	+ };
7747	+
7748	+ // force json dataType
7749	+ s.dataTypes[ 0 ] = "json";
7750	+
7751	+ // Delegate to script
7752	+ return "script";
7753	+ }
7754	+ });
7755	+
7756	+
7757	+
7758	+
7759	+ // Install script dataType
7760	+ jQuery.ajaxSetup({
7761	+ accepts: {
7762	+ script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7763	+ },
7764	+ contents: {
7765	+ script: /javascript\|ecmascript/
7766	+ },
7767	+ converters: {
7768	+ "text script": function( text ) {
7769	+ jQuery.globalEval( text );
7770	+ return text;
7771	+ }
7772	+ }
7773	+ });
7774	+
7775	+ // Handle cache's special case and global
7776	+ jQuery.ajaxPrefilter( "script", function( s ) {
7777	+ if ( s.cache === undefined ) {
7778	+ s.cache = false;
7779	+ }
7780	+ if ( s.crossDomain ) {
7781	+ s.type = "GET";
7782	+ s.global = false;
7783	+ }
7784	+ });
7785	+
7786	+ // Bind script tag hack transport
7787	+ jQuery.ajaxTransport( "script", function(s) {
7788	+
7789	+ // This transport only deals with cross domain requests
7790	+ if ( s.crossDomain ) {
7791	+
7792	+ var script,
7793	+ head = document.head \|\| document.getElementsByTagName( "head" )[0] \|\| document.documentElement;
7794	+
7795	+ return {
7796	+
7797	+ send: function( _, callback ) {
7798	+
7799	+ script = document.createElement( "script" );
7800	+
7801	+ script.async = "async";
7802	+
7803	+ if ( s.scriptCharset ) {
7804	+ script.charset = s.scriptCharset;
7805	+ }
7806	+
7807	+ script.src = s.url;
7808	+
7809	+ // Attach handlers for all browsers
7810	+ script.onload = script.onreadystatechange = function( _, isAbort ) {
7811	+
7812	+ if ( isAbort \|\| !script.readyState \|\| /loaded\|complete/.test( script.readyState ) ) {
7813	+
7814	+ // Handle memory leak in IE
7815	+ script.onload = script.onreadystatechange = null;
7816	+
7817	+ // Remove the script
7818	+ if ( head && script.parentNode ) {
7819	+ head.removeChild( script );
7820	+ }
7821	+
7822	+ // Dereference the script
7823	+ script = undefined;
7824	+
7825	+ // Callback if not abort
7826	+ if ( !isAbort ) {
7827	+ callback( 200, "success" );
7828	+ }
7829	+ }
7830	+ };
7831	+ // Use insertBefore instead of appendChild to circumvent an IE6 bug.
7832	+ // This arises when a base node is used (#2709 and #4378).
7833	+ head.insertBefore( script, head.firstChild );
7834	+ },
7835	+
7836	+ abort: function() {
7837	+ if ( script ) {
7838	+ script.onload( 0, 1 );
7839	+ }
7840	+ }
7841	+ };
7842	+ }
7843	+ });
7844	+
7845	+
7846	+
7847	+
7848	+ var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
7849	+ xhrOnUnloadAbort = window.ActiveXObject ? function() {
7850	+ // Abort all pending requests
7851	+ for ( var key in xhrCallbacks ) {
7852	+ xhrCallbacks[ key ]( 0, 1 );
7853	+ }
7854	+ } : false,
7855	+ xhrId = 0,
7856	+ xhrCallbacks;
7857	+
7858	+ // Functions to create xhrs
7859	+ function createStandardXHR() {
7860	+ try {
7861	+ return new window.XMLHttpRequest();
7862	+ } catch( e ) {}
7863	+ }
7864	+
7865	+ function createActiveXHR() {
7866	+ try {
7867	+ return new window.ActiveXObject( "Microsoft.XMLHTTP" );
7868	+ } catch( e ) {}
7869	+ }
7870	+
7871	+ // Create the request object
7872	+ // (This is still attached to ajaxSettings for backward compatibility)
7873	+ jQuery.ajaxSettings.xhr = window.ActiveXObject ?
7874	+ /* Microsoft failed to properly
7875	+ * implement the XMLHttpRequest in IE7 (can't request local files),
7876	+ * so we use the ActiveXObject when it is available
7877	+ * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
7878	+ * we need a fallback.
7879	+ */
7880	+ function() {
7881	+ return !this.isLocal && createStandardXHR() \|\| createActiveXHR();
7882	+ } :
7883	+ // For all other browsers, use the standard XMLHttpRequest object
7884	+ createStandardXHR;
7885	+
7886	+ // Determine support properties
7887	+ (function( xhr ) {
7888	+ jQuery.extend( jQuery.support, {
7889	+ ajax: !!xhr,
7890	+ cors: !!xhr && ( "withCredentials" in xhr )
7891	+ });
7892	+ })( jQuery.ajaxSettings.xhr() );
7893	+
7894	+ // Create transport if the browser can provide an xhr
7895	+ if ( jQuery.support.ajax ) {
7896	+
7897	+ jQuery.ajaxTransport(function( s ) {
7898	+ // Cross domain only allowed if supported through XMLHttpRequest
7899	+ if ( !s.crossDomain \|\| jQuery.support.cors ) {
7900	+
7901	+ var callback;
7902	+
7903	+ return {
7904	+ send: function( headers, complete ) {
7905	+
7906	+ // Get a new xhr
7907	+ var xhr = s.xhr(),
7908	+ handle,
7909	+ i;
7910	+
7911	+ // Open the socket
7912	+ // Passing null username, generates a login popup on Opera (#2865)
7913	+ if ( s.username ) {
7914	+ xhr.open( s.type, s.url, s.async, s.username, s.password );
7915	+ } else {
7916	+ xhr.open( s.type, s.url, s.async );
7917	+ }
7918	+
7919	+ // Apply custom fields if provided
7920	+ if ( s.xhrFields ) {
7921	+ for ( i in s.xhrFields ) {
7922	+ xhr[ i ] = s.xhrFields[ i ];
7923	+ }
7924	+ }
7925	+
7926	+ // Override mime type if needed
7927	+ if ( s.mimeType && xhr.overrideMimeType ) {
7928	+ xhr.overrideMimeType( s.mimeType );
7929	+ }
7930	+
7931	+ // X-Requested-With header
7932	+ // For cross-domain requests, seeing as conditions for a preflight are
7933	+ // akin to a jigsaw puzzle, we simply never set it to be sure.
7934	+ // (it can always be set on a per-request basis or even using ajaxSetup)
7935	+ // For same-domain requests, won't change header if already provided.
7936	+ if ( !s.crossDomain && !headers["X-Requested-With"] ) {
7937	+ headers[ "X-Requested-With" ] = "XMLHttpRequest";
7938	+ }
7939	+
7940	+ // Need an extra try/catch for cross domain requests in Firefox 3
7941	+ try {
7942	+ for ( i in headers ) {
7943	+ xhr.setRequestHeader( i, headers[ i ] );
7944	+ }
7945	+ } catch( _ ) {}
7946	+
7947	+ // Do send the request
7948	+ // This may raise an exception which is actually
7949	+ // handled in jQuery.ajax (so no try/catch here)
7950	+ xhr.send( ( s.hasContent && s.data ) \|\| null );
7951	+
7952	+ // Listener
7953	+ callback = function( _, isAbort ) {
7954	+
7955	+ var status,
7956	+ statusText,
7957	+ responseHeaders,
7958	+ responses,
7959	+ xml;
7960	+
7961	+ // Firefox throws exceptions when accessing properties
7962	+ // of an xhr when a network error occured
7963	+ // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
7964	+ try {
7965	+
7966	+ // Was never called and is aborted or complete
7967	+ if ( callback && ( isAbort \|\| xhr.readyState === 4 ) ) {
7968	+
7969	+ // Only called once
7970	+ callback = undefined;
7971	+
7972	+ // Do not keep as active anymore
7973	+ if ( handle ) {
7974	+ xhr.onreadystatechange = jQuery.noop;
7975	+ if ( xhrOnUnloadAbort ) {
7976	+ delete xhrCallbacks[ handle ];
7977	+ }
7978	+ }
7979	+
7980	+ // If it's an abort
7981	+ if ( isAbort ) {
7982	+ // Abort it manually if needed
7983	+ if ( xhr.readyState !== 4 ) {
7984	+ xhr.abort();
7985	+ }
7986	+ } else {
7987	+ status = xhr.status;
7988	+ responseHeaders = xhr.getAllResponseHeaders();
7989	+ responses = {};
7990	+ xml = xhr.responseXML;
7991	+
7992	+ // Construct response list
7993	+ if ( xml && xml.documentElement /* #4958 */ ) {
7994	+ responses.xml = xml;
7995	+ }
7996	+ responses.text = xhr.responseText;
7997	+
7998	+ // Firefox throws an exception when accessing
7999	+ // statusText for faulty cross-domain requests
8000	+ try {
8001	+ statusText = xhr.statusText;
8002	+ } catch( e ) {
8003	+ // We normalize with Webkit giving an empty statusText
8004	+ statusText = "";
8005	+ }
8006	+
8007	+ // Filter status for non standard behaviors
8008	+
8009	+ // If the request is local and we have data: assume a success
8010	+ // (success with no data won't get notified, that's the best we
8011	+ // can do given current implementations)
8012	+ if ( !status && s.isLocal && !s.crossDomain ) {
8013	+ status = responses.text ? 200 : 404;
8014	+ // IE - #1450: sometimes returns 1223 when it should be 204
8015	+ } else if ( status === 1223 ) {
8016	+ status = 204;
8017	+ }
8018	+ }
8019	+ }
8020	+ } catch( firefoxAccessException ) {
8021	+ if ( !isAbort ) {
8022	+ complete( -1, firefoxAccessException );
8023	+ }
8024	+ }
8025	+
8026	+ // Call complete if needed
8027	+ if ( responses ) {
8028	+ complete( status, statusText, responses, responseHeaders );
8029	+ }
8030	+ };
8031	+
8032	+ // if we're in sync mode or it's in cache
8033	+ // and has been retrieved directly (IE6 & IE7)
8034	+ // we need to manually fire the callback
8035	+ if ( !s.async \|\| xhr.readyState === 4 ) {
8036	+ callback();
8037	+ } else {
8038	+ handle = ++xhrId;
8039	+ if ( xhrOnUnloadAbort ) {
8040	+ // Create the active xhrs callbacks list if needed
8041	+ // and attach the unload handler
8042	+ if ( !xhrCallbacks ) {
8043	+ xhrCallbacks = {};
8044	+ jQuery( window ).unload( xhrOnUnloadAbort );
8045	+ }
8046	+ // Add to list of active xhrs callbacks
8047	+ xhrCallbacks[ handle ] = callback;
8048	+ }
8049	+ xhr.onreadystatechange = callback;
8050	+ }
8051	+ },
8052	+
8053	+ abort: function() {
8054	+ if ( callback ) {
8055	+ callback(0,1);
8056	+ }
8057	+ }
8058	+ };
8059	+ }
8060	+ });
8061	+ }
8062	+
8063	+
8064	+
8065	+
8066	+ var elemdisplay = {},
8067	+ iframe, iframeDoc,
8068	+ rfxtypes = /^(?:toggle\|show\|hide)$/,
8069	+ rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
8070	+ timerId,
8071	+ fxAttrs = [
8072	+ // height animations
8073	+ [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
8074	+ // width animations
8075	+ [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
8076	+ // opacity animations
8077	+ [ "opacity" ]
8078	+ ],
8079	+ fxNow;
8080	+
8081	+ jQuery.fn.extend({
8082	+ show: function( speed, easing, callback ) {
8083	+ var elem, display;
8084	+
8085	+ if ( speed \|\| speed === 0 ) {
8086	+ return this.animate( genFx("show", 3), speed, easing, callback);
8087	+
8088	+ } else {
8089	+ for ( var i = 0, j = this.length; i < j; i++ ) {
8090	+ elem = this[i];
8091	+
8092	+ if ( elem.style ) {
8093	+ display = elem.style.display;
8094	+
8095	+ // Reset the inline display of this element to learn if it is
8096	+ // being hidden by cascaded rules or not
8097	+ if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
8098	+ display = elem.style.display = "";
8099	+ }
8100	+
8101	+ // Set elements which have been overridden with display: none
8102	+ // in a stylesheet to whatever the default browser style is
8103	+ // for such an element
8104	+ if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
8105	+ jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
8106	+ }
8107	+ }
8108	+ }
8109	+
8110	+ // Set the display of most of the elements in a second loop
8111	+ // to avoid the constant reflow
8112	+ for ( i = 0; i < j; i++ ) {
8113	+ elem = this[i];
8114	+
8115	+ if ( elem.style ) {
8116	+ display = elem.style.display;
8117	+
8118	+ if ( display === "" \|\| display === "none" ) {
8119	+ elem.style.display = jQuery._data(elem, "olddisplay") \|\| "";
8120	+ }
8121	+ }
8122	+ }
8123	+
8124	+ return this;
8125	+ }
8126	+ },
8127	+
8128	+ hide: function( speed, easing, callback ) {
8129	+ if ( speed \|\| speed === 0 ) {
8130	+ return this.animate( genFx("hide", 3), speed, easing, callback);
8131	+
8132	+ } else {
8133	+ for ( var i = 0, j = this.length; i < j; i++ ) {
8134	+ if ( this[i].style ) {
8135	+ var display = jQuery.css( this[i], "display" );
8136	+
8137	+ if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
8138	+ jQuery._data( this[i], "olddisplay", display );
8139	+ }
8140	+ }
8141	+ }
8142	+
8143	+ // Set the display of the elements in a second loop
8144	+ // to avoid the constant reflow
8145	+ for ( i = 0; i < j; i++ ) {
8146	+ if ( this[i].style ) {
8147	+ this[i].style.display = "none";
8148	+ }
8149	+ }
8150	+
8151	+ return this;
8152	+ }
8153	+ },
8154	+
8155	+ // Save the old toggle function
8156	+ _toggle: jQuery.fn.toggle,
8157	+
8158	+ toggle: function( fn, fn2, callback ) {
8159	+ var bool = typeof fn === "boolean";
8160	+
8161	+ if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8162	+ this._toggle.apply( this, arguments );
8163	+
8164	+ } else if ( fn == null \|\| bool ) {
8165	+ this.each(function() {
8166	+ var state = bool ? fn : jQuery(this).is(":hidden");
8167	+ jQuery(this)[ state ? "show" : "hide" ]();
8168	+ });
8169	+
8170	+ } else {
8171	+ this.animate(genFx("toggle", 3), fn, fn2, callback);
8172	+ }
8173	+
8174	+ return this;
8175	+ },
8176	+
8177	+ fadeTo: function( speed, to, easing, callback ) {
8178	+ return this.filter(":hidden").css("opacity", 0).show().end()
8179	+ .animate({opacity: to}, speed, easing, callback);
8180	+ },
8181	+
8182	+ animate: function( prop, speed, easing, callback ) {
8183	+ var optall = jQuery.speed(speed, easing, callback);
8184	+
8185	+ if ( jQuery.isEmptyObject( prop ) ) {
8186	+ return this.each( optall.complete, [ false ] );
8187	+ }
8188	+
8189	+ // Do not change referenced properties as per-property easing will be lost
8190	+ prop = jQuery.extend( {}, prop );
8191	+
8192	+ return this[ optall.queue === false ? "each" : "queue" ](function() {
8193	+ // XXX 'this' does not always have a nodeName when running the
8194	+ // test suite
8195	+
8196	+ if ( optall.queue === false ) {
8197	+ jQuery._mark( this );
8198	+ }
8199	+
8200	+ var opt = jQuery.extend( {}, optall ),
8201	+ isElement = this.nodeType === 1,
8202	+ hidden = isElement && jQuery(this).is(":hidden"),
8203	+ name, val, p,
8204	+ display, e,
8205	+ parts, start, end, unit;
8206	+
8207	+ // will store per property easing and be used to determine when an animation is complete
8208	+ opt.animatedProperties = {};
8209	+
8210	+ for ( p in prop ) {
8211	+
8212	+ // property name normalization
8213	+ name = jQuery.camelCase( p );
8214	+ if ( p !== name ) {
8215	+ prop[ name ] = prop[ p ];
8216	+ delete prop[ p ];
8217	+ }
8218	+
8219	+ val = prop[ name ];
8220	+
8221	+ // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8222	+ if ( jQuery.isArray( val ) ) {
8223	+ opt.animatedProperties[ name ] = val[ 1 ];
8224	+ val = prop[ name ] = val[ 0 ];
8225	+ } else {
8226	+ opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] \|\| opt.easing \|\| 'swing';
8227	+ }
8228	+
8229	+ if ( val === "hide" && hidden \|\| val === "show" && !hidden ) {
8230	+ return opt.complete.call( this );
8231	+ }
8232	+
8233	+ if ( isElement && ( name === "height" \|\| name === "width" ) ) {
8234	+ // Make sure that nothing sneaks out
8235	+ // Record all 3 overflow attributes because IE does not
8236	+ // change the overflow attribute when overflowX and
8237	+ // overflowY are set to the same value
8238	+ opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8239	+
8240	+ // Set display property to inline-block for height/width
8241	+ // animations on inline elements that are having width/height
8242	+ // animated
8243	+ if ( jQuery.css( this, "display" ) === "inline" &&
8244	+ jQuery.css( this, "float" ) === "none" ) {
8245	+ if ( !jQuery.support.inlineBlockNeedsLayout ) {
8246	+ this.style.display = "inline-block";
8247	+
8248	+ } else {
8249	+ display = defaultDisplay( this.nodeName );
8250	+
8251	+ // inline-level elements accept inline-block;
8252	+ // block-level elements need to be inline with layout
8253	+ if ( display === "inline" ) {
8254	+ this.style.display = "inline-block";
8255	+
8256	+ } else {
8257	+ this.style.display = "inline";
8258	+ this.style.zoom = 1;
8259	+ }
8260	+ }
8261	+ }
8262	+ }
8263	+ }
8264	+
8265	+ if ( opt.overflow != null ) {
8266	+ this.style.overflow = "hidden";
8267	+ }
8268	+
8269	+ for ( p in prop ) {
8270	+ e = new jQuery.fx( this, opt, p );
8271	+ val = prop[ p ];
8272	+
8273	+ if ( rfxtypes.test(val) ) {
8274	+ e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
8275	+
8276	+ } else {
8277	+ parts = rfxnum.exec( val );
8278	+ start = e.cur();
8279	+
8280	+ if ( parts ) {
8281	+ end = parseFloat( parts[2] );
8282	+ unit = parts[3] \|\| ( jQuery.cssNumber[ p ] ? "" : "px" );
8283	+
8284	+ // We need to compute starting value
8285	+ if ( unit !== "px" ) {
8286	+ jQuery.style( this, p, (end \|\| 1) + unit);
8287	+ start = ((end \|\| 1) / e.cur()) * start;
8288	+ jQuery.style( this, p, start + unit);
8289	+ }
8290	+
8291	+ // If a +=/-= token was provided, we're doing a relative animation
8292	+ if ( parts[1] ) {
8293	+ end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8294	+ }
8295	+
8296	+ e.custom( start, end, unit );
8297	+
8298	+ } else {
8299	+ e.custom( start, val, "" );
8300	+ }
8301	+ }
8302	+ }
8303	+
8304	+ // For JS strict compliance
8305	+ return true;
8306	+ });
8307	+ },
8308	+
8309	+ stop: function( clearQueue, gotoEnd ) {
8310	+ if ( clearQueue ) {
8311	+ this.queue([]);
8312	+ }
8313	+
8314	+ this.each(function() {
8315	+ var timers = jQuery.timers,
8316	+ i = timers.length;
8317	+ // clear marker counters if we know they won't be
8318	+ if ( !gotoEnd ) {
8319	+ jQuery._unmark( true, this );
8320	+ }
8321	+ while ( i-- ) {
8322	+ if ( timers[i].elem === this ) {
8323	+ if (gotoEnd) {
8324	+ // force the next step to be the last
8325	+ timers[i](true);
8326	+ }
8327	+
8328	+ timers.splice(i, 1);
8329	+ }
8330	+ }
8331	+ });
8332	+
8333	+ // start the next in the queue if the last step wasn't forced
8334	+ if ( !gotoEnd ) {
8335	+ this.dequeue();
8336	+ }
8337	+
8338	+ return this;
8339	+ }
8340	+
8341	+ });
8342	+
8343	+ // Animations created synchronously will run synchronously
8344	+ function createFxNow() {
8345	+ setTimeout( clearFxNow, 0 );
8346	+ return ( fxNow = jQuery.now() );
8347	+ }
8348	+
8349	+ function clearFxNow() {
8350	+ fxNow = undefined;
8351	+ }
8352	+
8353	+ // Generate parameters to create a standard animation
8354	+ function genFx( type, num ) {
8355	+ var obj = {};
8356	+
8357	+ jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
8358	+ obj[ this ] = type;
8359	+ });
8360	+
8361	+ return obj;
8362	+ }
8363	+
8364	+ // Generate shortcuts for custom animations
8365	+ jQuery.each({
8366	+ slideDown: genFx("show", 1),
8367	+ slideUp: genFx("hide", 1),
8368	+ slideToggle: genFx("toggle", 1),
8369	+ fadeIn: { opacity: "show" },
8370	+ fadeOut: { opacity: "hide" },
8371	+ fadeToggle: { opacity: "toggle" }
8372	+ }, function( name, props ) {
8373	+ jQuery.fn[ name ] = function( speed, easing, callback ) {
8374	+ return this.animate( props, speed, easing, callback );
8375	+ };
8376	+ });
8377	+
8378	+ jQuery.extend({
8379	+ speed: function( speed, easing, fn ) {
8380	+ var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
8381	+ complete: fn \|\| !fn && easing \|\|
8382	+ jQuery.isFunction( speed ) && speed,
8383	+ duration: speed,
8384	+ easing: fn && easing \|\| easing && !jQuery.isFunction(easing) && easing
8385	+ };
8386	+
8387	+ opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8388	+ opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
8389	+
8390	+ // Queueing
8391	+ opt.old = opt.complete;
8392	+ opt.complete = function( noUnmark ) {
8393	+ if ( jQuery.isFunction( opt.old ) ) {
8394	+ opt.old.call( this );
8395	+ }
8396	+
8397	+ if ( opt.queue !== false ) {
8398	+ jQuery.dequeue( this );
8399	+ } else if ( noUnmark !== false ) {
8400	+ jQuery._unmark( this );
8401	+ }
8402	+ };
8403	+
8404	+ return opt;
8405	+ },
8406	+
8407	+ easing: {
8408	+ linear: function( p, n, firstNum, diff ) {
8409	+ return firstNum + diff * p;
8410	+ },
8411	+ swing: function( p, n, firstNum, diff ) {
8412	+ return ((-Math.cos(pMath.PI)/2) + 0.5) diff + firstNum;
8413	+ }
8414	+ },
8415	+
8416	+ timers: [],
8417	+
8418	+ fx: function( elem, options, prop ) {
8419	+ this.options = options;
8420	+ this.elem = elem;
8421	+ this.prop = prop;
8422	+
8423	+ options.orig = options.orig \|\| {};
8424	+ }
8425	+
8426	+ });
8427	+
8428	+ jQuery.fx.prototype = {
8429	+ // Simple function for setting a style value
8430	+ update: function() {
8431	+ if ( this.options.step ) {
8432	+ this.options.step.call( this.elem, this.now, this );
8433	+ }
8434	+
8435	+ (jQuery.fx.step[this.prop] \|\| jQuery.fx.step._default)( this );
8436	+ },
8437	+
8438	+ // Get the current size
8439	+ cur: function() {
8440	+ if ( this.elem[this.prop] != null && (!this.elem.style \|\| this.elem.style[this.prop] == null) ) {
8441	+ return this.elem[ this.prop ];
8442	+ }
8443	+
8444	+ var parsed,
8445	+ r = jQuery.css( this.elem, this.prop );
8446	+ // Empty strings, null, undefined and "auto" are converted to 0,
8447	+ // complex values such as "rotate(1rad)" are returned as is,
8448	+ // simple values such as "10px" are parsed to Float.
8449	+ return isNaN( parsed = parseFloat( r ) ) ? !r \|\| r === "auto" ? 0 : r : parsed;
8450	+ },
8451	+
8452	+ // Start an animation from one number to another
8453	+ custom: function( from, to, unit ) {
8454	+ var self = this,
8455	+ fx = jQuery.fx;
8456	+
8457	+ this.startTime = fxNow \|\| createFxNow();
8458	+ this.start = from;
8459	+ this.end = to;
8460	+ this.unit = unit \|\| this.unit \|\| ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8461	+ this.now = this.start;
8462	+ this.pos = this.state = 0;
8463	+
8464	+ function t( gotoEnd ) {
8465	+ return self.step(gotoEnd);
8466	+ }
8467	+
8468	+ t.elem = this.elem;
8469	+
8470	+ if ( t() && jQuery.timers.push(t) && !timerId ) {
8471	+ timerId = setInterval( fx.tick, fx.interval );
8472	+ }
8473	+ },
8474	+
8475	+ // Simple 'show' function
8476	+ show: function() {
8477	+ // Remember where we started, so that we can go back to it later
8478	+ this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8479	+ this.options.show = true;
8480	+
8481	+ // Begin the animation
8482	+ // Make sure that we start at a small width/height to avoid any
8483	+ // flash of content
8484	+ this.custom(this.prop === "width" \|\| this.prop === "height" ? 1 : 0, this.cur());
8485	+
8486	+ // Start by showing the element
8487	+ jQuery( this.elem ).show();
8488	+ },
8489	+
8490	+ // Simple 'hide' function
8491	+ hide: function() {
8492	+ // Remember where we started, so that we can go back to it later
8493	+ this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8494	+ this.options.hide = true;
8495	+
8496	+ // Begin the animation
8497	+ this.custom(this.cur(), 0);
8498	+ },
8499	+
8500	+ // Each step of an animation
8501	+ step: function( gotoEnd ) {
8502	+ var t = fxNow \|\| createFxNow(),
8503	+ done = true,
8504	+ elem = this.elem,
8505	+ options = this.options,
8506	+ i, n;
8507	+
8508	+ if ( gotoEnd \|\| t >= options.duration + this.startTime ) {
8509	+ this.now = this.end;
8510	+ this.pos = this.state = 1;
8511	+ this.update();
8512	+
8513	+ options.animatedProperties[ this.prop ] = true;
8514	+
8515	+ for ( i in options.animatedProperties ) {
8516	+ if ( options.animatedProperties[i] !== true ) {
8517	+ done = false;
8518	+ }
8519	+ }
8520	+
8521	+ if ( done ) {
8522	+ // Reset the overflow
8523	+ if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8524	+
8525	+ jQuery.each( [ "", "X", "Y" ], function (index, value) {
8526	+ elem.style[ "overflow" + value ] = options.overflow[index];
8527	+ });
8528	+ }
8529	+
8530	+ // Hide the element if the "hide" operation was done
8531	+ if ( options.hide ) {
8532	+ jQuery(elem).hide();
8533	+ }
8534	+
8535	+ // Reset the properties, if the item has been hidden or shown
8536	+ if ( options.hide \|\| options.show ) {
8537	+ for ( var p in options.animatedProperties ) {
8538	+ jQuery.style( elem, p, options.orig[p] );
8539	+ }
8540	+ }
8541	+
8542	+ // Execute the complete function
8543	+ options.complete.call( elem );
8544	+ }
8545	+
8546	+ return false;
8547	+
8548	+ } else {
8549	+ // classical easing cannot be used with an Infinity duration
8550	+ if ( options.duration == Infinity ) {
8551	+ this.now = t;
8552	+ } else {
8553	+ n = t - this.startTime;
8554	+ this.state = n / options.duration;
8555	+
8556	+ // Perform the easing function, defaults to swing
8557	+ this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
8558	+ this.now = this.start + ((this.end - this.start) * this.pos);
8559	+ }
8560	+ // Perform the next step of the animation
8561	+ this.update();
8562	+ }
8563	+
8564	+ return true;
8565	+ }
8566	+ };
8567	+
8568	+ jQuery.extend( jQuery.fx, {
8569	+ tick: function() {
8570	+ for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
8571	+ if ( !timers[i]() ) {
8572	+ timers.splice(i--, 1);
8573	+ }
8574	+ }
8575	+
8576	+ if ( !timers.length ) {
8577	+ jQuery.fx.stop();
8578	+ }
8579	+ },
8580	+
8581	+ interval: 13,
8582	+
8583	+ stop: function() {
8584	+ clearInterval( timerId );
8585	+ timerId = null;
8586	+ },
8587	+
8588	+ speeds: {
8589	+ slow: 600,
8590	+ fast: 200,
8591	+ // Default speed
8592	+ _default: 400
8593	+ },
8594	+
8595	+ step: {
8596	+ opacity: function( fx ) {
8597	+ jQuery.style( fx.elem, "opacity", fx.now );
8598	+ },
8599	+
8600	+ _default: function( fx ) {
8601	+ if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8602	+ fx.elem.style[ fx.prop ] = (fx.prop === "width" \|\| fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
8603	+ } else {
8604	+ fx.elem[ fx.prop ] = fx.now;
8605	+ }
8606	+ }
8607	+ }
8608	+ });
8609	+
8610	+ if ( jQuery.expr && jQuery.expr.filters ) {
8611	+ jQuery.expr.filters.animated = function( elem ) {
8612	+ return jQuery.grep(jQuery.timers, function( fn ) {
8613	+ return elem === fn.elem;
8614	+ }).length;
8615	+ };
8616	+ }
8617	+
8618	+ // Try to restore the default display value of an element
8619	+ function defaultDisplay( nodeName ) {
8620	+
8621	+ if ( !elemdisplay[ nodeName ] ) {
8622	+
8623	+ var body = document.body,
8624	+ elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8625	+ display = elem.css( "display" );
8626	+
8627	+ elem.remove();
8628	+
8629	+ // If the simple way fails,
8630	+ // get element's real default display by attaching it to a temp iframe
8631	+ if ( display === "none" \|\| display === "" ) {
8632	+ // No iframe to use yet, so create it
8633	+ if ( !iframe ) {
8634	+ iframe = document.createElement( "iframe" );
8635	+ iframe.frameBorder = iframe.width = iframe.height = 0;
8636	+ }
8637	+
8638	+ body.appendChild( iframe );
8639	+
8640	+ // Create a cacheable copy of the iframe document on first call.
8641	+ // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
8642	+ // document to it; WebKit & Firefox won't allow reusing the iframe document.
8643	+ if ( !iframeDoc \|\| !iframe.createElement ) {
8644	+ iframeDoc = ( iframe.contentWindow \|\| iframe.contentDocument ).document;
8645	+ iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
8646	+ iframeDoc.close();
8647	+ }
8648	+
8649	+ elem = iframeDoc.createElement( nodeName );
8650	+
8651	+ iframeDoc.body.appendChild( elem );
8652	+
8653	+ display = jQuery.css( elem, "display" );
8654	+
8655	+ body.removeChild( iframe );
8656	+ }
8657	+
8658	+ // Store the correct default display
8659	+ elemdisplay[ nodeName ] = display;
8660	+ }
8661	+
8662	+ return elemdisplay[ nodeName ];
8663	+ }
8664	+
8665	+
8666	+
8667	+
8668	+ var rtable = /^t(?:able\|d\|h)$/i,
8669	+ rroot = /^(?:body\|html)$/i;
8670	+
8671	+ if ( "getBoundingClientRect" in document.documentElement ) {
8672	+ jQuery.fn.offset = function( options ) {
8673	+ var elem = this[0], box;
8674	+
8675	+ if ( options ) {
8676	+ return this.each(function( i ) {
8677	+ jQuery.offset.setOffset( this, options, i );
8678	+ });
8679	+ }
8680	+
8681	+ if ( !elem \|\| !elem.ownerDocument ) {
8682	+ return null;
8683	+ }
8684	+
8685	+ if ( elem === elem.ownerDocument.body ) {
8686	+ return jQuery.offset.bodyOffset( elem );
8687	+ }
8688	+
8689	+ try {
8690	+ box = elem.getBoundingClientRect();
8691	+ } catch(e) {}
8692	+
8693	+ var doc = elem.ownerDocument,
8694	+ docElem = doc.documentElement;
8695	+
8696	+ // Make sure we're not dealing with a disconnected DOM node
8697	+ if ( !box \|\| !jQuery.contains( docElem, elem ) ) {
8698	+ return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8699	+ }
8700	+
8701	+ var body = doc.body,
8702	+ win = getWindow(doc),
8703	+ clientTop = docElem.clientTop \|\| body.clientTop \|\| 0,
8704	+ clientLeft = docElem.clientLeft \|\| body.clientLeft \|\| 0,
8705	+ scrollTop = win.pageYOffset \|\| jQuery.support.boxModel && docElem.scrollTop \|\| body.scrollTop,
8706	+ scrollLeft = win.pageXOffset \|\| jQuery.support.boxModel && docElem.scrollLeft \|\| body.scrollLeft,
8707	+ top = box.top + scrollTop - clientTop,
8708	+ left = box.left + scrollLeft - clientLeft;
8709	+
8710	+ return { top: top, left: left };
8711	+ };
8712	+
8713	+ } else {
8714	+ jQuery.fn.offset = function( options ) {
8715	+ var elem = this[0];
8716	+
8717	+ if ( options ) {
8718	+ return this.each(function( i ) {
8719	+ jQuery.offset.setOffset( this, options, i );
8720	+ });
8721	+ }
8722	+
8723	+ if ( !elem \|\| !elem.ownerDocument ) {
8724	+ return null;
8725	+ }
8726	+
8727	+ if ( elem === elem.ownerDocument.body ) {
8728	+ return jQuery.offset.bodyOffset( elem );
8729	+ }
8730	+
8731	+ jQuery.offset.initialize();
8732	+
8733	+ var computedStyle,
8734	+ offsetParent = elem.offsetParent,
8735	+ prevOffsetParent = elem,
8736	+ doc = elem.ownerDocument,
8737	+ docElem = doc.documentElement,
8738	+ body = doc.body,
8739	+ defaultView = doc.defaultView,
8740	+ prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8741	+ top = elem.offsetTop,
8742	+ left = elem.offsetLeft;
8743	+
8744	+ while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8745	+ if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8746	+ break;
8747	+ }
8748	+
8749	+ computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8750	+ top -= elem.scrollTop;
8751	+ left -= elem.scrollLeft;
8752	+
8753	+ if ( elem === offsetParent ) {
8754	+ top += elem.offsetTop;
8755	+ left += elem.offsetLeft;
8756	+
8757	+ if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8758	+ top += parseFloat( computedStyle.borderTopWidth ) \|\| 0;
8759	+ left += parseFloat( computedStyle.borderLeftWidth ) \|\| 0;
8760	+ }
8761	+
8762	+ prevOffsetParent = offsetParent;
8763	+ offsetParent = elem.offsetParent;
8764	+ }
8765	+
8766	+ if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8767	+ top += parseFloat( computedStyle.borderTopWidth ) \|\| 0;
8768	+ left += parseFloat( computedStyle.borderLeftWidth ) \|\| 0;
8769	+ }
8770	+
8771	+ prevComputedStyle = computedStyle;
8772	+ }
8773	+
8774	+ if ( prevComputedStyle.position === "relative" \|\| prevComputedStyle.position === "static" ) {
8775	+ top += body.offsetTop;
8776	+ left += body.offsetLeft;
8777	+ }
8778	+
8779	+ if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8780	+ top += Math.max( docElem.scrollTop, body.scrollTop );
8781	+ left += Math.max( docElem.scrollLeft, body.scrollLeft );
8782	+ }
8783	+
8784	+ return { top: top, left: left };
8785	+ };
8786	+ }
8787	+
8788	+ jQuery.offset = {
8789	+ initialize: function() {
8790	+ var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) \|\| 0,
8791	+ html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
8792	+
8793	+ jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
8794	+
8795	+ container.innerHTML = html;
8796	+ body.insertBefore( container, body.firstChild );
8797	+ innerDiv = container.firstChild;
8798	+ checkDiv = innerDiv.firstChild;
8799	+ td = innerDiv.nextSibling.firstChild.firstChild;
8800	+
8801	+ this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
8802	+ this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
8803	+
8804	+ checkDiv.style.position = "fixed";
8805	+ checkDiv.style.top = "20px";
8806	+
8807	+ // safari subtracts parent border width here which is 5px
8808	+ this.supportsFixedPosition = (checkDiv.offsetTop === 20 \|\| checkDiv.offsetTop === 15);
8809	+ checkDiv.style.position = checkDiv.style.top = "";
8810	+
8811	+ innerDiv.style.overflow = "hidden";
8812	+ innerDiv.style.position = "relative";
8813	+
8814	+ this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
8815	+
8816	+ this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
8817	+
8818	+ body.removeChild( container );
8819	+ jQuery.offset.initialize = jQuery.noop;
8820	+ },
8821	+
8822	+ bodyOffset: function( body ) {
8823	+ var top = body.offsetTop,
8824	+ left = body.offsetLeft;
8825	+
8826	+ jQuery.offset.initialize();
8827	+
8828	+ if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
8829	+ top += parseFloat( jQuery.css(body, "marginTop") ) \|\| 0;
8830	+ left += parseFloat( jQuery.css(body, "marginLeft") ) \|\| 0;
8831	+ }
8832	+
8833	+ return { top: top, left: left };
8834	+ },
8835	+
8836	+ setOffset: function( elem, options, i ) {
8837	+ var position = jQuery.css( elem, "position" );
8838	+
8839	+ // set position first, in-case top/left are set even on static elem
8840	+ if ( position === "static" ) {
8841	+ elem.style.position = "relative";
8842	+ }
8843	+
8844	+ var curElem = jQuery( elem ),
8845	+ curOffset = curElem.offset(),
8846	+ curCSSTop = jQuery.css( elem, "top" ),
8847	+ curCSSLeft = jQuery.css( elem, "left" ),
8848	+ calculatePosition = (position === "absolute" \|\| position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
8849	+ props = {}, curPosition = {}, curTop, curLeft;
8850	+
8851	+ // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
8852	+ if ( calculatePosition ) {
8853	+ curPosition = curElem.position();
8854	+ curTop = curPosition.top;
8855	+ curLeft = curPosition.left;
8856	+ } else {
8857	+ curTop = parseFloat( curCSSTop ) \|\| 0;
8858	+ curLeft = parseFloat( curCSSLeft ) \|\| 0;
8859	+ }
8860	+
8861	+ if ( jQuery.isFunction( options ) ) {
8862	+ options = options.call( elem, i, curOffset );
8863	+ }
8864	+
8865	+ if (options.top != null) {
8866	+ props.top = (options.top - curOffset.top) + curTop;
8867	+ }
8868	+ if (options.left != null) {
8869	+ props.left = (options.left - curOffset.left) + curLeft;
8870	+ }
8871	+
8872	+ if ( "using" in options ) {
8873	+ options.using.call( elem, props );
8874	+ } else {
8875	+ curElem.css( props );
8876	+ }
8877	+ }
8878	+ };
8879	+
8880	+
8881	+ jQuery.fn.extend({
8882	+ position: function() {
8883	+ if ( !this[0] ) {
8884	+ return null;
8885	+ }
8886	+
8887	+ var elem = this[0],
8888	+
8889	+ // Get real offsetParent
8890	+ offsetParent = this.offsetParent(),
8891	+
8892	+ // Get correct offsets
8893	+ offset = this.offset(),
8894	+ parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
8895	+
8896	+ // Subtract element margins
8897	+ // note: when an element has margin: auto the offsetLeft and marginLeft
8898	+ // are the same in Safari causing offset.left to incorrectly be 0
8899	+ offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) \|\| 0;
8900	+ offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) \|\| 0;
8901	+
8902	+ // Add offsetParent borders
8903	+ parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) \|\| 0;
8904	+ parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) \|\| 0;
8905	+
8906	+ // Subtract the two offsets
8907	+ return {
8908	+ top: offset.top - parentOffset.top,
8909	+ left: offset.left - parentOffset.left
8910	+ };
8911	+ },
8912	+
8913	+ offsetParent: function() {
8914	+ return this.map(function() {
8915	+ var offsetParent = this.offsetParent \|\| document.body;
8916	+ while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
8917	+ offsetParent = offsetParent.offsetParent;
8918	+ }
8919	+ return offsetParent;
8920	+ });
8921	+ }
8922	+ });
8923	+
8924	+
8925	+ // Create scrollLeft and scrollTop methods
8926	+ jQuery.each( ["Left", "Top"], function( i, name ) {
8927	+ var method = "scroll" + name;
8928	+
8929	+ jQuery.fn[ method ] = function( val ) {
8930	+ var elem, win;
8931	+
8932	+ if ( val === undefined ) {
8933	+ elem = this[ 0 ];
8934	+
8935	+ if ( !elem ) {
8936	+ return null;
8937	+ }
8938	+
8939	+ win = getWindow( elem );
8940	+
8941	+ // Return the scroll offset
8942	+ return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
8943	+ jQuery.support.boxModel && win.document.documentElement[ method ] \|\|
8944	+ win.document.body[ method ] :
8945	+ elem[ method ];
8946	+ }
8947	+
8948	+ // Set the scroll offset
8949	+ return this.each(function() {
8950	+ win = getWindow( this );
8951	+
8952	+ if ( win ) {
8953	+ win.scrollTo(
8954	+ !i ? val : jQuery( win ).scrollLeft(),
8955	+ i ? val : jQuery( win ).scrollTop()
8956	+ );
8957	+
8958	+ } else {
8959	+ this[ method ] = val;
8960	+ }
8961	+ });
8962	+ };
8963	+ });
8964	+
8965	+ function getWindow( elem ) {
8966	+ return jQuery.isWindow( elem ) ?
8967	+ elem :
8968	+ elem.nodeType === 9 ?
8969	+ elem.defaultView \|\| elem.parentWindow :
8970	+ false;
8971	+ }
8972	+
8973	+
8974	+
8975	+
8976	+ // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
8977	+ jQuery.each([ "Height", "Width" ], function( i, name ) {
8978	+
8979	+ var type = name.toLowerCase();
8980	+
8981	+ // innerHeight and innerWidth
8982	+ jQuery.fn[ "inner" + name ] = function() {
8983	+ var elem = this[0];
8984	+ return elem && elem.style ?
8985	+ parseFloat( jQuery.css( elem, type, "padding" ) ) :
8986	+ null;
8987	+ };
8988	+
8989	+ // outerHeight and outerWidth
8990	+ jQuery.fn[ "outer" + name ] = function( margin ) {
8991	+ var elem = this[0];
8992	+ return elem && elem.style ?
8993	+ parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
8994	+ null;
8995	+ };
8996	+
8997	+ jQuery.fn[ type ] = function( size ) {
8998	+ // Get window width or height
8999	+ var elem = this[0];
9000	+ if ( !elem ) {
9001	+ return size == null ? null : this;
9002	+ }
9003	+
9004	+ if ( jQuery.isFunction( size ) ) {
9005	+ return this.each(function( i ) {
9006	+ var self = jQuery( this );
9007	+ self[ type ]( size.call( this, i, self[ type ]() ) );
9008	+ });
9009	+ }
9010	+
9011	+ if ( jQuery.isWindow( elem ) ) {
9012	+ // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
9013	+ // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
9014	+ var docElemProp = elem.document.documentElement[ "client" + name ],
9015	+ body = elem.document.body;
9016	+ return elem.document.compatMode === "CSS1Compat" && docElemProp \|\|
9017	+ body && body[ "client" + name ] \|\| docElemProp;
9018	+
9019	+ // Get document width or height
9020	+ } else if ( elem.nodeType === 9 ) {
9021	+ // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
9022	+ return Math.max(
9023	+ elem.documentElement["client" + name],
9024	+ elem.body["scroll" + name], elem.documentElement["scroll" + name],
9025	+ elem.body["offset" + name], elem.documentElement["offset" + name]
9026	+ );
9027	+
9028	+ // Get or set width or height on the element
9029	+ } else if ( size === undefined ) {
9030	+ var orig = jQuery.css( elem, type ),
9031	+ ret = parseFloat( orig );
9032	+
9033	+ return jQuery.isNaN( ret ) ? orig : ret;
9034	+
9035	+ // Set the width or height on the element (default to pixels if value is unitless)
9036	+ } else {
9037	+ return this.css( type, typeof size === "string" ? size : size + "px" );
9038	+ }
9039	+ };
9040	+
9041	+ });
9042	+
9043	+
9044	+ // Expose jQuery to the global object
9045	+ window.jQuery = window.$ = jQuery;
9046	+ })(window);
9047	+
9048	+
9049	+ jQuery.noConflict();

skin/frontend/default/default/js/slider/jquery.jcarousel.js ADDED Viewed

	@@ -0,0 +1,487 @@


1	+ /**
2	+ * jCarousel - Riding carousels with jQuery
3	+ * http://sorgalla.com/jcarousel/
4	+ *
5	+ * Copyright (c) 2006 Jan Sorgalla (http://sorgalla.com)
6	+ * Dual licensed under the MIT (MIT-LICENSE.txt)
7	+ * and GPL (GPL-LICENSE.txt) licenses.
8	+ *
9	+ * Built on top of the jQuery library
10	+ * http://jquery.com
11	+ *
12	+ * Inspired by the "Carousel Component" by Bill Scott
13	+ * http://billwscott.com/carousel/
14	+ */ (function ($) {
15	+ $.fn.jcarousel = function (o) {
16	+ return this.each(function () {
17	+ new r(this, o)
18	+ })
19	+ };
20	+ var q = {
21	+ vertical: false,
22	+ start: 1,
23	+ offset: 1,
24	+ size: null,
25	+ scroll: 3,
26	+ visible: null,
27	+ animation: 'normal',
28	+ easing: 'swing',
29	+ auto: 1,
30	+ wrap: null,
31	+ initCallback: null,
32	+ reloadCallback: null,
33	+ itemLoadCallback: null,
34	+ itemFirstInCallback: null,
35	+ itemFirstOutCallback: null,
36	+ itemLastInCallback: null,
37	+ itemLastOutCallback: null,
38	+ itemVisibleInCallback: null,
39	+ itemVisibleOutCallback: null,
40	+ buttonNextHTML: '<div></div>',
41	+ buttonPrevHTML: '<div></div>',
42	+ buttonNextEvent: 'click',
43	+ buttonPrevEvent: 'click',
44	+ buttonNextCallback: null,
45	+ buttonPrevCallback: null
46	+ };
47	+ $.jcarousel = function (e, o) {
48	+ this.options = $.extend({}, q, o \|\| {});
49	+ this.locked = false;
50	+ this.container = null;
51	+ this.clip = null;
52	+ this.list = null;
53	+ this.buttonNext = null;
54	+ this.buttonPrev = null;
55	+ this.wh = !this.options.vertical ? 'width' : 'height';
56	+ this.lt = !this.options.vertical ? 'left' : 'top';
57	+ var a = '',
58	+ split = e.className.split(' ');
59	+ for (var i = 0; i < split.length; i++) {
60	+ if (split[i].indexOf('jcarousel-skin') != -1) {
61	+ $(e).removeClass(split[i]);
62	+ var a = split[i];
63	+ break
64	+ }
65	+ }
66	+ if (e.nodeName == 'UL' \|\| e.nodeName == 'OL') {
67	+ this.list = $(e);
68	+ this.container = this.list.parent();
69	+ if (this.container.hasClass('jcarousel-clip')) {
70	+ if (!this.container.parent().hasClass('jcarousel-container')) this.container = this.container.wrap('<div></div>');
71	+ this.container = this.container.parent()
72	+ } else if (!this.container.hasClass('jcarousel-container')) this.container = this.list.wrap('<div></div>').parent()
73	+ } else {
74	+ this.container = $(e);
75	+ this.list = $(e).find('>ul,>ol,div>ul,div>ol')
76	+ }
77	+ if (a != '' && this.container.parent()[0].className.indexOf('jcarousel-skin') == -1) this.container.wrap('<div class=" ' + a + '"></div>');
78	+ this.clip = this.list.parent();
79	+ if (!this.clip.length \|\| !this.clip.hasClass('jcarousel-clip')) this.clip = this.list.wrap('<div></div>').parent();
80	+ this.buttonPrev = $('.jcarousel-prev', this.container);
81	+ if (this.buttonPrev.size() == 0 && this.options.buttonPrevHTML != null) this.buttonPrev = this.clip.before(this.options.buttonPrevHTML).prev();
82	+ this.buttonPrev.addClass(this.className('jcarousel-prev'));
83	+ this.buttonNext = $('.jcarousel-next', this.container);
84	+ if (this.buttonNext.size() == 0 && this.options.buttonNextHTML != null) this.buttonNext = this.clip.before(this.options.buttonNextHTML).prev();
85	+ this.buttonNext.addClass(this.className('jcarousel-next'));
86	+ this.clip.addClass(this.className('jcarousel-clip'));
87	+ this.list.addClass(this.className('jcarousel-list'));
88	+ this.container.addClass(this.className('jcarousel-container'));
89	+ var b = this.options.visible != null ? Math.ceil(this.clipping() / this.options.visible) : null;
90	+ var c = this.list.children('li');
91	+ var d = this;
92	+ if (c.size() > 0) {
93	+ var f = 0,
94	+ i = this.options.offset;
95	+ c.each(function () {
96	+ d.format(this, i++);
97	+ f += d.dimension(this, b)
98	+ });
99	+ this.list.css(this.wh, f + 'px');
100	+ if (!o \|\| o.size === undefined) this.options.size = c.size()
101	+ }
102	+ this.container.css('display', 'block');
103	+ this.buttonNext.css('display', 'block');
104	+ this.buttonPrev.css('display', 'block');
105	+ this.funcNext = function () {
106	+ d.next()
107	+ };
108	+ this.funcPrev = function () {
109	+ d.prev()
110	+ };
111	+ this.funcResize = function () {
112	+ d.reload()
113	+ };
114	+ if (this.options.initCallback != null) this.options.initCallback(this, 'init');
115	+ if ($.browser.safari) {
116	+ this.buttons(false, false);
117	+ $(window).bind('load', function () {
118	+ d.setup()
119	+ })
120	+ } else this.setup()
121	+ };
122	+ var r = $.jcarousel;
123	+ r.fn = r.prototype = {
124	+ jcarousel: '0.2.3'
125	+ };
126	+ r.fn.extend = r.extend = $.extend;
127	+ r.fn.extend({
128	+ setup: function () {
129	+ this.first = null;
130	+ this.last = null;
131	+ this.prevFirst = null;
132	+ this.prevLast = null;
133	+ this.animating = false;
134	+ this.timer = null;
135	+ this.tail = null;
136	+ this.inTail = false;
137	+ if (this.locked) return;
138	+ this.list.css(this.lt, this.pos(this.options.offset) + 'px');
139	+ var p = this.pos(this.options.start);
140	+ this.prevFirst = this.prevLast = null;
141	+ this.animate(p, false);
142	+ $(window).unbind('resize', this.funcResize).bind('resize', this.funcResize)
143	+ },
144	+ reset: function () {
145	+ this.list.empty();
146	+ this.list.css(this.lt, '0px');
147	+ this.list.css(this.wh, '10px');
148	+ if (this.options.initCallback != null) this.options.initCallback(this, 'reset');
149	+ this.setup()
150	+ },
151	+ reload: function () {
152	+ if (this.tail != null && this.inTail) this.list.css(this.lt, r.intval(this.list.css(this.lt)) + this.tail);
153	+ this.tail = null;
154	+ this.inTail = false;
155	+ if (this.options.reloadCallback != null) this.options.reloadCallback(this);
156	+ if (this.options.visible != null) {
157	+ var a = this;
158	+ var b = Math.ceil(this.clipping() / this.options.visible),
159	+ wh = 0,
160	+ lt = 0;
161	+ $('li', this.list).each(function (i) {
162	+ wh += a.dimension(this, b);
163	+ if (i + 1 < a.first) lt = wh
164	+ });
165	+ this.list.css(this.wh, wh + 'px');
166	+ this.list.css(this.lt, -lt + 'px')
167	+ }
168	+ this.scroll(this.first, false)
169	+ },
170	+ lock: function () {
171	+ this.locked = true;
172	+ this.buttons()
173	+ },
174	+ unlock: function () {
175	+ this.locked = false;
176	+ this.buttons()
177	+ },
178	+ size: function (s) {
179	+ if (s != undefined) {
180	+ this.options.size = s;
181	+ if (!this.locked) this.buttons()
182	+ }
183	+ return this.options.size
184	+ },
185	+ has: function (i, a) {
186	+ if (a == undefined \|\| !a) a = i;
187	+ if (this.options.size !== null && a > this.options.size) a = this.options.size;
188	+ for (var j = i; j <= a; j++) {
189	+ var e = this.get(j);
190	+ if (!e.length \|\| e.hasClass('jcarousel-item-placeholder')) return false
191	+ }
192	+ return true
193	+ },
194	+ get: function (i) {
195	+ return $('.jcarousel-item-' + i, this.list)
196	+ },
197	+ add: function (i, s) {
198	+ var e = this.get(i),
199	+ old = 0,
200	+ add = 0;
201	+ if (e.length == 0) {
202	+ var c, e = this.create(i),
203	+ j = r.intval(i);
204	+ while (c = this.get(--j)) {
205	+ if (j <= 0 \|\| c.length) {
206	+ j <= 0 ? this.list.prepend(e) : c.after(e);
207	+ break
208	+ }
209	+ }
210	+ } else old = this.dimension(e);
211	+ e.removeClass(this.className('jcarousel-item-placeholder'));
212	+ typeof s == 'string' ? e.html(s) : e.empty().append(s);
213	+ var a = this.options.visible != null ? Math.ceil(this.clipping() / this.options.visible) : null;
214	+ var b = this.dimension(e, a) - old;
215	+ if (i > 0 && i < this.first) this.list.css(this.lt, r.intval(this.list.css(this.lt)) - b + 'px');
216	+ this.list.css(this.wh, r.intval(this.list.css(this.wh)) + b + 'px');
217	+ return e
218	+ },
219	+ remove: function (i) {
220	+ var e = this.get(i);
221	+ if (!e.length \|\| (i >= this.first && i <= this.last)) return;
222	+ var d = this.dimension(e);
223	+ if (i < this.first) this.list.css(this.lt, r.intval(this.list.css(this.lt)) + d + 'px');
224	+ e.remove();
225	+ this.list.css(this.wh, r.intval(this.list.css(this.wh)) - d + 'px')
226	+ },
227	+ next: function () {
228	+ this.stopAuto();
229	+ if (this.tail != null && !this.inTail) this.scrollTail(false);
230	+ else this.scroll(((this.options.wrap == 'both' \|\| this.options.wrap == 'last') && this.options.size != null && this.last == this.options.size) ? 1 : this.first + this.options.scroll)
231	+ },
232	+ prev: function () {
233	+ this.stopAuto();
234	+ if (this.tail != null && this.inTail) this.scrollTail(true);
235	+ else this.scroll(((this.options.wrap == 'both' \|\| this.options.wrap == 'first') && this.options.size != null && this.first == 1) ? this.options.size : this.first - this.options.scroll)
236	+ },
237	+ scrollTail: function (b) {
238	+ if (this.locked \|\| this.animating \|\| !this.tail) return;
239	+ var a = r.intval(this.list.css(this.lt));
240	+ !b ? a -= this.tail : a += this.tail;
241	+ this.inTail = !b;
242	+ this.prevFirst = this.first;
243	+ this.prevLast = this.last;
244	+ this.animate(a)
245	+ },
246	+ scroll: function (i, a) {
247	+ if (this.locked \|\| this.animating) return;
248	+ this.animate(this.pos(i), a)
249	+ },
250	+ pos: function (i) {
251	+ if (this.locked \|\| this.animating) return;
252	+ i = r.intval(i);
253	+ if (this.options.wrap != 'circular') i = i < 1 ? 1 : (this.options.size && i > this.options.size ? this.options.size : i);
254	+ var a = this.first > i;
255	+ var b = r.intval(this.list.css(this.lt));
256	+ var f = this.options.wrap != 'circular' && this.first <= 1 ? 1 : this.first;
257	+ var c = a ? this.get(f) : this.get(this.last);
258	+ var j = a ? f : f - 1;
259	+ var e = null,
260	+ l = 0,
261	+ p = false,
262	+ d = 0;
263	+ while (a ? --j >= i : ++j < i) {
264	+ e = this.get(j);
265	+ p = !e.length;
266	+ if (e.length == 0) {
267	+ e = this.create(j).addClass(this.className('jcarousel-item-placeholder'));
268	+ c[a ? 'before' : 'after'](e)
269	+ }
270	+ c = e;
271	+ d = this.dimension(e);
272	+ if (p) l += d;
273	+ if (this.first != null && (this.options.wrap == 'circular' \|\| (j >= 1 && (this.options.size == null \|\| j <= this.options.size)))) b = a ? b + d : b - d
274	+ }
275	+ var g = this.clipping();
276	+ var h = [];
277	+ var k = 0,
278	+ j = i,
279	+ v = 0;
280	+ var c = this.get(i - 1);
281	+ while (++k) {
282	+ e = this.get(j);
283	+ p = !e.length;
284	+ if (e.length == 0) {
285	+ e = this.create(j).addClass(this.className('jcarousel-item-placeholder'));
286	+ c.length == 0 ? this.list.prepend(e) : c[a ? 'before' : 'after'](e)
287	+ }
288	+ c = e;
289	+ var d = this.dimension(e);
290	+ if (d == 0) {
291	+ alert('jCarousel: No width/height set for items. This will cause an infinite loop. Aborting...');
292	+ return 0
293	+ }
294	+ if (this.options.wrap != 'circular' && this.options.size !== null && j > this.options.size) h.push(e);
295	+ else if (p) l += d;
296	+ v += d;
297	+ if (v >= g) break;
298	+ j++
299	+ }
300	+ for (var x = 0; x < h.length; x++) h[x].remove();
301	+ if (l > 0) {
302	+ this.list.css(this.wh, this.dimension(this.list) + l + 'px');
303	+ if (a) {
304	+ b -= l;
305	+ this.list.css(this.lt, r.intval(this.list.css(this.lt)) - l + 'px')
306	+ }
307	+ }
308	+ var n = i + k - 1;
309	+ if (this.options.wrap != 'circular' && this.options.size && n > this.options.size) n = this.options.size;
310	+ if (j > n) {
311	+ k = 0, j = n, v = 0;
312	+ while (++k) {
313	+ var e = this.get(j--);
314	+ if (!e.length) break;
315	+ v += this.dimension(e);
316	+ if (v >= g) break
317	+ }
318	+ }
319	+ var o = n - k + 1;
320	+ if (this.options.wrap != 'circular' && o < 1) o = 1;
321	+ if (this.inTail && a) {
322	+ b += this.tail;
323	+ this.inTail = false
324	+ }
325	+ this.tail = null;
326	+ if (this.options.wrap != 'circular' && n == this.options.size && (n - k + 1) >= 1) {
327	+ var m = r.margin(this.get(n), !this.options.vertical ? 'marginRight' : 'marginBottom');
328	+ if ((v - m) > g) this.tail = v - g - m
329	+ }
330	+ while (i-- > o) b += this.dimension(this.get(i));
331	+ this.prevFirst = this.first;
332	+ this.prevLast = this.last;
333	+ this.first = o;
334	+ this.last = n;
335	+ return b
336	+ },
337	+ animate: function (p, a) {
338	+ if (this.locked \|\| this.animating) return;
339	+ this.animating = true;
340	+ var b = this;
341	+ var c = function () {
342	+ b.animating = false;
343	+ if (p == 0) b.list.css(b.lt, 0);
344	+ if (b.options.wrap == 'both' \|\| b.options.wrap == 'last' \|\| b.options.size == null \|\| b.last < b.options.size) b.startAuto();
345	+ b.buttons();
346	+ b.notify('onAfterAnimation')
347	+ };
348	+ this.notify('onBeforeAnimation');
349	+ if (!this.options.animation \|\| a == false) {
350	+ this.list.css(this.lt, p + 'px');
351	+ c()
352	+ } else {
353	+ var o = !this.options.vertical ? {
354	+ 'left': p
355	+ } : {
356	+ 'top': p
357	+ };
358	+ this.list.animate(o, this.options.animation, this.options.easing, c)
359	+ }
360	+ },
361	+ startAuto: function (s) {
362	+ if (s != undefined) this.options.auto = s;
363	+ if (this.options.auto == 0) return this.stopAuto();
364	+ if (this.timer != null) return;
365	+ var a = this;
366	+ this.timer = setTimeout(function () {
367	+ a.next()
368	+ }, this.options.auto * 1000)
369	+ },
370	+ stopAuto: function () {
371	+ if (this.timer == null) return;
372	+ clearTimeout(this.timer);
373	+ this.timer = null
374	+ },
375	+ buttons: function (n, p) {
376	+ if (n == undefined \|\| n == null) {
377	+ var n = !this.locked && this.options.size !== 0 && ((this.options.wrap && this.options.wrap != 'first') \|\| this.options.size == null \|\| this.last < this.options.size);
378	+ if (!this.locked && (!this.options.wrap \|\| this.options.wrap == 'first') && this.options.size != null && this.last >= this.options.size) n = this.tail != null && !this.inTail
379	+ }
380	+ if (p == undefined \|\| p == null) {
381	+ var p = !this.locked && this.options.size !== 0 && ((this.options.wrap && this.options.wrap != 'last') \|\| this.first > 1);
382	+ if (!this.locked && (!this.options.wrap \|\| this.options.wrap == 'last') && this.options.size != null && this.first == 1) p = this.tail != null && this.inTail
383	+ }
384	+ var a = this;
385	+ this.buttonNext[n ? 'bind' : 'unbind'](this.options.buttonNextEvent, this.funcNext)[n ? 'removeClass' : 'addClass'](this.className('jcarousel-next-disabled')).attr('disabled', n ? false : true);
386	+ this.buttonPrev[p ? 'bind' : 'unbind'](this.options.buttonPrevEvent, this.funcPrev)[p ? 'removeClass' : 'addClass'](this.className('jcarousel-prev-disabled')).attr('disabled', p ? false : true);
387	+ if (this.buttonNext.length > 0 && (this.buttonNext[0].jcarouselstate == undefined \|\| this.buttonNext[0].jcarouselstate != n) && this.options.buttonNextCallback != null) {
388	+ this.buttonNext.each(function () {
389	+ a.options.buttonNextCallback(a, this, n)
390	+ });
391	+ this.buttonNext[0].jcarouselstate = n
392	+ }
393	+ if (this.buttonPrev.length > 0 && (this.buttonPrev[0].jcarouselstate == undefined \|\| this.buttonPrev[0].jcarouselstate != p) && this.options.buttonPrevCallback != null) {
394	+ this.buttonPrev.each(function () {
395	+ a.options.buttonPrevCallback(a, this, p)
396	+ });
397	+ this.buttonPrev[0].jcarouselstate = p
398	+ }
399	+ },
400	+ notify: function (a) {
401	+ var b = this.prevFirst == null ? 'init' : (this.prevFirst < this.first ? 'next' : 'prev');
402	+ this.callback('itemLoadCallback', a, b);
403	+ if (this.prevFirst !== this.first) {
404	+ this.callback('itemFirstInCallback', a, b, this.first);
405	+ this.callback('itemFirstOutCallback', a, b, this.prevFirst)
406	+ }
407	+ if (this.prevLast !== this.last) {
408	+ this.callback('itemLastInCallback', a, b, this.last);
409	+ this.callback('itemLastOutCallback', a, b, this.prevLast)
410	+ }
411	+ this.callback('itemVisibleInCallback', a, b, this.first, this.last, this.prevFirst, this.prevLast);
412	+ this.callback('itemVisibleOutCallback', a, b, this.prevFirst, this.prevLast, this.first, this.last)
413	+ },
414	+ callback: function (a, b, c, d, e, f, g) {
415	+ if (this.options[a] == undefined \|\| (typeof this.options[a] != 'object' && b != 'onAfterAnimation')) return;
416	+ var h = typeof this.options[a] == 'object' ? this.options[a][b] : this.options[a];
417	+ if (!$.isFunction(h)) return;
418	+ var j = this;
419	+ if (d === undefined) h(j, c, b);
420	+ else if (e === undefined) this.get(d).each(function () {
421	+ h(j, this, d, c, b)
422	+ });
423	+ else {
424	+ for (var i = d; i <= e; i++) if (i !== null && !(i >= f && i <= g)) this.get(i).each(function () {
425	+ h(j, this, i, c, b)
426	+ })
427	+ }
428	+ },
429	+ create: function (i) {
430	+ return this.format('<li></li>', i)
431	+ },
432	+ format: function (e, i) {
433	+ var a = $(e).addClass(this.className('jcarousel-item')).addClass(this.className('jcarousel-item-' + i));
434	+ a.attr('jcarouselindex', i);
435	+ return a
436	+ },
437	+ className: function (c) {
438	+ return c + ' ' + c + (!this.options.vertical ? '-horizontal' : '-vertical')
439	+ },
440	+ dimension: function (e, d) {
441	+ var a = e.jquery != undefined ? e[0] : e;
442	+ var b = !this.options.vertical ? a.offsetWidth + r.margin(a, 'marginLeft') + r.margin(a, 'marginRight') : a.offsetHeight + r.margin(a, 'marginTop') + r.margin(a, 'marginBottom');
443	+ if (d == undefined \|\| b == d) return b;
444	+ var w = !this.options.vertical ? d - r.margin(a, 'marginLeft') - r.margin(a, 'marginRight') : d - r.margin(a, 'marginTop') - r.margin(a, 'marginBottom');
445	+ $(a).css(this.wh, w + 'px');
446	+ return this.dimension(a)
447	+ },
448	+ clipping: function () {
449	+ return !this.options.vertical ? this.clip[0].offsetWidth - r.intval(this.clip.css('borderLeftWidth')) - r.intval(this.clip.css('borderRightWidth')) : this.clip[0].offsetHeight - r.intval(this.clip.css('borderTopWidth')) - r.intval(this.clip.css('borderBottomWidth'))
450	+ },
451	+ index: function (i, s) {
452	+ if (s == undefined) s = this.options.size;
453	+ return Math.round((((i - 1) / s) - Math.floor((i - 1) / s)) * s) + 1
454	+ }
455	+ });
456	+ r.extend({
457	+ defaults: function (d) {
458	+ return $.extend(q, d \|\| {})
459	+ },
460	+ margin: function (e, p) {
461	+ if (!e) return 0;
462	+ var a = e.jquery != undefined ? e[0] : e;
463	+ if (p == 'marginRight' && $.browser.safari) {
464	+ var b = {
465	+ 'display': 'block',
466	+ 'float': 'none',
467	+ 'width': 'auto'
468	+ },
469	+ oWidth, oWidth2;
470	+ $.swap(a, b, function () {
471	+ oWidth = a.offsetWidth
472	+ });
473	+ b['marginRight'] = 0;
474	+ $.swap(a, b, function () {
475	+ oWidth2 = a.offsetWidth
476	+ });
477	+ return oWidth2 - oWidth
478	+ }
479	+ return r.intval($.css(a, p))
480	+ },
481	+ intval: function (v) {
482	+ v = parseInt(v);
483	+ return isNaN(v) ? 0 : v
484	+ }
485	+ })
486	+ })(jQuery);
487	+ jQuery.noConflict();

Etatvasoft_Dynamic_Image_Slider - Version 1.5.1

Version Notes

Release Info

Version 1.5.1