https://www.joliette.ca/plugins/blanko/forms/assets/dist/build.js

1130/***/ "./node_modules/eonasdan-bootstrap-datetimepicker/src/js/bootstrap-datetimepicker.js":
1131/*!*******************************************************************************************!*\
1132  !*** ./node_modules/eonasdan-bootstrap-datetimepicker/src/js/bootstrap-datetimepicker.js ***!
1133  \*******************************************************************************************/
1134/***/ ((module, exports, __webpack_require__) => {
1135
1136var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
1137  * Bootstrap Datetime Picker v4.17.49
1138  * Copyright 2015-2020 Jonathan Peterson
1139  * Licensed under MIT (https://github.com/Eonasdan/bootstrap-datetimepicker/blob/master/LICENSE)
1140  */
1141/*global define:false */
1142/*global exports:false */
1143/*global require:false */
1144/*global jQuery:false */
1145/*global moment:false */
1146(function (factory) {
1147    'use strict';
1148    if (true) {
1149        // AMD is used - Register as an anonymous module.
1150        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! moment */ "./node_modules/moment/moment.js")], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
1151		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
1152		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
1153		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
1154    } else // removed by dead control flow
1155{}
1156}(function ($, moment) {
1157    'use strict';
1158    if (!moment) {
1159        throw new Error('bootstrap-datetimepicker requires Moment.js to be loaded first');
1160    }
1161
1162    var dateTimePicker = function (element, options) {
1163        var picker = {},
1164            date,
1165            viewDate,
1166            unset = true,
1167            input,
1168            component = false,
1169            widget = false,
1170            use24Hours,
1171            minViewModeNumber = 0,
1172            actualFormat,
1173            parseFormats,
1174            currentViewMode,
1175            datePickerModes = [
1176                {
1177                    clsName: 'days',
1178                    navFnc: 'M',
1179                    navStep: 1
1180                },
1181                {
1182                    clsName: 'months',
1183                    navFnc: 'y',
1184                    navStep: 1
1185                },
1186                {
1187                    clsName: 'years',
1188                    navFnc: 'y',
1189                    navStep: 10
1190                },
1191                {
1192                    clsName: 'decades',
1193                    navFnc: 'y',
1194                    navStep: 100
1195                }
1196            ],
1197            viewModes = ['days', 'months', 'years', 'decades'],
1198            verticalModes = ['top', 'bottom', 'auto'],
1199            horizontalModes = ['left', 'right', 'auto'],
1200            toolbarPlacements = ['default', 'top', 'bottom'],
1201            keyMap = {
1202                'up': 38,
1203                38: 'up',
1204                'down': 40,
1205                40: 'down',
1206                'left': 37,
1207                37: 'left',
1208                'right': 39,
1209                39: 'right',
1210                'tab': 9,
1211                9: 'tab',
1212                'escape': 27,
1213                27: 'escape',
1214                'enter': 13,
1215                13: 'enter',
1216                'pageUp': 33,
1217                33: 'pageUp',
1218                'pageDown': 34,
1219                34: 'pageDown',
1220                'shift': 16,
1221                16: 'shift',
1222                'control': 17,
1223                17: 'control',
1224                'space': 32,
1225                32: 'space',
1226                't': 84,
1227                84: 't',
1228                'delete': 46,
1229                46: 'delete'
1230            },
1231            keyState = {},
1232
1233            /********************************************************************************
1234             *
1235             * Private functions
1236             *
1237             ********************************************************************************/
1238
1239            hasTimeZone = function () {
1240                return moment.tz !== undefined && options.timeZone !== undefined && options.timeZone !== null && options.timeZone !== '';
1241            },
1242
1243            getMoment = function (d) {
1244                var returnMoment;
1245
1246                if (d === undefined || d === null) {
1247                    returnMoment = moment(); //TODO should this use format? and locale?
1248                } else if (moment.isDate(d) || moment.isMoment(d)) {
1249                    // If the date that is passed in is already a Date() or moment() object,
1250                    // pass it directly to moment.
1251                    returnMoment = moment(d);
1252                } else if (hasTimeZone()) { // There is a string to parse and a default time zone
1253                    // parse with the tz function which takes a default time zone if it is not in the format string
1254                    returnMoment = moment.tz(d, parseFormats, options.useStrict, options.timeZone);
1255                } else {
1256                    returnMoment = moment(d, parseFormats, options.useStrict);
1257                }
1258
1259                if (hasTimeZone()) {
1260                    returnMoment.tz(options.timeZone);
1261                }
1262
1263                return returnMoment;
1264            },
1265
1266            isEnabled = function (granularity) {
1267                if (typeof granularity !== 'string' || granularity.length > 1) {
1268                    throw new TypeError('isEnabled expects a single character string parameter');
1269                }
1270                switch (granularity) {
1271                    case 'y':
1272                        return actualFormat.indexOf('Y') !== -1;
1273                    case 'M':
1274                        return actualFormat.indexOf('M') !== -1;
1275                    case 'd':
1276                        return actualFormat.toLowerCase().indexOf('d') !== -1;
1277                    case 'h':
1278                    case 'H':
1279                        return actualFormat.toLowerCase().indexOf('h') !== -1;
1280                    case 'm':
1281                        return actualFormat.indexOf('m') !== -1;
1282                    case 's':
1283                        return actualFormat.indexOf('s') !== -1;
1284                    default:
1285                        return false;
1286                }
1287            },
1288
1289            hasTime = function () {
1290                return (isEnabled('h') || isEnabled('m') || isEnabled('s'));
1291            },
1292
1293            hasDate = function () {
1294                return (isEnabled('y') || isEnabled('M') || isEnabled('d'));
1295            },
1296
1297            getDatePickerTemplate = function () {
1298                var headTemplate = $('<thead>')
1299                        .append($('<tr>')
1300                            .append($('<th>').addClass('prev').attr('data-action', 'previous')
1301                                .append($('<span>').addClass(options.icons.previous))
1302                                )
1303                            .append($('<th>').addClass('picker-switch').attr('data-action', 'pickerSwitch').attr('colspan', (options.calendarWeeks ? '6' : '5')))
1304                            .append($('<th>').addClass('next').attr('data-action', 'next')
1305                                .append($('<span>').addClass(options.icons.next))
1306                                )
1307                            ),
1308                    contTemplate = $('<tbody>')
1309                        .append($('<tr>')
1310                            .append($('<td>').attr('colspan', (options.calendarWeeks ? '8' : '7')))
1311                            );
1312
1313                return [
1314                    $('<div>').addClass('datepicker-days')
1315                        .append($('<table>').addClass('table-condensed')
1316                            .append(headTemplate)
1317                            .append($('<tbody>'))
1318                            ),
1319                    $('<div>').addClass('datepicker-months')
1320                        .append($('<table>').addClass('table-condensed')
1321                            .append(headTemplate.clone())
1322                            .append(contTemplate.clone())
1323                            ),
1324                    $('<div>').addClass('datepicker-years')
1325                        .append($('<table>').addClass('table-condensed')
1326                            .append(headTemplate.clone())
1327                            .append(contTemplate.clone())
1328                            ),
1329                    $('<div>').addClass('datepicker-decades')
1330                        .append($('<table>').addClass('table-condensed')
1331                            .append(headTemplate.clone())
1332                            .append(contTemplate.clone())
1333                            )
1334                ];
1335            },
1336
1337            getTimePickerMainTemplate = function () {
1338                var topRow = $('<tr>'),
1339                    middleRow = $('<tr>'),
1340                    bottomRow = $('<tr>');
1341
1342                if (isEnabled('h')) {
1343                    topRow.append($('<td>')
1344                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementHour }).addClass('btn').attr('data-action', 'incrementHours').append($('<span>').addClass(options.icons.up))));
1345                    middleRow.append($('<td>')
1346                        .append($('<span>').addClass('timepicker-hour').attr({ 'data-time-component': 'hours', 'title': options.tooltips.pickHour }).attr('data-action', 'showHours')));
1347                    bottomRow.append($('<td>')
1348                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementHour }).addClass('btn').attr('data-action', 'decrementHours').append($('<span>').addClass(options.icons.down))));
1349                }
1350                if (isEnabled('m')) {
1351                    if (isEnabled('h')) {
1352                        topRow.append($('<td>').addClass('separator'));
1353                        middleRow.append($('<td>').addClass('separator').html(':'));
1354                        bottomRow.append($('<td>').addClass('separator'));
1355                    }
1356                    topRow.append($('<td>')
1357                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementMinute }).addClass('btn').attr('data-action', 'incrementMinutes')
1358                            .append($('<span>').addClass(options.icons.up))));
1359                    middleRow.append($('<td>')
1360                        .append($('<span>').addClass('timepicker-minute').attr({ 'data-time-component': 'minutes', 'title': options.tooltips.pickMinute }).attr('data-action', 'showMinutes')));
1361                    bottomRow.append($('<td>')
1362                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementMinute }).addClass('btn').attr('data-action', 'decrementMinutes')
1363                            .append($('<span>').addClass(options.icons.down))));
1364                }
1365                if (isEnabled('s')) {
1366                    if (isEnabled('m')) {
1367                        topRow.append($('<td>').addClass('separator'));
1368                        middleRow.append($('<td>').addClass('separator').html(':'));
1369                        bottomRow.append($('<td>').addClass('separator'));
1370                    }
1371                    topRow.append($('<td>')
1372                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.incrementSecond }).addClass('btn').attr('data-action', 'incrementSeconds')
1373                            .append($('<span>').addClass(options.icons.up))));
1374                    middleRow.append($('<td>')
1375                        .append($('<span>').addClass('timepicker-second').attr({ 'data-time-component': 'seconds', 'title': options.tooltips.pickSecond }).attr('data-action', 'showSeconds')));
1376                    bottomRow.append($('<td>')
1377                        .append($('<a>').attr({ href: '#', tabindex: '-1', 'title': options.tooltips.decrementSecond }).addClass('btn').attr('data-action', 'decrementSeconds')
1378                            .append($('<span>').addClass(options.icons.down))));
1379                }
1380
1381                if (!use24Hours) {
1382                    topRow.append($('<td>').addClass('separator'));
1383                    middleRow.append($('<td>')
1384                        .append($('<button>').addClass('btn btn-primary').attr({ 'data-action': 'togglePeriod', tabindex: '-1', 'title': options.tooltips.togglePeriod })));
1385                    bottomRow.append($('<td>').addClass('separator'));
1386                }
1387
1388                return $('<div>').addClass('timepicker-picker')
1389                    .append($('<table>').addClass('table-condensed')
1390                        .append([topRow, middleRow, bottomRow]));
1391            },
1392
1393            getTimePickerTemplate = function () {
1394                var hoursView = $('<div>').addClass('timepicker-hours')
1395                        .append($('<table>').addClass('table-condensed')),
1396                    minutesView = $('<div>').addClass('timepicker-minutes')
1397                        .append($('<table>').addClass('table-condensed')),
1398                    secondsView = $('<div>').addClass('timepicker-seconds')
1399                        .append($('<table>').addClass('table-condensed')),
1400                    ret = [getTimePickerMainTemplate()];
1401
1402                if (isEnabled('h')) {
1403                    ret.push(hoursView);
1404                }
1405                if (isEnabled('m')) {
1406                    ret.push(minutesView);
1407                }
1408                if (isEnabled('s')) {
1409                    ret.push(secondsView);
1410                }
1411
1412                return ret;
1413            },
1414
1415            getToolbar = function () {
1416                var row = [];
1417                if (options.showTodayButton) {
1418                    row.push($('<td>').append($('<a>').attr({ 'data-action': 'today', 'title': options.tooltips.today }).append($('<span>').addClass(options.icons.today))));
1419                }
1420                if (!options.sideBySide && hasDate() && hasTime()) {
1421                    row.push($('<td>').append($('<a>').attr({ 'data-action': 'togglePicker', 'title': options.tooltips.selectTime }).append($('<span>').addClass(options.icons.time))));
1422                }
1423                if (options.showClear) {
1424                    row.push($('<td>').append($('<a>').attr({ 'data-action': 'clear', 'title': options.tooltips.clear }).append($('<span>').addClass(options.icons.clear))));
1425                }
1426                if (options.showClose) {
1427                    row.push($('<td>').append($('<a>').attr({ 'data-action': 'close', 'title': options.tooltips.close }).append($('<span>').addClass(options.icons.close))));
1428                }
1429                return $('<table>').addClass('table-condensed').append($('<tbody>').append($('<tr>').append(row)));
1430            },
1431
1432            getTemplate = function () {
1433                var template = $('<div>').addClass('bootstrap-datetimepicker-widget dropdown-menu'),
1434                    dateView = $('<div>').addClass('datepicker').append(getDatePickerTemplate()),
1435                    timeView = $('<div>').addClass('timepicker').append(getTimePickerTemplate()),
1436                    content = $('<ul>').addClass('list-unstyled'),
1437                    toolbar = $('<li>').addClass('picker-switch' + (options.collapse ? ' accordion-toggle' : '')).append(getToolbar());
1438
1439                if (options.inline) {
1440                    template.removeClass('dropdown-menu');
1441                }
1442
1443                if (use24Hours) {
1444                    template.addClass('usetwentyfour');
1445                }
1446
1447                if (isEnabled('s') && !use24Hours) {
1448                    template.addClass('wider');
1449                }
1450
1451                if (options.sideBySide && hasDate() && hasTime()) {
1452                    template.addClass('timepicker-sbs');
1453                    if (options.toolbarPlacement === 'top') {
1454                        template.append(toolbar);
1455                    }
1456                    template.append(
1457                        $('<div>').addClass('row')
1458                            .append(dateView.addClass('col-md-6'))
1459                            .append(timeView.addClass('col-md-6'))
1460                    );
1461                    if (options.toolbarPlacement === 'bottom') {
1462                        template.append(toolbar);
1463                    }
1464                    return template;
1465                }
1466
1467                if (options.toolbarPlacement === 'top') {
1468                    content.append(toolbar);
1469                }
1470                if (hasDate()) {
1471                    content.append($('<li>').addClass((options.collapse && hasTime() ? 'collapse in' : '')).append(dateView));
1472                }
1473                if (options.toolbarPlacement === 'default') {
1474                    content.append(toolbar);
1475                }
1476                if (hasTime()) {
1477                    content.append($('<li>').addClass((options.collapse && hasDate() ? 'collapse' : '')).append(timeView));
1478                }
1479                if (options.toolbarPlacement === 'bottom') {
1480                    content.append(toolbar);
1481                }
1482                return template.append(content);
1483            },
1484
1485            dataToOptions = function () {
1486                var eData,
1487                    dataOptions = {};
1488
1489                if (element.is('input') || options.inline) {
1490                    eData = element.data();
1491                } else {
1492                    eData = element.find('input').data();
1493                }
1494
1495                if (eData.dateOptions && eData.dateOptions instanceof Object) {
1496                    dataOptions = $.extend(true, dataOptions, eData.dateOptions);
1497                }
1498
1499                $.each(options, function (key) {
1500                    var attributeName = 'date' + key.charAt(0).toUpperCase() + key.slice(1);
1501                    if (eData[attributeName] !== undefined) {
1502                        dataOptions[key] = eData[attributeName];
1503                    }
1504                });
1505                return dataOptions;
1506            },
1507
1508            place = function () {
1509                var position = (component || element).position(),
1510                    offset = (component || element).offset(),
1511                    vertical = options.widgetPositioning.vertical,
1512                    horizontal = options.widgetPositioning.horizontal,
1513                    parent;
1514
1515                if (options.widgetParent) {
1516                    parent = options.widgetParent.append(widget);
1517                } else if (element.is('input')) {
1518                    parent = element.after(widget).parent();
1519                } else if (options.inline) {
1520                    parent = element.append(widget);
1521                    return;
1522                } else {
1523                    parent = element;
1524                    element.children().first().after(widget);
1525                }
1526
1527                // Top and bottom logic
1528                if (vertical === 'auto') {
1529                    if (offset.top + widget.height() * 1.5 >= $(window).height() + $(window).scrollTop() &&
1530                        widget.height() + element.outerHeight() < offset.top) {
1531                        vertical = 'top';
1532                    } else {
1533                        vertical = 'bottom';
1534                    }
1535                }
1536
1537                // Left and right logic
1538                if (horizontal === 'auto') {
1539                    if (parent.width() < offset.left + widget.outerWidth() / 2 &&
1540                        offset.left + widget.outerWidth() > $(window).width()) {
1541                        horizontal = 'right';
1542                    } else {
1543                        horizontal = 'left';
1544                    }
1545                }
1546
1547                if (vertical === 'top') {
1548                    widget.addClass('top').removeClass('bottom');
1549                } else {
1550                    widget.addClass('bottom').removeClass('top');
1551                }
1552
1553                if (horizontal === 'right') {
1554                    widget.addClass('pull-right');
1555                } else {
1556                    widget.removeClass('pull-right');
1557                }
1558
1559                // find the first parent element that has a non-static css positioning
1560                if (parent.css('position') === 'static') {
1561                    parent = parent.parents().filter(function () {
1562                        return $(this).css('position') !== 'static';
1563                    }).first();
1564                }
1565
1566                if (parent.length === 0) {
1567                    throw new Error('datetimepicker component should be placed within a non-static positioned container');
1568                }
1569
1570                widget.css({
1571                    top: vertical === 'top' ? 'auto' : position.top + element.outerHeight(),
1572                    bottom: vertical === 'top' ? parent.outerHeight() - (parent === element ? 0 : position.top) : 'auto',
1573                    left: horizontal === 'left' ? (parent === element ? 0 : position.left) : 'auto',
1574                    right: horizontal === 'left' ? 'auto' : parent.outerWidth() - element.outerWidth() - (parent === element ? 0 : position.left)
1575                });
1576            },
1577
1578            notifyEvent = function (e) {
1579                if (e.type === 'dp.change' && ((e.date && e.date.isSame(e.oldDate)) || (!e.date && !e.oldDate))) {
1580                    return;
1581                }
1582                element.trigger(e);
1583            },
1584
1585            viewUpdate = function (e) {
1586                if (e === 'y') {
1587                    e = 'YYYY';
1588                }
1589                notifyEvent({
1590                    type: 'dp.update',
1591                    change: e,
1592                    viewDate: viewDate.clone()
1593                });
1594            },
1595
1596            showMode = function (dir) {
1597                if (!widget) {
1598                    return;
1599                }
1600                if (dir) {
1601                    currentViewMode = Math.max(minViewModeNumber, Math.min(3, currentViewMode + dir));
1602                }
1603                widget.find('.datepicker > div').hide().filter('.datepicker-' + datePickerModes[currentViewMode].clsName).show();
1604            },
1605
1606            fillDow = function () {
1607                var row = $('<tr>'),
1608                    currentDate = viewDate.clone().startOf('w').startOf('d');
1609
1610                if (options.calendarWeeks === true) {
1611                    row.append($('<th>').addClass('cw').text('#'));
1612                }
1613
1614                while (currentDate.isBefore(viewDate.clone().endOf('w'))) {
1615                    row.append($('<th>').addClass('dow').text(currentDate.format('dd')));
1616                    currentDate.add(1, 'd');
1617                }
1618                widget.find('.datepicker-days thead').append(row);
1619            },
1620
1621            isInDisabledDates = function (testDate) {
1622                return options.disabledDates[testDate.format('YYYY-MM-DD')] === true;
1623            },
1624
1625            isInEnabledDates = function (testDate) {
1626                return options.enabledDates[testDate.format('YYYY-MM-DD')] === true;
1627            },
1628
1629            isInDisabledHours = function (testDate) {
1630                return options.disabledHours[testDate.format('H')] === true;
1631            },
1632
1633            isInEnabledHours = function (testDate) {
1634                return options.enabledHours[testDate.format('H')] === true;
1635            },
1636
1637            isValid = function (targetMoment, granularity) {
1638                if (!targetMoment.isValid()) {
1639                    return false;
1640                }
1641                if (options.disabledDates && granularity === 'd' && isInDisabledDates(targetMoment)) {
1642                    return false;
1643                }
1644                if (options.enabledDates && granularity === 'd' && !isInEnabledDates(targetMoment)) {
1645                    return false;
1646                }
1647                if (options.minDate && targetMoment.isBefore(options.minDate, granularity)) {
1648                    return false;
1649                }
1650                if (options.maxDate && targetMoment.isAfter(options.maxDate, granularity)) {
1651                    return false;
1652                }
1653                if (options.daysOfWeekDisabled && granularity === 'd' && options.daysOfWeekDisabled.indexOf(targetMoment.day()) !== -1) {
1654                    return false;
1655                }
1656                if (options.disabledHours && (granularity === 'h' || granularity === 'm' || granularity === 's') && isInDisabledHours(targetMoment)) {
1657                    return false;
1658                }
1659                if (options.enabledHours && (granularity === 'h' || granularity === 'm' || granularity === 's') && !isInEnabledHours(targetMoment)) {
1660                    return false;
1661                }
1662                if (options.disabledTimeIntervals && (granularity === 'h' || granularity === 'm' || granularity === 's')) {
1663                    var found = false;
1664                    $.each(options.disabledTimeIntervals, function () {
1665                        if (targetMoment.isBetween(this[0], this[1])) {
1666                            found = true;
1667                            return false;
1668                        }
1669                    });
1670                    if (found) {
1671                        return false;
1672                    }
1673                }
1674                return true;
1675            },
1676
1677            fillMonths = function () {
1678                var spans = [],
1679                    monthsShort = viewDate.clone().startOf('y').startOf('d');
1680                while (monthsShort.isSame(viewDate, 'y')) {
1681                    spans.push($('<span>').attr('data-action', 'selectMonth').addClass('month').text(monthsShort.format('MMM')));
1682                    monthsShort.add(1, 'M');
1683                }
1684                widget.find('.datepicker-months td').empty().append(spans);
1685            },
1686
1687            updateMonths = function () {
1688                var monthsView = widget.find('.datepicker-months'),
1689                    monthsViewHeader = monthsView.find('th'),
1690                    months = monthsView.find('tbody').find('span');
1691
1692                monthsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevYear);
1693                monthsViewHeader.eq(1).attr('title', options.tooltips.selectYear);
1694                monthsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextYear);
1695
1696                monthsView.find('.disabled').removeClass('disabled');
1697
1698                if (!isValid(viewDate.clone().subtract(1, 'y'), 'y')) {
1699                    monthsViewHeader.eq(0).addClass('disabled');
1700                }
1701
1702                monthsViewHeader.eq(1).text(viewDate.year());
1703
1704                if (!isValid(viewDate.clone().add(1, 'y'), 'y')) {
1705                    monthsViewHeader.eq(2).addClass('disabled');
1706                }
1707
1708                months.removeClass('active');
1709                if (date.isSame(viewDate, 'y') && !unset) {
1710                    months.eq(date.month()).addClass('active');
1711                }
1712
1713                months.each(function (index) {
1714                    if (!isValid(viewDate.clone().month(index), 'M')) {
1715                        $(this).addClass('disabled');
1716                    }
1717                });
1718            },
1719
1720            updateYears = function () {
1721                var yearsView = widget.find('.datepicker-years'),
1722                    yearsViewHeader = yearsView.find('th'),
1723                    startYear = viewDate.clone().subtract(5, 'y'),
1724                    endYear = viewDate.clone().add(6, 'y'),
1725                    html = '';
1726
1727                yearsViewHeader.eq(0).find('span').attr('title', options.tooltips.prevDecade);
1728                yearsViewHeader.eq(1).attr('title', options.tooltips.selectDecade);
1729                yearsViewHeader.eq(2).find('span').attr('title', options.tooltips.nextDecade);
1730
1731                yearsView.find('.disabled').removeClass('disabled');
1732
1733                if (options.minDate && options.minDate.isAfter(startYear, 'y')) {
1734                    yearsViewHeader.eq(0).addClass('disabled');
1735                }
1736
1737                yearsViewHeader.eq(1).text(startYear.year() + '-' + endYear.year());
1738
1739                if (options.maxDate && options.maxDate.isBefore(endYear, 'y')) {
1740                    yearsViewHeader.eq(2).addClass('disabled');
1741                }
1742
1743                while (!startYear.isAfter(endYear, 'y')) {
1744                    html += '<span data-action="selectYear" class="year' + (startYear.isSame(date, 'y') && !unset ? ' active' : '') + (!isValid(startYear, 'y') ? ' disabled' : '') + '">' + startYear.year() + '</span>';
1745                    startYear.add(1, 'y');
1746                }
1747
1748                yearsView.find('td').html(html);
1749            },
1750
1751            updateDecades = function () {
1752                var decadesView = widget.find('.datepicker-decades'),
1753                    decadesViewHeader = decadesView.find('th'),
1754                    startDecade = moment({ y: viewDate.year() - (viewDate.year() % 100) - 1 }),
1755                    endDecade = startDecade.clone().add(100, 'y'),
1756                    startedAt = startDecade.clone(),
1757                    minDateDecade = false,
1758                    maxDateDecade = false,
1759                    endDecadeYear,
1760                    html = '';
1761
1762                decadesViewHeader.eq(0).find('span').attr('title', options.tooltips.prevCentury);
1763                decadesViewHeader.eq(2).find('span').attr('title', options.tooltips.nextCentury);
1764
1765                decadesView.find('.disabled').removeClass('disabled');
1766
1767                if (startDecade.isSame(moment({ y: 1900 })) || (options.minDate && options.minDate.isAfter(startDecade, 'y'))) {
1768                    decadesViewHeader.eq(0).addClass('disabled');
1769                }
1770
1771                decadesViewHeader.eq(1).text(startDecade.year() + '-' + endDecade.year());
1772
1773                if (startDecade.isSame(moment({ y: 2000 })) || (options.maxDate && options.maxDate.isBefore(endDecade, 'y'))) {
1774                    decadesViewHeader.eq(2).addClass('disabled');
1775                }
1776
1777                while (!startDecade.isAfter(endDecade, 'y')) {
1778                    endDecadeYear = startDecade.year() + 12;
1779                    minDateDecade = options.minDate && options.minDate.isAfter(startDecade, 'y') && options.minDate.year() <= endDecadeYear;
1780                    maxDateDecade = options.maxDate && options.maxDate.isAfter(startDecade, 'y') && options.maxDate.year() <= endDecadeYear;
1781                    html += '<span data-action="selectDecade" class="decade' + (date.isAfter(startDecade) && date.year() <= endDecadeYear ? ' active' : '') +
1782                        (!isValid(startDecade, 'y') && !minDateDecade && !maxDateDecade ? ' disabled' : '') + '" data-selection="' + (startDecade.year() + 6) + '">' + (startDecade.year() + 1) + ' - ' + (startDecade.year() + 12) + '</span>';
1783                    startDecade.add(12, 'y');
1784                }
1785                html += '<span></span><span></span><span></span>'; //push the dangling block over, at least this way it's even
1786
1787                decadesView.find('td').html(html);
1788                decadesViewHeader.eq(1).text((startedAt.year() + 1) + '-' + (startDecade.year()));
1789            },
1790
1791            fillDate = function () {
1792                var daysView = widget.find('.datepicker-days'),
1793                    daysViewHeader = daysView.find('th'),
1794                    currentDate,
1795                    html = [],
1796                    row,
1797                    clsNames = [],
1798                    i;
1799
1800                if (!hasDate()) {
1801                    return;
1802                }
1803
1804                daysViewHeader.eq(0).find('span').attr('title', options.tooltips.prevMonth);
1805                daysViewHeader.eq(1).attr('title', options.tooltips.selectMonth);
1806                daysViewHeader.eq(2).find('span').attr('title', options.tooltips.nextMonth);
1807
1808                daysView.find('.disabled').removeClass('disabled');
1809                daysViewHeader.eq(1).text(viewDate.format(options.dayViewHeaderFormat));
1810
1811                if (!isValid(viewDate.clone().subtract(1, 'M'), 'M')) {
1812                    daysViewHeader.eq(0).addClass('disabled');
1813                }
1814                if (!isValid(viewDate.clone().add(1, 'M'), 'M')) {
1815                    daysViewHeader.eq(2).addClass('disabled');
1816                }
1817
1818                currentDate = viewDate.clone().startOf('M').startOf('w').startOf('d');
1819
1820                for (i = 0; i < 42; i++) { //always display 42 days (should show 6 weeks)
1821                    if (currentDate.weekday() === 0) {
1822                        row = $('<tr>');
1823                        if (options.calendarWeeks) {
1824                            row.append('<td class="cw">' + currentDate.week() + '</td>');
1825                        }
1826                        html.push(row);
1827                    }
1828                    clsNames = ['day'];
1829                    if (currentDate.isBefore(viewDate, 'M')) {
1830                        clsNames.push('old');
1831                    }
1832                    if (currentDate.isAfter(viewDate, 'M')) {
1833                        clsNames.push('new');
1834                    }
1835                    if (currentDate.isSame(date, 'd') && !unset) {
1836                        clsNames.push('active');
1837                    }
1838                    if (!isValid(currentDate, 'd')) {
1839                        clsNames.push('disabled');
1840                    }
1841                    if (currentDate.isSame(getMoment(), 'd')) {
1842                        clsNames.push('today');
1843                    }
1844                    if (currentDate.day() === 0 || currentDate.day() === 6) {
1845                        clsNames.push('weekend');
1846                    }
1847                    notifyEvent({
1848                        type: 'dp.classify',
1849                        date: currentDate,
1850                        classNames: clsNames
1851                    });
1852                    row.append('<td data-action="selectDay" data-day="' + currentDate.format('L') + '" class="' + clsNames.join(' ') + '">' + currentDate.date() + '</td>');
1853                    currentDate.add(1, 'd');
1854                }
1855
1856                daysView.find('tbody').empty().append(html);
1857
1858                updateMonths();
1859
1860                updateYears();
1861
1862                updateDecades();
1863            },
1864
1865            fillHours = function () {
1866                var table = widget.find('.timepicker-hours table'),
1867                    currentHour = viewDate.clone().startOf('d'),
1868                    html = [],
1869                    row = $('<tr>');
1870
1871                if (viewDate.hour() > 11 && !use24Hours) {
1872                    currentHour.hour(12);
1873                }
1874                while (currentHour.isSame(viewDate, 'd') && (use24Hours || (viewDate.hour() < 12 && currentHour.hour() < 12) || viewDate.hour() > 11)) {
1875                    if (currentHour.hour() % 4 === 0) {
1876                        row = $('<tr>');
1877                        html.push(row);
1878                    }
1879                    row.append('<td data-action="selectHour" class="hour' + (!isValid(currentHour, 'h') ? ' disabled' : '') + '">' + currentHour.format(use24Hours ? 'HH' : 'hh') + '</td>');
1880                    currentHour.add(1, 'h');
1881                }
1882                table.empty().append(html);
1883            },
1884
1885            fillMinutes = function () {
1886                var table = widget.find('.timepicker-minutes table'),
1887                    currentMinute = viewDate.clone().startOf('h'),
1888                    html = [],
1889                    row = $('<tr>'),
1890                    step = options.stepping === 1 ? 5 : options.stepping;
1891
1892                while (viewDate.isSame(currentMinute, 'h')) {
1893                    if (currentMinute.minute() % (step * 4) === 0) {
1894                        row = $('<tr>');
1895                        html.push(row);
1896                    }
1897                    row.append('<td data-action="selectMinute" class="minute' + (!isValid(currentMinute, 'm') ? ' disabled' : '') + '">' + currentMinute.format('mm') + '</td>');
1898                    currentMinute.add(step, 'm');
1899                }
1900                table.empty().append(html);
1901            },
1902
1903            fillSeconds = function () {
1904                var table = widget.find('.timepicker-seconds table'),
1905                    currentSecond = viewDate.clone().startOf('m'),
1906                    html = [],
1907                    row = $('<tr>');
1908
1909                while (viewDate.isSame(currentSecond, 'm')) {
1910                    if (currentSecond.second() % 20 === 0) {
1911                        row = $('<tr>');
1912                        html.push(row);
1913                    }
1914                    row.append('<td data-action="selectSecond" class="second' + (!isValid(currentSecond, 's') ? ' disabled' : '') + '">' + currentSecond.format('ss') + '</td>');
1915                    currentSecond.add(5, 's');
1916                }
1917
1918                table.empty().append(html);
1919            },
1920
1921            fillTime = function () {
1922                var toggle, newDate, timeComponents = widget.find('.timepicker span[data-time-component]');
1923
1924                if (!use24Hours) {
1925                    toggle = widget.find('.timepicker [data-action=togglePeriod]');
1926                    newDate = date.clone().add((date.hours() >= 12) ? -12 : 12, 'h');
1927
1928                    toggle.text(date.format('A'));
1929
1930                    if (isValid(newDate, 'h')) {
1931                        toggle.removeClass('disabled');
1932                    } else {
1933                        toggle.addClass('disabled');
1934                    }
1935                }
1936                timeComponents.filter('[data-time-component=hours]').text(date.format(use24Hours ? 'HH' : 'hh'));
1937                timeComponents.filter('[data-time-component=minutes]').text(date.format('mm'));
1938                timeComponents.filter('[data-time-component=seconds]').text(date.format('ss'));
1939
1940                fillHours();
1941                fillMinutes();
1942                fillSeconds();
1943            },
1944
1945            update = function () {
1946                if (!widget) {
1947                    return;
1948                }
1949                fillDate();
1950                fillTime();
1951            },
1952
1953            setValue = function (targetMoment) {
1954                var oldDate = unset ? null : date;
1955
1956                // case of calling setValue(null or false)
1957                if (!targetMoment) {
1958                    unset = true;
1959                    input.val('');
1960                    element.data('date', '');
1961                    notifyEvent({
1962                        type: 'dp.change',
1963                        date: false,
1964                        oldDate: oldDate
1965                    });
1966                    update();
1967                    return;
1968                }
1969
1970                targetMoment = targetMoment.clone().locale(options.locale);
1971
1972                if (hasTimeZone()) {
1973                    targetMoment.tz(options.timeZone);
1974                }
1975
1976                if (options.stepping !== 1) {
1977                    targetMoment.minutes((Math.round(targetMoment.minutes() / options.stepping) * options.stepping)).seconds(0);
1978
1979                    while (options.minDate && targetMoment.isBefore(options.minDate)) {
1980                        targetMoment.add(options.stepping, 'minutes');
1981                    }
1982                }
1983
1984                if (isValid(targetMoment)) {
1985                    date = targetMoment;
1986                    viewDate = date.clone();
1987                    input.val(date.format(actualFormat));
1988                    element.data('date', date.format(actualFormat));
1989                    unset = false;
1990                    update();
1991                    notifyEvent({
1992                        type: 'dp.change',
1993                        date: date.clone(),
1994                        oldDate: oldDate
1995                    });
1996                } else {
1997                    if (!options.keepInvalid) {
1998                        input.val(unset ? '' : date.format(actualFormat));
1999                    } else {
2000                        notifyEvent({
2001                            type: 'dp.change',
2002                            date: targetMoment,
2003                            oldDate: oldDate
2004                        });
2005                    }
2006                    notifyEvent({
2007                        type: 'dp.error',
2008                        date: targetMoment,
2009                        oldDate: oldDate
2010                    });
2011                }
2012            },
2013
2014            /**
2015             * Hides the widget. Possibly will emit dp.hide
2016             */
2017            hide = function () {
2018                var transitioning = false;
2019                if (!widget) {
2020                    return picker;
2021                }
2022                // Ignore event if in the middle of a picker transition
2023                widget.find('.collapse').each(function () {
2024                    var collapseData = $(this).data('collapse');
2025                    if (collapseData && collapseData.transitioning) {
2026                        transitioning = true;
2027                        return false;
2028                    }
2029                    return true;
2030                });
2031                if (transitioning) {
2032                    return picker;
2033                }
2034                if (component && component.hasClass('btn')) {
2035                    component.toggleClass('active');
2036                }
2037                widget.hide();
2038
2039                $(window).off('resize', place);
2040                widget.off('click', '[data-action]');
2041                widget.off('mousedown', false);
2042
2043                widget.remove();
2044                widget = false;
2045
2046                notifyEvent({
2047                    type: 'dp.hide',
2048                    date: date.clone()
2049                });
2050
2051                input.blur();
2052
2053                viewDate = date.clone();
2054
2055                return picker;
2056            },
2057
2058            clear = function () {
2059                setValue(null);
2060            },
2061
2062            parseInputDate = function (inputDate) {
2063                if (options.parseInputDate === undefined) {
2064                    if (!moment.isMoment(inputDate) || inputDate instanceof Date) {
2065                        inputDate = getMoment(inputDate);
2066                    }
2067                } else {
2068                    inputDate = options.parseInputDate(inputDate);
2069                }
2070                //inputDate.locale(options.locale);
2071                return inputDate;
2072            },
2073
2074            /********************************************************************************
2075             *
2076             * Widget UI interaction functions
2077             *
2078             ********************************************************************************/
2079            actions = {
2080                next: function () {
2081                    var navFnc = datePickerModes[currentViewMode].navFnc;
2082                    viewDate.add(datePickerModes[currentViewMode].navStep, navFnc);
2083                    fillDate();
2084                    viewUpdate(navFnc);
2085                },
2086
2087                previous: function () {
2088                    var navFnc = datePickerModes[currentViewMode].navFnc;
2089                    viewDate.subtract(datePickerModes[currentViewMode].navStep, navFnc);
2090                    fillDate();
2091                    viewUpdate(navFnc);
2092                },
2093
2094                pickerSwitch: function () {
2095                    showMode(1);
2096                },
2097
2098                selectMonth: function (e) {
2099                    var month = $(e.target).closest('tbody').find('span').index($(e.target));
2100                    viewDate.month(month);
2101                    if (currentViewMode === minViewModeNumber) {
2102                        setValue(date.clone().year(viewDate.year()).month(viewDate.month()));
2103                        if (!options.inline) {
2104                            hide();
2105                        }
2106                    } else {
2107                        showMode(-1);
2108                        fillDate();
2109                    }
2110                    viewUpdate('M');
2111                },
2112
2113                selectYear: function (e) {
2114                    var year = parseInt($(e.target).text(), 10) || 0;
2115                    viewDate.year(year);
2116                    if (currentViewMode === minViewModeNumber) {
2117                        setValue(date.clone().year(viewDate.year()));
2118                        if (!options.inline) {
2119                            hide();
2120                        }
2121                    } else {
2122                        showMode(-1);
2123                        fillDate();
2124                    }
2125                    viewUpdate('YYYY');
2126                },
2127
2128                selectDecade: function (e) {
2129                    var year = parseInt($(e.target).data('selection'), 10) || 0;
2130                    viewDate.year(year);
2131                    if (currentViewMode === minViewModeNumber) {
2132                        setValue(date.clone().year(viewDate.year()));
2133                        if (!options.inline) {
2134                            hide();
2135                        }
2136                    } else {
2137                        showMode(-1);
2138                        fillDate();
2139                    }
2140                    viewUpdate('YYYY');
2141                },
2142
2143                selectDay: function (e) {
2144                    var day = viewDate.clone();
2145                    if ($(e.target).is('.old')) {
2146                        day.subtract(1, 'M');
2147                    }
2148                    if ($(e.target).is('.new')) {
2149                        day.add(1, 'M');
2150                    }
2151                    setValue(day.date(parseInt($(e.target).text(), 10)));
2152                    if (!hasTime() && !options.keepOpen && !options.inline) {
2153                        hide();
2154                    }
2155                },
2156
2157                incrementHours: function () {
2158                    var newDate = date.clone().add(1, 'h');
2159                    if (isValid(newDate, 'h')) {
2160                        setValue(newDate);
2161                    }
2162                },
2163
2164                incrementMinutes: function () {
2165                    var newDate = date.clone().add(options.stepping, 'm');
2166                    if (isValid(newDate, 'm')) {
2167                        setValue(newDate);
2168                    }
2169                },
2170
2171                incrementSeconds: function () {
2172                    var newDate = date.clone().add(1, 's');
2173                    if (isValid(newDate, 's')) {
2174                        setValue(newDate);
2175                    }
2176                },
2177
2178                decrementHours: function () {
2179                    var newDate = date.clone().subtract(1, 'h');
2180                    if (isValid(newDate, 'h')) {
2181                        setValue(newDate);
2182                    }
2183                },
2184
2185                decrementMinutes: function () {
2186                    var newDate = date.clone().subtract(options.stepping, 'm');
2187                    if (isValid(newDate, 'm')) {
2188                        setValue(newDate);
2189                    }
2190                },
2191
2192                decrementSeconds: function () {
2193                    var newDate = date.clone().subtract(1, 's');
2194                    if (isValid(newDate, 's')) {
2195                        setValue(newDate);
2196                    }
2197                },
2198
2199                togglePeriod: function () {
2200                    setValue(date.clone().add((date.hours() >= 12) ? -12 : 12, 'h'));
2201                },
2202
2203                togglePicker: function (e) {
2204                    var $this = $(e.target),
2205                        $parent = $this.closest('ul'),
2206                        expanded = $parent.find('.in'),
2207                        closed = $parent.find('.collapse:not(.in)'),
2208                        collapseData;
2209
2210                    if (expanded && expanded.length) {
2211                        collapseData = expanded.data('collapse');
2212                        if (collapseData && collapseData.transitioning) {
2213                            return;
2214                        }
2215                        if (expanded.collapse) { // if collapse plugin is available through bootstrap.js then use it
2216                            expanded.collapse('hide');
2217                            closed.collapse('show');
2218                        } else { // otherwise just toggle in class on the two views
2219                            expanded.removeClass('in');
2220                            closed.addClass('in');
2221                        }
2222                        if ($this.is('span')) {
2223                            $this.toggleClass(options.icons.time + ' ' + options.icons.date);
2224                        } else {
2225                            $this.find('span').toggleClass(options.icons.time + ' ' + options.icons.date);
2226                        }
2227
2228                        // NOTE: uncomment if toggled state will be restored in show()
2229                        //if (component) {
2230                        //    component.find('span').toggleClass(options.icons.time + ' ' + options.icons.date);
2231                        //}
2232                    }
2233                },
2234
2235                showPicker: function () {
2236                    widget.find('.timepicker > div:not(.timepicker-picker)').hide();
2237                    widget.find('.timepicker .timepicker-picker').show();
2238                },
2239
2240                showHours: function () {
2241                    widget.find('.timepicker .timepicker-picker').hide();
2242                    widget.find('.timepicker .timepicker-hours').show();
2243                },
2244
2245                showMinutes: function () {
2246                    widget.find('.timepicker .timepicker-picker').hide();
2247                    widget.find('.timepicker .timepicker-minutes').show();
2248                },
2249
2250                showSeconds: function () {
2251                    widget.find('.timepicker .timepicker-picker').hide();
2252                    widget.find('.timepicker .timepicker-seconds').show();
2253                },
2254
2255                selectHour: function (e) {
2256                    var hour = parseInt($(e.target).text(), 10);
2257
2258                    if (!use24Hours) {
2259                        if (date.hours() >= 12) {
2260                            if (hour !== 12) {
2261                                hour += 12;
2262                            }
2263                        } else {
2264                            if (hour === 12) {
2265                                hour = 0;
2266                            }
2267                        }
2268                    }
2269                    setValue(date.clone().hours(hour));
2270                    actions.showPicker.call(picker);
2271                },
2272
2273                selectMinute: function (e) {
2274                    setValue(date.clone().minutes(parseInt($(e.target).text(), 10)));
2275                    actions.showPicker.call(picker);
2276                },
2277
2278                selectSecond: function (e) {
2279                    setValue(date.clone().seconds(parseInt($(e.target).text(), 10)));
2280                    actions.showPicker.call(picker);
2281                },
2282
2283                clear: clear,
2284
2285                today: function () {
2286                    var todaysDate = getMoment();
2287                    if (isValid(todaysDate, 'd')) {
2288                        setValue(todaysDate);
2289                    }
2290                },
2291
2292                close: hide
2293            },
2294
2295            doAction = function (e) {
2296                if ($(e.currentTarget).is('.disabled')) {
2297                    return false;
2298                }
2299                actions[$(e.currentTarget).data('action')].apply(picker, arguments);
2300                return false;
2301            },
2302
2303            /**
2304             * Shows the widget. Possibly will emit dp.show and dp.change
2305             */
2306            show = function () {
2307                var currentMoment,
2308                    useCurrentGranularity = {
2309                        'year': function (m) {
2310                            return m.month(0).date(1).hours(0).seconds(0).minutes(0);
2311                        },
2312                        'month': function (m) {
2313                            return m.date(1).hours(0).seconds(0).minutes(0);
2314                        },
2315                        'day': function (m) {
2316                            return m.hours(0).seconds(0).minutes(0);
2317                        },
2318                        'hour': function (m) {
2319                            return m.seconds(0).minutes(0);
2320                        },
2321                        'minute': function (m) {
2322                            return m.seconds(0);
2323                        }
2324                    };
2325
2326                if (input.prop('disabled') || (!options.ignoreReadonly && input.prop('readonly')) || widget) {
2327                    return picker;
2328                }
2329                if (input.val() !== undefined && input.val().trim().length !== 0) {
2330                    setValue(parseInputDate(input.val().trim()));
2331                } else if (unset && options.useCurrent && (options.inline || (input.is('input') && input.val().trim().length === 0))) {
2332                    currentMoment = getMoment();
2333                    if (typeof options.useCurrent === 'string') {
2334                        currentMoment = useCurrentGranularity[options.useCurrent](currentMoment);
2335                    }
2336                    setValue(currentMoment);
2337                }
2338                widget = getTemplate();
2339
2340                fillDow();
2341                fillMonths();
2342
2343                widget.find('.timepicker-hours').hide();
2344                widget.find('.timepicker-minutes').hide();
2345                widget.find('.timepicker-seconds').hide();
2346
2347                update();
2348                showMode();
2349
2350                $(window).on('resize', place);
2351                widget.on('click', '[data-action]', doAction); // this handles clicks on the widget
2352                widget.on('mousedown', false);
2353
2354                if (component && component.hasClass('btn')) {
2355                    component.toggleClass('active');
2356                }
2357                place();
2358                widget.show();
2359                if (options.focusOnShow && !input.is(':focus')) {
2360                    input.focus();
2361                }
2362
2363                notifyEvent({
2364                    type: 'dp.show'
2365                });
2366                return picker;
2367            },
2368
2369            /**
2370             * Shows or hides the widget
2371             */
2372            toggle = function () {
2373                return (widget ? hide() : show());
2374            },
2375
2376            keydown = function (e) {
2377                var handler = null,
2378                    index,
2379                    index2,
2380                    pressedKeys = [],
2381                    pressedModifiers = {},
2382                    currentKey = e.which,
2383                    keyBindKeys,
2384                    allModifiersPressed,
2385                    pressed = 'p';
2386
2387                keyState[currentKey] = pressed;
2388
2389                for (index in keyState) {
2390                    if (keyState.hasOwnProperty(index) && keyState[index] === pressed) {
2391                        pressedKeys.push(index);
2392                        if (parseInt(index, 10) !== currentKey) {
2393                            pressedModifiers[index] = true;
2394                        }
2395                    }
2396                }
2397
2398                for (index in options.keyBinds) {
2399                    if (options.keyBinds.hasOwnProperty(index) && typeof (options.keyBinds[index]) === 'function') {
2400                        keyBindKeys = index.split(' ');
2401                        if (keyBindKeys.length === pressedKeys.length && keyMap[currentKey] === keyBindKeys[keyBindKeys.length - 1]) {
2402                            allModifiersPressed = true;
2403                            for (index2 = keyBindKeys.length - 2; index2 >= 0; index2--) {
2404                                if (!(keyMap[keyBindKeys[index2]] in pressedModifiers)) {
2405                                    allModifiersPressed = false;
2406                                    break;
2407                                }
2408                            }
2409                            if (allModifiersPressed) {
2410                                handler = options.keyBinds[index];
2411                                break;
2412                            }
2413                        }
2414                    }
2415                }
2416
2417                if (handler) {
2418                    handler.call(picker, widget);
2419                    e.stopPropagation();
2420                    e.preventDefault();
2421                }
2422            },
2423
2424            keyup = function (e) {
2425                keyState[e.which] = 'r';
2426                e.stopPropagation();
2427                e.preventDefault();
2428            },
2429
2430            change = function (e) {
2431                var val = $(e.target).val().trim(),
2432                    parsedDate = val ? parseInputDate(val) : null;
2433                setValue(parsedDate);
2434                e.stopImmediatePropagation();
2435                return false;
2436            },
2437
2438            attachDatePickerElementEvents = function () {
2439                input.on({
2440                    'change': change,
2441                    'blur': options.debug ? '' : hide,
2442                    'keydown': keydown,
2443                    'keyup': keyup,
2444                    'focus': options.allowInputToggle ? show : ''
2445                });
2446
2447                if (element.is('input')) {
2448                    input.on({
2449                        'focus': show
2450                    });
2451                } else if (component) {
2452                    component.on('click', toggle);
2453                    component.on('mousedown', false);
2454                }
2455            },
2456
2457            detachDatePickerElementEvents = function () {
2458                input.off({
2459                    'change': change,
2460                    'blur': blur,
2461                    'keydown': keydown,
2462                    'keyup': keyup,
2463                    'focus': options.allowInputToggle ? hide : ''
2464                });
2465
2466                if (element.is('input')) {
2467                    input.off({
2468                        'focus': show
2469                    });
2470                } else if (component) {
2471                    component.off('click', toggle);
2472                    component.off('mousedown', false);
2473                }
2474            },
2475
2476            indexGivenDates = function (givenDatesArray) {
2477                // Store given enabledDates and disabledDates as keys.
2478                // This way we can check their existence in O(1) time instead of looping through whole array.
2479                // (for example: options.enabledDates['2014-02-27'] === true)
2480                var givenDatesIndexed = {};
2481                $.each(givenDatesArray, function () {
2482                    var dDate = parseInputDate(this);
2483                    if (dDate.isValid()) {
2484                        givenDatesIndexed[dDate.format('YYYY-MM-DD')] = true;
2485                    }
2486                });
2487                return (Object.keys(givenDatesIndexed).length) ? givenDatesIndexed : false;
2488            },
2489
2490            indexGivenHours = function (givenHoursArray) {
2491                // Store given enabledHours and disabledHours as keys.
2492                // This way we can check their existence in O(1) time instead of looping through whole array.
2493                // (for example: options.enabledHours['2014-02-27'] === true)
2494                var givenHoursIndexed = {};
2495                $.each(givenHoursArray, function () {
2496                    givenHoursIndexed[this] = true;
2497                });
2498                return (Object.keys(givenHoursIndexed).length) ? givenHoursIndexed : false;
2499            },
2500
2501            initFormatting = function () {
2502                var format = options.format || 'L LT';
2503
2504                actualFormat = format.replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function (formatInput) {
2505                    var newinput = date.localeData().longDateFormat(formatInput) || formatInput;
2506                    return newinput.replace(/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, function (formatInput2) { //temp fix for #740
2507                        return date.localeData().longDateFormat(formatInput2) || formatInput2;
2508                    });
2509                });
2510
2511
2512                parseFormats = options.extraFormats ? options.extraFormats.slice() : [];
2513                if (parseFormats.indexOf(format) < 0 && parseFormats.indexOf(actualFormat) < 0) {
2514                    parseFormats.push(actualFormat);
2515                }
2516
2517                use24Hours = (actualFormat.toLowerCase().indexOf('a') < 1 && actualFormat.replace(/\[.*?\]/g, '').indexOf('h') < 1);
2518
2519                if (isEnabled('y')) {
2520                    minViewModeNumber = 2;
2521                }
2522                if (isEnabled('M')) {
2523                    minViewModeNumber = 1;
2524                }
2525                if (isEnabled('d')) {
2526                    minViewModeNumber = 0;
2527                }
2528
2529                currentViewMode = Math.max(minViewModeNumber, currentViewMode);
2530
2531                if (!unset) {
2532                    setValue(date);
2533                }
2534            };
2535
2536        /********************************************************************************
2537         *
2538         * Public API functions
2539         * =====================
2540         *
2541         * Important: Do not expose direct references to private objects or the options
2542         * object to the outer world. Always return a clone when returning values or make
2543         * a clone when setting a private variable.
2544         *
2545         ********************************************************************************/
2546        picker.destroy = function () {
2547            ///<summary>Destroys the widget and removes all attached event listeners</summary>
2548            hide();
2549            detachDatePickerElementEvents();
2550            element.removeData('DateTimePicker');
2551            element.removeData('date');
2552        };
2553
2554        picker.toggle = toggle;
2555
2556        picker.show = show;
2557
2558        picker.hide = hide;
2559
2560        picker.disable = function () {
2561            ///<summary>Disables the input element, the component is attached to, by adding a disabled="true" attribute to it.
2562            ///If the widget was visible before that call it is hidden. Possibly emits dp.hide</summary>
2563            hide();
2564            if (component && component.hasClass('btn')) {
2565                component.addClass('disabled');
2566            }
2567            input.prop('disabled', true);
2568            return picker;
2569        };
2570
2571        picker.enable = function () {
2572            ///<summary>Enables the input element, the component is attached to, by removing disabled attribute from it.</summary>
2573            if (component && component.hasClass('btn')) {
2574                component.removeClass('disabled');
2575            }
2576            input.prop('disabled', false);
2577            return picker;
2578        };
2579
2580        picker.ignoreReadonly = function (ignoreReadonly) {
2581            if (arguments.length === 0) {
2582                return options.ignoreReadonly;
2583            }
2584            if (typeof ignoreReadonly !== 'boolean') {
2585                throw new TypeError('ignoreReadonly () expects a boolean parameter');
2586            }
2587            options.ignoreReadonly = ignoreReadonly;
2588            return picker;
2589        };
2590
2591        picker.options = function (newOptions) {
2592            if (arguments.length === 0) {
2593                return $.extend(true, {}, options);
2594            }
2595
2596            if (!(newOptions instanceof Object)) {
2597                throw new TypeError('options() options parameter should be an object');
2598            }
2599            $.extend(true, options, newOptions);
2600            $.each(options, function (key, value) {
2601                if (picker[key] !== undefined) {
2602                    picker[key](value);
2603                } else {
2604                    throw new TypeError('option ' + key + ' is not recognized!');
2605                }
2606            });
2607            return picker;
2608        };
2609
2610        picker.date = function (newDate) {
2611            ///<signature helpKeyword="$.fn.datetimepicker.date">
2612            ///<summary>Returns the component's model current date, a moment object or null if not set.</summary>
2613            ///<returns type="Moment">date.clone()</returns>
2614            ///</signature>
2615            ///<signature>
2616            ///<summary>Sets the components model current moment to it. Passing a null value unsets the components model current moment. Parsing of the newDate parameter is made using moment library with the options.format and options.useStrict components configuration.</summary>
2617            ///<param name="newDate" locid="$.fn.datetimepicker.date_p:newDate">Takes string, Date, moment, null parameter.</param>
2618            ///</signature>
2619            if (arguments.length === 0) {
2620                if (unset) {
2621                    return null;
2622                }
2623                return date.clone();
2624            }
2625
2626            if (newDate !== null && typeof newDate !== 'string' && !moment.isMoment(newDate) && !(newDate instanceof Date)) {
2627                throw new TypeError('date() parameter must be one of [null, string, moment or Date]');
2628            }
2629
2630            setValue(newDate === null ? null : parseInputDate(newDate));
2631            return picker;
2632        };
2633
2634        picker.format = function (newFormat) {
2635            ///<summary>test su</summary>
2636            ///<param name="newFormat">info about para</param>
2637            ///<returns type="string|boolean">returns foo</returns>
2638            if (arguments.length === 0) {
2639                return options.format;
2640            }
2641
2642            if ((typeof newFormat !== 'string') && ((typeof newFormat !== 'boolean') || (newFormat !== false))) {
2643                throw new TypeError('format() expects a string or boolean:false parameter ' + newFormat);
2644            }
2645
2646            options.format = newFormat;
2647            if (actualFormat) {
2648                initFormatting(); // reinit formatting
2649            }
2650            return picker;
2651        };
2652
2653        picker.timeZone = function (newZone) {
2654            if (arguments.length === 0) {
2655                return options.timeZone;
2656            }
2657
2658            if (typeof newZone !== 'string') {
2659                throw new TypeError('newZone() expects a string parameter');
2660            }
2661
2662            options.timeZone = newZone;
2663
2664            return picker;
2665        };
2666
2667        picker.dayViewHeaderFormat = function (newFormat) {
2668            if (arguments.length === 0) {
2669                return options.dayViewHeaderFormat;
2670            }
2671
2672            if (typeof newFormat !== 'string') {
2673                throw new TypeError('dayViewHeaderFormat() expects a string parameter');
2674            }
2675
2676            options.dayViewHeaderFormat = newFormat;
2677            return picker;
2678        };
2679
2680        picker.extraFormats = function (formats) {
2681            if (arguments.length === 0) {
2682                return options.extraFormats;
2683            }
2684
2685            if (formats !== false && !(formats instanceof Array)) {
2686                throw new TypeError('extraFormats() expects an array or false parameter');
2687            }
2688
2689            options.extraFormats = formats;
2690            if (parseFormats) {
2691                initFormatting(); // reinit formatting
2692            }
2693            return picker;
2694        };
2695
2696        picker.disabledDates = function (dates) {
2697            ///<signature helpKeyword="$.fn.datetimepicker.disabledDates">
2698            ///<summary>Returns an array with the currently set disabled dates on the component.</summary>
2699            ///<returns type="array">options.disabledDates</returns>
2700            ///</signature>
2701            ///<signature>
2702            ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
2703            ///options.enabledDates if such exist.</summary>
2704            ///<param name="dates" locid="$.fn.datetimepicker.disabledDates_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
2705            ///</signature>
2706            if (arguments.length === 0) {
2707                return (options.disabledDates ? $.extend({}, options.disabledDates) : options.disabledDates);
2708            }
2709
2710            if (!dates) {
2711                options.disabledDates = false;
2712                update();
2713                return picker;
2714            }
2715            if (!(dates instanceof Array)) {
2716                throw new TypeError('disabledDates() expects an array parameter');
2717            }
2718            options.disabledDates = indexGivenDates(dates);
2719            options.enabledDates = false;
2720            update();
2721            return picker;
2722        };
2723
2724        picker.enabledDates = function (dates) {
2725            ///<signature helpKeyword="$.fn.datetimepicker.enabledDates">
2726            ///<summary>Returns an array with the currently set enabled dates on the component.</summary>
2727            ///<returns type="array">options.enabledDates</returns>
2728            ///</signature>
2729            ///<signature>
2730            ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of options.disabledDates if such exist.</summary>
2731            ///<param name="dates" locid="$.fn.datetimepicker.enabledDates_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
2732            ///</signature>
2733            if (arguments.length === 0) {
2734                return (options.enabledDates ? $.extend({}, options.enabledDates) : options.enabledDates);
2735            }
2736
2737            if (!dates) {
2738                options.enabledDates = false;
2739                update();
2740                return picker;
2741            }
2742            if (!(dates instanceof Array)) {
2743                throw new TypeError('enabledDates() expects an array parameter');
2744            }
2745            options.enabledDates = indexGivenDates(dates);
2746            options.disabledDates = false;
2747            update();
2748            return picker;
2749        };
2750
2751        picker.daysOfWeekDisabled = function (daysOfWeekDisabled) {
2752            if (arguments.length === 0) {
2753                return options.daysOfWeekDisabled.splice(0);
2754            }
2755
2756            if ((typeof daysOfWeekDisabled === 'boolean') && !daysOfWeekDisabled) {
2757                options.daysOfWeekDisabled = false;
2758                update();
2759                return picker;
2760            }
2761
2762            if (!(daysOfWeekDisabled instanceof Array)) {
2763                throw new TypeError('daysOfWeekDisabled() expects an array parameter');
2764            }
2765            options.daysOfWeekDisabled = daysOfWeekDisabled.reduce(function (previousValue, currentValue) {
2766                currentValue = parseInt(currentValue, 10);
2767                if (currentValue > 6 || currentValue < 0 || isNaN(currentValue)) {
2768                    return previousValue;
2769                }
2770                if (previousValue.indexOf(currentValue) === -1) {
2771                    previousValue.push(currentValue);
2772                }
2773                return previousValue;
2774            }, []).sort();
2775            if (options.useCurrent && !options.keepInvalid) {
2776                var tries = 0;
2777                while (!isValid(date, 'd')) {
2778                    date.add(1, 'd');
2779                    if (tries === 31) {
2780                        throw 'Tried 31 times to find a valid date';
2781                    }
2782                    tries++;
2783                }
2784                setValue(date);
2785            }
2786            update();
2787            return picker;
2788        };
2789
2790        picker.maxDate = function (maxDate) {
2791            if (arguments.length === 0) {
2792                return options.maxDate ? options.maxDate.clone() : options.maxDate;
2793            }
2794
2795            if ((typeof maxDate === 'boolean') && maxDate === false) {
2796                options.maxDate = false;
2797                update();
2798                return picker;
2799            }
2800
2801            if (typeof maxDate === 'string') {
2802                if (maxDate === 'now' || maxDate === 'moment') {
2803                    maxDate = getMoment();
2804                }
2805            }
2806
2807            var parsedDate = parseInputDate(maxDate);
2808
2809            if (!parsedDate.isValid()) {
2810                throw new TypeError('maxDate() Could not parse date parameter: ' + maxDate);
2811            }
2812            if (options.minDate && parsedDate.isBefore(options.minDate)) {
2813                throw new TypeError('maxDate() date parameter is before options.minDate: ' + parsedDate.format(actualFormat));
2814            }
2815            options.maxDate = parsedDate;
2816            if (options.useCurrent && !options.keepInvalid && date.isAfter(maxDate)) {
2817                setValue(options.maxDate);
2818            }
2819            if (viewDate.isAfter(parsedDate)) {
2820                viewDate = parsedDate.clone().subtract(options.stepping, 'm');
2821            }
2822            update();
2823            return picker;
2824        };
2825
2826        picker.minDate = function (minDate) {
2827            if (arguments.length === 0) {
2828                return options.minDate ? options.minDate.clone() : options.minDate;
2829            }
2830
2831            if ((typeof minDate === 'boolean') && minDate === false) {
2832                options.minDate = false;
2833                update();
2834                return picker;
2835            }
2836
2837            if (typeof minDate === 'string') {
2838                if (minDate === 'now' || minDate === 'moment') {
2839                    minDate = getMoment();
2840                }
2841            }
2842
2843            var parsedDate = parseInputDate(minDate);
2844
2845            if (!parsedDate.isValid()) {
2846                throw new TypeError('minDate() Could not parse date parameter: ' + minDate);
2847            }
2848            if (options.maxDate && parsedDate.isAfter(options.maxDate)) {
2849                throw new TypeError('minDate() date parameter is after options.maxDate: ' + parsedDate.format(actualFormat));
2850            }
2851            options.minDate = parsedDate;
2852            if (options.useCurrent && !options.keepInvalid && date.isBefore(minDate)) {
2853                setValue(options.minDate);
2854            }
2855            if (viewDate.isBefore(parsedDate)) {
2856                viewDate = parsedDate.clone().add(options.stepping, 'm');
2857            }
2858            update();
2859            return picker;
2860        };
2861
2862        picker.defaultDate = function (defaultDate) {
2863            ///<signature helpKeyword="$.fn.datetimepicker.defaultDate">
2864            ///<summary>Returns a moment with the options.defaultDate option configuration or false if not set</summary>
2865            ///<returns type="Moment">date.clone()</returns>
2866            ///</signature>
2867            ///<signature>
2868            ///<summary>Will set the picker's inital date. If a boolean:false value is passed the options.defaultDate parameter is cleared.</summary>
2869            ///<param name="defaultDate" locid="$.fn.datetimepicker.defaultDate_p:defaultDate">Takes a string, Date, moment, boolean:false</param>
2870            ///</signature>
2871            if (arguments.length === 0) {
2872                return options.defaultDate ? options.defaultDate.clone() : options.defaultDate;
2873            }
2874            if (!defaultDate) {
2875                options.defaultDate = false;
2876                return picker;
2877            }
2878
2879            if (typeof defaultDate === 'string') {
2880                if (defaultDate === 'now' || defaultDate === 'moment') {
2881                    defaultDate = getMoment();
2882                } else {
2883                    defaultDate = getMoment(defaultDate);
2884                }
2885            }
2886
2887            var parsedDate = parseInputDate(defaultDate);
2888            if (!parsedDate.isValid()) {
2889                throw new TypeError('defaultDate() Could not parse date parameter: ' + defaultDate);
2890            }
2891            if (!isValid(parsedDate)) {
2892                throw new TypeError('defaultDate() date passed is invalid according to component setup validations');
2893            }
2894
2895            options.defaultDate = parsedDate;
2896
2897            if ((options.defaultDate && options.inline) || input.val().trim() === '') {
2898                setValue(options.defaultDate);
2899            }
2900            return picker;
2901        };
2902
2903        picker.locale = function (locale) {
2904            if (arguments.length === 0) {
2905                return options.locale;
2906            }
2907
2908            if (!moment.localeData(locale)) {
2909                throw new TypeError('locale() locale ' + locale + ' is not loaded from moment locales!');
2910            }
2911
2912            options.locale = locale;
2913            date.locale(options.locale);
2914            viewDate.locale(options.locale);
2915
2916            if (actualFormat) {
2917                initFormatting(); // reinit formatting
2918            }
2919            if (widget) {
2920                hide();
2921                show();
2922            }
2923            return picker;
2924        };
2925
2926        picker.stepping = function (stepping) {
2927            if (arguments.length === 0) {
2928                return options.stepping;
2929            }
2930
2931            stepping = parseInt(stepping, 10);
2932            if (isNaN(stepping) || stepping < 1) {
2933                stepping = 1;
2934            }
2935            options.stepping = stepping;
2936            return picker;
2937        };
2938
2939        picker.useCurrent = function (useCurrent) {
2940            var useCurrentOptions = ['year', 'month', 'day', 'hour', 'minute'];
2941            if (arguments.length === 0) {
2942                return options.useCurrent;
2943            }
2944
2945            if ((typeof useCurrent !== 'boolean') && (typeof useCurrent !== 'string')) {
2946                throw new TypeError('useCurrent() expects a boolean or string parameter');
2947            }
2948            if (typeof useCurrent === 'string' && useCurrentOptions.indexOf(useCurrent.toLowerCase()) === -1) {
2949                throw new TypeError('useCurrent() expects a string parameter of ' + useCurrentOptions.join(', '));
2950            }
2951            options.useCurrent = useCurrent;
2952            return picker;
2953        };
2954
2955        picker.collapse = function (collapse) {
2956            if (arguments.length === 0) {
2957                return options.collapse;
2958            }
2959
2960            if (typeof collapse !== 'boolean') {
2961                throw new TypeError('collapse() expects a boolean parameter');
2962            }
2963            if (options.collapse === collapse) {
2964                return picker;
2965            }
2966            options.collapse = collapse;
2967            if (widget) {
2968                hide();
2969                show();
2970            }
2971            return picker;
2972        };
2973
2974        picker.icons = function (icons) {
2975            if (arguments.length === 0) {
2976                return $.extend({}, options.icons);
2977            }
2978
2979            if (!(icons instanceof Object)) {
2980                throw new TypeError('icons() expects parameter to be an Object');
2981            }
2982            $.extend(options.icons, icons);
2983            if (widget) {
2984                hide();
2985                show();
2986            }
2987            return picker;
2988        };
2989
2990        picker.tooltips = function (tooltips) {
2991            if (arguments.length === 0) {
2992                return $.extend({}, options.tooltips);
2993            }
2994
2995            if (!(tooltips instanceof Object)) {
2996                throw new TypeError('tooltips() expects parameter to be an Object');
2997            }
2998            $.extend(options.tooltips, tooltips);
2999            if (widget) {
3000                hide();
3001                show();
3002            }
3003            return picker;
3004        };
3005
3006        picker.useStrict = function (useStrict) {
3007            if (arguments.length === 0) {
3008                return options.useStrict;
3009            }
3010
3011            if (typeof useStrict !== 'boolean') {
3012                throw new TypeError('useStrict() expects a boolean parameter');
3013            }
3014            options.useStrict = useStrict;
3015            return picker;
3016        };
3017
3018        picker.sideBySide = function (sideBySide) {
3019            if (arguments.length === 0) {
3020                return options.sideBySide;
3021            }
3022
3023            if (typeof sideBySide !== 'boolean') {
3024                throw new TypeError('sideBySide() expects a boolean parameter');
3025            }
3026            options.sideBySide = sideBySide;
3027            if (widget) {
3028                hide();
3029                show();
3030            }
3031            return picker;
3032        };
3033
3034        picker.viewMode = function (viewMode) {
3035            if (arguments.length === 0) {
3036                return options.viewMode;
3037            }
3038
3039            if (typeof viewMode !== 'string') {
3040                throw new TypeError('viewMode() expects a string parameter');
3041            }
3042
3043            if (viewModes.indexOf(viewMode) === -1) {
3044                throw new TypeError('viewMode() parameter must be one of (' + viewModes.join(', ') + ') value');
3045            }
3046
3047            options.viewMode = viewMode;
3048            currentViewMode = Math.max(viewModes.indexOf(viewMode), minViewModeNumber);
3049
3050            showMode();
3051            return picker;
3052        };
3053
3054        picker.toolbarPlacement = function (toolbarPlacement) {
3055            if (arguments.length === 0) {
3056                return options.toolbarPlacement;
3057            }
3058
3059            if (typeof toolbarPlacement !== 'string') {
3060                throw new TypeError('toolbarPlacement() expects a string parameter');
3061            }
3062            if (toolbarPlacements.indexOf(toolbarPlacement) === -1) {
3063                throw new TypeError('toolbarPlacement() parameter must be one of (' + toolbarPlacements.join(', ') + ') value');
3064            }
3065            options.toolbarPlacement = toolbarPlacement;
3066
3067            if (widget) {
3068                hide();
3069                show();
3070            }
3071            return picker;
3072        };
3073
3074        picker.widgetPositioning = function (widgetPositioning) {
3075            if (arguments.length === 0) {
3076                return $.extend({}, options.widgetPositioning);
3077            }
3078
3079            if (({}).toString.call(widgetPositioning) !== '[object Object]') {
3080                throw new TypeError('widgetPositioning() expects an object variable');
3081            }
3082            if (widgetPositioning.horizontal) {
3083                if (typeof widgetPositioning.horizontal !== 'string') {
3084                    throw new TypeError('widgetPositioning() horizontal variable must be a string');
3085                }
3086                widgetPositioning.horizontal = widgetPositioning.horizontal.toLowerCase();
3087                if (horizontalModes.indexOf(widgetPositioning.horizontal) === -1) {
3088                    throw new TypeError('widgetPositioning() expects horizontal parameter to be one of (' + horizontalModes.join(', ') + ')');
3089                }
3090                options.widgetPositioning.horizontal = widgetPositioning.horizontal;
3091            }
3092            if (widgetPositioning.vertical) {
3093                if (typeof widgetPositioning.vertical !== 'string') {
3094                    throw new TypeError('widgetPositioning() vertical variable must be a string');
3095                }
3096                widgetPositioning.vertical = widgetPositioning.vertical.toLowerCase();
3097                if (verticalModes.indexOf(widgetPositioning.vertical) === -1) {
3098                    throw new TypeError('widgetPositioning() expects vertical parameter to be one of (' + verticalModes.join(', ') + ')');
3099                }
3100                options.widgetPositioning.vertical = widgetPositioning.vertical;
3101            }
3102            update();
3103            return picker;
3104        };
3105
3106        picker.calendarWeeks = function (calendarWeeks) {
3107            if (arguments.length === 0) {
3108                return options.calendarWeeks;
3109            }
3110
3111            if (typeof calendarWeeks !== 'boolean') {
3112                throw new TypeError('calendarWeeks() expects parameter to be a boolean value');
3113            }
3114
3115            options.calendarWeeks = calendarWeeks;
3116            update();
3117            return picker;
3118        };
3119
3120        picker.showTodayButton = function (showTodayButton) {
3121            if (arguments.length === 0) {
3122                return options.showTodayButton;
3123            }
3124
3125            if (typeof showTodayButton !== 'boolean') {
3126                throw new TypeError('showTodayButton() expects a boolean parameter');
3127            }
3128
3129            options.showTodayButton = showTodayButton;
3130            if (widget) {
3131                hide();
3132                show();
3133            }
3134            return picker;
3135        };
3136
3137        picker.showClear = function (showClear) {
3138            if (arguments.length === 0) {
3139                return options.showClear;
3140            }
3141
3142            if (typeof showClear !== 'boolean') {
3143                throw new TypeError('showClear() expects a boolean parameter');
3144            }
3145
3146            options.showClear = showClear;
3147            if (widget) {
3148                hide();
3149                show();
3150            }
3151            return picker;
3152        };
3153
3154        picker.widgetParent = function (widgetParent) {
3155            if (arguments.length === 0) {
3156                return options.widgetParent;
3157            }
3158
3159            if (typeof widgetParent === 'string') {
3160                widgetParent = $(widgetParent);
3161            }
3162
3163            if (widgetParent !== null && (typeof widgetParent !== 'string' && !(widgetParent instanceof $))) {
3164                throw new TypeError('widgetParent() expects a string or a jQuery object parameter');
3165            }
3166
3167            options.widgetParent = widgetParent;
3168            if (widget) {
3169                hide();
3170                show();
3171            }
3172            return picker;
3173        };
3174
3175        picker.keepOpen = function (keepOpen) {
3176            if (arguments.length === 0) {
3177                return options.keepOpen;
3178            }
3179
3180            if (typeof keepOpen !== 'boolean') {
3181                throw new TypeError('keepOpen() expects a boolean parameter');
3182            }
3183
3184            options.keepOpen = keepOpen;
3185            return picker;
3186        };
3187
3188        picker.focusOnShow = function (focusOnShow) {
3189            if (arguments.length === 0) {
3190                return options.focusOnShow;
3191            }
3192
3193            if (typeof focusOnShow !== 'boolean') {
3194                throw new TypeError('focusOnShow() expects a boolean parameter');
3195            }
3196
3197            options.focusOnShow = focusOnShow;
3198            return picker;
3199        };
3200
3201        picker.inline = function (inline) {
3202            if (arguments.length === 0) {
3203                return options.inline;
3204            }
3205
3206            if (typeof inline !== 'boolean') {
3207                throw new TypeError('inline() expects a boolean parameter');
3208            }
3209
3210            options.inline = inline;
3211            return picker;
3212        };
3213
3214        picker.clear = function () {
3215            clear();
3216            return picker;
3217        };
3218
3219        picker.keyBinds = function (keyBinds) {
3220            if (arguments.length === 0) {
3221                return options.keyBinds;
3222            }
3223
3224            options.keyBinds = keyBinds;
3225            return picker;
3226        };
3227
3228        picker.getMoment = function (d) {
3229            return getMoment(d);
3230        };
3231
3232        picker.debug = function (debug) {
3233            if (typeof debug !== 'boolean') {
3234                throw new TypeError('debug() expects a boolean parameter');
3235            }
3236
3237            options.debug = debug;
3238            return picker;
3239        };
3240
3241        picker.allowInputToggle = function (allowInputToggle) {
3242            if (arguments.length === 0) {
3243                return options.allowInputToggle;
3244            }
3245
3246            if (typeof allowInputToggle !== 'boolean') {
3247                throw new TypeError('allowInputToggle() expects a boolean parameter');
3248            }
3249
3250            options.allowInputToggle = allowInputToggle;
3251            return picker;
3252        };
3253
3254        picker.showClose = function (showClose) {
3255            if (arguments.length === 0) {
3256                return options.showClose;
3257            }
3258
3259            if (typeof showClose !== 'boolean') {
3260                throw new TypeError('showClose() expects a boolean parameter');
3261            }
3262
3263            options.showClose = showClose;
3264            return picker;
3265        };
3266
3267        picker.keepInvalid = function (keepInvalid) {
3268            if (arguments.length === 0) {
3269                return options.keepInvalid;
3270            }
3271
3272            if (typeof keepInvalid !== 'boolean') {
3273                throw new TypeError('keepInvalid() expects a boolean parameter');
3274            }
3275            options.keepInvalid = keepInvalid;
3276            return picker;
3277        };
3278
3279        picker.datepickerInput = function (datepickerInput) {
3280            if (arguments.length === 0) {
3281                return options.datepickerInput;
3282            }
3283
3284            if (typeof datepickerInput !== 'string') {
3285                throw new TypeError('datepickerInput() expects a string parameter');
3286            }
3287
3288            options.datepickerInput = datepickerInput;
3289            return picker;
3290        };
3291
3292        picker.parseInputDate = function (parseInputDate) {
3293            if (arguments.length === 0) {
3294                return options.parseInputDate;
3295            }
3296
3297            if (typeof parseInputDate !== 'function') {
3298                throw new TypeError('parseInputDate() sholud be as function');
3299            }
3300
3301            options.parseInputDate = parseInputDate;
3302
3303            return picker;
3304        };
3305
3306        picker.disabledTimeIntervals = function (disabledTimeIntervals) {
3307            ///<signature helpKeyword="$.fn.datetimepicker.disabledTimeIntervals">
3308            ///<summary>Returns an array with the currently set disabled dates on the component.</summary>
3309            ///<returns type="array">options.disabledTimeIntervals</returns>
3310            ///</signature>
3311            ///<signature>
3312            ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
3313            ///options.enabledDates if such exist.</summary>
3314            ///<param name="dates" locid="$.fn.datetimepicker.disabledTimeIntervals_p:dates">Takes an [ string or Date or moment ] of values and allows the user to select only from those days.</param>
3315            ///</signature>
3316            if (arguments.length === 0) {
3317                return (options.disabledTimeIntervals ? $.extend({}, options.disabledTimeIntervals) : options.disabledTimeIntervals);
3318            }
3319
3320            if (!disabledTimeIntervals) {
3321                options.disabledTimeIntervals = false;
3322                update();
3323                return picker;
3324            }
3325            if (!(disabledTimeIntervals instanceof Array)) {
3326                throw new TypeError('disabledTimeIntervals() expects an array parameter');
3327            }
3328            options.disabledTimeIntervals = disabledTimeIntervals;
3329            update();
3330            return picker;
3331        };
3332
3333        picker.disabledHours = function (hours) {
3334            ///<signature helpKeyword="$.fn.datetimepicker.disabledHours">
3335            ///<summary>Returns an array with the currently set disabled hours on the component.</summary>
3336            ///<returns type="array">options.disabledHours</returns>
3337            ///</signature>
3338            ///<signature>
3339            ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of
3340            ///options.enabledHours if such exist.</summary>
3341            ///<param name="hours" locid="$.fn.datetimepicker.disabledHours_p:hours">Takes an [ int ] of values and disallows the user to select only from those hours.</param>
3342            ///</signature>
3343            if (arguments.length === 0) {
3344                return (options.disabledHours ? $.extend({}, options.disabledHours) : options.disabledHours);
3345            }
3346
3347            if (!hours) {
3348                options.disabledHours = false;
3349                update();
3350                return picker;
3351            }
3352            if (!(hours instanceof Array)) {
3353                throw new TypeError('disabledHours() expects an array parameter');
3354            }
3355            options.disabledHours = indexGivenHours(hours);
3356            options.enabledHours = false;
3357            if (options.useCurrent && !options.keepInvalid) {
3358                var tries = 0;
3359                while (!isValid(date, 'h')) {
3360                    date.add(1, 'h');
3361                    if (tries === 24) {
3362                        throw 'Tried 24 times to find a valid date';
3363                    }
3364                    tries++;
3365                }
3366                setValue(date);
3367            }
3368            update();
3369            return picker;
3370        };
3371
3372        picker.enabledHours = function (hours) {
3373            ///<signature helpKeyword="$.fn.datetimepicker.enabledHours">
3374            ///<summary>Returns an array with the currently set enabled hours on the component.</summary>
3375            ///<returns type="array">options.enabledHours</returns>
3376            ///</signature>
3377            ///<signature>
3378            ///<summary>Setting this takes precedence over options.minDate, options.maxDate configuration. Also calling this function removes the configuration of options.disabledHours if such exist.</summary>
3379            ///<param name="hours" locid="$.fn.datetimepicker.enabledHours_p:hours">Takes an [ int ] of values and allows the user to select only from those hours.</param>
3380            ///</signature>
3381            if (arguments.length === 0) {
3382                return (options.enabledHours ? $.extend({}, options.enabledHours) : options.enabledHours);
3383            }
3384
3385            if (!hours) {
3386                options.enabledHours = false;
3387                update();
3388                return picker;
3389            }
3390            if (!(hours instanceof Array)) {
3391                throw new TypeError('enabledHours() expects an array parameter');
3392            }
3393            options.enabledHours = indexGivenHours(hours);
3394            options.disabledHours = false;
3395            if (options.useCurrent && !options.keepInvalid) {
3396                var tries = 0;
3397                while (!isValid(date, 'h')) {
3398                    date.add(1, 'h');
3399                    if (tries === 24) {
3400                        throw 'Tried 24 times to find a valid date';
3401                    }
3402                    tries++;
3403                }
3404                setValue(date);
3405            }
3406            update();
3407            return picker;
3408        };
3409        /**
3410         * Returns the component's model current viewDate, a moment object or null if not set. Passing a null value unsets the components model current moment. Parsing of the newDate parameter is made using moment library with the options.format and options.useStrict components configuration.
3411         * @param {Takes string, viewDate, moment, null parameter.} newDate
3412         * @returns {viewDate.clone()}
3413         */
3414        picker.viewDate = function (newDate) {
3415            if (arguments.length === 0) {
3416                return viewDate.clone();
3417            }
3418
3419            if (!newDate) {
3420                viewDate = date.clone();
3421                return picker;
3422            }
3423
3424            if (typeof newDate !== 'string' && !moment.isMoment(newDate) && !(newDate instanceof Date)) {
3425                throw new TypeError('viewDate() parameter must be one of [string, moment or Date]');
3426            }
3427
3428            viewDate = parseInputDate(newDate);
3429            viewUpdate();
3430            return picker;
3431        };
3432
3433        // initializing element and component attributes
3434        if (element.is('input')) {
3435            input = element;
3436        } else {
3437            input = element.find(options.datepickerInput);
3438            if (input.length === 0) {
3439                input = element.find('input');
3440            } else if (!input.is('input')) {
3441                throw new Error('CSS class "' + options.datepickerInput + '" cannot be applied to non input element');
3442            }
3443        }
3444
3445        if (element.hasClass('input-group')) {
3446            // in case there is more then one 'input-group-addon' Issue #48
3447            if (element.find('.datepickerbutton').length === 0) {
3448                component = element.find('.input-group-addon');
3449            } else {
3450                component = element.find('.datepickerbutton');
3451            }
3452        }
3453
3454        if (!options.inline && !input.is('input')) {
3455            throw new Error('Could not initialize DateTimePicker without an input element');
3456        }
3457
3458        // Set defaults for date here now instead of in var declaration
3459        date = getMoment();
3460        viewDate = date.clone();
3461
3462        $.extend(true, options, dataToOptions());
3463
3464        picker.options(options);
3465
3466        initFormatting();
3467
3468        attachDatePickerElementEvents();
3469
3470        if (input.prop('disabled')) {
3471            picker.disable();
3472        }
3473        if (input.is('input') && input.val().trim().length !== 0) {
3474            setValue(parseInputDate(input.val().trim()));
3475        }
3476        else if (options.defaultDate && input.attr('placeholder') === undefined) {
3477            setValue(options.defaultDate);
3478        }
3479        if (options.inline) {
3480            show();
3481        }
3482        return picker;
3483    };
3484
3485    /********************************************************************************
3486     *
3487     * jQuery plugin constructor and defaults object
3488     *
3489     ********************************************************************************/
3490
3491    /**
3492    * See (http://jquery.com/).
3493    * @name jQuery
3494    * @class
3495    * See the jQuery Library  (http://jquery.com/) for full details.  This just
3496    * documents the function and classes that are added to jQuery by this plug-in.
3497    */
3498    /**
3499     * See (http://jquery.com/)
3500     * @name fn
3501     * @class
3502     * See the jQuery Library  (http://jquery.com/) for full details.  This just
3503     * documents the function and classes that are added to jQuery by this plug-in.
3504     * @memberOf jQuery
3505     */
3506    /**
3507     * Show comments
3508     * @class datetimepicker
3509     * @memberOf jQuery.fn
3510     */
3511    $.fn.datetimepicker = function (options) {
3512        options = options || {};
3513
3514        var args = Array.prototype.slice.call(arguments, 1),
3515            isInstance = true,
3516            thisMethods = ['destroy', 'hide', 'show', 'toggle'],
3517            returnValue;
3518
3519        if (typeof options === 'object') {
3520            return this.each(function () {
3521                var $this = $(this),
3522                    _options;
3523                if (!$this.data('DateTimePicker')) {
3524                    // create a private copy of the defaults object
3525                    _options = $.extend(true, {}, $.fn.datetimepicker.defaults, options);
3526                    $this.data('DateTimePicker', dateTimePicker($this, _options));
3527                }
3528            });
3529        } else if (typeof options === 'string') {
3530            this.each(function () {
3531                var $this = $(this),
3532                    instance = $this.data('DateTimePicker');
3533                if (!instance) {
3534                    throw new Error('bootstrap-datetimepicker("' + options + '") method was called on an element that is not using DateTimePicker');
3535                }
3536
3537                returnValue = instance[options].apply(instance, args);
3538                isInstance = returnValue === instance;
3539            });
3540
3541            if (isInstance || $.inArray(options, thisMethods) > -1) {
3542                return this;
3543            }
3544
3545            return returnValue;
3546        }
3547
3548        throw new TypeError('Invalid arguments for DateTimePicker: ' + options);
3549    };
3550
3551    $.fn.datetimepicker.defaults = {
3552        timeZone: '',
3553        format: false,
3554        dayViewHeaderFormat: 'MMMM YYYY',
3555        extraFormats: false,
3556        stepping: 1,
3557        minDate: false,
3558        maxDate: false,
3559        useCurrent: true,
3560        collapse: true,
3561        locale: moment.locale(),
3562        defaultDate: false,
3563        disabledDates: false,
3564        enabledDates: false,
3565        icons: {
3566            time: 'glyphicon glyphicon-time',
3567            date: 'glyphicon glyphicon-calendar',
3568            up: 'glyphicon glyphicon-chevron-up',
3569            down: 'glyphicon glyphicon-chevron-down',
3570            previous: 'glyphicon glyphicon-chevron-left',
3571            next: 'glyphicon glyphicon-chevron-right',
3572            today: 'glyphicon glyphicon-screenshot',
3573            clear: 'glyphicon glyphicon-trash',
3574            close: 'glyphicon glyphicon-remove'
3575        },
3576        tooltips: {
3577            today: 'Go to today',
3578            clear: 'Clear selection',
3579            close: 'Close the picker',
3580            selectMonth: 'Select Month',
3581            prevMonth: 'Previous Month',
3582            nextMonth: 'Next Month',
3583            selectYear: 'Select Year',
3584            prevYear: 'Previous Year',
3585            nextYear: 'Next Year',
3586            selectDecade: 'Select Decade',
3587            prevDecade: 'Previous Decade',
3588            nextDecade: 'Next Decade',
3589            prevCentury: 'Previous Century',
3590            nextCentury: 'Next Century',
3591            pickHour: 'Pick Hour',
3592            incrementHour: 'Increment Hour',
3593            decrementHour: 'Decrement Hour',
3594            pickMinute: 'Pick Minute',
3595            incrementMinute: 'Increment Minute',
3596            decrementMinute: 'Decrement Minute',
3597            pickSecond: 'Pick Second',
3598            incrementSecond: 'Increment Second',
3599            decrementSecond: 'Decrement Second',
3600            togglePeriod: 'Toggle Period',
3601            selectTime: 'Select Time'
3602        },
3603        useStrict: false,
3604        sideBySide: false,
3605        daysOfWeekDisabled: false,
3606        calendarWeeks: false,
3607        viewMode: 'days',
3608        toolbarPlacement: 'default',
3609        showTodayButton: false,
3610        showClear: false,
3611        showClose: false,
3612        widgetPositioning: {
3613            horizontal: 'auto',
3614            vertical: 'auto'
3615        },
3616        widgetParent: null,
3617        ignoreReadonly: false,
3618        keepOpen: false,
3619        focusOnShow: true,
3620        inline: false,
3621        keepInvalid: false,
3622        datepickerInput: '.datepickerinput',
3623        keyBinds: {
3624            up: function (widget) {
3625                if (!widget) {
3626                    return;
3627                }
3628                var d = this.date() || this.getMoment();
3629                if (widget.find('.datepicker').is(':visible')) {
3630                    this.date(d.clone().subtract(7, 'd'));
3631                } else {
3632                    this.date(d.clone().add(this.stepping(), 'm'));
3633                }
3634            },
3635            down: function (widget) {
3636                if (!widget) {
3637                    this.show();
3638                    return;
3639                }
3640                var d = this.date() || this.getMoment();
3641                if (widget.find('.datepicker').is(':visible')) {
3642                    this.date(d.clone().add(7, 'd'));
3643                } else {
3644                    this.date(d.clone().subtract(this.stepping(), 'm'));
3645                }
3646            },
3647            'control up': function (widget) {
3648                if (!widget) {
3649                    return;
3650                }
3651                var d = this.date() || this.getMoment();
3652                if (widget.find('.datepicker').is(':visible')) {
3653                    this.date(d.clone().subtract(1, 'y'));
3654                } else {
3655                    this.date(d.clone().add(1, 'h'));
3656                }
3657            },
3658            'control down': function (widget) {
3659                if (!widget) {
3660                    return;
3661                }
3662                var d = this.date() || this.getMoment();
3663                if (widget.find('.datepicker').is(':visible')) {
3664                    this.date(d.clone().add(1, 'y'));
3665                } else {
3666                    this.date(d.clone().subtract(1, 'h'));
3667                }
3668            },
3669            left: function (widget) {
3670                if (!widget) {
3671                    return;
3672                }
3673                var d = this.date() || this.getMoment();
3674                if (widget.find('.datepicker').is(':visible')) {
3675                    this.date(d.clone().subtract(1, 'd'));
3676                }
3677            },
3678            right: function (widget) {
3679                if (!widget) {
3680                    return;
3681                }
3682                var d = this.date() || this.getMoment();
3683                if (widget.find('.datepicker').is(':visible')) {
3684                    this.date(d.clone().add(1, 'd'));
3685                }
3686            },
3687            pageUp: function (widget) {
3688                if (!widget) {
3689                    return;
3690                }
3691                var d = this.date() || this.getMoment();
3692                if (widget.find('.datepicker').is(':visible')) {
3693                    this.date(d.clone().subtract(1, 'M'));
3694                }
3695            },
3696            pageDown: function (widget) {
3697                if (!widget) {
3698                    return;
3699                }
3700                var d = this.date() || this.getMoment();
3701                if (widget.find('.datepicker').is(':visible')) {
3702                    this.date(d.clone().add(1, 'M'));
3703                }
3704            },
3705            enter: function () {
3706                this.hide();
3707            },
3708            escape: function () {
3709                this.hide();
3710            },
3711            //tab: function (widget) { //this break the flow of the form. disabling for now
3712            //    var toggle = widget.find('.picker-switch a[data-action="togglePicker"]');
3713            //    if(toggle.length > 0) toggle.click();
3714            //},
3715            'control space': function (widget) {
3716                if (!widget) {
3717                    return;
3718                }
3719                if (widget.find('.timepicker').is(':visible')) {
3720                    widget.find('.btn[data-action="togglePeriod"]').click();
3721                }
3722            },
3723            t: function () {
3724                this.date(this.getMoment());
3725            },
3726            'delete': function () {
3727                this.clear();
3728            }
3729        },
3730        debug: false,
3731        allowInputToggle: false,
3732        disabledTimeIntervals: false,
3733        disabledHours: false,
3734        enabledHours: false,
3735        viewDate: false
3736    };
3737
3738    return $.fn.datetimepicker;
3739}));
3740
3741
3742/***/ }),
3743