/* ========================================================================

* Bootstrap: transition.js v3.3.5

* http://getbootstrap.com/javascript/#transitions

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)

// ============================================================

function transitionEnd() {

var el = document.createElement('bootstrap')

var transEndEventNames = {

WebkitTransition : 'webkitTransitionEnd',

MozTransition : 'transitionend',

OTransition : 'oTransitionEnd otransitionend',

transition : 'transitionend'

}

for (var name in transEndEventNames) {

if (el.style[name] !== undefined) {

return { end: transEndEventNames[name] }

}

}

return false // explicit for ie8 ( ._.)

}

// http://blog.alexmaccaw.com/css-transitions

$.fn.emulateTransitionEnd = function (duration) {

var called = false

var $el = this

$(this).one('bsTransitionEnd', function () { called = true })

var callback = function () { if (!called) $($el).trigger($.support.transition.end) }

setTimeout(callback, duration)

return this

}

$(function () {

$.support.transition = transitionEnd()

if (!$.support.transition) return

$.event.special.bsTransitionEnd = {

bindType: $.support.transition.end,

delegateType: $.support.transition.end,

handle: function (e) {

if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)

}

}

})

}(jQuery);

/* ========================================================================

* Bootstrap: affix.js v3.3.5

* http://getbootstrap.com/javascript/#affix

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// AFFIX CLASS DEFINITION

// ======================

var Affix = function (element, options) {

this.options = $.extend({}, Affix.DEFAULTS, options)

this.$target = $(this.options.target)

.on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))

.on('click.bs.affix.data-api', $.proxy(this.checkPositionWithEventLoop, this))

this.$element = $(element)

this.affixed = null

this.unpin = null

this.pinnedOffset = null

this.checkPosition()

}

Affix.VERSION = '3.3.5'

Affix.RESET = 'affix affix-top affix-bottom'

Affix.DEFAULTS = {

offset: 0,

target: window

}

Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {

var scrollTop = this.$target.scrollTop()

var position = this.$element.offset()

var targetHeight = this.$target.height()

if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false

if (this.affixed == 'bottom') {

if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'

return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'

}

var initializing = this.affixed == null

var colliderTop = initializing ? scrollTop : position.top

var colliderHeight = initializing ? targetHeight : height

if (offsetTop != null && scrollTop <= offsetTop) return 'top'

if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'

return false

}

Affix.prototype.getPinnedOffset = function () {

if (this.pinnedOffset) return this.pinnedOffset

this.$element.removeClass(Affix.RESET).addClass('affix')

var scrollTop = this.$target.scrollTop()

var position = this.$element.offset()

return (this.pinnedOffset = position.top - scrollTop)

}

Affix.prototype.checkPositionWithEventLoop = function () {

setTimeout($.proxy(this.checkPosition, this), 1)

}

Affix.prototype.checkPosition = function () {

if (!this.$element.is(':visible')) return

var height = this.$element.height()

var offset = this.options.offset

var offsetTop = offset.top

var offsetBottom = offset.bottom

var scrollHeight = Math.max($(document).height(), $(document.body).height())

if (typeof offset != 'object') offsetBottom = offsetTop = offset

if (typeof offsetTop == 'function') offsetTop = offset.top(this.$element)

if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)

var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)

if (this.affixed != affix) {

if (this.unpin != null) this.$element.css('top', '')

var affixType = 'affix' + (affix ? '-' + affix : '')

var e = $.Event(affixType + '.bs.affix')

this.$element.trigger(e)

if (e.isDefaultPrevented()) return

this.affixed = affix

this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null

this.$element

.removeClass(Affix.RESET)

.addClass(affixType)

.trigger(affixType.replace('affix', 'affixed') + '.bs.affix')

}

if (affix == 'bottom') {

this.$element.offset({

top: scrollHeight - height - offsetBottom

})

}

}

// AFFIX PLUGIN DEFINITION

// =======================

function Plugin(option) {

return this.each(function () {

var $this = $(this)

var data = $this.data('bs.affix')

var options = typeof option == 'object' && option

if (!data) $this.data('bs.affix', (data = new Affix(this, options)))

if (typeof option == 'string') data[option]()

})

}

var old = $.fn.affix

$.fn.affix = Plugin

$.fn.affix.Constructor = Affix

// AFFIX NO CONFLICT

// =================

$.fn.affix.noConflict = function () {

$.fn.affix = old

return this

}

// AFFIX DATA-API

// ==============

$(window).on('load', function () {

$('[data-spy="affix"]').each(function () {

var $spy = $(this)

var data = $spy.data()

data.offset = data.offset || {}

if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom

if (data.offsetTop != null) data.offset.top = data.offsetTop

Plugin.call($spy, data)

})

})

}(jQuery);

/* ========================================================================

* Bootstrap: alert.js v3.3.5

* http://getbootstrap.com/javascript/#alerts

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// ALERT CLASS DEFINITION

// ======================

var dismiss = '[data-dismiss="alert"]'

var Alert = function (el) {

$(el).on('click', dismiss, this.close)

}

Alert.VERSION = '3.3.5'

Alert.TRANSITION_DURATION = 150

Alert.prototype.close = function (e) {

var $this = $(this)

var selector = $this.attr('data-target')

if (!selector) {

selector = $this.attr('href')

selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7

}

var $parent = $(selector)

if (e) e.preventDefault()

if (!$parent.length) {

$parent = $this.closest('.alert')

}

$parent.trigger(e = $.Event('close.bs.alert'))

if (e.isDefaultPrevented()) return

$parent.removeClass('in')

function removeElement() {

// detach from parent, fire event then clean up data

$parent.detach().trigger('closed.bs.alert').remove()

}

$.support.transition && $parent.hasClass('fade') ?

$parent

.one('bsTransitionEnd', removeElement)

.emulateTransitionEnd(Alert.TRANSITION_DURATION) :

removeElement()

}

// ALERT PLUGIN DEFINITION

// =======================

function Plugin(option) {

return this.each(function () {

var $this = $(this)

var data = $this.data('bs.alert')

if (!data) $this.data('bs.alert', (data = new Alert(this)))

if (typeof option == 'string') data[option].call($this)

})

}

var old = $.fn.alert

$.fn.alert = Plugin

$.fn.alert.Constructor = Alert

// ALERT NO CONFLICT

// =================

$.fn.alert.noConflict = function () {

$.fn.alert = old

return this

}

// ALERT DATA-API

// ==============

$(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)

}(jQuery);

/* ========================================================================

* Bootstrap: button.js v3.3.5

* http://getbootstrap.com/javascript/#buttons

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// BUTTON PUBLIC CLASS DEFINITION

// ==============================

var Button = function (element, options) {

this.$element = $(element)

this.options = $.extend({}, Button.DEFAULTS, options)

this.isLoading = false

}

Button.VERSION = '3.3.5'

Button.DEFAULTS = {

loadingText: 'loading...'

}

Button.prototype.setState = function (state) {

var d = 'disabled'

var $el = this.$element

var val = $el.is('input') ? 'val' : 'html'

var data = $el.data()

state += 'Text'

if (data.resetText == null) $el.data('resetText', $el[val]())

// push to event loop to allow forms to submit

setTimeout($.proxy(function () {

$el[val](data[state] == null ? this.options[state] : data[state])

if (state == 'loadingText') {

this.isLoading = true

$el.addClass(d).attr(d, d)

} else if (this.isLoading) {

this.isLoading = false

$el.removeClass(d).removeAttr(d)

}

}, this), 0)

}

Button.prototype.toggle = function () {

var changed = true

var $parent = this.$element.closest('[data-toggle="buttons"]')

if ($parent.length) {

var $input = this.$element.find('input')

if ($input.prop('type') == 'radio') {

if ($input.prop('checked')) changed = false

$parent.find('.active').removeClass('active')

this.$element.addClass('active')

} else if ($input.prop('type') == 'checkbox') {

if (($input.prop('checked')) !== this.$element.hasClass('active')) changed = false

this.$element.toggleClass('active')

}

$input.prop('checked', this.$element.hasClass('active'))

if (changed) $input.trigger('change')

} else {

this.$element.attr('aria-pressed', !this.$element.hasClass('active'))

this.$element.toggleClass('active')

}

}

// BUTTON PLUGIN DEFINITION

// ========================

function Plugin(option) {

return this.each(function () {

var $this = $(this)

var data = $this.data('bs.button')

var options = typeof option == 'object' && option

if (!data) $this.data('bs.button', (data = new Button(this, options)))

if (option == 'toggle') data.toggle()

else if (option) data.setState(option)

})

}

var old = $.fn.button

$.fn.button = Plugin

$.fn.button.Constructor = Button

// BUTTON NO CONFLICT

// ==================

$.fn.button.noConflict = function () {

$.fn.button = old

return this

}

// BUTTON DATA-API

// ===============

$(document)

.on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {

var $btn = $(e.target)

if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')

Plugin.call($btn, 'toggle')

if (!($(e.target).is('input[type="radio"]') || $(e.target).is('input[type="checkbox"]'))) e.preventDefault()

})

.on('focus.bs.button.data-api blur.bs.button.data-api', '[data-toggle^="button"]', function (e) {

$(e.target).closest('.btn').toggleClass('focus', /^focus(in)?$/.test(e.type))

})

}(jQuery);

/* ========================================================================

* Bootstrap: carousel.js v3.3.5

* http://getbootstrap.com/javascript/#carousel

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// CAROUSEL CLASS DEFINITION

// =========================

var Carousel = function (element, options) {

this.$element = $(element)

this.$indicators = this.$element.find('.carousel-indicators')

this.options = options

this.paused = null

this.sliding = null

this.interval = null

this.$active = null

this.$items = null

this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this))

this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element

.on('mouseenter.bs.carousel', $.proxy(this.pause, this))

.on('mouseleave.bs.carousel', $.proxy(this.cycle, this))

}

Carousel.VERSION = '3.3.5'

Carousel.TRANSITION_DURATION = 600

Carousel.DEFAULTS = {

interval: 5000,

pause: 'hover',

wrap: true,

keyboard: true

}

Carousel.prototype.keydown = function (e) {

if (/input|textarea/i.test(e.target.tagName)) return

switch (e.which) {

case 37: this.prev(); break

case 39: this.next(); break

default: return

}

e.preventDefault()

}

Carousel.prototype.cycle = function (e) {

e || (this.paused = false)

this.interval && clearInterval(this.interval)

this.options.interval

&& !this.paused

&& (this.interval = setInterval($.proxy(this.next, this), this.options.interval))

return this

}

Carousel.prototype.getItemIndex = function (item) {

this.$items = item.parent().children('.item')

return this.$items.index(item || this.$active)

}

Carousel.prototype.getItemForDirection = function (direction, active) {

var activeIndex = this.getItemIndex(active)

var willWrap = (direction == 'prev' && activeIndex === 0)

|| (direction == 'next' && activeIndex == (this.$items.length - 1))

if (willWrap && !this.options.wrap) return active

var delta = direction == 'prev' ? -1 : 1

var itemIndex = (activeIndex + delta) % this.$items.length

return this.$items.eq(itemIndex)

}

Carousel.prototype.to = function (pos) {

var that = this

var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))

if (pos > (this.$items.length - 1) || pos < 0) return

if (this.sliding) return this.$element.one('slid.bs.carousel', function () { that.to(pos) }) // yes, "slid"

if (activeIndex == pos) return this.pause().cycle()

return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos))

}

Carousel.prototype.pause = function (e) {

e || (this.paused = true)

if (this.$element.find('.next, .prev').length && $.support.transition) {

this.$element.trigger($.support.transition.end)

this.cycle(true)

}

this.interval = clearInterval(this.interval)

return this

}

Carousel.prototype.next = function () {

if (this.sliding) return

return this.slide('next')

}

Carousel.prototype.prev = function () {

if (this.sliding) return

return this.slide('prev')

}

Carousel.prototype.slide = function (type, next) {

var $active = this.$element.find('.item.active')

var $next = next || this.getItemForDirection(type, $active)

var isCycling = this.interval

var direction = type == 'next' ? 'left' : 'right'

var that = this

if ($next.hasClass('active')) return (this.sliding = false)

var relatedTarget = $next[0]

var slideEvent = $.Event('slide.bs.carousel', {

relatedTarget: relatedTarget,

direction: direction

})

this.$element.trigger(slideEvent)

if (slideEvent.isDefaultPrevented()) return

this.sliding = true

isCycling && this.pause()

if (this.$indicators.length) {

this.$indicators.find('.active').removeClass('active')

var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])

$nextIndicator && $nextIndicator.addClass('active')

}

var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }) // yes, "slid"

if ($.support.transition && this.$element.hasClass('slide')) {

$next.addClass(type)

$next[0].offsetWidth // force reflow

$active.addClass(direction)

$next.addClass(direction)

$active

.one('bsTransitionEnd', function () {

$next.removeClass([type, direction].join(' ')).addClass('active')

$active.removeClass(['active', direction].join(' '))

that.sliding = false

setTimeout(function () {

that.$element.trigger(slidEvent)

}, 0)

})

.emulateTransitionEnd(Carousel.TRANSITION_DURATION)

} else {

$active.removeClass('active')

$next.addClass('active')

this.sliding = false

this.$element.trigger(slidEvent)

}

isCycling && this.cycle()

return this

}

// CAROUSEL PLUGIN DEFINITION

// ==========================

function Plugin(option) {

return this.each(function () {

var $this = $(this)

var data = $this.data('bs.carousel')

var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)

var action = typeof option == 'string' ? option : options.slide

if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))

if (typeof option == 'number') data.to(option)

else if (action) data[action]()

else if (options.interval) data.pause().cycle()

})

}

var old = $.fn.carousel

$.fn.carousel = Plugin

$.fn.carousel.Constructor = Carousel

// CAROUSEL NO CONFLICT

// ====================

$.fn.carousel.noConflict = function () {

$.fn.carousel = old

return this

}

// CAROUSEL DATA-API

// =================

var clickHandler = function (e) {

var href

var $this = $(this)

var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7

if (!$target.hasClass('carousel')) return

var options = $.extend({}, $target.data(), $this.data())

var slideIndex = $this.attr('data-slide-to')

if (slideIndex) options.interval = false

Plugin.call($target, options)

if (slideIndex) {

$target.data('bs.carousel').to(slideIndex)

}

e.preventDefault()

}

$(document)

.on('click.bs.carousel.data-api', '[data-slide]', clickHandler)

.on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)

$(window).on('load', function () {

$('[data-ride="carousel"]').each(function () {

var $carousel = $(this)

Plugin.call($carousel, $carousel.data())

})

})

}(jQuery);

/* ========================================================================

* Bootstrap: collapse.js v3.3.5

* http://getbootstrap.com/javascript/#collapse

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// COLLAPSE PUBLIC CLASS DEFINITION

// ================================

var Collapse = function (element, options) {

this.$element = $(element)

this.options = $.extend({}, Collapse.DEFAULTS, options)

this.$trigger = $('[data-toggle="collapse"][href="#' + element.id + '"],' +

'[data-toggle="collapse"][data-target="#' + element.id + '"]')

this.transitioning = null

if (this.options.parent) {

this.$parent = this.getParent()

} else {

this.addAriaAndCollapsedClass(this.$element, this.$trigger)

}

if (this.options.toggle) this.toggle()

}

Collapse.VERSION = '3.3.5'

Collapse.TRANSITION_DURATION = 350

Collapse.DEFAULTS = {

toggle: true

}

Collapse.prototype.dimension = function () {

var hasWidth = this.$element.hasClass('width')

return hasWidth ? 'width' : 'height'

}

Collapse.prototype.show = function () {

if (this.transitioning || this.$element.hasClass('in')) return

var activesData

var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')

if (actives && actives.length) {

activesData = actives.data('bs.collapse')

if (activesData && activesData.transitioning) return

}

var startEvent = $.Event('show.bs.collapse')

this.$element.trigger(startEvent)

if (startEvent.isDefaultPrevented()) return

if (actives && actives.length) {

Plugin.call(actives, 'hide')

activesData || actives.data('bs.collapse', null)

}

var dimension = this.dimension()

this.$element

.removeClass('collapse')

.addClass('collapsing')[dimension](0)

.attr('aria-expanded', true)

this.$trigger

.removeClass('collapsed')

.attr('aria-expanded', true)

this.transitioning = 1

var complete = function () {

this.$element

.removeClass('collapsing')

.addClass('collapse in')[dimension]('')

this.transitioning = 0

this.$element

.trigger('shown.bs.collapse')

}

if (!$.support.transition) return complete.call(this)

var scrollSize = $.camelCase(['scroll', dimension].join('-'))

this.$element

.one('bsTransitionEnd', $.proxy(complete, this))

.emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])

}

Collapse.prototype.hide = function () {

if (this.transitioning || !this.$element.hasClass('in')) return

var startEvent = $.Event('hide.bs.collapse')

this.$element.trigger(startEvent)

if (startEvent.isDefaultPrevented()) return

var dimension = this.dimension()

this.$element[dimension](this.$element[dimension]())[0].offsetHeight

this.$element

.addClass('collapsing')

.removeClass('collapse in')

.attr('aria-expanded', false)

this.$trigger

.addClass('collapsed')

.attr('aria-expanded', false)

this.transitioning = 1

var complete = function () {

this.transitioning = 0

this.$element

.removeClass('collapsing')

.addClass('collapse')

.trigger('hidden.bs.collapse')

}

if (!$.support.transition) return complete.call(this)

this.$element

[dimension](0)

.one('bsTransitionEnd', $.proxy(complete, this))

.emulateTransitionEnd(Collapse.TRANSITION_DURATION)

}

Collapse.prototype.toggle = function () {

this[this.$element.hasClass('in') ? 'hide' : 'show']()

}

Collapse.prototype.getParent = function () {

return $(this.options.parent)

.find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')

.each($.proxy(function (i, element) {

var $element = $(element)

this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)

}, this))

.end()

}

Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {

var isOpen = $element.hasClass('in')

$element.attr('aria-expanded', isOpen)

$trigger

.toggleClass('collapsed', !isOpen)

.attr('aria-expanded', isOpen)

}

function getTargetFromTrigger($trigger) {

var href

var target = $trigger.attr('data-target')

|| (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7

return $(target)

}

// COLLAPSE PLUGIN DEFINITION

// ==========================

function Plugin(option) {

return this.each(function () {

var $this = $(this)

var data = $this.data('bs.collapse')

var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)

if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false

if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))

if (typeof option == 'string') data[option]()

})

}

var old = $.fn.collapse

$.fn.collapse = Plugin

$.fn.collapse.Constructor = Collapse

// COLLAPSE NO CONFLICT

// ====================

$.fn.collapse.noConflict = function () {

$.fn.collapse = old

return this

}

// COLLAPSE DATA-API

// =================

$(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {

var $this = $(this)

if (!$this.attr('data-target')) e.preventDefault()

var $target = getTargetFromTrigger($this)

var data = $target.data('bs.collapse')

var option = data ? 'toggle' : $this.data()

Plugin.call($target, option)

})

}(jQuery);

/* ========================================================================

* Bootstrap: dropdown.js v3.3.5

* http://getbootstrap.com/javascript/#dropdowns

* ========================================================================

* Copyright 2011-2015 Twitter, Inc.

* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)

* ======================================================================== */

+function ($) {

'use strict';

// DROPDOWN CLASS DEFINITION

// =========================

var backdrop = '.dropdown-backdrop'

var toggle = '[data-toggle="dropdown"]'

var Dropdown = function (element) {

$(element).on('click.bs.dropdown', this.toggle)

}

Dropdown.VERSION = '3.3.5'

function getParent($this) {

var selector = $this.attr('data-target')

if (!selector) {

selector = $this.attr('href')

selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7

}

var $parent = selector && $(selector)

return $parent && $parent.length ? $parent : $this.parent()

}

function clearMenus(e) {

if (e && e.which === 3) return

$(backdrop).remove()

$(toggle).each(function () {

var $this = $(this)

var $parent = getParent($this)

var relatedTarget = { relatedTarget: this }

if (!$parent.hasClass('open')) return

if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return

$parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))

if (e.isDefaultPrevented()) return

$this.attr('aria-expanded', 'false')

$parent.removeClass('open').trigger('hidden.bs.dropdown', relatedTarget)

})

}

Dropdown.prototype.toggle = function (e) {

var $this = $(this)

if ($this.is('.disabled, :disabled')) return

var $parent = getParent($this)

var isActive = $parent.hasClass('open')

clearMenus()

if (!isActive) {

if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {

// if mobile we use a backdrop because click events don't delegate

$(document.createElement('div'))

.addClass('dropdown-backdrop')

.insertAfter($(this))

.on('click', clearMenus)

}

var relatedTarget = { relatedTarget: this }

$parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))

if (e.isDefaultPrevented()) return

$this

.trigger('focus')

.attr('aria-expanded', 'true')

$parent

.toggleClass('open')

.trigger('shown.bs.dropdown', relatedTarget)

}

return false

}

Dropdown.prototype.keydown = function (e) {

if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return

var $this = $(this)

e.preventDefault()

e.stopPropagation()

if ($this.is('.disabled, :disabled')) return

var $parent = getParent($this)

var isActive = $parent.hasClass('open')

if (!isActive && e.which != 27 || isActive && e.which == 27) {

if (e.which == 27) $parent.find(toggle).trigger('focus')

return $this.trigger('click')

}