/**

* angular-strap

* @version v2.3.3 - 2015-09-24

* @link http://mgcrea.github.io/angular-strap

* @author Olivier Louvignes <olivier@mg-crea.com> (https://github.com/mgcrea)

* @license MIT License, http://www.opensource.org/licenses/MIT

*/

(function(window, document, undefined) {

'use strict';

angular.module('mgcrea.ngStrap.typeahead', [ 'mgcrea.ngStrap.tooltip', 'mgcrea.ngStrap.helpers.parseOptions' ]).provider('$bsTypeahead', function() {

var defaults = this.defaults = {

animation: 'am-fade',

prefixClass: 'typeahead',

prefixEvent: '$typeahead',

placement: 'bottom-left',

templateUrl: 'typeahead/typeahead.tpl.html',

trigger: 'focus',

container: false,

keyboard: true,

html: false,

delay: 0,

minLength: 1,

filter: 'bsAsyncFilter',

limit: 6,

autoSelect: false,

comparator: '',

trimValue: true

};

this.$get = ["$window", "$rootScope", "$bsTooltip", "$$bsRAF", "$timeout", function($window, $rootScope, $tooltip, $$rAF, $timeout) {

var bodyEl = angular.element($window.document.body);

function TypeaheadFactory(element, controller, config) {

var $typeahead = {};

var options = angular.extend({}, defaults, config);

$typeahead = $tooltip(element, options);

var parentScope = config.scope;

var scope = $typeahead.$scope;

scope.$resetMatches = function() {

scope.$matches = [];

scope.$activeIndex = options.autoSelect ? 0 : -1;

};

scope.$resetMatches();

scope.$activate = function(index) {

scope.$$postDigest(function() {

$typeahead.activate(index);

});

};

scope.$select = function(index, evt) {

scope.$$postDigest(function() {

$typeahead.select(index);

});

};

scope.$isVisible = function() {

return $typeahead.$isVisible();

};

$typeahead.update = function(matches) {

scope.$matches = matches;

if (scope.$activeIndex >= matches.length) {

scope.$activeIndex = options.autoSelect ? 0 : -1;

}

safeDigest(scope);

$$rAF($typeahead.$applyPlacement);

};

$typeahead.activate = function(index) {

scope.$activeIndex = index;

};

$typeahead.select = function(index) {

if (index === -1) return;

var value = scope.$matches[index].value;

controller.$setViewValue(value);

controller.$render();

scope.$resetMatches();

if (parentScope) parentScope.$digest();

scope.$emit(options.prefixEvent + '.select', value, index, $typeahead);

};

$typeahead.$isVisible = function() {

if (!options.minLength || !controller) {

return !!scope.$matches.length;

}

return scope.$matches.length && angular.isString(controller.$viewValue) && controller.$viewValue.length >= options.minLength;

};

$typeahead.$getIndex = function(value) {

var l = scope.$matches.length, i = l;

if (!l) return;

for (i = l; i--; ) {

if (scope.$matches[i].value === value) break;

}

if (i < 0) return;

return i;

};

$typeahead.$onMouseDown = function(evt) {

evt.preventDefault();

evt.stopPropagation();

};

$typeahead.$onKeyDown = function(evt) {

if (!/(38|40|13)/.test(evt.keyCode)) return;

if ($typeahead.$isVisible() && !(evt.keyCode === 13 && scope.$activeIndex === -1)) {

evt.preventDefault();

evt.stopPropagation();

}

if (evt.keyCode === 13 && scope.$matches.length) {

$typeahead.select(scope.$activeIndex);

} else if (evt.keyCode === 38 && scope.$activeIndex > 0) scope.$activeIndex--; else if (evt.keyCode === 40 && scope.$activeIndex < scope.$matches.length - 1) scope.$activeIndex++; else if (angular.isUndefined(scope.$activeIndex)) scope.$activeIndex = 0;

scope.$digest();

};

var show = $typeahead.show;

$typeahead.show = function() {

show();

$timeout(function() {

$typeahead.$element && $typeahead.$element.on('mousedown', $typeahead.$onMouseDown);

if (options.keyboard) {

element && element.on('keydown', $typeahead.$onKeyDown);

}

}, 0, false);

};

var hide = $typeahead.hide;

$typeahead.hide = function() {

$typeahead.$element && $typeahead.$element.off('mousedown', $typeahead.$onMouseDown);

if (options.keyboard) {

element && element.off('keydown', $typeahead.$onKeyDown);

}

if (!options.autoSelect) $typeahead.activate(-1);

hide();

};

return $typeahead;

}

function safeDigest(scope) {

scope.$$phase || scope.$root && scope.$root.$$phase || scope.$digest();

}

TypeaheadFactory.defaults = defaults;

return TypeaheadFactory;

} ];

}).filter('bsAsyncFilter', ["$filter", function($filter) {

return function(array, expression, comparator) {

if (array && angular.isFunction(array.then)) {

return array.then(function(results) {

return $filter('filter')(results, expression, comparator);

});

} else {

return $filter('filter')(array, expression, comparator);

}

};

} ]).directive('bsTypeahead', ["$window", "$parse", "$q", "$bsTypeahead", "$bsParseOptions", function($window, $parse, $q, $typeahead, $parseOptions) {

var defaults = $typeahead.defaults;

return {

restrict: 'EAC',

require: 'ngModel',

link: function postLink(scope, element, attr, controller) {

var options = {

scope: scope

};

angular.forEach([ 'template', 'templateUrl', 'controller', 'controllerAs', 'placement', 'container', 'delay', 'trigger', 'keyboard', 'html', 'animation', 'filter', 'limit', 'minLength', 'watchOptions', 'selectMode', 'autoSelect', 'comparator', 'id', 'prefixEvent', 'prefixClass' ], function(key) {

if (angular.isDefined(attr[key])) options[key] = attr[key];

});

var falseValueRegExp = /^(false|0|)$/i;

angular.forEach([ 'html', 'container', 'trimValue' ], function(key) {

if (angular.isDefined(attr[key]) && falseValueRegExp.test(attr[key])) options[key] = false;

});

if (!element.attr('autocomplete')) element.attr('autocomplete', 'off');

var filter = options.filter || defaults.filter;

var limit = options.limit || defaults.limit;

var comparator = options.comparator || defaults.comparator;

var bsOptions = attr.bsOptions;

if (filter) bsOptions += ' | ' + filter + ':$viewValue';

if (comparator) bsOptions += ':' + comparator;

if (limit) bsOptions += ' | limitTo:' + limit;

var parsedOptions = $parseOptions(bsOptions);

var typeahead = $typeahead(element, controller, options);

if (options.watchOptions) {

var watchedOptions = parsedOptions.$match[7].replace(/\|.+/, '').replace(/\(.*\)/g, '').trim();

scope.$watchCollection(watchedOptions, function(newValue, oldValue) {

parsedOptions.valuesFn(scope, controller).then(function(values) {

typeahead.update(values);

controller.$render();

});

});

}

scope.$watch(attr.ngModel, function(newValue, oldValue) {

scope.$modelValue = newValue;

parsedOptions.valuesFn(scope, controller).then(function(values) {

if (options.selectMode && !values.length && newValue.length > 0) {

controller.$setViewValue(controller.$viewValue.substring(0, controller.$viewValue.length - 1));

return;

}

if (values.length > limit) values = values.slice(0, limit);

var isVisible = typeahead.$isVisible();

isVisible && typeahead.update(values);

if (values.length === 1 && values[0].value === newValue) return;

!isVisible && typeahead.update(values);

controller.$render();

});

});

controller.$formatters.push(function(modelValue) {

var displayValue = parsedOptions.displayValue(modelValue);

if (displayValue) {

return displayValue;

}

if (modelValue && typeof modelValue !== 'object') {

return modelValue;

}

return '';

});

controller.$render = function() {

if (controller.$isEmpty(controller.$viewValue)) {

return element.val('');

}

var index = typeahead.$getIndex(controller.$modelValue);

var selected = angular.isDefined(index) ? typeahead.$scope.$matches[index].label : controller.$viewValue;

selected = angular.isObject(selected) ? parsedOptions.displayValue(selected) : selected;

var value = selected ? selected.toString().replace(/<(?:.|\n)*?>/gm, '') : '';

element.val(options.trimValue === false ? value : value.trim());

};

scope.$on('$destroy', function() {

if (typeahead) typeahead.destroy();

options = null;

typeahead = null;

});

}

};

} ]);

angular.module('mgcrea.ngStrap.tooltip', [ 'mgcrea.ngStrap.core', 'mgcrea.ngStrap.helpers.dimensions' ]).provider('$bsTooltip', function() {

var defaults = this.defaults = {

animation: 'am-fade',

customClass: '',

prefixClass: 'tooltip',

prefixEvent: 'tooltip',

container: false,

target: false,

placement: 'top',

templateUrl: 'tooltip/tooltip.tpl.html',

template: '',

contentTemplate: false,

trigger: 'hover focus',

keyboard: false,

html: false,

show: false,

title: '',

type: '',

delay: 0,

autoClose: false,

bsEnabled: true,

viewport: {

selector: 'body',

padding: 0

}

};

this.$get = ["$window", "$rootScope", "$bsCompiler", "$q", "$templateCache", "$http", "$animate", "$sce", "bsDimensions", "$$bsRAF", "$timeout", function($window, $rootScope, $bsCompiler, $q, $templateCache, $http, $animate, $sce, dimensions, $$rAF, $timeout) {

var trim = String.prototype.trim;

var isTouch = 'createTouch' in $window.document;

var htmlReplaceRegExp = /ng-bind="/gi;

var $body = angular.element($window.document);

function TooltipFactory(element, config) {

var $tooltip = {};

var options = $tooltip.$options = angular.extend({}, defaults, config);

var promise = $tooltip.$promise = $bsCompiler.compile(options);

var scope = $tooltip.$scope = options.scope && options.scope.$new() || $rootScope.$new();

var nodeName = element[0].nodeName.toLowerCase();

if (options.delay && angular.isString(options.delay)) {

var split = options.delay.split(',').map(parseFloat);

options.delay = split.length > 1 ? {

show: split[0],

hide: split[1]

} : split[0];

}

$tooltip.$id = options.id || element.attr('id') || '';

if (options.title) {

scope.title = $sce.trustAsHtml(options.title);

}

scope.$setEnabled = function(isEnabled) {

scope.$$postDigest(function() {

$tooltip.setEnabled(isEnabled);

});

};

scope.$hide = function() {

scope.$$postDigest(function() {

$tooltip.hide();

});

};

scope.$show = function() {

scope.$$postDigest(function() {

$tooltip.show();

});

};

scope.$toggle = function() {

scope.$$postDigest(function() {

$tooltip.toggle();

});

};

$tooltip.$isShown = scope.$isShown = false;

var timeout, hoverState;

var compileData, tipElement, tipContainer, tipScope;

promise.then(function(data) {

compileData = data;

$tooltip.init();

});

$tooltip.init = function() {

if (options.delay && angular.isNumber(options.delay)) {

options.delay = {

show: options.delay,

hide: options.delay

};

}

if (options.container === 'self') {

tipContainer = element;

} else if (angular.isElement(options.container)) {

tipContainer = options.container;

} else if (options.container) {

tipContainer = findElement(options.container);

}

bindTriggerEvents();

if (options.target) {

options.target = angular.isElement(options.target) ? options.target : findElement(options.target);

}

if (options.show) {

scope.$$postDigest(function() {

options.trigger === 'focus' ? element[0].focus() : $tooltip.show();

});

}

};

$tooltip.destroy = function() {

unbindTriggerEvents();

destroyTipElement();

scope.$destroy();

};

$tooltip.enter = function() {

clearTimeout(timeout);

hoverState = 'in';

if (!options.delay || !options.delay.show) {

return $tooltip.show();

}

timeout = setTimeout(function() {

if (hoverState === 'in') $tooltip.show();

}, options.delay.show);

};

$tooltip.show = function() {

if (!options.bsEnabled || $tooltip.$isShown) return;

scope.$emit(options.prefixEvent + '.show.before', $tooltip);

var parent, after;

if (options.container) {

parent = tipContainer;

if (tipContainer[0].lastChild) {

after = angular.element(tipContainer[0].lastChild);

} else {

after = null;

}

} else {

parent = null;

after = element;

}

if (tipElement) destroyTipElement();

tipScope = $tooltip.$scope.$new();

tipElement = $tooltip.$element = compileData.link(tipScope, function(clonedElement, scope) {});

tipElement.css({

top: '-9999px',

left: '-9999px',

right: 'auto',

display: 'block',

visibility: 'hidden'

});

if (options.animation) tipElement.addClass(options.animation);

if (options.type) tipElement.addClass(options.prefixClass + '-' + options.type);

if (options.customClass) tipElement.addClass(options.customClass);

after ? after.after(tipElement) : parent.prepend(tipElement);

$tooltip.$isShown = scope.$isShown = true;

safeDigest(scope);

$tooltip.$applyPlacement();

if (angular.version.minor <= 2) {

$animate.enter(tipElement, parent, after, enterAnimateCallback);

} else {

$animate.enter(tipElement, parent, after).then(enterAnimateCallback);

}

safeDigest(scope);

$$rAF(function() {

if (tipElement) tipElement.css({

visibility: 'visible'

});

});

if (options.keyboard) {

if (options.trigger !== 'focus') {

$tooltip.focus();

}

bindKeyboardEvents();

}

if (options.autoClose) {

bindAutoCloseEvents();

}

};

function enterAnimateCallback() {

scope.$emit(options.prefixEvent + '.show', $tooltip);

}

$tooltip.leave = function() {

clearTimeout(timeout);

hoverState = 'out';

if (!options.delay || !options.delay.hide) {

return $tooltip.hide();

}

timeout = setTimeout(function() {

if (hoverState === 'out') {

$tooltip.hide();

}

}, options.delay.hide);

};

var _blur;

var _tipToHide;

$tooltip.hide = function(blur) {

if (!$tooltip.$isShown) return;

scope.$emit(options.prefixEvent + '.hide.before', $tooltip);

_blur = blur;

_tipToHide = tipElement;

if (angular.version.minor <= 2) {

$animate.leave(tipElement, leaveAnimateCallback);

} else {

$animate.leave(tipElement).then(leaveAnimateCallback);

}

$tooltip.$isShown = scope.$isShown = false;

safeDigest(scope);

if (options.keyboard && tipElement !== null) {

unbindKeyboardEvents();

}

if (options.autoClose && tipElement !== null) {

unbindAutoCloseEvents();

}

};

function leaveAnimateCallback() {

scope.$emit(options.prefixEvent + '.hide', $tooltip);

if (tipElement === _tipToHide) {

if (_blur && options.trigger === 'focus') {

return element[0].blur();

}

destroyTipElement();

}

}

$tooltip.toggle = function() {

$tooltip.$isShown ? $tooltip.leave() : $tooltip.enter();

};

$tooltip.focus = function() {

tipElement[0].focus();

};

$tooltip.setEnabled = function(isEnabled) {

options.bsEnabled = isEnabled;

};

$tooltip.setViewport = function(viewport) {

options.viewport = viewport;

};

$tooltip.$applyPlacement = function() {

if (!tipElement) return;

var placement = options.placement, autoToken = /\s?auto?\s?/i, autoPlace = autoToken.test(placement);

if (autoPlace) {

placement = placement.replace(autoToken, '') || defaults.placement;

}

tipElement.addClass(options.placement);

var elementPosition = getPosition(), tipWidth = tipElement.prop('offsetWidth'), tipHeight = tipElement.prop('offsetHeight');

$tooltip.$viewport = options.viewport && findElement(options.viewport.selector || options.viewport);

if (autoPlace) {

var originalPlacement = placement;

var viewportPosition = getPosition($tooltip.$viewport);

if (originalPlacement.indexOf('bottom') >= 0 && elementPosition.bottom + tipHeight > viewportPosition.bottom) {

placement = originalPlacement.replace('bottom', 'top');

} else if (originalPlacement.indexOf('top') >= 0 && elementPosition.top - tipHeight < viewportPosition.top) {

placement = originalPlacement.replace('top', 'bottom');

}

if ((originalPlacement === 'right' || originalPlacement === 'bottom-left' || originalPlacement === 'top-left') && elementPosition.right + tipWidth > viewportPosition.width) {

placement = originalPlacement === 'right' ? 'left' : placement.replace('left', 'right');

} else if ((originalPlacement === 'left' || originalPlacement === 'bottom-right' || originalPlacement === 'top-right') && elementPosition.left - tipWidth < viewportPosition.left) {

placement = originalPlacement === 'left' ? 'right' : placement.replace('right', 'left');

}

tipElement.removeClass(originalPlacement).addClass(placement);

}

var tipPosition = getCalculatedOffset(placement, elementPosition, tipWidth, tipHeight);

applyPlacement(tipPosition, placement);

};

$tooltip.$onKeyUp = function(evt) {

if (evt.which === 27 && $tooltip.$isShown) {

$tooltip.hide();

evt.stopPropagation();

}

};

$tooltip.$onFocusKeyUp = function(evt) {

if (evt.which === 27) {

element[0].blur();

evt.stopPropagation();

}

};

$tooltip.$onFocusElementMouseDown = function(evt) {

evt.preventDefault();

evt.stopPropagation();

$tooltip.$isShown ? element[0].blur() : element[0].focus();

};

function bindTriggerEvents() {

var triggers = options.trigger.split(' ');

angular.forEach(triggers, function(trigger) {

if (trigger === 'click') {

element.on('click', $tooltip.toggle);

} else if (trigger !== 'manual') {

element.on(trigger === 'hover' ? 'mouseenter' : 'focus', $tooltip.enter);

element.on(trigger === 'hover' ? 'mouseleave' : 'blur', $tooltip.leave);

nodeName === 'button' && trigger !== 'hover' && element.on(isTouch ? 'touchstart' : 'mousedown', $tooltip.$onFocusElementMouseDown);

}

});

}

function unbindTriggerEvents() {

var triggers = options.trigger.split(' ');

for (var i = triggers.length; i--; ) {

var trigger = triggers[i];

if (trigger === 'click') {

element.off('click', $tooltip.toggle);

} else if (trigger !== 'manual') {

element.off(trigger === 'hover' ? 'mouseenter' : 'focus', $tooltip.enter);

element.off(trigger === 'hover' ? 'mouseleave' : 'blur', $tooltip.leave);

nodeName === 'button' && trigger !== 'hover' && element.off(isTouch ? 'touchstart' : 'mousedown', $tooltip.$onFocusElementMouseDown);

}

}

}

function bindKeyboardEvents() {

if (options.trigger !== 'focus') {

tipElement.on('keyup', $tooltip.$onKeyUp);

} else {

element.on('keyup', $tooltip.$onFocusKeyUp);

}

}

function unbindKeyboardEvents() {

if (options.trigger !== 'focus') {

tipElement.off('keyup', $tooltip.$onKeyUp);

} else {

element.off('keyup', $tooltip.$onFocusKeyUp);

}

}

var _autoCloseEventsBinded = false;

function bindAutoCloseEvents() {

$timeout(function() {

tipElement.on('click', stopEventPropagation);

$body.on('click', $tooltip.hide);

_autoCloseEventsBinded = true;

}, 0, false);

}

function unbindAutoCloseEvents() {

if (_autoCloseEventsBinded) {

tipElement.off('click', stopEventPropagation);

$body.off('click', $tooltip.hide);

_autoCloseEventsBinded = false;

}

}

function stopEventPropagation(event) {

event.stopPropagation();

}

function getPosition($element) {

$element = $element || (options.target || element);

var el = $element[0], isBody = el.tagName === 'BODY';

var elRect = el.getBoundingClientRect();

var rect = {};

for (var p in elRect) {

rect[p] = elRect[p];

}

if (rect.width === null) {

rect = angular.extend({}, rect, {

width: elRect.right - elRect.left,

height: elRect.bottom - elRect.top

});

}

var elOffset = isBody ? {

top: 0,

left: 0

} : dimensions.offset(el), scroll = {

scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.prop('scrollTop') || 0

}, outerDims = isBody ? {

width: document.documentElement.clientWidth,

height: $window.innerHeight

} : null;

return angular.extend({}, rect, scroll, outerDims, elOffset);

}

function getCalculatedOffset(placement, position, actualWidth, actualHeight) {

var offset;

var split = placement.split('-');

switch (split[0]) {

case 'right':

offset = {

top: position.top + position.height / 2 - actualHeight / 2,

left: position.left + position.width

};

break;

case 'bottom':

offset = {

top: position.top + position.height,

left: position.left + position.width / 2 - actualWidth / 2

};

break;

case 'left':

offset = {

top: position.top + position.height / 2 - actualHeight / 2,

left: position.left - actualWidth

};

break;

default:

offset = {

top: position.top - actualHeight,

left: position.left + position.width / 2 - actualWidth / 2

};

break;

}

if (!split[1]) {

return offset;

}

if (split[0] === 'top' || split[0] === 'bottom') {

switch (split[1]) {

case 'left':

offset.left = position.left;

break;

case 'right':

offset.left = position.left + position.width - actualWidth;

}

} else if (split[0] === 'left' || split[0] === 'right') {

switch (split[1]) {

case 'top':

offset.top = position.top - actualHeight;

break;

case 'bottom':

offset.top = position.top + position.height;

}

}

return offset;

}

function applyPlacement(offset, placement) {

var tip = tipElement[0], width = tip.offsetWidth, height = tip.offsetHeight;

var marginTop = parseInt(dimensions.css(tip, 'margin-top'), 10), marginLeft = parseInt(dimensions.css(tip, 'margin-left'), 10);

if (isNaN(marginTop)) marginTop = 0;

if (isNaN(marginLeft)) marginLeft = 0;

offset.top = offset.top + marginTop;

offset.left = offset.left + marginLeft;

dimensions.setOffset(tip, angular.extend({

using: function(props) {

tipElement.css({

top: Math.round(props.top) + 'px',

left: Math.round(props.left) + 'px',

right: ''

});

}

}, offset), 0);

var actualWidth = tip.offsetWidth, actualHeight = tip.offsetHeight;

if (placement === 'top' && actualHeight !== height) {

offset.top = offset.top + height - actualHeight;

}

if (/top-left|top-right|bottom-left|bottom-right/.test(placement)) return;

var delta = getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight);

if (delta.left) {

offset.left += delta.left;

} else {

offset.top += delta.top;

}

dimensions.setOffset(tip, offset);

if (/top|right|bottom|left/.test(placement)) {

var isVertical = /top|bottom/.test(placement), arrowDelta = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight, arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight';

replaceArrow(arrowDelta, tip[arrowOffsetPosition], isVertical);

}

}

function getViewportAdjustedDelta(placement, position, actualWidth, actualHeight) {

var delta = {

top: 0,

left: 0

};

if (!$tooltip.$viewport) return delta;

var viewportPadding = options.viewport && options.viewport.padding || 0;

var viewportDimensions = getPosition($tooltip.$viewport);

if (/right|left/.test(placement)) {

var topEdgeOffset = position.top - viewportPadding - viewportDimensions.scroll;

var bottomEdgeOffset = position.top + viewportPadding - viewportDimensions.scroll + actualHeight;

if (topEdgeOffset < viewportDimensions.top) {

delta.top = viewportDimensions.top - topEdgeOffset;

} else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) {

delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset;

}

} else {

var leftEdgeOffset = position.left - viewportPadding;

var rightEdgeOffset = position.left + viewportPadding + actualWidth;

if (leftEdgeOffset < viewportDimensions.left) {

delta.left = viewportDimensions.left - leftEdgeOffset;

} else if (rightEdgeOffset > viewportDimensions.right) {

delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset;

}

}

return delta;

}

function replaceArrow(delta, dimension, isHorizontal) {

var $arrow = findElement('.tooltip-arrow, .arrow', tipElement[0]);

$arrow.css(isHorizontal ? 'left' : 'top', 50 * (1 - delta / dimension) + '%').css(isHorizontal ? 'top' : 'left', '');

}

function destroyTipElement() {

clearTimeout(timeout);

if ($tooltip.$isShown && tipElement !== null) {

if (options.autoClose) {

unbindAutoCloseEvents();

}

if (options.keyboard) {

unbindKeyboardEvents();

}

}

if (tipScope) {

tipScope.$destroy();

tipScope = null;

}

if (tipElement) {

tipElement.remove();

tipElement = $tooltip.$element = null;

}

}

return $tooltip;

}

function safeDigest(scope) {

scope.$$phase || scope.$root && scope.$root.$$phase || scope.$digest();

}

function findElement(query, element) {

return angular.element((element || document).querySelectorAll(query));

}

var fetchPromises = {};

function fetchTemplate(template) {

if (fetchPromises[template]) return fetchPromises[template];

return fetchPromises[template] = $http.get(template, {

cache: $templateCache

}).then(function(res) {

return res.data;

});

}

return TooltipFactory;

} ];

}).directive('bsTooltip', ["$window", "$location", "$sce", "$bsTooltip", "$$bsRAF", function($window, $location, $sce, $tooltip, $$rAF) {

return {

restrict: 'EAC',

scope: true,

link: function postLink(scope, element, attr, transclusion) {

var options = {

scope: scope

};

angular.forEach([ 'template', 'templateUrl', 'controller', 'controllerAs', 'contentTemplate', 'placement', 'container', 'delay', 'trigger', 'html', 'animation', 'backdropAnimation', 'type', 'customClass', 'id' ], function(key) {

if (angular.isDefined(attr[key])) options[key] = attr[key];

});

var falseValueRegExp = /^(false|0|)$/i;

angular.forEach([ 'html', 'container' ], function(key) {

if (angular.isDefined(attr[key]) && falseValueRegExp.test(attr[key])) options[key] = false;

});

var dataTarget = element.attr('data-target');

if (angular.isDefined(dataTarget)) {

if (falseValueRegExp.test(dataTarget)) options.target = false; else options.target = dataTarget;

}

if (!scope.hasOwnProperty('title')) {

scope.title = '';

}

attr.$observe('title', function(newValue) {

if (angular.isDefined(newValue) || !scope.hasOwnProperty('title')) {

var oldValue = scope.title;

scope.title = $sce.trustAsHtml(newValue);

angular.isDefined(oldValue) && $$rAF(function() {

tooltip && tooltip.$applyPlacement();

});

}

});

attr.bsTooltip && scope.$watch(attr.bsTooltip, function(newValue, oldValue) {

if (angular.isObject(newValue)) {

angular.extend(scope, newValue);

} else {

scope.title = newValue;

}

angular.isDefined(oldValue) && $$rAF(function() {

tooltip && tooltip.$applyPlacement();

});

}, true);

attr.bsShow && scope.$watch(attr.bsShow, function(newValue, oldValue) {

if (!tooltip || !angular.isDefined(newValue)) return;

if (angular.isString(newValue)) newValue = !!newValue.match(/true|,?(tooltip),?/i);

newValue === true ? tooltip.show() : tooltip.hide();

});

attr.bsEnabled && scope.$watch(attr.bsEnabled, function(newValue, oldValue) {

if (!tooltip || !angular.isDefined(newValue)) return;

if (angular.isString(newValue)) newValue = !!newValue.match(/true|1|,?(tooltip),?/i);

newValue === false ? tooltip.setEnabled(false) : tooltip.setEnabled(true);

});

attr.viewport && scope.$watch(attr.viewport, function(newValue) {

if (!tooltip || !angular.isDefined(newValue)) return;

tooltip.setViewport(newValue);

});

var tooltip = $tooltip(element, options);

scope.$on('$destroy', function() {

if (tooltip) tooltip.destroy();

options = null;

tooltip = null;

});

}

};

} ]);

angular.module('mgcrea.ngStrap.timepicker', [ 'mgcrea.ngStrap.helpers.dateParser', 'mgcrea.ngStrap.helpers.dateFormatter', 'mgcrea.ngStrap.tooltip' ]).provider('$bsTimepicker', function() {

var defaults = this.defaults = {

animation: 'am-fade',

prefixClass: 'timepicker',

placement: 'bottom-left',

templateUrl: 'timepicker/timepicker.tpl.html',

trigger: 'focus',

container: false,

keyboard: true,

html: false,

delay: 0,

useNative: true,

timeType: 'date',

timeFormat: 'shortTime',

timezone: null,

modelTimeFormat: null,

autoclose: false,

minTime: -Infinity,

maxTime: +Infinity,

length: 5,

hourStep: 1,

minuteStep: 5,

secondStep: 5,

roundDisplay: false,

iconUp: 'glyphicon glyphicon-chevron-up',

iconDown: 'glyphicon glyphicon-chevron-down',

arrowBehavior: 'pager'

};

this.$get = ["$window", "$document", "$rootScope", "$sce", "$bsDateFormatter", "$bsTooltip", "$timeout", function($window, $document, $rootScope, $sce, $dateFormatter, $tooltip, $timeout) {

var isNative = /(ip(a|o)d|iphone|android)/gi.test($window.navigator.userAgent);

var isTouch = 'createTouch' in $window.document && isNative;

if (!defaults.lang) {

defaults.lang = $dateFormatter.getDefaultLocale();

}

function timepickerFactory(element, controller, config) {

var $timepicker = $tooltip(element, angular.extend({}, defaults, config));

var parentScope = config.scope;

var options = $timepicker.$options;

var scope = $timepicker.$scope;

var lang = options.lang;

var formatDate = function(date, format, timezone) {

return $dateFormatter.formatDate(date, format, lang, timezone);

};

function floorMinutes(time) {

var coeff = 1e3 * 60 * options.minuteStep;

return new Date(Math.floor(time.getTime() / coeff) * coeff);

}

var selectedIndex = 0;

var defaultDate = options.roundDisplay ? floorMinutes(new Date()) : new Date();

var startDate = controller.$dateValue || defaultDate;

var viewDate = {

hour: startDate.getHours(),

meridian: startDate.getHours() < 12,

minute: startDate.getMinutes(),

second: startDate.getSeconds(),

millisecond: startDate.getMilliseconds()

};

var format = $dateFormatter.getDatetimeFormat(options.timeFormat, lang);

var hoursFormat = $dateFormatter.hoursFormat(format), timeSeparator = $dateFormatter.timeSeparator(format), minutesFormat = $dateFormatter.minutesFormat(format), secondsFormat = $dateFormatter.secondsFormat(format), showSeconds = $dateFormatter.showSeconds(format), showAM = $dateFormatter.showAM(format);

scope.$iconUp = options.iconUp;

scope.$iconDown = options.iconDown;

scope.$select = function(date, index) {

$timepicker.select(date, index);

};

scope.$moveIndex = function(value, index) {

$timepicker.$moveIndex(value, index);

};

scope.$switchMeridian = function(date) {

$timepicker.switchMeridian(date);

};

$timepicker.update = function(date) {

if (angular.isDate(date) && !isNaN(date.getTime())) {

$timepicker.$date = date;

angular.extend(viewDate, {

hour: date.getHours(),

minute: date.getMinutes(),

second: date.getSeconds(),

millisecond: date.getMilliseconds()

});

$timepicker.$build();

} else if (!$timepicker.$isBuilt) {

$timepicker.$build();

}

};

$timepicker.select = function(date, index, keep) {

if (!controller.$dateValue || isNaN(controller.$dateValue.getTime())) controller.$dateValue = new Date(1970, 0, 1);

if (!angular.isDate(date)) date = new Date(date);

if (index === 0) controller.$dateValue.setHours(date.getHours()); else if (index === 1) controller.$dateValue.setMinutes(date.getMinutes()); else if (index === 2) controller.$dateValue.setSeconds(date.getSeconds());

controller.$setViewValue(angular.copy(controller.$dateValue));

controller.$render();

if (options.autoclose && !keep) {

$timeout(function() {

$timepicker.hide(true);

});

}

};

$timepicker.switchMeridian = function(date) {

if (!controller.$dateValue || isNaN(controller.$dateValue.getTime())) {

return;

}

var hours = (date || controller.$dateValue).getHours();

controller.$dateValue.setHours(hours < 12 ? hours + 12 : hours - 12);

controller.$setViewValue(angular.copy(controller.$dateValue));

controller.$render();

};

$timepicker.$build = function() {

var i, midIndex = scope.midIndex = parseInt(options.length / 2, 10);

var hours = [], hour;

for (i = 0; i < options.length; i++) {

hour = new Date(1970, 0, 1, viewDate.hour - (midIndex - i) * options.hourStep);

hours.push({

date: hour,

label: formatDate(hour, hoursFormat),

selected: $timepicker.$date && $timepicker.$isSelected(hour, 0),

disabled: $timepicker.$isDisabled(hour, 0)

});

}

var minutes = [], minute;

for (i = 0; i < options.length; i++) {

minute = new Date(1970, 0, 1, 0, viewDate.minute - (midIndex - i) * options.minuteStep);

minutes.push({

date: minute,

label: formatDate(minute, minutesFormat),

selected: $timepicker.$date && $timepicker.$isSelected(minute, 1),

disabled: $timepicker.$isDisabled(minute, 1)

});

}

var seconds = [], second;

for (i = 0; i < options.length; i++) {

second = new Date(1970, 0, 1, 0, 0, viewDate.second - (midIndex - i) * options.secondStep);

seconds.push({

date: second,

label: formatDate(second, secondsFormat),

selected: $timepicker.$date && $timepicker.$isSelected(second, 2),

disabled: $timepicker.$isDisabled(second, 2)

});

}

var rows = [];

for (i = 0; i < options.length; i++) {

if (showSeconds) {

rows.push([ hours[i], minutes[i], seconds[i] ]);

} else {

rows.push([ hours[i], minutes[i] ]);

}

}

scope.rows = rows;

scope.showSeconds = showSeconds;

scope.showAM = showAM;

scope.isAM = ($timepicker.$date || hours[midIndex].date).getHours() < 12;

scope.timeSeparator = timeSeparator;

$timepicker.$isBuilt = true;

};

$timepicker.$isSelected = function(date, index) {

if (!$timepicker.$date) return false; else if (index === 0) {

return date.getHours() === $timepicker.$date.getHours();

} else if (index === 1) {

return date.getMinutes() === $timepicker.$date.getMinutes();

} else if (index === 2) {

return date.getSeconds() === $timepicker.$date.getSeconds();

}

};

$timepicker.$isDisabled = function(date, index) {

var selectedTime;

if (index === 0) {

selectedTime = date.getTime() + viewDate.minute * 6e4 + viewDate.second * 1e3;

} else if (index === 1) {

selectedTime = date.getTime() + viewDate.hour * 36e5 + viewDate.second * 1e3;

} else if (index === 2) {

selectedTime = date.getTime() + viewDate.hour * 36e5 + viewDate.minute * 6e4;

}

return selectedTime < options.minTime * 1 || selectedTime > options.maxTime * 1;

};

scope.$arrowAction = function(value, index) {

if (options.arrowBehavior === 'picker') {

$timepicker.$setTimeByStep(value, index);

} else {

$timepicker.$moveIndex(value, index);

}

};

$timepicker.$setTimeByStep = function(value, index) {

var newDate = new Date($timepicker.$date || startDate);

var hours = newDate.getHours();

var minutes = newDate.getMinutes();

var seconds = newDate.getSeconds();

if (index === 0) {

newDate.setHours(hours - parseInt(options.hourStep, 10) * value);

} else if (index === 1) {

newDate.setMinutes(minutes - parseInt(options.minuteStep, 10) * value);

} else if (index === 2) {

newDate.setSeconds(seconds - parseInt(options.secondStep, 10) * value);

}

$timepicker.select(newDate, index, true);

};

$timepicker.$moveIndex = function(value, index) {

var targetDate;

if (index === 0) {

targetDate = new Date(1970, 0, 1, viewDate.hour + value * options.length, viewDate.minute, viewDate.second);

angular.extend(viewDate, {

hour: targetDate.getHours()

});

} else if (index === 1) {

targetDate = new Date(1970, 0, 1, viewDate.hour, viewDate.minute + value * options.length * options.minuteStep, viewDate.second);

angular.extend(viewDate, {

minute: targetDate.getMinutes()

});

} else if (index === 2) {

targetDate = new Date(1970, 0, 1, viewDate.hour, viewDate.minute, viewDate.second + value * options.length * options.secondStep);

angular.extend(viewDate, {

second: targetDate.getSeconds()