@taiga-ui/cdk 2.26.0 → 2.27.0

package/bundles/taiga-ui-cdk-date-time.umd.js

@@ -288,6 +288,54 @@
             this.year = year;
             classes.tuiAssert.assert(TuiYear.isValidYear(year));
         }
+        /**
+         * Checks year for validity
+         */
+        TuiYear.isValidYear = function (year) {
+            return Number.isInteger(year) && math.inRange(year, MIN_YEAR, MAX_YEAR + 1);
+        };
+        /**
+         * Check if passed year is a leap year
+         */
+        TuiYear.isLeapYear = function (year) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+        };
+        /**
+         * Returns amount of leap years from year 0 to the passed one
+         */
+        TuiYear.getAbsoluteLeapYears = function (year) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
+        };
+        /**
+         * @deprecated DONT USE IT (will be deleted soon)
+         *
+         * Returns day of week offset of the beginning of the passed year
+         *
+         * @param year
+         * @param absoluteLeapYears amount of leap years prior to the passed one
+         * @return offset in days
+         */
+        TuiYear.getYearStartDaysOffset = function (year, absoluteLeapYears) {
+            classes.tuiAssert.assert(TuiYear.isValidYear(year));
+            classes.tuiAssert.assert(Number.isInteger(absoluteLeapYears));
+            classes.tuiAssert.assert(year >= absoluteLeapYears);
+            classes.tuiAssert.assert(absoluteLeapYears >= 0);
+            return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
+                (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
+                5) %
+                DAYS_IN_WEEK);
+        };
+        TuiYear.lengthBetween = function (from, to) {
+            return to.year - from.year;
+        };
+        /**
+         * Normalizes year by clamping it between min and max years
+         */
+        TuiYear.normalizeYearPart = function (year) {
+            return math.normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
+        };
         Object.defineProperty(TuiYear.prototype, "formattedYear", {
             get: function () {
                 return format.padStart(this.year.toString(), 4, '0');
@@ -380,54 +428,6 @@
         TuiYear.prototype.toJSON = function () {
             return this.formattedYear;
         };
-        /**
-         * Checks year for validity
-         */
-        TuiYear.isValidYear = function (year) {
-            return Number.isInteger(year) && math.inRange(year, MIN_YEAR, MAX_YEAR + 1);
-        };
-        /**
-         * Check if passed year is a leap year
-         */
-        TuiYear.isLeapYear = function (year) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
-        };
-        /**
-         * Returns amount of leap years from year 0 to the passed one
-         */
-        TuiYear.getAbsoluteLeapYears = function (year) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            return Math.ceil(year / 400) + (Math.ceil(year / 4) - Math.ceil(year / 100));
-        };
-        /**
-         * @deprecated DONT USE IT (will be deleted soon)
-         *
-         * Returns day of week offset of the beginning of the passed year
-         *
-         * @param year
-         * @param absoluteLeapYears amount of leap years prior to the passed one
-         * @return offset in days
-         */
-        TuiYear.getYearStartDaysOffset = function (year, absoluteLeapYears) {
-            classes.tuiAssert.assert(TuiYear.isValidYear(year));
-            classes.tuiAssert.assert(Number.isInteger(absoluteLeapYears));
-            classes.tuiAssert.assert(year >= absoluteLeapYears);
-            classes.tuiAssert.assert(absoluteLeapYears >= 0);
-            return ((absoluteLeapYears * DAYS_IN_LEAP_YEAR +
-                (year - absoluteLeapYears) * DAYS_IN_NORMAL_YEAR +
-                5) %
-                DAYS_IN_WEEK);
-        };
-        TuiYear.lengthBetween = function (from, to) {
-            return to.year - from.year;
-        };
-        /**
-         * Normalizes year by clamping it between min and max years
-         */
-        TuiYear.normalizeYearPart = function (year) {
-            return math.normalizeToIntNumber(year, MIN_YEAR, MAX_YEAR);
-        };
         return TuiYear;
     }());
 
@@ -446,6 +446,61 @@
             classes.tuiAssert.assert(TuiMonth.isValidMonth(year, month));
             return _this;
         }
+        /**
+         * Tests month and year for validity
+         */
+        TuiMonth.isValidMonth = function (year, month) {
+            return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
+        };
+        /**
+         * Returns number of days in a month
+         */
+        TuiMonth.getMonthDaysCount = function (month, isLeapYear) {
+            classes.tuiAssert.assert(TuiMonth.isValidMonthPart(month));
+            switch (month) {
+                case 1 /* February */:
+                    return isLeapYear ? 29 : 28;
+                case 3 /* April */:
+                case 5 /* June */:
+                case 8 /* September */:
+                case 10 /* November */:
+                    return 30;
+                default:
+                    return 31;
+            }
+        };
+        /**
+         * Returns current month and year based on local time zone
+         * @nosideeffects
+         */
+        TuiMonth.currentLocal = function () {
+            var nativeDate = new Date();
+            return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
+        };
+        /**
+         * Returns current month and year based on UTC
+         */
+        TuiMonth.currentUtc = function () {
+            var nativeDate = new Date();
+            return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
+        };
+        TuiMonth.lengthBetween = function (from, to) {
+            var absoluteFrom = from.month + from.year * 12;
+            var absoluteTo = to.month + to.year * 12;
+            return absoluteTo - absoluteFrom;
+        };
+        /**
+         * Normalizes number by clamping it between min and max month
+         */
+        TuiMonth.normalizeMonthPart = function (month) {
+            return math.normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
+        };
+        /**
+         * Tests month for validity
+         */
+        TuiMonth.isValidMonthPart = function (month) {
+            return Number.isInteger(month) && math.inRange(month, MIN_MONTH, MAX_MONTH + 1);
+        };
         Object.defineProperty(TuiMonth.prototype, "formattedMonthPart", {
             get: function () {
                 return format.padStart((this.month + 1).toString(), 2, '0');
@@ -571,61 +626,6 @@
         TuiMonth.prototype.toUtcNativeDate = function () {
             return new Date(Date.UTC(this.year, this.month));
         };
-        /**
-         * Tests month and year for validity
-         */
-        TuiMonth.isValidMonth = function (year, month) {
-            return TuiYear.isValidYear(year) && TuiMonth.isValidMonthPart(month);
-        };
-        /**
-         * Returns number of days in a month
-         */
-        TuiMonth.getMonthDaysCount = function (month, isLeapYear) {
-            classes.tuiAssert.assert(TuiMonth.isValidMonthPart(month));
-            switch (month) {
-                case 1 /* February */:
-                    return isLeapYear ? 29 : 28;
-                case 3 /* April */:
-                case 5 /* June */:
-                case 8 /* September */:
-                case 10 /* November */:
-                    return 30;
-                default:
-                    return 31;
-            }
-        };
-        /**
-         * Returns current month and year based on local time zone
-         * @nosideeffects
-         */
-        TuiMonth.currentLocal = function () {
-            var nativeDate = new Date();
-            return new TuiMonth(nativeDate.getFullYear(), nativeDate.getMonth());
-        };
-        /**
-         * Returns current month and year based on UTC
-         */
-        TuiMonth.currentUtc = function () {
-            var nativeDate = new Date();
-            return new TuiMonth(nativeDate.getUTCFullYear(), nativeDate.getUTCMonth());
-        };
-        TuiMonth.lengthBetween = function (from, to) {
-            var absoluteFrom = from.month + from.year * 12;
-            var absoluteTo = to.month + to.year * 12;
-            return absoluteTo - absoluteFrom;
-        };
-        /**
-         * Normalizes number by clamping it between min and max month
-         */
-        TuiMonth.normalizeMonthPart = function (month) {
-            return math.normalizeToIntNumber(month, MIN_MONTH, MAX_MONTH);
-        };
-        /**
-         * Tests month for validity
-         */
-        TuiMonth.isValidMonthPart = function (month) {
-            return Number.isInteger(month) && math.inRange(month, MIN_MONTH, MAX_MONTH + 1);
-        };
         return TuiMonth;
     }(TuiYear));
 
@@ -641,169 +641,17 @@
             classes.tuiAssert.assert(TuiDay.isValidDay(year, month, day));
             return _this;
         }
-        Object.defineProperty(TuiDay.prototype, "formattedDayPart", {
-            get: function () {
-                return format.padStart(this.day.toString(), 2, '0');
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(TuiDay.prototype, "formattedDay", {
-            /**
-             * Formatted whole date
-             */
-            get: function () {
-                return this.formattedDayPart + "." + this.formattedMonth;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.defineProperty(TuiDay.prototype, "isWeekend", {
-            get: function () {
-                var dayOfWeek = this.dayOfWeek(false);
-                return dayOfWeek === 6 /* Saturday */ || dayOfWeek === 0 /* Sunday */;
-            },
-            enumerable: true,
-            configurable: true
-        });
         /**
-         * Returns day of week
-         *
-         * @param startFromMonday whether week starts from Monday and not from Sunday
-         * @return day of week (from 0 to 6)
+         * Creates {@link TuiDay} from native {@link Date} based on local time zone
          */
-        TuiDay.prototype.dayOfWeek = function (startFromMonday) {
-            if (startFromMonday === void 0) { startFromMonday = true; }
-            var dayOfWeek = startFromMonday
-                ? this.toLocalNativeDate().getDay() - 1
-                : this.toLocalNativeDate().getDay();
-            return dayOfWeek < 0 ? 6 : dayOfWeek;
+        TuiDay.fromLocalNativeDate = function (date) {
+            return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
         };
         /**
-         * Passed date is after current
+         * Creates {@link TuiDay} from native {@link Date} using UTC
          */
-        TuiDay.prototype.dayBefore = function (another) {
-            return (this.monthBefore(another) ||
-                (this.monthSame(another) && this.day < another.day));
-        };
-        /**
-         * Passed date is after or equals to current
-         */
-        TuiDay.prototype.daySameOrBefore = function (another) {
-            return (this.monthBefore(another) ||
-                (this.monthSame(another) && this.day <= another.day));
-        };
-        /**
-         * Passed date is the same as current
-         */
-        TuiDay.prototype.daySame = function (another) {
-            return this.monthSame(another) && this.day === another.day;
-        };
-        /**
-         * Passed date is either before or the same as current
-         */
-        TuiDay.prototype.daySameOrAfter = function (another) {
-            return (this.monthAfter(another) ||
-                (this.monthSame(another) && this.day >= another.day));
-        };
-        /**
-         * Passed date is before current
-         */
-        TuiDay.prototype.dayAfter = function (another) {
-            return (this.monthAfter(another) ||
-                (this.monthSame(another) && this.day > another.day));
-        };
-        /**
-         * Clamping date between two limits
-         *
-         * @param min
-         * @param max
-         * @return clamped date
-         */
-        TuiDay.prototype.dayLimit = function (min, max) {
-            if (min !== null && this.dayBefore(min)) {
-                return min;
-            }
-            if (max !== null && this.dayAfter(max)) {
-                return max;
-            }
-            return this;
-        };
-        // TODO: Consider removing `backwards` option
-        /**
-         * Immutably alters current day by passed offset
-         *
-         * If resulting month has more days than original one, date is rounded to the maximum day
-         * in the resulting month. Offset of days will be calculated based on the resulted year and month
-         * to not interfere with parent classes methods
-         *
-         * @param offset
-         * @param backwards shift date backwards
-         * @return new date object as a result of offsetting current
-         */
-        TuiDay.prototype.append = function (_a, backwards) {
-            var _b = _a.year, year = _b === void 0 ? 0 : _b, _c = _a.month, month = _c === void 0 ? 0 : _c, _d = _a.day, day = _d === void 0 ? 0 : _d;
-            if (backwards === void 0) { backwards = false; }
-            if (backwards) {
-                year *= -1;
-                month *= -1;
-                day *= -1;
-            }
-            var totalMonths = (this.year + year) * MONTHS_IN_YEAR + this.month + month;
-            var years = Math.floor(totalMonths / MONTHS_IN_YEAR);
-            var months = totalMonths % MONTHS_IN_YEAR;
-            var days = Math.min(this.day, TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years))) + day;
-            while (days > TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years))) {
-                days -= TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years));
-                if (months === 11 /* December */) {
-                    years++;
-                    months = 0 /* January */;
-                }
-                else {
-                    months++;
-                }
-            }
-            while (days < MIN_DAY) {
-                if (months === 0 /* January */) {
-                    years--;
-                    months = 11 /* December */;
-                }
-                else {
-                    months--;
-                }
-                days += TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years));
-            }
-            return new TuiDay(years, months, days);
-        };
-        TuiDay.prototype.toString = function () {
-            return this.formattedDay;
-        };
-        TuiDay.prototype.toJSON = function () {
-            return _super.prototype.toJSON.call(this) + "-" + this.formattedDayPart;
-        };
-        /**
-         * Returns native {@link Date} based on local time zone
-         */
-        TuiDay.prototype.toLocalNativeDate = function () {
-            return new Date(this.year, this.month, this.day);
-        };
-        /**
-         * Returns native {@link Date} based on UTC
-         */
-        TuiDay.prototype.toUtcNativeDate = function () {
-            return new Date(Date.UTC(this.year, this.month, this.day));
-        };
-        /**
-         * Creates {@link TuiDay} from native {@link Date} based on local time zone
-         */
-        TuiDay.fromLocalNativeDate = function (date) {
-            return new TuiDay(date.getFullYear(), date.getMonth(), date.getDate());
-        };
-        /**
-         * Creates {@link TuiDay} from native {@link Date} using UTC
-         */
-        TuiDay.fromUtcNativeDate = function (date) {
-            return new TuiDay(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+        TuiDay.fromUtcNativeDate = function (date) {
+            return new TuiDay(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
         };
         /**
          * Check validity of year, month and day
@@ -912,6 +760,158 @@
             var monthDaysCount = TuiMonth.getMonthDaysCount(month, TuiYear.isLeapYear(year));
             return math.normalizeToIntNumber(day, 1, monthDaysCount);
         };
+        Object.defineProperty(TuiDay.prototype, "formattedDayPart", {
+            get: function () {
+                return format.padStart(this.day.toString(), 2, '0');
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TuiDay.prototype, "formattedDay", {
+            /**
+             * Formatted whole date
+             */
+            get: function () {
+                return this.formattedDayPart + "." + this.formattedMonth;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TuiDay.prototype, "isWeekend", {
+            get: function () {
+                var dayOfWeek = this.dayOfWeek(false);
+                return dayOfWeek === 6 /* Saturday */ || dayOfWeek === 0 /* Sunday */;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * Returns day of week
+         *
+         * @param startFromMonday whether week starts from Monday and not from Sunday
+         * @return day of week (from 0 to 6)
+         */
+        TuiDay.prototype.dayOfWeek = function (startFromMonday) {
+            if (startFromMonday === void 0) { startFromMonday = true; }
+            var dayOfWeek = startFromMonday
+                ? this.toLocalNativeDate().getDay() - 1
+                : this.toLocalNativeDate().getDay();
+            return dayOfWeek < 0 ? 6 : dayOfWeek;
+        };
+        /**
+         * Passed date is after current
+         */
+        TuiDay.prototype.dayBefore = function (another) {
+            return (this.monthBefore(another) ||
+                (this.monthSame(another) && this.day < another.day));
+        };
+        /**
+         * Passed date is after or equals to current
+         */
+        TuiDay.prototype.daySameOrBefore = function (another) {
+            return (this.monthBefore(another) ||
+                (this.monthSame(another) && this.day <= another.day));
+        };
+        /**
+         * Passed date is the same as current
+         */
+        TuiDay.prototype.daySame = function (another) {
+            return this.monthSame(another) && this.day === another.day;
+        };
+        /**
+         * Passed date is either before or the same as current
+         */
+        TuiDay.prototype.daySameOrAfter = function (another) {
+            return (this.monthAfter(another) ||
+                (this.monthSame(another) && this.day >= another.day));
+        };
+        /**
+         * Passed date is before current
+         */
+        TuiDay.prototype.dayAfter = function (another) {
+            return (this.monthAfter(another) ||
+                (this.monthSame(another) && this.day > another.day));
+        };
+        /**
+         * Clamping date between two limits
+         *
+         * @param min
+         * @param max
+         * @return clamped date
+         */
+        TuiDay.prototype.dayLimit = function (min, max) {
+            if (min !== null && this.dayBefore(min)) {
+                return min;
+            }
+            if (max !== null && this.dayAfter(max)) {
+                return max;
+            }
+            return this;
+        };
+        // TODO: Consider removing `backwards` option
+        /**
+         * Immutably alters current day by passed offset
+         *
+         * If resulting month has more days than original one, date is rounded to the maximum day
+         * in the resulting month. Offset of days will be calculated based on the resulted year and month
+         * to not interfere with parent classes methods
+         *
+         * @param offset
+         * @param backwards shift date backwards
+         * @return new date object as a result of offsetting current
+         */
+        TuiDay.prototype.append = function (_a, backwards) {
+            var _b = _a.year, year = _b === void 0 ? 0 : _b, _c = _a.month, month = _c === void 0 ? 0 : _c, _d = _a.day, day = _d === void 0 ? 0 : _d;
+            if (backwards === void 0) { backwards = false; }
+            if (backwards) {
+                year *= -1;
+                month *= -1;
+                day *= -1;
+            }
+            var totalMonths = (this.year + year) * MONTHS_IN_YEAR + this.month + month;
+            var years = Math.floor(totalMonths / MONTHS_IN_YEAR);
+            var months = totalMonths % MONTHS_IN_YEAR;
+            var days = Math.min(this.day, TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years))) + day;
+            while (days > TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years))) {
+                days -= TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years));
+                if (months === 11 /* December */) {
+                    years++;
+                    months = 0 /* January */;
+                }
+                else {
+                    months++;
+                }
+            }
+            while (days < MIN_DAY) {
+                if (months === 0 /* January */) {
+                    years--;
+                    months = 11 /* December */;
+                }
+                else {
+                    months--;
+                }
+                days += TuiMonth.getMonthDaysCount(months, TuiYear.isLeapYear(years));
+            }
+            return new TuiDay(years, months, days);
+        };
+        TuiDay.prototype.toString = function () {
+            return this.formattedDay;
+        };
+        TuiDay.prototype.toJSON = function () {
+            return _super.prototype.toJSON.call(this) + "-" + this.formattedDayPart;
+        };
+        /**
+         * Returns native {@link Date} based on local time zone
+         */
+        TuiDay.prototype.toLocalNativeDate = function () {
+            return new Date(this.year, this.month, this.day);
+        };
+        /**
+         * Returns native {@link Date} based on UTC
+         */
+        TuiDay.prototype.toUtcNativeDate = function () {
+            return new Date(Date.UTC(this.year, this.month, this.day));
+        };
         return TuiDay;
     }(TuiMonth));
 
@@ -924,6 +924,11 @@
             this.to = to;
             classes.tuiAssert.assert(from.monthSameOrBefore(to));
         }
+        TuiMonthRange.sort = function (month1, month2) {
+            return month1.monthSameOrBefore(month2)
+                ? new TuiMonthRange(month1, month2)
+                : new TuiMonthRange(month2, month1);
+        };
         Object.defineProperty(TuiMonthRange.prototype, "isSingleMonth", {
             get: function () {
                 return this.from.monthSame(this.to);
@@ -944,11 +949,6 @@
         TuiMonthRange.prototype.toString = function () {
             return "" + this.from + RANGE_SEPARATOR_CHAR + this.to;
         };
-        TuiMonthRange.sort = function (month1, month2) {
-            return month1.monthSameOrBefore(month2)
-                ? new TuiMonthRange(month1, month2)
-                : new TuiMonthRange(month2, month1);
-        };
         return TuiMonthRange;
     }());
 
@@ -964,6 +964,31 @@
             classes.tuiAssert.assert(from.daySameOrBefore(to));
             return _this;
         }
+        /**
+         * Creates range from two days after sorting them
+         *
+         * @param day1
+         * @param day2
+         * @return new range with sorted days
+         */
+        TuiDayRange.sort = function (day1, day2) {
+            return day1.daySameOrBefore(day2)
+                ? new TuiDayRange(day1, day2)
+                : new TuiDayRange(day2, day1);
+        };
+        /**
+         * Parse and correct a day range in string format
+         *
+         * @param rangeString a string of dates in a format dd.mm.yyyy - dd.mm.yyyy
+         * @return normalized day range object
+         */
+        TuiDayRange.normalizeParse = function (rangeString) {
+            var leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH));
+            if (rangeString.length < DATE_RANGE_FILLER_LENGTH) {
+                return new TuiDayRange(leftDay, leftDay);
+            }
+            return TuiDayRange.sort(leftDay, TuiDay.normalizeParse(rangeString.slice(DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length)));
+        };
         Object.defineProperty(TuiDayRange.prototype, "isSingleDay", {
             get: function () {
                 return this.from.daySame(this.to);
@@ -1000,31 +1025,6 @@
         TuiDayRange.prototype.dayLimit = function (min, max) {
             return new TuiDayRange(this.from.dayLimit(min, max), this.to.dayLimit(min, max));
         };
-        /**
-         * Creates range from two days after sorting them
-         *
-         * @param day1
-         * @param day2
-         * @return new range with sorted days
-         */
-        TuiDayRange.sort = function (day1, day2) {
-            return day1.daySameOrBefore(day2)
-                ? new TuiDayRange(day1, day2)
-                : new TuiDayRange(day2, day1);
-        };
-        /**
-         * Parse and correct a day range in string format
-         *
-         * @param rangeString a string of dates in a format dd.mm.yyyy - dd.mm.yyyy
-         * @return normalized day range object
-         */
-        TuiDayRange.normalizeParse = function (rangeString) {
-            var leftDay = TuiDay.normalizeParse(rangeString.slice(0, DATE_FILLER_LENGTH));
-            if (rangeString.length < DATE_RANGE_FILLER_LENGTH) {
-                return new TuiDayRange(leftDay, leftDay);
-            }
-            return TuiDayRange.sort(leftDay, TuiDay.normalizeParse(rangeString.slice(DATE_FILLER_LENGTH + RANGE_SEPARATOR_CHAR.length)));
-        };
         return TuiDayRange;
     }(TuiMonthRange));
 
@@ -1044,46 +1044,6 @@
             this.ms = ms;
             classes.tuiAssert.assert(TuiTime.isValidTime(hours, minutes, seconds, ms), 'Time must be real, but got:', hours, minutes, seconds, ms);
         }
-        /**
-         * Shifts time by hours and minutes
-         */
-        TuiTime.prototype.shift = function (_a) {
-            var _b = _a.hours, hours = _b === void 0 ? 0 : _b, _c = _a.minutes, minutes = _c === void 0 ? 0 : _c, _d = _a.seconds, seconds = _d === void 0 ? 0 : _d, _e = _a.ms, ms = _e === void 0 ? 0 : _e;
-            var newMs = (1000 + this.ms + (ms % 1000)) % 1000;
-            var secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
-            var secondsToAdd = secondsInMs + seconds;
-            var newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
-            var minutesInSeconds = secondsToAdd < 0
-                ? Math.ceil(secondsToAdd / 60)
-                : Math.floor(secondsToAdd / 60);
-            var minutesToAdd = minutesInSeconds + minutes;
-            var newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
-            var hoursInMinutes = minutesToAdd < 0
-                ? Math.ceil(minutesToAdd / 60)
-                : Math.floor(minutesToAdd / 60);
-            var hoursToAdd = hoursInMinutes + hours;
-            var newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
-            return new TuiTime(newHours, newMinutes, newSeconds, newMs);
-        };
-        /**
-         * Converts TuiTime to string
-         */
-        TuiTime.prototype.toString = function (mode) {
-            var needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
-            var needAddSeconds = needAddMs || mode === 'HH:MM:SS' || (!mode && this.seconds > 0);
-            return (this.formatTime(this.hours) + ":" + this.formatTime(this.minutes) +
-                ("" + (needAddSeconds ? ':' + this.formatTime(this.seconds) : '')) +
-                ("" + (needAddMs ? '.' + this.formatTime(this.ms, 3) : '')));
-        };
-        /**
-         * Converts TuiTime to milliseconds
-         */
-        TuiTime.prototype.toAbsoluteMilliseconds = function () {
-            return (this.hours * MILLISECONDS_IN_HOUR +
-                this.minutes * MILLISECONDS_IN_MINUTE +
-                this.seconds * 1000 +
-                this.ms);
-        };
         /**
          * Checks if time is valid
          */
@@ -1142,6 +1102,46 @@
         TuiTime.fromLocalNativeDate = function (date) {
             return new TuiTime(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
         };
+        /**
+         * Shifts time by hours and minutes
+         */
+        TuiTime.prototype.shift = function (_a) {
+            var _b = _a.hours, hours = _b === void 0 ? 0 : _b, _c = _a.minutes, minutes = _c === void 0 ? 0 : _c, _d = _a.seconds, seconds = _d === void 0 ? 0 : _d, _e = _a.ms, ms = _e === void 0 ? 0 : _e;
+            var newMs = (1000 + this.ms + (ms % 1000)) % 1000;
+            var secondsInMs = ms < 0 ? Math.ceil(ms / 1000) : Math.floor(ms / 1000);
+            var secondsToAdd = secondsInMs + seconds;
+            var newSeconds = (60 + this.seconds + (secondsToAdd % 60)) % 60;
+            var minutesInSeconds = secondsToAdd < 0
+                ? Math.ceil(secondsToAdd / 60)
+                : Math.floor(secondsToAdd / 60);
+            var minutesToAdd = minutesInSeconds + minutes;
+            var newMinutes = (60 + this.minutes + (minutesToAdd % 60)) % 60;
+            var hoursInMinutes = minutesToAdd < 0
+                ? Math.ceil(minutesToAdd / 60)
+                : Math.floor(minutesToAdd / 60);
+            var hoursToAdd = hoursInMinutes + hours;
+            var newHours = (24 + this.hours + (hoursToAdd % 24)) % 24;
+            return new TuiTime(newHours, newMinutes, newSeconds, newMs);
+        };
+        /**
+         * Converts TuiTime to string
+         */
+        TuiTime.prototype.toString = function (mode) {
+            var needAddMs = mode === 'HH:MM:SS.MSS' || (!mode && this.ms > 0);
+            var needAddSeconds = needAddMs || mode === 'HH:MM:SS' || (!mode && this.seconds > 0);
+            return (this.formatTime(this.hours) + ":" + this.formatTime(this.minutes) +
+                ("" + (needAddSeconds ? ':' + this.formatTime(this.seconds) : '')) +
+                ("" + (needAddMs ? '.' + this.formatTime(this.ms, 3) : '')));
+        };
+        /**
+         * Converts TuiTime to milliseconds
+         */
+        TuiTime.prototype.toAbsoluteMilliseconds = function () {
+            return (this.hours * MILLISECONDS_IN_HOUR +
+                this.minutes * MILLISECONDS_IN_MINUTE +
+                this.seconds * 1000 +
+                this.ms);
+        };
         TuiTime.prototype.formatTime = function (time, digits) {
             if (digits === void 0) { digits = 2; }
             return format.padStart(time.toString(), digits, '0');