ngx-bootstrap 3.0.1 → 3.1.4

package/datepicker/fesm5/ngx-bootstrap-datepicker.js

@@ -0,0 +1,4198 @@
+import { Injectable, Component, EventEmitter, Directive, ElementRef, Input, Output, Renderer2, ViewContainerRef, ChangeDetectorRef, forwardRef, Host, ChangeDetectionStrategy, NgModule, ViewChild } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { __extends, __values, __spread } from 'tslib';
+import { filter, map } from 'rxjs/operators';
+import { getFullYear, getMonth, getDay, isFirstDayOfWeek, isAfter, isBefore, shiftDate, endOf, startOf, getFirstDayOfMonth, formatDate, getLocale, isDisabledDay, isSameDay, isSameMonth, isSameYear, setFullDate, isArray, isDateValid, parseDate, isDate } from 'ngx-bootstrap/chronos';
+import { MiniStore, MiniState } from 'ngx-bootstrap/mini-ngrx';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { PositioningService } from 'ngx-bootstrap/positioning';
+import { isBs3 } from 'ngx-bootstrap/utils';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * For date range picker there are `BsDaterangepickerConfig` which inherits all properties,
+ * except `displayMonths`, for range picker it default to `2`
+ */
+var BsDatepickerConfig = /** @class */ (function () {
+    function BsDatepickerConfig() {
+        /**
+         * CSS class which will be applied to datepicker container,
+         * usually used to set color theme
+         */
+        this.containerClass = 'theme-green';
+        // DatepickerRenderOptions
+        this.displayMonths = 1;
+        /**
+         * Allows to hide week numbers in datepicker
+         */
+        this.showWeekNumbers = true;
+        this.dateInputFormat = 'L';
+        // range picker
+        this.rangeSeparator = ' - ';
+        /**
+         * Date format for date range input field
+         */
+        this.rangeInputFormat = 'L';
+        // DatepickerFormatOptions
+        this.monthTitle = 'MMMM';
+        this.yearTitle = 'YYYY';
+        this.dayLabel = 'D';
+        this.monthLabel = 'MMMM';
+        this.yearLabel = 'YYYY';
+        this.weekNumbers = 'w';
+    }
+    BsDatepickerConfig.decorators = [
+        { type: Injectable }
+    ];
+    return BsDatepickerConfig;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @abstract
+ */
+var  /**
+ * @abstract
+ */
+BsDatepickerAbstractComponent = /** @class */ (function () {
+    function BsDatepickerAbstractComponent() {
+        this._customRangesFish = [];
+    }
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "minDate", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setMinDate(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "maxDate", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setMaxDate(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "daysDisabled", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setDaysDisabled(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerAbstractComponent.prototype, "isDisabled", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setDisabled(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.setViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.dayHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.monthHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.yearHoverHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} day
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.daySelectHandler = /**
+     * @param {?} day
+     * @return {?}
+     */
+    function (day) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.monthSelectHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype.yearSelectHandler = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) { };
+    /* tslint:disable-next-line: no-any */
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerAbstractComponent.prototype._stopPropagation = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        event.stopPropagation();
+    };
+    return BsDatepickerAbstractComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerActions = /** @class */ (function () {
+    function BsDatepickerActions() {
+    }
+    /**
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.calculate = /**
+     * @return {?}
+     */
+    function () {
+        return { type: BsDatepickerActions.CALCULATE };
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.format = /**
+     * @return {?}
+     */
+    function () {
+        return { type: BsDatepickerActions.FORMAT };
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.flag = /**
+     * @return {?}
+     */
+    function () {
+        return { type: BsDatepickerActions.FLAG };
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.select = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        return {
+            type: BsDatepickerActions.SELECT,
+            payload: date
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.changeViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: BsDatepickerActions.CHANGE_VIEWMODE,
+            payload: event
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: BsDatepickerActions.NAVIGATE_TO,
+            payload: event
+        };
+    };
+    /**
+     * @param {?} step
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.navigateStep = /**
+     * @param {?} step
+     * @return {?}
+     */
+    function (step) {
+        return {
+            type: BsDatepickerActions.NAVIGATE_OFFSET,
+            payload: step
+        };
+    };
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.setOptions = /**
+     * @param {?} options
+     * @return {?}
+     */
+    function (options) {
+        return {
+            type: BsDatepickerActions.SET_OPTIONS,
+            payload: options
+        };
+    };
+    // date range picker
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.selectRange = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return {
+            type: BsDatepickerActions.SELECT_RANGE,
+            payload: value
+        };
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.hoverDay = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        return {
+            type: BsDatepickerActions.HOVER,
+            payload: event.isHovered ? event.cell.date : null
+        };
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.minDate = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        return {
+            type: BsDatepickerActions.SET_MIN_DATE,
+            payload: date
+        };
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.maxDate = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        return {
+            type: BsDatepickerActions.SET_MAX_DATE,
+            payload: date
+        };
+    };
+    /**
+     * @param {?} days
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.daysDisabled = /**
+     * @param {?} days
+     * @return {?}
+     */
+    function (days) {
+        return {
+            type: BsDatepickerActions.SET_DAYSDISABLED,
+            payload: days
+        };
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.isDisabled = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return {
+            type: BsDatepickerActions.SET_IS_DISABLED,
+            payload: value
+        };
+    };
+    /**
+     * @param {?} locale
+     * @return {?}
+     */
+    BsDatepickerActions.prototype.setLocale = /**
+     * @param {?} locale
+     * @return {?}
+     */
+    function (locale) {
+        return {
+            type: BsDatepickerActions.SET_LOCALE,
+            payload: locale
+        };
+    };
+    BsDatepickerActions.CALCULATE = '[datepicker] calculate dates matrix';
+    BsDatepickerActions.FORMAT = '[datepicker] format datepicker values';
+    BsDatepickerActions.FLAG = '[datepicker] set flags';
+    BsDatepickerActions.SELECT = '[datepicker] select date';
+    BsDatepickerActions.NAVIGATE_OFFSET = '[datepicker] shift view date';
+    BsDatepickerActions.NAVIGATE_TO = '[datepicker] change view date';
+    BsDatepickerActions.SET_OPTIONS = '[datepicker] update render options';
+    BsDatepickerActions.HOVER = '[datepicker] hover date';
+    BsDatepickerActions.CHANGE_VIEWMODE = '[datepicker] switch view mode';
+    BsDatepickerActions.SET_MIN_DATE = '[datepicker] set min date';
+    BsDatepickerActions.SET_MAX_DATE = '[datepicker] set max date';
+    BsDatepickerActions.SET_DAYSDISABLED = '[datepicker] set days disabled';
+    BsDatepickerActions.SET_IS_DISABLED = '[datepicker] set is disabled';
+    BsDatepickerActions.SET_LOCALE = '[datepicker] set datepicker locale';
+    BsDatepickerActions.SELECT_RANGE = '[daterangepicker] select dates range';
+    BsDatepickerActions.decorators = [
+        { type: Injectable }
+    ];
+    return BsDatepickerActions;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsLocaleService = /** @class */ (function () {
+    function BsLocaleService() {
+        this._defaultLocale = 'en';
+        this._locale = new BehaviorSubject(this._defaultLocale);
+        this._localeChange = this._locale.asObservable();
+    }
+    Object.defineProperty(BsLocaleService.prototype, "locale", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._locale;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsLocaleService.prototype, "localeChange", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._localeChange;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsLocaleService.prototype, "currentLocale", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._locale.getValue();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} locale
+     * @return {?}
+     */
+    BsLocaleService.prototype.use = /**
+     * @param {?} locale
+     * @return {?}
+     */
+    function (locale) {
+        if (locale === this.currentLocale) {
+            return;
+        }
+        this._locale.next(locale);
+    };
+    BsLocaleService.decorators = [
+        { type: Injectable }
+    ];
+    return BsLocaleService;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerEffects = /** @class */ (function () {
+    function BsDatepickerEffects(_actions, _localeService) {
+        this._actions = _actions;
+        this._localeService = _localeService;
+        this._subs = [];
+    }
+    /**
+     * @param {?} _bsDatepickerStore
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.init = /**
+     * @param {?} _bsDatepickerStore
+     * @return {?}
+     */
+    function (_bsDatepickerStore) {
+        this._store = _bsDatepickerStore;
+        return this;
+    };
+    /** setters */
+    /**
+     * setters
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setValue = /**
+     * setters
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.select(value));
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setRangeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.selectRange(value));
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setMinDate = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.minDate(value));
+        return this;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setMaxDate = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.maxDate(value));
+        return this;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setDaysDisabled = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.daysDisabled(value));
+        return this;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setDisabled = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this._store.dispatch(this._actions.isDisabled(value));
+        return this;
+    };
+    /* Set rendering options */
+    /**
+     * @param {?} _config
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setOptions = /**
+     * @param {?} _config
+     * @return {?}
+     */
+    function (_config) {
+        var /** @type {?} */ _options = Object.assign({ locale: this._localeService.currentLocale }, _config);
+        this._store.dispatch(this._actions.setOptions(_options));
+        return this;
+    };
+    /** view to mode bindings */
+    /**
+     * view to mode bindings
+     * @param {?} container
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setBindings = /**
+     * view to mode bindings
+     * @param {?} container
+     * @return {?}
+     */
+    function (container) {
+        container.daysCalendar = this._store
+            .select(function (state) { return state.flaggedMonths; })
+            .pipe(filter(function (months) { return !!months; }));
+        // month calendar
+        container.monthsCalendar = this._store
+            .select(function (state) { return state.flaggedMonthsCalendar; })
+            .pipe(filter(function (months) { return !!months; }));
+        // year calendar
+        container.yearsCalendar = this._store
+            .select(function (state) { return state.yearsCalendarFlagged; })
+            .pipe(filter(function (years) { return !!years; }));
+        container.viewMode = this._store.select(function (state) { return state.view.mode; });
+        container.options = this._store
+            .select(function (state) { return state.showWeekNumbers; })
+            .pipe(map(function (showWeekNumbers) { return ({ showWeekNumbers: showWeekNumbers }); }));
+        return this;
+    };
+    /** event handlers */
+    /**
+     * event handlers
+     * @param {?} container
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.setEventHandlers = /**
+     * event handlers
+     * @param {?} container
+     * @return {?}
+     */
+    function (container) {
+        var _this = this;
+        container.setViewMode = function (event) {
+            _this._store.dispatch(_this._actions.changeViewMode(event));
+        };
+        container.navigateTo = function (event) {
+            _this._store.dispatch(_this._actions.navigateStep(event.step));
+        };
+        container.dayHoverHandler = function (event) {
+            var /** @type {?} */ _cell = /** @type {?} */ (event.cell);
+            if (_cell.isOtherMonth || _cell.isDisabled) {
+                return;
+            }
+            _this._store.dispatch(_this._actions.hoverDay(event));
+            _cell.isHovered = event.isHovered;
+        };
+        container.monthHoverHandler = function (event) {
+            event.cell.isHovered = event.isHovered;
+        };
+        container.yearHoverHandler = function (event) {
+            event.cell.isHovered = event.isHovered;
+        };
+        container.monthSelectHandler = function (event) {
+            if (event.isDisabled) {
+                return;
+            }
+            _this._store.dispatch(_this._actions.navigateTo({
+                unit: {
+                    month: getMonth(event.date),
+                    year: getFullYear(event.date)
+                },
+                viewMode: 'day'
+            }));
+        };
+        container.yearSelectHandler = function (event) {
+            if (event.isDisabled) {
+                return;
+            }
+            _this._store.dispatch(_this._actions.navigateTo({
+                unit: {
+                    year: getFullYear(event.date)
+                },
+                viewMode: 'month'
+            }));
+        };
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.registerDatepickerSideEffects = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this._subs.push(this._store.select(function (state) { return state.view; }).subscribe(function (view) {
+            _this._store.dispatch(_this._actions.calculate());
+        }));
+        // format calendar values on month model change
+        this._subs.push(this._store
+            .select(function (state) { return state.monthsModel; })
+            .pipe(filter(function (monthModel) { return !!monthModel; }))
+            .subscribe(function (month) { return _this._store.dispatch(_this._actions.format()); }));
+        // flag day values
+        this._subs.push(this._store
+            .select(function (state) { return state.formattedMonths; })
+            .pipe(filter(function (month) { return !!month; }))
+            .subscribe(function (month) { return _this._store.dispatch(_this._actions.flag()); }));
+        // flag day values
+        this._subs.push(this._store
+            .select(function (state) { return state.selectedDate; })
+            .pipe(filter(function (selectedDate) { return !!selectedDate; }))
+            .subscribe(function (selectedDate) { return _this._store.dispatch(_this._actions.flag()); }));
+        // flag for date range picker
+        this._subs.push(this._store
+            .select(function (state) { return state.selectedRange; })
+            .pipe(filter(function (selectedRange) { return !!selectedRange; }))
+            .subscribe(function (selectedRange) { return _this._store.dispatch(_this._actions.flag()); }));
+        // monthsCalendar
+        this._subs.push(this._store
+            .select(function (state) { return state.monthsCalendar; })
+            .subscribe(function () { return _this._store.dispatch(_this._actions.flag()); }));
+        // years calendar
+        this._subs.push(this._store
+            .select(function (state) { return state.yearsCalendarModel; })
+            .pipe(filter(function (state) { return !!state; }))
+            .subscribe(function () { return _this._store.dispatch(_this._actions.flag()); }));
+        // on hover
+        this._subs.push(this._store
+            .select(function (state) { return state.hoveredDate; })
+            .pipe(filter(function (hoveredDate) { return !!hoveredDate; }))
+            .subscribe(function (hoveredDate) { return _this._store.dispatch(_this._actions.flag()); }));
+        // on locale change
+        this._subs.push(this._localeService.localeChange
+            .subscribe(function (locale) { return _this._store.dispatch(_this._actions.setLocale(locale)); }));
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerEffects.prototype.destroy = /**
+     * @return {?}
+     */
+    function () {
+        try {
+            for (var _a = __values(this._subs), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _c;
+    };
+    BsDatepickerEffects.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    BsDatepickerEffects.ctorParameters = function () { return [
+        { type: BsDatepickerActions, },
+        { type: BsLocaleService, },
+    ]; };
+    return BsDatepickerEffects;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ defaultMonthOptions = {
+    width: 7,
+    height: 6
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ _initialView = { date: new Date(), mode: 'day' };
+var /** @type {?} */ initialDatepickerState = Object.assign(new BsDatepickerConfig(), {
+    locale: 'en',
+    view: _initialView,
+    selectedRange: [],
+    monthViewOptions: defaultMonthOptions
+});
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} date
+ * @param {?} options
+ * @return {?}
+ */
+function getStartingDayOfCalendar(date, options) {
+    if (isFirstDayOfWeek(date, options.firstDayOfWeek)) {
+        return date;
+    }
+    var /** @type {?} */ weekDay = getDay(date);
+    var /** @type {?} */ offset = calculateDateOffset(weekDay, options.firstDayOfWeek);
+    return shiftDate(date, { day: -offset });
+}
+/**
+ * @param {?} weekday
+ * @param {?} startingDayOffset
+ * @return {?}
+ */
+function calculateDateOffset(weekday, startingDayOffset) {
+    if (startingDayOffset === 0) {
+        return weekday;
+    }
+    var /** @type {?} */ offset = weekday - startingDayOffset % 7;
+    return offset < 0 ? offset + 7 : offset;
+}
+/**
+ * @param {?} date
+ * @param {?} min
+ * @param {?} max
+ * @return {?}
+ */
+function isMonthDisabled(date, min, max) {
+    var /** @type {?} */ minBound = min && isBefore(endOf(date, 'month'), min, 'day');
+    var /** @type {?} */ maxBound = max && isAfter(startOf(date, 'month'), max, 'day');
+    return minBound || maxBound;
+}
+/**
+ * @param {?} date
+ * @param {?} min
+ * @param {?} max
+ * @return {?}
+ */
+function isYearDisabled(date, min, max) {
+    var /** @type {?} */ minBound = min && isBefore(endOf(date, 'year'), min, 'day');
+    var /** @type {?} */ maxBound = max && isAfter(startOf(date, 'year'), max, 'day');
+    return minBound || maxBound;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @template T
+ * @param {?} options
+ * @param {?} fn
+ * @return {?}
+ */
+function createMatrix(options, fn) {
+    var /** @type {?} */ prevValue = options.initialDate;
+    var /** @type {?} */ matrix = new Array(options.height);
+    for (var /** @type {?} */ i = 0; i < options.height; i++) {
+        matrix[i] = new Array(options.width);
+        for (var /** @type {?} */ j = 0; j < options.width; j++) {
+            matrix[i][j] = fn(prevValue);
+            prevValue = shiftDate(prevValue, options.shift);
+        }
+    }
+    return matrix;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} startingDate
+ * @param {?} options
+ * @return {?}
+ */
+function calcDaysCalendar(startingDate, options) {
+    var /** @type {?} */ firstDay = getFirstDayOfMonth(startingDate);
+    var /** @type {?} */ initialDate = getStartingDayOfCalendar(firstDay, options);
+    var /** @type {?} */ matrixOptions = {
+        width: options.width,
+        height: options.height,
+        initialDate: initialDate,
+        shift: { day: 1 }
+    };
+    var /** @type {?} */ daysMatrix = createMatrix(matrixOptions, function (date) { return date; });
+    return {
+        daysMatrix: daysMatrix,
+        month: firstDay
+    };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} daysCalendar
+ * @param {?} formatOptions
+ * @param {?} monthIndex
+ * @return {?}
+ */
+function formatDaysCalendar(daysCalendar, formatOptions, monthIndex) {
+    return {
+        month: daysCalendar.month,
+        monthTitle: formatDate(daysCalendar.month, formatOptions.monthTitle, formatOptions.locale),
+        yearTitle: formatDate(daysCalendar.month, formatOptions.yearTitle, formatOptions.locale),
+        weekNumbers: getWeekNumbers(daysCalendar.daysMatrix, formatOptions.weekNumbers, formatOptions.locale),
+        weekdays: getShiftedWeekdays(formatOptions.locale),
+        weeks: daysCalendar.daysMatrix.map(function (week, weekIndex) {
+            return ({
+                days: week.map(function (date, dayIndex) {
+                    return ({
+                        date: date,
+                        label: formatDate(date, formatOptions.dayLabel, formatOptions.locale),
+                        monthIndex: monthIndex,
+                        weekIndex: weekIndex,
+                        dayIndex: dayIndex
+                    });
+                })
+            });
+        })
+    };
+}
+/**
+ * @param {?} daysMatrix
+ * @param {?} format
+ * @param {?} locale
+ * @return {?}
+ */
+function getWeekNumbers(daysMatrix, format, locale) {
+    return daysMatrix.map(function (days) { return (days[0] ? formatDate(days[0], format, locale) : ''); });
+}
+/**
+ * @param {?} locale
+ * @return {?}
+ */
+function getShiftedWeekdays(locale) {
+    var /** @type {?} */ _locale = getLocale(locale);
+    var /** @type {?} */ weekdays = /** @type {?} */ (_locale.weekdaysShort());
+    var /** @type {?} */ firstDayOfWeek = _locale.firstDayOfWeek();
+    return __spread(weekdays.slice(firstDayOfWeek), weekdays.slice(0, firstDayOfWeek));
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} formattedMonth
+ * @param {?} options
+ * @return {?}
+ */
+function flagDaysCalendar(formattedMonth, options) {
+    formattedMonth.weeks.forEach(function (week) {
+        /* tslint:disable-next-line: cyclomatic-complexity */
+        week.days.forEach(function (day, dayIndex) {
+            // datepicker
+            var /** @type {?} */ isOtherMonth = !isSameMonth(day.date, formattedMonth.month);
+            var /** @type {?} */ isHovered = !isOtherMonth && isSameDay(day.date, options.hoveredDate);
+            // date range picker
+            var /** @type {?} */ isSelectionStart = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[0]);
+            var /** @type {?} */ isSelectionEnd = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[1]);
+            var /** @type {?} */ isSelected = (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||
+                isSelectionStart ||
+                isSelectionEnd;
+            var /** @type {?} */ isInRange = !isOtherMonth &&
+                options.selectedRange &&
+                isDateInRange(day.date, options.selectedRange, options.hoveredDate);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isBefore(day.date, options.minDate, 'day') ||
+                isAfter(day.date, options.maxDate, 'day') ||
+                isDisabledDay(day.date, options.daysDisabled);
+            var /** @type {?} */ currentDate = new Date();
+            var /** @type {?} */ isToday = !isOtherMonth && isSameDay(day.date, currentDate);
+            // decide update or not
+            var /** @type {?} */ newDay = Object.assign({}, day, {
+                isOtherMonth: isOtherMonth,
+                isHovered: isHovered,
+                isSelected: isSelected,
+                isSelectionStart: isSelectionStart,
+                isSelectionEnd: isSelectionEnd,
+                isInRange: isInRange,
+                isDisabled: isDisabled,
+                isToday: isToday
+            });
+            if (day.isOtherMonth !== newDay.isOtherMonth ||
+                day.isHovered !== newDay.isHovered ||
+                day.isSelected !== newDay.isSelected ||
+                day.isSelectionStart !== newDay.isSelectionStart ||
+                day.isSelectionEnd !== newDay.isSelectionEnd ||
+                day.isDisabled !== newDay.isDisabled ||
+                day.isInRange !== newDay.isInRange) {
+                week.days[dayIndex] = newDay;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    formattedMonth.hideLeftArrow =
+        options.isDisabled ||
+            (options.monthIndex > 0 && options.monthIndex !== options.displayMonths);
+    formattedMonth.hideRightArrow =
+        options.isDisabled ||
+            (options.monthIndex < options.displayMonths &&
+                options.monthIndex + 1 !== options.displayMonths);
+    formattedMonth.disableLeftArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: -1 }), options.minDate, options.maxDate);
+    formattedMonth.disableRightArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: 1 }), options.minDate, options.maxDate);
+    return formattedMonth;
+}
+/**
+ * @param {?} date
+ * @param {?} selectedRange
+ * @param {?} hoveredDate
+ * @return {?}
+ */
+function isDateInRange(date, selectedRange, hoveredDate) {
+    if (!date || !selectedRange[0]) {
+        return false;
+    }
+    if (selectedRange[1]) {
+        return date > selectedRange[0] && date <= selectedRange[1];
+    }
+    if (hoveredDate) {
+        return date > selectedRange[0] && date <= hoveredDate;
+    }
+    return false;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} mode
+ * @param {?=} minMode
+ * @return {?}
+ */
+function canSwitchMode(mode, minMode) {
+    return minMode ? mode >= minMode : true;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ height = 4;
+var /** @type {?} */ width = 3;
+var /** @type {?} */ shift = { month: 1 };
+/**
+ * @param {?} viewDate
+ * @param {?} formatOptions
+ * @return {?}
+ */
+function formatMonthsCalendar(viewDate, formatOptions) {
+    var /** @type {?} */ initialDate = startOf(viewDate, 'year');
+    var /** @type {?} */ matrixOptions = { width: width, height: height, initialDate: initialDate, shift: shift };
+    var /** @type {?} */ monthMatrix = createMatrix(matrixOptions, function (date) {
+        return ({
+            date: date,
+            label: formatDate(date, formatOptions.monthLabel, formatOptions.locale)
+        });
+    });
+    return {
+        months: monthMatrix,
+        monthTitle: '',
+        yearTitle: formatDate(viewDate, formatOptions.yearTitle, formatOptions.locale)
+    };
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} monthCalendar
+ * @param {?} options
+ * @return {?}
+ */
+function flagMonthsCalendar(monthCalendar, options) {
+    monthCalendar.months.forEach(function (months, rowIndex) {
+        months.forEach(function (month, monthIndex) {
+            var /** @type {?} */ isHovered = isSameMonth(month.date, options.hoveredMonth);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isMonthDisabled(month.date, options.minDate, options.maxDate);
+            var /** @type {?} */ newMonth = Object.assign(/*{},*/ month, {
+                isHovered: isHovered,
+                isDisabled: isDisabled
+            });
+            if (month.isHovered !== newMonth.isHovered ||
+                month.isDisabled !== newMonth.isDisabled) {
+                monthCalendar.months[rowIndex][monthIndex] = newMonth;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    monthCalendar.hideLeftArrow =
+        options.monthIndex > 0 && options.monthIndex !== options.displayMonths;
+    monthCalendar.hideRightArrow =
+        options.monthIndex < options.displayMonths &&
+            options.monthIndex + 1 !== options.displayMonths;
+    monthCalendar.disableLeftArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: -1 }), options.minDate, options.maxDate);
+    monthCalendar.disableRightArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: 1 }), options.minDate, options.maxDate);
+    return monthCalendar;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ height$1 = 4;
+var /** @type {?} */ width$1 = 4;
+var /** @type {?} */ yearsPerCalendar = height$1 * width$1;
+var /** @type {?} */ initialShift = (Math.floor(yearsPerCalendar / 2) - 1) * -1;
+var /** @type {?} */ shift$1 = { year: 1 };
+/**
+ * @param {?} viewDate
+ * @param {?} formatOptions
+ * @return {?}
+ */
+function formatYearsCalendar(viewDate, formatOptions) {
+    var /** @type {?} */ initialDate = shiftDate(viewDate, { year: initialShift });
+    var /** @type {?} */ matrixOptions = { width: width$1, height: height$1, initialDate: initialDate, shift: shift$1 };
+    var /** @type {?} */ yearsMatrix = createMatrix(matrixOptions, function (date) {
+        return ({
+            date: date,
+            label: formatDate(date, formatOptions.yearLabel, formatOptions.locale)
+        });
+    });
+    var /** @type {?} */ yearTitle = formatYearRangeTitle(yearsMatrix, formatOptions);
+    return {
+        years: yearsMatrix,
+        monthTitle: '',
+        yearTitle: yearTitle
+    };
+}
+/**
+ * @param {?} yearsMatrix
+ * @param {?} formatOptions
+ * @return {?}
+ */
+function formatYearRangeTitle(yearsMatrix, formatOptions) {
+    var /** @type {?} */ from = formatDate(yearsMatrix[0][0].date, formatOptions.yearTitle, formatOptions.locale);
+    var /** @type {?} */ to = formatDate(yearsMatrix[height$1 - 1][width$1 - 1].date, formatOptions.yearTitle, formatOptions.locale);
+    return from + " - " + to;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?} yearsCalendar
+ * @param {?} options
+ * @return {?}
+ */
+function flagYearsCalendar(yearsCalendar, options) {
+    yearsCalendar.years.forEach(function (years, rowIndex) {
+        years.forEach(function (year, yearIndex) {
+            var /** @type {?} */ isHovered = isSameYear(year.date, options.hoveredYear);
+            var /** @type {?} */ isDisabled = options.isDisabled ||
+                isYearDisabled(year.date, options.minDate, options.maxDate);
+            var /** @type {?} */ newMonth = Object.assign(/*{},*/ year, { isHovered: isHovered, isDisabled: isDisabled });
+            if (year.isHovered !== newMonth.isHovered ||
+                year.isDisabled !== newMonth.isDisabled) {
+                yearsCalendar.years[rowIndex][yearIndex] = newMonth;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    yearsCalendar.hideLeftArrow =
+        options.yearIndex > 0 && options.yearIndex !== options.displayMonths;
+    yearsCalendar.hideRightArrow =
+        options.yearIndex < options.displayMonths &&
+            options.yearIndex + 1 !== options.displayMonths;
+    yearsCalendar.disableLeftArrow = isYearDisabled(shiftDate(yearsCalendar.years[0][0].date, { year: -1 }), options.minDate, options.maxDate);
+    var /** @type {?} */ i = yearsCalendar.years.length - 1;
+    var /** @type {?} */ j = yearsCalendar.years[i].length - 1;
+    yearsCalendar.disableRightArrow = isYearDisabled(shiftDate(yearsCalendar.years[i][j].date, { year: 1 }), options.minDate, options.maxDate);
+    return yearsCalendar;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @param {?=} state
+ * @param {?=} action
+ * @return {?}
+ */
+function bsDatepickerReducer(state, action) {
+    if (state === void 0) { state = initialDatepickerState; }
+    switch (action.type) {
+        case BsDatepickerActions.CALCULATE: {
+            return calculateReducer(state);
+        }
+        case BsDatepickerActions.FORMAT: {
+            return formatReducer(state, action);
+        }
+        case BsDatepickerActions.FLAG: {
+            return flagReducer(state, action);
+        }
+        case BsDatepickerActions.NAVIGATE_OFFSET: {
+            var /** @type {?} */ date = shiftDate(startOf(state.view.date, 'month'), action.payload);
+            var /** @type {?} */ newState = {
+                view: {
+                    mode: state.view.mode,
+                    date: date
+                }
+            };
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.NAVIGATE_TO: {
+            var /** @type {?} */ payload = action.payload;
+            var /** @type {?} */ date = setFullDate(state.view.date, payload.unit);
+            var /** @type {?} */ newState = void 0;
+            var /** @type {?} */ mode = void 0;
+            if (canSwitchMode(payload.viewMode, state.minMode)) {
+                mode = payload.viewMode;
+                newState = { view: { date: date, mode: mode } };
+            }
+            else {
+                mode = state.view.mode;
+                newState = { selectedDate: date, view: { date: date, mode: mode } };
+            }
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.CHANGE_VIEWMODE: {
+            if (!canSwitchMode(action.payload, state.minMode)) {
+                return state;
+            }
+            var /** @type {?} */ date = state.view.date;
+            var /** @type {?} */ mode = action.payload;
+            var /** @type {?} */ newState = { view: { date: date, mode: mode } };
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.HOVER: {
+            return Object.assign({}, state, { hoveredDate: action.payload });
+        }
+        case BsDatepickerActions.SELECT: {
+            var /** @type {?} */ newState = {
+                selectedDate: action.payload,
+                view: state.view
+            };
+            var /** @type {?} */ mode = state.view.mode;
+            var /** @type {?} */ _date = action.payload || state.view.date;
+            var /** @type {?} */ date = getViewDate(_date, state.minDate, state.maxDate);
+            newState.view = { mode: mode, date: date };
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.SET_OPTIONS: {
+            var /** @type {?} */ newState = action.payload;
+            // preserve view mode
+            var /** @type {?} */ mode = newState.minMode ? newState.minMode : state.view.mode;
+            var /** @type {?} */ _viewDate = isDateValid(newState.value) && newState.value
+                || isArray(newState.value) && isDateValid(newState.value[0]) && newState.value[0]
+                || state.view.date;
+            var /** @type {?} */ date = getViewDate(_viewDate, newState.minDate, newState.maxDate);
+            newState.view = { mode: mode, date: date };
+            // update selected value
+            if (newState.value) {
+                // if new value is array we work with date range
+                if (isArray(newState.value)) {
+                    newState.selectedRange = newState.value;
+                }
+                // if new value is a date -> datepicker
+                if (newState.value instanceof Date) {
+                    newState.selectedDate = newState.value;
+                }
+                // provided value is not supported :)
+                // need to report it somehow
+            }
+            return Object.assign({}, state, newState);
+        }
+        // date range picker
+        case BsDatepickerActions.SELECT_RANGE: {
+            var /** @type {?} */ newState = {
+                selectedRange: action.payload,
+                view: state.view
+            };
+            var /** @type {?} */ mode = state.view.mode;
+            var /** @type {?} */ _date = action.payload && action.payload[0] || state.view.date;
+            var /** @type {?} */ date = getViewDate(_date, state.minDate, state.maxDate);
+            newState.view = { mode: mode, date: date };
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.SET_MIN_DATE: {
+            return Object.assign({}, state, {
+                minDate: action.payload
+            });
+        }
+        case BsDatepickerActions.SET_MAX_DATE: {
+            return Object.assign({}, state, {
+                maxDate: action.payload
+            });
+        }
+        case BsDatepickerActions.SET_IS_DISABLED: {
+            return Object.assign({}, state, {
+                isDisabled: action.payload
+            });
+        }
+        default:
+            return state;
+    }
+}
+/**
+ * @param {?} state
+ * @return {?}
+ */
+function calculateReducer(state) {
+    // how many calendars
+    var /** @type {?} */ displayMonths = state.displayMonths;
+    // use selected date on initial rendering if set
+    var /** @type {?} */ viewDate = state.view.date;
+    if (state.view.mode === 'day') {
+        state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();
+        var /** @type {?} */ monthsModel = new Array(displayMonths);
+        for (var /** @type {?} */ monthIndex = 0; monthIndex < displayMonths; monthIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsModel[monthIndex] = calcDaysCalendar(viewDate, state.monthViewOptions);
+            viewDate = shiftDate(viewDate, { month: 1 });
+        }
+        return Object.assign({}, state, { monthsModel: monthsModel });
+    }
+    if (state.view.mode === 'month') {
+        var /** @type {?} */ monthsCalendar = new Array(displayMonths);
+        for (var /** @type {?} */ calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 1 });
+        }
+        return Object.assign({}, state, { monthsCalendar: monthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        var /** @type {?} */ yearsCalendarModel = new Array(displayMonths);
+        for (var /** @type {?} */ calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: yearsPerCalendar });
+        }
+        return Object.assign({}, state, { yearsCalendarModel: yearsCalendarModel });
+    }
+    return state;
+}
+/**
+ * @param {?} state
+ * @param {?} action
+ * @return {?}
+ */
+function formatReducer(state, action) {
+    if (state.view.mode === 'day') {
+        var /** @type {?} */ formattedMonths = state.monthsModel.map(function (month, monthIndex) {
+            return formatDaysCalendar(month, getFormatOptions(state), monthIndex);
+        });
+        return Object.assign({}, state, { formattedMonths: formattedMonths });
+    }
+    // how many calendars
+    var /** @type {?} */ displayMonths = state.displayMonths;
+    // check initial rendering
+    // use selected date on initial rendering if set
+    var /** @type {?} */ viewDate = state.view.date;
+    if (state.view.mode === 'month') {
+        var /** @type {?} */ monthsCalendar = new Array(displayMonths);
+        for (var /** @type {?} */ calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 1 });
+        }
+        return Object.assign({}, state, { monthsCalendar: monthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        var /** @type {?} */ yearsCalendarModel = new Array(displayMonths);
+        for (var /** @type {?} */ calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 16 });
+        }
+        return Object.assign({}, state, { yearsCalendarModel: yearsCalendarModel });
+    }
+    return state;
+}
+/**
+ * @param {?} state
+ * @param {?} action
+ * @return {?}
+ */
+function flagReducer(state, action) {
+    if (state.view.mode === 'day') {
+        var /** @type {?} */ flaggedMonths = state.formattedMonths.map(function (formattedMonth, monthIndex) {
+            return flagDaysCalendar(formattedMonth, {
+                isDisabled: state.isDisabled,
+                minDate: state.minDate,
+                maxDate: state.maxDate,
+                daysDisabled: state.daysDisabled,
+                hoveredDate: state.hoveredDate,
+                selectedDate: state.selectedDate,
+                selectedRange: state.selectedRange,
+                displayMonths: state.displayMonths,
+                monthIndex: monthIndex
+            });
+        });
+        return Object.assign({}, state, { flaggedMonths: flaggedMonths });
+    }
+    if (state.view.mode === 'month') {
+        var /** @type {?} */ flaggedMonthsCalendar = state.monthsCalendar.map(function (formattedMonth, monthIndex) {
+            return flagMonthsCalendar(formattedMonth, {
+                isDisabled: state.isDisabled,
+                minDate: state.minDate,
+                maxDate: state.maxDate,
+                hoveredMonth: state.hoveredMonth,
+                displayMonths: state.displayMonths,
+                monthIndex: monthIndex
+            });
+        });
+        return Object.assign({}, state, { flaggedMonthsCalendar: flaggedMonthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        var /** @type {?} */ yearsCalendarFlagged = state.yearsCalendarModel.map(function (formattedMonth, yearIndex) {
+            return flagYearsCalendar(formattedMonth, {
+                isDisabled: state.isDisabled,
+                minDate: state.minDate,
+                maxDate: state.maxDate,
+                hoveredYear: state.hoveredYear,
+                displayMonths: state.displayMonths,
+                yearIndex: yearIndex
+            });
+        });
+        return Object.assign({}, state, { yearsCalendarFlagged: yearsCalendarFlagged });
+    }
+    return state;
+}
+/**
+ * @param {?} state
+ * @return {?}
+ */
+function getFormatOptions(state) {
+    return {
+        locale: state.locale,
+        monthTitle: state.monthTitle,
+        yearTitle: state.yearTitle,
+        dayLabel: state.dayLabel,
+        monthLabel: state.monthLabel,
+        yearLabel: state.yearLabel,
+        weekNumbers: state.weekNumbers
+    };
+}
+/**
+ * if view date is provided (bsValue|ngModel) it should be shown
+ * if view date is not provider:
+ * if minDate>currentDate (default view value), show minDate
+ * if maxDate<currentDate(default view value) show maxDate
+ * @param {?} viewDate
+ * @param {?} minDate
+ * @param {?} maxDate
+ * @return {?}
+ */
+function getViewDate(viewDate, minDate, maxDate) {
+    var /** @type {?} */ _date = Array.isArray(viewDate) ? viewDate[0] : viewDate;
+    if (minDate && isAfter(minDate, _date, 'day')) {
+        return minDate;
+    }
+    if (maxDate && isBefore(maxDate, _date, 'day')) {
+        return maxDate;
+    }
+    return _date;
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerStore = /** @class */ (function (_super) {
+    __extends(BsDatepickerStore, _super);
+    function BsDatepickerStore() {
+        var _this = this;
+        var /** @type {?} */ _dispatcher = new BehaviorSubject({
+            type: '[datepicker] dispatcher init'
+        });
+        var /** @type {?} */ state = new MiniState(initialDatepickerState, _dispatcher, bsDatepickerReducer);
+        _this = _super.call(this, _dispatcher, bsDatepickerReducer, state) || this;
+        return _this;
+    }
+    BsDatepickerStore.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    BsDatepickerStore.ctorParameters = function () { return []; };
+    return BsDatepickerStore;
+}(MiniStore));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerContainerComponent = /** @class */ (function (_super) {
+    __extends(BsDatepickerContainerComponent, _super);
+    function BsDatepickerContainerComponent(_config, _store, _actions, _effects) {
+        var _this = _super.call(this) || this;
+        _this._config = _config;
+        _this._store = _store;
+        _this._actions = _actions;
+        _this.valueChange = new EventEmitter();
+        _this._subs = [];
+        _this._effects = _effects;
+        return _this;
+    }
+    Object.defineProperty(BsDatepickerContainerComponent.prototype, "value", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setValue(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    BsDatepickerContainerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this.isOtherMonthsActive = this._config.selectFromOtherMonth;
+        this.containerClass = this._config.containerClass;
+        this._effects
+            .init(this._store)
+            .setOptions(this._config)
+            .setBindings(this)
+            .setEventHandlers(this)
+            .registerDatepickerSideEffects();
+        // todo: move it somewhere else
+        // on selected date change
+        this._subs.push(this._store
+            .select(function (state) { return state.selectedDate; })
+            .subscribe(function (date) { return _this.valueChange.emit(date); }));
+    };
+    /**
+     * @param {?} day
+     * @return {?}
+     */
+    BsDatepickerContainerComponent.prototype.daySelectHandler = /**
+     * @param {?} day
+     * @return {?}
+     */
+    function (day) {
+        var /** @type {?} */ isDisabled = this.isOtherMonthsActive ? day.isDisabled : (day.isOtherMonth || day.isDisabled);
+        if (isDisabled) {
+            return;
+        }
+        this._store.dispatch(this._actions.select(day.date));
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerContainerComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        try {
+            for (var _a = __values(this._subs), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._effects.destroy();
+        var e_1, _c;
+    };
+    BsDatepickerContainerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-datepicker-container',
+                    providers: [BsDatepickerStore, BsDatepickerEffects],
+                    template: "<!-- days calendar view mode -->\n<div class=\"bs-datepicker\" [ngClass]=\"containerClass\" *ngIf=\"viewMode | async\">\n  <div class=\"bs-datepicker-container\">\n\n    <!--calendars-->\n    <div class=\"bs-calendar-container\" [ngSwitch]=\"viewMode | async\" role=\"application\">\n      <!--days calendar-->\n      <div *ngSwitchCase=\"'day'\" class=\"bs-media-container\">\n        <bs-days-calendar-view\n          *ngFor=\"let calendar of (daysCalendar | async)\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\"\n          [calendar]=\"calendar\"\n          [options]=\"options | async\"\n          (onNavigate)=\"navigateTo($event)\"\n          (onViewMode)=\"setViewMode($event)\"\n          (onHover)=\"dayHoverHandler($event)\"\n          (onSelect)=\"daySelectHandler($event)\"\n        ></bs-days-calendar-view>\n      </div>\n\n      <!--months calendar-->\n      <div *ngSwitchCase=\"'month'\" class=\"bs-media-container\">\n        <bs-month-calendar-view\n          *ngFor=\"let calendar of (monthsCalendar | async)\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\"\n          [calendar]=\"calendar\"\n          (onNavigate)=\"navigateTo($event)\"\n          (onViewMode)=\"setViewMode($event)\"\n          (onHover)=\"monthHoverHandler($event)\"\n          (onSelect)=\"monthSelectHandler($event)\"\n        ></bs-month-calendar-view>\n      </div>\n\n      <!--years calendar-->\n      <div *ngSwitchCase=\"'year'\" class=\"bs-media-container\">\n        <bs-years-calendar-view\n        *ngFor=\"let calendar of (yearsCalendar | async)\"\n        [class.bs-datepicker-multiple]=\"(daysCalendar | async )?.length > 1\"\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"setViewMode($event)\"\n        (onHover)=\"yearHoverHandler($event)\"\n        (onSelect)=\"yearSelectHandler($event)\"\n      ></bs-years-calendar-view>\n    </div>\n\n  </div>\n\n  <!--applycancel buttons-->\n    <div class=\"bs-datepicker-buttons\" *ngIf=\"false\">\n      <button class=\"btn btn-success\">Apply</button>\n      <button class=\"btn btn-default\">Cancel</button>\n    </div>\n\n  </div>\n\n  <!--custom dates or date ranges picker-->\n  <div class=\"bs-datepicker-custom-range\" *ngIf=\"false\">\n    <bs-custom-date-view [ranges]=\"_customRangesFish\"></bs-custom-date-view>\n  </div>\n</div>\n",
+                    host: {
+                        '(click)': '_stopPropagation($event)',
+                        style: 'position: absolute; display: block;',
+                        role: 'dialog',
+                        'aria-label': 'calendar'
+                    }
+                }] }
+    ];
+    /** @nocollapse */
+    BsDatepickerContainerComponent.ctorParameters = function () { return [
+        { type: BsDatepickerConfig, },
+        { type: BsDatepickerStore, },
+        { type: BsDatepickerActions, },
+        { type: BsDatepickerEffects, },
+    ]; };
+    return BsDatepickerContainerComponent;
+}(BsDatepickerAbstractComponent));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerDirective = /** @class */ (function () {
+    function BsDatepickerDirective(_config, _elementRef, _renderer, _viewContainerRef, cis) {
+        this._config = _config;
+        /**
+         * Placement of a datepicker. Accepts: "top", "bottom", "left", "right"
+         */
+        this.placement = 'bottom';
+        /**
+         * Specifies events that should trigger. Supports a space separated list of
+         * event names.
+         */
+        this.triggers = 'click';
+        /**
+         * Close datepicker on outside click
+         */
+        this.outsideClick = true;
+        /**
+         * A selector specifying the element the datepicker should be appended to.
+         * Currently only supports "body".
+         */
+        this.container = 'body';
+        this.outsideEsc = true;
+        /**
+         * Emits when datepicker value has been changed
+         */
+        this.bsValueChange = new EventEmitter();
+        this._subs = [];
+        // todo: assign only subset of fields
+        Object.assign(this, this._config);
+        this._datepicker = cis.createLoader(_elementRef, _viewContainerRef, _renderer);
+        this.onShown = this._datepicker.onShown;
+        this.onHidden = this._datepicker.onHidden;
+    }
+    Object.defineProperty(BsDatepickerDirective.prototype, "isOpen", {
+        get: /**
+         * Returns whether or not the datepicker is currently being shown
+         * @return {?}
+         */
+        function () {
+            return this._datepicker.isShown;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            if (value) {
+                this.show();
+            }
+            else {
+                this.hide();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDatepickerDirective.prototype, "bsValue", {
+        set: /**
+         * Initial value of datepicker
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            if (this._bsValue === value) {
+                return;
+            }
+            this._bsValue = value;
+            this.bsValueChange.emit(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this._datepicker.listen({
+            outsideClick: this.outsideClick,
+            outsideEsc: this.outsideEsc,
+            triggers: this.triggers,
+            show: function () { return _this.show(); }
+        });
+        this.setConfig();
+    };
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.ngOnChanges = /**
+     * @param {?} changes
+     * @return {?}
+     */
+    function (changes) {
+        if (!this._datepickerRef || !this._datepickerRef.instance) {
+            return;
+        }
+        if (changes["minDate"]) {
+            this._datepickerRef.instance.minDate = this.minDate;
+        }
+        if (changes["maxDate"]) {
+            this._datepickerRef.instance.maxDate = this.maxDate;
+        }
+        if (changes["daysDisabled"]) {
+            this._datepickerRef.instance.daysDisabled = this.daysDisabled;
+        }
+        if (changes["isDisabled"]) {
+            this._datepickerRef.instance.isDisabled = this.isDisabled;
+        }
+    };
+    /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     */
+    /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.show = /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        if (this._datepicker.isShown) {
+            return;
+        }
+        this.setConfig();
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .attach(BsDatepickerContainerComponent)
+            .to(this.container)
+            .position({ attachment: this.placement })
+            .show({ placement: this.placement });
+        // if date changes from external source (model -> view)
+        this._subs.push(this.bsValueChange.subscribe(function (value) {
+            _this._datepickerRef.instance.value = value;
+        }));
+        // if date changes from picker (view -> model)
+        this._subs.push(this._datepickerRef.instance.valueChange.subscribe(function (value) {
+            _this.bsValue = value;
+            _this.hide();
+        }));
+    };
+    /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     */
+    /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.hide = /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    function () {
+        if (this.isOpen) {
+            this._datepicker.hide();
+        }
+        try {
+            for (var _a = __values(this._subs), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _c;
+    };
+    /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     */
+    /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.toggle = /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     * @return {?}
+     */
+    function () {
+        if (this.isOpen) {
+            return this.hide();
+        }
+        this.show();
+    };
+    /**
+     * Set config for datepicker
+     */
+    /**
+     * Set config for datepicker
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.setConfig = /**
+     * Set config for datepicker
+     * @return {?}
+     */
+    function () {
+        this._config = Object.assign({}, this._config, this.bsConfig, {
+            value: this._bsValue,
+            isDisabled: this.isDisabled,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,
+            daysDisabled: this.daysDisabled || this.bsConfig && this.bsConfig.daysDisabled,
+            minMode: this.minMode || this.bsConfig && this.bsConfig.minMode
+        });
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerDirective.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this._datepicker.dispose();
+    };
+    BsDatepickerDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: '[bsDatepicker]',
+                    exportAs: 'bsDatepicker'
+                },] }
+    ];
+    /** @nocollapse */
+    BsDatepickerDirective.ctorParameters = function () { return [
+        { type: BsDatepickerConfig, },
+        { type: ElementRef, },
+        { type: Renderer2, },
+        { type: ViewContainerRef, },
+        { type: ComponentLoaderFactory, },
+    ]; };
+    BsDatepickerDirective.propDecorators = {
+        "placement": [{ type: Input },],
+        "triggers": [{ type: Input },],
+        "outsideClick": [{ type: Input },],
+        "container": [{ type: Input },],
+        "outsideEsc": [{ type: Input },],
+        "isOpen": [{ type: Input },],
+        "onShown": [{ type: Output },],
+        "onHidden": [{ type: Output },],
+        "bsValue": [{ type: Input },],
+        "bsConfig": [{ type: Input },],
+        "isDisabled": [{ type: Input },],
+        "minDate": [{ type: Input },],
+        "maxDate": [{ type: Input },],
+        "minMode": [{ type: Input },],
+        "daysDisabled": [{ type: Input },],
+        "bsValueChange": [{ type: Output },],
+    };
+    return BsDatepickerDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ BS_DATEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDatepickerInputDirective; }),
+    multi: true
+};
+var /** @type {?} */ BS_DATEPICKER_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDatepickerInputDirective; }),
+    multi: true
+};
+var BsDatepickerInputDirective = /** @class */ (function () {
+    function BsDatepickerInputDirective(_picker, _localeService, _renderer, _elRef, changeDetection) {
+        var _this = this;
+        this._picker = _picker;
+        this._localeService = _localeService;
+        this._renderer = _renderer;
+        this._elRef = _elRef;
+        this.changeDetection = changeDetection;
+        this._onChange = Function.prototype;
+        this._onTouched = Function.prototype;
+        this._validatorChange = Function.prototype;
+        // update input value on datepicker value update
+        this._picker.bsValueChange.subscribe(function (value) {
+            _this._setInputValue(value);
+            if (_this._value !== value) {
+                _this._value = value;
+                _this._onChange(value);
+                _this._onTouched();
+            }
+            _this.changeDetection.markForCheck();
+        });
+        // update input value on locale change
+        this._localeService.localeChange.subscribe(function () {
+            _this._setInputValue(_this._value);
+        });
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype._setInputValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        var /** @type {?} */ initialDate = !value ? ''
+            : formatDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);
+        this._renderer.setProperty(this._elRef.nativeElement, 'value', initialDate);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.onChange = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /* tslint:disable-next-line: no-any*/
+        this.writeValue((/** @type {?} */ (event.target)).value);
+        this._onChange(this._value);
+        this._onTouched();
+    };
+    /**
+     * @param {?} c
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.validate = /**
+     * @param {?} c
+     * @return {?}
+     */
+    function (c) {
+        var /** @type {?} */ _value = c.value;
+        /* tslint:disable-next-line: prefer-switch */
+        if (_value === null || _value === undefined || _value === '') {
+            return null;
+        }
+        if (isDate(_value)) {
+            var /** @type {?} */ _isDateValid = isDateValid(_value);
+            if (!_isDateValid) {
+                return { bsDate: { invalid: _value } };
+            }
+            if (this._picker && this._picker.minDate && isBefore(_value, this._picker.minDate, 'date')) {
+                return { bsDate: { minDate: this._picker.minDate } };
+            }
+            if (this._picker && this._picker.maxDate && isAfter(_value, this._picker.maxDate, 'date')) {
+                return { bsDate: { maxDate: this._picker.maxDate } };
+            }
+        }
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnValidatorChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._validatorChange = fn;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        if (!value) {
+            this._value = null;
+        }
+        else {
+            var /** @type {?} */ _localeKey = this._localeService.currentLocale;
+            var /** @type {?} */ _locale = getLocale(_localeKey);
+            if (!_locale) {
+                throw new Error("Locale \"" + _localeKey + "\" is not defined, please add it with \"defineLocale(...)\"");
+            }
+            this._value = parseDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);
+        }
+        this._picker.bsValue = this._value;
+    };
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.setDisabledState = /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    function (isDisabled) {
+        this._picker.isDisabled = isDisabled;
+        if (isDisabled) {
+            this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');
+            return;
+        }
+        this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onChange = fn;
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.registerOnTouched = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onTouched = fn;
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.onBlur = /**
+     * @return {?}
+     */
+    function () {
+        this._onTouched();
+    };
+    /**
+     * @return {?}
+     */
+    BsDatepickerInputDirective.prototype.hide = /**
+     * @return {?}
+     */
+    function () {
+        this._picker.hide();
+        this._renderer.selectRootElement(this._elRef.nativeElement).blur();
+    };
+    BsDatepickerInputDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: "input[bsDatepicker]",
+                    host: {
+                        '(change)': 'onChange($event)',
+                        '(keyup.esc)': 'hide()',
+                        '(blur)': 'onBlur()'
+                    },
+                    providers: [BS_DATEPICKER_VALUE_ACCESSOR, BS_DATEPICKER_VALIDATOR]
+                },] }
+    ];
+    /** @nocollapse */
+    BsDatepickerInputDirective.ctorParameters = function () { return [
+        { type: BsDatepickerDirective, decorators: [{ type: Host },] },
+        { type: BsLocaleService, },
+        { type: Renderer2, },
+        { type: ElementRef, },
+        { type: ChangeDetectorRef, },
+    ]; };
+    return BsDatepickerInputDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDaterangepickerConfig = /** @class */ (function (_super) {
+    __extends(BsDaterangepickerConfig, _super);
+    function BsDaterangepickerConfig() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        // DatepickerRenderOptions
+        _this.displayMonths = 2;
+        return _this;
+    }
+    BsDaterangepickerConfig.decorators = [
+        { type: Injectable }
+    ];
+    return BsDaterangepickerConfig;
+}(BsDatepickerConfig));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDaterangepickerContainerComponent = /** @class */ (function (_super) {
+    __extends(BsDaterangepickerContainerComponent, _super);
+    function BsDaterangepickerContainerComponent(_config, _store, _actions, _effects) {
+        var _this = _super.call(this) || this;
+        _this._config = _config;
+        _this._store = _store;
+        _this._actions = _actions;
+        _this.valueChange = new EventEmitter();
+        _this._rangeStack = [];
+        _this._subs = [];
+        _this._effects = _effects;
+        return _this;
+    }
+    Object.defineProperty(BsDaterangepickerContainerComponent.prototype, "value", {
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._effects.setRangeValue(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerContainerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this.containerClass = this._config.containerClass;
+        this.isOtherMonthsActive = this._config.selectFromOtherMonth;
+        this._effects
+            .init(this._store)
+            .setOptions(this._config)
+            .setBindings(this)
+            .setEventHandlers(this)
+            .registerDatepickerSideEffects();
+        // todo: move it somewhere else
+        // on selected date change
+        this._subs.push(this._store
+            .select(function (state) { return state.selectedRange; })
+            .subscribe(function (date) { return _this.valueChange.emit(date); }));
+    };
+    /**
+     * @param {?} day
+     * @return {?}
+     */
+    BsDaterangepickerContainerComponent.prototype.daySelectHandler = /**
+     * @param {?} day
+     * @return {?}
+     */
+    function (day) {
+        var /** @type {?} */ isDisabled = this.isOtherMonthsActive ? day.isDisabled : (day.isOtherMonth || day.isDisabled);
+        if (isDisabled) {
+            return;
+        }
+        // if only one date is already selected
+        // and user clicks on previous date
+        // start selection from new date
+        // but if new date is after initial one
+        // than finish selection
+        if (this._rangeStack.length === 1) {
+            this._rangeStack =
+                day.date >= this._rangeStack[0]
+                    ? [this._rangeStack[0], day.date]
+                    : [day.date];
+        }
+        if (this._rangeStack.length === 0) {
+            this._rangeStack = [day.date];
+        }
+        this._store.dispatch(this._actions.selectRange(this._rangeStack));
+        if (this._rangeStack.length === 2) {
+            this._rangeStack = [];
+        }
+    };
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerContainerComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        try {
+            for (var _a = __values(this._subs), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this._effects.destroy();
+        var e_1, _c;
+    };
+    BsDaterangepickerContainerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-daterangepicker-container',
+                    providers: [BsDatepickerStore, BsDatepickerEffects],
+                    template: "<!-- days calendar view mode -->\n<div class=\"bs-datepicker\" [ngClass]=\"containerClass\" *ngIf=\"viewMode | async\">\n  <div class=\"bs-datepicker-container\">\n\n    <!--calendars-->\n    <div class=\"bs-calendar-container\" [ngSwitch]=\"viewMode | async\" role=\"application\">\n      <!--days calendar-->\n      <div *ngSwitchCase=\"'day'\" class=\"bs-media-container\">\n        <bs-days-calendar-view\n          *ngFor=\"let calendar of (daysCalendar | async)\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\"\n          [calendar]=\"calendar\"\n          [options]=\"options | async\"\n          (onNavigate)=\"navigateTo($event)\"\n          (onViewMode)=\"setViewMode($event)\"\n          (onHover)=\"dayHoverHandler($event)\"\n          (onSelect)=\"daySelectHandler($event)\"\n        ></bs-days-calendar-view>\n      </div>\n\n      <!--months calendar-->\n      <div *ngSwitchCase=\"'month'\" class=\"bs-media-container\">\n        <bs-month-calendar-view\n          *ngFor=\"let calendar of (monthsCalendar | async)\"\n          [class.bs-datepicker-multiple]=\"(daysCalendar | async)?.length > 1\"\n          [calendar]=\"calendar\"\n          (onNavigate)=\"navigateTo($event)\"\n          (onViewMode)=\"setViewMode($event)\"\n          (onHover)=\"monthHoverHandler($event)\"\n          (onSelect)=\"monthSelectHandler($event)\"\n        ></bs-month-calendar-view>\n      </div>\n\n      <!--years calendar-->\n      <div *ngSwitchCase=\"'year'\" class=\"bs-media-container\">\n        <bs-years-calendar-view\n        *ngFor=\"let calendar of (yearsCalendar | async)\"\n        [class.bs-datepicker-multiple]=\"(daysCalendar | async )?.length > 1\"\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"setViewMode($event)\"\n        (onHover)=\"yearHoverHandler($event)\"\n        (onSelect)=\"yearSelectHandler($event)\"\n      ></bs-years-calendar-view>\n    </div>\n\n  </div>\n\n  <!--applycancel buttons-->\n    <div class=\"bs-datepicker-buttons\" *ngIf=\"false\">\n      <button class=\"btn btn-success\">Apply</button>\n      <button class=\"btn btn-default\">Cancel</button>\n    </div>\n\n  </div>\n\n  <!--custom dates or date ranges picker-->\n  <div class=\"bs-datepicker-custom-range\" *ngIf=\"false\">\n    <bs-custom-date-view [ranges]=\"_customRangesFish\"></bs-custom-date-view>\n  </div>\n</div>\n",
+                    host: {
+                        '(click)': '_stopPropagation($event)',
+                        style: 'position: absolute; display: block;',
+                        role: 'dialog',
+                        'aria-label': 'calendar'
+                    }
+                }] }
+    ];
+    /** @nocollapse */
+    BsDaterangepickerContainerComponent.ctorParameters = function () { return [
+        { type: BsDatepickerConfig, },
+        { type: BsDatepickerStore, },
+        { type: BsDatepickerActions, },
+        { type: BsDatepickerEffects, },
+    ]; };
+    return BsDaterangepickerContainerComponent;
+}(BsDatepickerAbstractComponent));
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDaterangepickerDirective = /** @class */ (function () {
+    function BsDaterangepickerDirective(_config, _elementRef, _renderer, _viewContainerRef, cis) {
+        this._config = _config;
+        /**
+         * Placement of a daterangepicker. Accepts: "top", "bottom", "left", "right"
+         */
+        this.placement = 'bottom';
+        /**
+         * Specifies events that should trigger. Supports a space separated list of
+         * event names.
+         */
+        this.triggers = 'click';
+        /**
+         * Close daterangepicker on outside click
+         */
+        this.outsideClick = true;
+        /**
+         * A selector specifying the element the daterangepicker should be appended
+         * to. Currently only supports "body".
+         */
+        this.container = 'body';
+        this.outsideEsc = true;
+        /**
+         * Emits when daterangepicker value has been changed
+         */
+        this.bsValueChange = new EventEmitter();
+        this._subs = [];
+        this._datepicker = cis.createLoader(_elementRef, _viewContainerRef, _renderer);
+        Object.assign(this, _config);
+        this.onShown = this._datepicker.onShown;
+        this.onHidden = this._datepicker.onHidden;
+    }
+    Object.defineProperty(BsDaterangepickerDirective.prototype, "isOpen", {
+        get: /**
+         * Returns whether or not the daterangepicker is currently being shown
+         * @return {?}
+         */
+        function () {
+            return this._datepicker.isShown;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            if (value) {
+                this.show();
+            }
+            else {
+                this.hide();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BsDaterangepickerDirective.prototype, "bsValue", {
+        set: /**
+         * Initial value of daterangepicker
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            if (this._bsValue === value) {
+                return;
+            }
+            this._bsValue = value;
+            this.bsValueChange.emit(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        this._datepicker.listen({
+            outsideClick: this.outsideClick,
+            outsideEsc: this.outsideEsc,
+            triggers: this.triggers,
+            show: function () { return _this.show(); }
+        });
+        this.setConfig();
+    };
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.ngOnChanges = /**
+     * @param {?} changes
+     * @return {?}
+     */
+    function (changes) {
+        if (!this._datepickerRef || !this._datepickerRef.instance) {
+            return;
+        }
+        if (changes["minDate"]) {
+            this._datepickerRef.instance.minDate = this.minDate;
+        }
+        if (changes["maxDate"]) {
+            this._datepickerRef.instance.maxDate = this.maxDate;
+        }
+        if (changes["isDisabled"]) {
+            this._datepickerRef.instance.isDisabled = this.isDisabled;
+        }
+    };
+    /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     */
+    /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.show = /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        if (this._datepicker.isShown) {
+            return;
+        }
+        this.setConfig();
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .attach(BsDaterangepickerContainerComponent)
+            .to(this.container)
+            .position({ attachment: this.placement })
+            .show({ placement: this.placement });
+        // if date changes from external source (model -> view)
+        this._subs.push(this.bsValueChange.subscribe(function (value) {
+            _this._datepickerRef.instance.value = value;
+        }));
+        // if date changes from picker (view -> model)
+        this._subs.push(this._datepickerRef.instance.valueChange
+            .pipe(filter(function (range) { return range && range[0] && !!range[1]; }))
+            .subscribe(function (value) {
+            _this.bsValue = value;
+            _this.hide();
+        }));
+    };
+    /**
+     * Set config for daterangepicker
+     */
+    /**
+     * Set config for daterangepicker
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.setConfig = /**
+     * Set config for daterangepicker
+     * @return {?}
+     */
+    function () {
+        this._config = Object.assign({}, this._config, this.bsConfig, {
+            value: this._bsValue,
+            isDisabled: this.isDisabled,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate
+        });
+    };
+    /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     */
+    /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.hide = /**
+     * Closes an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     * @return {?}
+     */
+    function () {
+        if (this.isOpen) {
+            this._datepicker.hide();
+        }
+        try {
+            for (var _a = __values(this._subs), _b = _a.next(); !_b.done; _b = _a.next()) {
+                var sub = _b.value;
+                sub.unsubscribe();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _c;
+    };
+    /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     */
+    /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.toggle = /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     * @return {?}
+     */
+    function () {
+        if (this.isOpen) {
+            return this.hide();
+        }
+        this.show();
+    };
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerDirective.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this._datepicker.dispose();
+    };
+    BsDaterangepickerDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: '[bsDaterangepicker]',
+                    exportAs: 'bsDaterangepicker'
+                },] }
+    ];
+    /** @nocollapse */
+    BsDaterangepickerDirective.ctorParameters = function () { return [
+        { type: BsDaterangepickerConfig, },
+        { type: ElementRef, },
+        { type: Renderer2, },
+        { type: ViewContainerRef, },
+        { type: ComponentLoaderFactory, },
+    ]; };
+    BsDaterangepickerDirective.propDecorators = {
+        "placement": [{ type: Input },],
+        "triggers": [{ type: Input },],
+        "outsideClick": [{ type: Input },],
+        "container": [{ type: Input },],
+        "outsideEsc": [{ type: Input },],
+        "isOpen": [{ type: Input },],
+        "onShown": [{ type: Output },],
+        "onHidden": [{ type: Output },],
+        "bsValue": [{ type: Input },],
+        "bsConfig": [{ type: Input },],
+        "isDisabled": [{ type: Input },],
+        "minDate": [{ type: Input },],
+        "maxDate": [{ type: Input },],
+        "bsValueChange": [{ type: Output },],
+    };
+    return BsDaterangepickerDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ BS_DATERANGEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDaterangepickerInputDirective; }),
+    multi: true
+};
+var /** @type {?} */ BS_DATERANGEPICKER_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return BsDaterangepickerInputDirective; }),
+    multi: true
+};
+var BsDaterangepickerInputDirective = /** @class */ (function () {
+    function BsDaterangepickerInputDirective(_picker, _localeService, _renderer, _elRef, changeDetection) {
+        var _this = this;
+        this._picker = _picker;
+        this._localeService = _localeService;
+        this._renderer = _renderer;
+        this._elRef = _elRef;
+        this.changeDetection = changeDetection;
+        this._onChange = Function.prototype;
+        this._onTouched = Function.prototype;
+        this._validatorChange = Function.prototype;
+        // update input value on datepicker value update
+        this._picker.bsValueChange.subscribe(function (value) {
+            _this._setInputValue(value);
+            if (_this._value !== value) {
+                _this._value = value;
+                _this._onChange(value);
+                _this._onTouched();
+            }
+            _this.changeDetection.markForCheck();
+        });
+        // update input value on locale change
+        this._localeService.localeChange.subscribe(function () {
+            _this._setInputValue(_this._value);
+        });
+    }
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype._setInputValue = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var /** @type {?} */ range = '';
+        if (date) {
+            var /** @type {?} */ start = !date[0] ? ''
+                : formatDate(date[0], this._picker._config.rangeInputFormat, this._localeService.currentLocale);
+            var /** @type {?} */ end = !date[1] ? ''
+                : formatDate(date[1], this._picker._config.rangeInputFormat, this._localeService.currentLocale);
+            range = (start && end) ? start + this._picker._config.rangeSeparator + end : '';
+        }
+        this._renderer.setProperty(this._elRef.nativeElement, 'value', range);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.onChange = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        /* tslint:disable-next-line: no-any*/
+        this.writeValue((/** @type {?} */ (event.target)).value);
+        this._onChange(this._value);
+        this._onTouched();
+    };
+    /**
+     * @param {?} c
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.validate = /**
+     * @param {?} c
+     * @return {?}
+     */
+    function (c) {
+        var /** @type {?} */ _value = c.value;
+        if (_value === null || _value === undefined || !isArray(_value)) {
+            return null;
+        }
+        var /** @type {?} */ _isFirstDateValid = isDateValid(_value[0]);
+        var /** @type {?} */ _isSecondDateValid = isDateValid(_value[1]);
+        if (!_isFirstDateValid) {
+            return { bsDate: { invalid: _value[0] } };
+        }
+        if (!_isSecondDateValid) {
+            return { bsDate: { invalid: _value[1] } };
+        }
+        if (this._picker && this._picker.minDate && isBefore(_value[0], this._picker.minDate, 'date')) {
+            return { bsDate: { minDate: this._picker.minDate } };
+        }
+        if (this._picker && this._picker.maxDate && isAfter(_value[1], this._picker.maxDate, 'date')) {
+            return { bsDate: { maxDate: this._picker.maxDate } };
+        }
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.registerOnValidatorChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._validatorChange = fn;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        var _this = this;
+        if (!value) {
+            this._value = null;
+        }
+        else {
+            var /** @type {?} */ _localeKey = this._localeService.currentLocale;
+            var /** @type {?} */ _locale = getLocale(_localeKey);
+            if (!_locale) {
+                throw new Error("Locale \"" + _localeKey + "\" is not defined, please add it with \"defineLocale(...)\"");
+            }
+            var /** @type {?} */ _input = [];
+            if (typeof value === 'string') {
+                _input = value.split(this._picker._config.rangeSeparator);
+            }
+            if (Array.isArray(value)) {
+                _input = value;
+            }
+            this._value = (/** @type {?} */ (_input))
+                .map(function (_val) {
+                return parseDate(_val, _this._picker._config.dateInputFormat, _this._localeService.currentLocale);
+            })
+                .map(function (date) { return (isNaN(date.valueOf()) ? null : date); });
+        }
+        this._picker.bsValue = this._value;
+    };
+    /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.setDisabledState = /**
+     * @param {?} isDisabled
+     * @return {?}
+     */
+    function (isDisabled) {
+        this._picker.isDisabled = isDisabled;
+        if (isDisabled) {
+            this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');
+            return;
+        }
+        this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');
+    };
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.registerOnChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onChange = fn;
+    };
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.registerOnTouched = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this._onTouched = fn;
+    };
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.onBlur = /**
+     * @return {?}
+     */
+    function () {
+        this._onTouched();
+    };
+    /**
+     * @return {?}
+     */
+    BsDaterangepickerInputDirective.prototype.hide = /**
+     * @return {?}
+     */
+    function () {
+        this._picker.hide();
+        this._renderer.selectRootElement(this._elRef.nativeElement).blur();
+    };
+    BsDaterangepickerInputDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: "input[bsDaterangepicker]",
+                    host: {
+                        '(change)': 'onChange($event)',
+                        '(keyup.esc)': 'hide()',
+                        '(blur)': 'onBlur()'
+                    },
+                    providers: [BS_DATERANGEPICKER_VALUE_ACCESSOR, BS_DATERANGEPICKER_VALIDATOR]
+                },] }
+    ];
+    /** @nocollapse */
+    BsDaterangepickerInputDirective.ctorParameters = function () { return [
+        { type: BsDaterangepickerDirective, decorators: [{ type: Host },] },
+        { type: BsLocaleService, },
+        { type: Renderer2, },
+        { type: ElementRef, },
+        { type: ChangeDetectorRef, },
+    ]; };
+    return BsDaterangepickerInputDirective;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsCalendarLayoutComponent = /** @class */ (function () {
+    function BsCalendarLayoutComponent() {
+    }
+    BsCalendarLayoutComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-calendar-layout',
+                    template: "\n    <!-- current date, will be added in nearest releases -->\n    <bs-current-date title=\"hey there\" *ngIf=\"false\"></bs-current-date>\n\n    <!--navigation-->\n    <div class=\"bs-datepicker-head\">\n      <ng-content select=\"bs-datepicker-navigation-view\"></ng-content>\n    </div>\n\n    <div class=\"bs-datepicker-body\">\n      <ng-content></ng-content>\n    </div>\n\n    <!--timepicker-->\n    <bs-timepicker *ngIf=\"false\"></bs-timepicker>\n  "
+                }] }
+    ];
+    return BsCalendarLayoutComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsCurrentDateViewComponent = /** @class */ (function () {
+    function BsCurrentDateViewComponent() {
+    }
+    BsCurrentDateViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-current-date',
+                    template: "<div class=\"current-timedate\"><span>{{ title }}</span></div>"
+                }] }
+    ];
+    /** @nocollapse */
+    BsCurrentDateViewComponent.propDecorators = {
+        "title": [{ type: Input },],
+    };
+    return BsCurrentDateViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsCustomDatesViewComponent = /** @class */ (function () {
+    function BsCustomDatesViewComponent() {
+    }
+    BsCustomDatesViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-custom-date-view',
+                    template: "\n    <div class=\"bs-datepicker-predefined-btns\">\n      <button *ngFor=\"let range of ranges\">{{ range.label }}</button>\n      <button *ngIf=\"isCustomRangeShown\">Custom Range</button>\n    </div>\n  ",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }] }
+    ];
+    /** @nocollapse */
+    BsCustomDatesViewComponent.propDecorators = {
+        "isCustomRangeShown": [{ type: Input },],
+        "ranges": [{ type: Input },],
+    };
+    return BsCustomDatesViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerDayDecoratorComponent = /** @class */ (function () {
+    function BsDatepickerDayDecoratorComponent(_config, _elRef, _renderer) {
+        this._config = _config;
+        this._elRef = _elRef;
+        this._renderer = _renderer;
+    }
+    /**
+     * @return {?}
+     */
+    BsDatepickerDayDecoratorComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        if (this.day.isToday && this._config && this._config.customTodayClass) {
+            this._renderer.addClass(this._elRef.nativeElement, this._config.customTodayClass);
+        }
+    };
+    BsDatepickerDayDecoratorComponent.decorators = [
+        { type: Component, args: [{
+                    selector: '[bsDatepickerDayDecorator]',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[class.disabled]': 'day.isDisabled',
+                        '[class.is-highlighted]': 'day.isHovered',
+                        '[class.is-other-month]': 'day.isOtherMonth',
+                        '[class.is-active-other-month]': 'day.isOtherMonthHovered',
+                        '[class.in-range]': 'day.isInRange',
+                        '[class.select-start]': 'day.isSelectionStart',
+                        '[class.select-end]': 'day.isSelectionEnd',
+                        '[class.selected]': 'day.isSelected'
+                    },
+                    template: "{{ day.label }}"
+                }] }
+    ];
+    /** @nocollapse */
+    BsDatepickerDayDecoratorComponent.ctorParameters = function () { return [
+        { type: BsDatepickerConfig, },
+        { type: ElementRef, },
+        { type: Renderer2, },
+    ]; };
+    BsDatepickerDayDecoratorComponent.propDecorators = {
+        "day": [{ type: Input },],
+    };
+    return BsDatepickerDayDecoratorComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/** @enum {number} */
+var BsNavigationDirection = {
+    UP: 0,
+    DOWN: 1,
+};
+BsNavigationDirection[BsNavigationDirection.UP] = "UP";
+BsNavigationDirection[BsNavigationDirection.DOWN] = "DOWN";
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDatepickerNavigationViewComponent = /** @class */ (function () {
+    function BsDatepickerNavigationViewComponent() {
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+    }
+    /**
+     * @param {?} down
+     * @return {?}
+     */
+    BsDatepickerNavigationViewComponent.prototype.navTo = /**
+     * @param {?} down
+     * @return {?}
+     */
+    function (down) {
+        this.onNavigate.emit(down ? BsNavigationDirection.DOWN : BsNavigationDirection.UP);
+    };
+    /**
+     * @param {?} viewMode
+     * @return {?}
+     */
+    BsDatepickerNavigationViewComponent.prototype.view = /**
+     * @param {?} viewMode
+     * @return {?}
+     */
+    function (viewMode) {
+        this.onViewMode.emit(viewMode);
+    };
+    BsDatepickerNavigationViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-datepicker-navigation-view',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: "\n    <button class=\"previous\"\n            [disabled]=\"calendar.disableLeftArrow\"\n            [style.visibility]=\"calendar.hideLeftArrow ? 'hidden' : 'visible'\"\n            (click)=\"navTo(true)\"><span>&lsaquo;</span>\n    </button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"current\"\n            *ngIf=\"calendar.monthTitle\"\n            (click)=\"view('month')\"\n    ><span>{{ calendar.monthTitle }}</span>\n    </button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"current\" (click)=\"view('year')\"\n    ><span>{{ calendar.yearTitle }}</span></button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"next\"\n            [disabled]=\"calendar.disableRightArrow\"\n            [style.visibility]=\"calendar.hideRightArrow ? 'hidden' : 'visible'\"\n            (click)=\"navTo(false)\"><span>&rsaquo;</span>\n    </button>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    BsDatepickerNavigationViewComponent.propDecorators = {
+        "calendar": [{ type: Input },],
+        "onNavigate": [{ type: Output },],
+        "onViewMode": [{ type: Output },],
+    };
+    return BsDatepickerNavigationViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsDaysCalendarViewComponent = /** @class */ (function () {
+    function BsDaysCalendarViewComponent(_config) {
+        this._config = _config;
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDaysCalendarViewComponent.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        var /** @type {?} */ step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { month: step } });
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDaysCalendarViewComponent.prototype.changeViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.onViewMode.emit(event);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsDaysCalendarViewComponent.prototype.selectDay = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.onSelect.emit(event);
+    };
+    /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    BsDaysCalendarViewComponent.prototype.hoverDay = /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    function (cell, isHovered) {
+        if (this._config.selectFromOtherMonth && cell.isOtherMonth) {
+            cell.isOtherMonthHovered = isHovered;
+        }
+        this.onHover.emit({ cell: cell, isHovered: isHovered });
+    };
+    BsDaysCalendarViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-days-calendar-view',
+                    // changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: "\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <!--days matrix-->\n      <table role=\"grid\" class=\"days weeks\">\n        <thead>\n        <tr>\n          <!--if show weeks-->\n          <th *ngIf=\"options.showWeekNumbers\"></th>\n          <th *ngFor=\"let weekday of calendar.weekdays; let i = index\"\n              aria-label=\"weekday\">{{ calendar.weekdays[i] }}\n          </th>\n        </tr>\n        </thead>\n        <tbody>\n        <tr *ngFor=\"let week of calendar.weeks; let i = index\">\n          <td class=\"week\" *ngIf=\"options.showWeekNumbers\">\n            <span>{{ calendar.weekNumbers[i] }}</span>\n          </td>\n          <td *ngFor=\"let day of week.days\" role=\"gridcell\">\n          <span bsDatepickerDayDecorator\n                [day]=\"day\"\n                (click)=\"selectDay(day)\"\n                (mouseenter)=\"hoverDay(day, true)\"\n                (mouseleave)=\"hoverDay(day, false)\">{{ day.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n\n    </bs-calendar-layout>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    BsDaysCalendarViewComponent.ctorParameters = function () { return [
+        { type: BsDatepickerConfig, },
+    ]; };
+    BsDaysCalendarViewComponent.propDecorators = {
+        "calendar": [{ type: Input },],
+        "options": [{ type: Input },],
+        "onNavigate": [{ type: Output },],
+        "onViewMode": [{ type: Output },],
+        "onSelect": [{ type: Output },],
+        "onHover": [{ type: Output },],
+    };
+    return BsDaysCalendarViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsMonthCalendarViewComponent = /** @class */ (function () {
+    function BsMonthCalendarViewComponent() {
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsMonthCalendarViewComponent.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        var /** @type {?} */ step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { year: step } });
+    };
+    /**
+     * @param {?} month
+     * @return {?}
+     */
+    BsMonthCalendarViewComponent.prototype.viewMonth = /**
+     * @param {?} month
+     * @return {?}
+     */
+    function (month) {
+        this.onSelect.emit(month);
+    };
+    /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    BsMonthCalendarViewComponent.prototype.hoverMonth = /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    function (cell, isHovered) {
+        this.onHover.emit({ cell: cell, isHovered: isHovered });
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsMonthCalendarViewComponent.prototype.changeViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.onViewMode.emit(event);
+    };
+    BsMonthCalendarViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-month-calendar-view',
+                    template: "\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <table role=\"grid\" class=\"months\">\n        <tbody>\n        <tr *ngFor=\"let row of calendar.months\">\n          <td *ngFor=\"let month of row\" role=\"gridcell\"\n              (click)=\"viewMonth(month)\"\n              (mouseenter)=\"hoverMonth(month, true)\"\n              (mouseleave)=\"hoverMonth(month, false)\"\n              [class.disabled]=\"month.isDisabled\"\n              [class.is-highlighted]=\"month.isHovered\">\n            <span>{{ month.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n    </bs-calendar-layout>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    BsMonthCalendarViewComponent.propDecorators = {
+        "calendar": [{ type: Input },],
+        "onNavigate": [{ type: Output },],
+        "onViewMode": [{ type: Output },],
+        "onSelect": [{ type: Output },],
+        "onHover": [{ type: Output },],
+    };
+    return BsMonthCalendarViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsTimepickerViewComponent = /** @class */ (function () {
+    function BsTimepickerViewComponent() {
+        this.ampm = 'ok';
+        this.hours = 0;
+        this.minutes = 0;
+    }
+    BsTimepickerViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-timepicker',
+                    template: "\n    <div class=\"bs-timepicker-container\">\n      <div class=\"bs-timepicker-controls\">\n        <button class=\"bs-decrease\">-</button>\n        <input type=\"text\" [value]=\"hours\" placeholder=\"00\">\n        <button class=\"bs-increase\">+</button>\n      </div>\n      <div class=\"bs-timepicker-controls\">\n        <button class=\"bs-decrease\">-</button>\n        <input type=\"text\" [value]=\"minutes\" placeholder=\"00\">\n        <button class=\"bs-increase\">+</button>\n      </div>\n      <button class=\"switch-time-format\">{{ ampm }}\n        <img\n          src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAKCAYAAABi8KSDAAABSElEQVQYV3XQPUvDUBQG4HNuagtVqc6KgouCv6GIuIntYBLB9hcIQpLStCAIV7DYmpTcRWcXqZio3Vwc/UCc/QEqfgyKGbr0I7nS1EiHeqYzPO/h5SD0jaxUZjmSLCB+OFb+UFINFwASAEAdpu9gaGXVyAHHFQBkHpKHc6a9dzECvADyY9sqlAMsK9W0jzxDXqeytr3mhQckxSji27TJJ5/rPmIpwJJq3HrtduriYOurv1a4i1p5HnhkG9OFymi0ReoO05cGwb+ayv4dysVygjeFmsP05f8wpZQ8fsdvfmuY9zjWSNqUtgYFVnOVReILYoBFzdQI5/GGFzNHhGbeZnopDGU29sZbscgldmC99w35VOATTycIMMcBXIfpSVGzZhA6C8hh00conln6VQ9TGgV32OEAKQC4DrBq7CJwd0ggR7Vq/rPrfgB+C3sGypY5DAAAAABJRU5ErkJggg==\"\n          alt=\"\">\n      </button>\n    </div>\n  "
+                }] }
+    ];
+    return BsTimepickerViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var BsYearsCalendarViewComponent = /** @class */ (function () {
+    function BsYearsCalendarViewComponent() {
+        this.onNavigate = new EventEmitter();
+        this.onViewMode = new EventEmitter();
+        this.onSelect = new EventEmitter();
+        this.onHover = new EventEmitter();
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsYearsCalendarViewComponent.prototype.navigateTo = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        var /** @type {?} */ step = BsNavigationDirection.DOWN === event ? -1 : 1;
+        this.onNavigate.emit({ step: { year: step * yearsPerCalendar } });
+    };
+    /**
+     * @param {?} year
+     * @return {?}
+     */
+    BsYearsCalendarViewComponent.prototype.viewYear = /**
+     * @param {?} year
+     * @return {?}
+     */
+    function (year) {
+        this.onSelect.emit(year);
+    };
+    /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    BsYearsCalendarViewComponent.prototype.hoverYear = /**
+     * @param {?} cell
+     * @param {?} isHovered
+     * @return {?}
+     */
+    function (cell, isHovered) {
+        this.onHover.emit({ cell: cell, isHovered: isHovered });
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    BsYearsCalendarViewComponent.prototype.changeViewMode = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.onViewMode.emit(event);
+    };
+    BsYearsCalendarViewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-years-calendar-view',
+                    template: "\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <table role=\"grid\" class=\"years\">\n        <tbody>\n        <tr *ngFor=\"let row of calendar.years\">\n          <td *ngFor=\"let year of row\" role=\"gridcell\"\n              (click)=\"viewYear(year)\"\n              (mouseenter)=\"hoverYear(year, true)\"\n              (mouseleave)=\"hoverYear(year, false)\"\n              [class.disabled]=\"year.isDisabled\"\n              [class.is-highlighted]=\"year.isHovered\">\n            <span>{{ year.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n    </bs-calendar-layout>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    BsYearsCalendarViewComponent.propDecorators = {
+        "calendar": [{ type: Input },],
+        "onNavigate": [{ type: Output },],
+        "onViewMode": [{ type: Output },],
+        "onSelect": [{ type: Output },],
+        "onHover": [{ type: Output },],
+    };
+    return BsYearsCalendarViewComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ _exports = [
+    BsDatepickerContainerComponent,
+    BsDaterangepickerContainerComponent,
+    BsDatepickerDirective,
+    BsDatepickerInputDirective,
+    BsDaterangepickerInputDirective,
+    BsDaterangepickerDirective
+];
+var BsDatepickerModule = /** @class */ (function () {
+    function BsDatepickerModule() {
+    }
+    /**
+     * @return {?}
+     */
+    BsDatepickerModule.forRoot = /**
+     * @return {?}
+     */
+    function () {
+        return {
+            ngModule: BsDatepickerModule,
+            providers: [
+                ComponentLoaderFactory,
+                PositioningService,
+                BsDatepickerStore,
+                BsDatepickerActions,
+                BsDatepickerConfig,
+                BsDaterangepickerConfig,
+                BsDatepickerEffects,
+                BsLocaleService
+            ]
+        };
+    };
+    BsDatepickerModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [CommonModule],
+                    declarations: __spread([
+                        BsDatepickerDayDecoratorComponent,
+                        BsCurrentDateViewComponent,
+                        BsDatepickerNavigationViewComponent,
+                        BsTimepickerViewComponent,
+                        BsCalendarLayoutComponent,
+                        BsDaysCalendarViewComponent,
+                        BsMonthCalendarViewComponent,
+                        BsYearsCalendarViewComponent,
+                        BsCustomDatesViewComponent
+                    ], _exports),
+                    entryComponents: [
+                        BsDatepickerContainerComponent,
+                        BsDaterangepickerContainerComponent
+                    ],
+                    exports: _exports
+                },] }
+    ];
+    return BsDatepickerModule;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var DateFormatter = /** @class */ (function () {
+    function DateFormatter() {
+    }
+    /**
+     * @param {?} date
+     * @param {?} format
+     * @param {?} locale
+     * @return {?}
+     */
+    DateFormatter.prototype.format = /**
+     * @param {?} date
+     * @param {?} format
+     * @param {?} locale
+     * @return {?}
+     */
+    function (date, format, locale) {
+        return formatDate(date, format, locale);
+    };
+    return DateFormatter;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var DatePickerInnerComponent = /** @class */ (function () {
+    function DatePickerInnerComponent() {
+        this.selectionDone = new EventEmitter(undefined);
+        this.update = new EventEmitter(false);
+        this.activeDateChange = new EventEmitter(undefined);
+        /* tslint:disable-next-line: no-any*/
+        this.stepDay = {};
+        /* tslint:disable-next-line: no-any*/
+        this.stepMonth = {};
+        /* tslint:disable-next-line: no-any*/
+        this.stepYear = {};
+        this.modes = ['day', 'month', 'year'];
+        this.dateFormatter = new DateFormatter();
+    }
+    Object.defineProperty(DatePickerInnerComponent.prototype, "activeDate", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._activeDate;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._activeDate = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    // todo: add formatter value to Date object
+    /**
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        // todo: use date for unique value
+        this.uniqueId = "datepicker--" + Math.floor(Math.random() * 10000);
+        if (this.initDate) {
+            this.activeDate = this.initDate;
+            this.selectedDate = new Date(this.activeDate.valueOf());
+            this.update.emit(this.activeDate);
+        }
+        else if (this.activeDate === undefined) {
+            this.activeDate = new Date();
+        }
+    };
+    // this.refreshView should be called here to reflect the changes on the fly
+    // tslint:disable-next-line:no-unused-variable
+    /**
+     * @param {?} changes
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.ngOnChanges = /**
+     * @param {?} changes
+     * @return {?}
+     */
+    function (changes) {
+        this.refreshView();
+        this.checkIfActiveDateGotUpdated(changes["activeDate"]);
+    };
+    // Check if activeDate has been update and then emit the activeDateChange with the new date
+    /* tslint:disable-next-line: no-any */
+    /**
+     * @param {?} activeDate
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.checkIfActiveDateGotUpdated = /**
+     * @param {?} activeDate
+     * @return {?}
+     */
+    function (activeDate) {
+        if (activeDate && !activeDate.firstChange) {
+            var /** @type {?} */ previousValue = activeDate.previousValue;
+            if (previousValue &&
+                previousValue instanceof Date &&
+                previousValue.getTime() !== activeDate.currentValue.getTime()) {
+                this.activeDateChange.emit(this.activeDate);
+            }
+        }
+    };
+    /**
+     * @param {?} handler
+     * @param {?} type
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.setCompareHandler = /**
+     * @param {?} handler
+     * @param {?} type
+     * @return {?}
+     */
+    function (handler, type) {
+        if (type === 'day') {
+            this.compareHandlerDay = handler;
+        }
+        if (type === 'month') {
+            this.compareHandlerMonth = handler;
+        }
+        if (type === 'year') {
+            this.compareHandlerYear = handler;
+        }
+    };
+    /**
+     * @param {?} date1
+     * @param {?} date2
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.compare = /**
+     * @param {?} date1
+     * @param {?} date2
+     * @return {?}
+     */
+    function (date1, date2) {
+        if (date1 === undefined || date2 === undefined) {
+            return undefined;
+        }
+        if (this.datepickerMode === 'day' && this.compareHandlerDay) {
+            return this.compareHandlerDay(date1, date2);
+        }
+        if (this.datepickerMode === 'month' && this.compareHandlerMonth) {
+            return this.compareHandlerMonth(date1, date2);
+        }
+        if (this.datepickerMode === 'year' && this.compareHandlerYear) {
+            return this.compareHandlerYear(date1, date2);
+        }
+        return void 0;
+    };
+    /**
+     * @param {?} handler
+     * @param {?} type
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.setRefreshViewHandler = /**
+     * @param {?} handler
+     * @param {?} type
+     * @return {?}
+     */
+    function (handler, type) {
+        if (type === 'day') {
+            this.refreshViewHandlerDay = handler;
+        }
+        if (type === 'month') {
+            this.refreshViewHandlerMonth = handler;
+        }
+        if (type === 'year') {
+            this.refreshViewHandlerYear = handler;
+        }
+    };
+    /**
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.refreshView = /**
+     * @return {?}
+     */
+    function () {
+        if (this.datepickerMode === 'day' && this.refreshViewHandlerDay) {
+            this.refreshViewHandlerDay();
+        }
+        if (this.datepickerMode === 'month' && this.refreshViewHandlerMonth) {
+            this.refreshViewHandlerMonth();
+        }
+        if (this.datepickerMode === 'year' && this.refreshViewHandlerYear) {
+            this.refreshViewHandlerYear();
+        }
+    };
+    /**
+     * @param {?} date
+     * @param {?} format
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.dateFilter = /**
+     * @param {?} date
+     * @param {?} format
+     * @return {?}
+     */
+    function (date, format) {
+        return this.dateFormatter.format(date, format, this.locale);
+    };
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} dateObject
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.isActive = /**
+     * @param {?} dateObject
+     * @return {?}
+     */
+    function (dateObject) {
+        if (this.compare(dateObject.date, this.activeDate) === 0) {
+            this.activeDateId = dateObject.uid;
+            return true;
+        }
+        return false;
+    };
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} date
+     * @param {?} format
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.createDateObject = /**
+     * @param {?} date
+     * @param {?} format
+     * @return {?}
+     */
+    function (date, format) {
+        /* tslint:disable-next-line: no-any*/
+        var /** @type {?} */ dateObject = {};
+        dateObject.date = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+        dateObject.date = this.fixTimeZone(dateObject.date);
+        dateObject.label = this.dateFilter(date, format);
+        dateObject.selected = this.compare(date, this.selectedDate) === 0;
+        dateObject.disabled = this.isDisabled(date);
+        dateObject.current = this.compare(date, new Date()) === 0;
+        dateObject.customClass = this.getCustomClassForDate(dateObject.date);
+        return dateObject;
+    };
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} arr
+     * @param {?} size
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.split = /**
+     * @param {?} arr
+     * @param {?} size
+     * @return {?}
+     */
+    function (arr, size) {
+        /* tslint:disable-next-line: no-any*/
+        var /** @type {?} */ arrays = [];
+        while (arr.length > 0) {
+            arrays.push(arr.splice(0, size));
+        }
+        return arrays;
+    };
+    // Fix a hard-reproducible bug with timezones
+    // The bug depends on OS, browser, current timezone and current date
+    // i.e.
+    // var date = new Date(2014, 0, 1);
+    // console.log(date.getFullYear(), date.getMonth(), date.getDate(),
+    // date.getHours()); can result in "2013 11 31 23" because of the bug.
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.fixTimeZone = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var /** @type {?} */ hours = date.getHours();
+        return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours === 23 ? hours + 2 : 0);
+    };
+    /**
+     * @param {?} date
+     * @param {?=} isManual
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.select = /**
+     * @param {?} date
+     * @param {?=} isManual
+     * @return {?}
+     */
+    function (date, isManual) {
+        if (isManual === void 0) { isManual = true; }
+        if (this.datepickerMode === this.minMode) {
+            if (!this.activeDate) {
+                this.activeDate = new Date(0, 0, 0, 0, 0, 0, 0);
+            }
+            this.activeDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+            this.activeDate = this.fixTimeZone(this.activeDate);
+            if (isManual) {
+                this.selectionDone.emit(this.activeDate);
+            }
+        }
+        else {
+            this.activeDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+            this.activeDate = this.fixTimeZone(this.activeDate);
+            if (isManual) {
+                this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) - 1];
+            }
+        }
+        this.selectedDate = new Date(this.activeDate.valueOf());
+        this.update.emit(this.activeDate);
+        this.refreshView();
+    };
+    /**
+     * @param {?} direction
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.move = /**
+     * @param {?} direction
+     * @return {?}
+     */
+    function (direction) {
+        /* tslint:disable-next-line: no-any*/
+        var /** @type {?} */ expectedStep;
+        if (this.datepickerMode === 'day') {
+            expectedStep = this.stepDay;
+        }
+        if (this.datepickerMode === 'month') {
+            expectedStep = this.stepMonth;
+        }
+        if (this.datepickerMode === 'year') {
+            expectedStep = this.stepYear;
+        }
+        if (expectedStep) {
+            var /** @type {?} */ year = this.activeDate.getFullYear() + direction * (expectedStep.years || 0);
+            var /** @type {?} */ month = this.activeDate.getMonth() + direction * (expectedStep.months || 0);
+            this.activeDate = new Date(year, month, 1);
+            this.refreshView();
+            this.activeDateChange.emit(this.activeDate);
+        }
+    };
+    /**
+     * @param {?} _direction
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.toggleMode = /**
+     * @param {?} _direction
+     * @return {?}
+     */
+    function (_direction) {
+        var /** @type {?} */ direction = _direction || 1;
+        if ((this.datepickerMode === this.maxMode && direction === 1) ||
+            (this.datepickerMode === this.minMode && direction === -1)) {
+            return;
+        }
+        this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) + direction];
+        this.refreshView();
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.getCustomClassForDate = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var _this = this;
+        if (!this.customClass) {
+            return '';
+        }
+        // todo: build a hash of custom classes, it will work faster
+        var /** @type {?} */ customClassObject = this.customClass.find(function (customClass) {
+            return (customClass.date.valueOf() === date.valueOf() &&
+                customClass.mode === _this.datepickerMode);
+        }, this);
+        return customClassObject === undefined ? '' : customClassObject.clazz;
+    };
+    /**
+     * @param {?} date1Disabled
+     * @param {?} date2
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.compareDateDisabled = /**
+     * @param {?} date1Disabled
+     * @param {?} date2
+     * @return {?}
+     */
+    function (date1Disabled, date2) {
+        if (date1Disabled === undefined || date2 === undefined) {
+            return undefined;
+        }
+        if (date1Disabled.mode === 'day' && this.compareHandlerDay) {
+            return this.compareHandlerDay(date1Disabled.date, date2);
+        }
+        if (date1Disabled.mode === 'month' && this.compareHandlerMonth) {
+            return this.compareHandlerMonth(date1Disabled.date, date2);
+        }
+        if (date1Disabled.mode === 'year' && this.compareHandlerYear) {
+            return this.compareHandlerYear(date1Disabled.date, date2);
+        }
+        return undefined;
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    DatePickerInnerComponent.prototype.isDisabled = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var _this = this;
+        var /** @type {?} */ isDateDisabled = false;
+        if (this.dateDisabled) {
+            this.dateDisabled.forEach(function (disabledDate) {
+                if (_this.compareDateDisabled(disabledDate, date) === 0) {
+                    isDateDisabled = true;
+                }
+            });
+        }
+        if (this.dayDisabled) {
+            isDateDisabled =
+                isDateDisabled ||
+                    this.dayDisabled.indexOf(date.getDay()) > -1;
+        }
+        return (isDateDisabled ||
+            (this.minDate && this.compare(date, this.minDate) < 0) ||
+            (this.maxDate && this.compare(date, this.maxDate) > 0));
+    };
+    DatePickerInnerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'datepicker-inner',
+                    template: "\n    <!--&lt;!&ndash;ng-keydown=\"keydown($event)\"&ndash;&gt;-->\n    <div *ngIf=\"datepickerMode\" class=\"well well-sm bg-faded p-a card\" role=\"application\" >\n      <ng-content></ng-content>\n    </div>\n  "
+                }] }
+    ];
+    /** @nocollapse */
+    DatePickerInnerComponent.propDecorators = {
+        "locale": [{ type: Input },],
+        "datepickerMode": [{ type: Input },],
+        "startingDay": [{ type: Input },],
+        "yearRange": [{ type: Input },],
+        "minDate": [{ type: Input },],
+        "maxDate": [{ type: Input },],
+        "minMode": [{ type: Input },],
+        "maxMode": [{ type: Input },],
+        "showWeeks": [{ type: Input },],
+        "formatDay": [{ type: Input },],
+        "formatMonth": [{ type: Input },],
+        "formatYear": [{ type: Input },],
+        "formatDayHeader": [{ type: Input },],
+        "formatDayTitle": [{ type: Input },],
+        "formatMonthTitle": [{ type: Input },],
+        "onlyCurrentMonth": [{ type: Input },],
+        "shortcutPropagation": [{ type: Input },],
+        "customClass": [{ type: Input },],
+        "monthColLimit": [{ type: Input },],
+        "yearColLimit": [{ type: Input },],
+        "dateDisabled": [{ type: Input },],
+        "dayDisabled": [{ type: Input },],
+        "initDate": [{ type: Input },],
+        "selectionDone": [{ type: Output },],
+        "update": [{ type: Output },],
+        "activeDateChange": [{ type: Output },],
+        "activeDate": [{ type: Input },],
+    };
+    return DatePickerInnerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var DatepickerConfig = /** @class */ (function () {
+    function DatepickerConfig() {
+        this.locale = 'en';
+        this.datepickerMode = 'day';
+        this.startingDay = 0;
+        this.yearRange = 20;
+        this.minMode = 'day';
+        this.maxMode = 'year';
+        this.showWeeks = true;
+        this.formatDay = 'DD';
+        this.formatMonth = 'MMMM';
+        this.formatYear = 'YYYY';
+        this.formatDayHeader = 'dd';
+        this.formatDayTitle = 'MMMM YYYY';
+        this.formatMonthTitle = 'YYYY';
+        this.onlyCurrentMonth = false;
+        this.monthColLimit = 3;
+        this.yearColLimit = 5;
+        this.shortcutPropagation = false;
+    }
+    DatepickerConfig.decorators = [
+        { type: Injectable }
+    ];
+    return DatepickerConfig;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var /** @type {?} */ DATEPICKER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(function () { return DatePickerComponent; }),
+    multi: true
+};
+var DatePickerComponent = /** @class */ (function () {
+    function DatePickerComponent(config) {
+        /**
+         * sets datepicker mode, supports: `day`, `month`, `year`
+         */
+        this.datepickerMode = 'day';
+        /**
+         * if false week numbers will be hidden
+         */
+        this.showWeeks = true;
+        this.selectionDone = new EventEmitter(undefined);
+        /**
+         * callback to invoke when the activeDate is changed.
+         */
+        this.activeDateChange = new EventEmitter(undefined);
+        /* tslint:disable-next-line: no-any*/
+        this.onChange = Function.prototype;
+        /* tslint:disable-next-line: no-any*/
+        this.onTouched = Function.prototype;
+        this._now = new Date();
+        this.config = config;
+        this.configureOptions();
+    }
+    Object.defineProperty(DatePickerComponent.prototype, "activeDate", {
+        get: /**
+         * currently active date
+         * @return {?}
+         */
+        function () {
+            return this._activeDate || this._now;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._activeDate = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    DatePickerComponent.prototype.configureOptions = /**
+     * @return {?}
+     */
+    function () {
+        Object.assign(this, this.config);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    DatePickerComponent.prototype.onUpdate = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.activeDate = event;
+        this.onChange(event);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    DatePickerComponent.prototype.onSelectionDone = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.selectionDone.emit(event);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    DatePickerComponent.prototype.onActiveDateChange = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.activeDateChange.emit(event);
+    };
+    // todo: support null value
+    /* tslint:disable-next-line: no-any*/
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    DatePickerComponent.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        if (this._datePicker.compare(value, this._activeDate) === 0) {
+            return;
+        }
+        if (value && value instanceof Date) {
+            this.activeDate = value;
+            this._datePicker.select(value, false);
+            return;
+        }
+        this.activeDate = value ? new Date(value) : void 0;
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    DatePickerComponent.prototype.registerOnChange = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this.onChange = fn;
+    };
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    DatePickerComponent.prototype.registerOnTouched = /**
+     * @param {?} fn
+     * @return {?}
+     */
+    function (fn) {
+        this.onTouched = fn;
+    };
+    DatePickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'datepicker',
+                    template: "\n    <datepicker-inner [activeDate]=\"activeDate\"\n                      (update)=\"onUpdate($event)\"\n                      [locale]=\"config.locale\"\n                      [datepickerMode]=\"datepickerMode\"\n                      [initDate]=\"initDate\"\n                      [minDate]=\"minDate\"\n                      [maxDate]=\"maxDate\"\n                      [minMode]=\"minMode\"\n                      [maxMode]=\"maxMode\"\n                      [showWeeks]=\"showWeeks\"\n                      [formatDay]=\"formatDay\"\n                      [formatMonth]=\"formatMonth\"\n                      [formatYear]=\"formatYear\"\n                      [formatDayHeader]=\"formatDayHeader\"\n                      [formatDayTitle]=\"formatDayTitle\"\n                      [formatMonthTitle]=\"formatMonthTitle\"\n                      [startingDay]=\"startingDay\"\n                      [yearRange]=\"yearRange\"\n                      [customClass]=\"customClass\"\n                      [dateDisabled]=\"dateDisabled\"\n                      [dayDisabled]=\"dayDisabled\"\n                      [onlyCurrentMonth]=\"onlyCurrentMonth\"\n                      [shortcutPropagation]=\"shortcutPropagation\"\n                      [monthColLimit]=\"monthColLimit\"\n                      [yearColLimit]=\"yearColLimit\"\n                      (selectionDone)=\"onSelectionDone($event)\"\n                      (activeDateChange)=\"onActiveDateChange($event)\">\n      <daypicker tabindex=\"0\"></daypicker>\n      <monthpicker tabindex=\"0\"></monthpicker>\n      <yearpicker tabindex=\"0\"></yearpicker>\n    </datepicker-inner>\n    ",
+                    providers: [DATEPICKER_CONTROL_VALUE_ACCESSOR]
+                }] }
+    ];
+    /** @nocollapse */
+    DatePickerComponent.ctorParameters = function () { return [
+        { type: DatepickerConfig, },
+    ]; };
+    DatePickerComponent.propDecorators = {
+        "datepickerMode": [{ type: Input },],
+        "initDate": [{ type: Input },],
+        "minDate": [{ type: Input },],
+        "maxDate": [{ type: Input },],
+        "minMode": [{ type: Input },],
+        "maxMode": [{ type: Input },],
+        "showWeeks": [{ type: Input },],
+        "formatDay": [{ type: Input },],
+        "formatMonth": [{ type: Input },],
+        "formatYear": [{ type: Input },],
+        "formatDayHeader": [{ type: Input },],
+        "formatDayTitle": [{ type: Input },],
+        "formatMonthTitle": [{ type: Input },],
+        "startingDay": [{ type: Input },],
+        "yearRange": [{ type: Input },],
+        "onlyCurrentMonth": [{ type: Input },],
+        "shortcutPropagation": [{ type: Input },],
+        "monthColLimit": [{ type: Input },],
+        "yearColLimit": [{ type: Input },],
+        "customClass": [{ type: Input },],
+        "dateDisabled": [{ type: Input },],
+        "dayDisabled": [{ type: Input },],
+        "activeDate": [{ type: Input },],
+        "selectionDone": [{ type: Output },],
+        "activeDateChange": [{ type: Output },],
+        "_datePicker": [{ type: ViewChild, args: [DatePickerInnerComponent,] },],
+    };
+    return DatePickerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var DayPickerComponent = /** @class */ (function () {
+    function DayPickerComponent(datePicker) {
+        this.labels = [];
+        this.rows = [];
+        this.weekNumbers = [];
+        this.datePicker = datePicker;
+    }
+    Object.defineProperty(DayPickerComponent.prototype, "isBs4", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /*protected getDaysInMonth(year:number, month:number) {
+     return ((month === 1) && (year % 4 === 0) &&
+     ((year % 100 !== 0) || (year % 400 === 0))) ? 29 : DAYS_IN_MONTH[month];
+     }*/
+    /**
+     * @return {?}
+     */
+    DayPickerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ self = this;
+        this.datePicker.stepDay = { months: 1 };
+        this.datePicker.setRefreshViewHandler(function () {
+            var /** @type {?} */ year = this.activeDate.getFullYear();
+            var /** @type {?} */ month = this.activeDate.getMonth();
+            var /** @type {?} */ firstDayOfMonth = new Date(year, month, 1);
+            var /** @type {?} */ difference = this.startingDay - firstDayOfMonth.getDay();
+            var /** @type {?} */ numDisplayedFromPreviousMonth = difference > 0 ? 7 - difference : -difference;
+            var /** @type {?} */ firstDate = new Date(firstDayOfMonth.getTime());
+            if (numDisplayedFromPreviousMonth > 0) {
+                firstDate.setDate(-numDisplayedFromPreviousMonth + 1);
+            }
+            // 42 is the number of days on a six-week calendar
+            var /** @type {?} */ _days = self.getDates(firstDate, 42);
+            var /** @type {?} */ days = [];
+            for (var /** @type {?} */ i = 0; i < 42; i++) {
+                var /** @type {?} */ _dateObject = this.createDateObject(_days[i], this.formatDay);
+                _dateObject.secondary = _days[i].getMonth() !== month;
+                _dateObject.uid = this.uniqueId + '-' + i;
+                days[i] = _dateObject;
+            }
+            self.labels = [];
+            for (var /** @type {?} */ j = 0; j < 7; j++) {
+                self.labels[j] = {};
+                self.labels[j].abbr = this.dateFilter(days[j].date, this.formatDayHeader);
+                self.labels[j].full = this.dateFilter(days[j].date, 'EEEE');
+            }
+            self.title = this.dateFilter(this.activeDate, this.formatDayTitle);
+            self.rows = this.split(days, 7);
+            if (this.showWeeks) {
+                self.weekNumbers = [];
+                var /** @type {?} */ thursdayIndex = (4 + 7 - this.startingDay) % 7;
+                var /** @type {?} */ numWeeks = self.rows.length;
+                for (var /** @type {?} */ curWeek = 0; curWeek < numWeeks; curWeek++) {
+                    self.weekNumbers.push(self.getISO8601WeekNumber(self.rows[curWeek][thursdayIndex].date));
+                }
+            }
+        }, 'day');
+        this.datePicker.setCompareHandler(function (date1, date2) {
+            var /** @type {?} */ d1 = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate());
+            var /** @type {?} */ d2 = new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+            return d1.getTime() - d2.getTime();
+        }, 'day');
+        this.datePicker.refreshView();
+    };
+    /**
+     * @param {?} startDate
+     * @param {?} n
+     * @return {?}
+     */
+    DayPickerComponent.prototype.getDates = /**
+     * @param {?} startDate
+     * @param {?} n
+     * @return {?}
+     */
+    function (startDate, n) {
+        var /** @type {?} */ dates = new Array(n);
+        var /** @type {?} */ current = new Date(startDate.getTime());
+        var /** @type {?} */ i = 0;
+        var /** @type {?} */ date;
+        while (i < n) {
+            date = new Date(current.getTime());
+            date = this.datePicker.fixTimeZone(date);
+            dates[i++] = date;
+            current = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1);
+        }
+        return dates;
+    };
+    /**
+     * @param {?} date
+     * @return {?}
+     */
+    DayPickerComponent.prototype.getISO8601WeekNumber = /**
+     * @param {?} date
+     * @return {?}
+     */
+    function (date) {
+        var /** @type {?} */ checkDate = new Date(date.getTime());
+        // Thursday
+        checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
+        var /** @type {?} */ time = checkDate.getTime();
+        // Compare with Jan 1
+        checkDate.setMonth(0);
+        checkDate.setDate(1);
+        return (Math.floor(Math.round((time - checkDate.getTime()) / 86400000) / 7) + 1);
+    };
+    DayPickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'daypicker',
+                    template: "\n<table *ngIf=\"datePicker.datepickerMode === 'day'\" role=\"grid\" [attr.aria-labelledby]=\"datePicker.uniqueId + '-title'\" aria-activedescendant=\"activeDateId\">\n  <thead>\n    <tr>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">\u2039</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">&lt;</button>\n      </th>\n      <th [attr.colspan]=\"5 + (datePicker.showWeeks ? 1 : 0)\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-secondary btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">\u203A</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">&gt;\n        </button>\n      </th>\n    </tr>\n    <tr>\n      <th *ngIf=\"datePicker.showWeeks\"></th>\n      <th *ngFor=\"let labelz of labels\" class=\"text-center\">\n        <small aria-label=\"labelz.full\"><b>{{ labelz.abbr }}</b></small>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <ng-template ngFor [ngForOf]=\"rows\" let-rowz=\"$implicit\" let-index=\"index\">\n      <tr *ngIf=\"!(datePicker.onlyCurrentMonth && rowz[0].secondary && rowz[6].secondary)\">\n        <td *ngIf=\"datePicker.showWeeks\" class=\"h6\" class=\"text-center\">\n          <em>{{ weekNumbers[index] }}</em>\n        </td>\n        <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [id]=\"dtz.uid\">\n          <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-sm {{dtz.customClass}}\"\n                  *ngIf=\"!(datePicker.onlyCurrentMonth && dtz.secondary)\"\n                  [ngClass]=\"{'btn-secondary': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected, disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz), 'btn-default': !isBs4}\"\n                  [disabled]=\"dtz.disabled\"\n                  (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n            <span [ngClass]=\"{'text-muted': dtz.secondary || dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n          </button>\n        </td>\n      </tr>\n    </ng-template>\n  </tbody>\n</table>\n  ",
+                    styles: ["\n    :host .btn-secondary {\n      color: #292b2c;\n      background-color: #fff;\n      border-color: #ccc;\n    }\n    :host .btn-info .text-muted {\n      color: #292b2c !important;\n    }\n  "]
+                }] }
+    ];
+    // todo: key events implementation
+    /** @nocollapse */
+    DayPickerComponent.ctorParameters = function () { return [
+        { type: DatePickerInnerComponent, },
+    ]; };
+    return DayPickerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var MonthPickerComponent = /** @class */ (function () {
+    function MonthPickerComponent(datePicker) {
+        this.rows = [];
+        this.datePicker = datePicker;
+    }
+    Object.defineProperty(MonthPickerComponent.prototype, "isBs4", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    MonthPickerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ self = this;
+        this.datePicker.stepMonth = { years: 1 };
+        this.datePicker.setRefreshViewHandler(function () {
+            var /** @type {?} */ months = new Array(12);
+            var /** @type {?} */ year = this.activeDate.getFullYear();
+            var /** @type {?} */ date;
+            for (var /** @type {?} */ i = 0; i < 12; i++) {
+                date = new Date(year, i, 1);
+                date = this.fixTimeZone(date);
+                months[i] = this.createDateObject(date, this.formatMonth);
+                months[i].uid = this.uniqueId + '-' + i;
+            }
+            self.title = this.dateFilter(this.activeDate, this.formatMonthTitle);
+            self.rows = this.split(months, self.datePicker.monthColLimit);
+        }, 'month');
+        this.datePicker.setCompareHandler(function (date1, date2) {
+            var /** @type {?} */ d1 = new Date(date1.getFullYear(), date1.getMonth());
+            var /** @type {?} */ d2 = new Date(date2.getFullYear(), date2.getMonth());
+            return d1.getTime() - d2.getTime();
+        }, 'month');
+        this.datePicker.refreshView();
+    };
+    MonthPickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'monthpicker',
+                    template: "\n<table *ngIf=\"datePicker.datepickerMode==='month'\" role=\"grid\">\n  <thead>\n    <tr>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\" tabindex=\"-1\">\u2039</button></th>\n      <th [attr.colspan]=\"((datePicker.monthColLimit - 2) <= 0) ? 1 : datePicker.monthColLimit - 2\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong> \n        </button>\n      </th>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\" tabindex=\"-1\">\u203A</button>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr *ngFor=\"let rowz of rows\">\n      <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [attr.id]=\"dtz.uid\" [ngClass]=\"dtz.customClass\">\n        <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-default\"\n                [ngClass]=\"{'btn-link': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected || (isBs4 && !dtz.selected && datePicker.isActive(dtz)), disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz)}\"\n                [disabled]=\"dtz.disabled\"\n                (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n          <span [ngClass]=\"{'text-success': isBs4 && dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n        </button>\n      </td>\n    </tr>\n  </tbody>\n</table>\n  ",
+                    styles: ["\n    :host .btn-info .text-success {\n      color: #fff !important;\n    }\n  "]
+                }] }
+    ];
+    // todo: key events implementation
+    /** @nocollapse */
+    MonthPickerComponent.ctorParameters = function () { return [
+        { type: DatePickerInnerComponent, },
+    ]; };
+    return MonthPickerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var YearPickerComponent = /** @class */ (function () {
+    function YearPickerComponent(datePicker) {
+        this.rows = [];
+        this.datePicker = datePicker;
+    }
+    Object.defineProperty(YearPickerComponent.prototype, "isBs4", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    YearPickerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ self = this;
+        this.datePicker.stepYear = { years: this.datePicker.yearRange };
+        this.datePicker.setRefreshViewHandler(function () {
+            var /** @type {?} */ years = new Array(this.yearRange);
+            var /** @type {?} */ date;
+            var /** @type {?} */ start = self.getStartingYear(this.activeDate.getFullYear());
+            for (var /** @type {?} */ i = 0; i < this.yearRange; i++) {
+                date = new Date(start + i, 0, 1);
+                date = this.fixTimeZone(date);
+                years[i] = this.createDateObject(date, this.formatYear);
+                years[i].uid = this.uniqueId + '-' + i;
+            }
+            self.title = [years[0].label, years[this.yearRange - 1].label].join(' - ');
+            self.rows = this.split(years, self.datePicker.yearColLimit);
+        }, 'year');
+        this.datePicker.setCompareHandler(function (date1, date2) {
+            return date1.getFullYear() - date2.getFullYear();
+        }, 'year');
+        this.datePicker.refreshView();
+    };
+    /**
+     * @param {?} year
+     * @return {?}
+     */
+    YearPickerComponent.prototype.getStartingYear = /**
+     * @param {?} year
+     * @return {?}
+     */
+    function (year) {
+        // todo: parseInt
+        return ((year - 1) / this.datePicker.yearRange * this.datePicker.yearRange + 1);
+    };
+    YearPickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'yearpicker',
+                    template: "\n<table *ngIf=\"datePicker.datepickerMode==='year'\" role=\"grid\">\n  <thead>\n    <tr>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\" tabindex=\"-1\">\u2039</button>\n      </th>\n      <th [attr.colspan]=\"((datePicker.yearColLimit - 2) <= 0) ? 1 : datePicker.yearColLimit - 2\">\n        <button [id]=\"datePicker.uniqueId + '-title'\" role=\"heading\"\n                type=\"button\" class=\"btn btn-default btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\" tabindex=\"-1\">\u203A</button>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr *ngFor=\"let rowz of rows\">\n      <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [attr.id]=\"dtz.uid\">\n        <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-default\"\n                [ngClass]=\"{'btn-link': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected || (isBs4 && !dtz.selected && datePicker.isActive(dtz)), disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz)}\"\n                [disabled]=\"dtz.disabled\"\n                (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n          <span [ngClass]=\"{'text-success': isBs4 && dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n        </button>\n      </td>\n    </tr>\n  </tbody>\n</table>\n  ",
+                    styles: ["\n    :host .btn-info .text-success {\n      color: #fff !important;\n    }\n  "]
+                }] }
+    ];
+    /** @nocollapse */
+    YearPickerComponent.ctorParameters = function () { return [
+        { type: DatePickerInnerComponent, },
+    ]; };
+    return YearPickerComponent;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var DatepickerModule = /** @class */ (function () {
+    function DatepickerModule() {
+    }
+    /**
+     * @return {?}
+     */
+    DatepickerModule.forRoot = /**
+     * @return {?}
+     */
+    function () {
+        return { ngModule: DatepickerModule, providers: [DatepickerConfig] };
+    };
+    DatepickerModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [CommonModule, FormsModule],
+                    declarations: [
+                        DatePickerComponent,
+                        DatePickerInnerComponent,
+                        DayPickerComponent,
+                        MonthPickerComponent,
+                        YearPickerComponent
+                    ],
+                    exports: [
+                        DatePickerComponent,
+                        DatePickerInnerComponent,
+                        DayPickerComponent,
+                        MonthPickerComponent,
+                        YearPickerComponent
+                    ],
+                    entryComponents: [DatePickerComponent]
+                },] }
+    ];
+    return DatepickerModule;
+}());
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+export { BsDatepickerConfig, BsDatepickerDirective, BsDatepickerModule, BsDaterangepickerConfig, BsDaterangepickerDirective, BsLocaleService, DateFormatter, DatePickerComponent, DatepickerConfig, DatepickerModule, DayPickerComponent, MonthPickerComponent, YearPickerComponent, BsDatepickerAbstractComponent as ɵl, BsDatepickerInputDirective as ɵq, BsDaterangepickerInputDirective as ɵr, DatePickerInnerComponent as ɵs, DATEPICKER_CONTROL_VALUE_ACCESSOR as ɵa, BsDatepickerActions as ɵo, BsDatepickerEffects as ɵn, BsDatepickerStore as ɵm, BsCalendarLayoutComponent as ɵf, BsCurrentDateViewComponent as ɵc, BsCustomDatesViewComponent as ɵj, BsDatepickerContainerComponent as ɵk, BsDatepickerDayDecoratorComponent as ɵb, BsDatepickerNavigationViewComponent as ɵd, BsDaterangepickerContainerComponent as ɵp, BsDaysCalendarViewComponent as ɵg, BsMonthCalendarViewComponent as ɵh, BsTimepickerViewComponent as ɵe, BsYearsCalendarViewComponent as ɵi };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-datepicker.js.map","sources":["ng://ngx-bootstrap/datepicker/bs-datepicker.config.ts","ng://ngx-bootstrap/datepicker/base/bs-datepicker-container.ts","ng://ngx-bootstrap/datepicker/reducer/bs-datepicker.actions.ts","ng://ngx-bootstrap/datepicker/bs-locale.service.ts","ng://ngx-bootstrap/datepicker/reducer/bs-datepicker.effects.ts","ng://ngx-bootstrap/datepicker/reducer/_defaults.ts","ng://ngx-bootstrap/datepicker/reducer/bs-datepicker.state.ts","ng://ngx-bootstrap/datepicker/utils/bs-calendar-utils.ts","ng://ngx-bootstrap/datepicker/utils/matrix-utils.ts","ng://ngx-bootstrap/datepicker/engine/calc-days-calendar.ts","ng://ngx-bootstrap/datepicker/engine/format-days-calendar.ts","ng://ngx-bootstrap/datepicker/engine/flag-days-calendar.ts","ng://ngx-bootstrap/datepicker/engine/view-mode.ts","ng://ngx-bootstrap/datepicker/engine/format-months-calendar.ts","ng://ngx-bootstrap/datepicker/engine/flag-months-calendar.ts","ng://ngx-bootstrap/datepicker/engine/format-years-calendar.ts","ng://ngx-bootstrap/datepicker/engine/flag-years-calendar.ts","ng://ngx-bootstrap/datepicker/reducer/bs-datepicker.reducer.ts","ng://ngx-bootstrap/datepicker/reducer/bs-datepicker.store.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-datepicker-container.component.ts","ng://ngx-bootstrap/datepicker/bs-datepicker.component.ts","ng://ngx-bootstrap/datepicker/bs-datepicker-input.directive.ts","ng://ngx-bootstrap/datepicker/bs-daterangepicker.config.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-daterangepicker-container.component.ts","ng://ngx-bootstrap/datepicker/bs-daterangepicker.component.ts","ng://ngx-bootstrap/datepicker/bs-daterangepicker-input.directive.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-calendar-layout.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-current-date-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-custom-dates-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-datepicker-day-decorator.directive.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-datepicker-navigation-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-days-calendar-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-months-calendar-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-timepicker-view.component.ts","ng://ngx-bootstrap/datepicker/themes/bs/bs-years-calendar-view.component.ts","ng://ngx-bootstrap/datepicker/bs-datepicker.module.ts","ng://ngx-bootstrap/datepicker/date-formatter.ts","ng://ngx-bootstrap/datepicker/datepicker-inner.component.ts","ng://ngx-bootstrap/datepicker/datepicker.config.ts","ng://ngx-bootstrap/datepicker/datepicker.component.ts","ng://ngx-bootstrap/datepicker/daypicker.component.ts","ng://ngx-bootstrap/datepicker/monthpicker.component.ts","ng://ngx-bootstrap/datepicker/yearpicker.component.ts","ng://ngx-bootstrap/datepicker/datepicker.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  DatepickerRenderOptions,\n  BsDatepickerViewMode\n} from './models';\n\n\n/**\n * For date range picker there are `BsDaterangepickerConfig` which inherits all properties,\n * except `displayMonths`, for range picker it default to `2`\n */\n@Injectable()\nexport class BsDatepickerConfig implements DatepickerRenderOptions {\n  value?: Date | Date[];\n  isDisabled?: boolean;\n  /**\n   * Default min date for all date/range pickers\n   */\n  minDate?: Date;\n  /**\n   * Default max date for all date/range pickers\n   */\n  maxDate?: Date;\n\n  daysDisabled?: number[];\n  /**\n   * Makes dates from other months active\n   */\n  selectFromOtherMonth?: boolean;\n\n  /**\n   * Add class to current day\n   */\n  customTodayClass?: string;\n\n  /**\n   * Defaut mode for all date pickers\n   */\n  minMode?: BsDatepickerViewMode;\n\n  /** CSS class which will be applied to datepicker container,\n   * usually used to set color theme\n   */\n  containerClass = 'theme-green';\n\n  // DatepickerRenderOptions\n  displayMonths = 1;\n  /**\n   * Allows to hide week numbers in datepicker\n   */\n  showWeekNumbers = true;\n\n  dateInputFormat = 'L';\n  // range picker\n  rangeSeparator = ' - ';\n  /**\n   * Date format for date range input field\n   */\n  rangeInputFormat = 'L';\n\n  // DatepickerFormatOptions\n  monthTitle = 'MMMM';\n  yearTitle = 'YYYY';\n  dayLabel = 'D';\n  monthLabel = 'MMMM';\n  yearLabel = 'YYYY';\n  weekNumbers = 'w';\n}\n","// datepicker container component\n/* tslint:disable:no-empty */\nimport { BsCustomDates } from '../themes/bs/bs-custom-dates-view.component';\nimport { BsDatepickerEffects } from '../reducer/bs-datepicker.effects';\nimport { Observable } from 'rxjs';\nimport {\n  BsDatepickerViewMode,\n  BsNavigationEvent,\n  CalendarCellViewModel,\n  CellHoverEvent,\n  DatepickerRenderOptions,\n  DaysCalendarViewModel,\n  DayViewModel,\n  MonthsCalendarViewModel,\n  YearsCalendarViewModel\n} from '../models';\n\nexport abstract class BsDatepickerAbstractComponent {\n  containerClass: string;\n  isOtherMonthsActive: boolean;\n\n  _effects: BsDatepickerEffects;\n  _customRangesFish: BsCustomDates[] = [];\n\n  set minDate(value: Date) {\n    this._effects.setMinDate(value);\n  }\n\n  set maxDate(value: Date) {\n    this._effects.setMaxDate(value);\n  }\n  set daysDisabled(value: number[]) {\n    this._effects.setDaysDisabled(value);\n  }\n\n  set isDisabled(value: boolean) {\n    this._effects.setDisabled(value);\n  }\n\n  viewMode: Observable<BsDatepickerViewMode>;\n  daysCalendar: Observable<DaysCalendarViewModel[]>;\n  monthsCalendar: Observable<MonthsCalendarViewModel[]>;\n  yearsCalendar: Observable<YearsCalendarViewModel[]>;\n  options: Observable<DatepickerRenderOptions>;\n\n  setViewMode(event: BsDatepickerViewMode): void {}\n\n  navigateTo(event: BsNavigationEvent): void {}\n\n  dayHoverHandler(event: CellHoverEvent): void {}\n\n  monthHoverHandler(event: CellHoverEvent): void {}\n\n  yearHoverHandler(event: CellHoverEvent): void {}\n\n  daySelectHandler(day: DayViewModel): void {}\n\n  monthSelectHandler(event: CalendarCellViewModel): void {}\n\n  yearSelectHandler(event: CalendarCellViewModel): void {}\n\n  /* tslint:disable-next-line: no-any */\n  _stopPropagation(event: any): void {\n    event.stopPropagation();\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { TimeUnit } from 'ngx-bootstrap/chronos';\nimport { Action } from 'ngx-bootstrap/mini-ngrx';\nimport {\n  BsDatepickerViewMode,\n  BsViewNavigationEvent,\n  CellHoverEvent,\n  DatepickerRenderOptions\n} from '../models';\n\n@Injectable()\nexport class BsDatepickerActions {\n  static readonly CALCULATE = '[datepicker] calculate dates matrix';\n  static readonly FORMAT = '[datepicker] format datepicker values';\n  static readonly FLAG = '[datepicker] set flags';\n  static readonly SELECT = '[datepicker] select date';\n  static readonly NAVIGATE_OFFSET = '[datepicker] shift view date';\n  static readonly NAVIGATE_TO = '[datepicker] change view date';\n  static readonly SET_OPTIONS = '[datepicker] update render options';\n  static readonly HOVER = '[datepicker] hover date';\n  static readonly CHANGE_VIEWMODE = '[datepicker] switch view mode';\n\n  static readonly SET_MIN_DATE = '[datepicker] set min date';\n  static readonly SET_MAX_DATE = '[datepicker] set max date';\n  static readonly SET_DAYSDISABLED = '[datepicker] set days disabled';\n  static readonly SET_IS_DISABLED = '[datepicker] set is disabled';\n\n  static readonly SET_LOCALE = '[datepicker] set datepicker locale';\n\n  static readonly SELECT_RANGE = '[daterangepicker] select dates range';\n\n  calculate(): Action {\n    return { type: BsDatepickerActions.CALCULATE };\n  }\n\n  format(): Action {\n    return { type: BsDatepickerActions.FORMAT };\n  }\n\n  flag(): Action {\n    return { type: BsDatepickerActions.FLAG };\n  }\n\n  select(date: Date): Action {\n    return {\n      type: BsDatepickerActions.SELECT,\n      payload: date\n    };\n  }\n\n  changeViewMode(event: BsDatepickerViewMode): Action {\n    return {\n      type: BsDatepickerActions.CHANGE_VIEWMODE,\n      payload: event\n    };\n  }\n\n  navigateTo(event: BsViewNavigationEvent): Action {\n    return {\n      type: BsDatepickerActions.NAVIGATE_TO,\n      payload: event\n    };\n  }\n\n  navigateStep(step: TimeUnit): Action {\n    return {\n      type: BsDatepickerActions.NAVIGATE_OFFSET,\n      payload: step\n    };\n  }\n\n  setOptions(options: DatepickerRenderOptions): Action {\n    return {\n      type: BsDatepickerActions.SET_OPTIONS,\n      payload: options\n    };\n  }\n\n  // date range picker\n  selectRange(value: Date[]): Action {\n    return {\n      type: BsDatepickerActions.SELECT_RANGE,\n      payload: value\n    };\n  }\n\n  hoverDay(event: CellHoverEvent): Action {\n    return {\n      type: BsDatepickerActions.HOVER,\n      payload: event.isHovered ? event.cell.date : null\n    };\n  }\n\n  minDate(date: Date): Action {\n    return {\n      type: BsDatepickerActions.SET_MIN_DATE,\n      payload: date\n    };\n  }\n\n  maxDate(date: Date): Action {\n    return {\n      type: BsDatepickerActions.SET_MAX_DATE,\n      payload: date\n    };\n  }\n\n  daysDisabled(days: number[]): Action {\n    return {\n      type: BsDatepickerActions.SET_DAYSDISABLED,\n      payload: days\n    };\n  }\n\n  isDisabled(value: boolean): Action {\n    return {\n      type: BsDatepickerActions.SET_IS_DISABLED,\n      payload: value\n    };\n  }\n\n  setLocale(locale: string): Action {\n    return {\n      type: BsDatepickerActions.SET_LOCALE,\n      payload: locale\n    };\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\n\n@Injectable()\nexport class BsLocaleService {\n  private _defaultLocale = 'en';\n  private _locale = new BehaviorSubject<string>(this._defaultLocale);\n  private _localeChange: Observable<string> = this._locale.asObservable();\n\n  get locale(): BehaviorSubject<string> {\n    return this._locale;\n  }\n\n  get localeChange(): Observable<string> {\n    return this._localeChange;\n  }\n\n  get currentLocale(): string {\n    return this._locale.getValue();\n  }\n\n  use(locale: string): void {\n    if (locale === this.currentLocale) {\n      return;\n    }\n\n    this._locale.next(locale);\n  }\n}\n","import { Injectable } from '@angular/core';\n\nimport { Observable, Subscription } from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\n\nimport { getFullYear, getMonth } from 'ngx-bootstrap/chronos';\n\nimport { BsDatepickerAbstractComponent } from '../base/bs-datepicker-container';\nimport { BsDatepickerActions } from './bs-datepicker.actions';\nimport { BsDatepickerConfig } from '../bs-datepicker.config';\nimport { BsDatepickerStore } from './bs-datepicker.store';\nimport { BsLocaleService } from '../bs-locale.service';\n\nimport {\n  BsDatepickerViewMode,\n  BsNavigationEvent,\n  CalendarCellViewModel,\n  CellHoverEvent,\n  DatepickerRenderOptions,\n  DaysCalendarViewModel,\n  DayViewModel,\n  MonthsCalendarViewModel,\n  YearsCalendarViewModel\n} from '../models';\n\n\n@Injectable()\nexport class BsDatepickerEffects {\n  viewMode: Observable<BsDatepickerViewMode>;\n  daysCalendar: Observable<DaysCalendarViewModel[]>;\n  monthsCalendar: Observable<MonthsCalendarViewModel[]>;\n  yearsCalendar: Observable<YearsCalendarViewModel[]>;\n  options: Observable<DatepickerRenderOptions>;\n\n  private _store: BsDatepickerStore;\n  private _subs: Subscription[] = [];\n\n  constructor(private _actions: BsDatepickerActions,\n              private _localeService: BsLocaleService) {}\n\n  init(_bsDatepickerStore: BsDatepickerStore): BsDatepickerEffects {\n    this._store = _bsDatepickerStore;\n\n    return this;\n  }\n\n  /** setters */\n\n  setValue(value: Date): void {\n    this._store.dispatch(this._actions.select(value));\n  }\n\n  setRangeValue(value: Date[]): void {\n    this._store.dispatch(this._actions.selectRange(value));\n  }\n\n  setMinDate(value: Date): BsDatepickerEffects {\n    this._store.dispatch(this._actions.minDate(value));\n\n    return this;\n  }\n\n  setMaxDate(value: Date): BsDatepickerEffects {\n    this._store.dispatch(this._actions.maxDate(value));\n\n    return this;\n  }\n\n  setDaysDisabled(value: number[]) {\n    this._store.dispatch(this._actions.daysDisabled(value));\n\n    return this;\n  }\n\n  setDisabled(value: boolean): BsDatepickerEffects {\n    this._store.dispatch(this._actions.isDisabled(value));\n\n    return this;\n  }\n\n  /* Set rendering options */\n  setOptions(_config: BsDatepickerConfig): BsDatepickerEffects {\n    const _options = Object.assign({locale: this._localeService.currentLocale}, _config);\n    this._store.dispatch(this._actions.setOptions(_options));\n\n    return this;\n  }\n\n  /** view to mode bindings */\n  setBindings(container: BsDatepickerAbstractComponent): BsDatepickerEffects {\n    container.daysCalendar = this._store\n      .select(state => state.flaggedMonths)\n      .pipe(\n        filter(months => !!months)\n      );\n\n    // month calendar\n    container.monthsCalendar = this._store\n      .select(state => state.flaggedMonthsCalendar)\n      .pipe(\n        filter(months => !!months)\n      );\n\n    // year calendar\n    container.yearsCalendar = this._store\n      .select(state => state.yearsCalendarFlagged)\n      .pipe(\n        filter(years => !!years)\n      );\n\n    container.viewMode = this._store.select(state => state.view.mode);\n\n    container.options = this._store\n      .select(state => state.showWeekNumbers)\n      .pipe(\n        map(showWeekNumbers => ({showWeekNumbers}))\n      );\n\n    return this;\n  }\n\n  /** event handlers */\n  setEventHandlers(container: BsDatepickerAbstractComponent): BsDatepickerEffects {\n    container.setViewMode = (event: BsDatepickerViewMode): void => {\n      this._store.dispatch(this._actions.changeViewMode(event));\n    };\n\n    container.navigateTo = (event: BsNavigationEvent): void => {\n      this._store.dispatch(this._actions.navigateStep(event.step));\n    };\n\n    container.dayHoverHandler = (event: CellHoverEvent): void => {\n      const _cell = event.cell as DayViewModel;\n      if (_cell.isOtherMonth || _cell.isDisabled) {\n        return;\n      }\n\n      this._store.dispatch(this._actions.hoverDay(event));\n      _cell.isHovered = event.isHovered;\n    };\n\n    container.monthHoverHandler = (event: CellHoverEvent): void => {\n      event.cell.isHovered = event.isHovered;\n    };\n\n    container.yearHoverHandler = (event: CellHoverEvent): void => {\n      event.cell.isHovered = event.isHovered;\n    };\n\n    container.monthSelectHandler = (event: CalendarCellViewModel): void => {\n      if (event.isDisabled) {\n        return;\n      }\n      this._store.dispatch(\n        this._actions.navigateTo({\n          unit: {\n            month: getMonth(event.date),\n            year: getFullYear(event.date)\n          },\n          viewMode: 'day'\n        })\n      );\n    };\n\n    container.yearSelectHandler = (event: CalendarCellViewModel): void => {\n      if (event.isDisabled) {\n        return;\n      }\n      this._store.dispatch(\n        this._actions.navigateTo({\n          unit: {\n            year: getFullYear(event.date)\n          },\n          viewMode: 'month'\n        })\n      );\n    };\n\n    return this;\n  }\n\n  registerDatepickerSideEffects(): BsDatepickerEffects {\n    this._subs.push(\n      this._store.select(state => state.view).subscribe(view => {\n        this._store.dispatch(this._actions.calculate());\n      })\n    );\n\n    // format calendar values on month model change\n    this._subs.push(\n      this._store\n        .select(state => state.monthsModel)\n        .pipe(\n          filter(monthModel => !!monthModel)\n        )\n        .subscribe(month => this._store.dispatch(this._actions.format()))\n    );\n\n    // flag day values\n    this._subs.push(\n      this._store\n        .select(state => state.formattedMonths)\n        .pipe(\n          filter(month => !!month)\n        )\n        .subscribe(month => this._store.dispatch(this._actions.flag()))\n    );\n\n    // flag day values\n    this._subs.push(\n      this._store\n        .select(state => state.selectedDate)\n        .pipe(\n          filter(selectedDate => !!selectedDate)\n        )\n        .subscribe(selectedDate => this._store.dispatch(this._actions.flag()))\n    );\n\n    // flag for date range picker\n    this._subs.push(\n      this._store\n        .select(state => state.selectedRange)\n        .pipe(\n          filter(selectedRange => !!selectedRange)\n        )\n        .subscribe(selectedRange => this._store.dispatch(this._actions.flag()))\n    );\n\n    // monthsCalendar\n    this._subs.push(\n      this._store\n        .select(state => state.monthsCalendar)\n        .subscribe(() => this._store.dispatch(this._actions.flag()))\n    );\n\n    // years calendar\n    this._subs.push(\n      this._store\n        .select(state => state.yearsCalendarModel)\n        .pipe(\n          filter(state => !!state)\n        )\n        .subscribe(() => this._store.dispatch(this._actions.flag()))\n    );\n\n    // on hover\n    this._subs.push(\n      this._store\n        .select(state => state.hoveredDate)\n        .pipe(\n          filter(hoveredDate => !!hoveredDate)\n        )\n        .subscribe(hoveredDate => this._store.dispatch(this._actions.flag()))\n    );\n\n    // on locale change\n    this._subs.push(\n      this._localeService.localeChange\n        .subscribe(locale => this._store.dispatch(this._actions.setLocale(locale)))\n    );\n\n    return this;\n  }\n\n  destroy(): void {\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n  }\n}\n","import {\n  MonthViewOptions\n} from '../models';\n\nexport const defaultMonthOptions: MonthViewOptions = {\n  width: 7,\n  height: 6\n};\n","import {\n  BsDatepickerViewMode,\n  DatepickerFormatOptions,\n  DatepickerRenderOptions,\n  DaysCalendarModel,\n  DaysCalendarViewModel,\n  MonthsCalendarViewModel,\n  MonthViewOptions,\n  YearsCalendarViewModel\n} from '../models';\nimport { defaultMonthOptions } from './_defaults';\nimport { BsDatepickerConfig } from '../bs-datepicker.config';\n\nexport interface BsDatepickerViewState {\n  date: Date;\n  mode: BsDatepickerViewMode;\n}\n\nexport class BsDatepickerState\n  implements DatepickerRenderOptions, DatepickerFormatOptions {\n  // date picker\n  selectedDate?: Date;\n  // daterange picker\n  selectedRange?: Date[];\n\n  // initial date of calendar, today by default\n  view: BsDatepickerViewState;\n\n  isDisabled?: boolean;\n  // bounds\n  minDate?: Date;\n  maxDate?: Date;\n  daysDisabled?: number[];\n  minMode?: BsDatepickerViewMode;\n\n  hoveredDate?: Date;\n  hoveredMonth?: Date;\n  hoveredYear?: Date;\n\n  // days calendar\n  monthsModel?: DaysCalendarModel[];\n  formattedMonths?: DaysCalendarViewModel[];\n  flaggedMonths?: DaysCalendarViewModel[];\n\n  // months calendar\n  monthsCalendar?: MonthsCalendarViewModel[];\n  flaggedMonthsCalendar?: MonthsCalendarViewModel[];\n\n  // years calendar\n  yearsCalendarModel?: YearsCalendarViewModel[];\n  yearsCalendarFlagged?: YearsCalendarViewModel[];\n\n  // options\n  monthViewOptions: MonthViewOptions;\n\n  // DatepickerRenderOptions\n  showWeekNumbers?: boolean;\n  displayMonths?: number;\n  selectFromOtherMonth?: boolean;\n\n  // DatepickerFormatOptions\n  locale: string;\n\n  monthTitle: string;\n  yearTitle: string;\n\n  dayLabel: string;\n  monthLabel: string;\n  yearLabel: string;\n\n  weekNumbers: string;\n}\n\nconst _initialView: BsDatepickerViewState = { date: new Date(), mode: 'day' };\n\nexport const initialDatepickerState: BsDatepickerState = Object.assign(\n  new BsDatepickerConfig(),\n  {\n    locale: 'en',\n    view: _initialView,\n    selectedRange: [],\n    monthViewOptions: defaultMonthOptions\n  }\n);\n","import {\n  getDay,\n  isFirstDayOfWeek,\n  isAfter,\n  isBefore,\n  shiftDate,\n  endOf,\n  startOf\n} from 'ngx-bootstrap/chronos';\n\nexport function getStartingDayOfCalendar(date: Date,\n                                         options: { firstDayOfWeek?: number }): Date {\n  if (isFirstDayOfWeek(date, options.firstDayOfWeek)) {\n    return date;\n  }\n\n  const weekDay = getDay(date);\n  const offset = calculateDateOffset(weekDay, options.firstDayOfWeek);\n\n  return shiftDate(date, {day: -offset});\n}\n\nexport function calculateDateOffset(weekday: number, startingDayOffset: number): number {\n  if (startingDayOffset === 0) {\n    return weekday;\n  }\n\n  const offset = weekday - startingDayOffset % 7;\n\n  return offset < 0 ? offset + 7 : offset;\n}\n\nexport function isMonthDisabled(date: Date, min: Date, max: Date): boolean {\n  const minBound = min && isBefore(endOf(date, 'month'), min, 'day');\n  const maxBound = max && isAfter(startOf(date, 'month'), max, 'day');\n\n  return minBound || maxBound;\n}\n\nexport function isYearDisabled(date: Date, min: Date, max: Date): boolean {\n  const minBound = min && isBefore(endOf(date, 'year'), min, 'day');\n  const maxBound = max && isAfter(startOf(date, 'year'), max, 'day');\n\n  return minBound || maxBound;\n}\n","import { TimeUnit, shiftDate } from 'ngx-bootstrap/chronos';\n\nexport type CreateMatrixCb<T> = (date: Date) => T;\n\nexport interface MatrixOptions {\n  height: number;\n  width: number;\n  initialDate: Date;\n  shift: TimeUnit;\n}\n\nexport function createMatrix<T>(\n  options: MatrixOptions,\n  fn: CreateMatrixCb<T>\n): T[][] {\n  let prevValue = options.initialDate;\n  const matrix: T[][] = new Array(options.height);\n  for (let i = 0; i < options.height; i++) {\n    matrix[i] = new Array(options.width);\n    for (let j = 0; j < options.width; j++) {\n      matrix[i][j] = fn(prevValue);\n      prevValue = shiftDate(prevValue, options.shift);\n    }\n  }\n\n  return matrix;\n}\n","// user and model input should handle parsing and validating input values\n// should accept some options\n// todo: split out formatting\nimport { DaysCalendarModel, MonthViewOptions } from '../models';\nimport { getFirstDayOfMonth } from 'ngx-bootstrap/chronos';\nimport { getStartingDayOfCalendar } from '../utils/bs-calendar-utils';\nimport { createMatrix } from '../utils/matrix-utils';\n\nexport function calcDaysCalendar(\n  startingDate: Date,\n  options: MonthViewOptions\n): DaysCalendarModel {\n  const firstDay = getFirstDayOfMonth(startingDate);\n  const initialDate = getStartingDayOfCalendar(firstDay, options);\n\n  const matrixOptions = {\n    width: options.width,\n    height: options.height,\n    initialDate,\n    shift: { day: 1 }\n  };\n  const daysMatrix = createMatrix<Date>(matrixOptions, date => date);\n\n  return {\n    daysMatrix,\n    month: firstDay\n  };\n}\n","import {\n  DatepickerFormatOptions,\n  DaysCalendarModel,\n  DaysCalendarViewModel\n} from '../models';\nimport { formatDate, getLocale } from 'ngx-bootstrap/chronos';\n\nexport function formatDaysCalendar(daysCalendar: DaysCalendarModel,\n                                   formatOptions: DatepickerFormatOptions,\n                                   monthIndex: number): DaysCalendarViewModel {\n  return {\n    month: daysCalendar.month,\n    monthTitle: formatDate(\n      daysCalendar.month,\n      formatOptions.monthTitle,\n      formatOptions.locale\n    ),\n    yearTitle: formatDate(\n      daysCalendar.month,\n      formatOptions.yearTitle,\n      formatOptions.locale\n    ),\n    weekNumbers: getWeekNumbers(\n      daysCalendar.daysMatrix,\n      formatOptions.weekNumbers,\n      formatOptions.locale\n    ),\n    weekdays: getShiftedWeekdays(formatOptions.locale),\n    weeks: daysCalendar.daysMatrix.map((week: Date[], weekIndex: number) => ({\n      days: week.map((date: Date, dayIndex: number) => ({\n        date,\n        label: formatDate(date, formatOptions.dayLabel, formatOptions.locale),\n        monthIndex,\n        weekIndex,\n        dayIndex\n      }))\n    }))\n  };\n}\n\nexport function getWeekNumbers(daysMatrix: Date[][],\n                               format: string,\n                               locale: string): string[] {\n  return daysMatrix.map(\n    (days: Date[]) => (days[0] ? formatDate(days[0], format, locale) : '')\n  );\n}\n\nexport function getShiftedWeekdays(locale: string): string[] {\n  const _locale = getLocale(locale);\n  const weekdays = _locale.weekdaysShort() as string[];\n  const firstDayOfWeek = _locale.firstDayOfWeek();\n\n  return [...weekdays.slice(firstDayOfWeek), ...weekdays.slice(0, firstDayOfWeek)];\n}\n","import {\n  DaysCalendarViewModel,\n  DayViewModel,\n  WeekViewModel\n} from '../models';\n\nimport {\n  isAfter,\n  isBefore,\n  isDisabledDay,\n  isSameDay,\n  isSameMonth,\n  shiftDate\n} from 'ngx-bootstrap/chronos';\n\nimport { isMonthDisabled } from '../utils/bs-calendar-utils';\n\nexport interface FlagDaysCalendarOptions {\n  isDisabled: boolean;\n  minDate: Date;\n  maxDate: Date;\n  daysDisabled: number[];\n  hoveredDate: Date;\n  selectedDate: Date;\n  selectedRange: Date[];\n  displayMonths: number;\n  monthIndex: number;\n}\n\nexport function flagDaysCalendar(\n  formattedMonth: DaysCalendarViewModel,\n  options: FlagDaysCalendarOptions\n): DaysCalendarViewModel {\n  formattedMonth.weeks.forEach((week: WeekViewModel) => {\n    /* tslint:disable-next-line: cyclomatic-complexity */\n    week.days.forEach((day: DayViewModel, dayIndex: number) => {\n      // datepicker\n      const isOtherMonth = !isSameMonth(day.date, formattedMonth.month);\n\n      const isHovered =\n        !isOtherMonth && isSameDay(day.date, options.hoveredDate);\n      // date range picker\n      const isSelectionStart =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[0]);\n      const isSelectionEnd =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[1]);\n\n      const isSelected =\n        (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||\n        isSelectionStart ||\n        isSelectionEnd;\n\n      const isInRange =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isDateInRange(day.date, options.selectedRange, options.hoveredDate);\n\n      const isDisabled =\n        options.isDisabled ||\n        isBefore(day.date, options.minDate, 'day') ||\n        isAfter(day.date, options.maxDate, 'day') ||\n        isDisabledDay(day.date, options.daysDisabled);\n\n      const currentDate = new Date();\n      const isToday = !isOtherMonth && isSameDay(day.date, currentDate);\n\n      // decide update or not\n      const newDay = Object.assign({}, day, {\n        isOtherMonth,\n        isHovered,\n        isSelected,\n        isSelectionStart,\n        isSelectionEnd,\n        isInRange,\n        isDisabled,\n        isToday\n      });\n\n      if (\n        day.isOtherMonth !== newDay.isOtherMonth ||\n        day.isHovered !== newDay.isHovered ||\n        day.isSelected !== newDay.isSelected ||\n        day.isSelectionStart !== newDay.isSelectionStart ||\n        day.isSelectionEnd !== newDay.isSelectionEnd ||\n        day.isDisabled !== newDay.isDisabled ||\n        day.isInRange !== newDay.isInRange\n      ) {\n        week.days[dayIndex] = newDay;\n      }\n    });\n  });\n\n  // todo: add check for linked calendars\n  formattedMonth.hideLeftArrow =\n    options.isDisabled ||\n    (options.monthIndex > 0 && options.monthIndex !== options.displayMonths);\n  formattedMonth.hideRightArrow =\n    options.isDisabled ||\n    (options.monthIndex < options.displayMonths &&\n      options.monthIndex + 1 !== options.displayMonths);\n\n  formattedMonth.disableLeftArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: -1 }),\n    options.minDate,\n    options.maxDate\n  );\n  formattedMonth.disableRightArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: 1 }),\n    options.minDate,\n    options.maxDate\n  );\n\n  return formattedMonth;\n}\n\nfunction isDateInRange(\n  date: Date,\n  selectedRange: Date[],\n  hoveredDate: Date\n): boolean {\n  if (!date || !selectedRange[0]) {\n    return false;\n  }\n\n  if (selectedRange[1]) {\n    return date > selectedRange[0] && date <= selectedRange[1];\n  }\n\n  if (hoveredDate) {\n    return date > selectedRange[0] && date <= hoveredDate;\n  }\n\n  return false;\n}\n","import { BsDatepickerViewMode } from '../models';\n\nexport function canSwitchMode(mode: BsDatepickerViewMode, minMode?: BsDatepickerViewMode): boolean {\n  return minMode ? mode >= minMode : true;\n}\n","import {\n  DatepickerFormatOptions,\n  MonthsCalendarViewModel,\n  CalendarCellViewModel\n} from '../models';\nimport { startOf, formatDate } from 'ngx-bootstrap/chronos';\nimport { createMatrix } from '../utils/matrix-utils';\n\nconst height = 4;\nconst width = 3;\nconst shift = { month: 1 };\n\nexport function formatMonthsCalendar(\n  viewDate: Date,\n  formatOptions: DatepickerFormatOptions\n): MonthsCalendarViewModel {\n  const initialDate = startOf(viewDate, 'year');\n  const matrixOptions = { width, height, initialDate, shift };\n  const monthMatrix = createMatrix<\n    CalendarCellViewModel\n  >(matrixOptions, date => ({\n    date,\n    label: formatDate(date, formatOptions.monthLabel, formatOptions.locale)\n  }));\n\n  return {\n    months: monthMatrix,\n    monthTitle: '',\n    yearTitle: formatDate(\n      viewDate,\n      formatOptions.yearTitle,\n      formatOptions.locale\n    )\n  };\n}\n","import { isSameMonth, shiftDate } from 'ngx-bootstrap/chronos';\nimport {\n  MonthsCalendarViewModel,\n  CalendarCellViewModel\n} from '../models';\nimport { isMonthDisabled, isYearDisabled } from '../utils/bs-calendar-utils';\n\nexport interface FlagMonthCalendarOptions {\n  isDisabled: boolean;\n  minDate: Date;\n  maxDate: Date;\n  hoveredMonth: Date;\n  displayMonths: number;\n  monthIndex: number;\n}\n\nexport function flagMonthsCalendar(\n  monthCalendar: MonthsCalendarViewModel,\n  options: FlagMonthCalendarOptions\n): MonthsCalendarViewModel {\n  monthCalendar.months.forEach(\n    (months: CalendarCellViewModel[], rowIndex: number) => {\n      months.forEach((month: CalendarCellViewModel, monthIndex: number) => {\n        const isHovered = isSameMonth(month.date, options.hoveredMonth);\n        const isDisabled =\n          options.isDisabled ||\n          isMonthDisabled(month.date, options.minDate, options.maxDate);\n        const newMonth = Object.assign(/*{},*/ month, {\n          isHovered,\n          isDisabled\n        });\n        if (\n          month.isHovered !== newMonth.isHovered ||\n          month.isDisabled !== newMonth.isDisabled\n        ) {\n          monthCalendar.months[rowIndex][monthIndex] = newMonth;\n        }\n      });\n    }\n  );\n\n  // todo: add check for linked calendars\n  monthCalendar.hideLeftArrow =\n    options.monthIndex > 0 && options.monthIndex !== options.displayMonths;\n  monthCalendar.hideRightArrow =\n    options.monthIndex < options.displayMonths &&\n    options.monthIndex + 1 !== options.displayMonths;\n\n  monthCalendar.disableLeftArrow = isYearDisabled(\n    shiftDate(monthCalendar.months[0][0].date, { year: -1 }),\n    options.minDate,\n    options.maxDate\n  );\n  monthCalendar.disableRightArrow = isYearDisabled(\n    shiftDate(monthCalendar.months[0][0].date, { year: 1 }),\n    options.minDate,\n    options.maxDate\n  );\n\n  return monthCalendar;\n}\n","import {\n  DatepickerFormatOptions,\n  YearsCalendarViewModel,\n  CalendarCellViewModel\n} from '../models';\nimport { shiftDate, formatDate } from 'ngx-bootstrap/chronos';\nimport { createMatrix } from '../utils/matrix-utils';\n\nconst height = 4;\nconst width = 4;\nexport const yearsPerCalendar = height * width;\nconst initialShift = (Math.floor(yearsPerCalendar / 2) - 1) * -1;\nconst shift = { year: 1 };\n\nexport function formatYearsCalendar(\n  viewDate: Date,\n  formatOptions: DatepickerFormatOptions\n): YearsCalendarViewModel {\n  const initialDate = shiftDate(viewDate, { year: initialShift });\n  const matrixOptions = { width, height, initialDate, shift };\n  const yearsMatrix = createMatrix<\n    CalendarCellViewModel\n  >(matrixOptions, date => ({\n    date,\n    label: formatDate(date, formatOptions.yearLabel, formatOptions.locale)\n  }));\n  const yearTitle = formatYearRangeTitle(yearsMatrix, formatOptions);\n\n  return {\n    years: yearsMatrix,\n    monthTitle: '',\n    yearTitle\n  };\n}\n\nfunction formatYearRangeTitle(\n  yearsMatrix: CalendarCellViewModel[][],\n  formatOptions: DatepickerFormatOptions\n): string {\n  const from = formatDate(\n    yearsMatrix[0][0].date,\n    formatOptions.yearTitle,\n    formatOptions.locale\n  );\n  const to = formatDate(\n    yearsMatrix[height - 1][width - 1].date,\n    formatOptions.yearTitle,\n    formatOptions.locale\n  );\n\n  return `${from} - ${to}`;\n}\n","import { isSameYear, shiftDate } from 'ngx-bootstrap/chronos';\nimport { YearsCalendarViewModel, CalendarCellViewModel } from '../models';\nimport { isYearDisabled } from '../utils/bs-calendar-utils';\n\nexport interface FlagYearsCalendarOptions {\n  isDisabled: boolean;\n  minDate: Date;\n  maxDate: Date;\n  hoveredYear: Date;\n  displayMonths: number;\n  yearIndex: number;\n}\n\nexport function flagYearsCalendar(\n  yearsCalendar: YearsCalendarViewModel,\n  options: FlagYearsCalendarOptions\n): YearsCalendarViewModel {\n  yearsCalendar.years.forEach(\n    (years: CalendarCellViewModel[], rowIndex: number) => {\n      years.forEach((year: CalendarCellViewModel, yearIndex: number) => {\n        const isHovered = isSameYear(year.date, options.hoveredYear);\n        const isDisabled =\n          options.isDisabled ||\n          isYearDisabled(year.date, options.minDate, options.maxDate);\n\n        const newMonth = Object.assign(/*{},*/ year, { isHovered, isDisabled });\n        if (\n          year.isHovered !== newMonth.isHovered ||\n          year.isDisabled !== newMonth.isDisabled\n        ) {\n          yearsCalendar.years[rowIndex][yearIndex] = newMonth;\n        }\n      });\n    }\n  );\n\n  // todo: add check for linked calendars\n  yearsCalendar.hideLeftArrow =\n    options.yearIndex > 0 && options.yearIndex !== options.displayMonths;\n  yearsCalendar.hideRightArrow =\n    options.yearIndex < options.displayMonths &&\n    options.yearIndex + 1 !== options.displayMonths;\n\n  yearsCalendar.disableLeftArrow = isYearDisabled(\n    shiftDate(yearsCalendar.years[0][0].date, { year: -1 }),\n    options.minDate,\n    options.maxDate\n  );\n  const i = yearsCalendar.years.length - 1;\n  const j = yearsCalendar.years[i].length - 1;\n  yearsCalendar.disableRightArrow = isYearDisabled(\n    shiftDate(yearsCalendar.years[i][j].date, { year: 1 }),\n    options.minDate,\n    options.maxDate\n  );\n\n  return yearsCalendar;\n}\n","// tslint:disable:max-file-line-count\nimport { BsDatepickerState, initialDatepickerState } from './bs-datepicker.state';\nimport { Action } from 'ngx-bootstrap/mini-ngrx';\nimport { BsDatepickerActions } from './bs-datepicker.actions';\nimport { calcDaysCalendar } from '../engine/calc-days-calendar';\nimport { formatDaysCalendar } from '../engine/format-days-calendar';\nimport { flagDaysCalendar } from '../engine/flag-days-calendar';\nimport {\n  setFullDate,\n  shiftDate,\n  isArray,\n  isDateValid,\n  startOf,\n  getLocale,\n  isAfter,\n  isBefore\n} from 'ngx-bootstrap/chronos';\nimport { canSwitchMode } from '../engine/view-mode';\nimport { formatMonthsCalendar } from '../engine/format-months-calendar';\nimport { flagMonthsCalendar } from '../engine/flag-months-calendar';\nimport { formatYearsCalendar, yearsPerCalendar } from '../engine/format-years-calendar';\nimport { flagYearsCalendar } from '../engine/flag-years-calendar';\nimport { BsViewNavigationEvent, DatepickerFormatOptions, BsDatepickerViewMode } from '../models';\n\n\n/* tslint:disable-next-line: cyclomatic-complexity */\nexport function bsDatepickerReducer(state = initialDatepickerState,\n                                    action: Action): BsDatepickerState {\n  switch (action.type) {\n    case BsDatepickerActions.CALCULATE: {\n      return calculateReducer(state);\n    }\n\n    case BsDatepickerActions.FORMAT: {\n      return formatReducer(state, action);\n    }\n\n    case BsDatepickerActions.FLAG: {\n      return flagReducer(state, action);\n    }\n\n    case BsDatepickerActions.NAVIGATE_OFFSET: {\n      const date = shiftDate(startOf(state.view.date, 'month'), action.payload);\n      const newState = {\n        view: {\n          mode: state.view.mode,\n          date\n        }\n      };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.NAVIGATE_TO: {\n      const payload: BsViewNavigationEvent = action.payload;\n\n      const date = setFullDate(state.view.date, payload.unit);\n      let newState;\n      let mode: BsDatepickerViewMode;\n      if (canSwitchMode(payload.viewMode, state.minMode)) {\n        mode = payload.viewMode;\n        newState = { view: { date, mode } };\n      } else {\n        mode = state.view.mode;\n        newState = { selectedDate: date, view: { date, mode } };\n      }\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.CHANGE_VIEWMODE: {\n      if (!canSwitchMode(action.payload, state.minMode)) {\n        return state;\n      }\n      const date = state.view.date;\n      const mode = action.payload;\n      const newState = { view: { date, mode } };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.HOVER: {\n      return Object.assign({}, state, { hoveredDate: action.payload });\n    }\n\n    case BsDatepickerActions.SELECT: {\n      const newState = {\n        selectedDate: action.payload,\n        view: state.view\n      };\n\n      const mode = state.view.mode;\n      const _date = action.payload || state.view.date;\n      const date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = { mode, date };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.SET_OPTIONS: {\n      const newState = action.payload;\n      // preserve view mode\n      const mode = newState.minMode ? newState.minMode : state.view.mode;\n      const _viewDate = isDateValid(newState.value) && newState.value\n        || isArray(newState.value) && isDateValid(newState.value[0]) && newState.value[0]\n        || state.view.date;\n      const date = getViewDate(_viewDate, newState.minDate, newState.maxDate);\n      newState.view = { mode, date };\n      // update selected value\n      if (newState.value) {\n        // if new value is array we work with date range\n        if (isArray(newState.value)) {\n          newState.selectedRange = newState.value;\n        }\n\n        // if new value is a date -> datepicker\n        if (newState.value instanceof Date) {\n          newState.selectedDate = newState.value;\n        }\n\n        // provided value is not supported :)\n        // need to report it somehow\n      }\n\n      return Object.assign({}, state, newState);\n    }\n\n    // date range picker\n    case BsDatepickerActions.SELECT_RANGE: {\n      const newState = {\n        selectedRange: action.payload,\n        view: state.view\n      };\n\n      const mode = state.view.mode;\n      const _date = action.payload && action.payload[0] || state.view.date;\n      const date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = { mode, date };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.SET_MIN_DATE: {\n      return Object.assign({}, state, {\n        minDate: action.payload\n      });\n    }\n    case BsDatepickerActions.SET_MAX_DATE: {\n      return Object.assign({}, state, {\n        maxDate: action.payload\n      });\n    }\n    case BsDatepickerActions.SET_IS_DISABLED: {\n      return Object.assign({}, state, {\n        isDisabled: action.payload\n      });\n    }\n\n    default:\n      return state;\n  }\n}\n\nfunction calculateReducer(state: BsDatepickerState): BsDatepickerState {\n  // how many calendars\n  const displayMonths = state.displayMonths;\n  // use selected date on initial rendering if set\n  let viewDate = state.view.date;\n\n  if (state.view.mode === 'day') {\n    state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();\n    const monthsModel = new Array(displayMonths);\n    for (let monthIndex = 0; monthIndex < displayMonths; monthIndex++) {\n      // todo: for unlinked calendars it will be harder\n      monthsModel[monthIndex] = calcDaysCalendar(\n        viewDate,\n        state.monthViewOptions\n      );\n      viewDate = shiftDate(viewDate, { month: 1 });\n    }\n\n    return Object.assign({}, state, { monthsModel });\n  }\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 1 });\n    }\n\n    return Object.assign({}, state, { monthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarModel = new Array(displayMonths);\n\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: yearsPerCalendar });\n    }\n\n    return Object.assign({}, state, { yearsCalendarModel });\n  }\n\n  return state;\n}\n\nfunction formatReducer(state: BsDatepickerState,\n                       action: Action): BsDatepickerState {\n  if (state.view.mode === 'day') {\n    const formattedMonths = state.monthsModel.map((month, monthIndex) =>\n      formatDaysCalendar(month, getFormatOptions(state), monthIndex)\n    );\n\n    return Object.assign({}, state, { formattedMonths });\n  }\n\n  // how many calendars\n  const displayMonths = state.displayMonths;\n  // check initial rendering\n  // use selected date on initial rendering if set\n  let viewDate = state.view.date;\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 1 });\n    }\n\n    return Object.assign({}, state, { monthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarModel = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 16 });\n    }\n\n    return Object.assign({}, state, { yearsCalendarModel });\n  }\n\n  return state;\n}\n\nfunction flagReducer(state: BsDatepickerState,\n                     action: Action): BsDatepickerState {\n  if (state.view.mode === 'day') {\n    const flaggedMonths = state.formattedMonths.map(\n      (formattedMonth, monthIndex) =>\n        flagDaysCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          daysDisabled: state.daysDisabled,\n          hoveredDate: state.hoveredDate,\n          selectedDate: state.selectedDate,\n          selectedRange: state.selectedRange,\n          displayMonths: state.displayMonths,\n          monthIndex\n        })\n    );\n\n    return Object.assign({}, state, { flaggedMonths });\n  }\n\n  if (state.view.mode === 'month') {\n    const flaggedMonthsCalendar = state.monthsCalendar.map(\n      (formattedMonth, monthIndex) =>\n        flagMonthsCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          hoveredMonth: state.hoveredMonth,\n          displayMonths: state.displayMonths,\n          monthIndex\n        })\n    );\n\n    return Object.assign({}, state, { flaggedMonthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarFlagged = state.yearsCalendarModel.map(\n      (formattedMonth, yearIndex) =>\n        flagYearsCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          hoveredYear: state.hoveredYear,\n          displayMonths: state.displayMonths,\n          yearIndex\n        })\n    );\n\n    return Object.assign({}, state, { yearsCalendarFlagged });\n  }\n\n  return state;\n}\n\nfunction getFormatOptions(state: BsDatepickerState): DatepickerFormatOptions {\n  return {\n    locale: state.locale,\n\n    monthTitle: state.monthTitle,\n    yearTitle: state.yearTitle,\n\n    dayLabel: state.dayLabel,\n    monthLabel: state.monthLabel,\n    yearLabel: state.yearLabel,\n\n    weekNumbers: state.weekNumbers\n  };\n}\n\n/**\n * if view date is provided (bsValue|ngModel) it should be shown\n * if view date is not provider:\n * if minDate>currentDate (default view value), show minDate\n * if maxDate<currentDate(default view value) show maxDate\n */\nfunction getViewDate(viewDate: Date | Date[], minDate: Date, maxDate: Date) {\n  const _date = Array.isArray(viewDate) ? viewDate[0] : viewDate;\n\n  if (minDate && isAfter(minDate, _date, 'day')) {\n    return minDate;\n  }\n\n  if (maxDate && isBefore(maxDate, _date, 'day')) {\n    return maxDate;\n  }\n\n  return _date;\n}\n","import { Injectable } from '@angular/core';\nimport { MiniStore, Action, MiniState } from 'ngx-bootstrap/mini-ngrx';\nimport { BsDatepickerState, initialDatepickerState } from './bs-datepicker.state';\nimport { BehaviorSubject } from 'rxjs';\nimport { bsDatepickerReducer } from './bs-datepicker.reducer';\n\n@Injectable()\nexport class BsDatepickerStore extends MiniStore<BsDatepickerState> {\n  constructor() {\n    const _dispatcher = new BehaviorSubject<Action>({\n      type: '[datepicker] dispatcher init'\n    });\n    const state = new MiniState<BsDatepickerState>(\n      initialDatepickerState,\n      _dispatcher,\n      bsDatepickerReducer\n    );\n    super(_dispatcher, bsDatepickerReducer, state);\n  }\n}\n","import { Component, EventEmitter, OnDestroy, OnInit } from '@angular/core';\nimport { BsDatepickerAbstractComponent } from '../../base/bs-datepicker-container';\n\nimport { BsDatepickerConfig } from '../../bs-datepicker.config';\nimport { DayViewModel } from '../../models';\nimport { BsDatepickerActions } from '../../reducer/bs-datepicker.actions';\nimport { BsDatepickerEffects } from '../../reducer/bs-datepicker.effects';\nimport { BsDatepickerStore } from '../../reducer/bs-datepicker.store';\nimport { Subscription } from 'rxjs';\n\n@Component({\n  selector: 'bs-datepicker-container',\n  providers: [BsDatepickerStore, BsDatepickerEffects],\n  templateUrl: './bs-datepicker-view.html',\n  host: {\n    '(click)': '_stopPropagation($event)',\n    style: 'position: absolute; display: block;',\n    role: 'dialog',\n    'aria-label': 'calendar'\n  }\n})\nexport class BsDatepickerContainerComponent extends BsDatepickerAbstractComponent\n  implements OnInit, OnDestroy {\n  set value(value: Date) {\n    this._effects.setValue(value);\n  }\n  valueChange: EventEmitter<Date> = new EventEmitter<Date>();\n\n  _subs: Subscription[] = [];\n  constructor(\n    private _config: BsDatepickerConfig,\n    private _store: BsDatepickerStore,\n    private _actions: BsDatepickerActions,\n    _effects: BsDatepickerEffects\n  ) {\n    super();\n    this._effects = _effects;\n  }\n\n  ngOnInit(): void {\n    this.isOtherMonthsActive = this._config.selectFromOtherMonth;\n    this.containerClass = this._config.containerClass;\n    this._effects\n      .init(this._store)\n      // intial state options\n      .setOptions(this._config)\n      // data binding view --> model\n      .setBindings(this)\n      // set event handlers\n      .setEventHandlers(this)\n      .registerDatepickerSideEffects();\n\n    // todo: move it somewhere else\n    // on selected date change\n    this._subs.push(\n      this._store\n        /* tslint:disable-next-line: no-any */\n        .select((state: any) => state.selectedDate)\n        /* tslint:disable-next-line: no-any */\n        .subscribe((date: any) => this.valueChange.emit(date))\n    );\n  }\n\n  daySelectHandler(day: DayViewModel): void {\n    const isDisabled = this.isOtherMonthsActive ? day.isDisabled : (day.isOtherMonth || day.isDisabled);\n\n    if (isDisabled) {\n      return;\n    }\n\n    this._store.dispatch(this._actions.select(day.date));\n  }\n\n  ngOnDestroy(): void {\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n    this._effects.destroy();\n  }\n}\n","import {\n  ComponentRef, Directive, ElementRef, EventEmitter, Input, OnChanges,\n  OnDestroy, OnInit, Output, Renderer2, SimpleChanges, ViewContainerRef\n} from '@angular/core';\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { BsDatepickerContainerComponent } from './themes/bs/bs-datepicker-container.component';\nimport { Subscription } from 'rxjs';\nimport { BsDatepickerConfig } from './bs-datepicker.config';\nimport { BsDatepickerViewMode } from './models';\n\n@Directive({\n  selector: '[bsDatepicker]',\n  exportAs: 'bsDatepicker'\n})\nexport class BsDatepickerDirective implements OnInit, OnDestroy, OnChanges {\n  /**\n   * Placement of a datepicker. Accepts: \"top\", \"bottom\", \"left\", \"right\"\n   */\n  @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'bottom';\n  /**\n   * Specifies events that should trigger. Supports a space separated list of\n   * event names.\n   */\n  @Input() triggers = 'click';\n  /**\n   * Close datepicker on outside click\n   */\n  @Input() outsideClick = true;\n  /**\n   * A selector specifying the element the datepicker should be appended to.\n   * Currently only supports \"body\".\n   */\n  @Input() container = 'body';\n\n  @Input() outsideEsc = true;\n\n  /**\n   * Returns whether or not the datepicker is currently being shown\n   */\n  @Input()\n  get isOpen(): boolean {\n    return this._datepicker.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    if (value) {\n      this.show();\n    } else {\n      this.hide();\n    }\n  }\n\n  /**\n   * Emits an event when the datepicker is shown\n   */\n  /* tslint:disable-next-line: no-any*/\n  @Output() onShown: EventEmitter<any>;\n  /**\n   * Emits an event when the datepicker is hidden\n   */\n  /* tslint:disable-next-line: no-any*/\n  @Output() onHidden: EventEmitter<any>;\n\n  _bsValue: Date;\n  /**\n   * Initial value of datepicker\n   */\n  @Input()\n  set bsValue(value: Date) {\n    if (this._bsValue === value) {\n      return;\n    }\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  /**\n   * Config object for datepicker\n   */\n  @Input() bsConfig: Partial<BsDatepickerConfig>;\n  /**\n   * Indicates whether datepicker's content is enabled or not\n   */\n  @Input() isDisabled: boolean;\n  /**\n   * Minimum date which is available for selection\n   */\n  @Input() minDate: Date;\n  /**\n   * Maximum date which is available for selection\n   */\n  @Input() maxDate: Date;\n\n  /**\n   * Minimum view mode : day, month, or year\n   */\n  @Input() minMode: BsDatepickerViewMode;\n\n  /**\n   * Disable Certain days in the week\n   */\n  @Input() daysDisabled: number[];\n  /**\n   * Emits when datepicker value has been changed\n   */\n  @Output() bsValueChange: EventEmitter<Date> = new EventEmitter();\n\n  protected _subs: Subscription[] = [];\n\n  private _datepicker: ComponentLoader<BsDatepickerContainerComponent>;\n  private _datepickerRef: ComponentRef<BsDatepickerContainerComponent>;\n\n  constructor(public _config: BsDatepickerConfig,\n              _elementRef: ElementRef,\n              _renderer: Renderer2,\n              _viewContainerRef: ViewContainerRef,\n              cis: ComponentLoaderFactory) {\n    // todo: assign only subset of fields\n    Object.assign(this, this._config);\n    this._datepicker = cis.createLoader<BsDatepickerContainerComponent>(\n      _elementRef,\n      _viewContainerRef,\n      _renderer\n    );\n    this.onShown = this._datepicker.onShown;\n    this.onHidden = this._datepicker.onHidden;\n  }\n\n  ngOnInit(): void {\n    this._datepicker.listen({\n      outsideClick: this.outsideClick,\n      outsideEsc: this.outsideEsc,\n      triggers: this.triggers,\n      show: () => this.show()\n    });\n    this.setConfig();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this._datepickerRef || !this._datepickerRef.instance) {\n      return;\n    }\n\n    if (changes.minDate) {\n      this._datepickerRef.instance.minDate = this.minDate;\n    }\n\n    if (changes.maxDate) {\n      this._datepickerRef.instance.maxDate = this.maxDate;\n    }\n\n    if (changes.daysDisabled) {\n      this._datepickerRef.instance.daysDisabled = this.daysDisabled;\n    }\n\n    if (changes.isDisabled) {\n      this._datepickerRef.instance.isDisabled = this.isDisabled;\n    }\n  }\n\n  /**\n   * Opens an elementâs datepicker. This is considered a âmanualâ triggering of\n   * the datepicker.\n   */\n  show(): void {\n    if (this._datepicker.isShown) {\n      return;\n    }\n\n    this.setConfig();\n\n    this._datepickerRef = this._datepicker\n      .provide({provide: BsDatepickerConfig, useValue: this._config})\n      .attach(BsDatepickerContainerComponent)\n      .to(this.container)\n      .position({attachment: this.placement})\n      .show({placement: this.placement});\n\n    // if date changes from external source (model -> view)\n    this._subs.push(\n      this.bsValueChange.subscribe((value: Date) => {\n        this._datepickerRef.instance.value = value;\n      })\n    );\n\n    // if date changes from picker (view -> model)\n    this._subs.push(\n      this._datepickerRef.instance.valueChange.subscribe((value: Date) => {\n        this.bsValue = value;\n        this.hide();\n      })\n    );\n  }\n\n  /**\n   * Closes an elementâs datepicker. This is considered a âmanualâ triggering of\n   * the datepicker.\n   */\n  hide(): void {\n    if (this.isOpen) {\n      this._datepicker.hide();\n    }\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n  }\n\n  /**\n   * Toggles an elementâs datepicker. This is considered a âmanualâ triggering\n   * of the datepicker.\n   */\n  toggle(): void {\n    if (this.isOpen) {\n      return this.hide();\n    }\n\n    this.show();\n  }\n\n  /**\n   * Set config for datepicker\n   */\n  setConfig(): void {\n    this._config = Object.assign({}, this._config, this.bsConfig, {\n      value: this._bsValue,\n      isDisabled: this.isDisabled,\n      minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n      maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,\n      daysDisabled: this.daysDisabled || this.bsConfig && this.bsConfig.daysDisabled,\n      minMode: this.minMode || this.bsConfig && this.bsConfig.minMode\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._datepicker.dispose();\n  }\n}\n","import {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  forwardRef,\n  Host,\n  Provider,\n  Renderer2\n} from '@angular/core';\n\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator\n} from '@angular/forms';\n\nimport {\n  parseDate,\n  formatDate,\n  getLocale,\n  isAfter,\n  isBefore,\n  isDate,\n  isDateValid\n} from 'ngx-bootstrap/chronos';\n\nimport { BsDatepickerDirective } from './bs-datepicker.component';\nimport { BsLocaleService } from './bs-locale.service';\n\nconst BS_DATEPICKER_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDatepickerInputDirective),\n  multi: true\n};\n\nconst BS_DATEPICKER_VALIDATOR: Provider = {\n  provide: NG_VALIDATORS,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDatepickerInputDirective),\n  multi: true\n};\n\n@Directive({\n  selector: `input[bsDatepicker]`,\n  host: {\n    '(change)': 'onChange($event)',\n    '(keyup.esc)': 'hide()',\n    '(blur)': 'onBlur()'\n  },\n  providers: [BS_DATEPICKER_VALUE_ACCESSOR, BS_DATEPICKER_VALIDATOR]\n})\nexport class BsDatepickerInputDirective\n  implements ControlValueAccessor, Validator {\n  private _onChange = Function.prototype;\n  private _onTouched = Function.prototype;\n  /* tslint:disable-next-line: no-unused-variable */\n  private _validatorChange = Function.prototype;\n  private _value: Date;\n\n  constructor(@Host() private _picker: BsDatepickerDirective,\n              private _localeService: BsLocaleService,\n              private _renderer: Renderer2,\n              private _elRef: ElementRef,\n              private changeDetection: ChangeDetectorRef) {\n    // update input value on datepicker value update\n    this._picker.bsValueChange.subscribe((value: Date) => {\n      this._setInputValue(value);\n      if (this._value !== value) {\n        this._value = value;\n        this._onChange(value);\n        this._onTouched();\n      }\n      this.changeDetection.markForCheck();\n    });\n\n    // update input value on locale change\n    this._localeService.localeChange.subscribe(() => {\n      this._setInputValue(this._value);\n    });\n  }\n\n  _setInputValue(value: Date): void {\n    const initialDate = !value ? ''\n      : formatDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);\n\n    this._renderer.setProperty(this._elRef.nativeElement, 'value', initialDate);\n  }\n\n  onChange(event: Event) {\n    /* tslint:disable-next-line: no-any*/\n    this.writeValue((event.target as any).value);\n    this._onChange(this._value);\n    this._onTouched();\n  }\n\n  validate(c: AbstractControl): ValidationErrors | null {\n    const _value: Date | string = c.value;\n\n    /* tslint:disable-next-line: prefer-switch */\n    if (_value === null || _value === undefined || _value === '') {\n      return null;\n    }\n\n    if (isDate(_value)) {\n      const _isDateValid = isDateValid(_value);\n      if (!_isDateValid) {\n        return { bsDate: { invalid: _value } };\n      }\n\n      if (this._picker && this._picker.minDate && isBefore(_value, this._picker.minDate, 'date')) {\n        return { bsDate: { minDate: this._picker.minDate } };\n      }\n\n      if (this._picker && this._picker.maxDate && isAfter(_value, this._picker.maxDate, 'date')) {\n        return { bsDate: { maxDate: this._picker.maxDate } };\n      }\n    }\n  }\n\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorChange = fn;\n  }\n\n  writeValue(value: Date | string) {\n    if (!value) {\n      this._value = null;\n    } else {\n      const _localeKey = this._localeService.currentLocale;\n      const _locale = getLocale(_localeKey);\n      if (!_locale) {\n        throw new Error(\n          `Locale \"${_localeKey}\" is not defined, please add it with \"defineLocale(...)\"`\n        );\n      }\n      this._value = parseDate(value, this._picker._config.dateInputFormat, this._localeService.currentLocale);\n    }\n\n    this._picker.bsValue = this._value;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this._picker.isDisabled = isDisabled;\n    if (isDisabled) {\n      this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');\n\n      return;\n    }\n    this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');\n  }\n\n  registerOnChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  onBlur() {\n    this._onTouched();\n  }\n\n  hide() {\n    this._picker.hide();\n    this._renderer.selectRootElement(this._elRef.nativeElement).blur();\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { BsDatepickerConfig } from './bs-datepicker.config';\n\n@Injectable()\nexport class BsDaterangepickerConfig extends BsDatepickerConfig {\n  // DatepickerRenderOptions\n  displayMonths = 2;\n}\n","import { Component, EventEmitter, OnDestroy, OnInit } from '@angular/core';\nimport { BsDatepickerAbstractComponent } from '../../base/bs-datepicker-container';\nimport { BsDatepickerConfig } from '../../bs-datepicker.config';\nimport { DayViewModel } from '../../models';\nimport { BsDatepickerActions } from '../../reducer/bs-datepicker.actions';\nimport { BsDatepickerEffects } from '../../reducer/bs-datepicker.effects';\nimport { BsDatepickerStore } from '../../reducer/bs-datepicker.store';\nimport { Subscription } from 'rxjs';\n\n@Component({\n  selector: 'bs-daterangepicker-container',\n  providers: [BsDatepickerStore, BsDatepickerEffects],\n  templateUrl: './bs-datepicker-view.html',\n  host: {\n    '(click)': '_stopPropagation($event)',\n    style: 'position: absolute; display: block;',\n    role: 'dialog',\n    'aria-label': 'calendar'\n  }\n})\nexport class BsDaterangepickerContainerComponent extends BsDatepickerAbstractComponent\n  implements OnInit, OnDestroy {\n  set value(value: Date[]) {\n    this._effects.setRangeValue(value);\n  }\n\n  valueChange = new EventEmitter<Date[]>();\n\n  _rangeStack: Date[] = [];\n  _subs: Subscription[] = [];\n  constructor(\n    private _config: BsDatepickerConfig,\n    private _store: BsDatepickerStore,\n    private _actions: BsDatepickerActions,\n    _effects: BsDatepickerEffects\n  ) {\n    super();\n    this._effects = _effects;\n  }\n\n  ngOnInit(): void {\n    this.containerClass = this._config.containerClass;\n    this.isOtherMonthsActive = this._config.selectFromOtherMonth;\n    this._effects\n      .init(this._store)\n      // intial state options\n      // todo: fix this, split configs\n      .setOptions(this._config)\n      // data binding view --> model\n      .setBindings(this)\n      // set event handlers\n      .setEventHandlers(this)\n      .registerDatepickerSideEffects();\n\n    // todo: move it somewhere else\n    // on selected date change\n    this._subs.push(\n      this._store\n        .select(state => state.selectedRange)\n        .subscribe(date => this.valueChange.emit(date))\n    );\n  }\n\n  daySelectHandler(day: DayViewModel): void {\n    const isDisabled = this.isOtherMonthsActive ? day.isDisabled : (day.isOtherMonth || day.isDisabled);\n\n    if (isDisabled) {\n      return;\n    }\n\n    // if only one date is already selected\n    // and user clicks on previous date\n    // start selection from new date\n    // but if new date is after initial one\n    // than finish selection\n    if (this._rangeStack.length === 1) {\n      this._rangeStack =\n        day.date >= this._rangeStack[0]\n          ? [this._rangeStack[0], day.date]\n          : [day.date];\n    }\n\n    if (this._rangeStack.length === 0) {\n      this._rangeStack = [day.date];\n    }\n\n    this._store.dispatch(this._actions.selectRange(this._rangeStack));\n\n    if (this._rangeStack.length === 2) {\n      this._rangeStack = [];\n    }\n  }\n\n  ngOnDestroy(): void {\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n    this._effects.destroy();\n  }\n}\n","import {\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  SimpleChanges,\n  ViewContainerRef\n} from '@angular/core';\nimport { BsDaterangepickerConfig } from './bs-daterangepicker.config';\nimport { BsDaterangepickerContainerComponent } from './themes/bs/bs-daterangepicker-container.component';\nimport { Subscription } from 'rxjs';\nimport { ComponentLoaderFactory, ComponentLoader } from 'ngx-bootstrap/component-loader';\nimport { BsDatepickerConfig } from './bs-datepicker.config';\nimport { filter } from 'rxjs/operators';\n\n@Directive({\n  selector: '[bsDaterangepicker]',\n  exportAs: 'bsDaterangepicker'\n})\nexport class BsDaterangepickerDirective\n  implements OnInit, OnDestroy, OnChanges {\n  /**\n   * Placement of a daterangepicker. Accepts: \"top\", \"bottom\", \"left\", \"right\"\n   */\n  @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'bottom';\n  /**\n   * Specifies events that should trigger. Supports a space separated list of\n   * event names.\n   */\n  @Input() triggers = 'click';\n  /**\n   * Close daterangepicker on outside click\n   */\n  @Input() outsideClick = true;\n  /**\n   * A selector specifying the element the daterangepicker should be appended\n   * to. Currently only supports \"body\".\n   */\n  @Input() container = 'body';\n\n  @Input() outsideEsc = true;\n\n  /**\n   * Returns whether or not the daterangepicker is currently being shown\n   */\n  @Input()\n  get isOpen(): boolean {\n    return this._datepicker.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    if (value) {\n      this.show();\n    } else {\n      this.hide();\n    }\n  }\n\n  /**\n   * Emits an event when the daterangepicker is shown\n   */\n  /* tslint:disable-next-line: no-any*/\n  @Output() onShown: EventEmitter<any>;\n  /**\n   * Emits an event when the daterangepicker is hidden\n   */\n  /* tslint:disable-next-line: no-any*/\n  @Output() onHidden: EventEmitter<any>;\n\n  _bsValue: Date[];\n  /**\n   * Initial value of daterangepicker\n   */\n  @Input()\n  set bsValue(value: Date[]) {\n    if (this._bsValue === value) {\n      return;\n    }\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  /**\n   * Config object for daterangepicker\n   */\n  @Input() bsConfig: Partial<BsDaterangepickerConfig>;\n  /**\n   * Indicates whether daterangepicker's content is enabled or not\n   */\n  @Input() isDisabled: boolean;\n  /**\n   * Minimum date which is available for selection\n   */\n  @Input() minDate: Date;\n  /**\n   * Maximum date which is available for selection\n   */\n  @Input() maxDate: Date;\n  /**\n   * Emits when daterangepicker value has been changed\n   */\n  @Output() bsValueChange: EventEmitter<Date[]> = new EventEmitter();\n\n  protected _subs: Subscription[] = [];\n\n  private _datepicker: ComponentLoader<BsDaterangepickerContainerComponent>;\n  private _datepickerRef: ComponentRef<BsDaterangepickerContainerComponent>;\n\n  constructor(public _config: BsDaterangepickerConfig,\n              _elementRef: ElementRef,\n              _renderer: Renderer2,\n              _viewContainerRef: ViewContainerRef,\n              cis: ComponentLoaderFactory) {\n    this._datepicker = cis.createLoader<BsDaterangepickerContainerComponent>(\n      _elementRef,\n      _viewContainerRef,\n      _renderer\n    );\n    Object.assign(this, _config);\n    this.onShown = this._datepicker.onShown;\n    this.onHidden = this._datepicker.onHidden;\n  }\n\n  ngOnInit(): void {\n    this._datepicker.listen({\n      outsideClick: this.outsideClick,\n      outsideEsc: this.outsideEsc,\n      triggers: this.triggers,\n      show: () => this.show()\n    });\n    this.setConfig();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this._datepickerRef || !this._datepickerRef.instance) {\n      return;\n    }\n\n    if (changes.minDate) {\n      this._datepickerRef.instance.minDate = this.minDate;\n    }\n\n    if (changes.maxDate) {\n      this._datepickerRef.instance.maxDate = this.maxDate;\n    }\n\n    if (changes.isDisabled) {\n      this._datepickerRef.instance.isDisabled = this.isDisabled;\n    }\n  }\n\n  /**\n   * Opens an elementâs datepicker. This is considered a âmanualâ triggering of\n   * the datepicker.\n   */\n  show(): void {\n    if (this._datepicker.isShown) {\n      return;\n    }\n\n    this.setConfig();\n\n    this._datepickerRef = this._datepicker\n      .provide({provide: BsDatepickerConfig, useValue: this._config})\n      .attach(BsDaterangepickerContainerComponent)\n      .to(this.container)\n      .position({attachment: this.placement})\n      .show({placement: this.placement});\n\n    // if date changes from external source (model -> view)\n    this._subs.push(\n      this.bsValueChange.subscribe((value: Date[]) => {\n        this._datepickerRef.instance.value = value;\n      })\n    );\n\n    // if date changes from picker (view -> model)\n    this._subs.push(\n      this._datepickerRef.instance.valueChange\n        .pipe(\n          filter((range: Date[]) => range && range[0] && !!range[1])\n        )\n        .subscribe((value: Date[]) => {\n          this.bsValue = value;\n          this.hide();\n        })\n    );\n  }\n\n  /**\n   * Set config for daterangepicker\n   */\n  setConfig() {\n    this._config = Object.assign(\n      {},\n      this._config,\n      this.bsConfig,\n      {\n        value: this._bsValue,\n        isDisabled: this.isDisabled,\n        minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n        maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate\n      }\n    );\n  }\n\n  /**\n   * Closes an elementâs datepicker. This is considered a âmanualâ triggering of\n   * the datepicker.\n   */\n  hide(): void {\n    if (this.isOpen) {\n      this._datepicker.hide();\n    }\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n  }\n\n  /**\n   * Toggles an elementâs datepicker. This is considered a âmanualâ triggering\n   * of the datepicker.\n   */\n  toggle(): void {\n    if (this.isOpen) {\n      return this.hide();\n    }\n\n    this.show();\n  }\n\n  ngOnDestroy(): void {\n    this._datepicker.dispose();\n  }\n}\n","import {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  forwardRef,\n  Host,\n  Provider,\n  Renderer2\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator\n} from '@angular/forms';\nimport { parseDate, formatDate, getLocale, isAfter, isBefore, isArray, isDateValid } from 'ngx-bootstrap/chronos';\nimport { BsDaterangepickerDirective } from './bs-daterangepicker.component';\nimport { BsLocaleService } from './bs-locale.service';\n\nconst BS_DATERANGEPICKER_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDaterangepickerInputDirective),\n  multi: true\n};\n\nconst BS_DATERANGEPICKER_VALIDATOR: Provider = {\n  provide: NG_VALIDATORS,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => BsDaterangepickerInputDirective),\n  multi: true\n};\n\n\n@Directive({\n  selector: `input[bsDaterangepicker]`,\n  host: {\n    '(change)': 'onChange($event)',\n    '(keyup.esc)': 'hide()',\n    '(blur)': 'onBlur()'\n  },\n  providers: [BS_DATERANGEPICKER_VALUE_ACCESSOR, BS_DATERANGEPICKER_VALIDATOR]\n})\nexport class BsDaterangepickerInputDirective\n  implements ControlValueAccessor, Validator {\n  private _onChange = Function.prototype;\n  private _onTouched = Function.prototype;\n  /* tslint:disable-next-line: no-unused-variable */\n  private _validatorChange = Function.prototype;\n  private _value: Date[];\n\n  constructor(@Host() private _picker: BsDaterangepickerDirective,\n              private _localeService: BsLocaleService,\n              private _renderer: Renderer2,\n              private _elRef: ElementRef,\n              private changeDetection: ChangeDetectorRef) {\n    // update input value on datepicker value update\n    this._picker.bsValueChange.subscribe((value: Date[]) => {\n      this._setInputValue(value);\n      if (this._value !== value) {\n        this._value = value;\n        this._onChange(value);\n        this._onTouched();\n      }\n      this.changeDetection.markForCheck();\n    });\n\n    // update input value on locale change\n    this._localeService.localeChange.subscribe(() => {\n      this._setInputValue(this._value);\n    });\n  }\n\n  _setInputValue(date: Date[]): void {\n    let range = '';\n    if (date) {\n      const start: string = !date[0] ? ''\n        : formatDate(date[0],\n          this._picker._config.rangeInputFormat,\n          this._localeService.currentLocale\n        );\n      const end: string = !date[1] ? ''\n        : formatDate(\n          date[1],\n          this._picker._config.rangeInputFormat,\n          this._localeService.currentLocale\n        );\n      range = (start && end) ? start + this._picker._config.rangeSeparator + end : '';\n    }\n    this._renderer.setProperty(this._elRef.nativeElement, 'value', range);\n  }\n\n  onChange(event: Event) {\n    /* tslint:disable-next-line: no-any*/\n    this.writeValue((event.target as any).value);\n    this._onChange(this._value);\n    this._onTouched();\n  }\n\n  validate(c: AbstractControl): ValidationErrors | null {\n    const _value: [Date, Date] = c.value;\n\n    if (_value === null || _value === undefined || !isArray(_value)) {\n      return null;\n    }\n\n    const _isFirstDateValid = isDateValid(_value[0]);\n    const _isSecondDateValid = isDateValid(_value[1]);\n\n    if (!_isFirstDateValid) {\n      return { bsDate: { invalid: _value[0] } };\n    }\n\n    if (!_isSecondDateValid) {\n      return { bsDate: { invalid: _value[1] } };\n    }\n\n    if (this._picker && this._picker.minDate && isBefore(_value[0], this._picker.minDate, 'date')) {\n      return { bsDate: { minDate: this._picker.minDate } };\n    }\n\n    if (this._picker && this._picker.maxDate && isAfter(_value[1], this._picker.maxDate, 'date')) {\n      return { bsDate: { maxDate: this._picker.maxDate } };\n    }\n  }\n\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorChange = fn;\n  }\n\n  writeValue(value: Date[] | string) {\n    if (!value) {\n      this._value = null;\n    } else {\n      const _localeKey = this._localeService.currentLocale;\n      const _locale = getLocale(_localeKey);\n      if (!_locale) {\n        throw new Error(\n          `Locale \"${_localeKey}\" is not defined, please add it with \"defineLocale(...)\"`\n        );\n      }\n\n      let _input: (string[] | Date[]) = [];\n      if (typeof value === 'string') {\n        _input = value.split(this._picker._config.rangeSeparator);\n      }\n\n      if (Array.isArray(value)) {\n        _input = value;\n      }\n\n\n      this._value = (_input as string[])\n        .map((_val: string): Date =>\n          parseDate(_val, this._picker._config.dateInputFormat, this._localeService.currentLocale))\n        .map((date: Date) => (isNaN(date.valueOf()) ? null : date));\n    }\n\n    this._picker.bsValue = this._value;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this._picker.isDisabled = isDisabled;\n    if (isDisabled) {\n      this._renderer.setAttribute(this._elRef.nativeElement, 'disabled', 'disabled');\n\n      return;\n    }\n    this._renderer.removeAttribute(this._elRef.nativeElement, 'disabled');\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  registerOnChange(fn: () => void): void {\n    this._onChange = fn;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  onBlur() {\n    this._onTouched();\n  }\n\n  hide() {\n    this._picker.hide();\n    this._renderer.selectRootElement(this._elRef.nativeElement).blur();\n  }\n}\n","import { Component } from '@angular/core';\n\n@Component({\n  selector: 'bs-calendar-layout',\n  template: `\n    <!-- current date, will be added in nearest releases -->\n    <bs-current-date title=\"hey there\" *ngIf=\"false\"></bs-current-date>\n\n    <!--navigation-->\n    <div class=\"bs-datepicker-head\">\n      <ng-content select=\"bs-datepicker-navigation-view\"></ng-content>\n    </div>\n\n    <div class=\"bs-datepicker-body\">\n      <ng-content></ng-content>\n    </div>\n\n    <!--timepicker-->\n    <bs-timepicker *ngIf=\"false\"></bs-timepicker>\n  `\n})\nexport class BsCalendarLayoutComponent {}\n","import { Component, Input } from '@angular/core';\n\n@Component({\n  selector: 'bs-current-date',\n  template: `<div class=\"current-timedate\"><span>{{ title }}</span></div>`\n})\nexport class BsCurrentDateViewComponent {\n  @Input() title: string;\n}\n","import { Component, ChangeDetectionStrategy, Input } from '@angular/core';\n\nexport interface BsCustomDates {\n  label: string;\n  value: Date | Date[];\n}\n\n@Component({\n  selector: 'bs-custom-date-view',\n  template: `\n    <div class=\"bs-datepicker-predefined-btns\">\n      <button *ngFor=\"let range of ranges\">{{ range.label }}</button>\n      <button *ngIf=\"isCustomRangeShown\">Custom Range</button>\n    </div>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class BsCustomDatesViewComponent {\n  @Input() isCustomRangeShown: true;\n  @Input() ranges: BsCustomDates[];\n}\n","import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Input,\n  OnInit,\n  Renderer2\n} from '@angular/core';\n\nimport { BsDatepickerConfig } from '../../bs-datepicker.config';\nimport { DayViewModel } from '../../models';\n\n@Component({\n  selector: '[bsDatepickerDayDecorator]',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[class.disabled]': 'day.isDisabled',\n    '[class.is-highlighted]': 'day.isHovered',\n    '[class.is-other-month]': 'day.isOtherMonth',\n    '[class.is-active-other-month]': 'day.isOtherMonthHovered',\n    '[class.in-range]': 'day.isInRange',\n    '[class.select-start]': 'day.isSelectionStart',\n    '[class.select-end]': 'day.isSelectionEnd',\n    '[class.selected]': 'day.isSelected'\n  },\n  template: `{{ day.label }}`\n})\nexport class BsDatepickerDayDecoratorComponent implements OnInit {\n  @Input() day: DayViewModel;\n\n  constructor(\n    private _config: BsDatepickerConfig,\n    private _elRef: ElementRef,\n    private _renderer: Renderer2\n  ) { }\n\n  ngOnInit(): void {\n    if (this.day.isToday && this._config && this._config.customTodayClass) {\n      this._renderer.addClass(this._elRef.nativeElement, this._config.customTodayClass);\n    }\n  }\n}\n","import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output\n} from '@angular/core';\nimport {\n  BsDatepickerViewMode,\n  BsNavigationDirection,\n  DaysCalendarViewModel\n} from '../../models';\n\n@Component({\n  selector: 'bs-datepicker-navigation-view',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <button class=\"previous\"\n            [disabled]=\"calendar.disableLeftArrow\"\n            [style.visibility]=\"calendar.hideLeftArrow ? 'hidden' : 'visible'\"\n            (click)=\"navTo(true)\"><span>&lsaquo;</span>\n    </button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"current\"\n            *ngIf=\"calendar.monthTitle\"\n            (click)=\"view('month')\"\n    ><span>{{ calendar.monthTitle }}</span>\n    </button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"current\" (click)=\"view('year')\"\n    ><span>{{ calendar.yearTitle }}</span></button>\n\n    &#8203;  <!-- zero-width space needed for correct alignement\n                  with preserveWhitespaces: false in Angular -->\n\n    <button class=\"next\"\n            [disabled]=\"calendar.disableRightArrow\"\n            [style.visibility]=\"calendar.hideRightArrow ? 'hidden' : 'visible'\"\n            (click)=\"navTo(false)\"><span>&rsaquo;</span>\n    </button>\n  `\n})\nexport class BsDatepickerNavigationViewComponent {\n  @Input() calendar: DaysCalendarViewModel;\n\n  @Output() onNavigate = new EventEmitter<BsNavigationDirection>();\n  @Output() onViewMode = new EventEmitter<BsDatepickerViewMode>();\n\n  navTo(down: boolean): void {\n    this.onNavigate.emit(\n      down ? BsNavigationDirection.DOWN : BsNavigationDirection.UP\n    );\n  }\n\n  view(viewMode: BsDatepickerViewMode): void {\n    this.onViewMode.emit(viewMode);\n  }\n}\n","import {\n  Component,\n  EventEmitter,\n  Input,\n  Output\n} from '@angular/core';\nimport {\n  BsDatepickerViewMode,\n  BsNavigationDirection,\n  BsNavigationEvent,\n  CellHoverEvent,\n  DatepickerRenderOptions,\n  DaysCalendarViewModel,\n  DayViewModel\n} from '../../models';\nimport { BsDatepickerConfig } from '../../bs-datepicker.config';\n\n@Component({\n  selector: 'bs-days-calendar-view',\n  // changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <!--days matrix-->\n      <table role=\"grid\" class=\"days weeks\">\n        <thead>\n        <tr>\n          <!--if show weeks-->\n          <th *ngIf=\"options.showWeekNumbers\"></th>\n          <th *ngFor=\"let weekday of calendar.weekdays; let i = index\"\n              aria-label=\"weekday\">{{ calendar.weekdays[i] }}\n          </th>\n        </tr>\n        </thead>\n        <tbody>\n        <tr *ngFor=\"let week of calendar.weeks; let i = index\">\n          <td class=\"week\" *ngIf=\"options.showWeekNumbers\">\n            <span>{{ calendar.weekNumbers[i] }}</span>\n          </td>\n          <td *ngFor=\"let day of week.days\" role=\"gridcell\">\n          <span bsDatepickerDayDecorator\n                [day]=\"day\"\n                (click)=\"selectDay(day)\"\n                (mouseenter)=\"hoverDay(day, true)\"\n                (mouseleave)=\"hoverDay(day, false)\">{{ day.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n\n    </bs-calendar-layout>\n  `\n})\nexport class BsDaysCalendarViewComponent {\n  @Input() calendar: DaysCalendarViewModel;\n  @Input() options: DatepickerRenderOptions;\n\n  @Output() onNavigate = new EventEmitter<BsNavigationEvent>();\n  @Output() onViewMode = new EventEmitter<BsDatepickerViewMode>();\n\n  @Output() onSelect = new EventEmitter<DayViewModel>();\n  @Output() onHover = new EventEmitter<CellHoverEvent>();\n\n  constructor(private _config: BsDatepickerConfig) { }\n\n  navigateTo(event: BsNavigationDirection): void {\n    const step = BsNavigationDirection.DOWN === event ? -1 : 1;\n    this.onNavigate.emit({ step: { month: step } });\n  }\n\n  changeViewMode(event: BsDatepickerViewMode): void {\n    this.onViewMode.emit(event);\n  }\n\n  selectDay(event: DayViewModel): void {\n    this.onSelect.emit(event);\n  }\n\n  hoverDay(cell: DayViewModel, isHovered: boolean): void {\n    if (this._config.selectFromOtherMonth && cell.isOtherMonth) {\n      cell.isOtherMonthHovered = isHovered;\n    }\n\n    this.onHover.emit({ cell, isHovered });\n  }\n}\n","import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport {\n  BsDatepickerViewMode,\n  BsNavigationDirection,\n  BsNavigationEvent,\n  CellHoverEvent,\n  MonthsCalendarViewModel,\n  CalendarCellViewModel\n} from '../../models';\n\n@Component({\n  selector: 'bs-month-calendar-view',\n  template: `\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <table role=\"grid\" class=\"months\">\n        <tbody>\n        <tr *ngFor=\"let row of calendar.months\">\n          <td *ngFor=\"let month of row\" role=\"gridcell\"\n              (click)=\"viewMonth(month)\"\n              (mouseenter)=\"hoverMonth(month, true)\"\n              (mouseleave)=\"hoverMonth(month, false)\"\n              [class.disabled]=\"month.isDisabled\"\n              [class.is-highlighted]=\"month.isHovered\">\n            <span>{{ month.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n    </bs-calendar-layout>\n  `\n})\nexport class BsMonthCalendarViewComponent {\n  @Input() calendar: MonthsCalendarViewModel;\n\n  @Output() onNavigate = new EventEmitter<BsNavigationEvent>();\n  @Output() onViewMode = new EventEmitter<BsDatepickerViewMode>();\n\n  @Output() onSelect = new EventEmitter<CalendarCellViewModel>();\n  @Output() onHover = new EventEmitter<CellHoverEvent>();\n\n  navigateTo(event: BsNavigationDirection): void {\n    const step = BsNavigationDirection.DOWN === event ? -1 : 1;\n    this.onNavigate.emit({ step: { year: step } });\n  }\n\n  viewMonth(month: CalendarCellViewModel) {\n    this.onSelect.emit(month);\n  }\n\n  hoverMonth(cell: CalendarCellViewModel, isHovered: boolean) {\n    this.onHover.emit({ cell, isHovered });\n  }\n\n  changeViewMode(event: BsDatepickerViewMode): void {\n    this.onViewMode.emit(event);\n  }\n}\n","// tslint:disable:max-line-length\nimport { Component } from '@angular/core';\n\n@Component({\n  selector: 'bs-timepicker',\n  template: `\n    <div class=\"bs-timepicker-container\">\n      <div class=\"bs-timepicker-controls\">\n        <button class=\"bs-decrease\">-</button>\n        <input type=\"text\" [value]=\"hours\" placeholder=\"00\">\n        <button class=\"bs-increase\">+</button>\n      </div>\n      <div class=\"bs-timepicker-controls\">\n        <button class=\"bs-decrease\">-</button>\n        <input type=\"text\" [value]=\"minutes\" placeholder=\"00\">\n        <button class=\"bs-increase\">+</button>\n      </div>\n      <button class=\"switch-time-format\">{{ ampm }}\n        <img\n          src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAAKCAYAAABi8KSDAAABSElEQVQYV3XQPUvDUBQG4HNuagtVqc6KgouCv6GIuIntYBLB9hcIQpLStCAIV7DYmpTcRWcXqZio3Vwc/UCc/QEqfgyKGbr0I7nS1EiHeqYzPO/h5SD0jaxUZjmSLCB+OFb+UFINFwASAEAdpu9gaGXVyAHHFQBkHpKHc6a9dzECvADyY9sqlAMsK9W0jzxDXqeytr3mhQckxSji27TJJ5/rPmIpwJJq3HrtduriYOurv1a4i1p5HnhkG9OFymi0ReoO05cGwb+ayv4dysVygjeFmsP05f8wpZQ8fsdvfmuY9zjWSNqUtgYFVnOVReILYoBFzdQI5/GGFzNHhGbeZnopDGU29sZbscgldmC99w35VOATTycIMMcBXIfpSVGzZhA6C8hh00conln6VQ9TGgV32OEAKQC4DrBq7CJwd0ggR7Vq/rPrfgB+C3sGypY5DAAAAABJRU5ErkJggg==\"\n          alt=\"\">\n      </button>\n    </div>\n  `\n})\nexport class BsTimepickerViewComponent {\n  ampm = 'ok';\n  hours = 0;\n  minutes = 0;\n}\n","import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport { yearsPerCalendar } from '../../engine/format-years-calendar';\nimport {\n  BsDatepickerViewMode,\n  BsNavigationDirection,\n  BsNavigationEvent,\n  CalendarCellViewModel,\n  CellHoverEvent,\n  YearsCalendarViewModel\n} from '../../models';\n\n@Component({\n  selector: 'bs-years-calendar-view',\n  template: `\n    <bs-calendar-layout>\n      <bs-datepicker-navigation-view\n        [calendar]=\"calendar\"\n        (onNavigate)=\"navigateTo($event)\"\n        (onViewMode)=\"changeViewMode($event)\"\n      ></bs-datepicker-navigation-view>\n\n      <table role=\"grid\" class=\"years\">\n        <tbody>\n        <tr *ngFor=\"let row of calendar.years\">\n          <td *ngFor=\"let year of row\" role=\"gridcell\"\n              (click)=\"viewYear(year)\"\n              (mouseenter)=\"hoverYear(year, true)\"\n              (mouseleave)=\"hoverYear(year, false)\"\n              [class.disabled]=\"year.isDisabled\"\n              [class.is-highlighted]=\"year.isHovered\">\n            <span>{{ year.label }}</span>\n          </td>\n        </tr>\n        </tbody>\n      </table>\n    </bs-calendar-layout>\n  `\n})\nexport class BsYearsCalendarViewComponent {\n  @Input() calendar: YearsCalendarViewModel;\n\n  @Output() onNavigate = new EventEmitter<BsNavigationEvent>();\n  @Output() onViewMode = new EventEmitter<BsDatepickerViewMode>();\n\n  @Output() onSelect = new EventEmitter<CalendarCellViewModel>();\n  @Output() onHover = new EventEmitter<CellHoverEvent>();\n\n  navigateTo(event: BsNavigationDirection): void {\n    const step = BsNavigationDirection.DOWN === event ? -1 : 1;\n    this.onNavigate.emit({ step: { year: step * yearsPerCalendar } });\n  }\n\n  viewYear(year: CalendarCellViewModel) {\n    this.onSelect.emit(year);\n  }\n\n  hoverYear(cell: CalendarCellViewModel, isHovered: boolean) {\n    this.onHover.emit({ cell, isHovered });\n  }\n\n  changeViewMode(event: BsDatepickerViewMode): void {\n    this.onViewMode.emit(event);\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { ModuleWithProviders, NgModule } from '@angular/core';\nimport { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { PositioningService } from 'ngx-bootstrap/positioning';\n\nimport { BsDatepickerInputDirective } from './bs-datepicker-input.directive';\nimport { BsDatepickerDirective } from './bs-datepicker.component';\nimport { BsDatepickerConfig } from './bs-datepicker.config';\nimport { BsDaterangepickerInputDirective } from './bs-daterangepicker-input.directive';\nimport { BsDaterangepickerDirective } from './bs-daterangepicker.component';\nimport { BsDaterangepickerConfig } from './bs-daterangepicker.config';\n\nimport { BsLocaleService } from './bs-locale.service';\nimport { BsDatepickerActions } from './reducer/bs-datepicker.actions';\nimport { BsDatepickerEffects } from './reducer/bs-datepicker.effects';\nimport { BsDatepickerStore } from './reducer/bs-datepicker.store';\nimport { BsCalendarLayoutComponent } from './themes/bs/bs-calendar-layout.component';\nimport { BsCurrentDateViewComponent } from './themes/bs/bs-current-date-view.component';\nimport { BsCustomDatesViewComponent } from './themes/bs/bs-custom-dates-view.component';\nimport { BsDatepickerContainerComponent } from './themes/bs/bs-datepicker-container.component';\nimport { BsDatepickerDayDecoratorComponent } from './themes/bs/bs-datepicker-day-decorator.directive';\nimport { BsDatepickerNavigationViewComponent } from './themes/bs/bs-datepicker-navigation-view.component';\nimport { BsDaterangepickerContainerComponent } from './themes/bs/bs-daterangepicker-container.component';\nimport { BsDaysCalendarViewComponent } from './themes/bs/bs-days-calendar-view.component';\nimport { BsMonthCalendarViewComponent } from './themes/bs/bs-months-calendar-view.component';\nimport { BsTimepickerViewComponent } from './themes/bs/bs-timepicker-view.component';\nimport { BsYearsCalendarViewComponent } from './themes/bs/bs-years-calendar-view.component';\n\nconst _exports = [\n  BsDatepickerContainerComponent,\n  BsDaterangepickerContainerComponent,\n\n  BsDatepickerDirective,\n  BsDatepickerInputDirective,\n\n  BsDaterangepickerInputDirective,\n  BsDaterangepickerDirective\n];\n\n@NgModule({\n  imports: [CommonModule],\n  declarations: [\n    BsDatepickerDayDecoratorComponent,\n    BsCurrentDateViewComponent,\n    BsDatepickerNavigationViewComponent,\n    BsTimepickerViewComponent,\n\n    BsCalendarLayoutComponent,\n    BsDaysCalendarViewComponent,\n    BsMonthCalendarViewComponent,\n    BsYearsCalendarViewComponent,\n\n    BsCustomDatesViewComponent,\n\n    ..._exports\n  ],\n  entryComponents: [\n    BsDatepickerContainerComponent,\n    BsDaterangepickerContainerComponent\n  ],\n  exports: _exports\n})\nexport class BsDatepickerModule {\n  static forRoot(): ModuleWithProviders {\n    return {\n      ngModule: BsDatepickerModule,\n      providers: [\n        ComponentLoaderFactory,\n        PositioningService,\n        BsDatepickerStore,\n        BsDatepickerActions,\n        BsDatepickerConfig,\n        BsDaterangepickerConfig,\n        BsDatepickerEffects,\n        BsLocaleService\n      ]\n    };\n  }\n}\n","import { formatDate } from 'ngx-bootstrap/chronos';\n\nexport class DateFormatter {\n  format(date: Date, format: string, locale: string): string {\n    return formatDate(date, format, locale);\n  }\n}\n","/* tslint:disable: max-file-line-count */\nimport {\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges\n} from '@angular/core';\n\nimport { DateFormatter } from './date-formatter';\n\n\n@Component({\n  selector: 'datepicker-inner',\n  template: `\n    <!--&lt;!&ndash;ng-keydown=\"keydown($event)\"&ndash;&gt;-->\n    <div *ngIf=\"datepickerMode\" class=\"well well-sm bg-faded p-a card\" role=\"application\" >\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class DatePickerInnerComponent implements OnInit, OnChanges {\n  @Input() locale: string;\n  @Input() datepickerMode: string;\n  @Input() startingDay: number;\n  @Input() yearRange: number;\n\n  @Input() minDate: Date;\n  @Input() maxDate: Date;\n  @Input() minMode: string;\n  @Input() maxMode: string;\n  @Input() showWeeks: boolean;\n  @Input() formatDay: string;\n  @Input() formatMonth: string;\n  @Input() formatYear: string;\n  @Input() formatDayHeader: string;\n  @Input() formatDayTitle: string;\n  @Input() formatMonthTitle: string;\n  @Input() onlyCurrentMonth: boolean;\n  @Input() shortcutPropagation: boolean;\n  @Input() customClass: { date: Date; mode: string; clazz: string }[];\n  @Input() monthColLimit: number;\n  @Input() yearColLimit: number;\n  @Input() dateDisabled: { date: Date; mode: string }[];\n  @Input() dayDisabled: number[];\n  @Input() initDate: Date;\n\n  @Output() selectionDone: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n  @Output() update: EventEmitter<Date> = new EventEmitter<Date>(false);\n  @Output() activeDateChange: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n\n  /* tslint:disable-next-line: no-any*/\n  stepDay: any = {};\n  /* tslint:disable-next-line: no-any*/\n  stepMonth: any = {};\n  /* tslint:disable-next-line: no-any*/\n  stepYear: any = {};\n\n  uniqueId: string;\n\n  protected modes: string[] = ['day', 'month', 'year'];\n  protected dateFormatter: DateFormatter = new DateFormatter();\n  protected _activeDate: Date;\n  protected selectedDate: Date;\n  protected activeDateId: string;\n\n  protected refreshViewHandlerDay: Function;\n  protected compareHandlerDay: Function;\n  protected refreshViewHandlerMonth: Function;\n  protected compareHandlerMonth: Function;\n  protected refreshViewHandlerYear: Function;\n  protected compareHandlerYear: Function;\n\n  @Input()\n  get activeDate(): Date {\n    return this._activeDate;\n  }\n\n  set activeDate(value: Date) {\n    this._activeDate = value;\n  }\n\n  // todo: add formatter value to Date object\n  ngOnInit(): void {\n    // todo: use date for unique value\n    this.uniqueId =  `datepicker--${Math.floor(Math.random() * 10000)}`;\n\n    if (this.initDate) {\n      this.activeDate = this.initDate;\n      this.selectedDate = new Date(this.activeDate.valueOf());\n      this.update.emit(this.activeDate);\n    } else if (this.activeDate === undefined) {\n      this.activeDate = new Date();\n    }\n  }\n\n  // this.refreshView should be called here to reflect the changes on the fly\n  // tslint:disable-next-line:no-unused-variable\n  ngOnChanges(changes: SimpleChanges): void {\n    this.refreshView();\n    this.checkIfActiveDateGotUpdated(changes.activeDate);\n  }\n\n  // Check if activeDate has been update and then emit the activeDateChange with the new date\n  /* tslint:disable-next-line: no-any */\n  checkIfActiveDateGotUpdated(activeDate: any): void {\n    if (activeDate && !activeDate.firstChange) {\n      const previousValue = activeDate.previousValue;\n      if (\n        previousValue &&\n        previousValue instanceof Date &&\n        previousValue.getTime() !== activeDate.currentValue.getTime()\n      ) {\n        this.activeDateChange.emit(this.activeDate);\n      }\n    }\n  }\n\n  setCompareHandler(handler: Function, type: string): void {\n    if (type === 'day') {\n      this.compareHandlerDay = handler;\n    }\n\n    if (type === 'month') {\n      this.compareHandlerMonth = handler;\n    }\n\n    if (type === 'year') {\n      this.compareHandlerYear = handler;\n    }\n  }\n\n  compare(date1: Date, date2: Date): number | undefined {\n    if (date1 === undefined || date2 === undefined) {\n      return undefined;\n    }\n\n    if (this.datepickerMode === 'day' && this.compareHandlerDay) {\n      return this.compareHandlerDay(date1, date2);\n    }\n\n    if (this.datepickerMode === 'month' && this.compareHandlerMonth) {\n      return this.compareHandlerMonth(date1, date2);\n    }\n\n    if (this.datepickerMode === 'year' && this.compareHandlerYear) {\n      return this.compareHandlerYear(date1, date2);\n    }\n\n    return void 0;\n  }\n\n  setRefreshViewHandler(handler: Function, type: string): void {\n    if (type === 'day') {\n      this.refreshViewHandlerDay = handler;\n    }\n\n    if (type === 'month') {\n      this.refreshViewHandlerMonth = handler;\n    }\n\n    if (type === 'year') {\n      this.refreshViewHandlerYear = handler;\n    }\n  }\n\n  refreshView(): void {\n    if (this.datepickerMode === 'day' && this.refreshViewHandlerDay) {\n      this.refreshViewHandlerDay();\n    }\n\n    if (this.datepickerMode === 'month' && this.refreshViewHandlerMonth) {\n      this.refreshViewHandlerMonth();\n    }\n\n    if (this.datepickerMode === 'year' && this.refreshViewHandlerYear) {\n      this.refreshViewHandlerYear();\n    }\n  }\n\n  dateFilter(date: Date, format: string): string {\n    return this.dateFormatter.format(date, format, this.locale);\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  isActive(dateObject: any): boolean {\n    if (this.compare(dateObject.date, this.activeDate) === 0) {\n      this.activeDateId = dateObject.uid;\n\n      return true;\n    }\n\n    return false;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  createDateObject(date: Date, format: string): any {\n    /* tslint:disable-next-line: no-any*/\n    const dateObject: any = {};\n    dateObject.date = new Date(\n      date.getFullYear(),\n      date.getMonth(),\n      date.getDate()\n    );\n    dateObject.date = this.fixTimeZone(dateObject.date);\n    dateObject.label = this.dateFilter(date, format);\n    dateObject.selected = this.compare(date, this.selectedDate) === 0;\n    dateObject.disabled = this.isDisabled(date);\n    dateObject.current = this.compare(date, new Date()) === 0;\n    dateObject.customClass = this.getCustomClassForDate(dateObject.date);\n\n    return dateObject;\n  }\n\n  /* tslint:disable-next-line: no-any*/\n  split(arr: any[], size: number): any[] {\n    /* tslint:disable-next-line: no-any*/\n    const arrays: any[] = [];\n    while (arr.length > 0) {\n      arrays.push(arr.splice(0, size));\n    }\n\n    return arrays;\n  }\n\n  // Fix a hard-reproducible bug with timezones\n  // The bug depends on OS, browser, current timezone and current date\n  // i.e.\n  // var date = new Date(2014, 0, 1);\n  // console.log(date.getFullYear(), date.getMonth(), date.getDate(),\n  // date.getHours()); can result in \"2013 11 31 23\" because of the bug.\n  fixTimeZone(date: Date): Date {\n    const hours = date.getHours();\n\n    return new Date(\n      date.getFullYear(),\n      date.getMonth(),\n      date.getDate(),\n      hours === 23 ? hours + 2 : 0\n    );\n  }\n\n  select(date: Date, isManual = true): void {\n    if (this.datepickerMode === this.minMode) {\n      if (!this.activeDate) {\n        this.activeDate = new Date(0, 0, 0, 0, 0, 0, 0);\n      }\n\n      this.activeDate = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate()\n      );\n      this.activeDate = this.fixTimeZone(this.activeDate);\n      if (isManual) {\n        this.selectionDone.emit(this.activeDate);\n      }\n    } else {\n      this.activeDate = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate()\n      );\n      this.activeDate = this.fixTimeZone(this.activeDate);\n      if (isManual) {\n        this.datepickerMode = this.modes[\n          this.modes.indexOf(this.datepickerMode) - 1\n        ];\n      }\n    }\n\n    this.selectedDate = new Date(this.activeDate.valueOf());\n    this.update.emit(this.activeDate);\n    this.refreshView();\n  }\n\n  move(direction: number): void {\n    /* tslint:disable-next-line: no-any*/\n    let expectedStep: any;\n    if (this.datepickerMode === 'day') {\n      expectedStep = this.stepDay;\n    }\n\n    if (this.datepickerMode === 'month') {\n      expectedStep = this.stepMonth;\n    }\n\n    if (this.datepickerMode === 'year') {\n      expectedStep = this.stepYear;\n    }\n\n    if (expectedStep) {\n      const year =\n        this.activeDate.getFullYear() + direction * (expectedStep.years || 0);\n      const month =\n        this.activeDate.getMonth() + direction * (expectedStep.months || 0);\n      this.activeDate = new Date(year, month, 1);\n\n      this.refreshView();\n      this.activeDateChange.emit(this.activeDate);\n    }\n  }\n\n  toggleMode(_direction: number): void {\n    const direction = _direction || 1;\n\n    if (\n      (this.datepickerMode === this.maxMode && direction === 1) ||\n      (this.datepickerMode === this.minMode && direction === -1)\n    ) {\n      return;\n    }\n\n    this.datepickerMode = this.modes[\n      this.modes.indexOf(this.datepickerMode) + direction\n    ];\n    this.refreshView();\n  }\n\n  protected getCustomClassForDate(date: Date): string {\n    if (!this.customClass) {\n      return '';\n    }\n    // todo: build a hash of custom classes, it will work faster\n    const customClassObject: {\n      date: Date;\n      mode: string;\n      clazz: string;\n    /* tslint:disable-next-line: no-any */\n    } = this.customClass.find((customClass: any) => {\n      return (\n        customClass.date.valueOf() === date.valueOf() &&\n        customClass.mode === this.datepickerMode\n      );\n    }, this);\n\n    return customClassObject === undefined ? '' : customClassObject.clazz;\n  }\n\n  protected compareDateDisabled(\n    date1Disabled: { date: Date; mode: string },\n    date2: Date\n  ): number {\n    if (date1Disabled === undefined || date2 === undefined) {\n      return undefined;\n    }\n\n    if (date1Disabled.mode === 'day' && this.compareHandlerDay) {\n      return this.compareHandlerDay(date1Disabled.date, date2);\n    }\n\n    if (date1Disabled.mode === 'month' && this.compareHandlerMonth) {\n      return this.compareHandlerMonth(date1Disabled.date, date2);\n    }\n\n    if (date1Disabled.mode === 'year' && this.compareHandlerYear) {\n      return this.compareHandlerYear(date1Disabled.date, date2);\n    }\n\n    return undefined;\n  }\n\n  protected isDisabled(date: Date): boolean {\n    let isDateDisabled = false;\n    if (this.dateDisabled) {\n      this.dateDisabled.forEach(\n        (disabledDate: { date: Date; mode: string }) => {\n          if (this.compareDateDisabled(disabledDate, date) === 0) {\n            isDateDisabled = true;\n          }\n        }\n      );\n    }\n\n    if (this.dayDisabled) {\n      isDateDisabled =\n        isDateDisabled ||\n        this.dayDisabled.indexOf(date.getDay()) > -1;\n    }\n\n    return (\n      isDateDisabled ||\n      (this.minDate && this.compare(date, this.minDate) < 0) ||\n      (this.maxDate && this.compare(date, this.maxDate) > 0)\n    );\n  }\n}\n","import { Injectable } from '@angular/core';\n\n@Injectable()\nexport class DatepickerConfig {\n  locale = 'en';\n  datepickerMode = 'day';\n  startingDay = 0;\n  yearRange = 20;\n  minMode = 'day';\n  maxMode = 'year';\n  showWeeks = true;\n  formatDay = 'DD';\n  formatMonth = 'MMMM';\n  formatYear = 'YYYY';\n  formatDayHeader = 'dd';\n  formatDayTitle = 'MMMM YYYY';\n  formatMonthTitle = 'YYYY';\n  onlyCurrentMonth = false;\n  monthColLimit = 3;\n  yearColLimit = 5;\n  shortcutPropagation = false;\n}\n","import {\n  Component,\n  EventEmitter,\n  forwardRef,\n  Input,\n  Output,\n  Provider,\n  ViewChild\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\nimport { DatepickerConfig } from './datepicker.config';\n\nexport const DATEPICKER_CONTROL_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => DatePickerComponent),\n  multi: true\n};\n\n/* tslint:disable:component-selector-name component-selector-type */\n@Component({\n  selector: 'datepicker',\n  template: `\n    <datepicker-inner [activeDate]=\"activeDate\"\n                      (update)=\"onUpdate($event)\"\n                      [locale]=\"config.locale\"\n                      [datepickerMode]=\"datepickerMode\"\n                      [initDate]=\"initDate\"\n                      [minDate]=\"minDate\"\n                      [maxDate]=\"maxDate\"\n                      [minMode]=\"minMode\"\n                      [maxMode]=\"maxMode\"\n                      [showWeeks]=\"showWeeks\"\n                      [formatDay]=\"formatDay\"\n                      [formatMonth]=\"formatMonth\"\n                      [formatYear]=\"formatYear\"\n                      [formatDayHeader]=\"formatDayHeader\"\n                      [formatDayTitle]=\"formatDayTitle\"\n                      [formatMonthTitle]=\"formatMonthTitle\"\n                      [startingDay]=\"startingDay\"\n                      [yearRange]=\"yearRange\"\n                      [customClass]=\"customClass\"\n                      [dateDisabled]=\"dateDisabled\"\n                      [dayDisabled]=\"dayDisabled\"\n                      [onlyCurrentMonth]=\"onlyCurrentMonth\"\n                      [shortcutPropagation]=\"shortcutPropagation\"\n                      [monthColLimit]=\"monthColLimit\"\n                      [yearColLimit]=\"yearColLimit\"\n                      (selectionDone)=\"onSelectionDone($event)\"\n                      (activeDateChange)=\"onActiveDateChange($event)\">\n      <daypicker tabindex=\"0\"></daypicker>\n      <monthpicker tabindex=\"0\"></monthpicker>\n      <yearpicker tabindex=\"0\"></yearpicker>\n    </datepicker-inner>\n    `,\n  providers: [DATEPICKER_CONTROL_VALUE_ACCESSOR]\n})\n/* tslint:enable:component-selector-name component-selector-type */\nexport class DatePickerComponent implements ControlValueAccessor {\n  /** sets datepicker mode, supports: `day`, `month`, `year` */\n  @Input() datepickerMode = 'day';\n  /** default date to show if `ng-model` value is not specified */\n  @Input() initDate: Date;\n  /**  oldest selectable date */\n  @Input() minDate: Date;\n  /** latest selectable date */\n  @Input() maxDate: Date;\n  /** set lower datepicker mode, supports: `day`, `month`, `year` */\n  @Input() minMode: string;\n  /** sets upper datepicker mode, supports: `day`, `month`, `year` */\n  @Input() maxMode: string;\n  /** if false week numbers will be hidden */\n  @Input() showWeeks = true;\n  /** format of day in month */\n  @Input() formatDay: string;\n  /** format of month in year */\n  @Input() formatMonth: string;\n  /** format of year in year range */\n  @Input() formatYear: string;\n  /** format of day in week header */\n  @Input() formatDayHeader: string;\n  /** format of title when selecting day */\n  @Input() formatDayTitle: string;\n  /** format of title when selecting month */\n  @Input() formatMonthTitle: string;\n  /** starting day of the week from 0-6 (0=Sunday, ..., 6=Saturday) */\n  @Input() startingDay: number;\n  /** number of years displayed in year selection */\n  @Input() yearRange: number;\n  /** if true only dates from the currently displayed month will be shown */\n  @Input() onlyCurrentMonth: boolean;\n  /** if true shortcut`s event propagation will be disabled */\n  @Input() shortcutPropagation: boolean;\n  /** number of months displayed in a single row of month picker */\n  @Input() monthColLimit: number;\n  /** number of years displayed in a single row of year picker */\n  @Input() yearColLimit: number;\n  /** array of custom css classes to be applied to targeted dates */\n  @Input() customClass: { date: Date; mode: string; clazz: string }[];\n  /** array of disabled dates */\n  @Input() dateDisabled: { date: Date; mode: string }[];\n  /** disabled days of the week from 0-6 (0=Sunday, ..., 6=Saturday) */\n  @Input() dayDisabled: number[];\n\n  /** currently active date */\n  @Input()\n  get activeDate(): Date {\n    return this._activeDate || this._now;\n  }\n\n  set activeDate(value: Date) {\n    this._activeDate = value;\n  }\n\n  @Output()\n  selectionDone: EventEmitter<Date> = new EventEmitter<Date>(undefined);\n\n  /** callback to invoke when the activeDate is changed. */\n  @Output()\n  activeDateChange: EventEmitter<Date> = new EventEmitter<Date>(\n    undefined\n  );\n\n  @ViewChild(DatePickerInnerComponent)\n  _datePicker: DatePickerInnerComponent;\n\n  /* tslint:disable-next-line: no-any*/\n  onChange: any = Function.prototype;\n  /* tslint:disable-next-line: no-any*/\n  onTouched: any = Function.prototype;\n\n  config: DatepickerConfig;\n\n  protected _now: Date = new Date();\n  protected _activeDate: Date;\n\n  constructor(config: DatepickerConfig) {\n    this.config = config;\n    this.configureOptions();\n  }\n\n  configureOptions(): void {\n    Object.assign(this, this.config);\n  }\n\n  onUpdate(event: Date): void {\n    this.activeDate = event;\n    this.onChange(event);\n  }\n\n  onSelectionDone(event: Date): void {\n    this.selectionDone.emit(event);\n  }\n\n  onActiveDateChange(event: Date): void {\n    this.activeDateChange.emit(event);\n  }\n  // todo: support null value\n  /* tslint:disable-next-line: no-any*/\n  writeValue(value: any): void {\n    if (this._datePicker.compare(value, this._activeDate) === 0) {\n      return;\n    }\n    if (value && value instanceof Date) {\n      this.activeDate = value;\n      this._datePicker.select(value, false);\n\n      return;\n    }\n\n    this.activeDate = value ? new Date(value) : void 0;\n  }\n\n  registerOnChange(fn: () => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n}\n","// @deprecated\n// tslint:disable\nimport { Component, OnInit } from '@angular/core';\nimport { isBs3 } from 'ngx-bootstrap/utils';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\n\n@Component({\n  selector: 'daypicker',\n  template: `\n<table *ngIf=\"datePicker.datepickerMode === 'day'\" role=\"grid\" [attr.aria-labelledby]=\"datePicker.uniqueId + '-title'\" aria-activedescendant=\"activeDateId\">\n  <thead>\n    <tr>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">â¹</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\"\n                tabindex=\"-1\">&lt;</button>\n      </th>\n      <th [attr.colspan]=\"5 + (datePicker.showWeeks ? 1 : 0)\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-secondary btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button *ngIf=\"!isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">âº</button>\n        <button *ngIf=\"isBs4\"\n                type=\"button\"\n                class=\"btn btn-default btn-secondary btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\"\n                tabindex=\"-1\">&gt;\n        </button>\n      </th>\n    </tr>\n    <tr>\n      <th *ngIf=\"datePicker.showWeeks\"></th>\n      <th *ngFor=\"let labelz of labels\" class=\"text-center\">\n        <small aria-label=\"labelz.full\"><b>{{ labelz.abbr }}</b></small>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <ng-template ngFor [ngForOf]=\"rows\" let-rowz=\"$implicit\" let-index=\"index\">\n      <tr *ngIf=\"!(datePicker.onlyCurrentMonth && rowz[0].secondary && rowz[6].secondary)\">\n        <td *ngIf=\"datePicker.showWeeks\" class=\"h6\" class=\"text-center\">\n          <em>{{ weekNumbers[index] }}</em>\n        </td>\n        <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [id]=\"dtz.uid\">\n          <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-sm {{dtz.customClass}}\"\n                  *ngIf=\"!(datePicker.onlyCurrentMonth && dtz.secondary)\"\n                  [ngClass]=\"{'btn-secondary': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected, disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz), 'btn-default': !isBs4}\"\n                  [disabled]=\"dtz.disabled\"\n                  (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n            <span [ngClass]=\"{'text-muted': dtz.secondary || dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n          </button>\n        </td>\n      </tr>\n    </ng-template>\n  </tbody>\n</table>\n  `,\n  styles: [\n    `\n    :host .btn-secondary {\n      color: #292b2c;\n      background-color: #fff;\n      border-color: #ccc;\n    }\n    :host .btn-info .text-muted {\n      color: #292b2c !important;\n    }\n  `\n  ]\n})\nexport class DayPickerComponent implements OnInit {\n  labels: any[] = [];\n  title: string;\n  rows: any[] = [];\n  weekNumbers: number[] = [];\n  datePicker: DatePickerInnerComponent;\n\n  constructor(datePicker: DatePickerInnerComponent) {\n    this.datePicker = datePicker;\n  }\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  /*protected getDaysInMonth(year:number, month:number) {\n   return ((month === 1) && (year % 4 === 0) &&\n   ((year % 100 !== 0) || (year % 400 === 0))) ? 29 : DAYS_IN_MONTH[month];\n   }*/\n  ngOnInit(): void {\n    const self = this;\n\n    this.datePicker.stepDay = { months: 1 };\n\n    this.datePicker.setRefreshViewHandler(function(): void {\n      const year = this.activeDate.getFullYear();\n      const month = this.activeDate.getMonth();\n      const firstDayOfMonth = new Date(year, month, 1);\n      const difference = this.startingDay - firstDayOfMonth.getDay();\n      const numDisplayedFromPreviousMonth =\n        difference > 0 ? 7 - difference : -difference;\n      const firstDate = new Date(firstDayOfMonth.getTime());\n\n      if (numDisplayedFromPreviousMonth > 0) {\n        firstDate.setDate(-numDisplayedFromPreviousMonth + 1);\n      }\n\n      // 42 is the number of days on a six-week calendar\n      const _days: Date[] = self.getDates(firstDate, 42);\n      const days: any[] = [];\n      for (let i = 0; i < 42; i++) {\n        const _dateObject = this.createDateObject(_days[i], this.formatDay);\n        _dateObject.secondary = _days[i].getMonth() !== month;\n        _dateObject.uid = this.uniqueId + '-' + i;\n        days[i] = _dateObject;\n      }\n\n      self.labels = [];\n      for (let j = 0; j < 7; j++) {\n        self.labels[j] = {};\n        self.labels[j].abbr = this.dateFilter(\n          days[j].date,\n          this.formatDayHeader\n        );\n        self.labels[j].full = this.dateFilter(days[j].date, 'EEEE');\n      }\n\n      self.title = this.dateFilter(this.activeDate, this.formatDayTitle);\n      self.rows = this.split(days, 7);\n\n      if (this.showWeeks) {\n        self.weekNumbers = [];\n        const thursdayIndex = (4 + 7 - this.startingDay) % 7;\n        const numWeeks = self.rows.length;\n        for (let curWeek = 0; curWeek < numWeeks; curWeek++) {\n          self.weekNumbers.push(\n            self.getISO8601WeekNumber(self.rows[curWeek][thursdayIndex].date)\n          );\n        }\n      }\n    }, 'day');\n\n    this.datePicker.setCompareHandler(function(\n      date1: Date,\n      date2: Date\n    ): number {\n      const d1 = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate());\n      const d2 = new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());\n      return d1.getTime() - d2.getTime();\n    }, 'day');\n\n    this.datePicker.refreshView();\n  }\n\n  protected getDates(startDate: Date, n: number): Date[] {\n    const dates: Date[] = new Array(n);\n    let current = new Date(startDate.getTime());\n    let i = 0;\n    let date: Date;\n    while (i < n) {\n      date = new Date(current.getTime());\n      date = this.datePicker.fixTimeZone(date);\n      dates[i++] = date;\n      current = new Date(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate() + 1\n      );\n    }\n    return dates;\n  }\n\n  protected getISO8601WeekNumber(date: Date): number {\n    const checkDate = new Date(date.getTime());\n    // Thursday\n    checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));\n    const time = checkDate.getTime();\n    // Compare with Jan 1\n    checkDate.setMonth(0);\n    checkDate.setDate(1);\n    return (\n      Math.floor(Math.round((time - checkDate.getTime()) / 86400000) / 7) + 1\n    );\n  }\n\n  // todo: key events implementation\n}\n","// @deprecated\n// tslint:disable\nimport { Component, OnInit } from '@angular/core';\n\nimport { isBs3 } from 'ngx-bootstrap/utils';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\n\n@Component({\n  selector: 'monthpicker',\n  template: `\n<table *ngIf=\"datePicker.datepickerMode==='month'\" role=\"grid\">\n  <thead>\n    <tr>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\" tabindex=\"-1\">â¹</button></th>\n      <th [attr.colspan]=\"((datePicker.monthColLimit - 2) <= 0) ? 1 : datePicker.monthColLimit - 2\">\n        <button [id]=\"datePicker.uniqueId + '-title'\"\n                type=\"button\" class=\"btn btn-default btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong> \n        </button>\n      </th>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\" tabindex=\"-1\">âº</button>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr *ngFor=\"let rowz of rows\">\n      <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [attr.id]=\"dtz.uid\" [ngClass]=\"dtz.customClass\">\n        <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-default\"\n                [ngClass]=\"{'btn-link': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected || (isBs4 && !dtz.selected && datePicker.isActive(dtz)), disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz)}\"\n                [disabled]=\"dtz.disabled\"\n                (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n          <span [ngClass]=\"{'text-success': isBs4 && dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n        </button>\n      </td>\n    </tr>\n  </tbody>\n</table>\n  `,\n  styles: [\n    `\n    :host .btn-info .text-success {\n      color: #fff !important;\n    }\n  `\n  ]\n})\nexport class MonthPickerComponent implements OnInit {\n  title: string;\n  rows: any[] = [];\n  datePicker: DatePickerInnerComponent;\n  maxMode: string;\n\n  constructor(datePicker: DatePickerInnerComponent) {\n    this.datePicker = datePicker;\n  }\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  ngOnInit(): void {\n    const self = this;\n\n    this.datePicker.stepMonth = { years: 1 };\n\n    this.datePicker.setRefreshViewHandler(function(): void {\n      const months: any[] = new Array(12);\n      const year: number = this.activeDate.getFullYear();\n      let date: Date;\n\n      for (let i = 0; i < 12; i++) {\n        date = new Date(year, i, 1);\n        date = this.fixTimeZone(date);\n        months[i] = this.createDateObject(date, this.formatMonth);\n        months[i].uid = this.uniqueId + '-' + i;\n      }\n\n      self.title = this.dateFilter(this.activeDate, this.formatMonthTitle);\n      self.rows = this.split(months, self.datePicker.monthColLimit);\n    }, 'month');\n\n    this.datePicker.setCompareHandler(function(\n      date1: Date,\n      date2: Date\n    ): number {\n      const d1 = new Date(date1.getFullYear(), date1.getMonth());\n      const d2 = new Date(date2.getFullYear(), date2.getMonth());\n      return d1.getTime() - d2.getTime();\n    }, 'month');\n\n    this.datePicker.refreshView();\n  }\n\n  // todo: key events implementation\n}\n","// @deprecated\n// tslint:disable\nimport { Component, OnInit } from '@angular/core';\n\nimport { isBs3 } from 'ngx-bootstrap/utils';\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\n\n@Component({\n  selector: 'yearpicker',\n  template: `\n<table *ngIf=\"datePicker.datepickerMode==='year'\" role=\"grid\">\n  <thead>\n    <tr>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-left float-left\"\n                (click)=\"datePicker.move(-1)\" tabindex=\"-1\">â¹</button>\n      </th>\n      <th [attr.colspan]=\"((datePicker.yearColLimit - 2) <= 0) ? 1 : datePicker.yearColLimit - 2\">\n        <button [id]=\"datePicker.uniqueId + '-title'\" role=\"heading\"\n                type=\"button\" class=\"btn btn-default btn-sm\"\n                (click)=\"datePicker.toggleMode(0)\"\n                [disabled]=\"datePicker.datepickerMode === datePicker.maxMode\"\n                [ngClass]=\"{disabled: datePicker.datepickerMode === datePicker.maxMode}\" tabindex=\"-1\" style=\"width:100%;\">\n          <strong>{{ title }}</strong>\n        </button>\n      </th>\n      <th>\n        <button type=\"button\" class=\"btn btn-default btn-sm pull-right float-right\"\n                (click)=\"datePicker.move(1)\" tabindex=\"-1\">âº</button>\n      </th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr *ngFor=\"let rowz of rows\">\n      <td *ngFor=\"let dtz of rowz\" class=\"text-center\" role=\"gridcell\" [attr.id]=\"dtz.uid\">\n        <button type=\"button\" style=\"min-width:100%;\" class=\"btn btn-default\"\n                [ngClass]=\"{'btn-link': isBs4 && !dtz.selected && !datePicker.isActive(dtz), 'btn-info': dtz.selected || (isBs4 && !dtz.selected && datePicker.isActive(dtz)), disabled: dtz.disabled, active: !isBs4 && datePicker.isActive(dtz)}\"\n                [disabled]=\"dtz.disabled\"\n                (click)=\"datePicker.select(dtz.date)\" tabindex=\"-1\">\n          <span [ngClass]=\"{'text-success': isBs4 && dtz.current, 'text-info': !isBs4 && dtz.current}\">{{ dtz.label }}</span>\n        </button>\n      </td>\n    </tr>\n  </tbody>\n</table>\n  `,\n  styles: [\n    `\n    :host .btn-info .text-success {\n      color: #fff !important;\n    }\n  `\n  ]\n})\nexport class YearPickerComponent implements OnInit {\n  datePicker: DatePickerInnerComponent;\n  title: string;\n  rows: any[] = [];\n\n  constructor(datePicker: DatePickerInnerComponent) {\n    this.datePicker = datePicker;\n  }\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  ngOnInit(): void {\n    const self = this;\n\n    this.datePicker.stepYear = { years: this.datePicker.yearRange };\n\n    this.datePicker.setRefreshViewHandler(function(): void {\n      const years: any[] = new Array(this.yearRange);\n      let date: Date;\n      const start = self.getStartingYear(this.activeDate.getFullYear());\n\n      for (let i = 0; i < this.yearRange; i++) {\n        date = new Date(start + i, 0, 1);\n        date = this.fixTimeZone(date);\n        years[i] = this.createDateObject(date, this.formatYear);\n        years[i].uid = this.uniqueId + '-' + i;\n      }\n\n      self.title = [years[0].label, years[this.yearRange - 1].label].join(\n        ' - '\n      );\n      self.rows = this.split(years, self.datePicker.yearColLimit);\n    }, 'year');\n\n    this.datePicker.setCompareHandler(function(\n      date1: Date,\n      date2: Date\n    ): number {\n      return date1.getFullYear() - date2.getFullYear();\n    }, 'year');\n\n    this.datePicker.refreshView();\n  }\n\n  protected getStartingYear(year: number): number {\n    // todo: parseInt\n    return (\n      (year - 1) / this.datePicker.yearRange * this.datePicker.yearRange + 1\n    );\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { ModuleWithProviders, NgModule } from '@angular/core';\nimport { FormsModule } from '@angular/forms';\n\nimport { DatePickerInnerComponent } from './datepicker-inner.component';\nimport { DatePickerComponent } from './datepicker.component';\nimport { DatepickerConfig } from './datepicker.config';\nimport { DayPickerComponent } from './daypicker.component';\nimport { MonthPickerComponent } from './monthpicker.component';\nimport { YearPickerComponent } from './yearpicker.component';\n\n@NgModule({\n  imports: [CommonModule, FormsModule],\n  declarations: [\n    DatePickerComponent,\n    DatePickerInnerComponent,\n    DayPickerComponent,\n    MonthPickerComponent,\n    YearPickerComponent\n  ],\n  exports: [\n    DatePickerComponent,\n    DatePickerInnerComponent,\n    DayPickerComponent,\n    MonthPickerComponent,\n    YearPickerComponent\n  ],\n  entryComponents: [DatePickerComponent]\n})\nexport class DatepickerModule {\n  static forRoot(): ModuleWithProviders {\n    return { ngModule: DatepickerModule, providers: [DatepickerConfig] };\n  }\n}\n"],"names":["tslib_1.__values","height","width","shift","tslib_1.__extends"],"mappings":"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"}