/**

* angular-strap

* @version v2.2.1 - 2015-03-10

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

* @author Olivier Louvignes (olivier@mg-crea.com)

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

*/

(function(window, document, undefined) {

'use strict';

// Source: module.js

angular.module('mgcrea.ngStrap', [

'mgcrea.ngStrap.modal',

'mgcrea.ngStrap.aside',

'mgcrea.ngStrap.alert',

'mgcrea.ngStrap.button',

'mgcrea.ngStrap.select',

'mgcrea.ngStrap.datepicker',

'mgcrea.ngStrap.timepicker',

'mgcrea.ngStrap.navbar',

'mgcrea.ngStrap.tooltip',

'mgcrea.ngStrap.popover',

'mgcrea.ngStrap.dropdown',

'mgcrea.ngStrap.typeahead',

'mgcrea.ngStrap.scrollspy',

'mgcrea.ngStrap.affix',

'mgcrea.ngStrap.tab',

'mgcrea.ngStrap.collapse'

]);

// Source: affix.js

angular.module('mgcrea.ngStrap.affix', ['mgcrea.ngStrap.helpers.dimensions', 'mgcrea.ngStrap.helpers.debounce'])

.provider('$affix', function() {

var defaults = this.defaults = {

offsetTop: 'auto',

inlineStyles: true

};

this.$get = ["$window", "debounce", "dimensions", function($window, debounce, dimensions) {

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

var windowEl = angular.element($window);

function AffixFactory(element, config) {

var $affix = {};

// Common vars

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

var targetEl = options.target;

// Initial private vars

var reset = 'affix affix-top affix-bottom',

setWidth = false,

initialAffixTop = 0,

initialOffsetTop = 0,

offsetTop = 0,

offsetBottom = 0,

affixed = null,

unpin = null;

var parent = element.parent();

// Options: custom parent

if (options.offsetParent) {

if (options.offsetParent.match(/^\d+$/)) {

for (var i = 0; i < (options.offsetParent * 1) - 1; i++) {

parent = parent.parent();

}

}

else {

parent = angular.element(options.offsetParent);

}

}

$affix.init = function() {

this.$parseOffsets();

initialOffsetTop = dimensions.offset(element[0]).top + initialAffixTop;

setWidth = !element[0].style.width;

// Bind events

targetEl.on('scroll', this.checkPosition);

targetEl.on('click', this.checkPositionWithEventLoop);

windowEl.on('resize', this.$debouncedOnResize);

// Both of these checkPosition() calls are necessary for the case where

// the user hits refresh after scrolling to the bottom of the page.

this.checkPosition();

this.checkPositionWithEventLoop();

};

$affix.destroy = function() {

// Unbind events

targetEl.off('scroll', this.checkPosition);

targetEl.off('click', this.checkPositionWithEventLoop);

windowEl.off('resize', this.$debouncedOnResize);

};

$affix.checkPositionWithEventLoop = function() {

// IE 9 throws an error if we use 'this' instead of '$affix'

// in this setTimeout call

setTimeout($affix.checkPosition, 1);

};

$affix.checkPosition = function() {

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

var scrollTop = getScrollTop();

var position = dimensions.offset(element[0]);

var elementHeight = dimensions.height(element[0]);

// Get required affix class according to position

var affix = getRequiredAffixClass(unpin, position, elementHeight);

// Did affix status changed this last check?

if(affixed === affix) return;

affixed = affix;

// Add proper affix class

element.removeClass(reset).addClass('affix' + ((affix !== 'middle') ? '-' + affix : ''));

if(affix === 'top') {

unpin = null;

if(setWidth) {

element.css('width', '');

}

if (options.inlineStyles) {

element.css('position', (options.offsetParent) ? '' : 'relative');

element.css('top', '');

}

} else if(affix === 'bottom') {

if (options.offsetUnpin) {

unpin = -(options.offsetUnpin * 1);

}

else {

// Calculate unpin threshold when affixed to bottom.

// Hopefully the browser scrolls pixel by pixel.

unpin = position.top - scrollTop;

}

if(setWidth) {

element.css('width', '');

}

if (options.inlineStyles) {

element.css('position', (options.offsetParent) ? '' : 'relative');

element.css('top', (options.offsetParent) ? '' : ((bodyEl[0].offsetHeight - offsetBottom - elementHeight - initialOffsetTop) + 'px'));

}

} else { // affix === 'middle'

unpin = null;

if(setWidth) {

element.css('width', element[0].offsetWidth + 'px');

}

if (options.inlineStyles) {

element.css('position', 'fixed');

element.css('top', initialAffixTop + 'px');

}

}

};

$affix.$onResize = function() {

$affix.$parseOffsets();

$affix.checkPosition();

};

$affix.$debouncedOnResize = debounce($affix.$onResize, 50);

$affix.$parseOffsets = function() {

var initialPosition = element.css('position');

// Reset position to calculate correct offsetTop

if (options.inlineStyles){

element.css('position', (options.offsetParent) ? '' : 'relative');

}

if(options.offsetTop) {

if(options.offsetTop === 'auto') {

options.offsetTop = '+0';

}

if(options.offsetTop.match(/^[-+]\d+$/)) {

initialAffixTop = - options.offsetTop * 1;

if(options.offsetParent) {

offsetTop = dimensions.offset(parent[0]).top + (options.offsetTop * 1);

}

else {

offsetTop = dimensions.offset(element[0]).top - dimensions.css(element[0], 'marginTop', true) + (options.offsetTop * 1);

}

}

else {

offsetTop = options.offsetTop * 1;

}

}

if(options.offsetBottom) {

if(options.offsetParent && options.offsetBottom.match(/^[-+]\d+$/)) {

// add 1 pixel due to rounding problems...

offsetBottom = getScrollHeight() - (dimensions.offset(parent[0]).top + dimensions.height(parent[0])) + (options.offsetBottom * 1) + 1;

}

else {

offsetBottom = options.offsetBottom * 1;

}

}

// Bring back the element's position after calculations

if (options.inlineStyles){

element.css('position', initialPosition);

}

};

// Private methods

function getRequiredAffixClass(unpin, position, elementHeight) {

var scrollTop = getScrollTop();

var scrollHeight = getScrollHeight();

if(scrollTop <= offsetTop) {

return 'top';

} else if(unpin !== null && (scrollTop + unpin <= position.top)) {

return 'middle';

} else if(offsetBottom !== null && (position.top + elementHeight + initialAffixTop >= scrollHeight - offsetBottom)) {

return 'bottom';

} else {

return 'middle';

}

}

function getScrollTop() {

return targetEl[0] === $window ? $window.pageYOffset : targetEl[0].scrollTop;

}

function getScrollHeight() {

return targetEl[0] === $window ? $window.document.body.scrollHeight : targetEl[0].scrollHeight;

}

$affix.init();

return $affix;

}

return AffixFactory;

}];

})

.directive('bsAffix', ["$affix", "$window", function($affix, $window) {

return {

restrict: 'EAC',

require: '^?bsAffixTarget',

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

var options = {scope: scope, target: affixTarget ? affixTarget.$element : angular.element($window)};

angular.forEach(['offsetTop', 'offsetBottom', 'offsetParent', 'offsetUnpin', 'inlineStyles'], function(key) {

if(angular.isDefined(attr[key])) {

var option = attr[key];

if (/true/i.test(option)) option = true;

if (/false/i.test(option)) option = false;

options[key] = option;

}

});

var affix = $affix(element, options);

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

affix && affix.destroy();

options = null;

affix = null;

});

}

};

}])

.directive('bsAffixTarget', function() {

return {

controller: ["$element", function($element) {

this.$element = $element;

}]

};

});

// Source: aside.js

angular.module('mgcrea.ngStrap.aside', ['mgcrea.ngStrap.modal'])

.provider('$aside', function() {

var defaults = this.defaults = {

animation: 'am-fade-and-slide-right',

prefixClass: 'aside',

prefixEvent: 'aside',

placement: 'right',

template: 'aside/aside.tpl.html',

contentTemplate: false,

container: false,

element: null,

backdrop: true,

keyboard: true,

html: false,

show: true

};

this.$get = ["$modal", function($modal) {

function AsideFactory(config) {

var $aside = {};

// Common vars

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

$aside = $modal(options);

return $aside;

}

return AsideFactory;

}];

})

.directive('bsAside', ["$window", "$sce", "$aside", function($window, $sce, $aside) {

var requestAnimationFrame = $window.requestAnimationFrame || $window.setTimeout;

return {

restrict: 'EAC',

scope: true,

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

// Directive options

var options = {scope: scope, element: element, show: false};

angular.forEach(['template', 'contentTemplate', 'placement', 'backdrop', 'keyboard', 'html', 'container', 'animation'], function(key) {

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

});

// Support scope as data-attrs

angular.forEach(['title', 'content'], function(key) {

attr[key] && attr.$observe(key, function(newValue, oldValue) {

scope[key] = $sce.trustAsHtml(newValue);

});

});

// Support scope as an object

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

if(angular.isObject(newValue)) {

angular.extend(scope, newValue);

} else {

scope.content = newValue;

}

}, true);

// Initialize aside

var aside = $aside(options);

// Trigger

element.on(attr.trigger || 'click', aside.toggle);

// Garbage collection

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

if (aside) aside.destroy();

options = null;

aside = null;

});

}

};

}]);

// Source: alert.js

// @BUG: following snippet won't compile correctly

// @TODO: submit issue to core

// '<span ng-if="title"><strong ng-bind="title"></strong>&nbsp;</span><span ng-bind-html="content"></span>' +

angular.module('mgcrea.ngStrap.alert', ['mgcrea.ngStrap.modal'])

.provider('$alert', function() {

var defaults = this.defaults = {

animation: 'am-fade',

prefixClass: 'alert',

prefixEvent: 'alert',

placement: null,

template: 'alert/alert.tpl.html',

container: false,

element: null,

backdrop: false,

keyboard: true,

show: true,

// Specific options

duration: false,

type: false,

dismissable: true

};

this.$get = ["$modal", "$timeout", function($modal, $timeout) {

function AlertFactory(config) {

var $alert = {};

// Common vars

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

$alert = $modal(options);

// Support scope as string options [/*title, content, */ type, dismissable]

$alert.$scope.dismissable = !!options.dismissable;

if(options.type) {

$alert.$scope.type = options.type;

}

// Support auto-close duration

var show = $alert.show;

if(options.duration) {

$alert.show = function() {

show();

$timeout(function() {

$alert.hide();

}, options.duration * 1000);

};

}

return $alert;

}

return AlertFactory;

}];

})

.directive('bsAlert', ["$window", "$sce", "$alert", function($window, $sce, $alert) {

var requestAnimationFrame = $window.requestAnimationFrame || $window.setTimeout;

return {

restrict: 'EAC',

scope: true,

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

// Directive options

var options = {scope: scope, element: element, show: false};

angular.forEach(['template', 'placement', 'keyboard', 'html', 'container', 'animation', 'duration', 'dismissable'], function(key) {

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

});

// overwrite inherited title value when no value specified

// fix for angular 1.3.1 531a8de72c439d8ddd064874bf364c00cedabb11

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

scope.title = '';

}

// Support scope as data-attrs

angular.forEach(['title', 'content', 'type'], function(key) {

attr[key] && attr.$observe(key, function(newValue, oldValue) {

scope[key] = $sce.trustAsHtml(newValue);

});

});

// Support scope as an object

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

if(angular.isObject(newValue)) {

angular.extend(scope, newValue);

} else {

scope.content = newValue;

}

}, true);

// Initialize alert

var alert = $alert(options);

// Trigger

element.on(attr.trigger || 'click', alert.toggle);

// Garbage collection

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

if (alert) alert.destroy();

options = null;

alert = null;

});

}

};

}]);

// Source: button.js

angular.module('mgcrea.ngStrap.button', [])

.provider('$button', function() {

var defaults = this.defaults = {

activeClass:'active',

toggleEvent:'click'

};

this.$get = function() {

return {defaults: defaults};

};

})

.directive('bsCheckboxGroup', function() {

return {

restrict: 'A',

require: 'ngModel',

compile: function postLink(element, attr) {

element.attr('data-toggle', 'buttons');

element.removeAttr('ng-model');

var children = element[0].querySelectorAll('input[type="checkbox"]');

angular.forEach(children, function(child) {

var childEl = angular.element(child);

childEl.attr('bs-checkbox', '');

childEl.attr('ng-model', attr.ngModel + '.' + childEl.attr('value'));

});

}

};

})

.directive('bsCheckbox', ["$button", "$$rAF", function($button, $$rAF) {

var defaults = $button.defaults;

var constantValueRegExp = /^(true|false|\d+)$/;

return {

restrict: 'A',

require: 'ngModel',

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

var options = defaults;

// Support label > input[type="checkbox"]

var isInput = element[0].nodeName === 'INPUT';

var activeElement = isInput ? element.parent() : element;

var trueValue = angular.isDefined(attr.trueValue) ? attr.trueValue : true;

if(constantValueRegExp.test(attr.trueValue)) {

trueValue = scope.$eval(attr.trueValue);

}

var falseValue = angular.isDefined(attr.falseValue) ? attr.falseValue : false;

if(constantValueRegExp.test(attr.falseValue)) {

falseValue = scope.$eval(attr.falseValue);

}

// Parse exotic values

var hasExoticValues = typeof trueValue !== 'boolean' || typeof falseValue !== 'boolean';

if(hasExoticValues) {

controller.$parsers.push(function(viewValue) {

// console.warn('$parser', element.attr('ng-model'), 'viewValue', viewValue);

return viewValue ? trueValue : falseValue;

});

// modelValue -> $formatters -> viewValue

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

// console.warn('$formatter("%s"): modelValue=%o (%o)', element.attr('ng-model'), modelValue, typeof modelValue);

return angular.equals(modelValue, trueValue);

});

// Fix rendering for exotic values

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

controller.$render();

});

}

// model -> view

controller.$render = function () {

// console.warn('$render', element.attr('ng-model'), 'controller.$modelValue', typeof controller.$modelValue, controller.$modelValue, 'controller.$viewValue', typeof controller.$viewValue, controller.$viewValue);

var isActive = angular.equals(controller.$modelValue, trueValue);

$$rAF(function() {

if(isInput) element[0].checked = isActive;

activeElement.toggleClass(options.activeClass, isActive);

});

};

// view -> model

element.bind(options.toggleEvent, function() {

scope.$apply(function () {

// console.warn('!click', element.attr('ng-model'), 'controller.$viewValue', typeof controller.$viewValue, controller.$viewValue, 'controller.$modelValue', typeof controller.$modelValue, controller.$modelValue);

if(!isInput) {

controller.$setViewValue(!activeElement.hasClass('active'));

}

if(!hasExoticValues) {

controller.$render();

}

});

});

}

};

}])

.directive('bsRadioGroup', function() {

return {

restrict: 'A',

require: 'ngModel',

compile: function postLink(element, attr) {

element.attr('data-toggle', 'buttons');

element.removeAttr('ng-model');

var children = element[0].querySelectorAll('input[type="radio"]');

angular.forEach(children, function(child) {

angular.element(child).attr('bs-radio', '');

angular.element(child).attr('ng-model', attr.ngModel);

});

}

};

})

.directive('bsRadio', ["$button", "$$rAF", function($button, $$rAF) {

var defaults = $button.defaults;

var constantValueRegExp = /^(true|false|\d+)$/;

return {

restrict: 'A',

require: 'ngModel',

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

var options = defaults;

// Support `label > input[type="radio"]` markup

var isInput = element[0].nodeName === 'INPUT';

var activeElement = isInput ? element.parent() : element;

var value;

attr.$observe('value', function(v) {

value = constantValueRegExp.test(v) ? scope.$eval(v) : v;

controller.$render();

});

// model -> view

controller.$render = function () {

// console.warn('$render', element.attr('value'), 'controller.$modelValue', typeof controller.$modelValue, controller.$modelValue, 'controller.$viewValue', typeof controller.$viewValue, controller.$viewValue);

var isActive = angular.equals(controller.$modelValue, value);

$$rAF(function() {

if(isInput) element[0].checked = isActive;

activeElement.toggleClass(options.activeClass, isActive);

});

};

// view -> model

element.bind(options.toggleEvent, function() {

scope.$apply(function () {

// console.warn('!click', element.attr('value'), 'controller.$viewValue', typeof controller.$viewValue, controller.$viewValue, 'controller.$modelValue', typeof controller.$modelValue, controller.$modelValue);

controller.$setViewValue(value);

controller.$render();

});

});

}

};

}]);

// Source: collapse.js

angular.module('mgcrea.ngStrap.collapse', [])

.provider('$collapse', function() {

var defaults = this.defaults = {

animation: 'am-collapse',

disallowToggle: false,

activeClass: 'in',

startCollapsed: false,

allowMultiple: false

};

var controller = this.controller = function($scope, $element, $attrs) {

var self = this;

// Attributes options

self.$options = angular.copy(defaults);

angular.forEach(['animation', 'disallowToggle', 'activeClass', 'startCollapsed', 'allowMultiple'], function (key) {

if(angular.isDefined($attrs[key])) self.$options[key] = $attrs[key];

});

self.$toggles = [];

self.$targets = [];

self.$viewChangeListeners = [];

self.$registerToggle = function(element) {

self.$toggles.push(element);

};

self.$registerTarget = function(element) {

self.$targets.push(element);

};

self.$unregisterToggle = function(element) {

var index = self.$toggles.indexOf(element);

// remove toggle from $toggles array

self.$toggles.splice(index, 1);

};

self.$unregisterTarget = function(element) {

var index = self.$targets.indexOf(element);

// remove element from $targets array

self.$targets.splice(index, 1);

if (self.$options.allowMultiple) {

// remove target index from $active array values

deactivateItem(element);

}

// fix active item indexes

fixActiveItemIndexes(index);

self.$viewChangeListeners.forEach(function(fn) {

fn();

});

};

// use array to store all the currently open panels

self.$targets.$active = !self.$options.startCollapsed ? [0] : [];

self.$setActive = $scope.$setActive = function(value) {

if(angular.isArray(value)) {

self.$targets.$active = angular.copy(value);

}

else if(!self.$options.disallowToggle) {

// toogle element active status

isActive(value) ? deactivateItem(value) : activateItem(value);

} else {

activateItem(value);

}

self.$viewChangeListeners.forEach(function(fn) {

fn();

});

};

self.$activeIndexes = function() {

return self.$options.allowMultiple ? self.$targets.$active :

self.$targets.$active.length === 1 ? self.$targets.$active[0] : -1;

};

function fixActiveItemIndexes(index) {

// item with index was removed, so we

// need to adjust other items index values

var activeIndexes = self.$targets.$active;

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

if (index < activeIndexes[i]) {

activeIndexes[i] = activeIndexes[i] - 1;

}

// the last item is active, so we need to

// adjust its index

if (activeIndexes[i] === self.$targets.length) {

activeIndexes[i] = self.$targets.length - 1;

}

}

}

function isActive(value) {

var activeItems = self.$targets.$active;

return activeItems.indexOf(value) === -1 ? false : true;

}

function deactivateItem(value) {

var index = self.$targets.$active.indexOf(value);

if (index !== -1) {

self.$targets.$active.splice(index, 1);

}

}

function activateItem(value) {

if (!self.$options.allowMultiple) {

// remove current selected item

self.$targets.$active.splice(0, 1);

}

if (self.$targets.$active.indexOf(value) === -1) {

self.$targets.$active.push(value);

}

}

};

this.$get = function() {

var $collapse = {};

$collapse.defaults = defaults;

$collapse.controller = controller;

return $collapse;

};

})

.directive('bsCollapse', ["$window", "$animate", "$collapse", function($window, $animate, $collapse) {

var defaults = $collapse.defaults;

return {

require: ['?ngModel', 'bsCollapse'],

controller: ['$scope', '$element', '$attrs', $collapse.controller],

link: function postLink(scope, element, attrs, controllers) {

var ngModelCtrl = controllers[0];

var bsCollapseCtrl = controllers[1];

if(ngModelCtrl) {

// Update the modelValue following

bsCollapseCtrl.$viewChangeListeners.push(function() {

ngModelCtrl.$setViewValue(bsCollapseCtrl.$activeIndexes());

});

// modelValue -> $formatters -> viewValue

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

// console.warn('$formatter("%s"): modelValue=%o (%o)', element.attr('ng-model'), modelValue, typeof modelValue);

if (angular.isArray(modelValue)) {

// model value is an array, so just replace

// the active items directly

bsCollapseCtrl.$setActive(modelValue);

}

else {

var activeIndexes = bsCollapseCtrl.$activeIndexes();

if (angular.isArray(activeIndexes)) {

// we have an array of selected indexes

if (activeIndexes.indexOf(modelValue * 1) === -1) {

// item with modelValue index is not active

bsCollapseCtrl.$setActive(modelValue * 1);

}

}

else if (activeIndexes !== modelValue * 1) {

bsCollapseCtrl.$setActive(modelValue * 1);

}

}

return modelValue;

});

}

}

};

}])

.directive('bsCollapseToggle', function() {

return {

require: ['^?ngModel', '^bsCollapse'],

link: function postLink(scope, element, attrs, controllers) {

var ngModelCtrl = controllers[0];

var bsCollapseCtrl = controllers[1];

// Add base attr

element.attr('data-toggle', 'collapse');

// Push pane to parent bsCollapse controller

bsCollapseCtrl.$registerToggle(element);

// remove toggle from collapse controller when toggle is destroyed

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

bsCollapseCtrl.$unregisterToggle(element);

});

element.on('click', function() {

var index = attrs.bsCollapseToggle || bsCollapseCtrl.$toggles.indexOf(element);

bsCollapseCtrl.$setActive(index * 1);

scope.$apply();

});

}

};

})

.directive('bsCollapseTarget', ["$animate", function($animate) {

return {

require: ['^?ngModel', '^bsCollapse'],

// scope: true,

link: function postLink(scope, element, attrs, controllers) {

var ngModelCtrl = controllers[0];

var bsCollapseCtrl = controllers[1];

// Add base class

element.addClass('collapse');

// Add animation class

if(bsCollapseCtrl.$options.animation) {

element.addClass(bsCollapseCtrl.$options.animation);

}

// Push pane to parent bsCollapse controller

bsCollapseCtrl.$registerTarget(element);

// remove pane target from collapse controller when target is destroyed

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

bsCollapseCtrl.$unregisterTarget(element);

});

function render() {

var index = bsCollapseCtrl.$targets.indexOf(element);

var active = bsCollapseCtrl.$activeIndexes();

var action = 'removeClass';

if (angular.isArray(active)) {

if (active.indexOf(index) !== -1) {

action = 'addClass';

}

}

else if (index === active) {

action = 'addClass';

}

$animate[action](element, bsCollapseCtrl.$options.activeClass);

}

bsCollapseCtrl.$viewChangeListeners.push(function() {

render();

});

render();

}

};

}]);

// Source: datepicker.js

angular.module('mgcrea.ngStrap.datepicker', [

'mgcrea.ngStrap.helpers.dateParser',

'mgcrea.ngStrap.helpers.dateFormatter',

'mgcrea.ngStrap.tooltip'])

.provider('$datepicker', function() {

var defaults = this.defaults = {

animation: 'am-fade',

prefixClass: 'datepicker',

placement: 'bottom-left',

template: 'datepicker/datepicker.tpl.html',

trigger: 'focus',

container: false,

keyboard: true,

html: false,

delay: 0,

// lang: $locale.id,

useNative: false,

dateType: 'date',

dateFormat: 'shortDate',

timezone: null,

modelDateFormat: null,

dayFormat: 'dd',

monthFormat: 'MMM',

yearFormat: 'yyyy',

monthTitleFormat: 'MMMM yyyy',

yearTitleFormat: 'yyyy',

strictFormat: false,

autoclose: false,

minDate: -Infinity,

maxDate: +Infinity,

startView: 0,

minView: 0,

startWeek: 0,

daysOfWeekDisabled: '',

iconLeft: 'glyphicon glyphicon-chevron-left',

iconRight: 'glyphicon glyphicon-chevron-right'

};

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

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

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

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

if(!defaults.lang) defaults.lang = $dateFormatter.getDefaultLocale();

function DatepickerFactory(element, controller, config) {

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

var parentScope = config.scope;

var options = $datepicker.$options;

var scope = $datepicker.$scope;

if(options.startView) options.startView -= options.minView;

// View vars

var pickerViews = datepickerViews($datepicker);

$datepicker.$views = pickerViews.views;

var viewDate = pickerViews.viewDate;

scope.$mode = options.startView;

scope.$iconLeft = options.iconLeft;

scope.$iconRight = options.iconRight;

var $picker = $datepicker.$views[scope.$mode];